linux/drivers/power/supply/abx500_chargalg.c
<<
>>
Prefs
   1// SPDX-License-Identifier: GPL-2.0-only
   2/*
   3 * Copyright (C) ST-Ericsson SA 2012
   4 * Copyright (c) 2012 Sony Mobile Communications AB
   5 *
   6 * Charging algorithm driver for abx500 variants
   7 *
   8 * Authors:
   9 *      Johan Palsson <johan.palsson@stericsson.com>
  10 *      Karl Komierowski <karl.komierowski@stericsson.com>
  11 *      Arun R Murthy <arun.murthy@stericsson.com>
  12 *      Author: Imre Sunyi <imre.sunyi@sonymobile.com>
  13 */
  14
  15#include <linux/init.h>
  16#include <linux/module.h>
  17#include <linux/device.h>
  18#include <linux/hrtimer.h>
  19#include <linux/interrupt.h>
  20#include <linux/delay.h>
  21#include <linux/slab.h>
  22#include <linux/platform_device.h>
  23#include <linux/power_supply.h>
  24#include <linux/completion.h>
  25#include <linux/workqueue.h>
  26#include <linux/kobject.h>
  27#include <linux/of.h>
  28#include <linux/mfd/core.h>
  29#include <linux/mfd/abx500.h>
  30#include <linux/mfd/abx500/ab8500.h>
  31#include <linux/mfd/abx500/ux500_chargalg.h>
  32#include <linux/mfd/abx500/ab8500-bm.h>
  33#include <linux/notifier.h>
  34
  35/* Watchdog kick interval */
  36#define CHG_WD_INTERVAL                 (6 * HZ)
  37
  38/* End-of-charge criteria counter */
  39#define EOC_COND_CNT                    10
  40
  41/* One hour expressed in seconds */
  42#define ONE_HOUR_IN_SECONDS            3600
  43
  44/* Five minutes expressed in seconds */
  45#define FIVE_MINUTES_IN_SECONDS        300
  46
  47#define CHARGALG_CURR_STEP_LOW          0
  48#define CHARGALG_CURR_STEP_HIGH 100
  49
  50enum abx500_chargers {
  51        NO_CHG,
  52        AC_CHG,
  53        USB_CHG,
  54};
  55
  56struct abx500_chargalg_charger_info {
  57        enum abx500_chargers conn_chg;
  58        enum abx500_chargers prev_conn_chg;
  59        enum abx500_chargers online_chg;
  60        enum abx500_chargers prev_online_chg;
  61        enum abx500_chargers charger_type;
  62        bool usb_chg_ok;
  63        bool ac_chg_ok;
  64        int usb_volt;
  65        int usb_curr;
  66        int ac_volt;
  67        int ac_curr;
  68        int usb_vset;
  69        int usb_iset;
  70        int ac_vset;
  71        int ac_iset;
  72};
  73
  74struct abx500_chargalg_suspension_status {
  75        bool suspended_change;
  76        bool ac_suspended;
  77        bool usb_suspended;
  78};
  79
  80struct abx500_chargalg_current_step_status {
  81        bool curr_step_change;
  82        int curr_step;
  83};
  84
  85struct abx500_chargalg_battery_data {
  86        int temp;
  87        int volt;
  88        int avg_curr;
  89        int inst_curr;
  90        int percent;
  91};
  92
  93enum abx500_chargalg_states {
  94        STATE_HANDHELD_INIT,
  95        STATE_HANDHELD,
  96        STATE_CHG_NOT_OK_INIT,
  97        STATE_CHG_NOT_OK,
  98        STATE_HW_TEMP_PROTECT_INIT,
  99        STATE_HW_TEMP_PROTECT,
 100        STATE_NORMAL_INIT,
 101        STATE_NORMAL,
 102        STATE_WAIT_FOR_RECHARGE_INIT,
 103        STATE_WAIT_FOR_RECHARGE,
 104        STATE_MAINTENANCE_A_INIT,
 105        STATE_MAINTENANCE_A,
 106        STATE_MAINTENANCE_B_INIT,
 107        STATE_MAINTENANCE_B,
 108        STATE_TEMP_UNDEROVER_INIT,
 109        STATE_TEMP_UNDEROVER,
 110        STATE_TEMP_LOWHIGH_INIT,
 111        STATE_TEMP_LOWHIGH,
 112        STATE_SUSPENDED_INIT,
 113        STATE_SUSPENDED,
 114        STATE_OVV_PROTECT_INIT,
 115        STATE_OVV_PROTECT,
 116        STATE_SAFETY_TIMER_EXPIRED_INIT,
 117        STATE_SAFETY_TIMER_EXPIRED,
 118        STATE_BATT_REMOVED_INIT,
 119        STATE_BATT_REMOVED,
 120        STATE_WD_EXPIRED_INIT,
 121        STATE_WD_EXPIRED,
 122};
 123
 124static const char *states[] = {
 125        "HANDHELD_INIT",
 126        "HANDHELD",
 127        "CHG_NOT_OK_INIT",
 128        "CHG_NOT_OK",
 129        "HW_TEMP_PROTECT_INIT",
 130        "HW_TEMP_PROTECT",
 131        "NORMAL_INIT",
 132        "NORMAL",
 133        "WAIT_FOR_RECHARGE_INIT",
 134        "WAIT_FOR_RECHARGE",
 135        "MAINTENANCE_A_INIT",
 136        "MAINTENANCE_A",
 137        "MAINTENANCE_B_INIT",
 138        "MAINTENANCE_B",
 139        "TEMP_UNDEROVER_INIT",
 140        "TEMP_UNDEROVER",
 141        "TEMP_LOWHIGH_INIT",
 142        "TEMP_LOWHIGH",
 143        "SUSPENDED_INIT",
 144        "SUSPENDED",
 145        "OVV_PROTECT_INIT",
 146        "OVV_PROTECT",
 147        "SAFETY_TIMER_EXPIRED_INIT",
 148        "SAFETY_TIMER_EXPIRED",
 149        "BATT_REMOVED_INIT",
 150        "BATT_REMOVED",
 151        "WD_EXPIRED_INIT",
 152        "WD_EXPIRED",
 153};
 154
 155struct abx500_chargalg_events {
 156        bool batt_unknown;
 157        bool mainextchnotok;
 158        bool batt_ovv;
 159        bool batt_rem;
 160        bool btemp_underover;
 161        bool btemp_lowhigh;
 162        bool main_thermal_prot;
 163        bool usb_thermal_prot;
 164        bool main_ovv;
 165        bool vbus_ovv;
 166        bool usbchargernotok;
 167        bool safety_timer_expired;
 168        bool maintenance_timer_expired;
 169        bool ac_wd_expired;
 170        bool usb_wd_expired;
 171        bool ac_cv_active;
 172        bool usb_cv_active;
 173        bool vbus_collapsed;
 174};
 175
 176/**
 177 * struct abx500_charge_curr_maximization - Charger maximization parameters
 178 * @original_iset:      the non optimized/maximised charger current
 179 * @current_iset:       the charging current used at this moment
 180 * @test_delta_i:       the delta between the current we want to charge and the
 181                        current that is really going into the battery
 182 * @condition_cnt:      number of iterations needed before a new charger current
 183                        is set
 184 * @max_current:        maximum charger current
 185 * @wait_cnt:           to avoid too fast current step down in case of charger
 186 *                      voltage collapse, we insert this delay between step
 187 *                      down
 188 * @level:              tells in how many steps the charging current has been
 189                        increased
 190 */
 191struct abx500_charge_curr_maximization {
 192        int original_iset;
 193        int current_iset;
 194        int test_delta_i;
 195        int condition_cnt;
 196        int max_current;
 197        int wait_cnt;
 198        u8 level;
 199};
 200
 201enum maxim_ret {
 202        MAXIM_RET_NOACTION,
 203        MAXIM_RET_CHANGE,
 204        MAXIM_RET_IBAT_TOO_HIGH,
 205};
 206
 207/**
 208 * struct abx500_chargalg - abx500 Charging algorithm device information
 209 * @dev:                pointer to the structure device
 210 * @charge_status:      battery operating status
 211 * @eoc_cnt:            counter used to determine end-of_charge
 212 * @maintenance_chg:    indicate if maintenance charge is active
 213 * @t_hyst_norm         temperature hysteresis when the temperature has been
 214 *                      over or under normal limits
 215 * @t_hyst_lowhigh      temperature hysteresis when the temperature has been
 216 *                      over or under the high or low limits
 217 * @charge_state:       current state of the charging algorithm
 218 * @ccm                 charging current maximization parameters
 219 * @chg_info:           information about connected charger types
 220 * @batt_data:          data of the battery
 221 * @susp_status:        current charger suspension status
 222 * @bm:                 Platform specific battery management information
 223 * @curr_status:        Current step status for over-current protection
 224 * @parent:             pointer to the struct abx500
 225 * @chargalg_psy:       structure that holds the battery properties exposed by
 226 *                      the charging algorithm
 227 * @events:             structure for information about events triggered
 228 * @chargalg_wq:                work queue for running the charging algorithm
 229 * @chargalg_periodic_work:     work to run the charging algorithm periodically
 230 * @chargalg_wd_work:           work to kick the charger watchdog periodically
 231 * @chargalg_work:              work to run the charging algorithm instantly
 232 * @safety_timer:               charging safety timer
 233 * @maintenance_timer:          maintenance charging timer
 234 * @chargalg_kobject:           structure of type kobject
 235 */
 236struct abx500_chargalg {
 237        struct device *dev;
 238        int charge_status;
 239        int eoc_cnt;
 240        bool maintenance_chg;
 241        int t_hyst_norm;
 242        int t_hyst_lowhigh;
 243        enum abx500_chargalg_states charge_state;
 244        struct abx500_charge_curr_maximization ccm;
 245        struct abx500_chargalg_charger_info chg_info;
 246        struct abx500_chargalg_battery_data batt_data;
 247        struct abx500_chargalg_suspension_status susp_status;
 248        struct ab8500 *parent;
 249        struct abx500_chargalg_current_step_status curr_status;
 250        struct abx500_bm_data *bm;
 251        struct power_supply *chargalg_psy;
 252        struct ux500_charger *ac_chg;
 253        struct ux500_charger *usb_chg;
 254        struct abx500_chargalg_events events;
 255        struct workqueue_struct *chargalg_wq;
 256        struct delayed_work chargalg_periodic_work;
 257        struct delayed_work chargalg_wd_work;
 258        struct work_struct chargalg_work;
 259        struct hrtimer safety_timer;
 260        struct hrtimer maintenance_timer;
 261        struct kobject chargalg_kobject;
 262};
 263
 264/*External charger prepare notifier*/
 265BLOCKING_NOTIFIER_HEAD(charger_notifier_list);
 266
 267/* Main battery properties */
 268static enum power_supply_property abx500_chargalg_props[] = {
 269        POWER_SUPPLY_PROP_STATUS,
 270        POWER_SUPPLY_PROP_HEALTH,
 271};
 272
 273struct abx500_chargalg_sysfs_entry {
 274        struct attribute attr;
 275        ssize_t (*show)(struct abx500_chargalg *, char *);
 276        ssize_t (*store)(struct abx500_chargalg *, const char *, size_t);
 277};
 278
 279/**
 280 * abx500_chargalg_safety_timer_expired() - Expiration of the safety timer
 281 * @timer:     pointer to the hrtimer structure
 282 *
 283 * This function gets called when the safety timer for the charger
 284 * expires
 285 */
 286static enum hrtimer_restart
 287abx500_chargalg_safety_timer_expired(struct hrtimer *timer)
 288{
 289        struct abx500_chargalg *di = container_of(timer, struct abx500_chargalg,
 290                                                  safety_timer);
 291        dev_err(di->dev, "Safety timer expired\n");
 292        di->events.safety_timer_expired = true;
 293
 294        /* Trigger execution of the algorithm instantly */
 295        queue_work(di->chargalg_wq, &di->chargalg_work);
 296
 297        return HRTIMER_NORESTART;
 298}
 299
 300/**
 301 * abx500_chargalg_maintenance_timer_expired() - Expiration of
 302 * the maintenance timer
 303 * @timer:     pointer to the timer structure
 304 *
 305 * This function gets called when the maintenence timer
 306 * expires
 307 */
 308static enum hrtimer_restart
 309abx500_chargalg_maintenance_timer_expired(struct hrtimer *timer)
 310{
 311
 312        struct abx500_chargalg *di = container_of(timer, struct abx500_chargalg,
 313                                                  maintenance_timer);
 314
 315        dev_dbg(di->dev, "Maintenance timer expired\n");
 316        di->events.maintenance_timer_expired = true;
 317
 318        /* Trigger execution of the algorithm instantly */
 319        queue_work(di->chargalg_wq, &di->chargalg_work);
 320
 321        return HRTIMER_NORESTART;
 322}
 323
 324/**
 325 * abx500_chargalg_state_to() - Change charge state
 326 * @di:         pointer to the abx500_chargalg structure
 327 *
 328 * This function gets called when a charge state change should occur
 329 */
 330static void abx500_chargalg_state_to(struct abx500_chargalg *di,
 331        enum abx500_chargalg_states state)
 332{
 333        dev_dbg(di->dev,
 334                "State changed: %s (From state: [%d] %s =to=> [%d] %s )\n",
 335                di->charge_state == state ? "NO" : "YES",
 336                di->charge_state,
 337                states[di->charge_state],
 338                state,
 339                states[state]);
 340
 341        di->charge_state = state;
 342}
 343
 344static int abx500_chargalg_check_charger_enable(struct abx500_chargalg *di)
 345{
 346        switch (di->charge_state) {
 347        case STATE_NORMAL:
 348        case STATE_MAINTENANCE_A:
 349        case STATE_MAINTENANCE_B:
 350                break;
 351        default:
 352                return 0;
 353        }
 354
 355        if (di->chg_info.charger_type & USB_CHG) {
 356                return di->usb_chg->ops.check_enable(di->usb_chg,
 357                        di->bm->bat_type[di->bm->batt_id].normal_vol_lvl,
 358                        di->bm->bat_type[di->bm->batt_id].normal_cur_lvl);
 359        } else if ((di->chg_info.charger_type & AC_CHG) &&
 360                   !(di->ac_chg->external)) {
 361                return di->ac_chg->ops.check_enable(di->ac_chg,
 362                        di->bm->bat_type[di->bm->batt_id].normal_vol_lvl,
 363                        di->bm->bat_type[di->bm->batt_id].normal_cur_lvl);
 364        }
 365        return 0;
 366}
 367
 368/**
 369 * abx500_chargalg_check_charger_connection() - Check charger connection change
 370 * @di:         pointer to the abx500_chargalg structure
 371 *
 372 * This function will check if there is a change in the charger connection
 373 * and change charge state accordingly. AC has precedence over USB.
 374 */
 375static int abx500_chargalg_check_charger_connection(struct abx500_chargalg *di)
 376{
 377        if (di->chg_info.conn_chg != di->chg_info.prev_conn_chg ||
 378                di->susp_status.suspended_change) {
 379                /*
 380                 * Charger state changed or suspension
 381                 * has changed since last update
 382                 */
 383                if ((di->chg_info.conn_chg & AC_CHG) &&
 384                        !di->susp_status.ac_suspended) {
 385                        dev_dbg(di->dev, "Charging source is AC\n");
 386                        if (di->chg_info.charger_type != AC_CHG) {
 387                                di->chg_info.charger_type = AC_CHG;
 388                                abx500_chargalg_state_to(di, STATE_NORMAL_INIT);
 389                        }
 390                } else if ((di->chg_info.conn_chg & USB_CHG) &&
 391                        !di->susp_status.usb_suspended) {
 392                        dev_dbg(di->dev, "Charging source is USB\n");
 393                        di->chg_info.charger_type = USB_CHG;
 394                        abx500_chargalg_state_to(di, STATE_NORMAL_INIT);
 395                } else if (di->chg_info.conn_chg &&
 396                        (di->susp_status.ac_suspended ||
 397                        di->susp_status.usb_suspended)) {
 398                        dev_dbg(di->dev, "Charging is suspended\n");
 399                        di->chg_info.charger_type = NO_CHG;
 400                        abx500_chargalg_state_to(di, STATE_SUSPENDED_INIT);
 401                } else {
 402                        dev_dbg(di->dev, "Charging source is OFF\n");
 403                        di->chg_info.charger_type = NO_CHG;
 404                        abx500_chargalg_state_to(di, STATE_HANDHELD_INIT);
 405                }
 406                di->chg_info.prev_conn_chg = di->chg_info.conn_chg;
 407                di->susp_status.suspended_change = false;
 408        }
 409        return di->chg_info.conn_chg;
 410}
 411
 412/**
 413 * abx500_chargalg_check_current_step_status() - Check charging current
 414 * step status.
 415 * @di:         pointer to the abx500_chargalg structure
 416 *
 417 * This function will check if there is a change in the charging current step
 418 * and change charge state accordingly.
 419 */
 420static void abx500_chargalg_check_current_step_status
 421        (struct abx500_chargalg *di)
 422{
 423        if (di->curr_status.curr_step_change)
 424                abx500_chargalg_state_to(di, STATE_NORMAL_INIT);
 425        di->curr_status.curr_step_change = false;
 426}
 427
 428/**
 429 * abx500_chargalg_start_safety_timer() - Start charging safety timer
 430 * @di:         pointer to the abx500_chargalg structure
 431 *
 432 * The safety timer is used to avoid overcharging of old or bad batteries.
 433 * There are different timers for AC and USB
 434 */
 435static void abx500_chargalg_start_safety_timer(struct abx500_chargalg *di)
 436{
 437        /* Charger-dependent expiration time in hours*/
 438        int timer_expiration = 0;
 439
 440        switch (di->chg_info.charger_type) {
 441        case AC_CHG:
 442                timer_expiration = di->bm->main_safety_tmr_h;
 443                break;
 444
 445        case USB_CHG:
 446                timer_expiration = di->bm->usb_safety_tmr_h;
 447                break;
 448
 449        default:
 450                dev_err(di->dev, "Unknown charger to charge from\n");
 451                break;
 452        }
 453
 454        di->events.safety_timer_expired = false;
 455        hrtimer_set_expires_range(&di->safety_timer,
 456                ktime_set(timer_expiration * ONE_HOUR_IN_SECONDS, 0),
 457                ktime_set(FIVE_MINUTES_IN_SECONDS, 0));
 458        hrtimer_start_expires(&di->safety_timer, HRTIMER_MODE_REL);
 459}
 460
 461/**
 462 * abx500_chargalg_stop_safety_timer() - Stop charging safety timer
 463 * @di:         pointer to the abx500_chargalg structure
 464 *
 465 * The safety timer is stopped whenever the NORMAL state is exited
 466 */
 467static void abx500_chargalg_stop_safety_timer(struct abx500_chargalg *di)
 468{
 469        if (hrtimer_try_to_cancel(&di->safety_timer) >= 0)
 470                di->events.safety_timer_expired = false;
 471}
 472
 473/**
 474 * abx500_chargalg_start_maintenance_timer() - Start charging maintenance timer
 475 * @di:         pointer to the abx500_chargalg structure
 476 * @duration:   duration of ther maintenance timer in hours
 477 *
 478 * The maintenance timer is used to maintain the charge in the battery once
 479 * the battery is considered full. These timers are chosen to match the
 480 * discharge curve of the battery
 481 */
 482static void abx500_chargalg_start_maintenance_timer(struct abx500_chargalg *di,
 483        int duration)
 484{
 485        hrtimer_set_expires_range(&di->maintenance_timer,
 486                ktime_set(duration * ONE_HOUR_IN_SECONDS, 0),
 487                ktime_set(FIVE_MINUTES_IN_SECONDS, 0));
 488        di->events.maintenance_timer_expired = false;
 489        hrtimer_start_expires(&di->maintenance_timer, HRTIMER_MODE_REL);
 490}
 491
 492/**
 493 * abx500_chargalg_stop_maintenance_timer() - Stop maintenance timer
 494 * @di:         pointer to the abx500_chargalg structure
 495 *
 496 * The maintenance timer is stopped whenever maintenance ends or when another
 497 * state is entered
 498 */
 499static void abx500_chargalg_stop_maintenance_timer(struct abx500_chargalg *di)
 500{
 501        if (hrtimer_try_to_cancel(&di->maintenance_timer) >= 0)
 502                di->events.maintenance_timer_expired = false;
 503}
 504
 505/**
 506 * abx500_chargalg_kick_watchdog() - Kick charger watchdog
 507 * @di:         pointer to the abx500_chargalg structure
 508 *
 509 * The charger watchdog have to be kicked periodically whenever the charger is
 510 * on, else the ABB will reset the system
 511 */
 512static int abx500_chargalg_kick_watchdog(struct abx500_chargalg *di)
 513{
 514        /* Check if charger exists and kick watchdog if charging */
 515        if (di->ac_chg && di->ac_chg->ops.kick_wd &&
 516            di->chg_info.online_chg & AC_CHG) {
 517                /*
 518                 * If AB charger watchdog expired, pm2xxx charging
 519                 * gets disabled. To be safe, kick both AB charger watchdog
 520                 * and pm2xxx watchdog.
 521                 */
 522                if (di->ac_chg->external &&
 523                    di->usb_chg && di->usb_chg->ops.kick_wd)
 524                        di->usb_chg->ops.kick_wd(di->usb_chg);
 525
 526                return di->ac_chg->ops.kick_wd(di->ac_chg);
 527        }
 528        else if (di->usb_chg && di->usb_chg->ops.kick_wd &&
 529                        di->chg_info.online_chg & USB_CHG)
 530                return di->usb_chg->ops.kick_wd(di->usb_chg);
 531
 532        return -ENXIO;
 533}
 534
 535/**
 536 * abx500_chargalg_ac_en() - Turn on/off the AC charger
 537 * @di:         pointer to the abx500_chargalg structure
 538 * @enable:     charger on/off
 539 * @vset:       requested charger output voltage
 540 * @iset:       requested charger output current
 541 *
 542 * The AC charger will be turned on/off with the requested charge voltage and
 543 * current
 544 */
 545static int abx500_chargalg_ac_en(struct abx500_chargalg *di, int enable,
 546        int vset, int iset)
 547{
 548        static int abx500_chargalg_ex_ac_enable_toggle;
 549
 550        if (!di->ac_chg || !di->ac_chg->ops.enable)
 551                return -ENXIO;
 552
 553        /* Select maximum of what both the charger and the battery supports */
 554        if (di->ac_chg->max_out_volt)
 555                vset = min(vset, di->ac_chg->max_out_volt);
 556        if (di->ac_chg->max_out_curr)
 557                iset = min(iset, di->ac_chg->max_out_curr);
 558
 559        di->chg_info.ac_iset = iset;
 560        di->chg_info.ac_vset = vset;
 561
 562        /* Enable external charger */
 563        if (enable && di->ac_chg->external &&
 564            !abx500_chargalg_ex_ac_enable_toggle) {
 565                blocking_notifier_call_chain(&charger_notifier_list,
 566                                             0, di->dev);
 567                abx500_chargalg_ex_ac_enable_toggle++;
 568        }
 569
 570        return di->ac_chg->ops.enable(di->ac_chg, enable, vset, iset);
 571}
 572
 573/**
 574 * abx500_chargalg_usb_en() - Turn on/off the USB charger
 575 * @di:         pointer to the abx500_chargalg structure
 576 * @enable:     charger on/off
 577 * @vset:       requested charger output voltage
 578 * @iset:       requested charger output current
 579 *
 580 * The USB charger will be turned on/off with the requested charge voltage and
 581 * current
 582 */
 583static int abx500_chargalg_usb_en(struct abx500_chargalg *di, int enable,
 584        int vset, int iset)
 585{
 586        if (!di->usb_chg || !di->usb_chg->ops.enable)
 587                return -ENXIO;
 588
 589        /* Select maximum of what both the charger and the battery supports */
 590        if (di->usb_chg->max_out_volt)
 591                vset = min(vset, di->usb_chg->max_out_volt);
 592        if (di->usb_chg->max_out_curr)
 593                iset = min(iset, di->usb_chg->max_out_curr);
 594
 595        di->chg_info.usb_iset = iset;
 596        di->chg_info.usb_vset = vset;
 597
 598        return di->usb_chg->ops.enable(di->usb_chg, enable, vset, iset);
 599}
 600
 601/**
 602 * abx500_chargalg_update_chg_curr() - Update charger current
 603 * @di:         pointer to the abx500_chargalg structure
 604 * @iset:       requested charger output current
 605 *
 606 * The charger output current will be updated for the charger
 607 * that is currently in use
 608 */
 609static int abx500_chargalg_update_chg_curr(struct abx500_chargalg *di,
 610                int iset)
 611{
 612        /* Check if charger exists and update current if charging */
 613        if (di->ac_chg && di->ac_chg->ops.update_curr &&
 614                        di->chg_info.charger_type & AC_CHG) {
 615                /*
 616                 * Select maximum of what both the charger
 617                 * and the battery supports
 618                 */
 619                if (di->ac_chg->max_out_curr)
 620                        iset = min(iset, di->ac_chg->max_out_curr);
 621
 622                di->chg_info.ac_iset = iset;
 623
 624                return di->ac_chg->ops.update_curr(di->ac_chg, iset);
 625        } else if (di->usb_chg && di->usb_chg->ops.update_curr &&
 626                        di->chg_info.charger_type & USB_CHG) {
 627                /*
 628                 * Select maximum of what both the charger
 629                 * and the battery supports
 630                 */
 631                if (di->usb_chg->max_out_curr)
 632                        iset = min(iset, di->usb_chg->max_out_curr);
 633
 634                di->chg_info.usb_iset = iset;
 635
 636                return di->usb_chg->ops.update_curr(di->usb_chg, iset);
 637        }
 638
 639        return -ENXIO;
 640}
 641
 642/**
 643 * abx500_chargalg_stop_charging() - Stop charging
 644 * @di:         pointer to the abx500_chargalg structure
 645 *
 646 * This function is called from any state where charging should be stopped.
 647 * All charging is disabled and all status parameters and timers are changed
 648 * accordingly
 649 */
 650static void abx500_chargalg_stop_charging(struct abx500_chargalg *di)
 651{
 652        abx500_chargalg_ac_en(di, false, 0, 0);
 653        abx500_chargalg_usb_en(di, false, 0, 0);
 654        abx500_chargalg_stop_safety_timer(di);
 655        abx500_chargalg_stop_maintenance_timer(di);
 656        di->charge_status = POWER_SUPPLY_STATUS_NOT_CHARGING;
 657        di->maintenance_chg = false;
 658        cancel_delayed_work(&di->chargalg_wd_work);
 659        power_supply_changed(di->chargalg_psy);
 660}
 661
 662/**
 663 * abx500_chargalg_hold_charging() - Pauses charging
 664 * @di:         pointer to the abx500_chargalg structure
 665 *
 666 * This function is called in the case where maintenance charging has been
 667 * disabled and instead a battery voltage mode is entered to check when the
 668 * battery voltage has reached a certain recharge voltage
 669 */
 670static void abx500_chargalg_hold_charging(struct abx500_chargalg *di)
 671{
 672        abx500_chargalg_ac_en(di, false, 0, 0);
 673        abx500_chargalg_usb_en(di, false, 0, 0);
 674        abx500_chargalg_stop_safety_timer(di);
 675        abx500_chargalg_stop_maintenance_timer(di);
 676        di->charge_status = POWER_SUPPLY_STATUS_CHARGING;
 677        di->maintenance_chg = false;
 678        cancel_delayed_work(&di->chargalg_wd_work);
 679        power_supply_changed(di->chargalg_psy);
 680}
 681
 682/**
 683 * abx500_chargalg_start_charging() - Start the charger
 684 * @di:         pointer to the abx500_chargalg structure
 685 * @vset:       requested charger output voltage
 686 * @iset:       requested charger output current
 687 *
 688 * A charger will be enabled depending on the requested charger type that was
 689 * detected previously.
 690 */
 691static void abx500_chargalg_start_charging(struct abx500_chargalg *di,
 692        int vset, int iset)
 693{
 694        switch (di->chg_info.charger_type) {
 695        case AC_CHG:
 696                dev_dbg(di->dev,
 697                        "AC parameters: Vset %d, Ich %d\n", vset, iset);
 698                abx500_chargalg_usb_en(di, false, 0, 0);
 699                abx500_chargalg_ac_en(di, true, vset, iset);
 700                break;
 701
 702        case USB_CHG:
 703                dev_dbg(di->dev,
 704                        "USB parameters: Vset %d, Ich %d\n", vset, iset);
 705                abx500_chargalg_ac_en(di, false, 0, 0);
 706                abx500_chargalg_usb_en(di, true, vset, iset);
 707                break;
 708
 709        default:
 710                dev_err(di->dev, "Unknown charger to charge from\n");
 711                break;
 712        }
 713}
 714
 715/**
 716 * abx500_chargalg_check_temp() - Check battery temperature ranges
 717 * @di:         pointer to the abx500_chargalg structure
 718 *
 719 * The battery temperature is checked against the predefined limits and the
 720 * charge state is changed accordingly
 721 */
 722static void abx500_chargalg_check_temp(struct abx500_chargalg *di)
 723{
 724        if (di->batt_data.temp > (di->bm->temp_low + di->t_hyst_norm) &&
 725                di->batt_data.temp < (di->bm->temp_high - di->t_hyst_norm)) {
 726                /* Temp OK! */
 727                di->events.btemp_underover = false;
 728                di->events.btemp_lowhigh = false;
 729                di->t_hyst_norm = 0;
 730                di->t_hyst_lowhigh = 0;
 731        } else {
 732                if (((di->batt_data.temp >= di->bm->temp_high) &&
 733                        (di->batt_data.temp <
 734                                (di->bm->temp_over - di->t_hyst_lowhigh))) ||
 735                        ((di->batt_data.temp >
 736                                (di->bm->temp_under + di->t_hyst_lowhigh)) &&
 737                        (di->batt_data.temp <= di->bm->temp_low))) {
 738                        /* TEMP minor!!!!! */
 739                        di->events.btemp_underover = false;
 740                        di->events.btemp_lowhigh = true;
 741                        di->t_hyst_norm = di->bm->temp_hysteresis;
 742                        di->t_hyst_lowhigh = 0;
 743                } else if (di->batt_data.temp <= di->bm->temp_under ||
 744                        di->batt_data.temp >= di->bm->temp_over) {
 745                        /* TEMP major!!!!! */
 746                        di->events.btemp_underover = true;
 747                        di->events.btemp_lowhigh = false;
 748                        di->t_hyst_norm = 0;
 749                        di->t_hyst_lowhigh = di->bm->temp_hysteresis;
 750                } else {
 751                /* Within hysteresis */
 752                dev_dbg(di->dev, "Within hysteresis limit temp: %d "
 753                                "hyst_lowhigh %d, hyst normal %d\n",
 754                                di->batt_data.temp, di->t_hyst_lowhigh,
 755                                di->t_hyst_norm);
 756                }
 757        }
 758}
 759
 760/**
 761 * abx500_chargalg_check_charger_voltage() - Check charger voltage
 762 * @di:         pointer to the abx500_chargalg structure
 763 *
 764 * Charger voltage is checked against maximum limit
 765 */
 766static void abx500_chargalg_check_charger_voltage(struct abx500_chargalg *di)
 767{
 768        if (di->chg_info.usb_volt > di->bm->chg_params->usb_volt_max)
 769                di->chg_info.usb_chg_ok = false;
 770        else
 771                di->chg_info.usb_chg_ok = true;
 772
 773        if (di->chg_info.ac_volt > di->bm->chg_params->ac_volt_max)
 774                di->chg_info.ac_chg_ok = false;
 775        else
 776                di->chg_info.ac_chg_ok = true;
 777
 778}
 779
 780/**
 781 * abx500_chargalg_end_of_charge() - Check if end-of-charge criteria is fulfilled
 782 * @di:         pointer to the abx500_chargalg structure
 783 *
 784 * End-of-charge criteria is fulfilled when the battery voltage is above a
 785 * certain limit and the battery current is below a certain limit for a
 786 * predefined number of consecutive seconds. If true, the battery is full
 787 */
 788static void abx500_chargalg_end_of_charge(struct abx500_chargalg *di)
 789{
 790        if (di->charge_status == POWER_SUPPLY_STATUS_CHARGING &&
 791                di->charge_state == STATE_NORMAL &&
 792                !di->maintenance_chg && (di->batt_data.volt >=
 793                di->bm->bat_type[di->bm->batt_id].termination_vol ||
 794                di->events.usb_cv_active || di->events.ac_cv_active) &&
 795                di->batt_data.avg_curr <
 796                di->bm->bat_type[di->bm->batt_id].termination_curr &&
 797                di->batt_data.avg_curr > 0) {
 798                if (++di->eoc_cnt >= EOC_COND_CNT) {
 799                        di->eoc_cnt = 0;
 800                        di->charge_status = POWER_SUPPLY_STATUS_FULL;
 801                        di->maintenance_chg = true;
 802                        dev_dbg(di->dev, "EOC reached!\n");
 803                        power_supply_changed(di->chargalg_psy);
 804                } else {
 805                        dev_dbg(di->dev,
 806                                " EOC limit reached for the %d"
 807                                " time, out of %d before EOC\n",
 808                                di->eoc_cnt,
 809                                EOC_COND_CNT);
 810                }
 811        } else {
 812                di->eoc_cnt = 0;
 813        }
 814}
 815
 816static void init_maxim_chg_curr(struct abx500_chargalg *di)
 817{
 818        di->ccm.original_iset =
 819                di->bm->bat_type[di->bm->batt_id].normal_cur_lvl;
 820        di->ccm.current_iset =
 821                di->bm->bat_type[di->bm->batt_id].normal_cur_lvl;
 822        di->ccm.test_delta_i = di->bm->maxi->charger_curr_step;
 823        di->ccm.max_current = di->bm->maxi->chg_curr;
 824        di->ccm.condition_cnt = di->bm->maxi->wait_cycles;
 825        di->ccm.level = 0;
 826}
 827
 828/**
 829 * abx500_chargalg_chg_curr_maxim - increases the charger current to
 830 *                      compensate for the system load
 831 * @di          pointer to the abx500_chargalg structure
 832 *
 833 * This maximization function is used to raise the charger current to get the
 834 * battery current as close to the optimal value as possible. The battery
 835 * current during charging is affected by the system load
 836 */
 837static enum maxim_ret abx500_chargalg_chg_curr_maxim(struct abx500_chargalg *di)
 838{
 839        int delta_i;
 840
 841        if (!di->bm->maxi->ena_maxi)
 842                return MAXIM_RET_NOACTION;
 843
 844        delta_i = di->ccm.original_iset - di->batt_data.inst_curr;
 845
 846        if (di->events.vbus_collapsed) {
 847                dev_dbg(di->dev, "Charger voltage has collapsed %d\n",
 848                                di->ccm.wait_cnt);
 849                if (di->ccm.wait_cnt == 0) {
 850                        dev_dbg(di->dev, "lowering current\n");
 851                        di->ccm.wait_cnt++;
 852                        di->ccm.condition_cnt = di->bm->maxi->wait_cycles;
 853                        di->ccm.max_current =
 854                                di->ccm.current_iset - di->ccm.test_delta_i;
 855                        di->ccm.current_iset = di->ccm.max_current;
 856                        di->ccm.level--;
 857                        return MAXIM_RET_CHANGE;
 858                } else {
 859                        dev_dbg(di->dev, "waiting\n");
 860                        /* Let's go in here twice before lowering curr again */
 861                        di->ccm.wait_cnt = (di->ccm.wait_cnt + 1) % 3;
 862                        return MAXIM_RET_NOACTION;
 863                }
 864        }
 865
 866        di->ccm.wait_cnt = 0;
 867
 868        if ((di->batt_data.inst_curr > di->ccm.original_iset)) {
 869                dev_dbg(di->dev, " Maximization Ibat (%dmA) too high"
 870                        " (limit %dmA) (current iset: %dmA)!\n",
 871                        di->batt_data.inst_curr, di->ccm.original_iset,
 872                        di->ccm.current_iset);
 873
 874                if (di->ccm.current_iset == di->ccm.original_iset)
 875                        return MAXIM_RET_NOACTION;
 876
 877                di->ccm.condition_cnt = di->bm->maxi->wait_cycles;
 878                di->ccm.current_iset = di->ccm.original_iset;
 879                di->ccm.level = 0;
 880
 881                return MAXIM_RET_IBAT_TOO_HIGH;
 882        }
 883
 884        if (delta_i > di->ccm.test_delta_i &&
 885                (di->ccm.current_iset + di->ccm.test_delta_i) <
 886                di->ccm.max_current) {
 887                if (di->ccm.condition_cnt-- == 0) {
 888                        /* Increse the iset with cco.test_delta_i */
 889                        di->ccm.condition_cnt = di->bm->maxi->wait_cycles;
 890                        di->ccm.current_iset += di->ccm.test_delta_i;
 891                        di->ccm.level++;
 892                        dev_dbg(di->dev, " Maximization needed, increase"
 893                                " with %d mA to %dmA (Optimal ibat: %d)"
 894                                " Level %d\n",
 895                                di->ccm.test_delta_i,
 896                                di->ccm.current_iset,
 897                                di->ccm.original_iset,
 898                                di->ccm.level);
 899                        return MAXIM_RET_CHANGE;
 900                } else {
 901                        return MAXIM_RET_NOACTION;
 902                }
 903        }  else {
 904                di->ccm.condition_cnt = di->bm->maxi->wait_cycles;
 905                return MAXIM_RET_NOACTION;
 906        }
 907}
 908
 909static void handle_maxim_chg_curr(struct abx500_chargalg *di)
 910{
 911        enum maxim_ret ret;
 912        int result;
 913
 914        ret = abx500_chargalg_chg_curr_maxim(di);
 915        switch (ret) {
 916        case MAXIM_RET_CHANGE:
 917                result = abx500_chargalg_update_chg_curr(di,
 918                        di->ccm.current_iset);
 919                if (result)
 920                        dev_err(di->dev, "failed to set chg curr\n");
 921                break;
 922        case MAXIM_RET_IBAT_TOO_HIGH:
 923                result = abx500_chargalg_update_chg_curr(di,
 924                        di->bm->bat_type[di->bm->batt_id].normal_cur_lvl);
 925                if (result)
 926                        dev_err(di->dev, "failed to set chg curr\n");
 927                break;
 928
 929        case MAXIM_RET_NOACTION:
 930        default:
 931                /* Do nothing..*/
 932                break;
 933        }
 934}
 935
 936static int abx500_chargalg_get_ext_psy_data(struct device *dev, void *data)
 937{
 938        struct power_supply *psy;
 939        struct power_supply *ext = dev_get_drvdata(dev);
 940        const char **supplicants = (const char **)ext->supplied_to;
 941        struct abx500_chargalg *di;
 942        union power_supply_propval ret;
 943        int j;
 944        bool capacity_updated = false;
 945
 946        psy = (struct power_supply *)data;
 947        di = power_supply_get_drvdata(psy);
 948        /* For all psy where the driver name appears in any supplied_to */
 949        j = match_string(supplicants, ext->num_supplicants, psy->desc->name);
 950        if (j < 0)
 951                return 0;
 952
 953        /*
 954         *  If external is not registering 'POWER_SUPPLY_PROP_CAPACITY' to its
 955         * property because of handling that sysfs entry on its own, this is
 956         * the place to get the battery capacity.
 957         */
 958        if (!power_supply_get_property(ext, POWER_SUPPLY_PROP_CAPACITY, &ret)) {
 959                di->batt_data.percent = ret.intval;
 960                capacity_updated = true;
 961        }
 962
 963        /* Go through all properties for the psy */
 964        for (j = 0; j < ext->desc->num_properties; j++) {
 965                enum power_supply_property prop;
 966                prop = ext->desc->properties[j];
 967
 968                /*
 969                 * Initialize chargers if not already done.
 970                 * The ab8500_charger*/
 971                if (!di->ac_chg &&
 972                        ext->desc->type == POWER_SUPPLY_TYPE_MAINS)
 973                        di->ac_chg = psy_to_ux500_charger(ext);
 974                else if (!di->usb_chg &&
 975                        ext->desc->type == POWER_SUPPLY_TYPE_USB)
 976                        di->usb_chg = psy_to_ux500_charger(ext);
 977
 978                if (power_supply_get_property(ext, prop, &ret))
 979                        continue;
 980                switch (prop) {
 981                case POWER_SUPPLY_PROP_PRESENT:
 982                        switch (ext->desc->type) {
 983                        case POWER_SUPPLY_TYPE_BATTERY:
 984                                /* Battery present */
 985                                if (ret.intval)
 986                                        di->events.batt_rem = false;
 987                                /* Battery removed */
 988                                else
 989                                        di->events.batt_rem = true;
 990                                break;
 991                        case POWER_SUPPLY_TYPE_MAINS:
 992                                /* AC disconnected */
 993                                if (!ret.intval &&
 994                                        (di->chg_info.conn_chg & AC_CHG)) {
 995                                        di->chg_info.prev_conn_chg =
 996                                                di->chg_info.conn_chg;
 997                                        di->chg_info.conn_chg &= ~AC_CHG;
 998                                }
 999                                /* AC connected */
1000                                else if (ret.intval &&
1001                                        !(di->chg_info.conn_chg & AC_CHG)) {
1002                                        di->chg_info.prev_conn_chg =
1003                                                di->chg_info.conn_chg;
1004                                        di->chg_info.conn_chg |= AC_CHG;
1005                                }
1006                                break;
1007                        case POWER_SUPPLY_TYPE_USB:
1008                                /* USB disconnected */
1009                                if (!ret.intval &&
1010                                        (di->chg_info.conn_chg & USB_CHG)) {
1011                                        di->chg_info.prev_conn_chg =
1012                                                di->chg_info.conn_chg;
1013                                        di->chg_info.conn_chg &= ~USB_CHG;
1014                                }
1015                                /* USB connected */
1016                                else if (ret.intval &&
1017                                        !(di->chg_info.conn_chg & USB_CHG)) {
1018                                        di->chg_info.prev_conn_chg =
1019                                                di->chg_info.conn_chg;
1020                                        di->chg_info.conn_chg |= USB_CHG;
1021                                }
1022                                break;
1023                        default:
1024                                break;
1025                        }
1026                        break;
1027
1028                case POWER_SUPPLY_PROP_ONLINE:
1029                        switch (ext->desc->type) {
1030                        case POWER_SUPPLY_TYPE_BATTERY:
1031                                break;
1032                        case POWER_SUPPLY_TYPE_MAINS:
1033                                /* AC offline */
1034                                if (!ret.intval &&
1035                                        (di->chg_info.online_chg & AC_CHG)) {
1036                                        di->chg_info.prev_online_chg =
1037                                                di->chg_info.online_chg;
1038                                        di->chg_info.online_chg &= ~AC_CHG;
1039                                }
1040                                /* AC online */
1041                                else if (ret.intval &&
1042                                        !(di->chg_info.online_chg & AC_CHG)) {
1043                                        di->chg_info.prev_online_chg =
1044                                                di->chg_info.online_chg;
1045                                        di->chg_info.online_chg |= AC_CHG;
1046                                        queue_delayed_work(di->chargalg_wq,
1047                                                &di->chargalg_wd_work, 0);
1048                                }
1049                                break;
1050                        case POWER_SUPPLY_TYPE_USB:
1051                                /* USB offline */
1052                                if (!ret.intval &&
1053                                        (di->chg_info.online_chg & USB_CHG)) {
1054                                        di->chg_info.prev_online_chg =
1055                                                di->chg_info.online_chg;
1056                                        di->chg_info.online_chg &= ~USB_CHG;
1057                                }
1058                                /* USB online */
1059                                else if (ret.intval &&
1060                                        !(di->chg_info.online_chg & USB_CHG)) {
1061                                        di->chg_info.prev_online_chg =
1062                                                di->chg_info.online_chg;
1063                                        di->chg_info.online_chg |= USB_CHG;
1064                                        queue_delayed_work(di->chargalg_wq,
1065                                                &di->chargalg_wd_work, 0);
1066                                }
1067                                break;
1068                        default:
1069                                break;
1070                        }
1071                        break;
1072
1073                case POWER_SUPPLY_PROP_HEALTH:
1074                        switch (ext->desc->type) {
1075                        case POWER_SUPPLY_TYPE_BATTERY:
1076                                break;
1077                        case POWER_SUPPLY_TYPE_MAINS:
1078                                switch (ret.intval) {
1079                                case POWER_SUPPLY_HEALTH_UNSPEC_FAILURE:
1080                                        di->events.mainextchnotok = true;
1081                                        di->events.main_thermal_prot = false;
1082                                        di->events.main_ovv = false;
1083                                        di->events.ac_wd_expired = false;
1084                                        break;
1085                                case POWER_SUPPLY_HEALTH_DEAD:
1086                                        di->events.ac_wd_expired = true;
1087                                        di->events.mainextchnotok = false;
1088                                        di->events.main_ovv = false;
1089                                        di->events.main_thermal_prot = false;
1090                                        break;
1091                                case POWER_SUPPLY_HEALTH_COLD:
1092                                case POWER_SUPPLY_HEALTH_OVERHEAT:
1093                                        di->events.main_thermal_prot = true;
1094                                        di->events.mainextchnotok = false;
1095                                        di->events.main_ovv = false;
1096                                        di->events.ac_wd_expired = false;
1097                                        break;
1098                                case POWER_SUPPLY_HEALTH_OVERVOLTAGE:
1099                                        di->events.main_ovv = true;
1100                                        di->events.mainextchnotok = false;
1101                                        di->events.main_thermal_prot = false;
1102                                        di->events.ac_wd_expired = false;
1103                                        break;
1104                                case POWER_SUPPLY_HEALTH_GOOD:
1105                                        di->events.main_thermal_prot = false;
1106                                        di->events.mainextchnotok = false;
1107                                        di->events.main_ovv = false;
1108                                        di->events.ac_wd_expired = false;
1109                                        break;
1110                                default:
1111                                        break;
1112                                }
1113                                break;
1114
1115                        case POWER_SUPPLY_TYPE_USB:
1116                                switch (ret.intval) {
1117                                case POWER_SUPPLY_HEALTH_UNSPEC_FAILURE:
1118                                        di->events.usbchargernotok = true;
1119                                        di->events.usb_thermal_prot = false;
1120                                        di->events.vbus_ovv = false;
1121                                        di->events.usb_wd_expired = false;
1122                                        break;
1123                                case POWER_SUPPLY_HEALTH_DEAD:
1124                                        di->events.usb_wd_expired = true;
1125                                        di->events.usbchargernotok = false;
1126                                        di->events.usb_thermal_prot = false;
1127                                        di->events.vbus_ovv = false;
1128                                        break;
1129                                case POWER_SUPPLY_HEALTH_COLD:
1130                                case POWER_SUPPLY_HEALTH_OVERHEAT:
1131                                        di->events.usb_thermal_prot = true;
1132                                        di->events.usbchargernotok = false;
1133                                        di->events.vbus_ovv = false;
1134                                        di->events.usb_wd_expired = false;
1135                                        break;
1136                                case POWER_SUPPLY_HEALTH_OVERVOLTAGE:
1137                                        di->events.vbus_ovv = true;
1138                                        di->events.usbchargernotok = false;
1139                                        di->events.usb_thermal_prot = false;
1140                                        di->events.usb_wd_expired = false;
1141                                        break;
1142                                case POWER_SUPPLY_HEALTH_GOOD:
1143                                        di->events.usbchargernotok = false;
1144                                        di->events.usb_thermal_prot = false;
1145                                        di->events.vbus_ovv = false;
1146                                        di->events.usb_wd_expired = false;
1147                                        break;
1148                                default:
1149                                        break;
1150                                }
1151                        default:
1152                                break;
1153                        }
1154                        break;
1155
1156                case POWER_SUPPLY_PROP_VOLTAGE_NOW:
1157                        switch (ext->desc->type) {
1158                        case POWER_SUPPLY_TYPE_BATTERY:
1159                                di->batt_data.volt = ret.intval / 1000;
1160                                break;
1161                        case POWER_SUPPLY_TYPE_MAINS:
1162                                di->chg_info.ac_volt = ret.intval / 1000;
1163                                break;
1164                        case POWER_SUPPLY_TYPE_USB:
1165                                di->chg_info.usb_volt = ret.intval / 1000;
1166                                break;
1167                        default:
1168                                break;
1169                        }
1170                        break;
1171
1172                case POWER_SUPPLY_PROP_VOLTAGE_AVG:
1173                        switch (ext->desc->type) {
1174                        case POWER_SUPPLY_TYPE_MAINS:
1175                                /* AVG is used to indicate when we are
1176                                 * in CV mode */
1177                                if (ret.intval)
1178                                        di->events.ac_cv_active = true;
1179                                else
1180                                        di->events.ac_cv_active = false;
1181
1182                                break;
1183                        case POWER_SUPPLY_TYPE_USB:
1184                                /* AVG is used to indicate when we are
1185                                 * in CV mode */
1186                                if (ret.intval)
1187                                        di->events.usb_cv_active = true;
1188                                else
1189                                        di->events.usb_cv_active = false;
1190
1191                                break;
1192                        default:
1193                                break;
1194                        }
1195                        break;
1196
1197                case POWER_SUPPLY_PROP_TECHNOLOGY:
1198                        switch (ext->desc->type) {
1199                        case POWER_SUPPLY_TYPE_BATTERY:
1200                                if (ret.intval)
1201                                        di->events.batt_unknown = false;
1202                                else
1203                                        di->events.batt_unknown = true;
1204
1205                                break;
1206                        default:
1207                                break;
1208                        }
1209                        break;
1210
1211                case POWER_SUPPLY_PROP_TEMP:
1212                        di->batt_data.temp = ret.intval / 10;
1213                        break;
1214
1215                case POWER_SUPPLY_PROP_CURRENT_NOW:
1216                        switch (ext->desc->type) {
1217                        case POWER_SUPPLY_TYPE_MAINS:
1218                                        di->chg_info.ac_curr =
1219                                                ret.intval / 1000;
1220                                        break;
1221                        case POWER_SUPPLY_TYPE_USB:
1222                                        di->chg_info.usb_curr =
1223                                                ret.intval / 1000;
1224                                break;
1225                        case POWER_SUPPLY_TYPE_BATTERY:
1226                                di->batt_data.inst_curr = ret.intval / 1000;
1227                                break;
1228                        default:
1229                                break;
1230                        }
1231                        break;
1232
1233                case POWER_SUPPLY_PROP_CURRENT_AVG:
1234                        switch (ext->desc->type) {
1235                        case POWER_SUPPLY_TYPE_BATTERY:
1236                                di->batt_data.avg_curr = ret.intval / 1000;
1237                                break;
1238                        case POWER_SUPPLY_TYPE_USB:
1239                                if (ret.intval)
1240                                        di->events.vbus_collapsed = true;
1241                                else
1242                                        di->events.vbus_collapsed = false;
1243                                break;
1244                        default:
1245                                break;
1246                        }
1247                        break;
1248                case POWER_SUPPLY_PROP_CAPACITY:
1249                        if (!capacity_updated)
1250                                di->batt_data.percent = ret.intval;
1251                        break;
1252                default:
1253                        break;
1254                }
1255        }
1256        return 0;
1257}
1258
1259/**
1260 * abx500_chargalg_external_power_changed() - callback for power supply changes
1261 * @psy:       pointer to the structure power_supply
1262 *
1263 * This function is the entry point of the pointer external_power_changed
1264 * of the structure power_supply.
1265 * This function gets executed when there is a change in any external power
1266 * supply that this driver needs to be notified of.
1267 */
1268static void abx500_chargalg_external_power_changed(struct power_supply *psy)
1269{
1270        struct abx500_chargalg *di = power_supply_get_drvdata(psy);
1271
1272        /*
1273         * Trigger execution of the algorithm instantly and read
1274         * all power_supply properties there instead
1275         */
1276        queue_work(di->chargalg_wq, &di->chargalg_work);
1277}
1278
1279/**
1280 * abx500_chargalg_algorithm() - Main function for the algorithm
1281 * @di:         pointer to the abx500_chargalg structure
1282 *
1283 * This is the main control function for the charging algorithm.
1284 * It is called periodically or when something happens that will
1285 * trigger a state change
1286 */
1287static void abx500_chargalg_algorithm(struct abx500_chargalg *di)
1288{
1289        int charger_status;
1290        int ret;
1291        int curr_step_lvl;
1292
1293        /* Collect data from all power_supply class devices */
1294        class_for_each_device(power_supply_class, NULL,
1295                di->chargalg_psy, abx500_chargalg_get_ext_psy_data);
1296
1297        abx500_chargalg_end_of_charge(di);
1298        abx500_chargalg_check_temp(di);
1299        abx500_chargalg_check_charger_voltage(di);
1300
1301        charger_status = abx500_chargalg_check_charger_connection(di);
1302        abx500_chargalg_check_current_step_status(di);
1303
1304        if (is_ab8500(di->parent)) {
1305                ret = abx500_chargalg_check_charger_enable(di);
1306                if (ret < 0)
1307                        dev_err(di->dev, "Checking charger is enabled error"
1308                                        ": Returned Value %d\n", ret);
1309        }
1310
1311        /*
1312         * First check if we have a charger connected.
1313         * Also we don't allow charging of unknown batteries if configured
1314         * this way
1315         */
1316        if (!charger_status ||
1317                (di->events.batt_unknown && !di->bm->chg_unknown_bat)) {
1318                if (di->charge_state != STATE_HANDHELD) {
1319                        di->events.safety_timer_expired = false;
1320                        abx500_chargalg_state_to(di, STATE_HANDHELD_INIT);
1321                }
1322        }
1323
1324        /* If suspended, we should not continue checking the flags */
1325        else if (di->charge_state == STATE_SUSPENDED_INIT ||
1326                di->charge_state == STATE_SUSPENDED) {
1327                /* We don't do anything here, just don,t continue */
1328        }
1329
1330        /* Safety timer expiration */
1331        else if (di->events.safety_timer_expired) {
1332                if (di->charge_state != STATE_SAFETY_TIMER_EXPIRED)
1333                        abx500_chargalg_state_to(di,
1334                                STATE_SAFETY_TIMER_EXPIRED_INIT);
1335        }
1336        /*
1337         * Check if any interrupts has occured
1338         * that will prevent us from charging
1339         */
1340
1341        /* Battery removed */
1342        else if (di->events.batt_rem) {
1343                if (di->charge_state != STATE_BATT_REMOVED)
1344                        abx500_chargalg_state_to(di, STATE_BATT_REMOVED_INIT);
1345        }
1346        /* Main or USB charger not ok. */
1347        else if (di->events.mainextchnotok || di->events.usbchargernotok) {
1348                /*
1349                 * If vbus_collapsed is set, we have to lower the charger
1350                 * current, which is done in the normal state below
1351                 */
1352                if (di->charge_state != STATE_CHG_NOT_OK &&
1353                                !di->events.vbus_collapsed)
1354                        abx500_chargalg_state_to(di, STATE_CHG_NOT_OK_INIT);
1355        }
1356        /* VBUS, Main or VBAT OVV. */
1357        else if (di->events.vbus_ovv ||
1358                        di->events.main_ovv ||
1359                        di->events.batt_ovv ||
1360                        !di->chg_info.usb_chg_ok ||
1361                        !di->chg_info.ac_chg_ok) {
1362                if (di->charge_state != STATE_OVV_PROTECT)
1363                        abx500_chargalg_state_to(di, STATE_OVV_PROTECT_INIT);
1364        }
1365        /* USB Thermal, stop charging */
1366        else if (di->events.main_thermal_prot ||
1367                di->events.usb_thermal_prot) {
1368                if (di->charge_state != STATE_HW_TEMP_PROTECT)
1369                        abx500_chargalg_state_to(di,
1370                                STATE_HW_TEMP_PROTECT_INIT);
1371        }
1372        /* Battery temp over/under */
1373        else if (di->events.btemp_underover) {
1374                if (di->charge_state != STATE_TEMP_UNDEROVER)
1375                        abx500_chargalg_state_to(di,
1376                                STATE_TEMP_UNDEROVER_INIT);
1377        }
1378        /* Watchdog expired */
1379        else if (di->events.ac_wd_expired ||
1380                di->events.usb_wd_expired) {
1381                if (di->charge_state != STATE_WD_EXPIRED)
1382                        abx500_chargalg_state_to(di, STATE_WD_EXPIRED_INIT);
1383        }
1384        /* Battery temp high/low */
1385        else if (di->events.btemp_lowhigh) {
1386                if (di->charge_state != STATE_TEMP_LOWHIGH)
1387                        abx500_chargalg_state_to(di, STATE_TEMP_LOWHIGH_INIT);
1388        }
1389
1390        dev_dbg(di->dev,
1391                "[CHARGALG] Vb %d Ib_avg %d Ib_inst %d Tb %d Cap %d Maint %d "
1392                "State %s Active_chg %d Chg_status %d AC %d USB %d "
1393                "AC_online %d USB_online %d AC_CV %d USB_CV %d AC_I %d "
1394                "USB_I %d AC_Vset %d AC_Iset %d USB_Vset %d USB_Iset %d\n",
1395                di->batt_data.volt,
1396                di->batt_data.avg_curr,
1397                di->batt_data.inst_curr,
1398                di->batt_data.temp,
1399                di->batt_data.percent,
1400                di->maintenance_chg,
1401                states[di->charge_state],
1402                di->chg_info.charger_type,
1403                di->charge_status,
1404                di->chg_info.conn_chg & AC_CHG,
1405                di->chg_info.conn_chg & USB_CHG,
1406                di->chg_info.online_chg & AC_CHG,
1407                di->chg_info.online_chg & USB_CHG,
1408                di->events.ac_cv_active,
1409                di->events.usb_cv_active,
1410                di->chg_info.ac_curr,
1411                di->chg_info.usb_curr,
1412                di->chg_info.ac_vset,
1413                di->chg_info.ac_iset,
1414                di->chg_info.usb_vset,
1415                di->chg_info.usb_iset);
1416
1417        switch (di->charge_state) {
1418        case STATE_HANDHELD_INIT:
1419                abx500_chargalg_stop_charging(di);
1420                di->charge_status = POWER_SUPPLY_STATUS_DISCHARGING;
1421                abx500_chargalg_state_to(di, STATE_HANDHELD);
1422                fallthrough;
1423
1424        case STATE_HANDHELD:
1425                break;
1426
1427        case STATE_SUSPENDED_INIT:
1428                if (di->susp_status.ac_suspended)
1429                        abx500_chargalg_ac_en(di, false, 0, 0);
1430                if (di->susp_status.usb_suspended)
1431                        abx500_chargalg_usb_en(di, false, 0, 0);
1432                abx500_chargalg_stop_safety_timer(di);
1433                abx500_chargalg_stop_maintenance_timer(di);
1434                di->charge_status = POWER_SUPPLY_STATUS_NOT_CHARGING;
1435                di->maintenance_chg = false;
1436                abx500_chargalg_state_to(di, STATE_SUSPENDED);
1437                power_supply_changed(di->chargalg_psy);
1438                fallthrough;
1439
1440        case STATE_SUSPENDED:
1441                /* CHARGING is suspended */
1442                break;
1443
1444        case STATE_BATT_REMOVED_INIT:
1445                abx500_chargalg_stop_charging(di);
1446                abx500_chargalg_state_to(di, STATE_BATT_REMOVED);
1447                fallthrough;
1448
1449        case STATE_BATT_REMOVED:
1450                if (!di->events.batt_rem)
1451                        abx500_chargalg_state_to(di, STATE_NORMAL_INIT);
1452                break;
1453
1454        case STATE_HW_TEMP_PROTECT_INIT:
1455                abx500_chargalg_stop_charging(di);
1456                abx500_chargalg_state_to(di, STATE_HW_TEMP_PROTECT);
1457                fallthrough;
1458
1459        case STATE_HW_TEMP_PROTECT:
1460                if (!di->events.main_thermal_prot &&
1461                                !di->events.usb_thermal_prot)
1462                        abx500_chargalg_state_to(di, STATE_NORMAL_INIT);
1463                break;
1464
1465        case STATE_OVV_PROTECT_INIT:
1466                abx500_chargalg_stop_charging(di);
1467                abx500_chargalg_state_to(di, STATE_OVV_PROTECT);
1468                fallthrough;
1469
1470        case STATE_OVV_PROTECT:
1471                if (!di->events.vbus_ovv &&
1472                                !di->events.main_ovv &&
1473                                !di->events.batt_ovv &&
1474                                di->chg_info.usb_chg_ok &&
1475                                di->chg_info.ac_chg_ok)
1476                        abx500_chargalg_state_to(di, STATE_NORMAL_INIT);
1477                break;
1478
1479        case STATE_CHG_NOT_OK_INIT:
1480                abx500_chargalg_stop_charging(di);
1481                abx500_chargalg_state_to(di, STATE_CHG_NOT_OK);
1482                fallthrough;
1483
1484        case STATE_CHG_NOT_OK:
1485                if (!di->events.mainextchnotok &&
1486                                !di->events.usbchargernotok)
1487                        abx500_chargalg_state_to(di, STATE_NORMAL_INIT);
1488                break;
1489
1490        case STATE_SAFETY_TIMER_EXPIRED_INIT:
1491                abx500_chargalg_stop_charging(di);
1492                abx500_chargalg_state_to(di, STATE_SAFETY_TIMER_EXPIRED);
1493                fallthrough;
1494
1495        case STATE_SAFETY_TIMER_EXPIRED:
1496                /* We exit this state when charger is removed */
1497                break;
1498
1499        case STATE_NORMAL_INIT:
1500                if (di->curr_status.curr_step == CHARGALG_CURR_STEP_LOW)
1501                        abx500_chargalg_stop_charging(di);
1502                else {
1503                        curr_step_lvl = di->bm->bat_type[
1504                                di->bm->batt_id].normal_cur_lvl
1505                                * di->curr_status.curr_step
1506                                / CHARGALG_CURR_STEP_HIGH;
1507                        abx500_chargalg_start_charging(di,
1508                                di->bm->bat_type[di->bm->batt_id]
1509                                .normal_vol_lvl, curr_step_lvl);
1510                }
1511
1512                abx500_chargalg_state_to(di, STATE_NORMAL);
1513                abx500_chargalg_start_safety_timer(di);
1514                abx500_chargalg_stop_maintenance_timer(di);
1515                init_maxim_chg_curr(di);
1516                di->charge_status = POWER_SUPPLY_STATUS_CHARGING;
1517                di->eoc_cnt = 0;
1518                di->maintenance_chg = false;
1519                power_supply_changed(di->chargalg_psy);
1520
1521                break;
1522
1523        case STATE_NORMAL:
1524                handle_maxim_chg_curr(di);
1525                if (di->charge_status == POWER_SUPPLY_STATUS_FULL &&
1526                        di->maintenance_chg) {
1527                        if (di->bm->no_maintenance)
1528                                abx500_chargalg_state_to(di,
1529                                        STATE_WAIT_FOR_RECHARGE_INIT);
1530                        else
1531                                abx500_chargalg_state_to(di,
1532                                        STATE_MAINTENANCE_A_INIT);
1533                }
1534                break;
1535
1536        /* This state will be used when the maintenance state is disabled */
1537        case STATE_WAIT_FOR_RECHARGE_INIT:
1538                abx500_chargalg_hold_charging(di);
1539                abx500_chargalg_state_to(di, STATE_WAIT_FOR_RECHARGE);
1540                fallthrough;
1541
1542        case STATE_WAIT_FOR_RECHARGE:
1543                if (di->batt_data.percent <=
1544                    di->bm->bat_type[di->bm->batt_id].
1545                    recharge_cap)
1546                        abx500_chargalg_state_to(di, STATE_NORMAL_INIT);
1547                break;
1548
1549        case STATE_MAINTENANCE_A_INIT:
1550                abx500_chargalg_stop_safety_timer(di);
1551                abx500_chargalg_start_maintenance_timer(di,
1552                        di->bm->bat_type[
1553                                di->bm->batt_id].maint_a_chg_timer_h);
1554                abx500_chargalg_start_charging(di,
1555                        di->bm->bat_type[
1556                                di->bm->batt_id].maint_a_vol_lvl,
1557                        di->bm->bat_type[
1558                                di->bm->batt_id].maint_a_cur_lvl);
1559                abx500_chargalg_state_to(di, STATE_MAINTENANCE_A);
1560                power_supply_changed(di->chargalg_psy);
1561                fallthrough;
1562
1563        case STATE_MAINTENANCE_A:
1564                if (di->events.maintenance_timer_expired) {
1565                        abx500_chargalg_stop_maintenance_timer(di);
1566                        abx500_chargalg_state_to(di, STATE_MAINTENANCE_B_INIT);
1567                }
1568                break;
1569
1570        case STATE_MAINTENANCE_B_INIT:
1571                abx500_chargalg_start_maintenance_timer(di,
1572                        di->bm->bat_type[
1573                                di->bm->batt_id].maint_b_chg_timer_h);
1574                abx500_chargalg_start_charging(di,
1575                        di->bm->bat_type[
1576                                di->bm->batt_id].maint_b_vol_lvl,
1577                        di->bm->bat_type[
1578                                di->bm->batt_id].maint_b_cur_lvl);
1579                abx500_chargalg_state_to(di, STATE_MAINTENANCE_B);
1580                power_supply_changed(di->chargalg_psy);
1581                fallthrough;
1582
1583        case STATE_MAINTENANCE_B:
1584                if (di->events.maintenance_timer_expired) {
1585                        abx500_chargalg_stop_maintenance_timer(di);
1586                        abx500_chargalg_state_to(di, STATE_NORMAL_INIT);
1587                }
1588                break;
1589
1590        case STATE_TEMP_LOWHIGH_INIT:
1591                abx500_chargalg_start_charging(di,
1592                        di->bm->bat_type[
1593                                di->bm->batt_id].low_high_vol_lvl,
1594                        di->bm->bat_type[
1595                                di->bm->batt_id].low_high_cur_lvl);
1596                abx500_chargalg_stop_maintenance_timer(di);
1597                di->charge_status = POWER_SUPPLY_STATUS_CHARGING;
1598                abx500_chargalg_state_to(di, STATE_TEMP_LOWHIGH);
1599                power_supply_changed(di->chargalg_psy);
1600                fallthrough;
1601
1602        case STATE_TEMP_LOWHIGH:
1603                if (!di->events.btemp_lowhigh)
1604                        abx500_chargalg_state_to(di, STATE_NORMAL_INIT);
1605                break;
1606
1607        case STATE_WD_EXPIRED_INIT:
1608                abx500_chargalg_stop_charging(di);
1609                abx500_chargalg_state_to(di, STATE_WD_EXPIRED);
1610                fallthrough;
1611
1612        case STATE_WD_EXPIRED:
1613                if (!di->events.ac_wd_expired &&
1614                                !di->events.usb_wd_expired)
1615                        abx500_chargalg_state_to(di, STATE_NORMAL_INIT);
1616                break;
1617
1618        case STATE_TEMP_UNDEROVER_INIT:
1619                abx500_chargalg_stop_charging(di);
1620                abx500_chargalg_state_to(di, STATE_TEMP_UNDEROVER);
1621                fallthrough;
1622
1623        case STATE_TEMP_UNDEROVER:
1624                if (!di->events.btemp_underover)
1625                        abx500_chargalg_state_to(di, STATE_NORMAL_INIT);
1626                break;
1627        }
1628
1629        /* Start charging directly if the new state is a charge state */
1630        if (di->charge_state == STATE_NORMAL_INIT ||
1631                        di->charge_state == STATE_MAINTENANCE_A_INIT ||
1632                        di->charge_state == STATE_MAINTENANCE_B_INIT)
1633                queue_work(di->chargalg_wq, &di->chargalg_work);
1634}
1635
1636/**
1637 * abx500_chargalg_periodic_work() - Periodic work for the algorithm
1638 * @work:       pointer to the work_struct structure
1639 *
1640 * Work queue function for the charging algorithm
1641 */
1642static void abx500_chargalg_periodic_work(struct work_struct *work)
1643{
1644        struct abx500_chargalg *di = container_of(work,
1645                struct abx500_chargalg, chargalg_periodic_work.work);
1646
1647        abx500_chargalg_algorithm(di);
1648
1649        /*
1650         * If a charger is connected then the battery has to be monitored
1651         * frequently, else the work can be delayed.
1652         */
1653        if (di->chg_info.conn_chg)
1654                queue_delayed_work(di->chargalg_wq,
1655                        &di->chargalg_periodic_work,
1656                        di->bm->interval_charging * HZ);
1657        else
1658                queue_delayed_work(di->chargalg_wq,
1659                        &di->chargalg_periodic_work,
1660                        di->bm->interval_not_charging * HZ);
1661}
1662
1663/**
1664 * abx500_chargalg_wd_work() - periodic work to kick the charger watchdog
1665 * @work:       pointer to the work_struct structure
1666 *
1667 * Work queue function for kicking the charger watchdog
1668 */
1669static void abx500_chargalg_wd_work(struct work_struct *work)
1670{
1671        int ret;
1672        struct abx500_chargalg *di = container_of(work,
1673                struct abx500_chargalg, chargalg_wd_work.work);
1674
1675        dev_dbg(di->dev, "abx500_chargalg_wd_work\n");
1676
1677        ret = abx500_chargalg_kick_watchdog(di);
1678        if (ret < 0)
1679                dev_err(di->dev, "failed to kick watchdog\n");
1680
1681        queue_delayed_work(di->chargalg_wq,
1682                &di->chargalg_wd_work, CHG_WD_INTERVAL);
1683}
1684
1685/**
1686 * abx500_chargalg_work() - Work to run the charging algorithm instantly
1687 * @work:       pointer to the work_struct structure
1688 *
1689 * Work queue function for calling the charging algorithm
1690 */
1691static void abx500_chargalg_work(struct work_struct *work)
1692{
1693        struct abx500_chargalg *di = container_of(work,
1694                struct abx500_chargalg, chargalg_work);
1695
1696        abx500_chargalg_algorithm(di);
1697}
1698
1699/**
1700 * abx500_chargalg_get_property() - get the chargalg properties
1701 * @psy:        pointer to the power_supply structure
1702 * @psp:        pointer to the power_supply_property structure
1703 * @val:        pointer to the power_supply_propval union
1704 *
1705 * This function gets called when an application tries to get the
1706 * chargalg properties by reading the sysfs files.
1707 * status:     charging/discharging/full/unknown
1708 * health:     health of the battery
1709 * Returns error code in case of failure else 0 on success
1710 */
1711static int abx500_chargalg_get_property(struct power_supply *psy,
1712        enum power_supply_property psp,
1713        union power_supply_propval *val)
1714{
1715        struct abx500_chargalg *di = power_supply_get_drvdata(psy);
1716
1717        switch (psp) {
1718        case POWER_SUPPLY_PROP_STATUS:
1719                val->intval = di->charge_status;
1720                break;
1721        case POWER_SUPPLY_PROP_HEALTH:
1722                if (di->events.batt_ovv) {
1723                        val->intval = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
1724                } else if (di->events.btemp_underover) {
1725                        if (di->batt_data.temp <= di->bm->temp_under)
1726                                val->intval = POWER_SUPPLY_HEALTH_COLD;
1727                        else
1728                                val->intval = POWER_SUPPLY_HEALTH_OVERHEAT;
1729                } else if (di->charge_state == STATE_SAFETY_TIMER_EXPIRED ||
1730                           di->charge_state == STATE_SAFETY_TIMER_EXPIRED_INIT) {
1731                        val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
1732                } else {
1733                        val->intval = POWER_SUPPLY_HEALTH_GOOD;
1734                }
1735                break;
1736        default:
1737                return -EINVAL;
1738        }
1739        return 0;
1740}
1741
1742/* Exposure to the sysfs interface */
1743
1744static ssize_t abx500_chargalg_curr_step_show(struct abx500_chargalg *di,
1745                                              char *buf)
1746{
1747        return sprintf(buf, "%d\n", di->curr_status.curr_step);
1748}
1749
1750static ssize_t abx500_chargalg_curr_step_store(struct abx500_chargalg *di,
1751                                               const char *buf, size_t length)
1752{
1753        long int param;
1754        int ret;
1755
1756        ret = kstrtol(buf, 10, &param);
1757        if (ret < 0)
1758                return ret;
1759
1760        di->curr_status.curr_step = param;
1761        if (di->curr_status.curr_step >= CHARGALG_CURR_STEP_LOW &&
1762                di->curr_status.curr_step <= CHARGALG_CURR_STEP_HIGH) {
1763                di->curr_status.curr_step_change = true;
1764                queue_work(di->chargalg_wq, &di->chargalg_work);
1765        } else
1766                dev_info(di->dev, "Wrong current step\n"
1767                        "Enter 0. Disable AC/USB Charging\n"
1768                        "1--100. Set AC/USB charging current step\n"
1769                        "100. Enable AC/USB Charging\n");
1770
1771        return strlen(buf);
1772}
1773
1774
1775static ssize_t abx500_chargalg_en_show(struct abx500_chargalg *di,
1776                                       char *buf)
1777{
1778        return sprintf(buf, "%d\n",
1779                       di->susp_status.ac_suspended &&
1780                       di->susp_status.usb_suspended);
1781}
1782
1783static ssize_t abx500_chargalg_en_store(struct abx500_chargalg *di,
1784        const char *buf, size_t length)
1785{
1786        long int param;
1787        int ac_usb;
1788        int ret;
1789
1790        ret = kstrtol(buf, 10, &param);
1791        if (ret < 0)
1792                return ret;
1793
1794        ac_usb = param;
1795        switch (ac_usb) {
1796        case 0:
1797                /* Disable charging */
1798                di->susp_status.ac_suspended = true;
1799                di->susp_status.usb_suspended = true;
1800                di->susp_status.suspended_change = true;
1801                /* Trigger a state change */
1802                queue_work(di->chargalg_wq,
1803                        &di->chargalg_work);
1804                break;
1805        case 1:
1806                /* Enable AC Charging */
1807                di->susp_status.ac_suspended = false;
1808                di->susp_status.suspended_change = true;
1809                /* Trigger a state change */
1810                queue_work(di->chargalg_wq,
1811                        &di->chargalg_work);
1812                break;
1813        case 2:
1814                /* Enable USB charging */
1815                di->susp_status.usb_suspended = false;
1816                di->susp_status.suspended_change = true;
1817                /* Trigger a state change */
1818                queue_work(di->chargalg_wq,
1819                        &di->chargalg_work);
1820                break;
1821        default:
1822                dev_info(di->dev, "Wrong input\n"
1823                        "Enter 0. Disable AC/USB Charging\n"
1824                        "1. Enable AC charging\n"
1825                        "2. Enable USB Charging\n");
1826        }
1827        return strlen(buf);
1828}
1829
1830static struct abx500_chargalg_sysfs_entry abx500_chargalg_en_charger =
1831        __ATTR(chargalg, 0644, abx500_chargalg_en_show,
1832                                abx500_chargalg_en_store);
1833
1834static struct abx500_chargalg_sysfs_entry abx500_chargalg_curr_step =
1835        __ATTR(chargalg_curr_step, 0644, abx500_chargalg_curr_step_show,
1836                                        abx500_chargalg_curr_step_store);
1837
1838static ssize_t abx500_chargalg_sysfs_show(struct kobject *kobj,
1839        struct attribute *attr, char *buf)
1840{
1841        struct abx500_chargalg_sysfs_entry *entry = container_of(attr,
1842                struct abx500_chargalg_sysfs_entry, attr);
1843
1844        struct abx500_chargalg *di = container_of(kobj,
1845                struct abx500_chargalg, chargalg_kobject);
1846
1847        if (!entry->show)
1848                return -EIO;
1849
1850        return entry->show(di, buf);
1851}
1852
1853static ssize_t abx500_chargalg_sysfs_charger(struct kobject *kobj,
1854        struct attribute *attr, const char *buf, size_t length)
1855{
1856        struct abx500_chargalg_sysfs_entry *entry = container_of(attr,
1857                struct abx500_chargalg_sysfs_entry, attr);
1858
1859        struct abx500_chargalg *di = container_of(kobj,
1860                struct abx500_chargalg, chargalg_kobject);
1861
1862        if (!entry->store)
1863                return -EIO;
1864
1865        return entry->store(di, buf, length);
1866}
1867
1868static struct attribute *abx500_chargalg_chg[] = {
1869        &abx500_chargalg_en_charger.attr,
1870        &abx500_chargalg_curr_step.attr,
1871        NULL,
1872};
1873
1874static const struct sysfs_ops abx500_chargalg_sysfs_ops = {
1875        .show = abx500_chargalg_sysfs_show,
1876        .store = abx500_chargalg_sysfs_charger,
1877};
1878
1879static struct kobj_type abx500_chargalg_ktype = {
1880        .sysfs_ops = &abx500_chargalg_sysfs_ops,
1881        .default_attrs = abx500_chargalg_chg,
1882};
1883
1884/**
1885 * abx500_chargalg_sysfs_exit() - de-init of sysfs entry
1886 * @di:                pointer to the struct abx500_chargalg
1887 *
1888 * This function removes the entry in sysfs.
1889 */
1890static void abx500_chargalg_sysfs_exit(struct abx500_chargalg *di)
1891{
1892        kobject_del(&di->chargalg_kobject);
1893}
1894
1895/**
1896 * abx500_chargalg_sysfs_init() - init of sysfs entry
1897 * @di:                pointer to the struct abx500_chargalg
1898 *
1899 * This function adds an entry in sysfs.
1900 * Returns error code in case of failure else 0(on success)
1901 */
1902static int abx500_chargalg_sysfs_init(struct abx500_chargalg *di)
1903{
1904        int ret = 0;
1905
1906        ret = kobject_init_and_add(&di->chargalg_kobject,
1907                &abx500_chargalg_ktype,
1908                NULL, "abx500_chargalg");
1909        if (ret < 0)
1910                dev_err(di->dev, "failed to create sysfs entry\n");
1911
1912        return ret;
1913}
1914/* Exposure to the sysfs interface <<END>> */
1915
1916#if defined(CONFIG_PM)
1917static int abx500_chargalg_resume(struct platform_device *pdev)
1918{
1919        struct abx500_chargalg *di = platform_get_drvdata(pdev);
1920
1921        /* Kick charger watchdog if charging (any charger online) */
1922        if (di->chg_info.online_chg)
1923                queue_delayed_work(di->chargalg_wq, &di->chargalg_wd_work, 0);
1924
1925        /*
1926         * Run the charging algorithm directly to be sure we don't
1927         * do it too seldom
1928         */
1929        queue_delayed_work(di->chargalg_wq, &di->chargalg_periodic_work, 0);
1930
1931        return 0;
1932}
1933
1934static int abx500_chargalg_suspend(struct platform_device *pdev,
1935        pm_message_t state)
1936{
1937        struct abx500_chargalg *di = platform_get_drvdata(pdev);
1938
1939        if (di->chg_info.online_chg)
1940                cancel_delayed_work_sync(&di->chargalg_wd_work);
1941
1942        cancel_delayed_work_sync(&di->chargalg_periodic_work);
1943
1944        return 0;
1945}
1946#else
1947#define abx500_chargalg_suspend      NULL
1948#define abx500_chargalg_resume       NULL
1949#endif
1950
1951static int abx500_chargalg_remove(struct platform_device *pdev)
1952{
1953        struct abx500_chargalg *di = platform_get_drvdata(pdev);
1954
1955        /* sysfs interface to enable/disbale charging from user space */
1956        abx500_chargalg_sysfs_exit(di);
1957
1958        hrtimer_cancel(&di->safety_timer);
1959        hrtimer_cancel(&di->maintenance_timer);
1960
1961        cancel_delayed_work_sync(&di->chargalg_periodic_work);
1962        cancel_delayed_work_sync(&di->chargalg_wd_work);
1963        cancel_work_sync(&di->chargalg_work);
1964
1965        /* Delete the work queue */
1966        destroy_workqueue(di->chargalg_wq);
1967
1968        power_supply_unregister(di->chargalg_psy);
1969
1970        return 0;
1971}
1972
1973static char *supply_interface[] = {
1974        "ab8500_fg",
1975};
1976
1977static const struct power_supply_desc abx500_chargalg_desc = {
1978        .name                   = "abx500_chargalg",
1979        .type                   = POWER_SUPPLY_TYPE_BATTERY,
1980        .properties             = abx500_chargalg_props,
1981        .num_properties         = ARRAY_SIZE(abx500_chargalg_props),
1982        .get_property           = abx500_chargalg_get_property,
1983        .external_power_changed = abx500_chargalg_external_power_changed,
1984};
1985
1986static int abx500_chargalg_probe(struct platform_device *pdev)
1987{
1988        struct device_node *np = pdev->dev.of_node;
1989        struct abx500_bm_data *plat = pdev->dev.platform_data;
1990        struct power_supply_config psy_cfg = {};
1991        struct abx500_chargalg *di;
1992        int ret = 0;
1993
1994        di = devm_kzalloc(&pdev->dev, sizeof(*di), GFP_KERNEL);
1995        if (!di) {
1996                dev_err(&pdev->dev, "%s no mem for ab8500_chargalg\n", __func__);
1997                return -ENOMEM;
1998        }
1999
2000        if (!plat) {
2001                dev_err(&pdev->dev, "no battery management data supplied\n");
2002                return -EINVAL;
2003        }
2004        di->bm = plat;
2005
2006        if (np) {
2007                ret = ab8500_bm_of_probe(&pdev->dev, np, di->bm);
2008                if (ret) {
2009                        dev_err(&pdev->dev, "failed to get battery information\n");
2010                        return ret;
2011                }
2012        }
2013
2014        /* get device struct and parent */
2015        di->dev = &pdev->dev;
2016        di->parent = dev_get_drvdata(pdev->dev.parent);
2017
2018        psy_cfg.supplied_to = supply_interface;
2019        psy_cfg.num_supplicants = ARRAY_SIZE(supply_interface);
2020        psy_cfg.drv_data = di;
2021
2022        /* Initilialize safety timer */
2023        hrtimer_init(&di->safety_timer, CLOCK_REALTIME, HRTIMER_MODE_ABS);
2024        di->safety_timer.function = abx500_chargalg_safety_timer_expired;
2025
2026        /* Initilialize maintenance timer */
2027        hrtimer_init(&di->maintenance_timer, CLOCK_REALTIME, HRTIMER_MODE_ABS);
2028        di->maintenance_timer.function =
2029                abx500_chargalg_maintenance_timer_expired;
2030
2031        /* Create a work queue for the chargalg */
2032        di->chargalg_wq = alloc_ordered_workqueue("abx500_chargalg_wq",
2033                                                   WQ_MEM_RECLAIM);
2034        if (di->chargalg_wq == NULL) {
2035                dev_err(di->dev, "failed to create work queue\n");
2036                return -ENOMEM;
2037        }
2038
2039        /* Init work for chargalg */
2040        INIT_DEFERRABLE_WORK(&di->chargalg_periodic_work,
2041                abx500_chargalg_periodic_work);
2042        INIT_DEFERRABLE_WORK(&di->chargalg_wd_work,
2043                abx500_chargalg_wd_work);
2044
2045        /* Init work for chargalg */
2046        INIT_WORK(&di->chargalg_work, abx500_chargalg_work);
2047
2048        /* To detect charger at startup */
2049        di->chg_info.prev_conn_chg = -1;
2050
2051        /* Register chargalg power supply class */
2052        di->chargalg_psy = power_supply_register(di->dev, &abx500_chargalg_desc,
2053                                                 &psy_cfg);
2054        if (IS_ERR(di->chargalg_psy)) {
2055                dev_err(di->dev, "failed to register chargalg psy\n");
2056                ret = PTR_ERR(di->chargalg_psy);
2057                goto free_chargalg_wq;
2058        }
2059
2060        platform_set_drvdata(pdev, di);
2061
2062        /* sysfs interface to enable/disable charging from user space */
2063        ret = abx500_chargalg_sysfs_init(di);
2064        if (ret) {
2065                dev_err(di->dev, "failed to create sysfs entry\n");
2066                goto free_psy;
2067        }
2068        di->curr_status.curr_step = CHARGALG_CURR_STEP_HIGH;
2069
2070        /* Run the charging algorithm */
2071        queue_delayed_work(di->chargalg_wq, &di->chargalg_periodic_work, 0);
2072
2073        dev_info(di->dev, "probe success\n");
2074        return ret;
2075
2076free_psy:
2077        power_supply_unregister(di->chargalg_psy);
2078free_chargalg_wq:
2079        destroy_workqueue(di->chargalg_wq);
2080        return ret;
2081}
2082
2083static const struct of_device_id ab8500_chargalg_match[] = {
2084        { .compatible = "stericsson,ab8500-chargalg", },
2085        { },
2086};
2087
2088static struct platform_driver abx500_chargalg_driver = {
2089        .probe = abx500_chargalg_probe,
2090        .remove = abx500_chargalg_remove,
2091        .suspend = abx500_chargalg_suspend,
2092        .resume = abx500_chargalg_resume,
2093        .driver = {
2094                .name = "ab8500-chargalg",
2095                .of_match_table = ab8500_chargalg_match,
2096        },
2097};
2098
2099module_platform_driver(abx500_chargalg_driver);
2100
2101MODULE_LICENSE("GPL v2");
2102MODULE_AUTHOR("Johan Palsson, Karl Komierowski");
2103MODULE_ALIAS("platform:abx500-chargalg");
2104MODULE_DESCRIPTION("abx500 battery charging algorithm");
2105