drivers/power/charger-manager.c

   1 /*
   2  * Copyright (C) 2011 Samsung Electronics Co., Ltd.
   3  * MyungJoo Ham <myungjoo.ham@samsung.com>
   4  *
   5  * This driver enables to monitor battery health and control charger
   6  * during suspend-to-mem.
   7  * Charger manager depends on other devices. register this later than
   8  * the depending devices.
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License version 2 as
  12  * published by the Free Software Foundation.
  13 **/
  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
  27 static const char * const default_event_names[] = {
  28         [CM_EVENT_UNKNOWN] = "Unknown",
  29         [CM_EVENT_BATT_FULL] = "Battery Full",
  30         [CM_EVENT_BATT_IN] = "Battery Inserted",
  31         [CM_EVENT_BATT_OUT] = "Battery Pulled Out",
  32         [CM_EVENT_EXT_PWR_IN_OUT] = "External Power Attach/Detach",
  33         [CM_EVENT_CHG_START_STOP] = "Charging Start/Stop",
  34         [CM_EVENT_OTHERS] = "Other battery events"
  35 };
  36
  37 /*
  38  * Regard CM_JIFFIES_SMALL jiffies is small enough to ignore for
  39  * delayed works so that we can run delayed works with CM_JIFFIES_SMALL
  40  * without any delays.
  41  */
  42 #define CM_JIFFIES_SMALL        (2)
  43
  44 /* If y is valid (> 0) and smaller than x, do x = y */
  45 #define CM_MIN_VALID(x, y)      x = (((y > 0) && ((x) > (y))) ? (y) : (x))
  46
  47 /*
  48  * Regard CM_RTC_SMALL (sec) is small enough to ignore error in invoking
  49  * rtc alarm. It should be 2 or larger
  50  */
  51 #define CM_RTC_SMALL            (2)
  52
  53 #define UEVENT_BUF_SIZE         32
  54
  55 static LIST_HEAD(cm_list);
  56 static DEFINE_MUTEX(cm_list_mtx);
  57
  58 /* About in-suspend (suspend-again) monitoring */
  59 static struct rtc_device *rtc_dev;
  60 /*
  61  * Backup RTC alarm
  62  * Save the wakeup alarm before entering suspend-to-RAM
  63  */
  64 static struct rtc_wkalrm rtc_wkalarm_save;
  65 /* Backup RTC alarm time in terms of seconds since 01-01-1970 00:00:00 */
  66 static unsigned long rtc_wkalarm_save_time;
  67 static bool cm_suspended;
  68 static bool cm_rtc_set;
  69 static unsigned long cm_suspend_duration_ms;
  70
  71 /* About normal (not suspended) monitoring */
  72 static unsigned long polling_jiffy = ULONG_MAX; /* ULONG_MAX: no polling */
  73 static unsigned long next_polling; /* Next appointed polling time */
  74 static struct workqueue_struct *cm_wq; /* init at driver add */
  75 static struct delayed_work cm_monitor_work; /* init at driver add */
  76
  77 /* Global charger-manager description */
  78 static struct charger_global_desc *g_desc; /* init with setup_charger_manager */
  79
  80 /**
  81  * is_batt_present - See if the battery presents in place.
  82  * @cm: the Charger Manager representing the battery.
  83  */
  84 static bool is_batt_present(struct charger_manager *cm)
  85 {
  86         union power_supply_propval val;
  87         bool present = false;
  88         int i, ret;
  89
  90         switch (cm->desc->battery_present) {
  91         case CM_BATTERY_PRESENT:
  92                 present = true;
  93                 break;
  94         case CM_NO_BATTERY:
  95                 break;
  96         case CM_FUEL_GAUGE:
  97                 ret = cm->fuel_gauge->get_property(cm->fuel_gauge,
  98                                 POWER_SUPPLY_PROP_PRESENT, &val);
  99                 if (ret == 0 && val.intval)
 100                         present = true;
 101                 break;
 102         case CM_CHARGER_STAT:
 103                 for (i = 0; cm->charger_stat[i]; i++) {
 104                         ret = cm->charger_stat[i]->get_property(
 105                                         cm->charger_stat[i],
 106                                         POWER_SUPPLY_PROP_PRESENT, &val);
 107                         if (ret == 0 && val.intval) {
 108                                 present = true;
 109                                 break;
 110                         }
 111                 }
 112                 break;
 113         }
 114
 115         return present;
 116 }
 117
 118 /**
 119  * is_ext_pwr_online - See if an external power source is attached to charge
 120  * @cm: the Charger Manager representing the battery.
 121  *
 122  * Returns true if at least one of the chargers of the battery has an external
 123  * power source attached to charge the battery regardless of whether it is
 124  * actually charging or not.
 125  */
 126 static bool is_ext_pwr_online(struct charger_manager *cm)
 127 {
 128         union power_supply_propval val;
 129         bool online = false;
 130         int i, ret;
 131
 132         /* If at least one of them has one, it's yes. */
 133         for (i = 0; cm->charger_stat[i]; i++) {
 134                 ret = cm->charger_stat[i]->get_property(
 135                                 cm->charger_stat[i],
 136                                 POWER_SUPPLY_PROP_ONLINE, &val);
 137                 if (ret == 0 && val.intval) {
 138                         online = true;
 139                         break;
 140                 }
 141         }
 142
 143         return online;
 144 }
 145
 146 /**
 147  * get_batt_uV - Get the voltage level of the battery
 148  * @cm: the Charger Manager representing the battery.
 149  * @uV: the voltage level returned.
 150  *
 151  * Returns 0 if there is no error.
 152  * Returns a negative value on error.
 153  */
 154 static int get_batt_uV(struct charger_manager *cm, int *uV)
 155 {
 156         union power_supply_propval val;
 157         int ret;
 158
 159         if (!cm->fuel_gauge)
 160                 return -ENODEV;
 161
 162         ret = cm->fuel_gauge->get_property(cm->fuel_gauge,
 163                                 POWER_SUPPLY_PROP_VOLTAGE_NOW, &val);
 164         if (ret)
 165                 return ret;
 166
 167         *uV = val.intval;
 168         return 0;
 169 }
 170
 171 /**
 172  * is_charging - Returns true if the battery is being charged.
 173  * @cm: the Charger Manager representing the battery.
 174  */
 175 static bool is_charging(struct charger_manager *cm)
 176 {
 177         int i, ret;
 178         bool charging = false;
 179         union power_supply_propval val;
 180
 181         /* If there is no battery, it cannot be charged */
 182         if (!is_batt_present(cm))
 183                 return false;
 184
 185         /* If at least one of the charger is charging, return yes */
 186         for (i = 0; cm->charger_stat[i]; i++) {
 187                 /* 1. The charger sholuld not be DISABLED */
 188                 if (cm->emergency_stop)
 189                         continue;
 190                 if (!cm->charger_enabled)
 191                         continue;
 192
 193                 /* 2. The charger should be online (ext-power) */
 194                 ret = cm->charger_stat[i]->get_property(
 195                                 cm->charger_stat[i],
 196                                 POWER_SUPPLY_PROP_ONLINE, &val);
 197                 if (ret) {
 198                         dev_warn(cm->dev, "Cannot read ONLINE value from %s.\n",
 199                                         cm->desc->psy_charger_stat[i]);
 200                         continue;
 201                 }
 202                 if (val.intval == 0)
 203                         continue;
 204
 205                 /*
 206                  * 3. The charger should not be FULL, DISCHARGING,
 207                  * or NOT_CHARGING.
 208                  */
 209                 ret = cm->charger_stat[i]->get_property(
 210                                 cm->charger_stat[i],
 211                                 POWER_SUPPLY_PROP_STATUS, &val);
 212                 if (ret) {
 213                         dev_warn(cm->dev, "Cannot read STATUS value from %s.\n",
 214                                         cm->desc->psy_charger_stat[i]);
 215                         continue;
 216                 }
 217                 if (val.intval == POWER_SUPPLY_STATUS_FULL ||
 218                                 val.intval == POWER_SUPPLY_STATUS_DISCHARGING ||
 219                                 val.intval == POWER_SUPPLY_STATUS_NOT_CHARGING)
 220                         continue;
 221
 222                 /* Then, this is charging. */
 223                 charging = true;
 224                 break;
 225         }
 226
 227         return charging;
 228 }
 229
 230 /**
 231  * is_full_charged - Returns true if the battery is fully charged.
 232  * @cm: the Charger Manager representing the battery.
 233  */
 234 static bool is_full_charged(struct charger_manager *cm)
 235 {
 236         struct charger_desc *desc = cm->desc;
 237         union power_supply_propval val;
 238         int ret = 0;
 239         int uV;
 240
 241         /* If there is no battery, it cannot be charged */
 242         if (!is_batt_present(cm))
 243                 return false;
 244
 245         if (cm->fuel_gauge && desc->fullbatt_full_capacity > 0) {
 246                 val.intval = 0;
 247
 248                 /* Not full if capacity of fuel gauge isn't full */
 249                 ret = cm->fuel_gauge->get_property(cm->fuel_gauge,
 250                                 POWER_SUPPLY_PROP_CHARGE_FULL, &val);
 251                 if (!ret && val.intval > desc->fullbatt_full_capacity)
 252                         return true;
 253         }
 254
 255         /* Full, if it's over the fullbatt voltage */
 256         if (desc->fullbatt_uV > 0) {
 257                 ret = get_batt_uV(cm, &uV);
 258                 if (!ret && uV >= desc->fullbatt_uV)
 259                         return true;
 260         }
 261
 262         /* Full, if the capacity is more than fullbatt_soc */
 263         if (cm->fuel_gauge && desc->fullbatt_soc > 0) {
 264                 val.intval = 0;
 265
 266                 ret = cm->fuel_gauge->get_property(cm->fuel_gauge,
 267                                 POWER_SUPPLY_PROP_CAPACITY, &val);
 268                 if (!ret && val.intval >= desc->fullbatt_soc)
 269                         return true;
 270         }
 271
 272         return false;
 273 }
 274
 275 /**
 276  * is_polling_required - Return true if need to continue polling for this CM.
 277  * @cm: the Charger Manager representing the battery.
 278  */
 279 static bool is_polling_required(struct charger_manager *cm)
 280 {
 281         switch (cm->desc->polling_mode) {
 282         case CM_POLL_DISABLE:
 283                 return false;
 284         case CM_POLL_ALWAYS:
 285                 return true;
 286         case CM_POLL_EXTERNAL_POWER_ONLY:
 287                 return is_ext_pwr_online(cm);
 288         case CM_POLL_CHARGING_ONLY:
 289                 return is_charging(cm);
 290         default:
 291                 dev_warn(cm->dev, "Incorrect polling_mode (%d)\n",
 292                         cm->desc->polling_mode);
 293         }
 294
 295         return false;
 296 }
 297
 298 /**
 299  * try_charger_enable - Enable/Disable chargers altogether
 300  * @cm: the Charger Manager representing the battery.
 301  * @enable: true: enable / false: disable
 302  *
 303  * Note that Charger Manager keeps the charger enabled regardless whether
 304  * the charger is charging or not (because battery is full or no external
 305  * power source exists) except when CM needs to disable chargers forcibly
 306  * bacause of emergency causes; when the battery is overheated or too cold.
 307  */
 308 static int try_charger_enable(struct charger_manager *cm, bool enable)
 309 {
 310         int err = 0, i;
 311         struct charger_desc *desc = cm->desc;
 312
 313         /* Ignore if it's redundent command */
 314         if (enable == cm->charger_enabled)
 315                 return 0;
 316
 317         if (enable) {
 318                 if (cm->emergency_stop)
 319                         return -EAGAIN;
 320
 321                 /*
 322                  * Save start time of charging to limit
 323                  * maximum possible charging time.
 324                  */
 325                 cm->charging_start_time = ktime_to_ms(ktime_get());
 326                 cm->charging_end_time = 0;
 327
 328                 for (i = 0 ; i < desc->num_charger_regulators ; i++) {
 329                         if (desc->charger_regulators[i].externally_control)
 330                                 continue;
 331
 332                         err = regulator_enable(desc->charger_regulators[i].consumer);
 333                         if (err < 0) {
 334                                 dev_warn(cm->dev,
 335                                         "Cannot enable %s regulator\n",
 336                                         desc->charger_regulators[i].regulator_name);
 337                         }
 338                 }
 339         } else {
 340                 /*
 341                  * Save end time of charging to maintain fully charged state
 342                  * of battery after full-batt.
 343                  */
 344                 cm->charging_start_time = 0;
 345                 cm->charging_end_time = ktime_to_ms(ktime_get());
 346
 347                 for (i = 0 ; i < desc->num_charger_regulators ; i++) {
 348                         if (desc->charger_regulators[i].externally_control)
 349                                 continue;
 350
 351                         err = regulator_disable(desc->charger_regulators[i].consumer);
 352                         if (err < 0) {
 353                                 dev_warn(cm->dev,
 354                                         "Cannot disable %s regulator\n",
 355                                         desc->charger_regulators[i].regulator_name);
 356                         }
 357                 }
 358
 359                 /*
 360                  * Abnormal battery state - Stop charging forcibly,
 361                  * even if charger was enabled at the other places
 362                  */
 363                 for (i = 0; i < desc->num_charger_regulators; i++) {
 364                         if (regulator_is_enabled(
 365                                     desc->charger_regulators[i].consumer)) {
 366                                 regulator_force_disable(
 367                                         desc->charger_regulators[i].consumer);
 368                                 dev_warn(cm->dev,
 369                                         "Disable regulator(%s) forcibly.\n",
 370                                         desc->charger_regulators[i].regulator_name);
 371                         }
 372                 }
 373         }
 374
 375         if (!err)
 376                 cm->charger_enabled = enable;
 377
 378         return err;
 379 }
 380
 381 /**
 382  * try_charger_restart - Restart charging.
 383  * @cm: the Charger Manager representing the battery.
 384  *
 385  * Restart charging by turning off and on the charger.
 386  */
 387 static int try_charger_restart(struct charger_manager *cm)
 388 {
 389         int err;
 390
 391         if (cm->emergency_stop)
 392                 return -EAGAIN;
 393
 394         err = try_charger_enable(cm, false);
 395         if (err)
 396                 return err;
 397
 398         return try_charger_enable(cm, true);
 399 }
 400
 401 /**
 402  * uevent_notify - Let users know something has changed.
 403  * @cm: the Charger Manager representing the battery.
 404  * @event: the event string.
 405  *
 406  * If @event is null, it implies that uevent_notify is called
 407  * by resume function. When called in the resume function, cm_suspended
 408  * should be already reset to false in order to let uevent_notify
 409  * notify the recent event during the suspend to users. While
 410  * suspended, uevent_notify does not notify users, but tracks
 411  * events so that uevent_notify can notify users later after resumed.
 412  */
 413 static void uevent_notify(struct charger_manager *cm, const char *event)
 414 {
 415         static char env_str[UEVENT_BUF_SIZE + 1] = "";
 416         static char env_str_save[UEVENT_BUF_SIZE + 1] = "";
 417
 418         if (cm_suspended) {
 419                 /* Nothing in suspended-event buffer */
 420                 if (env_str_save[0] == 0) {
 421                         if (!strncmp(env_str, event, UEVENT_BUF_SIZE))
 422                                 return; /* status not changed */
 423                         strncpy(env_str_save, event, UEVENT_BUF_SIZE);
 424                         return;
 425                 }
 426
 427                 if (!strncmp(env_str_save, event, UEVENT_BUF_SIZE))
 428                         return; /* Duplicated. */
 429                 strncpy(env_str_save, event, UEVENT_BUF_SIZE);
 430                 return;
 431         }
 432
 433         if (event == NULL) {
 434                 /* No messages pending */
 435                 if (!env_str_save[0])
 436                         return;
 437
 438                 strncpy(env_str, env_str_save, UEVENT_BUF_SIZE);
 439                 kobject_uevent(&cm->dev->kobj, KOBJ_CHANGE);
 440                 env_str_save[0] = 0;
 441
 442                 return;
 443         }
 444
 445         /* status not changed */
 446         if (!strncmp(env_str, event, UEVENT_BUF_SIZE))
 447                 return;
 448
 449         /* save the status and notify the update */
 450         strncpy(env_str, event, UEVENT_BUF_SIZE);
 451         kobject_uevent(&cm->dev->kobj, KOBJ_CHANGE);
 452
 453         dev_info(cm->dev, event);
 454 }
 455
 456 /**
 457  * fullbatt_vchk - Check voltage drop some times after "FULL" event.
 458  * @work: the work_struct appointing the function
 459  *
 460  * If a user has designated "fullbatt_vchkdrop_ms/uV" values with
 461  * charger_desc, Charger Manager checks voltage drop after the battery
 462  * "FULL" event. It checks whether the voltage has dropped more than
 463  * fullbatt_vchkdrop_uV by calling this function after fullbatt_vchkrop_ms.
 464  */
 465 static void fullbatt_vchk(struct work_struct *work)
 466 {
 467         struct delayed_work *dwork = to_delayed_work(work);
 468         struct charger_manager *cm = container_of(dwork,
 469                         struct charger_manager, fullbatt_vchk_work);
 470         struct charger_desc *desc = cm->desc;
 471         int batt_uV, err, diff;
 472
 473         /* remove the appointment for fullbatt_vchk */
 474         cm->fullbatt_vchk_jiffies_at = 0;
 475
 476         if (!desc->fullbatt_vchkdrop_uV || !desc->fullbatt_vchkdrop_ms)
 477                 return;
 478
 479         err = get_batt_uV(cm, &batt_uV);
 480         if (err) {
 481                 dev_err(cm->dev, "%s: get_batt_uV error(%d).\n", __func__, err);
 482                 return;
 483         }
 484
 485         diff = desc->fullbatt_uV - batt_uV;
 486         if (diff < 0)
 487                 return;
 488
 489         dev_info(cm->dev, "VBATT dropped %duV after full-batt.\n", diff);
 490
 491         if (diff > desc->fullbatt_vchkdrop_uV) {
 492                 try_charger_restart(cm);
 493                 uevent_notify(cm, "Recharging");
 494         }
 495 }
 496
 497 /**
 498  * check_charging_duration - Monitor charging/discharging duration
 499  * @cm: the Charger Manager representing the battery.
 500  *
 501  * If whole charging duration exceed 'charging_max_duration_ms',
 502  * cm stop charging to prevent overcharge/overheat. If discharging
 503  * duration exceed 'discharging _max_duration_ms', charger cable is
 504  * attached, after full-batt, cm start charging to maintain fully
 505  * charged state for battery.
 506  */
 507 static int check_charging_duration(struct charger_manager *cm)
 508 {
 509         struct charger_desc *desc = cm->desc;
 510         u64 curr = ktime_to_ms(ktime_get());
 511         u64 duration;
 512         int ret = false;
 513
 514         if (!desc->charging_max_duration_ms &&
 515                         !desc->discharging_max_duration_ms)
 516                 return ret;
 517
 518         if (cm->charger_enabled) {
 519                 duration = curr - cm->charging_start_time;
 520
 521                 if (duration > desc->charging_max_duration_ms) {
 522                         dev_info(cm->dev, "Charging duration exceed %lldms",
 523                                  desc->charging_max_duration_ms);
 524                         uevent_notify(cm, "Discharging");
 525                         try_charger_enable(cm, false);
 526                         ret = true;
 527                 }
 528         } else if (is_ext_pwr_online(cm) && !cm->charger_enabled) {
 529                 duration = curr - cm->charging_end_time;
 530
 531                 if (duration > desc->charging_max_duration_ms &&
 532                                 is_ext_pwr_online(cm)) {
 533                         dev_info(cm->dev, "DisCharging duration exceed %lldms",
 534                                  desc->discharging_max_duration_ms);
 535                         uevent_notify(cm, "Recharing");
 536                         try_charger_enable(cm, true);
 537                         ret = true;
 538                 }
 539         }
 540
 541         return ret;
 542 }
 543
 544 /**
 545  * _cm_monitor - Monitor the temperature and return true for exceptions.
 546  * @cm: the Charger Manager representing the battery.
 547  *
 548  * Returns true if there is an event to notify for the battery.
 549  * (True if the status of "emergency_stop" changes)
 550  */
 551 static bool _cm_monitor(struct charger_manager *cm)
 552 {
 553         struct charger_desc *desc = cm->desc;
 554         int temp = desc->temperature_out_of_range(&cm->last_temp_mC);
 555
 556         dev_dbg(cm->dev, "monitoring (%2.2d.%3.3dC)\n",
 557                 cm->last_temp_mC / 1000, cm->last_temp_mC % 1000);
 558
 559         /* It has been stopped already */
 560         if (temp && cm->emergency_stop)
 561                 return false;
 562
 563         /*
 564          * Check temperature whether overheat or cold.
 565          * If temperature is out of range normal state, stop charging.
 566          */
 567         if (temp) {
 568                 cm->emergency_stop = temp;
 569                 if (!try_charger_enable(cm, false)) {
 570                         if (temp > 0)
 571                                 uevent_notify(cm, "OVERHEAT");
 572                         else
 573                                 uevent_notify(cm, "COLD");
 574                 }
 575
 576         /*
 577          * Check whole charging duration and discharing duration
 578          * after full-batt.
 579          */
 580         } else if (!cm->emergency_stop && check_charging_duration(cm)) {
 581                 dev_dbg(cm->dev,
 582                         "Charging/Discharging duration is out of range");
 583         /*
 584          * Check dropped voltage of battery. If battery voltage is more
 585          * dropped than fullbatt_vchkdrop_uV after fully charged state,
 586          * charger-manager have to recharge battery.
 587          */
 588         } else if (!cm->emergency_stop && is_ext_pwr_online(cm) &&
 589                         !cm->charger_enabled) {
 590                 fullbatt_vchk(&cm->fullbatt_vchk_work.work);
 591
 592         /*
 593          * Check whether fully charged state to protect overcharge
 594          * if charger-manager is charging for battery.
 595          */
 596         } else if (!cm->emergency_stop && is_full_charged(cm) &&
 597                         cm->charger_enabled) {
 598                 dev_info(cm->dev, "EVENT_HANDLE: Battery Fully Charged.\n");
 599                 uevent_notify(cm, default_event_names[CM_EVENT_BATT_FULL]);
 600
 601                 try_charger_enable(cm, false);
 602
 603                 fullbatt_vchk(&cm->fullbatt_vchk_work.work);
 604         } else {
 605                 cm->emergency_stop = 0;
 606                 if (is_ext_pwr_online(cm)) {
 607                         if (!try_charger_enable(cm, true))
 608                                 uevent_notify(cm, "CHARGING");
 609                 }
 610         }
 611
 612         return true;
 613 }
 614
 615 /**
 616  * cm_monitor - Monitor every battery.
 617  *
 618  * Returns true if there is an event to notify from any of the batteries.
 619  * (True if the status of "emergency_stop" changes)
 620  */
 621 static bool cm_monitor(void)
 622 {
 623         bool stop = false;
 624         struct charger_manager *cm;
 625
 626         mutex_lock(&cm_list_mtx);
 627
 628         list_for_each_entry(cm, &cm_list, entry) {
 629                 if (_cm_monitor(cm))
 630                         stop = true;
 631         }
 632
 633         mutex_unlock(&cm_list_mtx);
 634
 635         return stop;
 636 }
 637
 638 /**
 639  * _setup_polling - Setup the next instance of polling.
 640  * @work: work_struct of the function _setup_polling.
 641  */
 642 static void _setup_polling(struct work_struct *work)
 643 {
 644         unsigned long min = ULONG_MAX;
 645         struct charger_manager *cm;
 646         bool keep_polling = false;
 647         unsigned long _next_polling;
 648
 649         mutex_lock(&cm_list_mtx);
 650
 651         list_for_each_entry(cm, &cm_list, entry) {
 652                 if (is_polling_required(cm) && cm->desc->polling_interval_ms) {
 653                         keep_polling = true;
 654
 655                         if (min > cm->desc->polling_interval_ms)
 656                                 min = cm->desc->polling_interval_ms;
 657                 }
 658         }
 659
 660         polling_jiffy = msecs_to_jiffies(min);
 661         if (polling_jiffy <= CM_JIFFIES_SMALL)
 662                 polling_jiffy = CM_JIFFIES_SMALL + 1;
 663
 664         if (!keep_polling)
 665                 polling_jiffy = ULONG_MAX;
 666         if (polling_jiffy == ULONG_MAX)
 667                 goto out;
 668
 669         WARN(cm_wq == NULL, "charger-manager: workqueue not initialized"
 670                             ". try it later. %s\n", __func__);
 671
 672         _next_polling = jiffies + polling_jiffy;
 673
 674         if (!delayed_work_pending(&cm_monitor_work) ||
 675             (delayed_work_pending(&cm_monitor_work) &&
 676              time_after(next_polling, _next_polling))) {
 677                 next_polling = jiffies + polling_jiffy;
 678                 mod_delayed_work(cm_wq, &cm_monitor_work, polling_jiffy);
 679         }
 680
 681 out:
 682         mutex_unlock(&cm_list_mtx);
 683 }
 684 static DECLARE_WORK(setup_polling, _setup_polling);
 685
 686 /**
 687  * cm_monitor_poller - The Monitor / Poller.
 688  * @work: work_struct of the function cm_monitor_poller
 689  *
 690  * During non-suspended state, cm_monitor_poller is used to poll and monitor
 691  * the batteries.
 692  */
 693 static void cm_monitor_poller(struct work_struct *work)
 694 {
 695         cm_monitor();
 696         schedule_work(&setup_polling);
 697 }
 698
 699 /**
 700  * fullbatt_handler - Event handler for CM_EVENT_BATT_FULL
 701  * @cm: the Charger Manager representing the battery.
 702  */
 703 static void fullbatt_handler(struct charger_manager *cm)
 704 {
 705         struct charger_desc *desc = cm->desc;
 706
 707         if (!desc->fullbatt_vchkdrop_uV || !desc->fullbatt_vchkdrop_ms)
 708                 goto out;
 709
 710         if (cm_suspended)
 711                 device_set_wakeup_capable(cm->dev, true);
 712
 713         mod_delayed_work(cm_wq, &cm->fullbatt_vchk_work,
 714                          msecs_to_jiffies(desc->fullbatt_vchkdrop_ms));
 715         cm->fullbatt_vchk_jiffies_at = jiffies + msecs_to_jiffies(
 716                                        desc->fullbatt_vchkdrop_ms);
 717
 718         if (cm->fullbatt_vchk_jiffies_at == 0)
 719                 cm->fullbatt_vchk_jiffies_at = 1;
 720
 721 out:
 722         dev_info(cm->dev, "EVENT_HANDLE: Battery Fully Charged.\n");
 723         uevent_notify(cm, default_event_names[CM_EVENT_BATT_FULL]);
 724 }
 725
 726 /**
 727  * battout_handler - Event handler for CM_EVENT_BATT_OUT
 728  * @cm: the Charger Manager representing the battery.
 729  */
 730 static void battout_handler(struct charger_manager *cm)
 731 {
 732         if (cm_suspended)
 733                 device_set_wakeup_capable(cm->dev, true);
 734
 735         if (!is_batt_present(cm)) {
 736                 dev_emerg(cm->dev, "Battery Pulled Out!\n");
 737                 uevent_notify(cm, default_event_names[CM_EVENT_BATT_OUT]);
 738         } else {
 739                 uevent_notify(cm, "Battery Reinserted?");
 740         }
 741 }
 742
 743 /**
 744  * misc_event_handler - Handler for other evnets
 745  * @cm: the Charger Manager representing the battery.
 746  * @type: the Charger Manager representing the battery.
 747  */
 748 static void misc_event_handler(struct charger_manager *cm,
 749                         enum cm_event_types type)
 750 {
 751         if (cm_suspended)
 752                 device_set_wakeup_capable(cm->dev, true);
 753
 754         if (!delayed_work_pending(&cm_monitor_work) &&
 755             is_polling_required(cm) && cm->desc->polling_interval_ms)
 756                 schedule_work(&setup_polling);
 757         uevent_notify(cm, default_event_names[type]);
 758 }
 759
 760 static int charger_get_property(struct power_supply *psy,
 761                 enum power_supply_property psp,
 762                 union power_supply_propval *val)
 763 {
 764         struct charger_manager *cm = container_of(psy,
 765                         struct charger_manager, charger_psy);
 766         struct charger_desc *desc = cm->desc;
 767         int ret = 0;
 768         int uV;
 769
 770         switch (psp) {
 771         case POWER_SUPPLY_PROP_STATUS:
 772                 if (is_charging(cm))
 773                         val->intval = POWER_SUPPLY_STATUS_CHARGING;
 774                 else if (is_ext_pwr_online(cm))
 775                         val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING;
 776                 else
 777                         val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
 778                 break;
 779         case POWER_SUPPLY_PROP_HEALTH:
 780                 if (cm->emergency_stop > 0)
 781                         val->intval = POWER_SUPPLY_HEALTH_OVERHEAT;
 782                 else if (cm->emergency_stop < 0)
 783                         val->intval = POWER_SUPPLY_HEALTH_COLD;
 784                 else
 785                         val->intval = POWER_SUPPLY_HEALTH_GOOD;
 786                 break;
 787         case POWER_SUPPLY_PROP_PRESENT:
 788                 if (is_batt_present(cm))
 789                         val->intval = 1;
 790                 else
 791                         val->intval = 0;
 792                 break;
 793         case POWER_SUPPLY_PROP_VOLTAGE_NOW:
 794                 ret = get_batt_uV(cm, &val->intval);
 795                 break;
 796         case POWER_SUPPLY_PROP_CURRENT_NOW:
 797                 ret = cm->fuel_gauge->get_property(cm->fuel_gauge,
 798                                 POWER_SUPPLY_PROP_CURRENT_NOW, val);
 799                 break;
 800         case POWER_SUPPLY_PROP_TEMP:
 801                 /* in thenth of centigrade */
 802                 if (cm->last_temp_mC == INT_MIN)
 803                         desc->temperature_out_of_range(&cm->last_temp_mC);
 804                 val->intval = cm->last_temp_mC / 100;
 805                 if (!desc->measure_battery_temp)
 806                         ret = -ENODEV;
 807                 break;
 808         case POWER_SUPPLY_PROP_TEMP_AMBIENT:
 809                 /* in thenth of centigrade */
 810                 if (cm->last_temp_mC == INT_MIN)
 811                         desc->temperature_out_of_range(&cm->last_temp_mC);
 812                 val->intval = cm->last_temp_mC / 100;
 813                 if (desc->measure_battery_temp)
 814                         ret = -ENODEV;
 815                 break;
 816         case POWER_SUPPLY_PROP_CAPACITY:
 817                 if (!cm->fuel_gauge) {
 818                         ret = -ENODEV;
 819                         break;
 820                 }
 821
 822                 if (!is_batt_present(cm)) {
 823                         /* There is no battery. Assume 100% */
 824                         val->intval = 100;
 825                         break;
 826                 }
 827
 828                 ret = cm->fuel_gauge->get_property(cm->fuel_gauge,
 829                                         POWER_SUPPLY_PROP_CAPACITY, val);
 830                 if (ret)
 831                         break;
 832
 833                 if (val->intval > 100) {
 834                         val->intval = 100;
 835                         break;
 836                 }
 837                 if (val->intval < 0)
 838                         val->intval = 0;
 839
 840                 /* Do not adjust SOC when charging: voltage is overrated */
 841                 if (is_charging(cm))
 842                         break;
 843
 844                 /*
 845                  * If the capacity value is inconsistent, calibrate it base on
 846                  * the battery voltage values and the thresholds given as desc
 847                  */
 848                 ret = get_batt_uV(cm, &uV);
 849                 if (ret) {
 850                         /* Voltage information not available. No calibration */
 851                         ret = 0;
 852                         break;
 853                 }
 854
 855                 if (desc->fullbatt_uV > 0 && uV >= desc->fullbatt_uV &&
 856                     !is_charging(cm)) {
 857                         val->intval = 100;
 858                         break;
 859                 }
 860
 861                 break;
 862         case POWER_SUPPLY_PROP_ONLINE:
 863                 if (is_ext_pwr_online(cm))
 864                         val->intval = 1;
 865                 else
 866                         val->intval = 0;
 867                 break;
 868         case POWER_SUPPLY_PROP_CHARGE_FULL:
 869                 if (is_full_charged(cm))
 870                         val->intval = 1;
 871                 else
 872                         val->intval = 0;
 873                 ret = 0;
 874                 break;
 875         case POWER_SUPPLY_PROP_CHARGE_NOW:
 876                 if (is_charging(cm)) {
 877                         ret = cm->fuel_gauge->get_property(cm->fuel_gauge,
 878                                                 POWER_SUPPLY_PROP_CHARGE_NOW,
 879                                                 val);
 880                         if (ret) {
 881                                 val->intval = 1;
 882                                 ret = 0;
 883                         } else {
 884                                 /* If CHARGE_NOW is supplied, use it */
 885                                 val->intval = (val->intval > 0) ?
 886                                                 val->intval : 1;
 887                         }
 888                 } else {
 889                         val->intval = 0;
 890                 }
 891                 break;
 892         default:
 893                 return -EINVAL;
 894         }
 895         return ret;
 896 }
 897
 898 #define NUM_CHARGER_PSY_OPTIONAL        (4)
 899 static enum power_supply_property default_charger_props[] = {
 900         /* Guaranteed to provide */
 901         POWER_SUPPLY_PROP_STATUS,
 902         POWER_SUPPLY_PROP_HEALTH,
 903         POWER_SUPPLY_PROP_PRESENT,
 904         POWER_SUPPLY_PROP_VOLTAGE_NOW,
 905         POWER_SUPPLY_PROP_CAPACITY,
 906         POWER_SUPPLY_PROP_ONLINE,
 907         POWER_SUPPLY_PROP_CHARGE_FULL,
 908         /*
 909          * Optional properties are:
 910          * POWER_SUPPLY_PROP_CHARGE_NOW,
 911          * POWER_SUPPLY_PROP_CURRENT_NOW,
 912          * POWER_SUPPLY_PROP_TEMP, and
 913          * POWER_SUPPLY_PROP_TEMP_AMBIENT,
 914          */
 915 };
 916
 917 static struct power_supply psy_default = {
 918         .name = "battery",
 919         .type = POWER_SUPPLY_TYPE_BATTERY,
 920         .properties = default_charger_props,
 921         .num_properties = ARRAY_SIZE(default_charger_props),
 922         .get_property = charger_get_property,
 923 };
 924
 925 /**
 926  * cm_setup_timer - For in-suspend monitoring setup wakeup alarm
 927  *                  for suspend_again.
 928  *
 929  * Returns true if the alarm is set for Charger Manager to use.
 930  * Returns false if
 931  *      cm_setup_timer fails to set an alarm,
 932  *      cm_setup_timer does not need to set an alarm for Charger Manager,
 933  *      or an alarm previously configured is to be used.
 934  */
 935 static bool cm_setup_timer(void)
 936 {
 937         struct charger_manager *cm;
 938         unsigned int wakeup_ms = UINT_MAX;
 939         bool ret = false;
 940
 941         mutex_lock(&cm_list_mtx);
 942
 943         list_for_each_entry(cm, &cm_list, entry) {
 944                 unsigned int fbchk_ms = 0;
 945
 946                 /* fullbatt_vchk is required. setup timer for that */
 947                 if (cm->fullbatt_vchk_jiffies_at) {
 948                         fbchk_ms = jiffies_to_msecs(cm->fullbatt_vchk_jiffies_at
 949                                                     - jiffies);
 950                         if (time_is_before_eq_jiffies(
 951                                 cm->fullbatt_vchk_jiffies_at) ||
 952                                 msecs_to_jiffies(fbchk_ms) < CM_JIFFIES_SMALL) {
 953                                 fullbatt_vchk(&cm->fullbatt_vchk_work.work);
 954                                 fbchk_ms = 0;
 955                         }
 956                 }
 957                 CM_MIN_VALID(wakeup_ms, fbchk_ms);
 958
 959                 /* Skip if polling is not required for this CM */
 960                 if (!is_polling_required(cm) && !cm->emergency_stop)
 961                         continue;
 962                 if (cm->desc->polling_interval_ms == 0)
 963                         continue;
 964                 CM_MIN_VALID(wakeup_ms, cm->desc->polling_interval_ms);
 965         }
 966
 967         mutex_unlock(&cm_list_mtx);
 968
 969         if (wakeup_ms < UINT_MAX && wakeup_ms > 0) {
 970                 pr_info("Charger Manager wakeup timer: %u ms.\n", wakeup_ms);
 971                 if (rtc_dev) {
 972                         struct rtc_wkalrm tmp;
 973                         unsigned long time, now;
 974                         unsigned long add = DIV_ROUND_UP(wakeup_ms, 1000);
 975
 976                         /*
 977                          * Set alarm with the polling interval (wakeup_ms)
 978                          * except when rtc_wkalarm_save comes first.
 979                          * However, the alarm time should be NOW +
 980                          * CM_RTC_SMALL or later.
 981                          */
 982                         tmp.enabled = 1;
 983                         rtc_read_time(rtc_dev, &tmp.time);
 984                         rtc_tm_to_time(&tmp.time, &now);
 985                         if (add < CM_RTC_SMALL)
 986                                 add = CM_RTC_SMALL;
 987                         time = now + add;
 988
 989                         ret = true;
 990
 991                         if (rtc_wkalarm_save.enabled &&
 992                             rtc_wkalarm_save_time &&
 993                             rtc_wkalarm_save_time < time) {
 994                                 if (rtc_wkalarm_save_time < now + CM_RTC_SMALL)
 995                                         time = now + CM_RTC_SMALL;
 996                                 else
 997                                         time = rtc_wkalarm_save_time;
 998
 999                                 /* The timer is not appointed by CM */
1000                                 ret = false;
1001                         }
1002
1003                         pr_info("Waking up after %lu secs.\n",
1004                                         time - now);
1005
1006                         rtc_time_to_tm(time, &tmp.time);
1007                         rtc_set_alarm(rtc_dev, &tmp);
1008                         cm_suspend_duration_ms += wakeup_ms;
1009                         return ret;
1010                 }
1011         }
1012
1013         if (rtc_dev)
1014                 rtc_set_alarm(rtc_dev, &rtc_wkalarm_save);
1015         return false;
1016 }
1017
1018 static void _cm_fbchk_in_suspend(struct charger_manager *cm)
1019 {
1020         unsigned long jiffy_now = jiffies;
1021
1022         if (!cm->fullbatt_vchk_jiffies_at)
1023                 return;
1024
1025         if (g_desc && g_desc->assume_timer_stops_in_suspend)
1026                 jiffy_now += msecs_to_jiffies(cm_suspend_duration_ms);
1027
1028         /* Execute now if it's going to be executed not too long after */
1029         jiffy_now += CM_JIFFIES_SMALL;
1030
1031         if (time_after_eq(jiffy_now, cm->fullbatt_vchk_jiffies_at))
1032                 fullbatt_vchk(&cm->fullbatt_vchk_work.work);
1033 }
1034
1035 /**
1036  * cm_suspend_again - Determine whether suspend again or not
1037  *
1038  * Returns true if the system should be suspended again
1039  * Returns false if the system should be woken up
1040  */
1041 bool cm_suspend_again(void)
1042 {
1043         struct charger_manager *cm;
1044         bool ret = false;
1045
1046         if (!g_desc || !g_desc->rtc_only_wakeup || !g_desc->rtc_only_wakeup() ||
1047             !cm_rtc_set)
1048                 return false;
1049
1050         if (cm_monitor())
1051                 goto out;
1052
1053         ret = true;
1054         mutex_lock(&cm_list_mtx);
1055         list_for_each_entry(cm, &cm_list, entry) {
1056                 _cm_fbchk_in_suspend(cm);
1057
1058                 if (cm->status_save_ext_pwr_inserted != is_ext_pwr_online(cm) ||
1059                     cm->status_save_batt != is_batt_present(cm)) {
1060                         ret = false;
1061                         break;
1062                 }
1063         }
1064         mutex_unlock(&cm_list_mtx);
1065
1066         cm_rtc_set = cm_setup_timer();
1067 out:
1068         /* It's about the time when the non-CM appointed timer goes off */
1069         if (rtc_wkalarm_save.enabled) {
1070                 unsigned long now;
1071                 struct rtc_time tmp;
1072
1073                 rtc_read_time(rtc_dev, &tmp);
1074                 rtc_tm_to_time(&tmp, &now);
1075
1076                 if (rtc_wkalarm_save_time &&
1077                     now + CM_RTC_SMALL >= rtc_wkalarm_save_time)
1078                         return false;
1079         }
1080         return ret;
1081 }
1082 EXPORT_SYMBOL_GPL(cm_suspend_again);
1083
1084 /**
1085  * setup_charger_manager - initialize charger_global_desc data
1086  * @gd: pointer to instance of charger_global_desc
1087  */
1088 int setup_charger_manager(struct charger_global_desc *gd)
1089 {
1090         if (!gd)
1091                 return -EINVAL;
1092
1093         if (rtc_dev)
1094                 rtc_class_close(rtc_dev);
1095         rtc_dev = NULL;
1096         g_desc = NULL;
1097
1098         if (!gd->rtc_only_wakeup) {
1099                 pr_err("The callback rtc_only_wakeup is not given.\n");
1100                 return -EINVAL;
1101         }
1102
1103         if (gd->rtc_name) {
1104                 rtc_dev = rtc_class_open(gd->rtc_name);
1105                 if (IS_ERR_OR_NULL(rtc_dev)) {
1106                         rtc_dev = NULL;
1107                         /* Retry at probe. RTC may be not registered yet */
1108                 }
1109         } else {
1110                 pr_warn("No wakeup timer is given for charger manager."
1111                         "In-suspend monitoring won't work.\n");
1112         }
1113
1114         g_desc = gd;
1115         return 0;
1116 }
1117 EXPORT_SYMBOL_GPL(setup_charger_manager);
1118
1119 /**
1120  * charger_extcon_work - enable/diable charger according to the state
1121  *                      of charger cable
1122  *
1123  * @work: work_struct of the function charger_extcon_work.
1124  */
1125 static void charger_extcon_work(struct work_struct *work)
1126 {
1127         struct charger_cable *cable =
1128                         container_of(work, struct charger_cable, wq);
1129         int ret;
1130
1131         if (cable->attached && cable->min_uA != 0 && cable->max_uA != 0) {
1132                 ret = regulator_set_current_limit(cable->charger->consumer,
1133                                         cable->min_uA, cable->max_uA);
1134                 if (ret < 0) {
1135                         pr_err("Cannot set current limit of %s (%s)\n",
1136                                 cable->charger->regulator_name, cable->name);
1137                         return;
1138                 }
1139
1140                 pr_info("Set current limit of %s : %duA ~ %duA\n",
1141                                         cable->charger->regulator_name,
1142                                         cable->min_uA, cable->max_uA);
1143         }
1144
1145         try_charger_enable(cable->cm, cable->attached);
1146 }
1147
1148 /**
1149  * charger_extcon_notifier - receive the state of charger cable
1150  *                      when registered cable is attached or detached.
1151  *
1152  * @self: the notifier block of the charger_extcon_notifier.
1153  * @event: the cable state.
1154  * @ptr: the data pointer of notifier block.
1155  */
1156 static int charger_extcon_notifier(struct notifier_block *self,
1157                         unsigned long event, void *ptr)
1158 {
1159         struct charger_cable *cable =
1160                 container_of(self, struct charger_cable, nb);
1161
1162         /*
1163          * The newly state of charger cable.
1164          * If cable is attached, cable->attached is true.
1165          */
1166         cable->attached = event;
1167
1168         /*
1169          * Setup monitoring to check battery state
1170          * when charger cable is attached.
1171          */
1172         if (cable->attached && is_polling_required(cable->cm)) {
1173                 if (work_pending(&setup_polling))
1174                         cancel_work_sync(&setup_polling);
1175                 schedule_work(&setup_polling);
1176         }
1177
1178         /*
1179          * Setup work for controlling charger(regulator)
1180          * according to charger cable.
1181          */
1182         schedule_work(&cable->wq);
1183
1184         return NOTIFY_DONE;
1185 }
1186
1187 /**
1188  * charger_extcon_init - register external connector to use it
1189  *                      as the charger cable
1190  *
1191  * @cm: the Charger Manager representing the battery.
1192  * @cable: the Charger cable representing the external connector.
1193  */
1194 static int charger_extcon_init(struct charger_manager *cm,
1195                 struct charger_cable *cable)
1196 {
1197         int ret = 0;
1198
1199         /*
1200          * Charger manager use Extcon framework to identify
1201          * the charger cable among various external connector
1202          * cable (e.g., TA, USB, MHL, Dock).
1203          */
1204         INIT_WORK(&cable->wq, charger_extcon_work);
1205         cable->nb.notifier_call = charger_extcon_notifier;
1206         ret = extcon_register_interest(&cable->extcon_dev,
1207                         cable->extcon_name, cable->name, &cable->nb);
1208         if (ret < 0) {
1209                 pr_info("Cannot register extcon_dev for %s(cable: %s).\n",
1210                                 cable->extcon_name,
1211                                 cable->name);
1212                 ret = -EINVAL;
1213         }
1214
1215         return ret;
1216 }
1217
1218 /* help function of sysfs node to control charger(regulator) */
1219 static ssize_t charger_name_show(struct device *dev,
1220                                 struct device_attribute *attr, char *buf)
1221 {
1222         struct charger_regulator *charger
1223                 = container_of(attr, struct charger_regulator, attr_name);
1224
1225         return sprintf(buf, "%s\n", charger->regulator_name);
1226 }
1227
1228 static ssize_t charger_state_show(struct device *dev,
1229                                 struct device_attribute *attr, char *buf)
1230 {
1231         struct charger_regulator *charger
1232                 = container_of(attr, struct charger_regulator, attr_state);
1233         int state = 0;
1234
1235         if (!charger->externally_control)
1236                 state = regulator_is_enabled(charger->consumer);
1237
1238         return sprintf(buf, "%s\n", state ? "enabled" : "disabled");
1239 }
1240
1241 static ssize_t charger_externally_control_show(struct device *dev,
1242                                 struct device_attribute *attr, char *buf)
1243 {
1244         struct charger_regulator *charger = container_of(attr,
1245                         struct charger_regulator, attr_externally_control);
1246
1247         return sprintf(buf, "%d\n", charger->externally_control);
1248 }
1249
1250 static ssize_t charger_externally_control_store(struct device *dev,
1251                                 struct device_attribute *attr, const char *buf,
1252                                 size_t count)
1253 {
1254         struct charger_regulator *charger
1255                 = container_of(attr, struct charger_regulator,
1256                                         attr_externally_control);
1257         struct charger_manager *cm = charger->cm;
1258         struct charger_desc *desc = cm->desc;
1259         int i;
1260         int ret;
1261         int externally_control;
1262         int chargers_externally_control = 1;
1263
1264         ret = sscanf(buf, "%d", &externally_control);
1265         if (ret == 0) {
1266                 ret = -EINVAL;
1267                 return ret;
1268         }
1269
1270         if (!externally_control) {
1271                 charger->externally_control = 0;
1272                 return count;
1273         }
1274
1275         for (i = 0; i < desc->num_charger_regulators; i++) {
1276                 if (&desc->charger_regulators[i] != charger &&
1277                               !desc->charger_regulators[i].externally_control) {
1278                         /*
1279                          * At least, one charger is controlled by
1280                          * charger-manager
1281                          */
1282                         chargers_externally_control = 0;
1283                         break;
1284                 }
1285         }
1286
1287         if (!chargers_externally_control) {
1288                 if (cm->charger_enabled) {
1289                         try_charger_enable(charger->cm, false);
1290                         charger->externally_control = externally_control;
1291                         try_charger_enable(charger->cm, true);
1292                 } else {
1293                         charger->externally_control = externally_control;
1294                 }
1295         } else {
1296                 dev_warn(cm->dev,
1297                         "'%s' regulator should be controlled "
1298                         "in charger-manager because charger-manager "
1299                         "must need at least one charger for charging\n",
1300                         charger->regulator_name);
1301         }
1302
1303         return count;
1304 }
1305
1306 static int charger_manager_probe(struct platform_device *pdev)
1307 {
1308         struct charger_desc *desc = dev_get_platdata(&pdev->dev);
1309         struct charger_manager *cm;
1310         int ret = 0, i = 0;
1311         int j = 0;
1312         int chargers_externally_control = 1;
1313         union power_supply_propval val;
1314
1315         if (g_desc && !rtc_dev && g_desc->rtc_name) {
1316                 rtc_dev = rtc_class_open(g_desc->rtc_name);
1317                 if (IS_ERR_OR_NULL(rtc_dev)) {
1318                         rtc_dev = NULL;
1319                         dev_err(&pdev->dev, "Cannot get RTC %s.\n",
1320                                 g_desc->rtc_name);
1321                         ret = -ENODEV;
1322                         goto err_alloc;
1323                 }
1324         }
1325
1326         if (!desc) {
1327                 dev_err(&pdev->dev, "No platform data (desc) found.\n");
1328                 ret = -ENODEV;
1329                 goto err_alloc;
1330         }
1331
1332         cm = kzalloc(sizeof(struct charger_manager), GFP_KERNEL);
1333         if (!cm) {
1334                 dev_err(&pdev->dev, "Cannot allocate memory.\n");
1335                 ret = -ENOMEM;
1336                 goto err_alloc;
1337         }
1338
1339         /* Basic Values. Unspecified are Null or 0 */
1340         cm->dev = &pdev->dev;
1341         cm->desc = kzalloc(sizeof(struct charger_desc), GFP_KERNEL);
1342         if (!cm->desc) {
1343                 dev_err(&pdev->dev, "Cannot allocate memory.\n");
1344                 ret = -ENOMEM;
1345                 goto err_alloc_desc;
1346         }
1347         memcpy(cm->desc, desc, sizeof(struct charger_desc));
1348         cm->last_temp_mC = INT_MIN; /* denotes "unmeasured, yet" */
1349
1350         /*
1351          * The following two do not need to be errors.
1352          * Users may intentionally ignore those two features.
1353          */
1354         if (desc->fullbatt_uV == 0) {
1355                 dev_info(&pdev->dev, "Ignoring full-battery voltage threshold"
1356                                         " as it is not supplied.");
1357         }
1358         if (!desc->fullbatt_vchkdrop_ms || !desc->fullbatt_vchkdrop_uV) {
1359                 dev_info(&pdev->dev, "Disabling full-battery voltage drop "
1360                                 "checking mechanism as it is not supplied.");
1361                 desc->fullbatt_vchkdrop_ms = 0;
1362                 desc->fullbatt_vchkdrop_uV = 0;
1363         }
1364         if (desc->fullbatt_soc == 0) {
1365                 dev_info(&pdev->dev, "Ignoring full-battery soc(state of"
1366                                         " charge) threshold as it is not"
1367                                         " supplied.");
1368         }
1369         if (desc->fullbatt_full_capacity == 0) {
1370                 dev_info(&pdev->dev, "Ignoring full-battery full capacity"
1371                                         " threshold as it is not supplied.");
1372         }
1373
1374         if (!desc->charger_regulators || desc->num_charger_regulators < 1) {
1375                 ret = -EINVAL;
1376                 dev_err(&pdev->dev, "charger_regulators undefined.\n");
1377                 goto err_no_charger;
1378         }
1379
1380         if (!desc->psy_charger_stat || !desc->psy_charger_stat[0]) {
1381                 dev_err(&pdev->dev, "No power supply defined.\n");
1382                 ret = -EINVAL;
1383                 goto err_no_charger_stat;
1384         }
1385
1386         /* Counting index only */
1387         while (desc->psy_charger_stat[i])
1388                 i++;
1389
1390         cm->charger_stat = kzalloc(sizeof(struct power_supply *) * (i + 1),
1391                                    GFP_KERNEL);
1392         if (!cm->charger_stat) {
1393                 ret = -ENOMEM;
1394                 goto err_no_charger_stat;
1395         }
1396
1397         for (i = 0; desc->psy_charger_stat[i]; i++) {
1398                 cm->charger_stat[i] = power_supply_get_by_name(
1399                                         desc->psy_charger_stat[i]);
1400                 if (!cm->charger_stat[i]) {
1401                         dev_err(&pdev->dev, "Cannot find power supply "
1402                                         "\"%s\"\n",
1403                                         desc->psy_charger_stat[i]);
1404                         ret = -ENODEV;
1405                         goto err_chg_stat;
1406                 }
1407         }
1408
1409         cm->fuel_gauge = power_supply_get_by_name(desc->psy_fuel_gauge);
1410         if (!cm->fuel_gauge) {
1411                 dev_err(&pdev->dev, "Cannot find power supply \"%s\"\n",
1412                                 desc->psy_fuel_gauge);
1413                 ret = -ENODEV;
1414                 goto err_chg_stat;
1415         }
1416
1417         if (desc->polling_interval_ms == 0 ||
1418             msecs_to_jiffies(desc->polling_interval_ms) <= CM_JIFFIES_SMALL) {
1419                 dev_err(&pdev->dev, "polling_interval_ms is too small\n");
1420                 ret = -EINVAL;
1421                 goto err_chg_stat;
1422         }
1423
1424         if (!desc->temperature_out_of_range) {
1425                 dev_err(&pdev->dev, "there is no temperature_out_of_range\n");
1426                 ret = -EINVAL;
1427                 goto err_chg_stat;
1428         }
1429
1430         if (!desc->charging_max_duration_ms ||
1431                         !desc->discharging_max_duration_ms) {
1432                 dev_info(&pdev->dev, "Cannot limit charging duration "
1433                          "checking mechanism to prevent overcharge/overheat "
1434                          "and control discharging duration");
1435                 desc->charging_max_duration_ms = 0;
1436                 desc->discharging_max_duration_ms = 0;
1437         }
1438
1439         platform_set_drvdata(pdev, cm);
1440
1441         memcpy(&cm->charger_psy, &psy_default, sizeof(psy_default));
1442
1443         if (!desc->psy_name) {
1444                 strncpy(cm->psy_name_buf, psy_default.name, PSY_NAME_MAX);
1445         } else {
1446                 strncpy(cm->psy_name_buf, desc->psy_name, PSY_NAME_MAX);
1447         }
1448         cm->charger_psy.name = cm->psy_name_buf;
1449
1450         /* Allocate for psy properties because they may vary */
1451         cm->charger_psy.properties = kzalloc(sizeof(enum power_supply_property)
1452                                 * (ARRAY_SIZE(default_charger_props) +
1453                                 NUM_CHARGER_PSY_OPTIONAL),
1454                                 GFP_KERNEL);
1455         if (!cm->charger_psy.properties) {
1456                 dev_err(&pdev->dev, "Cannot allocate for psy properties.\n");
1457                 ret = -ENOMEM;
1458                 goto err_chg_stat;
1459         }
1460         memcpy(cm->charger_psy.properties, default_charger_props,
1461                 sizeof(enum power_supply_property) *
1462                 ARRAY_SIZE(default_charger_props));
1463         cm->charger_psy.num_properties = psy_default.num_properties;
1464
1465         /* Find which optional psy-properties are available */
1466         if (!cm->fuel_gauge->get_property(cm->fuel_gauge,
1467                                           POWER_SUPPLY_PROP_CHARGE_NOW, &val)) {
1468                 cm->charger_psy.properties[cm->charger_psy.num_properties] =
1469                                 POWER_SUPPLY_PROP_CHARGE_NOW;
1470                 cm->charger_psy.num_properties++;
1471         }
1472         if (!cm->fuel_gauge->get_property(cm->fuel_gauge,
1473                                           POWER_SUPPLY_PROP_CURRENT_NOW,
1474                                           &val)) {
1475                 cm->charger_psy.properties[cm->charger_psy.num_properties] =
1476                                 POWER_SUPPLY_PROP_CURRENT_NOW;
1477                 cm->charger_psy.num_properties++;
1478         }
1479
1480         if (desc->measure_battery_temp) {
1481                 cm->charger_psy.properties[cm->charger_psy.num_properties] =
1482                                 POWER_SUPPLY_PROP_TEMP;
1483                 cm->charger_psy.num_properties++;
1484         } else {
1485                 cm->charger_psy.properties[cm->charger_psy.num_properties] =
1486                                 POWER_SUPPLY_PROP_TEMP_AMBIENT;
1487                 cm->charger_psy.num_properties++;
1488         }
1489
1490         INIT_DELAYED_WORK(&cm->fullbatt_vchk_work, fullbatt_vchk);
1491
1492         ret = power_supply_register(NULL, &cm->charger_psy);
1493         if (ret) {
1494                 dev_err(&pdev->dev, "Cannot register charger-manager with"
1495                                 " name \"%s\".\n", cm->charger_psy.name);
1496                 goto err_register;
1497         }
1498
1499         for (i = 0 ; i < desc->num_charger_regulators ; i++) {
1500                 struct charger_regulator *charger
1501                                         = &desc->charger_regulators[i];
1502                 char buf[11];
1503                 char *str;
1504
1505                 charger->consumer = regulator_get(&pdev->dev,
1506                                         charger->regulator_name);
1507                 if (charger->consumer == NULL) {
1508                         dev_err(&pdev->dev, "Cannot find charger(%s)n",
1509                                                 charger->regulator_name);
1510                         ret = -EINVAL;
1511                         goto err_chg_get;
1512                 }
1513                 charger->cm = cm;
1514
1515                 for (j = 0 ; j < charger->num_cables ; j++) {
1516                         struct charger_cable *cable = &charger->cables[j];
1517
1518                         ret = charger_extcon_init(cm, cable);
1519                         if (ret < 0) {
1520                                 dev_err(&pdev->dev, "Cannot find charger(%s)n",
1521                                                 charger->regulator_name);
1522                                 goto err_extcon;
1523                         }
1524                         cable->charger = charger;
1525                         cable->cm = cm;
1526                 }
1527
1528                 /* Create sysfs entry to control charger(regulator) */
1529                 snprintf(buf, 10, "charger.%d", i);
1530                 str = kzalloc(sizeof(char) * (strlen(buf) + 1), GFP_KERNEL);
1531                 if (!str) {
1532                         for (i--; i >= 0; i--) {
1533                                 charger = &desc->charger_regulators[i];
1534                                 kfree(charger->attr_g.name);
1535                         }
1536                         ret = -ENOMEM;
1537
1538                         goto err_extcon;
1539                 }
1540                 strcpy(str, buf);
1541
1542                 charger->attrs[0] = &charger->attr_name.attr;
1543                 charger->attrs[1] = &charger->attr_state.attr;
1544                 charger->attrs[2] = &charger->attr_externally_control.attr;
1545                 charger->attrs[3] = NULL;
1546                 charger->attr_g.name = str;
1547                 charger->attr_g.attrs = charger->attrs;
1548
1549                 sysfs_attr_init(&charger->attr_name.attr);
1550                 charger->attr_name.attr.name = "name";
1551                 charger->attr_name.attr.mode = 0444;
1552                 charger->attr_name.show = charger_name_show;
1553
1554                 sysfs_attr_init(&charger->attr_state.attr);
1555                 charger->attr_state.attr.name = "state";
1556                 charger->attr_state.attr.mode = 0444;
1557                 charger->attr_state.show = charger_state_show;
1558
1559                 sysfs_attr_init(&charger->attr_externally_control.attr);
1560                 charger->attr_externally_control.attr.name
1561                                 = "externally_control";
1562                 charger->attr_externally_control.attr.mode = 0644;
1563                 charger->attr_externally_control.show
1564                                 = charger_externally_control_show;
1565                 charger->attr_externally_control.store
1566                                 = charger_externally_control_store;
1567
1568                 if (!desc->charger_regulators[i].externally_control ||
1569                                 !chargers_externally_control) {
1570                         chargers_externally_control = 0;
1571                 }
1572                 dev_info(&pdev->dev, "'%s' regulator's externally_control"
1573                                 "is %d\n", charger->regulator_name,
1574                                 charger->externally_control);
1575
1576                 ret = sysfs_create_group(&cm->charger_psy.dev->kobj,
1577                                 &charger->attr_g);
1578                 if (ret < 0) {
1579                         dev_info(&pdev->dev, "Cannot create sysfs entry"
1580                                         "of %s regulator\n",
1581                                         charger->regulator_name);
1582                 }
1583         }
1584
1585         if (chargers_externally_control) {
1586                 dev_err(&pdev->dev, "Cannot register regulator because "
1587                                 "charger-manager must need at least "
1588                                 "one charger for charging battery\n");
1589
1590                 ret = -EINVAL;
1591                 goto err_chg_enable;
1592         }
1593
1594         ret = try_charger_enable(cm, true);
1595         if (ret) {
1596                 dev_err(&pdev->dev, "Cannot enable charger regulators\n");
1597                 goto err_chg_enable;
1598         }
1599
1600         /* Add to the list */
1601         mutex_lock(&cm_list_mtx);
1602         list_add(&cm->entry, &cm_list);
1603         mutex_unlock(&cm_list_mtx);
1604
1605         /*
1606          * Charger-manager is capable of waking up the systme from sleep
1607          * when event is happend through cm_notify_event()
1608          */
1609         device_init_wakeup(&pdev->dev, true);
1610         device_set_wakeup_capable(&pdev->dev, false);
1611
1612         schedule_work(&setup_polling);
1613
1614         return 0;
1615
1616 err_chg_enable:
1617         for (i = 0; i < desc->num_charger_regulators; i++) {
1618                 struct charger_regulator *charger;
1619
1620                 charger = &desc->charger_regulators[i];
1621                 sysfs_remove_group(&cm->charger_psy.dev->kobj,
1622                                 &charger->attr_g);
1623                 kfree(charger->attr_g.name);
1624         }
1625 err_extcon:
1626         for (i = 0 ; i < desc->num_charger_regulators ; i++) {
1627                 struct charger_regulator *charger
1628                                 = &desc->charger_regulators[i];
1629                 for (j = 0 ; j < charger->num_cables ; j++) {
1630                         struct charger_cable *cable = &charger->cables[j];
1631                         extcon_unregister_interest(&cable->extcon_dev);
1632                 }
1633         }
1634 err_chg_get:
1635         for (i = 0 ; i < desc->num_charger_regulators ; i++)
1636                 regulator_put(desc->charger_regulators[i].consumer);
1637
1638         power_supply_unregister(&cm->charger_psy);
1639 err_register:
1640         kfree(cm->charger_psy.properties);
1641 err_chg_stat:
1642         kfree(cm->charger_stat);
1643 err_no_charger_stat:
1644 err_no_charger:
1645         kfree(cm->desc);
1646 err_alloc_desc:
1647         kfree(cm);
1648 err_alloc:
1649         return ret;
1650 }
1651
1652 static int charger_manager_remove(struct platform_device *pdev)
1653 {
1654         struct charger_manager *cm = platform_get_drvdata(pdev);
1655         struct charger_desc *desc = cm->desc;
1656         int i = 0;
1657         int j = 0;
1658
1659         /* Remove from the list */
1660         mutex_lock(&cm_list_mtx);
1661         list_del(&cm->entry);
1662         mutex_unlock(&cm_list_mtx);
1663
1664         if (work_pending(&setup_polling))
1665                 cancel_work_sync(&setup_polling);
1666         if (delayed_work_pending(&cm_monitor_work))
1667                 cancel_delayed_work_sync(&cm_monitor_work);
1668
1669         for (i = 0 ; i < desc->num_charger_regulators ; i++) {
1670                 struct charger_regulator *charger
1671                                 = &desc->charger_regulators[i];
1672                 for (j = 0 ; j < charger->num_cables ; j++) {
1673                         struct charger_cable *cable = &charger->cables[j];
1674                         extcon_unregister_interest(&cable->extcon_dev);
1675                 }
1676         }
1677
1678         for (i = 0 ; i < desc->num_charger_regulators ; i++)
1679                 regulator_put(desc->charger_regulators[i].consumer);
1680
1681         power_supply_unregister(&cm->charger_psy);
1682
1683         try_charger_enable(cm, false);
1684
1685         kfree(cm->charger_psy.properties);
1686         kfree(cm->charger_stat);
1687         kfree(cm->desc);
1688         kfree(cm);
1689
1690         return 0;
1691 }
1692
1693 static const struct platform_device_id charger_manager_id[] = {
1694         { "charger-manager", 0 },
1695         { },
1696 };
1697 MODULE_DEVICE_TABLE(platform, charger_manager_id);
1698
1699 static int cm_suspend_noirq(struct device *dev)
1700 {
1701         int ret = 0;
1702
1703         if (device_may_wakeup(dev)) {
1704                 device_set_wakeup_capable(dev, false);
1705                 ret = -EAGAIN;
1706         }
1707
1708         return ret;
1709 }
1710
1711 static int cm_suspend_prepare(struct device *dev)
1712 {
1713         struct charger_manager *cm = dev_get_drvdata(dev);
1714
1715         if (!cm_suspended) {
1716                 if (rtc_dev) {
1717                         struct rtc_time tmp;
1718                         unsigned long now;
1719
1720                         rtc_read_alarm(rtc_dev, &rtc_wkalarm_save);
1721                         rtc_read_time(rtc_dev, &tmp);
1722
1723                         if (rtc_wkalarm_save.enabled) {
1724                                 rtc_tm_to_time(&rtc_wkalarm_save.time,
1725                                                &rtc_wkalarm_save_time);
1726                                 rtc_tm_to_time(&tmp, &now);
1727                                 if (now > rtc_wkalarm_save_time)
1728                                         rtc_wkalarm_save_time = 0;
1729                         } else {
1730                                 rtc_wkalarm_save_time = 0;
1731                         }
1732                 }
1733                 cm_suspended = true;
1734         }
1735
1736         if (delayed_work_pending(&cm->fullbatt_vchk_work))
1737                 cancel_delayed_work(&cm->fullbatt_vchk_work);
1738         cm->status_save_ext_pwr_inserted = is_ext_pwr_online(cm);
1739         cm->status_save_batt = is_batt_present(cm);
1740
1741         if (!cm_rtc_set) {
1742                 cm_suspend_duration_ms = 0;
1743                 cm_rtc_set = cm_setup_timer();
1744         }
1745
1746         return 0;
1747 }
1748
1749 static void cm_suspend_complete(struct device *dev)
1750 {
1751         struct charger_manager *cm = dev_get_drvdata(dev);
1752
1753         if (cm_suspended) {
1754                 if (rtc_dev) {
1755                         struct rtc_wkalrm tmp;
1756
1757                         rtc_read_alarm(rtc_dev, &tmp);
1758                         rtc_wkalarm_save.pending = tmp.pending;
1759                         rtc_set_alarm(rtc_dev, &rtc_wkalarm_save);
1760                 }
1761                 cm_suspended = false;
1762                 cm_rtc_set = false;
1763         }
1764
1765         /* Re-enqueue delayed work (fullbatt_vchk_work) */
1766         if (cm->fullbatt_vchk_jiffies_at) {
1767                 unsigned long delay = 0;
1768                 unsigned long now = jiffies + CM_JIFFIES_SMALL;
1769
1770                 if (time_after_eq(now, cm->fullbatt_vchk_jiffies_at)) {
1771                         delay = (unsigned long)((long)now
1772                                 - (long)(cm->fullbatt_vchk_jiffies_at));
1773                         delay = jiffies_to_msecs(delay);
1774                 } else {
1775                         delay = 0;
1776                 }
1777
1778                 /*
1779                  * Account for cm_suspend_duration_ms if
1780                  * assume_timer_stops_in_suspend is active
1781                  */
1782                 if (g_desc && g_desc->assume_timer_stops_in_suspend) {
1783                         if (delay > cm_suspend_duration_ms)
1784                                 delay -= cm_suspend_duration_ms;
1785                         else
1786                                 delay = 0;
1787                 }
1788
1789                 queue_delayed_work(cm_wq, &cm->fullbatt_vchk_work,
1790                                    msecs_to_jiffies(delay));
1791         }
1792         device_set_wakeup_capable(cm->dev, false);
1793         uevent_notify(cm, NULL);
1794 }
1795
1796 static const struct dev_pm_ops charger_manager_pm = {
1797         .prepare        = cm_suspend_prepare,
1798         .suspend_noirq  = cm_suspend_noirq,
1799         .complete       = cm_suspend_complete,
1800 };
1801
1802 static struct platform_driver charger_manager_driver = {
1803         .driver = {
1804                 .name = "charger-manager",
1805                 .owner = THIS_MODULE,
1806                 .pm = &charger_manager_pm,
1807         },
1808         .probe = charger_manager_probe,
1809         .remove = charger_manager_remove,
1810         .id_table = charger_manager_id,
1811 };
1812
1813 static int __init charger_manager_init(void)
1814 {
1815         cm_wq = create_freezable_workqueue("charger_manager");
1816         INIT_DELAYED_WORK(&cm_monitor_work, cm_monitor_poller);
1817
1818         return platform_driver_register(&charger_manager_driver);
1819 }
1820 late_initcall(charger_manager_init);
1821
1822 static void __exit charger_manager_cleanup(void)
1823 {
1824         destroy_workqueue(cm_wq);
1825         cm_wq = NULL;
1826
1827         platform_driver_unregister(&charger_manager_driver);
1828 }
1829 module_exit(charger_manager_cleanup);
1830
1831 /**
1832  * find_power_supply - find the associated power_supply of charger
1833  * @cm: the Charger Manager representing the battery
1834  * @psy: pointer to instance of charger's power_supply
1835  */
1836 static bool find_power_supply(struct charger_manager *cm,
1837                         struct power_supply *psy)
1838 {
1839         int i;
1840         bool found = false;
1841
1842         for (i = 0; cm->charger_stat[i]; i++) {
1843                 if (psy == cm->charger_stat[i]) {
1844                         found = true;
1845                         break;
1846                 }
1847         }
1848
1849         return found;
1850 }
1851
1852 /**
1853  * cm_notify_event - charger driver notify Charger Manager of charger event
1854  * @psy: pointer to instance of charger's power_supply
1855  * @type: type of charger event
1856  * @msg: optional message passed to uevent_notify fuction
1857  */
1858 void cm_notify_event(struct power_supply *psy, enum cm_event_types type,
1859                      char *msg)
1860 {
1861         struct charger_manager *cm;
1862         bool found_power_supply = false;
1863
1864         if (psy == NULL)
1865                 return;
1866
1867         mutex_lock(&cm_list_mtx);
1868         list_for_each_entry(cm, &cm_list, entry) {
1869                 found_power_supply = find_power_supply(cm, psy);
1870                 if (found_power_supply)
1871                         break;
1872         }
1873         mutex_unlock(&cm_list_mtx);
1874
1875         if (!found_power_supply)
1876                 return;
1877
1878         switch (type) {
1879         case CM_EVENT_BATT_FULL:
1880                 fullbatt_handler(cm);
1881                 break;
1882         case CM_EVENT_BATT_OUT:
1883                 battout_handler(cm);
1884                 break;
1885         case CM_EVENT_BATT_IN:
1886         case CM_EVENT_EXT_PWR_IN_OUT ... CM_EVENT_CHG_START_STOP:
1887                 misc_event_handler(cm, type);
1888                 break;
1889         case CM_EVENT_UNKNOWN:
1890         case CM_EVENT_OTHERS:
1891                 uevent_notify(cm, msg ? msg : default_event_names[type]);
1892                 break;
1893         default:
1894                 dev_err(cm->dev, "%s type not specified.\n", __func__);
1895                 break;
1896         }
1897 }
1898 EXPORT_SYMBOL_GPL(cm_notify_event);
1899
1900 MODULE_AUTHOR("MyungJoo Ham <myungjoo.ham@samsung.com>");
1901 MODULE_DESCRIPTION("Charger Manager");
1902 MODULE_LICENSE("GPL");