1// SPDX-License-Identifier: GPL-2.0-only 2/* 3 * Copyright (C) 2011 Samsung Electronics Co., Ltd. 4 * MyungJoo Ham <myungjoo.ham@samsung.com> 5 * 6 * This driver enables to monitor battery health and control charger 7 * during suspend-to-mem. 8 * Charger manager depends on other devices. Register this later than 9 * the depending devices. 10 * 11**/ 12 13#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 14 15#include <linux/io.h> 16#include <linux/module.h> 17#include <linux/irq.h> 18#include <linux/interrupt.h> 19#include <linux/rtc.h> 20#include <linux/slab.h> 21#include <linux/workqueue.h> 22#include <linux/platform_device.h> 23#include <linux/power/charger-manager.h> 24#include <linux/regulator/consumer.h> 25#include <linux/sysfs.h> 26#include <linux/of.h> 27#include <linux/thermal.h> 28 29static struct { 30 const char *name; 31 u64 extcon_type; 32} extcon_mapping[] = { 33 /* Current textual representations */ 34 { "USB", EXTCON_USB }, 35 { "USB-HOST", EXTCON_USB_HOST }, 36 { "SDP", EXTCON_CHG_USB_SDP }, 37 { "DCP", EXTCON_CHG_USB_DCP }, 38 { "CDP", EXTCON_CHG_USB_CDP }, 39 { "ACA", EXTCON_CHG_USB_ACA }, 40 { "FAST-CHARGER", EXTCON_CHG_USB_FAST }, 41 { "SLOW-CHARGER", EXTCON_CHG_USB_SLOW }, 42 { "WPT", EXTCON_CHG_WPT }, 43 { "PD", EXTCON_CHG_USB_PD }, 44 { "DOCK", EXTCON_DOCK }, 45 { "JIG", EXTCON_JIG }, 46 { "MECHANICAL", EXTCON_MECHANICAL }, 47 /* Deprecated textual representations */ 48 { "TA", EXTCON_CHG_USB_SDP }, 49 { "CHARGE-DOWNSTREAM", EXTCON_CHG_USB_CDP }, 50}; 51 52/* 53 * Default temperature threshold for charging. 54 * Every temperature units are in tenth of centigrade. 55 */ 56#define CM_DEFAULT_RECHARGE_TEMP_DIFF 50 57#define CM_DEFAULT_CHARGE_TEMP_MAX 500 58 59/* 60 * Regard CM_JIFFIES_SMALL jiffies is small enough to ignore for 61 * delayed works so that we can run delayed works with CM_JIFFIES_SMALL 62 * without any delays. 63 */ 64#define CM_JIFFIES_SMALL (2) 65 66/* If y is valid (> 0) and smaller than x, do x = y */ 67#define CM_MIN_VALID(x, y) x = (((y > 0) && ((x) > (y))) ? (y) : (x)) 68 69/* 70 * Regard CM_RTC_SMALL (sec) is small enough to ignore error in invoking 71 * rtc alarm. It should be 2 or larger 72 */ 73#define CM_RTC_SMALL (2) 74 75static LIST_HEAD(cm_list); 76static DEFINE_MUTEX(cm_list_mtx); 77 78/* About in-suspend (suspend-again) monitoring */ 79static struct alarm *cm_timer; 80 81static bool cm_suspended; 82static bool cm_timer_set; 83static unsigned long cm_suspend_duration_ms; 84 85/* About normal (not suspended) monitoring */ 86static unsigned long polling_jiffy = ULONG_MAX; /* ULONG_MAX: no polling */ 87static unsigned long next_polling; /* Next appointed polling time */ 88static struct workqueue_struct *cm_wq; /* init at driver add */ 89static struct delayed_work cm_monitor_work; /* init at driver add */ 90 91/** 92 * is_batt_present - See if the battery presents in place. 93 * @cm: the Charger Manager representing the battery. 94 */ 95static bool is_batt_present(struct charger_manager *cm) 96{ 97 union power_supply_propval val; 98 struct power_supply *psy; 99 bool present = false; 100 int i, ret; 101 102 switch (cm->desc->battery_present) { 103 case CM_BATTERY_PRESENT: 104 present = true; 105 break; 106 case CM_NO_BATTERY: 107 break; 108 case CM_FUEL_GAUGE: 109 psy = power_supply_get_by_name(cm->desc->psy_fuel_gauge); 110 if (!psy) 111 break; 112 113 ret = power_supply_get_property(psy, POWER_SUPPLY_PROP_PRESENT, 114 &val); 115 if (ret == 0 && val.intval) 116 present = true; 117 power_supply_put(psy); 118 break; 119 case CM_CHARGER_STAT: 120 for (i = 0; cm->desc->psy_charger_stat[i]; i++) { 121 psy = power_supply_get_by_name( 122 cm->desc->psy_charger_stat[i]); 123 if (!psy) { 124 dev_err(cm->dev, "Cannot find power supply \"%s\"\n", 125 cm->desc->psy_charger_stat[i]); 126 continue; 127 } 128 129 ret = power_supply_get_property(psy, 130 POWER_SUPPLY_PROP_PRESENT, &val); 131 power_supply_put(psy); 132 if (ret == 0 && val.intval) { 133 present = true; 134 break; 135 } 136 } 137 break; 138 } 139 140 return present; 141} 142 143/** 144 * is_ext_pwr_online - See if an external power source is attached to charge 145 * @cm: the Charger Manager representing the battery. 146 * 147 * Returns true if at least one of the chargers of the battery has an external 148 * power source attached to charge the battery regardless of whether it is 149 * actually charging or not. 150 */ 151static bool is_ext_pwr_online(struct charger_manager *cm) 152{ 153 union power_supply_propval val; 154 struct power_supply *psy; 155 bool online = false; 156 int i, ret; 157 158 /* If at least one of them has one, it's yes. */ 159 for (i = 0; cm->desc->psy_charger_stat[i]; i++) { 160 psy = power_supply_get_by_name(cm->desc->psy_charger_stat[i]); 161 if (!psy) { 162 dev_err(cm->dev, "Cannot find power supply \"%s\"\n", 163 cm->desc->psy_charger_stat[i]); 164 continue; 165 } 166 167 ret = power_supply_get_property(psy, POWER_SUPPLY_PROP_ONLINE, 168 &val); 169 power_supply_put(psy); 170 if (ret == 0 && val.intval) { 171 online = true; 172 break; 173 } 174 } 175 176 return online; 177} 178 179/** 180 * get_batt_uV - Get the voltage level of the battery 181 * @cm: the Charger Manager representing the battery. 182 * @uV: the voltage level returned. 183 * 184 * Returns 0 if there is no error. 185 * Returns a negative value on error. 186 */ 187static int get_batt_uV(struct charger_manager *cm, int *uV) 188{ 189 union power_supply_propval val; 190 struct power_supply *fuel_gauge; 191 int ret; 192 193 fuel_gauge = power_supply_get_by_name(cm->desc->psy_fuel_gauge); 194 if (!fuel_gauge) 195 return -ENODEV; 196 197 ret = power_supply_get_property(fuel_gauge, 198 POWER_SUPPLY_PROP_VOLTAGE_NOW, &val); 199 power_supply_put(fuel_gauge); 200 if (ret) 201 return ret; 202 203 *uV = val.intval; 204 return 0; 205} 206 207/** 208 * is_charging - Returns true if the battery is being charged. 209 * @cm: the Charger Manager representing the battery. 210 */ 211static bool is_charging(struct charger_manager *cm) 212{ 213 int i, ret; 214 bool charging = false; 215 struct power_supply *psy; 216 union power_supply_propval val; 217 218 /* If there is no battery, it cannot be charged */ 219 if (!is_batt_present(cm)) 220 return false; 221 222 /* If at least one of the charger is charging, return yes */ 223 for (i = 0; cm->desc->psy_charger_stat[i]; i++) { 224 /* 1. The charger sholuld not be DISABLED */ 225 if (cm->emergency_stop) 226 continue; 227 if (!cm->charger_enabled) 228 continue; 229 230 psy = power_supply_get_by_name(cm->desc->psy_charger_stat[i]); 231 if (!psy) { 232 dev_err(cm->dev, "Cannot find power supply \"%s\"\n", 233 cm->desc->psy_charger_stat[i]); 234 continue; 235 } 236 237 /* 2. The charger should be online (ext-power) */ 238 ret = power_supply_get_property(psy, POWER_SUPPLY_PROP_ONLINE, 239 &val); 240 if (ret) { 241 dev_warn(cm->dev, "Cannot read ONLINE value from %s\n", 242 cm->desc->psy_charger_stat[i]); 243 power_supply_put(psy); 244 continue; 245 } 246 if (val.intval == 0) { 247 power_supply_put(psy); 248 continue; 249 } 250 251 /* 252 * 3. The charger should not be FULL, DISCHARGING, 253 * or NOT_CHARGING. 254 */ 255 ret = power_supply_get_property(psy, POWER_SUPPLY_PROP_STATUS, 256 &val); 257 power_supply_put(psy); 258 if (ret) { 259 dev_warn(cm->dev, "Cannot read STATUS value from %s\n", 260 cm->desc->psy_charger_stat[i]); 261 continue; 262 } 263 if (val.intval == POWER_SUPPLY_STATUS_FULL || 264 val.intval == POWER_SUPPLY_STATUS_DISCHARGING || 265 val.intval == POWER_SUPPLY_STATUS_NOT_CHARGING) 266 continue; 267 268 /* Then, this is charging. */ 269 charging = true; 270 break; 271 } 272 273 return charging; 274} 275 276/** 277 * is_full_charged - Returns true if the battery is fully charged. 278 * @cm: the Charger Manager representing the battery. 279 */ 280static bool is_full_charged(struct charger_manager *cm) 281{ 282 struct charger_desc *desc = cm->desc; 283 union power_supply_propval val; 284 struct power_supply *fuel_gauge; 285 bool is_full = false; 286 int ret = 0; 287 int uV; 288 289 /* If there is no battery, it cannot be charged */ 290 if (!is_batt_present(cm)) 291 return false; 292 293 fuel_gauge = power_supply_get_by_name(cm->desc->psy_fuel_gauge); 294 if (!fuel_gauge) 295 return false; 296 297 /* Full, if it's over the fullbatt voltage */ 298 if (desc->fullbatt_uV > 0) { 299 ret = get_batt_uV(cm, &uV); 300 if (!ret) { 301 /* Battery is already full, checks voltage drop. */ 302 if (cm->battery_status == POWER_SUPPLY_STATUS_FULL 303 && desc->fullbatt_vchkdrop_uV) 304 uV += desc->fullbatt_vchkdrop_uV; 305 if (uV >= desc->fullbatt_uV) 306 return true; 307 } 308 } 309 310 if (desc->fullbatt_full_capacity > 0) { 311 val.intval = 0; 312 313 /* Not full if capacity of fuel gauge isn't full */ 314 ret = power_supply_get_property(fuel_gauge, 315 POWER_SUPPLY_PROP_CHARGE_FULL, &val); 316 if (!ret && val.intval > desc->fullbatt_full_capacity) { 317 is_full = true; 318 goto out; 319 } 320 } 321 322 /* Full, if the capacity is more than fullbatt_soc */ 323 if (desc->fullbatt_soc > 0) { 324 val.intval = 0; 325 326 ret = power_supply_get_property(fuel_gauge, 327 POWER_SUPPLY_PROP_CAPACITY, &val); 328 if (!ret && val.intval >= desc->fullbatt_soc) { 329 is_full = true; 330 goto out; 331 } 332 } 333 334out: 335 power_supply_put(fuel_gauge); 336 return is_full; 337} 338 339/** 340 * is_polling_required - Return true if need to continue polling for this CM. 341 * @cm: the Charger Manager representing the battery. 342 */ 343static bool is_polling_required(struct charger_manager *cm) 344{ 345 switch (cm->desc->polling_mode) { 346 case CM_POLL_DISABLE: 347 return false; 348 case CM_POLL_ALWAYS: 349 return true; 350 case CM_POLL_EXTERNAL_POWER_ONLY: 351 return is_ext_pwr_online(cm); 352 case CM_POLL_CHARGING_ONLY: 353 return is_charging(cm); 354 default: 355 dev_warn(cm->dev, "Incorrect polling_mode (%d)\n", 356 cm->desc->polling_mode); 357 } 358 359 return false; 360} 361 362/** 363 * try_charger_enable - Enable/Disable chargers altogether 364 * @cm: the Charger Manager representing the battery. 365 * @enable: true: enable / false: disable 366 * 367 * Note that Charger Manager keeps the charger enabled regardless whether 368 * the charger is charging or not (because battery is full or no external 369 * power source exists) except when CM needs to disable chargers forcibly 370 * because of emergency causes; when the battery is overheated or too cold. 371 */ 372static int try_charger_enable(struct charger_manager *cm, bool enable) 373{ 374 int err = 0, i; 375 struct charger_desc *desc = cm->desc; 376 377 /* Ignore if it's redundant command */ 378 if (enable == cm->charger_enabled) 379 return 0; 380 381 if (enable) { 382 if (cm->emergency_stop) 383 return -EAGAIN; 384 385 /* 386 * Save start time of charging to limit 387 * maximum possible charging time. 388 */ 389 cm->charging_start_time = ktime_to_ms(ktime_get()); 390 cm->charging_end_time = 0; 391 392 for (i = 0 ; i < desc->num_charger_regulators ; i++) { 393 if (desc->charger_regulators[i].externally_control) 394 continue; 395 396 err = regulator_enable(desc->charger_regulators[i].consumer); 397 if (err < 0) { 398 dev_warn(cm->dev, "Cannot enable %s regulator\n", 399 desc->charger_regulators[i].regulator_name); 400 } 401 } 402 } else { 403 /* 404 * Save end time of charging to maintain fully charged state 405 * of battery after full-batt. 406 */ 407 cm->charging_start_time = 0; 408 cm->charging_end_time = ktime_to_ms(ktime_get()); 409 410 for (i = 0 ; i < desc->num_charger_regulators ; i++) { 411 if (desc->charger_regulators[i].externally_control) 412 continue; 413 414 err = regulator_disable(desc->charger_regulators[i].consumer); 415 if (err < 0) { 416 dev_warn(cm->dev, "Cannot disable %s regulator\n", 417 desc->charger_regulators[i].regulator_name); 418 } 419 } 420 421 /* 422 * Abnormal battery state - Stop charging forcibly, 423 * even if charger was enabled at the other places 424 */ 425 for (i = 0; i < desc->num_charger_regulators; i++) { 426 if (regulator_is_enabled( 427 desc->charger_regulators[i].consumer)) { 428 regulator_force_disable( 429 desc->charger_regulators[i].consumer); 430 dev_warn(cm->dev, "Disable regulator(%s) forcibly\n", 431 desc->charger_regulators[i].regulator_name); 432 } 433 } 434 } 435 436 if (!err) 437 cm->charger_enabled = enable; 438 439 return err; 440} 441 442/** 443 * check_charging_duration - Monitor charging/discharging duration 444 * @cm: the Charger Manager representing the battery. 445 * 446 * If whole charging duration exceed 'charging_max_duration_ms', 447 * cm stop charging to prevent overcharge/overheat. If discharging 448 * duration exceed 'discharging _max_duration_ms', charger cable is 449 * attached, after full-batt, cm start charging to maintain fully 450 * charged state for battery. 451 */ 452static int check_charging_duration(struct charger_manager *cm) 453{ 454 struct charger_desc *desc = cm->desc; 455 u64 curr = ktime_to_ms(ktime_get()); 456 u64 duration; 457 int ret = false; 458 459 if (!desc->charging_max_duration_ms && 460 !desc->discharging_max_duration_ms) 461 return ret; 462 463 if (cm->charger_enabled) { 464 duration = curr - cm->charging_start_time; 465 466 if (duration > desc->charging_max_duration_ms) { 467 dev_info(cm->dev, "Charging duration exceed %ums\n", 468 desc->charging_max_duration_ms); 469 ret = true; 470 } 471 } else if (cm->battery_status == POWER_SUPPLY_STATUS_NOT_CHARGING) { 472 duration = curr - cm->charging_end_time; 473 474 if (duration > desc->discharging_max_duration_ms) { 475 dev_info(cm->dev, "Discharging duration exceed %ums\n", 476 desc->discharging_max_duration_ms); 477 ret = true; 478 } 479 } 480 481 return ret; 482} 483 484static int cm_get_battery_temperature_by_psy(struct charger_manager *cm, 485 int *temp) 486{ 487 struct power_supply *fuel_gauge; 488 int ret; 489 490 fuel_gauge = power_supply_get_by_name(cm->desc->psy_fuel_gauge); 491 if (!fuel_gauge) 492 return -ENODEV; 493 494 ret = power_supply_get_property(fuel_gauge, 495 POWER_SUPPLY_PROP_TEMP, 496 (union power_supply_propval *)temp); 497 power_supply_put(fuel_gauge); 498 499 return ret; 500} 501 502static int cm_get_battery_temperature(struct charger_manager *cm, 503 int *temp) 504{ 505 int ret; 506 507 if (!cm->desc->measure_battery_temp) 508 return -ENODEV; 509 510#ifdef CONFIG_THERMAL 511 if (cm->tzd_batt) { 512 ret = thermal_zone_get_temp(cm->tzd_batt, temp); 513 if (!ret) 514 /* Calibrate temperature unit */ 515 *temp /= 100; 516 } else 517#endif 518 { 519 /* if-else continued from CONFIG_THERMAL */ 520 ret = cm_get_battery_temperature_by_psy(cm, temp); 521 } 522 523 return ret; 524} 525 526static int cm_check_thermal_status(struct charger_manager *cm) 527{ 528 struct charger_desc *desc = cm->desc; 529 int temp, upper_limit, lower_limit; 530 int ret = 0; 531 532 ret = cm_get_battery_temperature(cm, &temp); 533 if (ret) { 534 /* FIXME: 535 * No information of battery temperature might 536 * occur hazardous result. We have to handle it 537 * depending on battery type. 538 */ 539 dev_err(cm->dev, "Failed to get battery temperature\n"); 540 return 0; 541 } 542 543 upper_limit = desc->temp_max; 544 lower_limit = desc->temp_min; 545 546 if (cm->emergency_stop) { 547 upper_limit -= desc->temp_diff; 548 lower_limit += desc->temp_diff; 549 } 550 551 if (temp > upper_limit) 552 ret = CM_BATT_OVERHEAT; 553 else if (temp < lower_limit) 554 ret = CM_BATT_COLD; 555 else 556 ret = CM_BATT_OK; 557 558 cm->emergency_stop = ret; 559 560 return ret; 561} 562 563/** 564 * cm_get_target_status - Check current status and get next target status. 565 * @cm: the Charger Manager representing the battery. 566 */ 567static int cm_get_target_status(struct charger_manager *cm) 568{ 569 if (!is_ext_pwr_online(cm)) 570 return POWER_SUPPLY_STATUS_DISCHARGING; 571 572 if (cm_check_thermal_status(cm)) { 573 /* Check if discharging duration exceeds limit. */ 574 if (check_charging_duration(cm)) 575 goto charging_ok; 576 return POWER_SUPPLY_STATUS_NOT_CHARGING; 577 } 578 579 switch (cm->battery_status) { 580 case POWER_SUPPLY_STATUS_CHARGING: 581 /* Check if charging duration exceeds limit. */ 582 if (check_charging_duration(cm)) 583 return POWER_SUPPLY_STATUS_FULL; 584 fallthrough; 585 case POWER_SUPPLY_STATUS_FULL: 586 if (is_full_charged(cm)) 587 return POWER_SUPPLY_STATUS_FULL; 588 fallthrough; 589 default: 590 break; 591 } 592 593charging_ok: 594 /* Charging is allowed. */ 595 return POWER_SUPPLY_STATUS_CHARGING; 596} 597 598/** 599 * _cm_monitor - Monitor the temperature and return true for exceptions. 600 * @cm: the Charger Manager representing the battery. 601 * 602 * Returns true if there is an event to notify for the battery. 603 * (True if the status of "emergency_stop" changes) 604 */ 605static bool _cm_monitor(struct charger_manager *cm) 606{ 607 int target; 608 609 target = cm_get_target_status(cm); 610 611 try_charger_enable(cm, (target == POWER_SUPPLY_STATUS_CHARGING)); 612 613 if (cm->battery_status != target) { 614 cm->battery_status = target; 615 power_supply_changed(cm->charger_psy); 616 } 617 618 return (cm->battery_status == POWER_SUPPLY_STATUS_NOT_CHARGING); 619} 620 621/** 622 * cm_monitor - Monitor every battery. 623 * 624 * Returns true if there is an event to notify from any of the batteries. 625 * (True if the status of "emergency_stop" changes) 626 */ 627static bool cm_monitor(void) 628{ 629 bool stop = false; 630 struct charger_manager *cm; 631 632 mutex_lock(&cm_list_mtx); 633 634 list_for_each_entry(cm, &cm_list, entry) { 635 if (_cm_monitor(cm)) 636 stop = true; 637 } 638 639 mutex_unlock(&cm_list_mtx); 640 641 return stop; 642} 643 644/** 645 * _setup_polling - Setup the next instance of polling. 646 * @work: work_struct of the function _setup_polling. 647 */ 648static void _setup_polling(struct work_struct *work) 649{ 650 unsigned long min = ULONG_MAX; 651 struct charger_manager *cm; 652 bool keep_polling = false; 653 unsigned long _next_polling; 654 655 mutex_lock(&cm_list_mtx); 656 657 list_for_each_entry(cm, &cm_list, entry) { 658 if (is_polling_required(cm) && cm->desc->polling_interval_ms) { 659 keep_polling = true; 660 661 if (min > cm->desc->polling_interval_ms) 662 min = cm->desc->polling_interval_ms; 663 } 664 } 665 666 polling_jiffy = msecs_to_jiffies(min); 667 if (polling_jiffy <= CM_JIFFIES_SMALL) 668 polling_jiffy = CM_JIFFIES_SMALL + 1; 669 670 if (!keep_polling) 671 polling_jiffy = ULONG_MAX; 672 if (polling_jiffy == ULONG_MAX) 673 goto out; 674 675 WARN(cm_wq == NULL, "charger-manager: workqueue not initialized" 676 ". try it later. %s\n", __func__); 677 678 /* 679 * Use mod_delayed_work() iff the next polling interval should 680 * occur before the currently scheduled one. If @cm_monitor_work 681 * isn't active, the end result is the same, so no need to worry 682 * about stale @next_polling. 683 */ 684 _next_polling = jiffies + polling_jiffy; 685 686 if (time_before(_next_polling, next_polling)) { 687 mod_delayed_work(cm_wq, &cm_monitor_work, polling_jiffy); 688 next_polling = _next_polling; 689 } else { 690 if (queue_delayed_work(cm_wq, &cm_monitor_work, polling_jiffy)) 691 next_polling = _next_polling; 692 } 693out: 694 mutex_unlock(&cm_list_mtx); 695} 696static DECLARE_WORK(setup_polling, _setup_polling); 697 698/** 699 * cm_monitor_poller - The Monitor / Poller. 700 * @work: work_struct of the function cm_monitor_poller 701 * 702 * During non-suspended state, cm_monitor_poller is used to poll and monitor 703 * the batteries. 704 */ 705static void cm_monitor_poller(struct work_struct *work) 706{ 707 cm_monitor(); 708 schedule_work(&setup_polling); 709} 710 711static int charger_get_property(struct power_supply *psy, 712 enum power_supply_property psp, 713 union power_supply_propval *val) 714{ 715 struct charger_manager *cm = power_supply_get_drvdata(psy); 716 struct charger_desc *desc = cm->desc; 717 struct power_supply *fuel_gauge = NULL; 718 int ret = 0; 719 int uV; 720 721 switch (psp) { 722 case POWER_SUPPLY_PROP_STATUS: 723 val->intval = cm->battery_status; 724 break; 725 case POWER_SUPPLY_PROP_HEALTH: 726 if (cm->emergency_stop == CM_BATT_OVERHEAT) 727 val->intval = POWER_SUPPLY_HEALTH_OVERHEAT; 728 else if (cm->emergency_stop == CM_BATT_COLD) 729 val->intval = POWER_SUPPLY_HEALTH_COLD; 730 else 731 val->intval = POWER_SUPPLY_HEALTH_GOOD; 732 break; 733 case POWER_SUPPLY_PROP_PRESENT: 734 if (is_batt_present(cm)) 735 val->intval = 1; 736 else 737 val->intval = 0; 738 break; 739 case POWER_SUPPLY_PROP_VOLTAGE_NOW: 740 ret = get_batt_uV(cm, &val->intval); 741 break; 742 case POWER_SUPPLY_PROP_CURRENT_NOW: 743 fuel_gauge = power_supply_get_by_name(cm->desc->psy_fuel_gauge); 744 if (!fuel_gauge) { 745 ret = -ENODEV; 746 break; 747 } 748 ret = power_supply_get_property(fuel_gauge, 749 POWER_SUPPLY_PROP_CURRENT_NOW, val); 750 break; 751 case POWER_SUPPLY_PROP_TEMP: 752 return cm_get_battery_temperature(cm, &val->intval); 753 case POWER_SUPPLY_PROP_CAPACITY: 754 if (!is_batt_present(cm)) { 755 /* There is no battery. Assume 100% */ 756 val->intval = 100; 757 break; 758 } 759 760 fuel_gauge = power_supply_get_by_name(cm->desc->psy_fuel_gauge); 761 if (!fuel_gauge) { 762 ret = -ENODEV; 763 break; 764 } 765 766 ret = power_supply_get_property(fuel_gauge, 767 POWER_SUPPLY_PROP_CAPACITY, val); 768 if (ret) 769 break; 770 771 if (val->intval > 100) { 772 val->intval = 100; 773 break; 774 } 775 if (val->intval < 0) 776 val->intval = 0; 777 778 /* Do not adjust SOC when charging: voltage is overrated */ 779 if (is_charging(cm)) 780 break; 781 782 /* 783 * If the capacity value is inconsistent, calibrate it base on 784 * the battery voltage values and the thresholds given as desc 785 */ 786 ret = get_batt_uV(cm, &uV); 787 if (ret) { 788 /* Voltage information not available. No calibration */ 789 ret = 0; 790 break; 791 } 792 793 if (desc->fullbatt_uV > 0 && uV >= desc->fullbatt_uV && 794 !is_charging(cm)) { 795 val->intval = 100; 796 break; 797 } 798 799 break; 800 case POWER_SUPPLY_PROP_ONLINE: 801 if (is_ext_pwr_online(cm)) 802 val->intval = 1; 803 else 804 val->intval = 0; 805 break; 806 case POWER_SUPPLY_PROP_CHARGE_FULL: 807 case POWER_SUPPLY_PROP_CHARGE_NOW: 808 fuel_gauge = power_supply_get_by_name(cm->desc->psy_fuel_gauge); 809 if (!fuel_gauge) { 810 ret = -ENODEV; 811 break; 812 } 813 ret = power_supply_get_property(fuel_gauge, psp, val); 814 break; 815 default: 816 return -EINVAL; 817 } 818 if (fuel_gauge) 819 power_supply_put(fuel_gauge); 820 return ret; 821} 822 823#define NUM_CHARGER_PSY_OPTIONAL (4) 824static enum power_supply_property default_charger_props[] = { 825 /* Guaranteed to provide */ 826 POWER_SUPPLY_PROP_STATUS, 827 POWER_SUPPLY_PROP_HEALTH, 828 POWER_SUPPLY_PROP_PRESENT, 829 POWER_SUPPLY_PROP_VOLTAGE_NOW, 830 POWER_SUPPLY_PROP_CAPACITY, 831 POWER_SUPPLY_PROP_ONLINE, 832 /* 833 * Optional properties are: 834 * POWER_SUPPLY_PROP_CHARGE_FULL, 835 * POWER_SUPPLY_PROP_CHARGE_NOW, 836 * POWER_SUPPLY_PROP_CURRENT_NOW, 837 * POWER_SUPPLY_PROP_TEMP, 838 */ 839}; 840 841static const struct power_supply_desc psy_default = { 842 .name = "battery", 843 .type = POWER_SUPPLY_TYPE_BATTERY, 844 .properties = default_charger_props, 845 .num_properties = ARRAY_SIZE(default_charger_props), 846 .get_property = charger_get_property, 847 .no_thermal = true, 848}; 849 850/** 851 * cm_setup_timer - For in-suspend monitoring setup wakeup alarm 852 * for suspend_again. 853 * 854 * Returns true if the alarm is set for Charger Manager to use. 855 * Returns false if 856 * cm_setup_timer fails to set an alarm, 857 * cm_setup_timer does not need to set an alarm for Charger Manager, 858 * or an alarm previously configured is to be used. 859 */ 860static bool cm_setup_timer(void) 861{ 862 struct charger_manager *cm; 863 unsigned int wakeup_ms = UINT_MAX; 864 int timer_req = 0; 865 866 if (time_after(next_polling, jiffies)) 867 CM_MIN_VALID(wakeup_ms, 868 jiffies_to_msecs(next_polling - jiffies)); 869 870 mutex_lock(&cm_list_mtx); 871 list_for_each_entry(cm, &cm_list, entry) { 872 /* Skip if polling is not required for this CM */ 873 if (!is_polling_required(cm) && !cm->emergency_stop) 874 continue; 875 timer_req++; 876 if (cm->desc->polling_interval_ms == 0) 877 continue; 878 CM_MIN_VALID(wakeup_ms, cm->desc->polling_interval_ms); 879 } 880 mutex_unlock(&cm_list_mtx); 881 882 if (timer_req && cm_timer) { 883 ktime_t now, add; 884 885 /* 886 * Set alarm with the polling interval (wakeup_ms) 887 * The alarm time should be NOW + CM_RTC_SMALL or later. 888 */ 889 if (wakeup_ms == UINT_MAX || 890 wakeup_ms < CM_RTC_SMALL * MSEC_PER_SEC) 891 wakeup_ms = 2 * CM_RTC_SMALL * MSEC_PER_SEC; 892 893 pr_info("Charger Manager wakeup timer: %u ms\n", wakeup_ms); 894 895 now = ktime_get_boottime(); 896 add = ktime_set(wakeup_ms / MSEC_PER_SEC, 897 (wakeup_ms % MSEC_PER_SEC) * NSEC_PER_MSEC); 898 alarm_start(cm_timer, ktime_add(now, add)); 899 900 cm_suspend_duration_ms = wakeup_ms; 901 902 return true; 903 } 904 return false; 905} 906 907/** 908 * charger_extcon_work - enable/diable charger according to the state 909 * of charger cable 910 * 911 * @work: work_struct of the function charger_extcon_work. 912 */ 913static void charger_extcon_work(struct work_struct *work) 914{ 915 struct charger_cable *cable = 916 container_of(work, struct charger_cable, wq); 917 int ret; 918 919 if (cable->attached && cable->min_uA != 0 && cable->max_uA != 0) { 920 ret = regulator_set_current_limit(cable->charger->consumer, 921 cable->min_uA, cable->max_uA); 922 if (ret < 0) { 923 pr_err("Cannot set current limit of %s (%s)\n", 924 cable->charger->regulator_name, cable->name); 925 return; 926 } 927 928 pr_info("Set current limit of %s : %duA ~ %duA\n", 929 cable->charger->regulator_name, 930 cable->min_uA, cable->max_uA); 931 } 932 933 cancel_delayed_work(&cm_monitor_work); 934 queue_delayed_work(cm_wq, &cm_monitor_work, 0); 935} 936 937/** 938 * charger_extcon_notifier - receive the state of charger cable 939 * when registered cable is attached or detached. 940 * 941 * @self: the notifier block of the charger_extcon_notifier. 942 * @event: the cable state. 943 * @ptr: the data pointer of notifier block. 944 */ 945static int charger_extcon_notifier(struct notifier_block *self, 946 unsigned long event, void *ptr) 947{ 948 struct charger_cable *cable = 949 container_of(self, struct charger_cable, nb); 950 951 /* 952 * The newly state of charger cable. 953 * If cable is attached, cable->attached is true. 954 */ 955 cable->attached = event; 956 957 /* 958 * Setup work for controlling charger(regulator) 959 * according to charger cable. 960 */ 961 schedule_work(&cable->wq); 962 963 return NOTIFY_DONE; 964} 965 966/** 967 * charger_extcon_init - register external connector to use it 968 * as the charger cable 969 * 970 * @cm: the Charger Manager representing the battery. 971 * @cable: the Charger cable representing the external connector. 972 */ 973static int charger_extcon_init(struct charger_manager *cm, 974 struct charger_cable *cable) 975{ 976 int ret, i; 977 u64 extcon_type = EXTCON_NONE; 978 979 /* 980 * Charger manager use Extcon framework to identify 981 * the charger cable among various external connector 982 * cable (e.g., TA, USB, MHL, Dock). 983 */ 984 INIT_WORK(&cable->wq, charger_extcon_work); 985 cable->nb.notifier_call = charger_extcon_notifier; 986 987 cable->extcon_dev = extcon_get_extcon_dev(cable->extcon_name); 988 if (IS_ERR(cable->extcon_dev)) { 989 pr_err("Cannot find extcon_dev for %s (cable: %s)\n", 990 cable->extcon_name, cable->name); 991 return PTR_ERR(cable->extcon_dev); 992 } 993 994 for (i = 0; i < ARRAY_SIZE(extcon_mapping); i++) { 995 if (!strcmp(cable->name, extcon_mapping[i].name)) { 996 extcon_type = extcon_mapping[i].extcon_type; 997 break; 998 } 999 } 1000 if (extcon_type == EXTCON_NONE) { 1001 pr_err("Cannot find cable for type %s", cable->name); 1002 return -EINVAL; 1003 } 1004 1005 cable->extcon_type = extcon_type; 1006 1007 ret = devm_extcon_register_notifier(cm->dev, cable->extcon_dev, 1008 cable->extcon_type, &cable->nb); 1009 if (ret < 0) { 1010 pr_err("Cannot register extcon_dev for %s (cable: %s)\n", 1011 cable->extcon_name, cable->name); 1012 return ret; 1013 } 1014 1015 return 0; 1016} 1017 1018/** 1019 * charger_manager_register_extcon - Register extcon device to receive state 1020 * of charger cable. 1021 * @cm: the Charger Manager representing the battery. 1022 * 1023 * This function support EXTCON(External Connector) subsystem to detect the 1024 * state of charger cables for enabling or disabling charger(regulator) and 1025 * select the charger cable for charging among a number of external cable 1026 * according to policy of H/W board. 1027 */ 1028static int charger_manager_register_extcon(struct charger_manager *cm) 1029{ 1030 struct charger_desc *desc = cm->desc; 1031 struct charger_regulator *charger; 1032 unsigned long event; 1033 int ret; 1034 int i; 1035 int j; 1036 1037 for (i = 0; i < desc->num_charger_regulators; i++) { 1038 charger = &desc->charger_regulators[i]; 1039 1040 charger->consumer = regulator_get(cm->dev, 1041 charger->regulator_name); 1042 if (IS_ERR(charger->consumer)) { 1043 dev_err(cm->dev, "Cannot find charger(%s)\n", 1044 charger->regulator_name); 1045 return PTR_ERR(charger->consumer); 1046 } 1047 charger->cm = cm; 1048 1049 for (j = 0; j < charger->num_cables; j++) { 1050 struct charger_cable *cable = &charger->cables[j]; 1051 1052 ret = charger_extcon_init(cm, cable); 1053 if (ret < 0) { 1054 dev_err(cm->dev, "Cannot initialize charger(%s)\n", 1055 charger->regulator_name); 1056 return ret; 1057 } 1058 cable->charger = charger; 1059 cable->cm = cm; 1060 1061 event = extcon_get_state(cable->extcon_dev, 1062 cable->extcon_type); 1063 charger_extcon_notifier(&cable->nb, 1064 event, NULL); 1065 } 1066 } 1067 1068 return 0; 1069} 1070 1071/* help function of sysfs node to control charger(regulator) */ 1072static ssize_t charger_name_show(struct device *dev, 1073 struct device_attribute *attr, char *buf) 1074{ 1075 struct charger_regulator *charger 1076 = container_of(attr, struct charger_regulator, attr_name); 1077 1078 return sysfs_emit(buf, "%s\n", charger->regulator_name); 1079} 1080 1081static ssize_t charger_state_show(struct device *dev, 1082 struct device_attribute *attr, char *buf) 1083{ 1084 struct charger_regulator *charger 1085 = container_of(attr, struct charger_regulator, attr_state); 1086 int state = 0; 1087 1088 if (!charger->externally_control) 1089 state = regulator_is_enabled(charger->consumer); 1090 1091 return sysfs_emit(buf, "%s\n", state ? "enabled" : "disabled"); 1092} 1093 1094static ssize_t charger_externally_control_show(struct device *dev, 1095 struct device_attribute *attr, char *buf) 1096{ 1097 struct charger_regulator *charger = container_of(attr, 1098 struct charger_regulator, attr_externally_control); 1099 1100 return sysfs_emit(buf, "%d\n", charger->externally_control); 1101} 1102 1103static ssize_t charger_externally_control_store(struct device *dev, 1104 struct device_attribute *attr, const char *buf, 1105 size_t count) 1106{ 1107 struct charger_regulator *charger 1108 = container_of(attr, struct charger_regulator, 1109 attr_externally_control); 1110 struct charger_manager *cm = charger->cm; 1111 struct charger_desc *desc = cm->desc; 1112 int i; 1113 int ret; 1114 int externally_control; 1115 int chargers_externally_control = 1; 1116 1117 ret = sscanf(buf, "%d", &externally_control); 1118 if (ret == 0) { 1119 ret = -EINVAL; 1120 return ret; 1121 } 1122 1123 if (!externally_control) { 1124 charger->externally_control = 0; 1125 return count; 1126 } 1127 1128 for (i = 0; i < desc->num_charger_regulators; i++) { 1129 if (&desc->charger_regulators[i] != charger && 1130 !desc->charger_regulators[i].externally_control) { 1131 /* 1132 * At least, one charger is controlled by 1133 * charger-manager 1134 */ 1135 chargers_externally_control = 0; 1136 break; 1137 } 1138 } 1139 1140 if (!chargers_externally_control) { 1141 if (cm->charger_enabled) { 1142 try_charger_enable(charger->cm, false); 1143 charger->externally_control = externally_control; 1144 try_charger_enable(charger->cm, true); 1145 } else { 1146 charger->externally_control = externally_control; 1147 } 1148 } else { 1149 dev_warn(cm->dev, 1150 "'%s' regulator should be controlled in charger-manager because charger-manager must need at least one charger for charging\n", 1151 charger->regulator_name); 1152 } 1153 1154 return count; 1155} 1156 1157/** 1158 * charger_manager_prepare_sysfs - Prepare sysfs entry for each charger 1159 * @cm: the Charger Manager representing the battery. 1160 * 1161 * This function add sysfs entry for charger(regulator) to control charger from 1162 * user-space. If some development board use one more chargers for charging 1163 * but only need one charger on specific case which is dependent on user 1164 * scenario or hardware restrictions, the user enter 1 or 0(zero) to '/sys/ 1165 * class/power_supply/battery/charger.[index]/externally_control'. For example, 1166 * if user enter 1 to 'sys/class/power_supply/battery/charger.[index]/ 1167 * externally_control, this charger isn't controlled from charger-manager and 1168 * always stay off state of regulator. 1169 */ 1170static int charger_manager_prepare_sysfs(struct charger_manager *cm) 1171{ 1172 struct charger_desc *desc = cm->desc; 1173 struct charger_regulator *charger; 1174 int chargers_externally_control = 1; 1175 char *name; 1176 int i; 1177 1178 /* Create sysfs entry to control charger(regulator) */ 1179 for (i = 0; i < desc->num_charger_regulators; i++) { 1180 charger = &desc->charger_regulators[i]; 1181 1182 name = devm_kasprintf(cm->dev, GFP_KERNEL, "charger.%d", i); 1183 if (!name) 1184 return -ENOMEM; 1185 1186 charger->attrs[0] = &charger->attr_name.attr; 1187 charger->attrs[1] = &charger->attr_state.attr; 1188 charger->attrs[2] = &charger->attr_externally_control.attr; 1189 charger->attrs[3] = NULL; 1190 1191 charger->attr_grp.name = name; 1192 charger->attr_grp.attrs = charger->attrs; 1193 desc->sysfs_groups[i] = &charger->attr_grp; 1194 1195 sysfs_attr_init(&charger->attr_name.attr); 1196 charger->attr_name.attr.name = "name"; 1197 charger->attr_name.attr.mode = 0444; 1198 charger->attr_name.show = charger_name_show; 1199 1200 sysfs_attr_init(&charger->attr_state.attr); 1201 charger->attr_state.attr.name = "state"; 1202 charger->attr_state.attr.mode = 0444; 1203 charger->attr_state.show = charger_state_show; 1204 1205 sysfs_attr_init(&charger->attr_externally_control.attr); 1206 charger->attr_externally_control.attr.name 1207 = "externally_control"; 1208 charger->attr_externally_control.attr.mode = 0644; 1209 charger->attr_externally_control.show 1210 = charger_externally_control_show; 1211 charger->attr_externally_control.store 1212 = charger_externally_control_store; 1213 1214 if (!desc->charger_regulators[i].externally_control || 1215 !chargers_externally_control) 1216 chargers_externally_control = 0; 1217 1218 dev_info(cm->dev, "'%s' regulator's externally_control is %d\n", 1219 charger->regulator_name, charger->externally_control); 1220 } 1221 1222 if (chargers_externally_control) { 1223 dev_err(cm->dev, "Cannot register regulator because charger-manager must need at least one charger for charging battery\n"); 1224 return -EINVAL; 1225 } 1226 1227 return 0; 1228} 1229 1230static int cm_init_thermal_data(struct charger_manager *cm, 1231 struct power_supply *fuel_gauge, 1232 enum power_supply_property *properties, 1233 size_t *num_properties) 1234{ 1235 struct charger_desc *desc = cm->desc; 1236 union power_supply_propval val; 1237 int ret; 1238 1239 /* Verify whether fuel gauge provides battery temperature */ 1240 ret = power_supply_get_property(fuel_gauge, 1241 POWER_SUPPLY_PROP_TEMP, &val); 1242 1243 if (!ret) { 1244 properties[*num_properties] = POWER_SUPPLY_PROP_TEMP; 1245 (*num_properties)++; 1246 cm->desc->measure_battery_temp = true; 1247 } 1248#ifdef CONFIG_THERMAL 1249 if (ret && desc->thermal_zone) { 1250 cm->tzd_batt = 1251 thermal_zone_get_zone_by_name(desc->thermal_zone); 1252 if (IS_ERR(cm->tzd_batt)) 1253 return PTR_ERR(cm->tzd_batt); 1254 1255 /* Use external thermometer */ 1256 properties[*num_properties] = POWER_SUPPLY_PROP_TEMP; 1257 (*num_properties)++; 1258 cm->desc->measure_battery_temp = true; 1259 ret = 0; 1260 } 1261#endif 1262 if (cm->desc->measure_battery_temp) { 1263 /* NOTICE : Default allowable minimum charge temperature is 0 */ 1264 if (!desc->temp_max) 1265 desc->temp_max = CM_DEFAULT_CHARGE_TEMP_MAX; 1266 if (!desc->temp_diff) 1267 desc->temp_diff = CM_DEFAULT_RECHARGE_TEMP_DIFF; 1268 } 1269 1270 return ret; 1271} 1272 1273static const struct of_device_id charger_manager_match[] = { 1274 { 1275 .compatible = "charger-manager", 1276 }, 1277 {}, 1278}; 1279MODULE_DEVICE_TABLE(of, charger_manager_match); 1280 1281static struct charger_desc *of_cm_parse_desc(struct device *dev) 1282{ 1283 struct charger_desc *desc; 1284 struct device_node *np = dev->of_node; 1285 u32 poll_mode = CM_POLL_DISABLE; 1286 u32 battery_stat = CM_NO_BATTERY; 1287 int num_chgs = 0; 1288 1289 desc = devm_kzalloc(dev, sizeof(*desc), GFP_KERNEL); 1290 if (!desc) 1291 return ERR_PTR(-ENOMEM); 1292 1293 of_property_read_string(np, "cm-name", &desc->psy_name); 1294 1295 of_property_read_u32(np, "cm-poll-mode", &poll_mode); 1296 desc->polling_mode = poll_mode; 1297 1298 of_property_read_u32(np, "cm-poll-interval", 1299 &desc->polling_interval_ms); 1300 1301 of_property_read_u32(np, "cm-fullbatt-vchkdrop-volt", 1302 &desc->fullbatt_vchkdrop_uV); 1303 of_property_read_u32(np, "cm-fullbatt-voltage", &desc->fullbatt_uV); 1304 of_property_read_u32(np, "cm-fullbatt-soc", &desc->fullbatt_soc); 1305 of_property_read_u32(np, "cm-fullbatt-capacity", 1306 &desc->fullbatt_full_capacity); 1307 1308 of_property_read_u32(np, "cm-battery-stat", &battery_stat); 1309 desc->battery_present = battery_stat; 1310 1311 /* chargers */ 1312 num_chgs = of_property_count_strings(np, "cm-chargers"); 1313 if (num_chgs > 0) { 1314 int i; 1315 1316 /* Allocate empty bin at the tail of array */ 1317 desc->psy_charger_stat = devm_kcalloc(dev, 1318 num_chgs + 1, 1319 sizeof(char *), 1320 GFP_KERNEL); 1321 if (!desc->psy_charger_stat) 1322 return ERR_PTR(-ENOMEM); 1323 1324 for (i = 0; i < num_chgs; i++) 1325 of_property_read_string_index(np, "cm-chargers", 1326 i, &desc->psy_charger_stat[i]); 1327 } 1328 1329 of_property_read_string(np, "cm-fuel-gauge", &desc->psy_fuel_gauge); 1330 1331 of_property_read_string(np, "cm-thermal-zone", &desc->thermal_zone); 1332 1333 of_property_read_u32(np, "cm-battery-cold", &desc->temp_min); 1334 if (of_property_read_bool(np, "cm-battery-cold-in-minus")) 1335 desc->temp_min *= -1; 1336 of_property_read_u32(np, "cm-battery-hot", &desc->temp_max); 1337 of_property_read_u32(np, "cm-battery-temp-diff", &desc->temp_diff); 1338 1339 of_property_read_u32(np, "cm-charging-max", 1340 &desc->charging_max_duration_ms); 1341 of_property_read_u32(np, "cm-discharging-max", 1342 &desc->discharging_max_duration_ms); 1343 1344 /* battery charger regulators */ 1345 desc->num_charger_regulators = of_get_child_count(np); 1346 if (desc->num_charger_regulators) { 1347 struct charger_regulator *chg_regs; 1348 struct device_node *child; 1349 1350 chg_regs = devm_kcalloc(dev, 1351 desc->num_charger_regulators, 1352 sizeof(*chg_regs), 1353 GFP_KERNEL); 1354 if (!chg_regs) 1355 return ERR_PTR(-ENOMEM); 1356 1357 desc->charger_regulators = chg_regs; 1358 1359 desc->sysfs_groups = devm_kcalloc(dev, 1360 desc->num_charger_regulators + 1, 1361 sizeof(*desc->sysfs_groups), 1362 GFP_KERNEL); 1363 if (!desc->sysfs_groups) 1364 return ERR_PTR(-ENOMEM); 1365 1366 for_each_child_of_node(np, child) { 1367 struct charger_cable *cables; 1368 struct device_node *_child; 1369 1370 of_property_read_string(child, "cm-regulator-name", 1371 &chg_regs->regulator_name); 1372 1373 /* charger cables */ 1374 chg_regs->num_cables = of_get_child_count(child); 1375 if (chg_regs->num_cables) { 1376 cables = devm_kcalloc(dev, 1377 chg_regs->num_cables, 1378 sizeof(*cables), 1379 GFP_KERNEL); 1380 if (!cables) { 1381 of_node_put(child); 1382 return ERR_PTR(-ENOMEM); 1383 } 1384 1385 chg_regs->cables = cables; 1386 1387 for_each_child_of_node(child, _child) { 1388 of_property_read_string(_child, 1389 "cm-cable-name", &cables->name); 1390 of_property_read_string(_child, 1391 "cm-cable-extcon", 1392 &cables->extcon_name); 1393 of_property_read_u32(_child, 1394 "cm-cable-min", 1395 &cables->min_uA); 1396 of_property_read_u32(_child, 1397 "cm-cable-max", 1398 &cables->max_uA); 1399 cables++; 1400 } 1401 } 1402 chg_regs++; 1403 } 1404 } 1405 return desc; 1406} 1407 1408static inline struct charger_desc *cm_get_drv_data(struct platform_device *pdev) 1409{ 1410 if (pdev->dev.of_node) 1411 return of_cm_parse_desc(&pdev->dev); 1412 return dev_get_platdata(&pdev->dev); 1413} 1414 1415static enum alarmtimer_restart cm_timer_func(struct alarm *alarm, ktime_t now) 1416{ 1417 cm_timer_set = false; 1418 return ALARMTIMER_NORESTART; 1419} 1420 1421static int charger_manager_probe(struct platform_device *pdev) 1422{ 1423 struct charger_desc *desc = cm_get_drv_data(pdev); 1424 struct charger_manager *cm; 1425 int ret, i = 0; 1426 union power_supply_propval val; 1427 struct power_supply *fuel_gauge; 1428 enum power_supply_property *properties; 1429 size_t num_properties; 1430 struct power_supply_config psy_cfg = {}; 1431 1432 if (IS_ERR(desc)) { 1433 dev_err(&pdev->dev, "No platform data (desc) found\n"); 1434 return PTR_ERR(desc); 1435 } 1436 1437 cm = devm_kzalloc(&pdev->dev, sizeof(*cm), GFP_KERNEL); 1438 if (!cm) 1439 return -ENOMEM; 1440 1441 /* Basic Values. Unspecified are Null or 0 */ 1442 cm->dev = &pdev->dev; 1443 cm->desc = desc; 1444 psy_cfg.drv_data = cm; 1445 1446 /* Initialize alarm timer */ 1447 if (alarmtimer_get_rtcdev()) { 1448 cm_timer = devm_kzalloc(cm->dev, sizeof(*cm_timer), GFP_KERNEL); 1449 if (!cm_timer) 1450 return -ENOMEM; 1451 alarm_init(cm_timer, ALARM_BOOTTIME, cm_timer_func); 1452 } 1453 1454 /* 1455 * Some of the following do not need to be errors. 1456 * Users may intentionally ignore those features. 1457 */ 1458 if (desc->fullbatt_uV == 0) { 1459 dev_info(&pdev->dev, "Ignoring full-battery voltage threshold as it is not supplied\n"); 1460 } 1461 if (!desc->fullbatt_vchkdrop_uV) { 1462 dev_info(&pdev->dev, "Disabling full-battery voltage drop checking mechanism as it is not supplied\n"); 1463 desc->fullbatt_vchkdrop_uV = 0; 1464 } 1465 if (desc->fullbatt_soc == 0) { 1466 dev_info(&pdev->dev, "Ignoring full-battery soc(state of charge) threshold as it is not supplied\n"); 1467 } 1468 if (desc->fullbatt_full_capacity == 0) { 1469 dev_info(&pdev->dev, "Ignoring full-battery full capacity threshold as it is not supplied\n"); 1470 } 1471 1472 if (!desc->charger_regulators || desc->num_charger_regulators < 1) { 1473 dev_err(&pdev->dev, "charger_regulators undefined\n"); 1474 return -EINVAL; 1475 } 1476 1477 if (!desc->psy_charger_stat || !desc->psy_charger_stat[0]) { 1478 dev_err(&pdev->dev, "No power supply defined\n"); 1479 return -EINVAL; 1480 } 1481 1482 if (!desc->psy_fuel_gauge) { 1483 dev_err(&pdev->dev, "No fuel gauge power supply defined\n"); 1484 return -EINVAL; 1485 } 1486 1487 /* Check if charger's supplies are present at probe */ 1488 for (i = 0; desc->psy_charger_stat[i]; i++) { 1489 struct power_supply *psy; 1490 1491 psy = power_supply_get_by_name(desc->psy_charger_stat[i]); 1492 if (!psy) { 1493 dev_err(&pdev->dev, "Cannot find power supply \"%s\"\n", 1494 desc->psy_charger_stat[i]); 1495 return -ENODEV; 1496 } 1497 power_supply_put(psy); 1498 } 1499 1500 if (cm->desc->polling_mode != CM_POLL_DISABLE && 1501 (desc->polling_interval_ms == 0 || 1502 msecs_to_jiffies(desc->polling_interval_ms) <= CM_JIFFIES_SMALL)) { 1503 dev_err(&pdev->dev, "polling_interval_ms is too small\n"); 1504 return -EINVAL; 1505 } 1506 1507 if (!desc->charging_max_duration_ms || 1508 !desc->discharging_max_duration_ms) { 1509 dev_info(&pdev->dev, "Cannot limit charging duration checking mechanism to prevent overcharge/overheat and control discharging duration\n"); 1510 desc->charging_max_duration_ms = 0; 1511 desc->discharging_max_duration_ms = 0; 1512 } 1513 1514 platform_set_drvdata(pdev, cm); 1515 1516 memcpy(&cm->charger_psy_desc, &psy_default, sizeof(psy_default)); 1517 1518 if (!desc->psy_name) 1519 strscpy(cm->psy_name_buf, psy_default.name, 1520 sizeof(cm->psy_name_buf)); 1521 else 1522 strscpy(cm->psy_name_buf, desc->psy_name, 1523 sizeof(cm->psy_name_buf)); 1524 cm->charger_psy_desc.name = cm->psy_name_buf; 1525 1526 /* Allocate for psy properties because they may vary */ 1527 properties = devm_kcalloc(&pdev->dev, 1528 ARRAY_SIZE(default_charger_props) + 1529 NUM_CHARGER_PSY_OPTIONAL, 1530 sizeof(*properties), GFP_KERNEL); 1531 if (!properties) 1532 return -ENOMEM; 1533 1534 memcpy(properties, default_charger_props, 1535 sizeof(enum power_supply_property) * 1536 ARRAY_SIZE(default_charger_props)); 1537 num_properties = ARRAY_SIZE(default_charger_props); 1538 1539 /* Find which optional psy-properties are available */ 1540 fuel_gauge = power_supply_get_by_name(desc->psy_fuel_gauge); 1541 if (!fuel_gauge) { 1542 dev_err(&pdev->dev, "Cannot find power supply \"%s\"\n", 1543 desc->psy_fuel_gauge); 1544 return -ENODEV; 1545 } 1546 if (!power_supply_get_property(fuel_gauge, 1547 POWER_SUPPLY_PROP_CHARGE_FULL, &val)) { 1548 properties[num_properties] = 1549 POWER_SUPPLY_PROP_CHARGE_FULL; 1550 num_properties++; 1551 } 1552 if (!power_supply_get_property(fuel_gauge, 1553 POWER_SUPPLY_PROP_CHARGE_NOW, &val)) { 1554 properties[num_properties] = 1555 POWER_SUPPLY_PROP_CHARGE_NOW; 1556 num_properties++; 1557 } 1558 if (!power_supply_get_property(fuel_gauge, 1559 POWER_SUPPLY_PROP_CURRENT_NOW, 1560 &val)) { 1561 properties[num_properties] = 1562 POWER_SUPPLY_PROP_CURRENT_NOW; 1563 num_properties++; 1564 } 1565 1566 ret = cm_init_thermal_data(cm, fuel_gauge, properties, &num_properties); 1567 if (ret) { 1568 dev_err(&pdev->dev, "Failed to initialize thermal data\n"); 1569 cm->desc->measure_battery_temp = false; 1570 } 1571 power_supply_put(fuel_gauge); 1572 1573 cm->charger_psy_desc.properties = properties; 1574 cm->charger_psy_desc.num_properties = num_properties; 1575 1576 /* Register sysfs entry for charger(regulator) */ 1577 ret = charger_manager_prepare_sysfs(cm); 1578 if (ret < 0) { 1579 dev_err(&pdev->dev, 1580 "Cannot prepare sysfs entry of regulators\n"); 1581 return ret; 1582 } 1583 psy_cfg.attr_grp = desc->sysfs_groups; 1584 1585 cm->charger_psy = power_supply_register(&pdev->dev, 1586 &cm->charger_psy_desc, 1587 &psy_cfg); 1588 if (IS_ERR(cm->charger_psy)) { 1589 dev_err(&pdev->dev, "Cannot register charger-manager with name \"%s\"\n", 1590 cm->charger_psy_desc.name); 1591 return PTR_ERR(cm->charger_psy); 1592 } 1593 1594 /* Register extcon device for charger cable */ 1595 ret = charger_manager_register_extcon(cm); 1596 if (ret < 0) { 1597 dev_err(&pdev->dev, "Cannot initialize extcon device\n"); 1598 goto err_reg_extcon; 1599 } 1600 1601 /* Add to the list */ 1602 mutex_lock(&cm_list_mtx); 1603 list_add(&cm->entry, &cm_list); 1604 mutex_unlock(&cm_list_mtx); 1605 1606 /* 1607 * Charger-manager is capable of waking up the system from sleep 1608 * when event is happened through cm_notify_event() 1609 */ 1610 device_init_wakeup(&pdev->dev, true); 1611 device_set_wakeup_capable(&pdev->dev, false); 1612 1613 /* 1614 * Charger-manager have to check the charging state right after 1615 * initialization of charger-manager and then update current charging 1616 * state. 1617 */ 1618 cm_monitor(); 1619 1620 schedule_work(&setup_polling); 1621 1622 return 0; 1623 1624err_reg_extcon: 1625 for (i = 0; i < desc->num_charger_regulators; i++) 1626 regulator_put(desc->charger_regulators[i].consumer); 1627 1628 power_supply_unregister(cm->charger_psy); 1629 1630 return ret; 1631} 1632 1633static void charger_manager_remove(struct platform_device *pdev) 1634{ 1635 struct charger_manager *cm = platform_get_drvdata(pdev); 1636 struct charger_desc *desc = cm->desc; 1637 int i = 0; 1638 1639 /* Remove from the list */ 1640 mutex_lock(&cm_list_mtx); 1641 list_del(&cm->entry); 1642 mutex_unlock(&cm_list_mtx); 1643 1644 cancel_work_sync(&setup_polling); 1645 cancel_delayed_work_sync(&cm_monitor_work); 1646 1647 for (i = 0 ; i < desc->num_charger_regulators ; i++) 1648 regulator_put(desc->charger_regulators[i].consumer); 1649 1650 power_supply_unregister(cm->charger_psy); 1651 1652 try_charger_enable(cm, false); 1653} 1654 1655static const struct platform_device_id charger_manager_id[] = { 1656 { "charger-manager", 0 }, 1657 { }, 1658}; 1659MODULE_DEVICE_TABLE(platform, charger_manager_id); 1660 1661static int cm_suspend_noirq(struct device *dev) 1662{ 1663 if (device_may_wakeup(dev)) { 1664 device_set_wakeup_capable(dev, false); 1665 return -EAGAIN; 1666 } 1667 1668 return 0; 1669} 1670 1671static bool cm_need_to_awake(void) 1672{ 1673 struct charger_manager *cm; 1674 1675 if (cm_timer) 1676 return false; 1677 1678 mutex_lock(&cm_list_mtx); 1679 list_for_each_entry(cm, &cm_list, entry) { 1680 if (is_charging(cm)) { 1681 mutex_unlock(&cm_list_mtx); 1682 return true; 1683 } 1684 } 1685 mutex_unlock(&cm_list_mtx); 1686 1687 return false; 1688} 1689 1690static int cm_suspend_prepare(struct device *dev) 1691{ 1692 if (cm_need_to_awake()) 1693 return -EBUSY; 1694 1695 if (!cm_suspended) 1696 cm_suspended = true; 1697 1698 cm_timer_set = cm_setup_timer(); 1699 1700 if (cm_timer_set) { 1701 cancel_work_sync(&setup_polling); 1702 cancel_delayed_work_sync(&cm_monitor_work); 1703 } 1704 1705 return 0; 1706} 1707 1708static void cm_suspend_complete(struct device *dev) 1709{ 1710 struct charger_manager *cm = dev_get_drvdata(dev); 1711 1712 if (cm_suspended) 1713 cm_suspended = false; 1714 1715 if (cm_timer_set) { 1716 ktime_t remain; 1717 1718 alarm_cancel(cm_timer); 1719 cm_timer_set = false; 1720 remain = alarm_expires_remaining(cm_timer); 1721 cm_suspend_duration_ms -= ktime_to_ms(remain); 1722 schedule_work(&setup_polling); 1723 } 1724 1725 _cm_monitor(cm); 1726 1727 device_set_wakeup_capable(cm->dev, false); 1728} 1729 1730static const struct dev_pm_ops charger_manager_pm = { 1731 .prepare = cm_suspend_prepare, 1732 .suspend_noirq = cm_suspend_noirq, 1733 .complete = cm_suspend_complete, 1734}; 1735 1736static struct platform_driver charger_manager_driver = { 1737 .driver = { 1738 .name = "charger-manager", 1739 .pm = &charger_manager_pm, 1740 .of_match_table = charger_manager_match, 1741 }, 1742 .probe = charger_manager_probe, 1743 .remove_new = charger_manager_remove, 1744 .id_table = charger_manager_id, 1745}; 1746 1747static int __init charger_manager_init(void) 1748{ 1749 cm_wq = create_freezable_workqueue("charger_manager"); 1750 if (unlikely(!cm_wq)) 1751 return -ENOMEM; 1752 1753 INIT_DELAYED_WORK(&cm_monitor_work, cm_monitor_poller); 1754 1755 return platform_driver_register(&charger_manager_driver); 1756} 1757late_initcall(charger_manager_init); 1758 1759static void __exit charger_manager_cleanup(void) 1760{ 1761 destroy_workqueue(cm_wq); 1762 cm_wq = NULL; 1763 1764 platform_driver_unregister(&charger_manager_driver); 1765} 1766module_exit(charger_manager_cleanup); 1767 1768MODULE_AUTHOR("MyungJoo Ham <myungjoo.ham@samsung.com>"); 1769MODULE_DESCRIPTION("Charger Manager"); 1770MODULE_LICENSE("GPL"); 1771