linux/drivers/power/charger-manager.c
<<
>>
Prefs
   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
  27static 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
  55static LIST_HEAD(cm_list);
  56static DEFINE_MUTEX(cm_list_mtx);
  57
  58/* About in-suspend (suspend-again) monitoring */
  59static struct rtc_device *rtc_dev;
  60/*
  61 * Backup RTC alarm
  62 * Save the wakeup alarm before entering suspend-to-RAM
  63 */
  64static struct rtc_wkalrm rtc_wkalarm_save;
  65/* Backup RTC alarm time in terms of seconds since 01-01-1970 00:00:00 */
  66static unsigned long rtc_wkalarm_save_time;
  67static bool cm_suspended;
  68static bool cm_rtc_set;
  69static unsigned long cm_suspend_duration_ms;
  70
  71/* About normal (not suspended) monitoring */
  72static unsigned long polling_jiffy = ULONG_MAX; /* ULONG_MAX: no polling */
  73static unsigned long next_polling; /* Next appointed polling time */
  74static struct workqueue_struct *cm_wq; /* init at driver add */
  75static struct delayed_work cm_monitor_work; /* init at driver add */
  76
  77/* Global charger-manager description */
  78static 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 */
  84static 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 */
 126static 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 */
 154static 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 */
 175static 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 */
 234static 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 */
 279static 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 */
 308static 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 */
 387static 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 */
 413static 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 */
 465static 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 */
 507static 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 */
 551static 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 */
 621static 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 */
 642static 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
 681out:
 682        mutex_unlock(&cm_list_mtx);
 683}
 684static 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 */
 693static 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 */
 703static 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
 721out:
 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 */
 730static 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 */
 748static 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
 760static 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)
 899static 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
 917static 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 */
 935static 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
1018static 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 */
1041bool 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();
1067out:
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}
1082EXPORT_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 */
1088int 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}
1117EXPORT_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 */
1125static 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 */
1156static 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 */
1194static 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) */
1219static 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
1228static 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
1241static 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
1250static 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
1306static 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
1616err_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        }
1625err_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        }
1634err_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);
1639err_register:
1640        kfree(cm->charger_psy.properties);
1641err_chg_stat:
1642        kfree(cm->charger_stat);
1643err_no_charger_stat:
1644err_no_charger:
1645        kfree(cm->desc);
1646err_alloc_desc:
1647        kfree(cm);
1648err_alloc:
1649        return ret;
1650}
1651
1652static 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
1693static const struct platform_device_id charger_manager_id[] = {
1694        { "charger-manager", 0 },
1695        { },
1696};
1697MODULE_DEVICE_TABLE(platform, charger_manager_id);
1698
1699static 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
1711static 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
1749static 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
1796static 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
1802static 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
1813static 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}
1820late_initcall(charger_manager_init);
1821
1822static 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}
1829module_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 */
1836static 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 */
1858void 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}
1898EXPORT_SYMBOL_GPL(cm_notify_event);
1899
1900MODULE_AUTHOR("MyungJoo Ham <myungjoo.ham@samsung.com>");
1901MODULE_DESCRIPTION("Charger Manager");
1902MODULE_LICENSE("GPL");
1903
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.