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_info(&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->energy_full_design_uwh = -EINVAL; 575 info->charge_full_design_uah = -EINVAL; 576 info->voltage_min_design_uv = -EINVAL; 577 info->voltage_max_design_uv = -EINVAL; 578 info->precharge_current_ua = -EINVAL; 579 info->charge_term_current_ua = -EINVAL; 580 info->constant_charge_current_max_ua = -EINVAL; 581 info->constant_charge_voltage_max_uv = -EINVAL; 582 info->temp_ambient_alert_min = INT_MIN; 583 info->temp_ambient_alert_max = INT_MAX; 584 info->temp_alert_min = INT_MIN; 585 info->temp_alert_max = INT_MAX; 586 info->temp_min = INT_MIN; 587 info->temp_max = INT_MAX; 588 info->factory_internal_resistance_uohm = -EINVAL; 589 info->resist_table = NULL; 590 591 for (index = 0; index < POWER_SUPPLY_OCV_TEMP_MAX; index++) { 592 info->ocv_table[index] = NULL; 593 info->ocv_temp[index] = -EINVAL; 594 info->ocv_table_size[index] = -EINVAL; 595 } 596 597 if (!psy->of_node) { 598 dev_warn(&psy->dev, "%s currently only supports devicetree\n", 599 __func__); 600 return -ENXIO; 601 } 602 603 battery_np = of_parse_phandle(psy->of_node, "monitored-battery", 0); 604 if (!battery_np) 605 return -ENODEV; 606 607 err = of_property_read_string(battery_np, "compatible", &value); 608 if (err) 609 goto out_put_node; 610 611 if (strcmp("simple-battery", value)) { 612 err = -ENODEV; 613 goto out_put_node; 614 } 615 616 /* The property and field names below must correspond to elements 617 * in enum power_supply_property. For reasoning, see 618 * Documentation/power/power_supply_class.rst. 619 */ 620 621 of_property_read_u32(battery_np, "energy-full-design-microwatt-hours", 622 &info->energy_full_design_uwh); 623 of_property_read_u32(battery_np, "charge-full-design-microamp-hours", 624 &info->charge_full_design_uah); 625 of_property_read_u32(battery_np, "voltage-min-design-microvolt", 626 &info->voltage_min_design_uv); 627 of_property_read_u32(battery_np, "voltage-max-design-microvolt", 628 &info->voltage_max_design_uv); 629 of_property_read_u32(battery_np, "trickle-charge-current-microamp", 630 &info->tricklecharge_current_ua); 631 of_property_read_u32(battery_np, "precharge-current-microamp", 632 &info->precharge_current_ua); 633 of_property_read_u32(battery_np, "precharge-upper-limit-microvolt", 634 &info->precharge_voltage_max_uv); 635 of_property_read_u32(battery_np, "charge-term-current-microamp", 636 &info->charge_term_current_ua); 637 of_property_read_u32(battery_np, "re-charge-voltage-microvolt", 638 &info->charge_restart_voltage_uv); 639 of_property_read_u32(battery_np, "over-voltage-threshold-microvolt", 640 &info->overvoltage_limit_uv); 641 of_property_read_u32(battery_np, "constant-charge-current-max-microamp", 642 &info->constant_charge_current_max_ua); 643 of_property_read_u32(battery_np, "constant-charge-voltage-max-microvolt", 644 &info->constant_charge_voltage_max_uv); 645 of_property_read_u32(battery_np, "factory-internal-resistance-micro-ohms", 646 &info->factory_internal_resistance_uohm); 647 648 of_property_read_u32_index(battery_np, "ambient-celsius", 649 0, &info->temp_ambient_alert_min); 650 of_property_read_u32_index(battery_np, "ambient-celsius", 651 1, &info->temp_ambient_alert_max); 652 of_property_read_u32_index(battery_np, "alert-celsius", 653 0, &info->temp_alert_min); 654 of_property_read_u32_index(battery_np, "alert-celsius", 655 1, &info->temp_alert_max); 656 of_property_read_u32_index(battery_np, "operating-range-celsius", 657 0, &info->temp_min); 658 of_property_read_u32_index(battery_np, "operating-range-celsius", 659 1, &info->temp_max); 660 661 len = of_property_count_u32_elems(battery_np, "ocv-capacity-celsius"); 662 if (len < 0 && len != -EINVAL) { 663 err = len; 664 goto out_put_node; 665 } else if (len > POWER_SUPPLY_OCV_TEMP_MAX) { 666 dev_err(&psy->dev, "Too many temperature values\n"); 667 err = -EINVAL; 668 goto out_put_node; 669 } else if (len > 0) { 670 of_property_read_u32_array(battery_np, "ocv-capacity-celsius", 671 info->ocv_temp, len); 672 } 673 674 for (index = 0; index < len; index++) { 675 struct power_supply_battery_ocv_table *table; 676 char *propname; 677 int i, tab_len, size; 678 679 propname = kasprintf(GFP_KERNEL, "ocv-capacity-table-%d", index); 680 list = of_get_property(battery_np, propname, &size); 681 if (!list || !size) { 682 dev_err(&psy->dev, "failed to get %s\n", propname); 683 kfree(propname); 684 power_supply_put_battery_info(psy, info); 685 err = -EINVAL; 686 goto out_put_node; 687 } 688 689 kfree(propname); 690 tab_len = size / (2 * sizeof(__be32)); 691 info->ocv_table_size[index] = tab_len; 692 693 table = info->ocv_table[index] = 694 devm_kcalloc(&psy->dev, tab_len, sizeof(*table), GFP_KERNEL); 695 if (!info->ocv_table[index]) { 696 power_supply_put_battery_info(psy, info); 697 err = -ENOMEM; 698 goto out_put_node; 699 } 700 701 for (i = 0; i < tab_len; i++) { 702 table[i].ocv = be32_to_cpu(*list); 703 list++; 704 table[i].capacity = be32_to_cpu(*list); 705 list++; 706 } 707 } 708 709 list = of_get_property(battery_np, "resistance-temp-table", &len); 710 if (!list || !len) 711 goto out_put_node; 712 713 info->resist_table_size = len / (2 * sizeof(__be32)); 714 resist_table = info->resist_table = devm_kcalloc(&psy->dev, 715 info->resist_table_size, 716 sizeof(*resist_table), 717 GFP_KERNEL); 718 if (!info->resist_table) { 719 power_supply_put_battery_info(psy, info); 720 err = -ENOMEM; 721 goto out_put_node; 722 } 723 724 for (index = 0; index < info->resist_table_size; index++) { 725 resist_table[index].temp = be32_to_cpu(*list++); 726 resist_table[index].resistance = be32_to_cpu(*list++); 727 } 728 729 out_put_node: 730 of_node_put(battery_np); 731 return err; 732 } 733 EXPORT_SYMBOL_GPL(power_supply_get_battery_info); 734 735 void power_supply_put_battery_info(struct power_supply *psy, 736 struct power_supply_battery_info *info) 737 { 738 int i; 739 740 for (i = 0; i < POWER_SUPPLY_OCV_TEMP_MAX; i++) { 741 if (info->ocv_table[i]) 742 devm_kfree(&psy->dev, info->ocv_table[i]); 743 } 744 745 if (info->resist_table) 746 devm_kfree(&psy->dev, info->resist_table); 747 } 748 EXPORT_SYMBOL_GPL(power_supply_put_battery_info); 749 750 /** 751 * power_supply_temp2resist_simple() - find the battery internal resistance 752 * percent 753 * @table: Pointer to battery resistance temperature table 754 * @table_len: The table length 755 * @temp: Current temperature 756 * 757 * This helper function is used to look up battery internal resistance percent 758 * according to current temperature value from the resistance temperature table, 759 * and the table must be ordered descending. Then the actual battery internal 760 * resistance = the ideal battery internal resistance * percent / 100. 761 * 762 * Return: the battery internal resistance percent 763 */ 764 int power_supply_temp2resist_simple(struct power_supply_resistance_temp_table *table, 765 int table_len, int temp) 766 { 767 int i, resist; 768 769 for (i = 0; i < table_len; i++) 770 if (temp > table[i].temp) 771 break; 772 773 if (i > 0 && i < table_len) { 774 int tmp; 775 776 tmp = (table[i - 1].resistance - table[i].resistance) * 777 (temp - table[i].temp); 778 tmp /= table[i - 1].temp - table[i].temp; 779 resist = tmp + table[i].resistance; 780 } else if (i == 0) { 781 resist = table[0].resistance; 782 } else { 783 resist = table[table_len - 1].resistance; 784 } 785 786 return resist; 787 } 788 EXPORT_SYMBOL_GPL(power_supply_temp2resist_simple); 789 790 /** 791 * power_supply_ocv2cap_simple() - find the battery capacity 792 * @table: Pointer to battery OCV lookup table 793 * @table_len: OCV table length 794 * @ocv: Current OCV value 795 * 796 * This helper function is used to look up battery capacity according to 797 * current OCV value from one OCV table, and the OCV table must be ordered 798 * descending. 799 * 800 * Return: the battery capacity. 801 */ 802 int power_supply_ocv2cap_simple(struct power_supply_battery_ocv_table *table, 803 int table_len, int ocv) 804 { 805 int i, cap, tmp; 806 807 for (i = 0; i < table_len; i++) 808 if (ocv > table[i].ocv) 809 break; 810 811 if (i > 0 && i < table_len) { 812 tmp = (table[i - 1].capacity - table[i].capacity) * 813 (ocv - table[i].ocv); 814 tmp /= table[i - 1].ocv - table[i].ocv; 815 cap = tmp + table[i].capacity; 816 } else if (i == 0) { 817 cap = table[0].capacity; 818 } else { 819 cap = table[table_len - 1].capacity; 820 } 821 822 return cap; 823 } 824 EXPORT_SYMBOL_GPL(power_supply_ocv2cap_simple); 825 826 struct power_supply_battery_ocv_table * 827 power_supply_find_ocv2cap_table(struct power_supply_battery_info *info, 828 int temp, int *table_len) 829 { 830 int best_temp_diff = INT_MAX, temp_diff; 831 u8 i, best_index = 0; 832 833 if (!info->ocv_table[0]) 834 return NULL; 835 836 for (i = 0; i < POWER_SUPPLY_OCV_TEMP_MAX; i++) { 837 temp_diff = abs(info->ocv_temp[i] - temp); 838 839 if (temp_diff < best_temp_diff) { 840 best_temp_diff = temp_diff; 841 best_index = i; 842 } 843 } 844 845 *table_len = info->ocv_table_size[best_index]; 846 return info->ocv_table[best_index]; 847 } 848 EXPORT_SYMBOL_GPL(power_supply_find_ocv2cap_table); 849 850 int power_supply_batinfo_ocv2cap(struct power_supply_battery_info *info, 851 int ocv, int temp) 852 { 853 struct power_supply_battery_ocv_table *table; 854 int table_len; 855 856 table = power_supply_find_ocv2cap_table(info, temp, &table_len); 857 if (!table) 858 return -EINVAL; 859 860 return power_supply_ocv2cap_simple(table, table_len, ocv); 861 } 862 EXPORT_SYMBOL_GPL(power_supply_batinfo_ocv2cap); 863 864 int power_supply_get_property(struct power_supply *psy, 865 enum power_supply_property psp, 866 union power_supply_propval *val) 867 { 868 if (atomic_read(&psy->use_cnt) <= 0) { 869 if (!psy->initialized) 870 return -EAGAIN; 871 return -ENODEV; 872 } 873 874 return psy->desc->get_property(psy, psp, val); 875 } 876 EXPORT_SYMBOL_GPL(power_supply_get_property); 877 878 int power_supply_set_property(struct power_supply *psy, 879 enum power_supply_property psp, 880 const union power_supply_propval *val) 881 { 882 if (atomic_read(&psy->use_cnt) <= 0 || !psy->desc->set_property) 883 return -ENODEV; 884 885 return psy->desc->set_property(psy, psp, val); 886 } 887 EXPORT_SYMBOL_GPL(power_supply_set_property); 888 889 int power_supply_property_is_writeable(struct power_supply *psy, 890 enum power_supply_property psp) 891 { 892 if (atomic_read(&psy->use_cnt) <= 0 || 893 !psy->desc->property_is_writeable) 894 return -ENODEV; 895 896 return psy->desc->property_is_writeable(psy, psp); 897 } 898 EXPORT_SYMBOL_GPL(power_supply_property_is_writeable); 899 900 void power_supply_external_power_changed(struct power_supply *psy) 901 { 902 if (atomic_read(&psy->use_cnt) <= 0 || 903 !psy->desc->external_power_changed) 904 return; 905 906 psy->desc->external_power_changed(psy); 907 } 908 EXPORT_SYMBOL_GPL(power_supply_external_power_changed); 909 910 int power_supply_powers(struct power_supply *psy, struct device *dev) 911 { 912 return sysfs_create_link(&psy->dev.kobj, &dev->kobj, "powers"); 913 } 914 EXPORT_SYMBOL_GPL(power_supply_powers); 915 916 static void power_supply_dev_release(struct device *dev) 917 { 918 struct power_supply *psy = to_power_supply(dev); 919 dev_dbg(dev, "%s\n", __func__); 920 kfree(psy); 921 } 922 923 int power_supply_reg_notifier(struct notifier_block *nb) 924 { 925 return atomic_notifier_chain_register(&power_supply_notifier, nb); 926 } 927 EXPORT_SYMBOL_GPL(power_supply_reg_notifier); 928 929 void power_supply_unreg_notifier(struct notifier_block *nb) 930 { 931 atomic_notifier_chain_unregister(&power_supply_notifier, nb); 932 } 933 EXPORT_SYMBOL_GPL(power_supply_unreg_notifier); 934 935 #ifdef CONFIG_THERMAL 936 static int power_supply_read_temp(struct thermal_zone_device *tzd, 937 int *temp) 938 { 939 struct power_supply *psy; 940 union power_supply_propval val; 941 int ret; 942 943 WARN_ON(tzd == NULL); 944 psy = tzd->devdata; 945 ret = power_supply_get_property(psy, POWER_SUPPLY_PROP_TEMP, &val); 946 if (ret) 947 return ret; 948 949 /* Convert tenths of degree Celsius to milli degree Celsius. */ 950 *temp = val.intval * 100; 951 952 return ret; 953 } 954 955 static struct thermal_zone_device_ops psy_tzd_ops = { 956 .get_temp = power_supply_read_temp, 957 }; 958 959 static int psy_register_thermal(struct power_supply *psy) 960 { 961 int i, ret; 962 963 if (psy->desc->no_thermal) 964 return 0; 965 966 /* Register battery zone device psy reports temperature */ 967 for (i = 0; i < psy->desc->num_properties; i++) { 968 if (psy->desc->properties[i] == POWER_SUPPLY_PROP_TEMP) { 969 psy->tzd = thermal_zone_device_register(psy->desc->name, 970 0, 0, psy, &psy_tzd_ops, NULL, 0, 0); 971 if (IS_ERR(psy->tzd)) 972 return PTR_ERR(psy->tzd); 973 ret = thermal_zone_device_enable(psy->tzd); 974 if (ret) 975 thermal_zone_device_unregister(psy->tzd); 976 return ret; 977 } 978 } 979 return 0; 980 } 981 982 static void psy_unregister_thermal(struct power_supply *psy) 983 { 984 if (IS_ERR_OR_NULL(psy->tzd)) 985 return; 986 thermal_zone_device_unregister(psy->tzd); 987 } 988 989 /* thermal cooling device callbacks */ 990 static int ps_get_max_charge_cntl_limit(struct thermal_cooling_device *tcd, 991 unsigned long *state) 992 { 993 struct power_supply *psy; 994 union power_supply_propval val; 995 int ret; 996 997 psy = tcd->devdata; 998 ret = power_supply_get_property(psy, 999 POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT_MAX, &val); 1000 if (ret) 1001 return ret; 1002 1003 *state = val.intval; 1004 1005 return ret; 1006 } 1007 1008 static int ps_get_cur_charge_cntl_limit(struct thermal_cooling_device *tcd, 1009 unsigned long *state) 1010 { 1011 struct power_supply *psy; 1012 union power_supply_propval val; 1013 int ret; 1014 1015 psy = tcd->devdata; 1016 ret = power_supply_get_property(psy, 1017 POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT, &val); 1018 if (ret) 1019 return ret; 1020 1021 *state = val.intval; 1022 1023 return ret; 1024 } 1025 1026 static int ps_set_cur_charge_cntl_limit(struct thermal_cooling_device *tcd, 1027 unsigned long state) 1028 { 1029 struct power_supply *psy; 1030 union power_supply_propval val; 1031 int ret; 1032 1033 psy = tcd->devdata; 1034 val.intval = state; 1035 ret = psy->desc->set_property(psy, 1036 POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT, &val); 1037 1038 return ret; 1039 } 1040 1041 static const struct thermal_cooling_device_ops psy_tcd_ops = { 1042 .get_max_state = ps_get_max_charge_cntl_limit, 1043 .get_cur_state = ps_get_cur_charge_cntl_limit, 1044 .set_cur_state = ps_set_cur_charge_cntl_limit, 1045 }; 1046 1047 static int psy_register_cooler(struct power_supply *psy) 1048 { 1049 int i; 1050 1051 /* Register for cooling device if psy can control charging */ 1052 for (i = 0; i < psy->desc->num_properties; i++) { 1053 if (psy->desc->properties[i] == 1054 POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT) { 1055 psy->tcd = thermal_cooling_device_register( 1056 (char *)psy->desc->name, 1057 psy, &psy_tcd_ops); 1058 return PTR_ERR_OR_ZERO(psy->tcd); 1059 } 1060 } 1061 return 0; 1062 } 1063 1064 static void psy_unregister_cooler(struct power_supply *psy) 1065 { 1066 if (IS_ERR_OR_NULL(psy->tcd)) 1067 return; 1068 thermal_cooling_device_unregister(psy->tcd); 1069 } 1070 #else 1071 static int psy_register_thermal(struct power_supply *psy) 1072 { 1073 return 0; 1074 } 1075 1076 static void psy_unregister_thermal(struct power_supply *psy) 1077 { 1078 } 1079 1080 static int psy_register_cooler(struct power_supply *psy) 1081 { 1082 return 0; 1083 } 1084 1085 static void psy_unregister_cooler(struct power_supply *psy) 1086 { 1087 } 1088 #endif 1089 1090 static struct power_supply *__must_check 1091 __power_supply_register(struct device *parent, 1092 const struct power_supply_desc *desc, 1093 const struct power_supply_config *cfg, 1094 bool ws) 1095 { 1096 struct device *dev; 1097 struct power_supply *psy; 1098 int i, rc; 1099 1100 if (!parent) 1101 pr_warn("%s: Expected proper parent device for '%s'\n", 1102 __func__, desc->name); 1103 1104 if (!desc || !desc->name || !desc->properties || !desc->num_properties) 1105 return ERR_PTR(-EINVAL); 1106 1107 for (i = 0; i < desc->num_properties; ++i) { 1108 if ((desc->properties[i] == POWER_SUPPLY_PROP_USB_TYPE) && 1109 (!desc->usb_types || !desc->num_usb_types)) 1110 return ERR_PTR(-EINVAL); 1111 } 1112 1113 psy = kzalloc(sizeof(*psy), GFP_KERNEL); 1114 if (!psy) 1115 return ERR_PTR(-ENOMEM); 1116 1117 dev = &psy->dev; 1118 1119 device_initialize(dev); 1120 1121 dev->class = power_supply_class; 1122 dev->type = &power_supply_dev_type; 1123 dev->parent = parent; 1124 dev->release = power_supply_dev_release; 1125 dev_set_drvdata(dev, psy); 1126 psy->desc = desc; 1127 if (cfg) { 1128 dev->groups = cfg->attr_grp; 1129 psy->drv_data = cfg->drv_data; 1130 psy->of_node = 1131 cfg->fwnode ? to_of_node(cfg->fwnode) : cfg->of_node; 1132 psy->supplied_to = cfg->supplied_to; 1133 psy->num_supplicants = cfg->num_supplicants; 1134 } 1135 1136 rc = dev_set_name(dev, "%s", desc->name); 1137 if (rc) 1138 goto dev_set_name_failed; 1139 1140 INIT_WORK(&psy->changed_work, power_supply_changed_work); 1141 INIT_DELAYED_WORK(&psy->deferred_register_work, 1142 power_supply_deferred_register_work); 1143 1144 rc = power_supply_check_supplies(psy); 1145 if (rc) { 1146 dev_info(dev, "Not all required supplies found, defer probe\n"); 1147 goto check_supplies_failed; 1148 } 1149 1150 spin_lock_init(&psy->changed_lock); 1151 rc = device_add(dev); 1152 if (rc) 1153 goto device_add_failed; 1154 1155 rc = device_init_wakeup(dev, ws); 1156 if (rc) 1157 goto wakeup_init_failed; 1158 1159 rc = psy_register_thermal(psy); 1160 if (rc) 1161 goto register_thermal_failed; 1162 1163 rc = psy_register_cooler(psy); 1164 if (rc) 1165 goto register_cooler_failed; 1166 1167 rc = power_supply_create_triggers(psy); 1168 if (rc) 1169 goto create_triggers_failed; 1170 1171 rc = power_supply_add_hwmon_sysfs(psy); 1172 if (rc) 1173 goto add_hwmon_sysfs_failed; 1174 1175 /* 1176 * Update use_cnt after any uevents (most notably from device_add()). 1177 * We are here still during driver's probe but 1178 * the power_supply_uevent() calls back driver's get_property 1179 * method so: 1180 * 1. Driver did not assigned the returned struct power_supply, 1181 * 2. Driver could not finish initialization (anything in its probe 1182 * after calling power_supply_register()). 1183 */ 1184 atomic_inc(&psy->use_cnt); 1185 psy->initialized = true; 1186 1187 queue_delayed_work(system_power_efficient_wq, 1188 &psy->deferred_register_work, 1189 POWER_SUPPLY_DEFERRED_REGISTER_TIME); 1190 1191 return psy; 1192 1193 add_hwmon_sysfs_failed: 1194 power_supply_remove_triggers(psy); 1195 create_triggers_failed: 1196 psy_unregister_cooler(psy); 1197 register_cooler_failed: 1198 psy_unregister_thermal(psy); 1199 register_thermal_failed: 1200 device_del(dev); 1201 wakeup_init_failed: 1202 device_add_failed: 1203 check_supplies_failed: 1204 dev_set_name_failed: 1205 put_device(dev); 1206 return ERR_PTR(rc); 1207 } 1208 1209 /** 1210 * power_supply_register() - Register new power supply 1211 * @parent: Device to be a parent of power supply's device, usually 1212 * the device which probe function calls this 1213 * @desc: Description of power supply, must be valid through whole 1214 * lifetime of this power supply 1215 * @cfg: Run-time specific configuration accessed during registering, 1216 * may be NULL 1217 * 1218 * Return: A pointer to newly allocated power_supply on success 1219 * or ERR_PTR otherwise. 1220 * Use power_supply_unregister() on returned power_supply pointer to release 1221 * resources. 1222 */ 1223 struct power_supply *__must_check power_supply_register(struct device *parent, 1224 const struct power_supply_desc *desc, 1225 const struct power_supply_config *cfg) 1226 { 1227 return __power_supply_register(parent, desc, cfg, true); 1228 } 1229 EXPORT_SYMBOL_GPL(power_supply_register); 1230 1231 /** 1232 * power_supply_register_no_ws() - Register new non-waking-source power supply 1233 * @parent: Device to be a parent of power supply's device, usually 1234 * the device which probe function calls this 1235 * @desc: Description of power supply, must be valid through whole 1236 * lifetime of this power supply 1237 * @cfg: Run-time specific configuration accessed during registering, 1238 * may be NULL 1239 * 1240 * Return: A pointer to newly allocated power_supply on success 1241 * or ERR_PTR otherwise. 1242 * Use power_supply_unregister() on returned power_supply pointer to release 1243 * resources. 1244 */ 1245 struct power_supply *__must_check 1246 power_supply_register_no_ws(struct device *parent, 1247 const struct power_supply_desc *desc, 1248 const struct power_supply_config *cfg) 1249 { 1250 return __power_supply_register(parent, desc, cfg, false); 1251 } 1252 EXPORT_SYMBOL_GPL(power_supply_register_no_ws); 1253 1254 static void devm_power_supply_release(struct device *dev, void *res) 1255 { 1256 struct power_supply **psy = res; 1257 1258 power_supply_unregister(*psy); 1259 } 1260 1261 /** 1262 * devm_power_supply_register() - Register managed power supply 1263 * @parent: Device to be a parent of power supply's device, usually 1264 * the device which probe function calls this 1265 * @desc: Description of power supply, must be valid through whole 1266 * lifetime of this power supply 1267 * @cfg: Run-time specific configuration accessed during registering, 1268 * may be NULL 1269 * 1270 * Return: A pointer to newly allocated power_supply on success 1271 * or ERR_PTR otherwise. 1272 * The returned power_supply pointer will be automatically unregistered 1273 * on driver detach. 1274 */ 1275 struct power_supply *__must_check 1276 devm_power_supply_register(struct device *parent, 1277 const struct power_supply_desc *desc, 1278 const struct power_supply_config *cfg) 1279 { 1280 struct power_supply **ptr, *psy; 1281 1282 ptr = devres_alloc(devm_power_supply_release, sizeof(*ptr), GFP_KERNEL); 1283 1284 if (!ptr) 1285 return ERR_PTR(-ENOMEM); 1286 psy = __power_supply_register(parent, desc, cfg, true); 1287 if (IS_ERR(psy)) { 1288 devres_free(ptr); 1289 } else { 1290 *ptr = psy; 1291 devres_add(parent, ptr); 1292 } 1293 return psy; 1294 } 1295 EXPORT_SYMBOL_GPL(devm_power_supply_register); 1296 1297 /** 1298 * devm_power_supply_register_no_ws() - Register managed non-waking-source power supply 1299 * @parent: Device to be a parent of power supply's device, usually 1300 * the device which probe function calls this 1301 * @desc: Description of power supply, must be valid through whole 1302 * lifetime of this power supply 1303 * @cfg: Run-time specific configuration accessed during registering, 1304 * may be NULL 1305 * 1306 * Return: A pointer to newly allocated power_supply on success 1307 * or ERR_PTR otherwise. 1308 * The returned power_supply pointer will be automatically unregistered 1309 * on driver detach. 1310 */ 1311 struct power_supply *__must_check 1312 devm_power_supply_register_no_ws(struct device *parent, 1313 const struct power_supply_desc *desc, 1314 const struct power_supply_config *cfg) 1315 { 1316 struct power_supply **ptr, *psy; 1317 1318 ptr = devres_alloc(devm_power_supply_release, sizeof(*ptr), GFP_KERNEL); 1319 1320 if (!ptr) 1321 return ERR_PTR(-ENOMEM); 1322 psy = __power_supply_register(parent, desc, cfg, false); 1323 if (IS_ERR(psy)) { 1324 devres_free(ptr); 1325 } else { 1326 *ptr = psy; 1327 devres_add(parent, ptr); 1328 } 1329 return psy; 1330 } 1331 EXPORT_SYMBOL_GPL(devm_power_supply_register_no_ws); 1332 1333 /** 1334 * power_supply_unregister() - Remove this power supply from system 1335 * @psy: Pointer to power supply to unregister 1336 * 1337 * Remove this power supply from the system. The resources of power supply 1338 * will be freed here or on last power_supply_put() call. 1339 */ 1340 void power_supply_unregister(struct power_supply *psy) 1341 { 1342 WARN_ON(atomic_dec_return(&psy->use_cnt)); 1343 psy->removing = true; 1344 cancel_work_sync(&psy->changed_work); 1345 cancel_delayed_work_sync(&psy->deferred_register_work); 1346 sysfs_remove_link(&psy->dev.kobj, "powers"); 1347 power_supply_remove_hwmon_sysfs(psy); 1348 power_supply_remove_triggers(psy); 1349 psy_unregister_cooler(psy); 1350 psy_unregister_thermal(psy); 1351 device_init_wakeup(&psy->dev, false); 1352 device_unregister(&psy->dev); 1353 } 1354 EXPORT_SYMBOL_GPL(power_supply_unregister); 1355 1356 void *power_supply_get_drvdata(struct power_supply *psy) 1357 { 1358 return psy->drv_data; 1359 } 1360 EXPORT_SYMBOL_GPL(power_supply_get_drvdata); 1361 1362 static int __init power_supply_class_init(void) 1363 { 1364 power_supply_class = class_create(THIS_MODULE, "power_supply"); 1365 1366 if (IS_ERR(power_supply_class)) 1367 return PTR_ERR(power_supply_class); 1368 1369 power_supply_class->dev_uevent = power_supply_uevent; 1370 power_supply_init_attrs(&power_supply_dev_type); 1371 1372 return 0; 1373 } 1374 1375 static void __exit power_supply_class_exit(void) 1376 { 1377 class_destroy(power_supply_class); 1378 } 1379 1380 subsys_initcall(power_supply_class_init); 1381 module_exit(power_supply_class_exit); 1382 1383 MODULE_DESCRIPTION("Universal power supply monitor class"); 1384 MODULE_AUTHOR("Ian Molton <spyro@f2s.com>, " 1385 "Szabolcs Gyurko, " 1386 "Anton Vorontsov <cbou@mail.ru>"); 1387 MODULE_LICENSE("GPL"); 1388