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 /* Out of capacity tables */ 857 if (!info->ocv_table[i]) 858 break; 859 860 temp_diff = abs(info->ocv_temp[i] - temp); 861 862 if (temp_diff < best_temp_diff) { 863 best_temp_diff = temp_diff; 864 best_index = i; 865 } 866 } 867 868 *table_len = info->ocv_table_size[best_index]; 869 return info->ocv_table[best_index]; 870 } 871 EXPORT_SYMBOL_GPL(power_supply_find_ocv2cap_table); 872 873 int power_supply_batinfo_ocv2cap(struct power_supply_battery_info *info, 874 int ocv, int temp) 875 { 876 struct power_supply_battery_ocv_table *table; 877 int table_len; 878 879 table = power_supply_find_ocv2cap_table(info, temp, &table_len); 880 if (!table) 881 return -EINVAL; 882 883 return power_supply_ocv2cap_simple(table, table_len, ocv); 884 } 885 EXPORT_SYMBOL_GPL(power_supply_batinfo_ocv2cap); 886 887 int power_supply_get_property(struct power_supply *psy, 888 enum power_supply_property psp, 889 union power_supply_propval *val) 890 { 891 if (atomic_read(&psy->use_cnt) <= 0) { 892 if (!psy->initialized) 893 return -EAGAIN; 894 return -ENODEV; 895 } 896 897 return psy->desc->get_property(psy, psp, val); 898 } 899 EXPORT_SYMBOL_GPL(power_supply_get_property); 900 901 int power_supply_set_property(struct power_supply *psy, 902 enum power_supply_property psp, 903 const union power_supply_propval *val) 904 { 905 if (atomic_read(&psy->use_cnt) <= 0 || !psy->desc->set_property) 906 return -ENODEV; 907 908 return psy->desc->set_property(psy, psp, val); 909 } 910 EXPORT_SYMBOL_GPL(power_supply_set_property); 911 912 int power_supply_property_is_writeable(struct power_supply *psy, 913 enum power_supply_property psp) 914 { 915 if (atomic_read(&psy->use_cnt) <= 0 || 916 !psy->desc->property_is_writeable) 917 return -ENODEV; 918 919 return psy->desc->property_is_writeable(psy, psp); 920 } 921 EXPORT_SYMBOL_GPL(power_supply_property_is_writeable); 922 923 void power_supply_external_power_changed(struct power_supply *psy) 924 { 925 if (atomic_read(&psy->use_cnt) <= 0 || 926 !psy->desc->external_power_changed) 927 return; 928 929 psy->desc->external_power_changed(psy); 930 } 931 EXPORT_SYMBOL_GPL(power_supply_external_power_changed); 932 933 int power_supply_powers(struct power_supply *psy, struct device *dev) 934 { 935 return sysfs_create_link(&psy->dev.kobj, &dev->kobj, "powers"); 936 } 937 EXPORT_SYMBOL_GPL(power_supply_powers); 938 939 static void power_supply_dev_release(struct device *dev) 940 { 941 struct power_supply *psy = to_power_supply(dev); 942 dev_dbg(dev, "%s\n", __func__); 943 kfree(psy); 944 } 945 946 int power_supply_reg_notifier(struct notifier_block *nb) 947 { 948 return atomic_notifier_chain_register(&power_supply_notifier, nb); 949 } 950 EXPORT_SYMBOL_GPL(power_supply_reg_notifier); 951 952 void power_supply_unreg_notifier(struct notifier_block *nb) 953 { 954 atomic_notifier_chain_unregister(&power_supply_notifier, nb); 955 } 956 EXPORT_SYMBOL_GPL(power_supply_unreg_notifier); 957 958 static bool psy_has_property(const struct power_supply_desc *psy_desc, 959 enum power_supply_property psp) 960 { 961 bool found = false; 962 int i; 963 964 for (i = 0; i < psy_desc->num_properties; i++) { 965 if (psy_desc->properties[i] == psp) { 966 found = true; 967 break; 968 } 969 } 970 971 return found; 972 } 973 974 #ifdef CONFIG_THERMAL 975 static int power_supply_read_temp(struct thermal_zone_device *tzd, 976 int *temp) 977 { 978 struct power_supply *psy; 979 union power_supply_propval val; 980 int ret; 981 982 WARN_ON(tzd == NULL); 983 psy = tzd->devdata; 984 ret = power_supply_get_property(psy, POWER_SUPPLY_PROP_TEMP, &val); 985 if (ret) 986 return ret; 987 988 /* Convert tenths of degree Celsius to milli degree Celsius. */ 989 *temp = val.intval * 100; 990 991 return ret; 992 } 993 994 static struct thermal_zone_device_ops psy_tzd_ops = { 995 .get_temp = power_supply_read_temp, 996 }; 997 998 static int psy_register_thermal(struct power_supply *psy) 999 { 1000 int ret; 1001 1002 if (psy->desc->no_thermal) 1003 return 0; 1004 1005 /* Register battery zone device psy reports temperature */ 1006 if (psy_has_property(psy->desc, POWER_SUPPLY_PROP_TEMP)) { 1007 psy->tzd = thermal_zone_device_register(psy->desc->name, 1008 0, 0, psy, &psy_tzd_ops, NULL, 0, 0); 1009 if (IS_ERR(psy->tzd)) 1010 return PTR_ERR(psy->tzd); 1011 ret = thermal_zone_device_enable(psy->tzd); 1012 if (ret) 1013 thermal_zone_device_unregister(psy->tzd); 1014 return ret; 1015 } 1016 1017 return 0; 1018 } 1019 1020 static void psy_unregister_thermal(struct power_supply *psy) 1021 { 1022 if (IS_ERR_OR_NULL(psy->tzd)) 1023 return; 1024 thermal_zone_device_unregister(psy->tzd); 1025 } 1026 1027 /* thermal cooling device callbacks */ 1028 static int ps_get_max_charge_cntl_limit(struct thermal_cooling_device *tcd, 1029 unsigned long *state) 1030 { 1031 struct power_supply *psy; 1032 union power_supply_propval val; 1033 int ret; 1034 1035 psy = tcd->devdata; 1036 ret = power_supply_get_property(psy, 1037 POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT_MAX, &val); 1038 if (ret) 1039 return ret; 1040 1041 *state = val.intval; 1042 1043 return ret; 1044 } 1045 1046 static int ps_get_cur_charge_cntl_limit(struct thermal_cooling_device *tcd, 1047 unsigned long *state) 1048 { 1049 struct power_supply *psy; 1050 union power_supply_propval val; 1051 int ret; 1052 1053 psy = tcd->devdata; 1054 ret = power_supply_get_property(psy, 1055 POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT, &val); 1056 if (ret) 1057 return ret; 1058 1059 *state = val.intval; 1060 1061 return ret; 1062 } 1063 1064 static int ps_set_cur_charge_cntl_limit(struct thermal_cooling_device *tcd, 1065 unsigned long state) 1066 { 1067 struct power_supply *psy; 1068 union power_supply_propval val; 1069 int ret; 1070 1071 psy = tcd->devdata; 1072 val.intval = state; 1073 ret = psy->desc->set_property(psy, 1074 POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT, &val); 1075 1076 return ret; 1077 } 1078 1079 static const struct thermal_cooling_device_ops psy_tcd_ops = { 1080 .get_max_state = ps_get_max_charge_cntl_limit, 1081 .get_cur_state = ps_get_cur_charge_cntl_limit, 1082 .set_cur_state = ps_set_cur_charge_cntl_limit, 1083 }; 1084 1085 static int psy_register_cooler(struct power_supply *psy) 1086 { 1087 /* Register for cooling device if psy can control charging */ 1088 if (psy_has_property(psy->desc, POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT)) { 1089 psy->tcd = thermal_cooling_device_register( 1090 (char *)psy->desc->name, 1091 psy, &psy_tcd_ops); 1092 return PTR_ERR_OR_ZERO(psy->tcd); 1093 } 1094 1095 return 0; 1096 } 1097 1098 static void psy_unregister_cooler(struct power_supply *psy) 1099 { 1100 if (IS_ERR_OR_NULL(psy->tcd)) 1101 return; 1102 thermal_cooling_device_unregister(psy->tcd); 1103 } 1104 #else 1105 static int psy_register_thermal(struct power_supply *psy) 1106 { 1107 return 0; 1108 } 1109 1110 static void psy_unregister_thermal(struct power_supply *psy) 1111 { 1112 } 1113 1114 static int psy_register_cooler(struct power_supply *psy) 1115 { 1116 return 0; 1117 } 1118 1119 static void psy_unregister_cooler(struct power_supply *psy) 1120 { 1121 } 1122 #endif 1123 1124 static struct power_supply *__must_check 1125 __power_supply_register(struct device *parent, 1126 const struct power_supply_desc *desc, 1127 const struct power_supply_config *cfg, 1128 bool ws) 1129 { 1130 struct device *dev; 1131 struct power_supply *psy; 1132 int rc; 1133 1134 if (!parent) 1135 pr_warn("%s: Expected proper parent device for '%s'\n", 1136 __func__, desc->name); 1137 1138 if (!desc || !desc->name || !desc->properties || !desc->num_properties) 1139 return ERR_PTR(-EINVAL); 1140 1141 if (psy_has_property(desc, POWER_SUPPLY_PROP_USB_TYPE) && 1142 (!desc->usb_types || !desc->num_usb_types)) 1143 return ERR_PTR(-EINVAL); 1144 1145 psy = kzalloc(sizeof(*psy), GFP_KERNEL); 1146 if (!psy) 1147 return ERR_PTR(-ENOMEM); 1148 1149 dev = &psy->dev; 1150 1151 device_initialize(dev); 1152 1153 dev->class = power_supply_class; 1154 dev->type = &power_supply_dev_type; 1155 dev->parent = parent; 1156 dev->release = power_supply_dev_release; 1157 dev_set_drvdata(dev, psy); 1158 psy->desc = desc; 1159 if (cfg) { 1160 dev->groups = cfg->attr_grp; 1161 psy->drv_data = cfg->drv_data; 1162 psy->of_node = 1163 cfg->fwnode ? to_of_node(cfg->fwnode) : cfg->of_node; 1164 psy->supplied_to = cfg->supplied_to; 1165 psy->num_supplicants = cfg->num_supplicants; 1166 } 1167 1168 rc = dev_set_name(dev, "%s", desc->name); 1169 if (rc) 1170 goto dev_set_name_failed; 1171 1172 INIT_WORK(&psy->changed_work, power_supply_changed_work); 1173 INIT_DELAYED_WORK(&psy->deferred_register_work, 1174 power_supply_deferred_register_work); 1175 1176 rc = power_supply_check_supplies(psy); 1177 if (rc) { 1178 dev_dbg(dev, "Not all required supplies found, defer probe\n"); 1179 goto check_supplies_failed; 1180 } 1181 1182 spin_lock_init(&psy->changed_lock); 1183 rc = device_add(dev); 1184 if (rc) 1185 goto device_add_failed; 1186 1187 rc = device_init_wakeup(dev, ws); 1188 if (rc) 1189 goto wakeup_init_failed; 1190 1191 rc = psy_register_thermal(psy); 1192 if (rc) 1193 goto register_thermal_failed; 1194 1195 rc = psy_register_cooler(psy); 1196 if (rc) 1197 goto register_cooler_failed; 1198 1199 rc = power_supply_create_triggers(psy); 1200 if (rc) 1201 goto create_triggers_failed; 1202 1203 rc = power_supply_add_hwmon_sysfs(psy); 1204 if (rc) 1205 goto add_hwmon_sysfs_failed; 1206 1207 /* 1208 * Update use_cnt after any uevents (most notably from device_add()). 1209 * We are here still during driver's probe but 1210 * the power_supply_uevent() calls back driver's get_property 1211 * method so: 1212 * 1. Driver did not assigned the returned struct power_supply, 1213 * 2. Driver could not finish initialization (anything in its probe 1214 * after calling power_supply_register()). 1215 */ 1216 atomic_inc(&psy->use_cnt); 1217 psy->initialized = true; 1218 1219 queue_delayed_work(system_power_efficient_wq, 1220 &psy->deferred_register_work, 1221 POWER_SUPPLY_DEFERRED_REGISTER_TIME); 1222 1223 return psy; 1224 1225 add_hwmon_sysfs_failed: 1226 power_supply_remove_triggers(psy); 1227 create_triggers_failed: 1228 psy_unregister_cooler(psy); 1229 register_cooler_failed: 1230 psy_unregister_thermal(psy); 1231 register_thermal_failed: 1232 device_del(dev); 1233 wakeup_init_failed: 1234 device_add_failed: 1235 check_supplies_failed: 1236 dev_set_name_failed: 1237 put_device(dev); 1238 return ERR_PTR(rc); 1239 } 1240 1241 /** 1242 * power_supply_register() - Register new power supply 1243 * @parent: Device to be a parent of power supply's device, usually 1244 * the device which probe function calls this 1245 * @desc: Description of power supply, must be valid through whole 1246 * lifetime of this power supply 1247 * @cfg: Run-time specific configuration accessed during registering, 1248 * may be NULL 1249 * 1250 * Return: A pointer to newly allocated power_supply on success 1251 * or ERR_PTR otherwise. 1252 * Use power_supply_unregister() on returned power_supply pointer to release 1253 * resources. 1254 */ 1255 struct power_supply *__must_check power_supply_register(struct device *parent, 1256 const struct power_supply_desc *desc, 1257 const struct power_supply_config *cfg) 1258 { 1259 return __power_supply_register(parent, desc, cfg, true); 1260 } 1261 EXPORT_SYMBOL_GPL(power_supply_register); 1262 1263 /** 1264 * power_supply_register_no_ws() - Register new non-waking-source power supply 1265 * @parent: Device to be a parent of power supply's device, usually 1266 * the device which probe function calls this 1267 * @desc: Description of power supply, must be valid through whole 1268 * lifetime of this power supply 1269 * @cfg: Run-time specific configuration accessed during registering, 1270 * may be NULL 1271 * 1272 * Return: A pointer to newly allocated power_supply on success 1273 * or ERR_PTR otherwise. 1274 * Use power_supply_unregister() on returned power_supply pointer to release 1275 * resources. 1276 */ 1277 struct power_supply *__must_check 1278 power_supply_register_no_ws(struct device *parent, 1279 const struct power_supply_desc *desc, 1280 const struct power_supply_config *cfg) 1281 { 1282 return __power_supply_register(parent, desc, cfg, false); 1283 } 1284 EXPORT_SYMBOL_GPL(power_supply_register_no_ws); 1285 1286 static void devm_power_supply_release(struct device *dev, void *res) 1287 { 1288 struct power_supply **psy = res; 1289 1290 power_supply_unregister(*psy); 1291 } 1292 1293 /** 1294 * devm_power_supply_register() - Register managed power supply 1295 * @parent: Device to be a parent of power supply's device, usually 1296 * the device which probe function calls this 1297 * @desc: Description of power supply, must be valid through whole 1298 * lifetime of this power supply 1299 * @cfg: Run-time specific configuration accessed during registering, 1300 * may be NULL 1301 * 1302 * Return: A pointer to newly allocated power_supply on success 1303 * or ERR_PTR otherwise. 1304 * The returned power_supply pointer will be automatically unregistered 1305 * on driver detach. 1306 */ 1307 struct power_supply *__must_check 1308 devm_power_supply_register(struct device *parent, 1309 const struct power_supply_desc *desc, 1310 const struct power_supply_config *cfg) 1311 { 1312 struct power_supply **ptr, *psy; 1313 1314 ptr = devres_alloc(devm_power_supply_release, sizeof(*ptr), GFP_KERNEL); 1315 1316 if (!ptr) 1317 return ERR_PTR(-ENOMEM); 1318 psy = __power_supply_register(parent, desc, cfg, true); 1319 if (IS_ERR(psy)) { 1320 devres_free(ptr); 1321 } else { 1322 *ptr = psy; 1323 devres_add(parent, ptr); 1324 } 1325 return psy; 1326 } 1327 EXPORT_SYMBOL_GPL(devm_power_supply_register); 1328 1329 /** 1330 * devm_power_supply_register_no_ws() - Register managed non-waking-source power supply 1331 * @parent: Device to be a parent of power supply's device, usually 1332 * the device which probe function calls this 1333 * @desc: Description of power supply, must be valid through whole 1334 * lifetime of this power supply 1335 * @cfg: Run-time specific configuration accessed during registering, 1336 * may be NULL 1337 * 1338 * Return: A pointer to newly allocated power_supply on success 1339 * or ERR_PTR otherwise. 1340 * The returned power_supply pointer will be automatically unregistered 1341 * on driver detach. 1342 */ 1343 struct power_supply *__must_check 1344 devm_power_supply_register_no_ws(struct device *parent, 1345 const struct power_supply_desc *desc, 1346 const struct power_supply_config *cfg) 1347 { 1348 struct power_supply **ptr, *psy; 1349 1350 ptr = devres_alloc(devm_power_supply_release, sizeof(*ptr), GFP_KERNEL); 1351 1352 if (!ptr) 1353 return ERR_PTR(-ENOMEM); 1354 psy = __power_supply_register(parent, desc, cfg, false); 1355 if (IS_ERR(psy)) { 1356 devres_free(ptr); 1357 } else { 1358 *ptr = psy; 1359 devres_add(parent, ptr); 1360 } 1361 return psy; 1362 } 1363 EXPORT_SYMBOL_GPL(devm_power_supply_register_no_ws); 1364 1365 /** 1366 * power_supply_unregister() - Remove this power supply from system 1367 * @psy: Pointer to power supply to unregister 1368 * 1369 * Remove this power supply from the system. The resources of power supply 1370 * will be freed here or on last power_supply_put() call. 1371 */ 1372 void power_supply_unregister(struct power_supply *psy) 1373 { 1374 WARN_ON(atomic_dec_return(&psy->use_cnt)); 1375 psy->removing = true; 1376 cancel_work_sync(&psy->changed_work); 1377 cancel_delayed_work_sync(&psy->deferred_register_work); 1378 sysfs_remove_link(&psy->dev.kobj, "powers"); 1379 power_supply_remove_hwmon_sysfs(psy); 1380 power_supply_remove_triggers(psy); 1381 psy_unregister_cooler(psy); 1382 psy_unregister_thermal(psy); 1383 device_init_wakeup(&psy->dev, false); 1384 device_unregister(&psy->dev); 1385 } 1386 EXPORT_SYMBOL_GPL(power_supply_unregister); 1387 1388 void *power_supply_get_drvdata(struct power_supply *psy) 1389 { 1390 return psy->drv_data; 1391 } 1392 EXPORT_SYMBOL_GPL(power_supply_get_drvdata); 1393 1394 static int __init power_supply_class_init(void) 1395 { 1396 power_supply_class = class_create(THIS_MODULE, "power_supply"); 1397 1398 if (IS_ERR(power_supply_class)) 1399 return PTR_ERR(power_supply_class); 1400 1401 power_supply_class->dev_uevent = power_supply_uevent; 1402 power_supply_init_attrs(&power_supply_dev_type); 1403 1404 return 0; 1405 } 1406 1407 static void __exit power_supply_class_exit(void) 1408 { 1409 class_destroy(power_supply_class); 1410 } 1411 1412 subsys_initcall(power_supply_class_init); 1413 module_exit(power_supply_class_exit); 1414 1415 MODULE_DESCRIPTION("Universal power supply monitor class"); 1416 MODULE_AUTHOR("Ian Molton <spyro@f2s.com>, " 1417 "Szabolcs Gyurko, " 1418 "Anton Vorontsov <cbou@mail.ru>"); 1419 MODULE_LICENSE("GPL"); 1420