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