1/* 2 * Generic battery driver code using IIO 3 * Copyright (C) 2012, Anish Kumar <anish198519851985@gmail.com> 4 * based on jz4740-battery.c 5 * based on s3c_adc_battery.c 6 * 7 * This file is subject to the terms and conditions of the GNU General Public 8 * License. See the file COPYING in the main directory of this archive for 9 * more details. 10 * 11 */ 12#include <linux/interrupt.h> 13#include <linux/platform_device.h> 14#include <linux/power_supply.h> 15#include <linux/gpio.h> 16#include <linux/err.h> 17#include <linux/timer.h> 18#include <linux/jiffies.h> 19#include <linux/errno.h> 20#include <linux/init.h> 21#include <linux/module.h> 22#include <linux/slab.h> 23#include <linux/iio/consumer.h> 24#include <linux/iio/types.h> 25#include <linux/power/generic-adc-battery.h> 26 27#define JITTER_DEFAULT 10 /* hope 10ms is enough */ 28 29enum gab_chan_type { 30 GAB_VOLTAGE = 0, 31 GAB_CURRENT, 32 GAB_POWER, 33 GAB_MAX_CHAN_TYPE 34}; 35 36/* 37 * gab_chan_name suggests the standard channel names for commonly used 38 * channel types. 39 */ 40static const char *const gab_chan_name[] = { 41 [GAB_VOLTAGE] = "voltage", 42 [GAB_CURRENT] = "current", 43 [GAB_POWER] = "power", 44}; 45 46struct gab { 47 struct power_supply psy; 48 struct iio_channel *channel[GAB_MAX_CHAN_TYPE]; 49 struct gab_platform_data *pdata; 50 struct delayed_work bat_work; 51 int level; 52 int status; 53 bool cable_plugged; 54}; 55 56static struct gab *to_generic_bat(struct power_supply *psy) 57{ 58 return container_of(psy, struct gab, psy); 59} 60 61static void gab_ext_power_changed(struct power_supply *psy) 62{ 63 struct gab *adc_bat = to_generic_bat(psy); 64 65 schedule_delayed_work(&adc_bat->bat_work, msecs_to_jiffies(0)); 66} 67 68static const enum power_supply_property gab_props[] = { 69 POWER_SUPPLY_PROP_STATUS, 70 POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN, 71 POWER_SUPPLY_PROP_CHARGE_EMPTY_DESIGN, 72 POWER_SUPPLY_PROP_CHARGE_NOW, 73 POWER_SUPPLY_PROP_VOLTAGE_NOW, 74 POWER_SUPPLY_PROP_CURRENT_NOW, 75 POWER_SUPPLY_PROP_TECHNOLOGY, 76 POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN, 77 POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN, 78 POWER_SUPPLY_PROP_MODEL_NAME, 79}; 80 81/* 82 * This properties are set based on the received platform data and this 83 * should correspond one-to-one with enum chan_type. 84 */ 85static const enum power_supply_property gab_dyn_props[] = { 86 POWER_SUPPLY_PROP_VOLTAGE_NOW, 87 POWER_SUPPLY_PROP_CURRENT_NOW, 88 POWER_SUPPLY_PROP_POWER_NOW, 89}; 90 91static bool gab_charge_finished(struct gab *adc_bat) 92{ 93 struct gab_platform_data *pdata = adc_bat->pdata; 94 bool ret = gpio_get_value(pdata->gpio_charge_finished); 95 bool inv = pdata->gpio_inverted; 96 97 if (!gpio_is_valid(pdata->gpio_charge_finished)) 98 return false; 99 return ret ^ inv; 100} 101 102static int gab_get_status(struct gab *adc_bat) 103{ 104 struct gab_platform_data *pdata = adc_bat->pdata; 105 struct power_supply_info *bat_info; 106 107 bat_info = &pdata->battery_info; 108 if (adc_bat->level == bat_info->charge_full_design) 109 return POWER_SUPPLY_STATUS_FULL; 110 return adc_bat->status; 111} 112 113static enum gab_chan_type gab_prop_to_chan(enum power_supply_property psp) 114{ 115 switch (psp) { 116 case POWER_SUPPLY_PROP_POWER_NOW: 117 return GAB_POWER; 118 case POWER_SUPPLY_PROP_VOLTAGE_NOW: 119 return GAB_VOLTAGE; 120 case POWER_SUPPLY_PROP_CURRENT_NOW: 121 return GAB_CURRENT; 122 default: 123 WARN_ON(1); 124 break; 125 } 126 return GAB_POWER; 127} 128 129static int read_channel(struct gab *adc_bat, enum power_supply_property psp, 130 int *result) 131{ 132 int ret; 133 int chan_index; 134 135 chan_index = gab_prop_to_chan(psp); 136 ret = iio_read_channel_processed(adc_bat->channel[chan_index], 137 result); 138 if (ret < 0) 139 pr_err("read channel error\n"); 140 return ret; 141} 142 143static int gab_get_property(struct power_supply *psy, 144 enum power_supply_property psp, union power_supply_propval *val) 145{ 146 struct gab *adc_bat; 147 struct gab_platform_data *pdata; 148 struct power_supply_info *bat_info; 149 int result = 0; 150 int ret = 0; 151 152 adc_bat = to_generic_bat(psy); 153 if (!adc_bat) { 154 dev_err(psy->dev, "no battery infos ?!\n"); 155 return -EINVAL; 156 } 157 pdata = adc_bat->pdata; 158 bat_info = &pdata->battery_info; 159 160 switch (psp) { 161 case POWER_SUPPLY_PROP_STATUS: 162 gab_get_status(adc_bat); 163 break; 164 case POWER_SUPPLY_PROP_CHARGE_EMPTY_DESIGN: 165 val->intval = 0; 166 break; 167 case POWER_SUPPLY_PROP_CHARGE_NOW: 168 val->intval = pdata->cal_charge(result); 169 break; 170 case POWER_SUPPLY_PROP_VOLTAGE_NOW: 171 case POWER_SUPPLY_PROP_CURRENT_NOW: 172 case POWER_SUPPLY_PROP_POWER_NOW: 173 ret = read_channel(adc_bat, psp, &result); 174 if (ret < 0) 175 goto err; 176 val->intval = result; 177 break; 178 case POWER_SUPPLY_PROP_TECHNOLOGY: 179 val->intval = bat_info->technology; 180 break; 181 case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN: 182 val->intval = bat_info->voltage_min_design; 183 break; 184 case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN: 185 val->intval = bat_info->voltage_max_design; 186 break; 187 case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN: 188 val->intval = bat_info->charge_full_design; 189 break; 190 case POWER_SUPPLY_PROP_MODEL_NAME: 191 val->strval = bat_info->name; 192 break; 193 default: 194 return -EINVAL; 195 } 196err: 197 return ret; 198} 199 200static void gab_work(struct work_struct *work) 201{ 202 struct gab *adc_bat; 203 struct gab_platform_data *pdata; 204 struct delayed_work *delayed_work; 205 bool is_plugged; 206 int status; 207 208 delayed_work = container_of(work, struct delayed_work, work); 209 adc_bat = container_of(delayed_work, struct gab, bat_work); 210 pdata = adc_bat->pdata; 211 status = adc_bat->status; 212 213 is_plugged = power_supply_am_i_supplied(&adc_bat->psy); 214 adc_bat->cable_plugged = is_plugged; 215 216 if (!is_plugged) 217 adc_bat->status = POWER_SUPPLY_STATUS_DISCHARGING; 218 else if (gab_charge_finished(adc_bat)) 219 adc_bat->status = POWER_SUPPLY_STATUS_NOT_CHARGING; 220 else 221 adc_bat->status = POWER_SUPPLY_STATUS_CHARGING; 222 223 if (status != adc_bat->status) 224 power_supply_changed(&adc_bat->psy); 225} 226 227static irqreturn_t gab_charged(int irq, void *dev_id) 228{ 229 struct gab *adc_bat = dev_id; 230 struct gab_platform_data *pdata = adc_bat->pdata; 231 int delay; 232 233 delay = pdata->jitter_delay ? pdata->jitter_delay : JITTER_DEFAULT; 234 schedule_delayed_work(&adc_bat->bat_work, 235 msecs_to_jiffies(delay)); 236 return IRQ_HANDLED; 237} 238 239static int gab_probe(struct platform_device *pdev) 240{ 241 struct gab *adc_bat; 242 struct power_supply *psy; 243 struct gab_platform_data *pdata = pdev->dev.platform_data; 244 enum power_supply_property *properties; 245 int ret = 0; 246 int chan; 247 int index = 0; 248 249 adc_bat = devm_kzalloc(&pdev->dev, sizeof(*adc_bat), GFP_KERNEL); 250 if (!adc_bat) { 251 dev_err(&pdev->dev, "failed to allocate memory\n"); 252 return -ENOMEM; 253 } 254 255 psy = &adc_bat->psy; 256 psy->name = pdata->battery_info.name; 257 258 /* bootup default values for the battery */ 259 adc_bat->cable_plugged = false; 260 adc_bat->status = POWER_SUPPLY_STATUS_DISCHARGING; 261 psy->type = POWER_SUPPLY_TYPE_BATTERY; 262 psy->get_property = gab_get_property; 263 psy->external_power_changed = gab_ext_power_changed; 264 adc_bat->pdata = pdata; 265 266 /* 267 * copying the static properties and allocating extra memory for holding 268 * the extra configurable properties received from platform data. 269 */ 270 psy->properties = kcalloc(ARRAY_SIZE(gab_props) + 271 ARRAY_SIZE(gab_chan_name), 272 sizeof(*psy->properties), GFP_KERNEL); 273 if (!psy->properties) { 274 ret = -ENOMEM; 275 goto first_mem_fail; 276 } 277 278 memcpy(psy->properties, gab_props, sizeof(gab_props)); 279 properties = (enum power_supply_property *) 280 ((char *)psy->properties + sizeof(gab_props)); 281 282 /* 283 * getting channel from iio and copying the battery properties 284 * based on the channel supported by consumer device. 285 */ 286 for (chan = 0; chan < ARRAY_SIZE(gab_chan_name); chan++) { 287 adc_bat->channel[chan] = iio_channel_get(&pdev->dev, 288 gab_chan_name[chan]); 289 if (IS_ERR(adc_bat->channel[chan])) { 290 ret = PTR_ERR(adc_bat->channel[chan]); 291 adc_bat->channel[chan] = NULL; 292 } else { 293 /* copying properties for supported channels only */ 294 memcpy(properties + sizeof(*(psy->properties)) * index, 295 &gab_dyn_props[chan], 296 sizeof(gab_dyn_props[chan])); 297 index++; 298 } 299 } 300 301 /* none of the channels are supported so let's bail out */ 302 if (index == 0) { 303 ret = -ENODEV; 304 goto second_mem_fail; 305 } 306 307 /* 308 * Total number of properties is equal to static properties 309 * plus the dynamic properties.Some properties may not be set 310 * as come channels may be not be supported by the device.So 311 * we need to take care of that. 312 */ 313 psy->num_properties = ARRAY_SIZE(gab_props) + index; 314 315 ret = power_supply_register(&pdev->dev, psy); 316 if (ret) 317 goto err_reg_fail; 318 319 INIT_DELAYED_WORK(&adc_bat->bat_work, gab_work); 320 321 if (gpio_is_valid(pdata->gpio_charge_finished)) { 322 int irq; 323 ret = gpio_request(pdata->gpio_charge_finished, "charged"); 324 if (ret) 325 goto gpio_req_fail; 326 327 irq = gpio_to_irq(pdata->gpio_charge_finished); 328 ret = request_any_context_irq(irq, gab_charged, 329 IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, 330 "battery charged", adc_bat); 331 if (ret < 0) 332 goto err_gpio; 333 } 334 335 platform_set_drvdata(pdev, adc_bat); 336 337 /* Schedule timer to check current status */ 338 schedule_delayed_work(&adc_bat->bat_work, 339 msecs_to_jiffies(0)); 340 return 0; 341 342err_gpio: 343 gpio_free(pdata->gpio_charge_finished); 344gpio_req_fail: 345 power_supply_unregister(psy); 346err_reg_fail: 347 for (chan = 0; chan < ARRAY_SIZE(gab_chan_name); chan++) { 348 if (adc_bat->channel[chan]) 349 iio_channel_release(adc_bat->channel[chan]); 350 } 351second_mem_fail: 352 kfree(psy->properties); 353first_mem_fail: 354 return ret; 355} 356 357static int gab_remove(struct platform_device *pdev) 358{ 359 int chan; 360 struct gab *adc_bat = platform_get_drvdata(pdev); 361 struct gab_platform_data *pdata = adc_bat->pdata; 362 363 power_supply_unregister(&adc_bat->psy); 364 365 if (gpio_is_valid(pdata->gpio_charge_finished)) { 366 free_irq(gpio_to_irq(pdata->gpio_charge_finished), adc_bat); 367 gpio_free(pdata->gpio_charge_finished); 368 } 369 370 for (chan = 0; chan < ARRAY_SIZE(gab_chan_name); chan++) { 371 if (adc_bat->channel[chan]) 372 iio_channel_release(adc_bat->channel[chan]); 373 } 374 375 kfree(adc_bat->psy.properties); 376 cancel_delayed_work(&adc_bat->bat_work); 377 return 0; 378} 379 380#ifdef CONFIG_PM 381static int gab_suspend(struct device *dev) 382{ 383 struct gab *adc_bat = dev_get_drvdata(dev); 384 385 cancel_delayed_work_sync(&adc_bat->bat_work); 386 adc_bat->status = POWER_SUPPLY_STATUS_UNKNOWN; 387 return 0; 388} 389 390static int gab_resume(struct device *dev) 391{ 392 struct gab *adc_bat = dev_get_drvdata(dev); 393 struct gab_platform_data *pdata = adc_bat->pdata; 394 int delay; 395 396 delay = pdata->jitter_delay ? pdata->jitter_delay : JITTER_DEFAULT; 397 398 /* Schedule timer to check current status */ 399 schedule_delayed_work(&adc_bat->bat_work, 400 msecs_to_jiffies(delay)); 401 return 0; 402} 403 404static const struct dev_pm_ops gab_pm_ops = { 405 .suspend = gab_suspend, 406 .resume = gab_resume, 407}; 408 409#define GAB_PM_OPS (&gab_pm_ops) 410#else 411#define GAB_PM_OPS (NULL) 412#endif 413 414static struct platform_driver gab_driver = { 415 .driver = { 416 .name = "generic-adc-battery", 417 .owner = THIS_MODULE, 418 .pm = GAB_PM_OPS 419 }, 420 .probe = gab_probe, 421 .remove = gab_remove, 422}; 423module_platform_driver(gab_driver); 424 425MODULE_AUTHOR("anish kumar <anish198519851985@gmail.com>"); 426MODULE_DESCRIPTION("generic battery driver using IIO"); 427MODULE_LICENSE("GPL"); 428