301 lines · c
1// SPDX-License-Identifier: GPL-2.02/*3 * Generic battery driver using IIO4 * Copyright (C) 2012, Anish Kumar <anish198519851985@gmail.com>5 * Copyright (c) 2023, Sebastian Reichel <sre@kernel.org>6 */7#include <linux/interrupt.h>8#include <linux/platform_device.h>9#include <linux/power_supply.h>10#include <linux/gpio/consumer.h>11#include <linux/err.h>12#include <linux/timer.h>13#include <linux/jiffies.h>14#include <linux/errno.h>15#include <linux/init.h>16#include <linux/module.h>17#include <linux/slab.h>18#include <linux/iio/consumer.h>19#include <linux/iio/types.h>20#include <linux/of.h>21#include <linux/devm-helpers.h>22 23#define JITTER_DEFAULT 10 /* hope 10ms is enough */24 25enum gab_chan_type {26 GAB_VOLTAGE = 0,27 GAB_CURRENT,28 GAB_POWER,29 GAB_TEMP,30 GAB_MAX_CHAN_TYPE31};32 33/*34 * gab_chan_name suggests the standard channel names for commonly used35 * channel types.36 */37static const char *const gab_chan_name[] = {38 [GAB_VOLTAGE] = "voltage",39 [GAB_CURRENT] = "current",40 [GAB_POWER] = "power",41 [GAB_TEMP] = "temperature",42};43 44struct gab {45 struct power_supply *psy;46 struct power_supply_desc psy_desc;47 struct iio_channel *channel[GAB_MAX_CHAN_TYPE];48 struct delayed_work bat_work;49 int status;50 struct gpio_desc *charge_finished;51};52 53static struct gab *to_generic_bat(struct power_supply *psy)54{55 return power_supply_get_drvdata(psy);56}57 58static void gab_ext_power_changed(struct power_supply *psy)59{60 struct gab *adc_bat = to_generic_bat(psy);61 62 schedule_delayed_work(&adc_bat->bat_work, msecs_to_jiffies(0));63}64 65static const enum power_supply_property gab_props[] = {66 POWER_SUPPLY_PROP_STATUS,67};68 69/*70 * This properties are set based on the received platform data and this71 * should correspond one-to-one with enum chan_type.72 */73static const enum power_supply_property gab_dyn_props[] = {74 POWER_SUPPLY_PROP_VOLTAGE_NOW,75 POWER_SUPPLY_PROP_CURRENT_NOW,76 POWER_SUPPLY_PROP_POWER_NOW,77 POWER_SUPPLY_PROP_TEMP,78};79 80static bool gab_charge_finished(struct gab *adc_bat)81{82 if (!adc_bat->charge_finished)83 return false;84 return gpiod_get_value(adc_bat->charge_finished);85}86 87static int gab_read_channel(struct gab *adc_bat, enum gab_chan_type channel,88 int *result)89{90 int ret;91 92 ret = iio_read_channel_processed(adc_bat->channel[channel], result);93 if (ret < 0)94 dev_err(&adc_bat->psy->dev, "read channel error: %d\n", ret);95 else96 *result *= 1000;97 98 return ret;99}100 101static int gab_get_property(struct power_supply *psy,102 enum power_supply_property psp, union power_supply_propval *val)103{104 struct gab *adc_bat = to_generic_bat(psy);105 106 switch (psp) {107 case POWER_SUPPLY_PROP_STATUS:108 val->intval = adc_bat->status;109 return 0;110 case POWER_SUPPLY_PROP_VOLTAGE_NOW:111 return gab_read_channel(adc_bat, GAB_VOLTAGE, &val->intval);112 case POWER_SUPPLY_PROP_CURRENT_NOW:113 return gab_read_channel(adc_bat, GAB_CURRENT, &val->intval);114 case POWER_SUPPLY_PROP_POWER_NOW:115 return gab_read_channel(adc_bat, GAB_POWER, &val->intval);116 case POWER_SUPPLY_PROP_TEMP:117 return gab_read_channel(adc_bat, GAB_TEMP, &val->intval);118 default:119 return -EINVAL;120 }121}122 123static void gab_work(struct work_struct *work)124{125 struct gab *adc_bat;126 struct delayed_work *delayed_work;127 int status;128 129 delayed_work = to_delayed_work(work);130 adc_bat = container_of(delayed_work, struct gab, bat_work);131 status = adc_bat->status;132 133 if (!power_supply_am_i_supplied(adc_bat->psy))134 adc_bat->status = POWER_SUPPLY_STATUS_DISCHARGING;135 else if (gab_charge_finished(adc_bat))136 adc_bat->status = POWER_SUPPLY_STATUS_NOT_CHARGING;137 else138 adc_bat->status = POWER_SUPPLY_STATUS_CHARGING;139 140 if (status != adc_bat->status)141 power_supply_changed(adc_bat->psy);142}143 144static irqreturn_t gab_charged(int irq, void *dev_id)145{146 struct gab *adc_bat = dev_id;147 148 schedule_delayed_work(&adc_bat->bat_work,149 msecs_to_jiffies(JITTER_DEFAULT));150 151 return IRQ_HANDLED;152}153 154static int gab_probe(struct platform_device *pdev)155{156 struct gab *adc_bat;157 struct power_supply_desc *psy_desc;158 struct power_supply_config psy_cfg = {};159 enum power_supply_property *properties;160 int ret = 0;161 int chan;162 int index = ARRAY_SIZE(gab_props);163 bool any = false;164 165 adc_bat = devm_kzalloc(&pdev->dev, sizeof(*adc_bat), GFP_KERNEL);166 if (!adc_bat)167 return -ENOMEM;168 169 psy_cfg.of_node = pdev->dev.of_node;170 psy_cfg.drv_data = adc_bat;171 psy_desc = &adc_bat->psy_desc;172 psy_desc->name = dev_name(&pdev->dev);173 174 /* bootup default values for the battery */175 adc_bat->status = POWER_SUPPLY_STATUS_DISCHARGING;176 psy_desc->type = POWER_SUPPLY_TYPE_BATTERY;177 psy_desc->get_property = gab_get_property;178 psy_desc->external_power_changed = gab_ext_power_changed;179 180 /*181 * copying the static properties and allocating extra memory for holding182 * the extra configurable properties received from platform data.183 */184 properties = devm_kcalloc(&pdev->dev,185 ARRAY_SIZE(gab_props) +186 ARRAY_SIZE(gab_chan_name),187 sizeof(*properties),188 GFP_KERNEL);189 if (!properties)190 return -ENOMEM;191 192 memcpy(properties, gab_props, sizeof(gab_props));193 194 /*195 * getting channel from iio and copying the battery properties196 * based on the channel supported by consumer device.197 */198 for (chan = 0; chan < ARRAY_SIZE(gab_chan_name); chan++) {199 adc_bat->channel[chan] = devm_iio_channel_get(&pdev->dev, gab_chan_name[chan]);200 if (IS_ERR(adc_bat->channel[chan])) {201 ret = PTR_ERR(adc_bat->channel[chan]);202 if (ret != -ENODEV)203 return dev_err_probe(&pdev->dev, ret, "Failed to get ADC channel %s\n", gab_chan_name[chan]);204 adc_bat->channel[chan] = NULL;205 } else if (adc_bat->channel[chan]) {206 /* copying properties for supported channels only */207 int index2;208 209 for (index2 = 0; index2 < index; index2++) {210 if (properties[index2] == gab_dyn_props[chan])211 break; /* already known */212 }213 if (index2 == index) /* really new */214 properties[index++] = gab_dyn_props[chan];215 any = true;216 }217 }218 219 /* none of the channels are supported so let's bail out */220 if (!any)221 return dev_err_probe(&pdev->dev, -ENODEV, "Failed to get any ADC channel\n");222 223 /*224 * Total number of properties is equal to static properties225 * plus the dynamic properties.Some properties may not be set226 * as come channels may be not be supported by the device.So227 * we need to take care of that.228 */229 psy_desc->properties = properties;230 psy_desc->num_properties = index;231 232 adc_bat->psy = devm_power_supply_register(&pdev->dev, psy_desc, &psy_cfg);233 if (IS_ERR(adc_bat->psy))234 return dev_err_probe(&pdev->dev, PTR_ERR(adc_bat->psy), "Failed to register power-supply device\n");235 236 ret = devm_delayed_work_autocancel(&pdev->dev, &adc_bat->bat_work, gab_work);237 if (ret)238 return dev_err_probe(&pdev->dev, ret, "Failed to register delayed work\n");239 240 adc_bat->charge_finished = devm_gpiod_get_optional(&pdev->dev, "charged", GPIOD_IN);241 if (adc_bat->charge_finished) {242 int irq;243 244 irq = gpiod_to_irq(adc_bat->charge_finished);245 ret = devm_request_any_context_irq(&pdev->dev, irq, gab_charged,246 IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,247 "battery charged", adc_bat);248 if (ret < 0)249 return dev_err_probe(&pdev->dev, ret, "Failed to register irq\n");250 }251 252 platform_set_drvdata(pdev, adc_bat);253 254 /* Schedule timer to check current status */255 schedule_delayed_work(&adc_bat->bat_work,256 msecs_to_jiffies(0));257 return 0;258}259 260static int __maybe_unused gab_suspend(struct device *dev)261{262 struct gab *adc_bat = dev_get_drvdata(dev);263 264 cancel_delayed_work_sync(&adc_bat->bat_work);265 adc_bat->status = POWER_SUPPLY_STATUS_UNKNOWN;266 return 0;267}268 269static int __maybe_unused gab_resume(struct device *dev)270{271 struct gab *adc_bat = dev_get_drvdata(dev);272 273 /* Schedule timer to check current status */274 schedule_delayed_work(&adc_bat->bat_work,275 msecs_to_jiffies(JITTER_DEFAULT));276 277 return 0;278}279 280static SIMPLE_DEV_PM_OPS(gab_pm_ops, gab_suspend, gab_resume);281 282static const struct of_device_id gab_match[] = {283 { .compatible = "adc-battery" },284 { }285};286MODULE_DEVICE_TABLE(of, gab_match);287 288static struct platform_driver gab_driver = {289 .driver = {290 .name = "generic-adc-battery",291 .pm = &gab_pm_ops,292 .of_match_table = gab_match,293 },294 .probe = gab_probe,295};296module_platform_driver(gab_driver);297 298MODULE_AUTHOR("anish kumar <anish198519851985@gmail.com>");299MODULE_DESCRIPTION("generic battery driver using IIO");300MODULE_LICENSE("GPL");301