drivers/power/supply/ab8500_chargalg.c

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