1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Universal power supply monitor class 4 * 5 * Copyright © 2007 Anton Vorontsov <cbou@mail.ru> 6 * Copyright © 2004 Szabolcs Gyurko 7 * Copyright © 2003 Ian Molton <spyro@f2s.com> 8 * 9 * Modified: 2004, Oct Szabolcs Gyurko 10 */ 11 12 #include <linux/module.h> 13 #include <linux/types.h> 14 #include <linux/init.h> 15 #include <linux/slab.h> 16 #include <linux/delay.h> 17 #include <linux/device.h> 18 #include <linux/notifier.h> 19 #include <linux/err.h> 20 #include <linux/of.h> 21 #include <linux/power_supply.h> 22 #include <linux/property.h> 23 #include <linux/thermal.h> 24 #include "power_supply.h" 25 26 /* exported for the APM Power driver, APM emulation */ 27 struct class *power_supply_class; 28 EXPORT_SYMBOL_GPL(power_supply_class); 29 30 ATOMIC_NOTIFIER_HEAD(power_supply_notifier); 31 EXPORT_SYMBOL_GPL(power_supply_notifier); 32 33 static struct device_type power_supply_dev_type; 34 35 #define POWER_SUPPLY_DEFERRED_REGISTER_TIME msecs_to_jiffies(10) 36 37 static bool __power_supply_is_supplied_by(struct power_supply *supplier, 38 struct power_supply *supply) 39 { 40 int i; 41 42 if (!supply->supplied_from && !supplier->supplied_to) 43 return false; 44 45 /* Support both supplied_to and supplied_from modes */ 46 if (supply->supplied_from) { 47 if (!supplier->desc->name) 48 return false; 49 for (i = 0; i < supply->num_supplies; i++) 50 if (!strcmp(supplier->desc->name, supply->supplied_from[i])) 51 return true; 52 } else { 53 if (!supply->desc->name) 54 return false; 55 for (i = 0; i < supplier->num_supplicants; i++) 56 if (!strcmp(supplier->supplied_to[i], supply->desc->name)) 57 return true; 58 } 59 60 return false; 61 } 62 63 static int __power_supply_changed_work(struct device *dev, void *data) 64 { 65 struct power_supply *psy = data; 66 struct power_supply *pst = dev_get_drvdata(dev); 67 68 if (__power_supply_is_supplied_by(psy, pst)) { 69 if (pst->desc->external_power_changed) 70 pst->desc->external_power_changed(pst); 71 } 72 73 return 0; 74 } 75 76 static void power_supply_changed_work(struct work_struct *work) 77 { 78 unsigned long flags; 79 struct power_supply *psy = container_of(work, struct power_supply, 80 changed_work); 81 82 dev_dbg(&psy->dev, "%s\n", __func__); 83 84 spin_lock_irqsave(&psy->changed_lock, flags); 85 /* 86 * Check 'changed' here to avoid issues due to race between 87 * power_supply_changed() and this routine. In worst case 88 * power_supply_changed() can be called again just before we take above 89 * lock. During the first call of this routine we will mark 'changed' as 90 * false and it will stay false for the next call as well. 91 */ 92 if (likely(psy->changed)) { 93 psy->changed = false; 94 spin_unlock_irqrestore(&psy->changed_lock, flags); 95 class_for_each_device(power_supply_class, NULL, psy, 96 __power_supply_changed_work); 97 power_supply_update_leds(psy); 98 atomic_notifier_call_chain(&power_supply_notifier, 99 PSY_EVENT_PROP_CHANGED, psy); 100 kobject_uevent(&psy->dev.kobj, KOBJ_CHANGE); 101 spin_lock_irqsave(&psy->changed_lock, flags); 102 } 103 104 /* 105 * Hold the wakeup_source until all events are processed. 106 * power_supply_changed() might have called again and have set 'changed' 107 * to true. 108 */ 109 if (likely(!psy->changed)) 110 pm_relax(&psy->dev); 111 spin_unlock_irqrestore(&psy->changed_lock, flags); 112 } 113 114 void power_supply_changed(struct power_supply *psy) 115 { 116 unsigned long flags; 117 118 dev_dbg(&psy->dev, "%s\n", __func__); 119 120 spin_lock_irqsave(&psy->changed_lock, flags); 121 psy->changed = true; 122 pm_stay_awake(&psy->dev); 123 spin_unlock_irqrestore(&psy->changed_lock, flags); 124 schedule_work(&psy->changed_work); 125 } 126 EXPORT_SYMBOL_GPL(power_supply_changed); 127 128 /* 129 * Notify that power supply was registered after parent finished the probing. 130 * 131 * Often power supply is registered from driver's probe function. However 132 * calling power_supply_changed() directly from power_supply_register() 133 * would lead to execution of get_property() function provided by the driver 134 * too early - before the probe ends. 135 * 136 * Avoid that by waiting on parent's mutex. 137 */ 138 static void power_supply_deferred_register_work(struct work_struct *work) 139 { 140 struct power_supply *psy = container_of(work, struct power_supply, 141 deferred_register_work.work); 142 143 if (psy->dev.parent) { 144 while (!mutex_trylock(&psy->dev.parent->mutex)) { 145 if (psy->removing) 146 return; 147 msleep(10); 148 } 149 } 150 151 power_supply_changed(psy); 152 153 if (psy->dev.parent) 154 mutex_unlock(&psy->dev.parent->mutex); 155 } 156 157 #ifdef CONFIG_OF 158 static int __power_supply_populate_supplied_from(struct device *dev, 159 void *data) 160 { 161 struct power_supply *psy = data; 162 struct power_supply *epsy = dev_get_drvdata(dev); 163 struct device_node *np; 164 int i = 0; 165 166 do { 167 np = of_parse_phandle(psy->of_node, "power-supplies", i++); 168 if (!np) 169 break; 170 171 if (np == epsy->of_node) { 172 dev_dbg(&psy->dev, "%s: Found supply : %s\n", 173 psy->desc->name, epsy->desc->name); 174 psy->supplied_from[i-1] = (char *)epsy->desc->name; 175 psy->num_supplies++; 176 of_node_put(np); 177 break; 178 } 179 of_node_put(np); 180 } while (np); 181 182 return 0; 183 } 184 185 static int power_supply_populate_supplied_from(struct power_supply *psy) 186 { 187 int error; 188 189 error = class_for_each_device(power_supply_class, NULL, psy, 190 __power_supply_populate_supplied_from); 191 192 dev_dbg(&psy->dev, "%s %d\n", __func__, error); 193 194 return error; 195 } 196 197 static int __power_supply_find_supply_from_node(struct device *dev, 198 void *data) 199 { 200 struct device_node *np = data; 201 struct power_supply *epsy = dev_get_drvdata(dev); 202 203 /* returning non-zero breaks out of class_for_each_device loop */ 204 if (epsy->of_node == np) 205 return 1; 206 207 return 0; 208 } 209 210 static int power_supply_find_supply_from_node(struct device_node *supply_node) 211 { 212 int error; 213 214 /* 215 * class_for_each_device() either returns its own errors or values 216 * returned by __power_supply_find_supply_from_node(). 217 * 218 * __power_supply_find_supply_from_node() will return 0 (no match) 219 * or 1 (match). 220 * 221 * We return 0 if class_for_each_device() returned 1, -EPROBE_DEFER if 222 * it returned 0, or error as returned by it. 223 */ 224 error = class_for_each_device(power_supply_class, NULL, supply_node, 225 __power_supply_find_supply_from_node); 226 227 return error ? (error == 1 ? 0 : error) : -EPROBE_DEFER; 228 } 229 230 static int power_supply_check_supplies(struct power_supply *psy) 231 { 232 struct device_node *np; 233 int cnt = 0; 234 235 /* If there is already a list honor it */ 236 if (psy->supplied_from && psy->num_supplies > 0) 237 return 0; 238 239 /* No device node found, nothing to do */ 240 if (!psy->of_node) 241 return 0; 242 243 do { 244 int ret; 245 246 np = of_parse_phandle(psy->of_node, "power-supplies", cnt++); 247 if (!np) 248 break; 249 250 ret = power_supply_find_supply_from_node(np); 251 of_node_put(np); 252 253 if (ret) { 254 dev_dbg(&psy->dev, "Failed to find supply!\n"); 255 return ret; 256 } 257 } while (np); 258 259 /* Missing valid "power-supplies" entries */ 260 if (cnt == 1) 261 return 0; 262 263 /* All supplies found, allocate char ** array for filling */ 264 psy->supplied_from = devm_kzalloc(&psy->dev, sizeof(psy->supplied_from), 265 GFP_KERNEL); 266 if (!psy->supplied_from) 267 return -ENOMEM; 268 269 *psy->supplied_from = devm_kcalloc(&psy->dev, 270 cnt - 1, sizeof(char *), 271 GFP_KERNEL); 272 if (!*psy->supplied_from) 273 return -ENOMEM; 274 275 return power_supply_populate_supplied_from(psy); 276 } 277 #else 278 static int power_supply_check_supplies(struct power_supply *psy) 279 { 280 int nval, ret; 281 282 if (!psy->dev.parent) 283 return 0; 284 285 nval = device_property_read_string_array(psy->dev.parent, 286 "supplied-from", NULL, 0); 287 if (nval <= 0) 288 return 0; 289 290 psy->supplied_from = devm_kmalloc_array(&psy->dev, nval, 291 sizeof(char *), GFP_KERNEL); 292 if (!psy->supplied_from) 293 return -ENOMEM; 294 295 ret = device_property_read_string_array(psy->dev.parent, 296 "supplied-from", (const char **)psy->supplied_from, nval); 297 if (ret < 0) 298 return ret; 299 300 psy->num_supplies = nval; 301 302 return 0; 303 } 304 #endif 305 306 struct psy_am_i_supplied_data { 307 struct power_supply *psy; 308 unsigned int count; 309 }; 310 311 static int __power_supply_am_i_supplied(struct device *dev, void *_data) 312 { 313 union power_supply_propval ret = {0,}; 314 struct power_supply *epsy = dev_get_drvdata(dev); 315 struct psy_am_i_supplied_data *data = _data; 316 317 if (__power_supply_is_supplied_by(epsy, data->psy)) { 318 data->count++; 319 if (!epsy->desc->get_property(epsy, POWER_SUPPLY_PROP_ONLINE, 320 &ret)) 321 return ret.intval; 322 } 323 324 return 0; 325 } 326 327 int power_supply_am_i_supplied(struct power_supply *psy) 328 { 329 struct psy_am_i_supplied_data data = { psy, 0 }; 330 int error; 331 332 error = class_for_each_device(power_supply_class, NULL, &data, 333 __power_supply_am_i_supplied); 334 335 dev_dbg(&psy->dev, "%s count %u err %d\n", __func__, data.count, error); 336 337 if (data.count == 0) 338 return -ENODEV; 339 340 return error; 341 } 342 EXPORT_SYMBOL_GPL(power_supply_am_i_supplied); 343 344 static int __power_supply_is_system_supplied(struct device *dev, void *data) 345 { 346 union power_supply_propval ret = {0,}; 347 struct power_supply *psy = dev_get_drvdata(dev); 348 unsigned int *count = data; 349 350 (*count)++; 351 if (psy->desc->type != POWER_SUPPLY_TYPE_BATTERY) 352 if (!psy->desc->get_property(psy, POWER_SUPPLY_PROP_ONLINE, 353 &ret)) 354 return ret.intval; 355 356 return 0; 357 } 358 359 int power_supply_is_system_supplied(void) 360 { 361 int error; 362 unsigned int count = 0; 363 364 error = class_for_each_device(power_supply_class, NULL, &count, 365 __power_supply_is_system_supplied); 366 367 /* 368 * If no power class device was found at all, most probably we are 369 * running on a desktop system, so assume we are on mains power. 370 */ 371 if (count == 0) 372 return 1; 373 374 return error; 375 } 376 EXPORT_SYMBOL_GPL(power_supply_is_system_supplied); 377 378 static int __power_supply_get_supplier_max_current(struct device *dev, 379 void *data) 380 { 381 union power_supply_propval ret = {0,}; 382 struct power_supply *epsy = dev_get_drvdata(dev); 383 struct power_supply *psy = data; 384 385 if (__power_supply_is_supplied_by(epsy, psy)) 386 if (!epsy->desc->get_property(epsy, 387 POWER_SUPPLY_PROP_CURRENT_MAX, 388 &ret)) 389 return ret.intval; 390 391 return 0; 392 } 393 394 int power_supply_set_input_current_limit_from_supplier(struct power_supply *psy) 395 { 396 union power_supply_propval val = {0,}; 397 int curr; 398 399 if (!psy->desc->set_property) 400 return -EINVAL; 401 402 /* 403 * This function is not intended for use with a supply with multiple 404 * suppliers, we simply pick the first supply to report a non 0 405 * max-current. 406 */ 407 curr = class_for_each_device(power_supply_class, NULL, psy, 408 __power_supply_get_supplier_max_current); 409 if (curr <= 0) 410 return (curr == 0) ? -ENODEV : curr; 411 412 val.intval = curr; 413 414 return psy->desc->set_property(psy, 415 POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT, &val); 416 } 417 EXPORT_SYMBOL_GPL(power_supply_set_input_current_limit_from_supplier); 418 419 int power_supply_set_battery_charged(struct power_supply *psy) 420 { 421 if (atomic_read(&psy->use_cnt) >= 0 && 422 psy->desc->type == POWER_SUPPLY_TYPE_BATTERY && 423 psy->desc->set_charged) { 424 psy->desc->set_charged(psy); 425 return 0; 426 } 427 428 return -EINVAL; 429 } 430 EXPORT_SYMBOL_GPL(power_supply_set_battery_charged); 431 432 static int power_supply_match_device_by_name(struct device *dev, const void *data) 433 { 434 const char *name = data; 435 struct power_supply *psy = dev_get_drvdata(dev); 436 437 return strcmp(psy->desc->name, name) == 0; 438 } 439 440 /** 441 * power_supply_get_by_name() - Search for a power supply and returns its ref 442 * @name: Power supply name to fetch 443 * 444 * If power supply was found, it increases reference count for the 445 * internal power supply's device. The user should power_supply_put() 446 * after usage. 447 * 448 * Return: On success returns a reference to a power supply with 449 * matching name equals to @name, a NULL otherwise. 450 */ 451 struct power_supply *power_supply_get_by_name(const char *name) 452 { 453 struct power_supply *psy = NULL; 454 struct device *dev = class_find_device(power_supply_class, NULL, name, 455 power_supply_match_device_by_name); 456 457 if (dev) { 458 psy = dev_get_drvdata(dev); 459 atomic_inc(&psy->use_cnt); 460 } 461 462 return psy; 463 } 464 EXPORT_SYMBOL_GPL(power_supply_get_by_name); 465 466 /** 467 * power_supply_put() - Drop reference obtained with power_supply_get_by_name 468 * @psy: Reference to put 469 * 470 * The reference to power supply should be put before unregistering 471 * the power supply. 472 */ 473 void power_supply_put(struct power_supply *psy) 474 { 475 might_sleep(); 476 477 atomic_dec(&psy->use_cnt); 478 put_device(&psy->dev); 479 } 480 EXPORT_SYMBOL_GPL(power_supply_put); 481 482 #ifdef CONFIG_OF 483 static int power_supply_match_device_node(struct device *dev, const void *data) 484 { 485 return dev->parent && dev->parent->of_node == data; 486 } 487 488 /** 489 * power_supply_get_by_phandle() - Search for a power supply and returns its ref 490 * @np: Pointer to device node holding phandle property 491 * @property: Name of property holding a power supply name 492 * 493 * If power supply was found, it increases reference count for the 494 * internal power supply's device. The user should power_supply_put() 495 * after usage. 496 * 497 * Return: On success returns a reference to a power supply with 498 * matching name equals to value under @property, NULL or ERR_PTR otherwise. 499 */ 500 struct power_supply *power_supply_get_by_phandle(struct device_node *np, 501 const char *property) 502 { 503 struct device_node *power_supply_np; 504 struct power_supply *psy = NULL; 505 struct device *dev; 506 507 power_supply_np = of_parse_phandle(np, property, 0); 508 if (!power_supply_np) 509 return ERR_PTR(-ENODEV); 510 511 dev = class_find_device(power_supply_class, NULL, power_supply_np, 512 power_supply_match_device_node); 513 514 of_node_put(power_supply_np); 515 516 if (dev) { 517 psy = dev_get_drvdata(dev); 518 atomic_inc(&psy->use_cnt); 519 } 520 521 return psy; 522 } 523 EXPORT_SYMBOL_GPL(power_supply_get_by_phandle); 524 525 static void devm_power_supply_put(struct device *dev, void *res) 526 { 527 struct power_supply **psy = res; 528 529 power_supply_put(*psy); 530 } 531 532 /** 533 * devm_power_supply_get_by_phandle() - Resource managed version of 534 * power_supply_get_by_phandle() 535 * @dev: Pointer to device holding phandle property 536 * @property: Name of property holding a power supply phandle 537 * 538 * Return: On success returns a reference to a power supply with 539 * matching name equals to value under @property, NULL or ERR_PTR otherwise. 540 */ 541 struct power_supply *devm_power_supply_get_by_phandle(struct device *dev, 542 const char *property) 543 { 544 struct power_supply **ptr, *psy; 545 546 if (!dev->of_node) 547 return ERR_PTR(-ENODEV); 548 549 ptr = devres_alloc(devm_power_supply_put, sizeof(*ptr), GFP_KERNEL); 550 if (!ptr) 551 return ERR_PTR(-ENOMEM); 552 553 psy = power_supply_get_by_phandle(dev->of_node, property); 554 if (IS_ERR_OR_NULL(psy)) { 555 devres_free(ptr); 556 } else { 557 *ptr = psy; 558 devres_add(dev, ptr); 559 } 560 return psy; 561 } 562 EXPORT_SYMBOL_GPL(devm_power_supply_get_by_phandle); 563 #endif /* CONFIG_OF */ 564 565 int power_supply_get_battery_info(struct power_supply *psy, 566 struct power_supply_battery_info *info) 567 { 568 struct power_supply_resistance_temp_table *resist_table; 569 struct device_node *battery_np; 570 const char *value; 571 int err, len, index; 572 const __be32 *list; 573 574 info->technology = POWER_SUPPLY_TECHNOLOGY_UNKNOWN; 575 info->energy_full_design_uwh = -EINVAL; 576 info->charge_full_design_uah = -EINVAL; 577 info->voltage_min_design_uv = -EINVAL; 578 info->voltage_max_design_uv = -EINVAL; 579 info->precharge_current_ua = -EINVAL; 580 info->charge_term_current_ua = -EINVAL; 581 info->constant_charge_current_max_ua = -EINVAL; 582 info->constant_charge_voltage_max_uv = -EINVAL; 583 info->temp_ambient_alert_min = INT_MIN; 584 info->temp_ambient_alert_max = INT_MAX; 585 info->temp_alert_min = INT_MIN; 586 info->temp_alert_max = INT_MAX; 587 info->temp_min = INT_MIN; 588 info->temp_max = INT_MAX; 589 info->factory_internal_resistance_uohm = -EINVAL; 590 info->resist_table = NULL; 591 592 for (index = 0; index < POWER_SUPPLY_OCV_TEMP_MAX; index++) { 593 info->ocv_table[index] = NULL; 594 info->ocv_temp[index] = -EINVAL; 595 info->ocv_table_size[index] = -EINVAL; 596 } 597 598 if (!psy->of_node) { 599 dev_warn(&psy->dev, "%s currently only supports devicetree\n", 600 __func__); 601 return -ENXIO; 602 } 603 604 battery_np = of_parse_phandle(psy->of_node, "monitored-battery", 0); 605 if (!battery_np) 606 return -ENODEV; 607 608 err = of_property_read_string(battery_np, "compatible", &value); 609 if (err) 610 goto out_put_node; 611 612 if (strcmp("simple-battery", value)) { 613 err = -ENODEV; 614 goto out_put_node; 615 } 616 617 /* The property and field names below must correspond to elements 618 * in enum power_supply_property. For reasoning, see 619 * Documentation/power/power_supply_class.rst. 620 */ 621 622 if (!of_property_read_string(battery_np, "device-chemistry", &value)) { 623 if (!strcmp("nickel-cadmium", value)) 624 info->technology = POWER_SUPPLY_TECHNOLOGY_NiCd; 625 else if (!strcmp("nickel-metal-hydride", value)) 626 info->technology = POWER_SUPPLY_TECHNOLOGY_NiMH; 627 else if (!strcmp("lithium-ion", value)) 628 /* Imprecise lithium-ion type */ 629 info->technology = POWER_SUPPLY_TECHNOLOGY_LION; 630 else if (!strcmp("lithium-ion-polymer", value)) 631 info->technology = POWER_SUPPLY_TECHNOLOGY_LIPO; 632 else if (!strcmp("lithium-ion-iron-phosphate", value)) 633 info->technology = POWER_SUPPLY_TECHNOLOGY_LiFe; 634 else if (!strcmp("lithium-ion-manganese-oxide", value)) 635 info->technology = POWER_SUPPLY_TECHNOLOGY_LiMn; 636 else 637 dev_warn(&psy->dev, "%s unknown battery type\n", value); 638 } 639 640 of_property_read_u32(battery_np, "energy-full-design-microwatt-hours", 641 &info->energy_full_design_uwh); 642 of_property_read_u32(battery_np, "charge-full-design-microamp-hours", 643 &info->charge_full_design_uah); 644 of_property_read_u32(battery_np, "voltage-min-design-microvolt", 645 &info->voltage_min_design_uv); 646 of_property_read_u32(battery_np, "voltage-max-design-microvolt", 647 &info->voltage_max_design_uv); 648 of_property_read_u32(battery_np, "trickle-charge-current-microamp", 649 &info->tricklecharge_current_ua); 650 of_property_read_u32(battery_np, "precharge-current-microamp", 651 &info->precharge_current_ua); 652 of_property_read_u32(battery_np, "precharge-upper-limit-microvolt", 653 &info->precharge_voltage_max_uv); 654 of_property_read_u32(battery_np, "charge-term-current-microamp", 655 &info->charge_term_current_ua); 656 of_property_read_u32(battery_np, "re-charge-voltage-microvolt", 657 &info->charge_restart_voltage_uv); 658 of_property_read_u32(battery_np, "over-voltage-threshold-microvolt", 659 &info->overvoltage_limit_uv); 660 of_property_read_u32(battery_np, "constant-charge-current-max-microamp", 661 &info->constant_charge_current_max_ua); 662 of_property_read_u32(battery_np, "constant-charge-voltage-max-microvolt", 663 &info->constant_charge_voltage_max_uv); 664 of_property_read_u32(battery_np, "factory-internal-resistance-micro-ohms", 665 &info->factory_internal_resistance_uohm); 666 667 of_property_read_u32_index(battery_np, "ambient-celsius", 668 0, &info->temp_ambient_alert_min); 669 of_property_read_u32_index(battery_np, "ambient-celsius", 670 1, &info->temp_ambient_alert_max); 671 of_property_read_u32_index(battery_np, "alert-celsius", 672 0, &info->temp_alert_min); 673 of_property_read_u32_index(battery_np, "alert-celsius", 674 1, &info->temp_alert_max); 675 of_property_read_u32_index(battery_np, "operating-range-celsius", 676 0, &info->temp_min); 677 of_property_read_u32_index(battery_np, "operating-range-celsius", 678 1, &info->temp_max); 679 680 len = of_property_count_u32_elems(battery_np, "ocv-capacity-celsius"); 681 if (len < 0 && len != -EINVAL) { 682 err = len; 683 goto out_put_node; 684 } else if (len > POWER_SUPPLY_OCV_TEMP_MAX) { 685 dev_err(&psy->dev, "Too many temperature values\n"); 686 err = -EINVAL; 687 goto out_put_node; 688 } else if (len > 0) { 689 of_property_read_u32_array(battery_np, "ocv-capacity-celsius", 690 info->ocv_temp, len); 691 } 692 693 for (index = 0; index < len; index++) { 694 struct power_supply_battery_ocv_table *table; 695 char *propname; 696 int i, tab_len, size; 697 698 propname = kasprintf(GFP_KERNEL, "ocv-capacity-table-%d", index); 699 list = of_get_property(battery_np, propname, &size); 700 if (!list || !size) { 701 dev_err(&psy->dev, "failed to get %s\n", propname); 702 kfree(propname); 703 power_supply_put_battery_info(psy, info); 704 err = -EINVAL; 705 goto out_put_node; 706 } 707 708 kfree(propname); 709 tab_len = size / (2 * sizeof(__be32)); 710 info->ocv_table_size[index] = tab_len; 711 712 table = info->ocv_table[index] = 713 devm_kcalloc(&psy->dev, tab_len, sizeof(*table), GFP_KERNEL); 714 if (!info->ocv_table[index]) { 715 power_supply_put_battery_info(psy, info); 716 err = -ENOMEM; 717 goto out_put_node; 718 } 719 720 for (i = 0; i < tab_len; i++) { 721 table[i].ocv = be32_to_cpu(*list); 722 list++; 723 table[i].capacity = be32_to_cpu(*list); 724 list++; 725 } 726 } 727 728 list = of_get_property(battery_np, "resistance-temp-table", &len); 729 if (!list || !len) 730 goto out_put_node; 731 732 info->resist_table_size = len / (2 * sizeof(__be32)); 733 resist_table = info->resist_table = devm_kcalloc(&psy->dev, 734 info->resist_table_size, 735 sizeof(*resist_table), 736 GFP_KERNEL); 737 if (!info->resist_table) { 738 power_supply_put_battery_info(psy, info); 739 err = -ENOMEM; 740 goto out_put_node; 741 } 742 743 for (index = 0; index < info->resist_table_size; index++) { 744 resist_table[index].temp = be32_to_cpu(*list++); 745 resist_table[index].resistance = be32_to_cpu(*list++); 746 } 747 748 out_put_node: 749 of_node_put(battery_np); 750 return err; 751 } 752 EXPORT_SYMBOL_GPL(power_supply_get_battery_info); 753 754 void power_supply_put_battery_info(struct power_supply *psy, 755 struct power_supply_battery_info *info) 756 { 757 int i; 758 759 for (i = 0; i < POWER_SUPPLY_OCV_TEMP_MAX; i++) { 760 if (info->ocv_table[i]) 761 devm_kfree(&psy->dev, info->ocv_table[i]); 762 } 763 764 if (info->resist_table) 765 devm_kfree(&psy->dev, info->resist_table); 766 } 767 EXPORT_SYMBOL_GPL(power_supply_put_battery_info); 768 769 /** 770 * power_supply_temp2resist_simple() - find the battery internal resistance 771 * percent 772 * @table: Pointer to battery resistance temperature table 773 * @table_len: The table length 774 * @temp: Current temperature 775 * 776 * This helper function is used to look up battery internal resistance percent 777 * according to current temperature value from the resistance temperature table, 778 * and the table must be ordered descending. Then the actual battery internal 779 * resistance = the ideal battery internal resistance * percent / 100. 780 * 781 * Return: the battery internal resistance percent 782 */ 783 int power_supply_temp2resist_simple(struct power_supply_resistance_temp_table *table, 784 int table_len, int temp) 785 { 786 int i, resist; 787 788 for (i = 0; i < table_len; i++) 789 if (temp > table[i].temp) 790 break; 791 792 if (i > 0 && i < table_len) { 793 int tmp; 794 795 tmp = (table[i - 1].resistance - table[i].resistance) * 796 (temp - table[i].temp); 797 tmp /= table[i - 1].temp - table[i].temp; 798 resist = tmp + table[i].resistance; 799 } else if (i == 0) { 800 resist = table[0].resistance; 801 } else { 802 resist = table[table_len - 1].resistance; 803 } 804 805 return resist; 806 } 807 EXPORT_SYMBOL_GPL(power_supply_temp2resist_simple); 808 809 /** 810 * power_supply_ocv2cap_simple() - find the battery capacity 811 * @table: Pointer to battery OCV lookup table 812 * @table_len: OCV table length 813 * @ocv: Current OCV value 814 * 815 * This helper function is used to look up battery capacity according to 816 * current OCV value from one OCV table, and the OCV table must be ordered 817 * descending. 818 * 819 * Return: the battery capacity. 820 */ 821 int power_supply_ocv2cap_simple(struct power_supply_battery_ocv_table *table, 822 int table_len, int ocv) 823 { 824 int i, cap, tmp; 825 826 for (i = 0; i < table_len; i++) 827 if (ocv > table[i].ocv) 828 break; 829 830 if (i > 0 && i < table_len) { 831 tmp = (table[i - 1].capacity - table[i].capacity) * 832 (ocv - table[i].ocv); 833 tmp /= table[i - 1].ocv - table[i].ocv; 834 cap = tmp + table[i].capacity; 835 } else if (i == 0) { 836 cap = table[0].capacity; 837 } else { 838 cap = table[table_len - 1].capacity; 839 } 840 841 return cap; 842 } 843 EXPORT_SYMBOL_GPL(power_supply_ocv2cap_simple); 844 845 struct power_supply_battery_ocv_table * 846 power_supply_find_ocv2cap_table(struct power_supply_battery_info *info, 847 int temp, int *table_len) 848 { 849 int best_temp_diff = INT_MAX, temp_diff; 850 u8 i, best_index = 0; 851 852 if (!info->ocv_table[0]) 853 return NULL; 854 855 for (i = 0; i < POWER_SUPPLY_OCV_TEMP_MAX; i++) { 856 temp_diff = abs(info->ocv_temp[i] - temp); 857 858 if (temp_diff < best_temp_diff) { 859 best_temp_diff = temp_diff; 860 best_index = i; 861 } 862 } 863 864 *table_len = info->ocv_table_size[best_index]; 865 return info->ocv_table[best_index]; 866 } 867 EXPORT_SYMBOL_GPL(power_supply_find_ocv2cap_table); 868 869 int power_supply_batinfo_ocv2cap(struct power_supply_battery_info *info, 870 int ocv, int temp) 871 { 872 struct power_supply_battery_ocv_table *table; 873 int table_len; 874 875 table = power_supply_find_ocv2cap_table(info, temp, &table_len); 876 if (!table) 877 return -EINVAL; 878 879 return power_supply_ocv2cap_simple(table, table_len, ocv); 880 } 881 EXPORT_SYMBOL_GPL(power_supply_batinfo_ocv2cap); 882 883 int power_supply_get_property(struct power_supply *psy, 884 enum power_supply_property psp, 885 union power_supply_propval *val) 886 { 887 if (atomic_read(&psy->use_cnt) <= 0) { 888 if (!psy->initialized) 889 return -EAGAIN; 890 return -ENODEV; 891 } 892 893 return psy->desc->get_property(psy, psp, val); 894 } 895 EXPORT_SYMBOL_GPL(power_supply_get_property); 896 897 int power_supply_set_property(struct power_supply *psy, 898 enum power_supply_property psp, 899 const union power_supply_propval *val) 900 { 901 if (atomic_read(&psy->use_cnt) <= 0 || !psy->desc->set_property) 902 return -ENODEV; 903 904 return psy->desc->set_property(psy, psp, val); 905 } 906 EXPORT_SYMBOL_GPL(power_supply_set_property); 907 908 int power_supply_property_is_writeable(struct power_supply *psy, 909 enum power_supply_property psp) 910 { 911 if (atomic_read(&psy->use_cnt) <= 0 || 912 !psy->desc->property_is_writeable) 913 return -ENODEV; 914 915 return psy->desc->property_is_writeable(psy, psp); 916 } 917 EXPORT_SYMBOL_GPL(power_supply_property_is_writeable); 918 919 void power_supply_external_power_changed(struct power_supply *psy) 920 { 921 if (atomic_read(&psy->use_cnt) <= 0 || 922 !psy->desc->external_power_changed) 923 return; 924 925 psy->desc->external_power_changed(psy); 926 } 927 EXPORT_SYMBOL_GPL(power_supply_external_power_changed); 928 929 int power_supply_powers(struct power_supply *psy, struct device *dev) 930 { 931 return sysfs_create_link(&psy->dev.kobj, &dev->kobj, "powers"); 932 } 933 EXPORT_SYMBOL_GPL(power_supply_powers); 934 935 static void power_supply_dev_release(struct device *dev) 936 { 937 struct power_supply *psy = to_power_supply(dev); 938 dev_dbg(dev, "%s\n", __func__); 939 kfree(psy); 940 } 941 942 int power_supply_reg_notifier(struct notifier_block *nb) 943 { 944 return atomic_notifier_chain_register(&power_supply_notifier, nb); 945 } 946 EXPORT_SYMBOL_GPL(power_supply_reg_notifier); 947 948 void power_supply_unreg_notifier(struct notifier_block *nb) 949 { 950 atomic_notifier_chain_unregister(&power_supply_notifier, nb); 951 } 952 EXPORT_SYMBOL_GPL(power_supply_unreg_notifier); 953 954 #ifdef CONFIG_THERMAL 955 static int power_supply_read_temp(struct thermal_zone_device *tzd, 956 int *temp) 957 { 958 struct power_supply *psy; 959 union power_supply_propval val; 960 int ret; 961 962 WARN_ON(tzd == NULL); 963 psy = tzd->devdata; 964 ret = power_supply_get_property(psy, POWER_SUPPLY_PROP_TEMP, &val); 965 if (ret) 966 return ret; 967 968 /* Convert tenths of degree Celsius to milli degree Celsius. */ 969 *temp = val.intval * 100; 970 971 return ret; 972 } 973 974 static struct thermal_zone_device_ops psy_tzd_ops = { 975 .get_temp = power_supply_read_temp, 976 }; 977 978 static int psy_register_thermal(struct power_supply *psy) 979 { 980 int i, ret; 981 982 if (psy->desc->no_thermal) 983 return 0; 984 985 /* Register battery zone device psy reports temperature */ 986 for (i = 0; i < psy->desc->num_properties; i++) { 987 if (psy->desc->properties[i] == POWER_SUPPLY_PROP_TEMP) { 988 psy->tzd = thermal_zone_device_register(psy->desc->name, 989 0, 0, psy, &psy_tzd_ops, NULL, 0, 0); 990 if (IS_ERR(psy->tzd)) 991 return PTR_ERR(psy->tzd); 992 ret = thermal_zone_device_enable(psy->tzd); 993 if (ret) 994 thermal_zone_device_unregister(psy->tzd); 995 return ret; 996 } 997 } 998 return 0; 999 } 1000 1001 static void psy_unregister_thermal(struct power_supply *psy) 1002 { 1003 if (IS_ERR_OR_NULL(psy->tzd)) 1004 return; 1005 thermal_zone_device_unregister(psy->tzd); 1006 } 1007 1008 /* thermal cooling device callbacks */ 1009 static int ps_get_max_charge_cntl_limit(struct thermal_cooling_device *tcd, 1010 unsigned long *state) 1011 { 1012 struct power_supply *psy; 1013 union power_supply_propval val; 1014 int ret; 1015 1016 psy = tcd->devdata; 1017 ret = power_supply_get_property(psy, 1018 POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT_MAX, &val); 1019 if (ret) 1020 return ret; 1021 1022 *state = val.intval; 1023 1024 return ret; 1025 } 1026 1027 static int ps_get_cur_charge_cntl_limit(struct thermal_cooling_device *tcd, 1028 unsigned long *state) 1029 { 1030 struct power_supply *psy; 1031 union power_supply_propval val; 1032 int ret; 1033 1034 psy = tcd->devdata; 1035 ret = power_supply_get_property(psy, 1036 POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT, &val); 1037 if (ret) 1038 return ret; 1039 1040 *state = val.intval; 1041 1042 return ret; 1043 } 1044 1045 static int ps_set_cur_charge_cntl_limit(struct thermal_cooling_device *tcd, 1046 unsigned long state) 1047 { 1048 struct power_supply *psy; 1049 union power_supply_propval val; 1050 int ret; 1051 1052 psy = tcd->devdata; 1053 val.intval = state; 1054 ret = psy->desc->set_property(psy, 1055 POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT, &val); 1056 1057 return ret; 1058 } 1059 1060 static const struct thermal_cooling_device_ops psy_tcd_ops = { 1061 .get_max_state = ps_get_max_charge_cntl_limit, 1062 .get_cur_state = ps_get_cur_charge_cntl_limit, 1063 .set_cur_state = ps_set_cur_charge_cntl_limit, 1064 }; 1065 1066 static int psy_register_cooler(struct power_supply *psy) 1067 { 1068 int i; 1069 1070 /* Register for cooling device if psy can control charging */ 1071 for (i = 0; i < psy->desc->num_properties; i++) { 1072 if (psy->desc->properties[i] == 1073 POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT) { 1074 psy->tcd = thermal_cooling_device_register( 1075 (char *)psy->desc->name, 1076 psy, &psy_tcd_ops); 1077 return PTR_ERR_OR_ZERO(psy->tcd); 1078 } 1079 } 1080 return 0; 1081 } 1082 1083 static void psy_unregister_cooler(struct power_supply *psy) 1084 { 1085 if (IS_ERR_OR_NULL(psy->tcd)) 1086 return; 1087 thermal_cooling_device_unregister(psy->tcd); 1088 } 1089 #else 1090 static int psy_register_thermal(struct power_supply *psy) 1091 { 1092 return 0; 1093 } 1094 1095 static void psy_unregister_thermal(struct power_supply *psy) 1096 { 1097 } 1098 1099 static int psy_register_cooler(struct power_supply *psy) 1100 { 1101 return 0; 1102 } 1103 1104 static void psy_unregister_cooler(struct power_supply *psy) 1105 { 1106 } 1107 #endif 1108 1109 static struct power_supply *__must_check 1110 __power_supply_register(struct device *parent, 1111 const struct power_supply_desc *desc, 1112 const struct power_supply_config *cfg, 1113 bool ws) 1114 { 1115 struct device *dev; 1116 struct power_supply *psy; 1117 int i, rc; 1118 1119 if (!parent) 1120 pr_warn("%s: Expected proper parent device for '%s'\n", 1121 __func__, desc->name); 1122 1123 if (!desc || !desc->name || !desc->properties || !desc->num_properties) 1124 return ERR_PTR(-EINVAL); 1125 1126 for (i = 0; i < desc->num_properties; ++i) { 1127 if ((desc->properties[i] == POWER_SUPPLY_PROP_USB_TYPE) && 1128 (!desc->usb_types || !desc->num_usb_types)) 1129 return ERR_PTR(-EINVAL); 1130 } 1131 1132 psy = kzalloc(sizeof(*psy), GFP_KERNEL); 1133 if (!psy) 1134 return ERR_PTR(-ENOMEM); 1135 1136 dev = &psy->dev; 1137 1138 device_initialize(dev); 1139 1140 dev->class = power_supply_class; 1141 dev->type = &power_supply_dev_type; 1142 dev->parent = parent; 1143 dev->release = power_supply_dev_release; 1144 dev_set_drvdata(dev, psy); 1145 psy->desc = desc; 1146 if (cfg) { 1147 dev->groups = cfg->attr_grp; 1148 psy->drv_data = cfg->drv_data; 1149 psy->of_node = 1150 cfg->fwnode ? to_of_node(cfg->fwnode) : cfg->of_node; 1151 psy->supplied_to = cfg->supplied_to; 1152 psy->num_supplicants = cfg->num_supplicants; 1153 } 1154 1155 rc = dev_set_name(dev, "%s", desc->name); 1156 if (rc) 1157 goto dev_set_name_failed; 1158 1159 INIT_WORK(&psy->changed_work, power_supply_changed_work); 1160 INIT_DELAYED_WORK(&psy->deferred_register_work, 1161 power_supply_deferred_register_work); 1162 1163 rc = power_supply_check_supplies(psy); 1164 if (rc) { 1165 dev_dbg(dev, "Not all required supplies found, defer probe\n"); 1166 goto check_supplies_failed; 1167 } 1168 1169 spin_lock_init(&psy->changed_lock); 1170 rc = device_add(dev); 1171 if (rc) 1172 goto device_add_failed; 1173 1174 rc = device_init_wakeup(dev, ws); 1175 if (rc) 1176 goto wakeup_init_failed; 1177 1178 rc = psy_register_thermal(psy); 1179 if (rc) 1180 goto register_thermal_failed; 1181 1182 rc = psy_register_cooler(psy); 1183 if (rc) 1184 goto register_cooler_failed; 1185 1186 rc = power_supply_create_triggers(psy); 1187 if (rc) 1188 goto create_triggers_failed; 1189 1190 rc = power_supply_add_hwmon_sysfs(psy); 1191 if (rc) 1192 goto add_hwmon_sysfs_failed; 1193 1194 /* 1195 * Update use_cnt after any uevents (most notably from device_add()). 1196 * We are here still during driver's probe but 1197 * the power_supply_uevent() calls back driver's get_property 1198 * method so: 1199 * 1. Driver did not assigned the returned struct power_supply, 1200 * 2. Driver could not finish initialization (anything in its probe 1201 * after calling power_supply_register()). 1202 */ 1203 atomic_inc(&psy->use_cnt); 1204 psy->initialized = true; 1205 1206 queue_delayed_work(system_power_efficient_wq, 1207 &psy->deferred_register_work, 1208 POWER_SUPPLY_DEFERRED_REGISTER_TIME); 1209 1210 return psy; 1211 1212 add_hwmon_sysfs_failed: 1213 power_supply_remove_triggers(psy); 1214 create_triggers_failed: 1215 psy_unregister_cooler(psy); 1216 register_cooler_failed: 1217 psy_unregister_thermal(psy); 1218 register_thermal_failed: 1219 device_del(dev); 1220 wakeup_init_failed: 1221 device_add_failed: 1222 check_supplies_failed: 1223 dev_set_name_failed: 1224 put_device(dev); 1225 return ERR_PTR(rc); 1226 } 1227 1228 /** 1229 * power_supply_register() - Register new power supply 1230 * @parent: Device to be a parent of power supply's device, usually 1231 * the device which probe function calls this 1232 * @desc: Description of power supply, must be valid through whole 1233 * lifetime of this power supply 1234 * @cfg: Run-time specific configuration accessed during registering, 1235 * may be NULL 1236 * 1237 * Return: A pointer to newly allocated power_supply on success 1238 * or ERR_PTR otherwise. 1239 * Use power_supply_unregister() on returned power_supply pointer to release 1240 * resources. 1241 */ 1242 struct power_supply *__must_check power_supply_register(struct device *parent, 1243 const struct power_supply_desc *desc, 1244 const struct power_supply_config *cfg) 1245 { 1246 return __power_supply_register(parent, desc, cfg, true); 1247 } 1248 EXPORT_SYMBOL_GPL(power_supply_register); 1249 1250 /** 1251 * power_supply_register_no_ws() - Register new non-waking-source power supply 1252 * @parent: Device to be a parent of power supply's device, usually 1253 * the device which probe function calls this 1254 * @desc: Description of power supply, must be valid through whole 1255 * lifetime of this power supply 1256 * @cfg: Run-time specific configuration accessed during registering, 1257 * may be NULL 1258 * 1259 * Return: A pointer to newly allocated power_supply on success 1260 * or ERR_PTR otherwise. 1261 * Use power_supply_unregister() on returned power_supply pointer to release 1262 * resources. 1263 */ 1264 struct power_supply *__must_check 1265 power_supply_register_no_ws(struct device *parent, 1266 const struct power_supply_desc *desc, 1267 const struct power_supply_config *cfg) 1268 { 1269 return __power_supply_register(parent, desc, cfg, false); 1270 } 1271 EXPORT_SYMBOL_GPL(power_supply_register_no_ws); 1272 1273 static void devm_power_supply_release(struct device *dev, void *res) 1274 { 1275 struct power_supply **psy = res; 1276 1277 power_supply_unregister(*psy); 1278 } 1279 1280 /** 1281 * devm_power_supply_register() - Register managed power supply 1282 * @parent: Device to be a parent of power supply's device, usually 1283 * the device which probe function calls this 1284 * @desc: Description of power supply, must be valid through whole 1285 * lifetime of this power supply 1286 * @cfg: Run-time specific configuration accessed during registering, 1287 * may be NULL 1288 * 1289 * Return: A pointer to newly allocated power_supply on success 1290 * or ERR_PTR otherwise. 1291 * The returned power_supply pointer will be automatically unregistered 1292 * on driver detach. 1293 */ 1294 struct power_supply *__must_check 1295 devm_power_supply_register(struct device *parent, 1296 const struct power_supply_desc *desc, 1297 const struct power_supply_config *cfg) 1298 { 1299 struct power_supply **ptr, *psy; 1300 1301 ptr = devres_alloc(devm_power_supply_release, sizeof(*ptr), GFP_KERNEL); 1302 1303 if (!ptr) 1304 return ERR_PTR(-ENOMEM); 1305 psy = __power_supply_register(parent, desc, cfg, true); 1306 if (IS_ERR(psy)) { 1307 devres_free(ptr); 1308 } else { 1309 *ptr = psy; 1310 devres_add(parent, ptr); 1311 } 1312 return psy; 1313 } 1314 EXPORT_SYMBOL_GPL(devm_power_supply_register); 1315 1316 /** 1317 * devm_power_supply_register_no_ws() - Register managed non-waking-source power supply 1318 * @parent: Device to be a parent of power supply's device, usually 1319 * the device which probe function calls this 1320 * @desc: Description of power supply, must be valid through whole 1321 * lifetime of this power supply 1322 * @cfg: Run-time specific configuration accessed during registering, 1323 * may be NULL 1324 * 1325 * Return: A pointer to newly allocated power_supply on success 1326 * or ERR_PTR otherwise. 1327 * The returned power_supply pointer will be automatically unregistered 1328 * on driver detach. 1329 */ 1330 struct power_supply *__must_check 1331 devm_power_supply_register_no_ws(struct device *parent, 1332 const struct power_supply_desc *desc, 1333 const struct power_supply_config *cfg) 1334 { 1335 struct power_supply **ptr, *psy; 1336 1337 ptr = devres_alloc(devm_power_supply_release, sizeof(*ptr), GFP_KERNEL); 1338 1339 if (!ptr) 1340 return ERR_PTR(-ENOMEM); 1341 psy = __power_supply_register(parent, desc, cfg, false); 1342 if (IS_ERR(psy)) { 1343 devres_free(ptr); 1344 } else { 1345 *ptr = psy; 1346 devres_add(parent, ptr); 1347 } 1348 return psy; 1349 } 1350 EXPORT_SYMBOL_GPL(devm_power_supply_register_no_ws); 1351 1352 /** 1353 * power_supply_unregister() - Remove this power supply from system 1354 * @psy: Pointer to power supply to unregister 1355 * 1356 * Remove this power supply from the system. The resources of power supply 1357 * will be freed here or on last power_supply_put() call. 1358 */ 1359 void power_supply_unregister(struct power_supply *psy) 1360 { 1361 WARN_ON(atomic_dec_return(&psy->use_cnt)); 1362 psy->removing = true; 1363 cancel_work_sync(&psy->changed_work); 1364 cancel_delayed_work_sync(&psy->deferred_register_work); 1365 sysfs_remove_link(&psy->dev.kobj, "powers"); 1366 power_supply_remove_hwmon_sysfs(psy); 1367 power_supply_remove_triggers(psy); 1368 psy_unregister_cooler(psy); 1369 psy_unregister_thermal(psy); 1370 device_init_wakeup(&psy->dev, false); 1371 device_unregister(&psy->dev); 1372 } 1373 EXPORT_SYMBOL_GPL(power_supply_unregister); 1374 1375 void *power_supply_get_drvdata(struct power_supply *psy) 1376 { 1377 return psy->drv_data; 1378 } 1379 EXPORT_SYMBOL_GPL(power_supply_get_drvdata); 1380 1381 static int __init power_supply_class_init(void) 1382 { 1383 power_supply_class = class_create(THIS_MODULE, "power_supply"); 1384 1385 if (IS_ERR(power_supply_class)) 1386 return PTR_ERR(power_supply_class); 1387 1388 power_supply_class->dev_uevent = power_supply_uevent; 1389 power_supply_init_attrs(&power_supply_dev_type); 1390 1391 return 0; 1392 } 1393 1394 static void __exit power_supply_class_exit(void) 1395 { 1396 class_destroy(power_supply_class); 1397 } 1398 1399 subsys_initcall(power_supply_class_init); 1400 module_exit(power_supply_class_exit); 1401 1402 MODULE_DESCRIPTION("Universal power supply monitor class"); 1403 MODULE_AUTHOR("Ian Molton <spyro@f2s.com>, " 1404 "Szabolcs Gyurko, " 1405 "Anton Vorontsov <cbou@mail.ru>"); 1406 MODULE_LICENSE("GPL"); 1407