drivers/power/abx500_chargalg.c

   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
  56 enum abx500_chargers {
  57         NO_CHG,
  58         AC_CHG,
  59         USB_CHG,
  60 };
  61
  62 struct 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
  80 struct abx500_chargalg_suspension_status {
  81         bool suspended_change;
  82         bool ac_suspended;
  83         bool usb_suspended;
  84 };
  85
  86 struct abx500_chargalg_current_step_status {
  87         bool curr_step_change;
  88         int curr_step;
  89 };
  90
  91 struct abx500_chargalg_battery_data {
  92         int temp;
  93         int volt;
  94         int avg_curr;
  95         int inst_curr;
  96         int percent;
  97 };
  98
  99 enum 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
 131 static 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
 163 struct 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  */
 199 struct 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
 209 enum 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  */
 244 struct 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*/
 273 BLOCKING_NOTIFIER_HEAD(charger_notifier_list);
 274
 275 /* Main battery properties */
 276 static enum power_supply_property abx500_chargalg_props[] = {
 277         POWER_SUPPLY_PROP_STATUS,
 278         POWER_SUPPLY_PROP_HEALTH,
 279 };
 280
 281 struct 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  */
 294 static enum hrtimer_restart
 295 abx500_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  */
 316 static enum hrtimer_restart
 317 abx500_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  */
 338 static 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
 352 static 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  */
 383 static 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  */
 428 static 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  */
 443 static 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  */
 475 static 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  */
 490 static 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  */
 507 static 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  */
 520 static 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  */
 553 static 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  */
 591 static 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  */
 616 static 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  */
 631 static 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  */
 648 static 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  */
 689 static 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  */
 709 static 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  */
 730 static 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  */
 761 static 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  */
 805 static 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  */
 827 static 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
 858 static 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  */
 879 static 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
 951 static 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
 978 static 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  */
1312 static 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  */
1331 static 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  */
1709 static 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  */
1736 static 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  */
1758 static 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  */
1778 static 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
1813 static 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
1819 static 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
1844 static 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
1852 static 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
1899 static struct abx500_chargalg_sysfs_entry abx500_chargalg_en_charger =
1900         __ATTR(chargalg, 0644, abx500_chargalg_en_show,
1901                                 abx500_chargalg_en_store);
1902
1903 static 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
1907 static 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
1922 static 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
1937 static struct attribute *abx500_chargalg_chg[] = {
1938         &abx500_chargalg_en_charger.attr,
1939         &abx500_chargalg_curr_step.attr,
1940         NULL,
1941 };
1942
1943 static const struct sysfs_ops abx500_chargalg_sysfs_ops = {
1944         .show = abx500_chargalg_sysfs_show,
1945         .store = abx500_chargalg_sysfs_charger,
1946 };
1947
1948 static 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  */
1959 static 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  */
1971 static 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)
1986 static 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
2003 static 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
2020 static 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
2042 static char *supply_interface[] = {
2043         "ab8500_fg",
2044 };
2045
2046 static 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
2140 free_psy:
2141         power_supply_unregister(&di->chargalg_psy);
2142 free_chargalg_wq:
2143         destroy_workqueue(di->chargalg_wq);
2144         return ret;
2145 }
2146
2147 static const struct of_device_id ab8500_chargalg_match[] = {
2148         { .compatible = "stericsson,ab8500-chargalg", },
2149         { },
2150 };
2151
2152 static 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
2164 module_platform_driver(abx500_chargalg_driver);
2165
2166 MODULE_LICENSE("GPL v2");
2167 MODULE_AUTHOR("Johan Palsson, Karl Komierowski");
2168 MODULE_ALIAS("platform:abx500-chargalg");
2169 MODULE_DESCRIPTION("abx500 battery charging algorithm");