drivers/power/supply/ab8500_charger.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright (C) ST-Ericsson SA 2012
   4  *
   5  * Charger driver for AB8500
   6  *
   7  * Author:
   8  *      Johan Palsson <johan.palsson@stericsson.com>
   9  *      Karl Komierowski <karl.komierowski@stericsson.com>
  10  *      Arun R Murthy <arun.murthy@stericsson.com>
  11  */
  12
  13 #include <linux/init.h>
  14 #include <linux/module.h>
  15 #include <linux/device.h>
  16 #include <linux/component.h>
  17 #include <linux/interrupt.h>
  18 #include <linux/delay.h>
  19 #include <linux/notifier.h>
  20 #include <linux/slab.h>
  21 #include <linux/platform_device.h>
  22 #include <linux/power_supply.h>
  23 #include <linux/completion.h>
  24 #include <linux/regulator/consumer.h>
  25 #include <linux/err.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/ab8500.h>
  31 #include <linux/mfd/abx500.h>
  32 #include <linux/usb/otg.h>
  33 #include <linux/mutex.h>
  34 #include <linux/iio/consumer.h>
  35
  36 #include "ab8500-bm.h"
  37 #include "ab8500-chargalg.h"
  38
  39 /* Charger constants */
  40 #define NO_PW_CONN                      0
  41 #define AC_PW_CONN                      1
  42 #define USB_PW_CONN                     2
  43
  44 #define MAIN_WDOG_ENA                   0x01
  45 #define MAIN_WDOG_KICK                  0x02
  46 #define MAIN_WDOG_DIS                   0x00
  47 #define CHARG_WD_KICK                   0x01
  48 #define MAIN_CH_ENA                     0x01
  49 #define MAIN_CH_NO_OVERSHOOT_ENA_N      0x02
  50 #define USB_CH_ENA                      0x01
  51 #define USB_CHG_NO_OVERSHOOT_ENA_N      0x02
  52 #define MAIN_CH_DET                     0x01
  53 #define MAIN_CH_CV_ON                   0x04
  54 #define USB_CH_CV_ON                    0x08
  55 #define VBUS_DET_DBNC100                0x02
  56 #define VBUS_DET_DBNC1                  0x01
  57 #define OTP_ENABLE_WD                   0x01
  58 #define DROP_COUNT_RESET                0x01
  59 #define USB_CH_DET                      0x01
  60
  61 #define MAIN_CH_INPUT_CURR_SHIFT        4
  62 #define VBUS_IN_CURR_LIM_SHIFT          4
  63 #define AUTO_VBUS_IN_CURR_LIM_SHIFT     4
  64 #define VBUS_IN_CURR_LIM_RETRY_SET_TIME 30 /* seconds */
  65
  66 #define LED_INDICATOR_PWM_ENA           0x01
  67 #define LED_INDICATOR_PWM_DIS           0x00
  68 #define LED_IND_CUR_5MA                 0x04
  69 #define LED_INDICATOR_PWM_DUTY_252_256  0xBF
  70
  71 /* HW failure constants */
  72 #define MAIN_CH_TH_PROT                 0x02
  73 #define VBUS_CH_NOK                     0x08
  74 #define USB_CH_TH_PROT                  0x02
  75 #define VBUS_OVV_TH                     0x01
  76 #define MAIN_CH_NOK                     0x01
  77 #define VBUS_DET                        0x80
  78
  79 #define MAIN_CH_STATUS2_MAINCHGDROP             0x80
  80 #define MAIN_CH_STATUS2_MAINCHARGERDETDBNC      0x40
  81 #define USB_CH_VBUSDROP                         0x40
  82 #define USB_CH_VBUSDETDBNC                      0x01
  83
  84 /* UsbLineStatus register bit masks */
  85 #define AB8500_USB_LINK_STATUS          0x78
  86 #define AB8505_USB_LINK_STATUS          0xF8
  87 #define AB8500_STD_HOST_SUSP            0x18
  88 #define USB_LINK_STATUS_SHIFT           3
  89
  90 /* Watchdog timeout constant */
  91 #define WD_TIMER                        0x30 /* 4min */
  92 #define WD_KICK_INTERVAL                (60 * HZ)
  93
  94 /* Lowest charger voltage is 3.39V -> 0x4E */
  95 #define LOW_VOLT_REG                    0x4E
  96
  97 /* Step up/down delay in us */
  98 #define STEP_UDELAY                     1000
  99
 100 #define CHARGER_STATUS_POLL 10 /* in ms */
 101
 102 #define CHG_WD_INTERVAL                 (60 * HZ)
 103
 104 #define AB8500_SW_CONTROL_FALLBACK      0x03
 105 /* Wait for enumeration before charing in us */
 106 #define WAIT_ACA_RID_ENUMERATION        (5 * 1000)
 107 /*External charger control*/
 108 #define AB8500_SYS_CHARGER_CONTROL_REG          0x52
 109 #define EXTERNAL_CHARGER_DISABLE_REG_VAL        0x03
 110 #define EXTERNAL_CHARGER_ENABLE_REG_VAL         0x07
 111
 112 /* UsbLineStatus register - usb types */
 113 enum ab8500_charger_link_status {
 114         USB_STAT_NOT_CONFIGURED,
 115         USB_STAT_STD_HOST_NC,
 116         USB_STAT_STD_HOST_C_NS,
 117         USB_STAT_STD_HOST_C_S,
 118         USB_STAT_HOST_CHG_NM,
 119         USB_STAT_HOST_CHG_HS,
 120         USB_STAT_HOST_CHG_HS_CHIRP,
 121         USB_STAT_DEDICATED_CHG,
 122         USB_STAT_ACA_RID_A,
 123         USB_STAT_ACA_RID_B,
 124         USB_STAT_ACA_RID_C_NM,
 125         USB_STAT_ACA_RID_C_HS,
 126         USB_STAT_ACA_RID_C_HS_CHIRP,
 127         USB_STAT_HM_IDGND,
 128         USB_STAT_RESERVED,
 129         USB_STAT_NOT_VALID_LINK,
 130         USB_STAT_PHY_EN,
 131         USB_STAT_SUP_NO_IDGND_VBUS,
 132         USB_STAT_SUP_IDGND_VBUS,
 133         USB_STAT_CHARGER_LINE_1,
 134         USB_STAT_CARKIT_1,
 135         USB_STAT_CARKIT_2,
 136         USB_STAT_ACA_DOCK_CHARGER,
 137 };
 138
 139 enum ab8500_usb_state {
 140         AB8500_BM_USB_STATE_RESET_HS,   /* HighSpeed Reset */
 141         AB8500_BM_USB_STATE_RESET_FS,   /* FullSpeed/LowSpeed Reset */
 142         AB8500_BM_USB_STATE_CONFIGURED,
 143         AB8500_BM_USB_STATE_SUSPEND,
 144         AB8500_BM_USB_STATE_RESUME,
 145         AB8500_BM_USB_STATE_MAX,
 146 };
 147
 148 /* VBUS input current limits supported in AB8500 in uA */
 149 #define USB_CH_IP_CUR_LVL_0P05          50000
 150 #define USB_CH_IP_CUR_LVL_0P09          98000
 151 #define USB_CH_IP_CUR_LVL_0P19          193000
 152 #define USB_CH_IP_CUR_LVL_0P29          290000
 153 #define USB_CH_IP_CUR_LVL_0P38          380000
 154 #define USB_CH_IP_CUR_LVL_0P45          450000
 155 #define USB_CH_IP_CUR_LVL_0P5           500000
 156 #define USB_CH_IP_CUR_LVL_0P6           600000
 157 #define USB_CH_IP_CUR_LVL_0P7           700000
 158 #define USB_CH_IP_CUR_LVL_0P8           800000
 159 #define USB_CH_IP_CUR_LVL_0P9           900000
 160 #define USB_CH_IP_CUR_LVL_1P0           1000000
 161 #define USB_CH_IP_CUR_LVL_1P1           1100000
 162 #define USB_CH_IP_CUR_LVL_1P3           1300000
 163 #define USB_CH_IP_CUR_LVL_1P4           1400000
 164 #define USB_CH_IP_CUR_LVL_1P5           1500000
 165
 166 #define VBAT_TRESH_IP_CUR_RED           3800
 167
 168 #define to_ab8500_charger_usb_device_info(x) container_of((x), \
 169         struct ab8500_charger, usb_chg)
 170 #define to_ab8500_charger_ac_device_info(x) container_of((x), \
 171         struct ab8500_charger, ac_chg)
 172
 173 /**
 174  * struct ab8500_charger_interrupts - ab8500 interupts
 175  * @name:       name of the interrupt
 176  * @isr         function pointer to the isr
 177  */
 178 struct ab8500_charger_interrupts {
 179         char *name;
 180         irqreturn_t (*isr)(int irq, void *data);
 181 };
 182
 183 struct ab8500_charger_info {
 184         int charger_connected;
 185         int charger_online;
 186         int charger_voltage_uv;
 187         int cv_active;
 188         bool wd_expired;
 189         int charger_current_ua;
 190 };
 191
 192 struct ab8500_charger_event_flags {
 193         bool mainextchnotok;
 194         bool main_thermal_prot;
 195         bool usb_thermal_prot;
 196         bool vbus_ovv;
 197         bool usbchargernotok;
 198         bool chgwdexp;
 199         bool vbus_collapse;
 200         bool vbus_drop_end;
 201 };
 202
 203 struct ab8500_charger_usb_state {
 204         int usb_current_ua;
 205         int usb_current_tmp_ua;
 206         enum ab8500_usb_state state;
 207         enum ab8500_usb_state state_tmp;
 208         spinlock_t usb_lock;
 209 };
 210
 211 struct ab8500_charger_max_usb_in_curr {
 212         int usb_type_max_ua;
 213         int set_max_ua;
 214         int calculated_max_ua;
 215 };
 216
 217 /**
 218  * struct ab8500_charger - ab8500 Charger device information
 219  * @dev:                Pointer to the structure device
 220  * @vbus_detected:      VBUS detected
 221  * @vbus_detected_start:
 222  *                      VBUS detected during startup
 223  * @ac_conn:            This will be true when the AC charger has been plugged
 224  * @vddadc_en_ac:       Indicate if VDD ADC supply is enabled because AC
 225  *                      charger is enabled
 226  * @vddadc_en_usb:      Indicate if VDD ADC supply is enabled because USB
 227  *                      charger is enabled
 228  * @vbat                Battery voltage
 229  * @old_vbat            Previously measured battery voltage
 230  * @usb_device_is_unrecognised  USB device is unrecognised by the hardware
 231  * @autopower           Indicate if we should have automatic pwron after pwrloss
 232  * @autopower_cfg       platform specific power config support for "pwron after pwrloss"
 233  * @invalid_charger_detect_state State when forcing AB to use invalid charger
 234  * @is_aca_rid:         Incicate if accessory is ACA type
 235  * @current_stepping_sessions:
 236  *                      Counter for current stepping sessions
 237  * @parent:             Pointer to the struct ab8500
 238  * @adc_main_charger_v  ADC channel for main charger voltage
 239  * @adc_main_charger_c  ADC channel for main charger current
 240  * @adc_vbus_v          ADC channel for USB charger voltage
 241  * @adc_usb_charger_c   ADC channel for USB charger current
 242  * @bm:                 Platform specific battery management information
 243  * @flags:              Structure for information about events triggered
 244  * @usb_state:          Structure for usb stack information
 245  * @max_usb_in_curr:    Max USB charger input current
 246  * @ac_chg:             AC charger power supply
 247  * @usb_chg:            USB charger power supply
 248  * @ac:                 Structure that holds the AC charger properties
 249  * @usb:                Structure that holds the USB charger properties
 250  * @regu:               Pointer to the struct regulator
 251  * @charger_wq:         Work queue for the IRQs and checking HW state
 252  * @usb_ipt_crnt_lock:  Lock to protect VBUS input current setting from mutuals
 253  * @pm_lock:            Lock to prevent system to suspend
 254  * @check_vbat_work     Work for checking vbat threshold to adjust vbus current
 255  * @check_hw_failure_work:      Work for checking HW state
 256  * @check_usbchgnotok_work:     Work for checking USB charger not ok status
 257  * @kick_wd_work:               Work for kicking the charger watchdog in case
 258  *                              of ABB rev 1.* due to the watchog logic bug
 259  * @ac_charger_attached_work:   Work for checking if AC charger is still
 260  *                              connected
 261  * @usb_charger_attached_work:  Work for checking if USB charger is still
 262  *                              connected
 263  * @ac_work:                    Work for checking AC charger connection
 264  * @detect_usb_type_work:       Work for detecting the USB type connected
 265  * @usb_link_status_work:       Work for checking the new USB link status
 266  * @usb_state_changed_work:     Work for checking USB state
 267  * @attach_work:                Work for detecting USB type
 268  * @vbus_drop_end_work:         Work for detecting VBUS drop end
 269  * @check_main_thermal_prot_work:
 270  *                              Work for checking Main thermal status
 271  * @check_usb_thermal_prot_work:
 272  *                              Work for checking USB thermal status
 273  * @charger_attached_mutex:     For controlling the wakelock
 274  */
 275 struct ab8500_charger {
 276         struct device *dev;
 277         bool vbus_detected;
 278         bool vbus_detected_start;
 279         bool ac_conn;
 280         bool vddadc_en_ac;
 281         bool vddadc_en_usb;
 282         int vbat;
 283         int old_vbat;
 284         bool usb_device_is_unrecognised;
 285         bool autopower;
 286         bool autopower_cfg;
 287         int invalid_charger_detect_state;
 288         int is_aca_rid;
 289         atomic_t current_stepping_sessions;
 290         struct ab8500 *parent;
 291         struct iio_channel *adc_main_charger_v;
 292         struct iio_channel *adc_main_charger_c;
 293         struct iio_channel *adc_vbus_v;
 294         struct iio_channel *adc_usb_charger_c;
 295         struct ab8500_bm_data *bm;
 296         struct ab8500_charger_event_flags flags;
 297         struct ab8500_charger_usb_state usb_state;
 298         struct ab8500_charger_max_usb_in_curr max_usb_in_curr;
 299         struct ux500_charger ac_chg;
 300         struct ux500_charger usb_chg;
 301         struct ab8500_charger_info ac;
 302         struct ab8500_charger_info usb;
 303         struct regulator *regu;
 304         struct workqueue_struct *charger_wq;
 305         struct mutex usb_ipt_crnt_lock;
 306         struct delayed_work check_vbat_work;
 307         struct delayed_work check_hw_failure_work;
 308         struct delayed_work check_usbchgnotok_work;
 309         struct delayed_work kick_wd_work;
 310         struct delayed_work usb_state_changed_work;
 311         struct delayed_work attach_work;
 312         struct delayed_work ac_charger_attached_work;
 313         struct delayed_work usb_charger_attached_work;
 314         struct delayed_work vbus_drop_end_work;
 315         struct work_struct ac_work;
 316         struct work_struct detect_usb_type_work;
 317         struct work_struct usb_link_status_work;
 318         struct work_struct check_main_thermal_prot_work;
 319         struct work_struct check_usb_thermal_prot_work;
 320         struct usb_phy *usb_phy;
 321         struct notifier_block nb;
 322         struct mutex charger_attached_mutex;
 323 };
 324
 325 /* AC properties */
 326 static enum power_supply_property ab8500_charger_ac_props[] = {
 327         POWER_SUPPLY_PROP_HEALTH,
 328         POWER_SUPPLY_PROP_PRESENT,
 329         POWER_SUPPLY_PROP_ONLINE,
 330         POWER_SUPPLY_PROP_VOLTAGE_NOW,
 331         POWER_SUPPLY_PROP_VOLTAGE_AVG,
 332         POWER_SUPPLY_PROP_CURRENT_NOW,
 333 };
 334
 335 /* USB properties */
 336 static enum power_supply_property ab8500_charger_usb_props[] = {
 337         POWER_SUPPLY_PROP_HEALTH,
 338         POWER_SUPPLY_PROP_CURRENT_AVG,
 339         POWER_SUPPLY_PROP_PRESENT,
 340         POWER_SUPPLY_PROP_ONLINE,
 341         POWER_SUPPLY_PROP_VOLTAGE_NOW,
 342         POWER_SUPPLY_PROP_VOLTAGE_AVG,
 343         POWER_SUPPLY_PROP_CURRENT_NOW,
 344 };
 345
 346 /*
 347  * Function for enabling and disabling sw fallback mode
 348  * should always be disabled when no charger is connected.
 349  */
 350 static void ab8500_enable_disable_sw_fallback(struct ab8500_charger *di,
 351                 bool fallback)
 352 {
 353         u8 val;
 354         u8 reg;
 355         u8 bank;
 356         u8 bit;
 357         int ret;
 358
 359         dev_dbg(di->dev, "SW Fallback: %d\n", fallback);
 360
 361         if (is_ab8500(di->parent)) {
 362                 bank = 0x15;
 363                 reg = 0x0;
 364                 bit = 3;
 365         } else {
 366                 bank = AB8500_SYS_CTRL1_BLOCK;
 367                 reg = AB8500_SW_CONTROL_FALLBACK;
 368                 bit = 0;
 369         }
 370
 371         /* read the register containing fallback bit */
 372         ret = abx500_get_register_interruptible(di->dev, bank, reg, &val);
 373         if (ret < 0) {
 374                 dev_err(di->dev, "%d read failed\n", __LINE__);
 375                 return;
 376         }
 377
 378         if (is_ab8500(di->parent)) {
 379                 /* enable the OPT emulation registers */
 380                 ret = abx500_set_register_interruptible(di->dev, 0x11, 0x00, 0x2);
 381                 if (ret) {
 382                         dev_err(di->dev, "%d write failed\n", __LINE__);
 383                         goto disable_otp;
 384                 }
 385         }
 386
 387         if (fallback)
 388                 val |= (1 << bit);
 389         else
 390                 val &= ~(1 << bit);
 391
 392         /* write back the changed fallback bit value to register */
 393         ret = abx500_set_register_interruptible(di->dev, bank, reg, val);
 394         if (ret) {
 395                 dev_err(di->dev, "%d write failed\n", __LINE__);
 396         }
 397
 398 disable_otp:
 399         if (is_ab8500(di->parent)) {
 400                 /* disable the set OTP registers again */
 401                 ret = abx500_set_register_interruptible(di->dev, 0x11, 0x00, 0x0);
 402                 if (ret) {
 403                         dev_err(di->dev, "%d write failed\n", __LINE__);
 404                 }
 405         }
 406 }
 407
 408 /**
 409  * ab8500_power_supply_changed - a wrapper with local extensions for
 410  * power_supply_changed
 411  * @di:   pointer to the ab8500_charger structure
 412  * @psy:  pointer to power_supply_that have changed.
 413  *
 414  */
 415 static void ab8500_power_supply_changed(struct ab8500_charger *di,
 416                                         struct power_supply *psy)
 417 {
 418         /*
 419          * This happens if we get notifications or interrupts and
 420          * the platform has been configured not to support one or
 421          * other type of charging.
 422          */
 423         if (!psy)
 424                 return;
 425
 426         if (di->autopower_cfg) {
 427                 if (!di->usb.charger_connected &&
 428                     !di->ac.charger_connected &&
 429                     di->autopower) {
 430                         di->autopower = false;
 431                         ab8500_enable_disable_sw_fallback(di, false);
 432                 } else if (!di->autopower &&
 433                            (di->ac.charger_connected ||
 434                             di->usb.charger_connected)) {
 435                         di->autopower = true;
 436                         ab8500_enable_disable_sw_fallback(di, true);
 437                 }
 438         }
 439         power_supply_changed(psy);
 440 }
 441
 442 static void ab8500_charger_set_usb_connected(struct ab8500_charger *di,
 443         bool connected)
 444 {
 445         if (connected != di->usb.charger_connected) {
 446                 dev_dbg(di->dev, "USB connected:%i\n", connected);
 447                 di->usb.charger_connected = connected;
 448
 449                 if (!connected)
 450                         di->flags.vbus_drop_end = false;
 451
 452                 /*
 453                  * Sometimes the platform is configured not to support
 454                  * USB charging and no psy has been created, but we still
 455                  * will get these notifications.
 456                  */
 457                 if (di->usb_chg.psy) {
 458                         sysfs_notify(&di->usb_chg.psy->dev.kobj, NULL,
 459                                      "present");
 460                 }
 461
 462                 if (connected) {
 463                         mutex_lock(&di->charger_attached_mutex);
 464                         mutex_unlock(&di->charger_attached_mutex);
 465
 466                         if (is_ab8500(di->parent))
 467                                 queue_delayed_work(di->charger_wq,
 468                                            &di->usb_charger_attached_work,
 469                                            HZ);
 470                 } else {
 471                         cancel_delayed_work_sync(&di->usb_charger_attached_work);
 472                         mutex_lock(&di->charger_attached_mutex);
 473                         mutex_unlock(&di->charger_attached_mutex);
 474                 }
 475         }
 476 }
 477
 478 /**
 479  * ab8500_charger_get_ac_voltage() - get ac charger voltage
 480  * @di:         pointer to the ab8500_charger structure
 481  *
 482  * Returns ac charger voltage in microvolt (on success)
 483  */
 484 static int ab8500_charger_get_ac_voltage(struct ab8500_charger *di)
 485 {
 486         int vch, ret;
 487
 488         /* Only measure voltage if the charger is connected */
 489         if (di->ac.charger_connected) {
 490                 ret = iio_read_channel_processed(di->adc_main_charger_v, &vch);
 491                 if (ret < 0)
 492                         dev_err(di->dev, "%s ADC conv failed,\n", __func__);
 493         } else {
 494                 vch = 0;
 495         }
 496         /* Convert to microvolt, IIO returns millivolt */
 497         return vch * 1000;
 498 }
 499
 500 /**
 501  * ab8500_charger_ac_cv() - check if the main charger is in CV mode
 502  * @di:         pointer to the ab8500_charger structure
 503  *
 504  * Returns ac charger CV mode (on success) else error code
 505  */
 506 static int ab8500_charger_ac_cv(struct ab8500_charger *di)
 507 {
 508         u8 val;
 509         int ret = 0;
 510
 511         /* Only check CV mode if the charger is online */
 512         if (di->ac.charger_online) {
 513                 ret = abx500_get_register_interruptible(di->dev, AB8500_CHARGER,
 514                         AB8500_CH_STATUS1_REG, &val);
 515                 if (ret < 0) {
 516                         dev_err(di->dev, "%s ab8500 read failed\n", __func__);
 517                         return 0;
 518                 }
 519
 520                 if (val & MAIN_CH_CV_ON)
 521                         ret = 1;
 522                 else
 523                         ret = 0;
 524         }
 525
 526         return ret;
 527 }
 528
 529 /**
 530  * ab8500_charger_get_vbus_voltage() - get vbus voltage
 531  * @di:         pointer to the ab8500_charger structure
 532  *
 533  * This function returns the vbus voltage.
 534  * Returns vbus voltage in microvolt (on success)
 535  */
 536 static int ab8500_charger_get_vbus_voltage(struct ab8500_charger *di)
 537 {
 538         int vch, ret;
 539
 540         /* Only measure voltage if the charger is connected */
 541         if (di->usb.charger_connected) {
 542                 ret = iio_read_channel_processed(di->adc_vbus_v, &vch);
 543                 if (ret < 0)
 544                         dev_err(di->dev, "%s ADC conv failed,\n", __func__);
 545         } else {
 546                 vch = 0;
 547         }
 548         /* Convert to microvolt, IIO returns millivolt */
 549         return vch * 1000;
 550 }
 551
 552 /**
 553  * ab8500_charger_get_usb_current() - get usb charger current
 554  * @di:         pointer to the ab8500_charger structure
 555  *
 556  * This function returns the usb charger current.
 557  * Returns usb current in microamperes (on success) and error code on failure
 558  */
 559 static int ab8500_charger_get_usb_current(struct ab8500_charger *di)
 560 {
 561         int ich, ret;
 562
 563         /* Only measure current if the charger is online */
 564         if (di->usb.charger_online) {
 565                 ret = iio_read_channel_processed(di->adc_usb_charger_c, &ich);
 566                 if (ret < 0)
 567                         dev_err(di->dev, "%s ADC conv failed,\n", __func__);
 568         } else {
 569                 ich = 0;
 570         }
 571         /* Return microamperes */
 572         return ich * 1000;
 573 }
 574
 575 /**
 576  * ab8500_charger_get_ac_current() - get ac charger current
 577  * @di:         pointer to the ab8500_charger structure
 578  *
 579  * This function returns the ac charger current.
 580  * Returns ac current in microamperes (on success) and error code on failure.
 581  */
 582 static int ab8500_charger_get_ac_current(struct ab8500_charger *di)
 583 {
 584         int ich, ret;
 585
 586         /* Only measure current if the charger is online */
 587         if (di->ac.charger_online) {
 588                 ret = iio_read_channel_processed(di->adc_main_charger_c, &ich);
 589                 if (ret < 0)
 590                         dev_err(di->dev, "%s ADC conv failed,\n", __func__);
 591         } else {
 592                 ich = 0;
 593         }
 594         /* Return microamperes */
 595         return ich * 1000;
 596 }
 597
 598 /**
 599  * ab8500_charger_usb_cv() - check if the usb charger is in CV mode
 600  * @di:         pointer to the ab8500_charger structure
 601  *
 602  * Returns ac charger CV mode (on success) else error code
 603  */
 604 static int ab8500_charger_usb_cv(struct ab8500_charger *di)
 605 {
 606         int ret;
 607         u8 val;
 608
 609         /* Only check CV mode if the charger is online */
 610         if (di->usb.charger_online) {
 611                 ret = abx500_get_register_interruptible(di->dev, AB8500_CHARGER,
 612                         AB8500_CH_USBCH_STAT1_REG, &val);
 613                 if (ret < 0) {
 614                         dev_err(di->dev, "%s ab8500 read failed\n", __func__);
 615                         return 0;
 616                 }
 617
 618                 if (val & USB_CH_CV_ON)
 619                         ret = 1;
 620                 else
 621                         ret = 0;
 622         } else {
 623                 ret = 0;
 624         }
 625
 626         return ret;
 627 }
 628
 629 /**
 630  * ab8500_charger_detect_chargers() - Detect the connected chargers
 631  * @di:         pointer to the ab8500_charger structure
 632  * @probe:      if probe, don't delay and wait for HW
 633  *
 634  * Returns the type of charger connected.
 635  * For USB it will not mean we can actually charge from it
 636  * but that there is a USB cable connected that we have to
 637  * identify. This is used during startup when we don't get
 638  * interrupts of the charger detection
 639  *
 640  * Returns an integer value, that means,
 641  * NO_PW_CONN  no power supply is connected
 642  * AC_PW_CONN  if the AC power supply is connected
 643  * USB_PW_CONN  if the USB power supply is connected
 644  * AC_PW_CONN + USB_PW_CONN if USB and AC power supplies are both connected
 645  */
 646 static int ab8500_charger_detect_chargers(struct ab8500_charger *di, bool probe)
 647 {
 648         int result = NO_PW_CONN;
 649         int ret;
 650         u8 val;
 651
 652         /* Check for AC charger */
 653         ret = abx500_get_register_interruptible(di->dev, AB8500_CHARGER,
 654                 AB8500_CH_STATUS1_REG, &val);
 655         if (ret < 0) {
 656                 dev_err(di->dev, "%s ab8500 read failed\n", __func__);
 657                 return ret;
 658         }
 659
 660         if (val & MAIN_CH_DET)
 661                 result = AC_PW_CONN;
 662
 663         /* Check for USB charger */
 664
 665         if (!probe) {
 666                 /*
 667                  * AB8500 says VBUS_DET_DBNC1 & VBUS_DET_DBNC100
 668                  * when disconnecting ACA even though no
 669                  * charger was connected. Try waiting a little
 670                  * longer than the 100 ms of VBUS_DET_DBNC100...
 671                  */
 672                 msleep(110);
 673         }
 674         ret = abx500_get_register_interruptible(di->dev, AB8500_CHARGER,
 675                 AB8500_CH_USBCH_STAT1_REG, &val);
 676         if (ret < 0) {
 677                 dev_err(di->dev, "%s ab8500 read failed\n", __func__);
 678                 return ret;
 679         }
 680         dev_dbg(di->dev,
 681                 "%s AB8500_CH_USBCH_STAT1_REG %x\n", __func__,
 682                 val);
 683         if ((val & VBUS_DET_DBNC1) && (val & VBUS_DET_DBNC100))
 684                 result |= USB_PW_CONN;
 685
 686         return result;
 687 }
 688
 689 /**
 690  * ab8500_charger_max_usb_curr() - get the max curr for the USB type
 691  * @di:                 pointer to the ab8500_charger structure
 692  * @link_status:        the identified USB type
 693  *
 694  * Get the maximum current that is allowed to be drawn from the host
 695  * based on the USB type.
 696  * Returns error code in case of failure else 0 on success
 697  */
 698 static int ab8500_charger_max_usb_curr(struct ab8500_charger *di,
 699                 enum ab8500_charger_link_status link_status)
 700 {
 701         int ret = 0;
 702
 703         di->usb_device_is_unrecognised = false;
 704
 705         /*
 706          * Platform only supports USB 2.0.
 707          * This means that charging current from USB source
 708          * is maximum 500 mA. Every occurrence of USB_STAT_*_HOST_*
 709          * should set USB_CH_IP_CUR_LVL_0P5.
 710          */
 711
 712         switch (link_status) {
 713         case USB_STAT_STD_HOST_NC:
 714         case USB_STAT_STD_HOST_C_NS:
 715         case USB_STAT_STD_HOST_C_S:
 716                 dev_dbg(di->dev, "USB Type - Standard host is "
 717                         "detected through USB driver\n");
 718                 di->max_usb_in_curr.usb_type_max_ua = USB_CH_IP_CUR_LVL_0P5;
 719                 di->is_aca_rid = 0;
 720                 break;
 721         case USB_STAT_HOST_CHG_HS_CHIRP:
 722                 di->max_usb_in_curr.usb_type_max_ua = USB_CH_IP_CUR_LVL_0P5;
 723                 di->is_aca_rid = 0;
 724                 break;
 725         case USB_STAT_HOST_CHG_HS:
 726                 di->max_usb_in_curr.usb_type_max_ua = USB_CH_IP_CUR_LVL_0P5;
 727                 di->is_aca_rid = 0;
 728                 break;
 729         case USB_STAT_ACA_RID_C_HS:
 730                 di->max_usb_in_curr.usb_type_max_ua = USB_CH_IP_CUR_LVL_0P9;
 731                 di->is_aca_rid = 0;
 732                 break;
 733         case USB_STAT_ACA_RID_A:
 734                 /*
 735                  * Dedicated charger level minus maximum current accessory
 736                  * can consume (900mA). Closest level is 500mA
 737                  */
 738                 dev_dbg(di->dev, "USB_STAT_ACA_RID_A detected\n");
 739                 di->max_usb_in_curr.usb_type_max_ua = USB_CH_IP_CUR_LVL_0P5;
 740                 di->is_aca_rid = 1;
 741                 break;
 742         case USB_STAT_ACA_RID_B:
 743                 /*
 744                  * Dedicated charger level minus 120mA (20mA for ACA and
 745                  * 100mA for potential accessory). Closest level is 1300mA
 746                  */
 747                 di->max_usb_in_curr.usb_type_max_ua = USB_CH_IP_CUR_LVL_1P3;
 748                 dev_dbg(di->dev, "USB Type - 0x%02x MaxCurr: %d", link_status,
 749                                 di->max_usb_in_curr.usb_type_max_ua);
 750                 di->is_aca_rid = 1;
 751                 break;
 752         case USB_STAT_HOST_CHG_NM:
 753                 di->max_usb_in_curr.usb_type_max_ua = USB_CH_IP_CUR_LVL_0P5;
 754                 di->is_aca_rid = 0;
 755                 break;
 756         case USB_STAT_DEDICATED_CHG:
 757                 di->max_usb_in_curr.usb_type_max_ua = USB_CH_IP_CUR_LVL_1P5;
 758                 di->is_aca_rid = 0;
 759                 break;
 760         case USB_STAT_ACA_RID_C_HS_CHIRP:
 761         case USB_STAT_ACA_RID_C_NM:
 762                 di->max_usb_in_curr.usb_type_max_ua = USB_CH_IP_CUR_LVL_1P5;
 763                 di->is_aca_rid = 1;
 764                 break;
 765         case USB_STAT_NOT_CONFIGURED:
 766                 if (di->vbus_detected) {
 767                         di->usb_device_is_unrecognised = true;
 768                         dev_dbg(di->dev, "USB Type - Legacy charger.\n");
 769                         di->max_usb_in_curr.usb_type_max_ua =
 770                                                 USB_CH_IP_CUR_LVL_1P5;
 771                         break;
 772                 }
 773                 fallthrough;
 774         case USB_STAT_HM_IDGND:
 775                 dev_err(di->dev, "USB Type - Charging not allowed\n");
 776                 di->max_usb_in_curr.usb_type_max_ua = USB_CH_IP_CUR_LVL_0P05;
 777                 ret = -ENXIO;
 778                 break;
 779         case USB_STAT_RESERVED:
 780                 if (is_ab8500(di->parent)) {
 781                         di->flags.vbus_collapse = true;
 782                         dev_err(di->dev, "USB Type - USB_STAT_RESERVED "
 783                                                 "VBUS has collapsed\n");
 784                         ret = -ENXIO;
 785                         break;
 786                 } else {
 787                         dev_dbg(di->dev, "USB Type - Charging not allowed\n");
 788                         di->max_usb_in_curr.usb_type_max_ua =
 789                                                 USB_CH_IP_CUR_LVL_0P05;
 790                         dev_dbg(di->dev, "USB Type - 0x%02x MaxCurr: %d",
 791                                 link_status,
 792                                 di->max_usb_in_curr.usb_type_max_ua);
 793                         ret = -ENXIO;
 794                         break;
 795                 }
 796         case USB_STAT_CARKIT_1:
 797         case USB_STAT_CARKIT_2:
 798         case USB_STAT_ACA_DOCK_CHARGER:
 799         case USB_STAT_CHARGER_LINE_1:
 800                 di->max_usb_in_curr.usb_type_max_ua = USB_CH_IP_CUR_LVL_0P5;
 801                 dev_dbg(di->dev, "USB Type - 0x%02x MaxCurr: %d", link_status,
 802                                 di->max_usb_in_curr.usb_type_max_ua);
 803                 break;
 804         case USB_STAT_NOT_VALID_LINK:
 805                 dev_err(di->dev, "USB Type invalid - try charging anyway\n");
 806                 di->max_usb_in_curr.usb_type_max_ua = USB_CH_IP_CUR_LVL_0P5;
 807                 break;
 808
 809         default:
 810                 dev_err(di->dev, "USB Type - Unknown\n");
 811                 di->max_usb_in_curr.usb_type_max_ua = USB_CH_IP_CUR_LVL_0P05;
 812                 ret = -ENXIO;
 813                 break;
 814         }
 815
 816         di->max_usb_in_curr.set_max_ua = di->max_usb_in_curr.usb_type_max_ua;
 817         dev_dbg(di->dev, "USB Type - 0x%02x MaxCurr: %d",
 818                 link_status, di->max_usb_in_curr.set_max_ua);
 819
 820         return ret;
 821 }
 822
 823 /**
 824  * ab8500_charger_read_usb_type() - read the type of usb connected
 825  * @di:         pointer to the ab8500_charger structure
 826  *
 827  * Detect the type of the plugged USB
 828  * Returns error code in case of failure else 0 on success
 829  */
 830 static int ab8500_charger_read_usb_type(struct ab8500_charger *di)
 831 {
 832         int ret;
 833         u8 val;
 834
 835         ret = abx500_get_register_interruptible(di->dev,
 836                 AB8500_INTERRUPT, AB8500_IT_SOURCE21_REG, &val);
 837         if (ret < 0) {
 838                 dev_err(di->dev, "%s ab8500 read failed\n", __func__);
 839                 return ret;
 840         }
 841         if (is_ab8500(di->parent))
 842                 ret = abx500_get_register_interruptible(di->dev, AB8500_USB,
 843                         AB8500_USB_LINE_STAT_REG, &val);
 844         else
 845                 ret = abx500_get_register_interruptible(di->dev,
 846                         AB8500_USB, AB8500_USB_LINK1_STAT_REG, &val);
 847         if (ret < 0) {
 848                 dev_err(di->dev, "%s ab8500 read failed\n", __func__);
 849                 return ret;
 850         }
 851
 852         /* get the USB type */
 853         if (is_ab8500(di->parent))
 854                 val = (val & AB8500_USB_LINK_STATUS) >> USB_LINK_STATUS_SHIFT;
 855         else
 856                 val = (val & AB8505_USB_LINK_STATUS) >> USB_LINK_STATUS_SHIFT;
 857         ret = ab8500_charger_max_usb_curr(di,
 858                 (enum ab8500_charger_link_status) val);
 859
 860         return ret;
 861 }
 862
 863 /**
 864  * ab8500_charger_detect_usb_type() - get the type of usb connected
 865  * @di:         pointer to the ab8500_charger structure
 866  *
 867  * Detect the type of the plugged USB
 868  * Returns error code in case of failure else 0 on success
 869  */
 870 static int ab8500_charger_detect_usb_type(struct ab8500_charger *di)
 871 {
 872         int i, ret;
 873         u8 val;
 874
 875         /*
 876          * On getting the VBUS rising edge detect interrupt there
 877          * is a 250ms delay after which the register UsbLineStatus
 878          * is filled with valid data.
 879          */
 880         for (i = 0; i < 10; i++) {
 881                 msleep(250);
 882                 ret = abx500_get_register_interruptible(di->dev,
 883                         AB8500_INTERRUPT, AB8500_IT_SOURCE21_REG,
 884                         &val);
 885                 dev_dbg(di->dev, "%s AB8500_IT_SOURCE21_REG %x\n",
 886                         __func__, val);
 887                 if (ret < 0) {
 888                         dev_err(di->dev, "%s ab8500 read failed\n", __func__);
 889                         return ret;
 890                 }
 891
 892                 if (is_ab8500(di->parent))
 893                         ret = abx500_get_register_interruptible(di->dev,
 894                                 AB8500_USB, AB8500_USB_LINE_STAT_REG, &val);
 895                 else
 896                         ret = abx500_get_register_interruptible(di->dev,
 897                                 AB8500_USB, AB8500_USB_LINK1_STAT_REG, &val);
 898                 if (ret < 0) {
 899                         dev_err(di->dev, "%s ab8500 read failed\n", __func__);
 900                         return ret;
 901                 }
 902                 dev_dbg(di->dev, "%s AB8500_USB_LINE_STAT_REG %x\n", __func__,
 903                         val);
 904                 /*
 905                  * Until the IT source register is read the UsbLineStatus
 906                  * register is not updated, hence doing the same
 907                  * Revisit this:
 908                  */
 909
 910                 /* get the USB type */
 911                 if (is_ab8500(di->parent))
 912                         val = (val & AB8500_USB_LINK_STATUS) >>
 913                                                         USB_LINK_STATUS_SHIFT;
 914                 else
 915                         val = (val & AB8505_USB_LINK_STATUS) >>
 916                                                         USB_LINK_STATUS_SHIFT;
 917                 if (val)
 918                         break;
 919         }
 920         ret = ab8500_charger_max_usb_curr(di,
 921                 (enum ab8500_charger_link_status) val);
 922
 923         return ret;
 924 }
 925
 926 /*
 927  * This array maps the raw hex value to charger voltage used by the AB8500
 928  * Values taken from the UM0836, in microvolt.
 929  */
 930 static int ab8500_charger_voltage_map[] = {
 931         3500000,
 932         3525000,
 933         3550000,
 934         3575000,
 935         3600000,
 936         3625000,
 937         3650000,
 938         3675000,
 939         3700000,
 940         3725000,
 941         3750000,
 942         3775000,
 943         3800000,
 944         3825000,
 945         3850000,
 946         3875000,
 947         3900000,
 948         3925000,
 949         3950000,
 950         3975000,
 951         4000000,
 952         4025000,
 953         4050000,
 954         4060000,
 955         4070000,
 956         4080000,
 957         4090000,
 958         4100000,
 959         4110000,
 960         4120000,
 961         4130000,
 962         4140000,
 963         4150000,
 964         4160000,
 965         4170000,
 966         4180000,
 967         4190000,
 968         4200000,
 969         4210000,
 970         4220000,
 971         4230000,
 972         4240000,
 973         4250000,
 974         4260000,
 975         4270000,
 976         4280000,
 977         4290000,
 978         4300000,
 979         4310000,
 980         4320000,
 981         4330000,
 982         4340000,
 983         4350000,
 984         4360000,
 985         4370000,
 986         4380000,
 987         4390000,
 988         4400000,
 989         4410000,
 990         4420000,
 991         4430000,
 992         4440000,
 993         4450000,
 994         4460000,
 995         4470000,
 996         4480000,
 997         4490000,
 998         4500000,
 999         4510000,
1000         4520000,
1001         4530000,
1002         4540000,
1003         4550000,
1004         4560000,
1005         4570000,
1006         4580000,
1007         4590000,
1008         4600000,
1009 };
1010
1011 static int ab8500_voltage_to_regval(int voltage_uv)
1012 {
1013         int i;
1014
1015         /* Special case for voltage below 3.5V */
1016         if (voltage_uv < ab8500_charger_voltage_map[0])
1017                 return LOW_VOLT_REG;
1018
1019         for (i = 1; i < ARRAY_SIZE(ab8500_charger_voltage_map); i++) {
1020                 if (voltage_uv < ab8500_charger_voltage_map[i])
1021                         return i - 1;
1022         }
1023
1024         /* If not last element, return error */
1025         i = ARRAY_SIZE(ab8500_charger_voltage_map) - 1;
1026         if (voltage_uv == ab8500_charger_voltage_map[i])
1027                 return i;
1028         else
1029                 return -1;
1030 }
1031
1032 /* This array maps the raw register value to charger input current */
1033 static int ab8500_charge_input_curr_map[] = {
1034         50000, 98000, 193000, 290000, 380000, 450000, 500000, 600000,
1035         700000, 800000, 900000, 1000000, 1100000, 1300000, 1400000, 1500000,
1036 };
1037
1038 /* This array maps the raw register value to charger output current */
1039 static int ab8500_charge_output_curr_map[] = {
1040         100000, 200000, 300000, 400000, 500000, 600000, 700000, 800000,
1041         900000, 1000000, 1100000, 1200000, 1300000, 1400000, 1500000, 1500000,
1042 };
1043
1044 static int ab8500_current_to_regval(struct ab8500_charger *di, int curr_ua)
1045 {
1046         int i;
1047
1048         if (curr_ua < ab8500_charge_output_curr_map[0])
1049                 return 0;
1050
1051         for (i = 0; i < ARRAY_SIZE(ab8500_charge_output_curr_map); i++) {
1052                 if (curr_ua < ab8500_charge_output_curr_map[i])
1053                         return i - 1;
1054         }
1055
1056         /* If not last element, return error */
1057         i =  ARRAY_SIZE(ab8500_charge_output_curr_map) - 1;
1058         if (curr_ua == ab8500_charge_output_curr_map[i])
1059                 return i;
1060         else
1061                 return -1;
1062 }
1063
1064 static int ab8500_vbus_in_curr_to_regval(struct ab8500_charger *di, int curr_ua)
1065 {
1066         int i;
1067
1068         if (curr_ua < ab8500_charge_input_curr_map[0])
1069                 return 0;
1070
1071         for (i = 0; i < ARRAY_SIZE(ab8500_charge_input_curr_map); i++) {
1072                 if (curr_ua < ab8500_charge_input_curr_map[i])
1073                         return i - 1;
1074         }
1075
1076         /* If not last element, return error */
1077         i =  ARRAY_SIZE(ab8500_charge_input_curr_map) - 1;
1078         if (curr_ua == ab8500_charge_input_curr_map[i])
1079                 return i;
1080         else
1081                 return -1;
1082 }
1083
1084 /**
1085  * ab8500_charger_get_usb_cur() - get usb current
1086  * @di:         pointer to the ab8500_charger structre
1087  *
1088  * The usb stack provides the maximum current that can be drawn from
1089  * the standard usb host. This will be in uA.
1090  * This function converts current in uA to a value that can be written
1091  * to the register. Returns -1 if charging is not allowed
1092  */
1093 static int ab8500_charger_get_usb_cur(struct ab8500_charger *di)
1094 {
1095         int ret = 0;
1096         switch (di->usb_state.usb_current_ua) {
1097         case 100000:
1098                 di->max_usb_in_curr.usb_type_max_ua = USB_CH_IP_CUR_LVL_0P09;
1099                 break;
1100         case 200000:
1101                 di->max_usb_in_curr.usb_type_max_ua = USB_CH_IP_CUR_LVL_0P19;
1102                 break;
1103         case 300000:
1104                 di->max_usb_in_curr.usb_type_max_ua = USB_CH_IP_CUR_LVL_0P29;
1105                 break;
1106         case 400000:
1107                 di->max_usb_in_curr.usb_type_max_ua = USB_CH_IP_CUR_LVL_0P38;
1108                 break;
1109         case 500000:
1110                 di->max_usb_in_curr.usb_type_max_ua = USB_CH_IP_CUR_LVL_0P5;
1111                 break;
1112         default:
1113                 di->max_usb_in_curr.usb_type_max_ua = USB_CH_IP_CUR_LVL_0P05;
1114                 ret = -EPERM;
1115                 break;
1116         }
1117         di->max_usb_in_curr.set_max_ua = di->max_usb_in_curr.usb_type_max_ua;
1118         return ret;
1119 }
1120
1121 /**
1122  * ab8500_charger_check_continue_stepping() - Check to allow stepping
1123  * @di:         pointer to the ab8500_charger structure
1124  * @reg:        select what charger register to check
1125  *
1126  * Check if current stepping should be allowed to continue.
1127  * Checks if charger source has not collapsed. If it has, further stepping
1128  * is not allowed.
1129  */
1130 static bool ab8500_charger_check_continue_stepping(struct ab8500_charger *di,
1131                                                    int reg)
1132 {
1133         if (reg == AB8500_USBCH_IPT_CRNTLVL_REG)
1134                 return !di->flags.vbus_drop_end;
1135         else
1136                 return true;
1137 }
1138
1139 /**
1140  * ab8500_charger_set_current() - set charger current
1141  * @di:         pointer to the ab8500_charger structure
1142  * @ich_ua:     charger current, in uA
1143  * @reg:        select what charger register to set
1144  *
1145  * Set charger current.
1146  * There is no state machine in the AB to step up/down the charger
1147  * current to avoid dips and spikes on MAIN, VBUS and VBAT when
1148  * charging is started. Instead we need to implement
1149  * this charger current step-up/down here.
1150  * Returns error code in case of failure else 0(on success)
1151  */
1152 static int ab8500_charger_set_current(struct ab8500_charger *di,
1153         int ich_ua, int reg)
1154 {
1155         int ret = 0;
1156         int curr_index, prev_curr_index, shift_value, i;
1157         u8 reg_value;
1158         u32 step_udelay;
1159         bool no_stepping = false;
1160
1161         atomic_inc(&di->current_stepping_sessions);
1162
1163         ret = abx500_get_register_interruptible(di->dev, AB8500_CHARGER,
1164                 reg, &reg_value);
1165         if (ret < 0) {
1166                 dev_err(di->dev, "%s read failed\n", __func__);
1167                 goto exit_set_current;
1168         }
1169
1170         switch (reg) {
1171         case AB8500_MCH_IPT_CURLVL_REG:
1172                 shift_value = MAIN_CH_INPUT_CURR_SHIFT;
1173                 prev_curr_index = (reg_value >> shift_value);
1174                 curr_index = ab8500_current_to_regval(di, ich_ua);
1175                 step_udelay = STEP_UDELAY;
1176                 if (!di->ac.charger_connected)
1177                         no_stepping = true;
1178                 break;
1179         case AB8500_USBCH_IPT_CRNTLVL_REG:
1180                 shift_value = VBUS_IN_CURR_LIM_SHIFT;
1181                 prev_curr_index = (reg_value >> shift_value);
1182                 curr_index = ab8500_vbus_in_curr_to_regval(di, ich_ua);
1183                 step_udelay = STEP_UDELAY * 100;
1184
1185                 if (!di->usb.charger_connected)
1186                         no_stepping = true;
1187                 break;
1188         case AB8500_CH_OPT_CRNTLVL_REG:
1189                 shift_value = 0;
1190                 prev_curr_index = (reg_value >> shift_value);
1191                 curr_index = ab8500_current_to_regval(di, ich_ua);
1192                 step_udelay = STEP_UDELAY;
1193                 if (curr_index && (curr_index - prev_curr_index) > 1)
1194                         step_udelay *= 100;
1195
1196                 if (!di->usb.charger_connected && !di->ac.charger_connected)
1197                         no_stepping = true;
1198
1199                 break;
1200         default:
1201                 dev_err(di->dev, "%s current register not valid\n", __func__);
1202                 ret = -ENXIO;
1203                 goto exit_set_current;
1204         }
1205
1206         if (curr_index < 0) {
1207                 dev_err(di->dev, "requested current limit out-of-range\n");
1208                 ret = -ENXIO;
1209                 goto exit_set_current;
1210         }
1211
1212         /* only update current if it's been changed */
1213         if (prev_curr_index == curr_index) {
1214                 dev_dbg(di->dev, "%s current not changed for reg: 0x%02x\n",
1215                         __func__, reg);
1216                 ret = 0;
1217                 goto exit_set_current;
1218         }
1219
1220         dev_dbg(di->dev, "%s set charger current: %d uA for reg: 0x%02x\n",
1221                 __func__, ich_ua, reg);
1222
1223         if (no_stepping) {
1224                 ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
1225                                         reg, (u8)curr_index << shift_value);
1226                 if (ret)
1227                         dev_err(di->dev, "%s write failed\n", __func__);
1228         } else if (prev_curr_index > curr_index) {
1229                 for (i = prev_curr_index - 1; i >= curr_index; i--) {
1230                         dev_dbg(di->dev, "curr change_1 to: %x for 0x%02x\n",
1231                                 (u8) i << shift_value, reg);
1232                         ret = abx500_set_register_interruptible(di->dev,
1233                                 AB8500_CHARGER, reg, (u8)i << shift_value);
1234                         if (ret) {
1235                                 dev_err(di->dev, "%s write failed\n", __func__);
1236                                 goto exit_set_current;
1237                         }
1238                         if (i != curr_index)
1239                                 usleep_range(step_udelay, step_udelay * 2);
1240                 }
1241         } else {
1242                 bool allow = true;
1243                 for (i = prev_curr_index + 1; i <= curr_index && allow; i++) {
1244                         dev_dbg(di->dev, "curr change_2 to: %x for 0x%02x\n",
1245                                 (u8)i << shift_value, reg);
1246                         ret = abx500_set_register_interruptible(di->dev,
1247                                 AB8500_CHARGER, reg, (u8)i << shift_value);
1248                         if (ret) {
1249                                 dev_err(di->dev, "%s write failed\n", __func__);
1250                                 goto exit_set_current;
1251                         }
1252                         if (i != curr_index)
1253                                 usleep_range(step_udelay, step_udelay * 2);
1254
1255                         allow = ab8500_charger_check_continue_stepping(di, reg);
1256                 }
1257         }
1258
1259 exit_set_current:
1260         atomic_dec(&di->current_stepping_sessions);
1261
1262         return ret;
1263 }
1264
1265 /**
1266  * ab8500_charger_set_vbus_in_curr() - set VBUS input current limit
1267  * @di:         pointer to the ab8500_charger structure
1268  * @ich_in_ua:  charger input current limit in microampere
1269  *
1270  * Sets the current that can be drawn from the USB host
1271  * Returns error code in case of failure else 0(on success)
1272  */
1273 static int ab8500_charger_set_vbus_in_curr(struct ab8500_charger *di,
1274                 int ich_in_ua)
1275 {
1276         int min_value;
1277         int ret;
1278
1279         /* We should always use to lowest current limit */
1280         min_value = min(di->bm->chg_params->usb_curr_max_ua, ich_in_ua);
1281         if (di->max_usb_in_curr.set_max_ua > 0)
1282                 min_value = min(di->max_usb_in_curr.set_max_ua, min_value);
1283
1284         if (di->usb_state.usb_current_ua >= 0)
1285                 min_value = min(di->usb_state.usb_current_ua, min_value);
1286
1287         switch (min_value) {
1288         case 100000:
1289                 if (di->vbat < VBAT_TRESH_IP_CUR_RED)
1290                         min_value = USB_CH_IP_CUR_LVL_0P05;
1291                 break;
1292         case 500000:
1293                 if (di->vbat < VBAT_TRESH_IP_CUR_RED)
1294                         min_value = USB_CH_IP_CUR_LVL_0P45;
1295                 break;
1296         default:
1297                 break;
1298         }
1299
1300         dev_info(di->dev, "VBUS input current limit set to %d uA\n", min_value);
1301
1302         mutex_lock(&di->usb_ipt_crnt_lock);
1303         ret = ab8500_charger_set_current(di, min_value,
1304                 AB8500_USBCH_IPT_CRNTLVL_REG);
1305         mutex_unlock(&di->usb_ipt_crnt_lock);
1306
1307         return ret;
1308 }
1309
1310 /**
1311  * ab8500_charger_set_main_in_curr() - set main charger input current
1312  * @di:         pointer to the ab8500_charger structure
1313  * @ich_in_ua:  input charger current, in uA
1314  *
1315  * Set main charger input current.
1316  * Returns error code in case of failure else 0(on success)
1317  */
1318 static int ab8500_charger_set_main_in_curr(struct ab8500_charger *di,
1319         int ich_in_ua)
1320 {
1321         return ab8500_charger_set_current(di, ich_in_ua,
1322                 AB8500_MCH_IPT_CURLVL_REG);
1323 }
1324
1325 /**
1326  * ab8500_charger_set_output_curr() - set charger output current
1327  * @di:         pointer to the ab8500_charger structure
1328  * @ich_out_ua: output charger current, in uA
1329  *
1330  * Set charger output current.
1331  * Returns error code in case of failure else 0(on success)
1332  */
1333 static int ab8500_charger_set_output_curr(struct ab8500_charger *di,
1334         int ich_out_ua)
1335 {
1336         return ab8500_charger_set_current(di, ich_out_ua,
1337                 AB8500_CH_OPT_CRNTLVL_REG);
1338 }
1339
1340 /**
1341  * ab8500_charger_led_en() - turn on/off chargign led
1342  * @di:         pointer to the ab8500_charger structure
1343  * @on:         flag to turn on/off the chargign led
1344  *
1345  * Power ON/OFF charging LED indication
1346  * Returns error code in case of failure else 0(on success)
1347  */
1348 static int ab8500_charger_led_en(struct ab8500_charger *di, int on)
1349 {
1350         int ret;
1351
1352         if (on) {
1353                 /* Power ON charging LED indicator, set LED current to 5mA */
1354                 ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
1355                         AB8500_LED_INDICATOR_PWM_CTRL,
1356                         (LED_IND_CUR_5MA | LED_INDICATOR_PWM_ENA));
1357                 if (ret) {
1358                         dev_err(di->dev, "Power ON LED failed\n");
1359                         return ret;
1360                 }
1361                 /* LED indicator PWM duty cycle 252/256 */
1362                 ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
1363                         AB8500_LED_INDICATOR_PWM_DUTY,
1364                         LED_INDICATOR_PWM_DUTY_252_256);
1365                 if (ret) {
1366                         dev_err(di->dev, "Set LED PWM duty cycle failed\n");
1367                         return ret;
1368                 }
1369         } else {
1370                 /* Power off charging LED indicator */
1371                 ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
1372                         AB8500_LED_INDICATOR_PWM_CTRL,
1373                         LED_INDICATOR_PWM_DIS);
1374                 if (ret) {
1375                         dev_err(di->dev, "Power-off LED failed\n");
1376                         return ret;
1377                 }
1378         }
1379
1380         return ret;
1381 }
1382
1383 /**
1384  * ab8500_charger_ac_en() - enable or disable ac charging
1385  * @di:         pointer to the ab8500_charger structure
1386  * @enable:     enable/disable flag
1387  * @vset_uv:    charging voltage in microvolt
1388  * @iset_ua:    charging current in microampere
1389  *
1390  * Enable/Disable AC/Mains charging and turns on/off the charging led
1391  * respectively.
1392  **/
1393 static int ab8500_charger_ac_en(struct ux500_charger *charger,
1394         int enable, int vset_uv, int iset_ua)
1395 {
1396         int ret;
1397         int volt_index;
1398         int curr_index;
1399         int input_curr_index;
1400         u8 overshoot = 0;
1401
1402         struct ab8500_charger *di = to_ab8500_charger_ac_device_info(charger);
1403
1404         if (enable) {
1405                 /* Check if AC is connected */
1406                 if (!di->ac.charger_connected) {
1407                         dev_err(di->dev, "AC charger not connected\n");
1408                         return -ENXIO;
1409                 }
1410
1411                 /* Enable AC charging */
1412                 dev_dbg(di->dev, "Enable AC: %duV %duA\n", vset_uv, iset_ua);
1413
1414                 /*
1415                  * Due to a bug in AB8500, BTEMP_HIGH/LOW interrupts
1416                  * will be triggered every time we enable the VDD ADC supply.
1417                  * This will turn off charging for a short while.
1418                  * It can be avoided by having the supply on when
1419                  * there is a charger enabled. Normally the VDD ADC supply
1420                  * is enabled every time a GPADC conversion is triggered.
1421                  * We will force it to be enabled from this driver to have
1422                  * the GPADC module independent of the AB8500 chargers
1423                  */
1424                 if (!di->vddadc_en_ac) {
1425                         ret = regulator_enable(di->regu);
1426                         if (ret)
1427                                 dev_warn(di->dev,
1428                                         "Failed to enable regulator\n");
1429                         else
1430                                 di->vddadc_en_ac = true;
1431                 }
1432
1433                 /* Check if the requested voltage or current is valid */
1434                 volt_index = ab8500_voltage_to_regval(vset_uv);
1435                 curr_index = ab8500_current_to_regval(di, iset_ua);
1436                 input_curr_index = ab8500_current_to_regval(di,
1437                         di->bm->chg_params->ac_curr_max_ua);
1438                 if (volt_index < 0 || curr_index < 0 || input_curr_index < 0) {
1439                         dev_err(di->dev,
1440                                 "Charger voltage or current too high, "
1441                                 "charging not started\n");
1442                         return -ENXIO;
1443                 }
1444
1445                 /* ChVoltLevel: maximum battery charging voltage */
1446                 ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
1447                         AB8500_CH_VOLT_LVL_REG, (u8) volt_index);
1448                 if (ret) {
1449                         dev_err(di->dev, "%s write failed\n", __func__);
1450                         return ret;
1451                 }
1452                 /* MainChInputCurr: current that can be drawn from the charger*/
1453                 ret = ab8500_charger_set_main_in_curr(di,
1454                         di->bm->chg_params->ac_curr_max_ua);
1455                 if (ret) {
1456                         dev_err(di->dev, "%s Failed to set MainChInputCurr\n",
1457                                 __func__);
1458                         return ret;
1459                 }
1460                 /* ChOutputCurentLevel: protected output current */
1461                 ret = ab8500_charger_set_output_curr(di, iset_ua);
1462                 if (ret) {
1463                         dev_err(di->dev, "%s "
1464                                 "Failed to set ChOutputCurentLevel\n",
1465                                 __func__);
1466                         return ret;
1467                 }
1468
1469                 /* Check if VBAT overshoot control should be enabled */
1470                 if (!di->bm->enable_overshoot)
1471                         overshoot = MAIN_CH_NO_OVERSHOOT_ENA_N;
1472
1473                 /* Enable Main Charger */
1474                 ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
1475                         AB8500_MCH_CTRL1, MAIN_CH_ENA | overshoot);
1476                 if (ret) {
1477                         dev_err(di->dev, "%s write failed\n", __func__);
1478                         return ret;
1479                 }
1480
1481                 /* Power on charging LED indication */
1482                 ret = ab8500_charger_led_en(di, true);
1483                 if (ret < 0)
1484                         dev_err(di->dev, "failed to enable LED\n");
1485
1486                 di->ac.charger_online = 1;
1487         } else {
1488                 /* Disable AC charging */
1489                 if (is_ab8500_1p1_or_earlier(di->parent)) {
1490                         /*
1491                          * For ABB revision 1.0 and 1.1 there is a bug in the
1492                          * watchdog logic. That means we have to continuously
1493                          * kick the charger watchdog even when no charger is
1494                          * connected. This is only valid once the AC charger
1495                          * has been enabled. This is a bug that is not handled
1496                          * by the algorithm and the watchdog have to be kicked
1497                          * by the charger driver when the AC charger
1498                          * is disabled
1499                          */
1500                         if (di->ac_conn) {
1501                                 queue_delayed_work(di->charger_wq,
1502                                         &di->kick_wd_work,
1503                                         round_jiffies(WD_KICK_INTERVAL));
1504                         }
1505
1506                         /*
1507                          * We can't turn off charging completely
1508                          * due to a bug in AB8500 cut1.
1509                          * If we do, charging will not start again.
1510                          * That is why we set the lowest voltage
1511                          * and current possible
1512                          */
1513                         ret = abx500_set_register_interruptible(di->dev,
1514                                 AB8500_CHARGER,
1515                                 AB8500_CH_VOLT_LVL_REG, CH_VOL_LVL_3P5);
1516                         if (ret) {
1517                                 dev_err(di->dev,
1518                                         "%s write failed\n", __func__);
1519                                 return ret;
1520                         }
1521
1522                         ret = ab8500_charger_set_output_curr(di, 0);
1523                         if (ret) {
1524                                 dev_err(di->dev, "%s "
1525                                         "Failed to set ChOutputCurentLevel\n",
1526                                         __func__);
1527                                 return ret;
1528                         }
1529                 } else {
1530                         ret = abx500_set_register_interruptible(di->dev,
1531                                 AB8500_CHARGER,
1532                                 AB8500_MCH_CTRL1, 0);
1533                         if (ret) {
1534                                 dev_err(di->dev,
1535                                         "%s write failed\n", __func__);
1536                                 return ret;
1537                         }
1538                 }
1539
1540                 ret = ab8500_charger_led_en(di, false);
1541                 if (ret < 0)
1542                         dev_err(di->dev, "failed to disable LED\n");
1543
1544                 di->ac.charger_online = 0;
1545                 di->ac.wd_expired = false;
1546
1547                 /* Disable regulator if enabled */
1548                 if (di->vddadc_en_ac) {
1549                         regulator_disable(di->regu);
1550                         di->vddadc_en_ac = false;
1551                 }
1552
1553                 dev_dbg(di->dev, "%s Disabled AC charging\n", __func__);
1554         }
1555         ab8500_power_supply_changed(di, di->ac_chg.psy);
1556
1557         return ret;
1558 }
1559
1560 /**
1561  * ab8500_charger_usb_en() - enable usb charging
1562  * @di:         pointer to the ab8500_charger structure
1563  * @enable:     enable/disable flag
1564  * @vset_uv:    charging voltage in microvolt
1565  * @ich_out_ua: charger output current in microampere
1566  *
1567  * Enable/Disable USB charging and turns on/off the charging led respectively.
1568  * Returns error code in case of failure else 0(on success)
1569  */
1570 static int ab8500_charger_usb_en(struct ux500_charger *charger,
1571         int enable, int vset_uv, int ich_out_ua)
1572 {
1573         int ret;
1574         int volt_index;
1575         int curr_index;
1576         u8 overshoot = 0;
1577
1578         struct ab8500_charger *di = to_ab8500_charger_usb_device_info(charger);
1579
1580         if (enable) {
1581                 /* Check if USB is connected */
1582                 if (!di->usb.charger_connected) {
1583                         dev_err(di->dev, "USB charger not connected\n");
1584                         return -ENXIO;
1585                 }
1586
1587                 /*
1588                  * Due to a bug in AB8500, BTEMP_HIGH/LOW interrupts
1589                  * will be triggered every time we enable the VDD ADC supply.
1590                  * This will turn off charging for a short while.
1591                  * It can be avoided by having the supply on when
1592                  * there is a charger enabled. Normally the VDD ADC supply
1593                  * is enabled every time a GPADC conversion is triggered.
1594                  * We will force it to be enabled from this driver to have
1595                  * the GPADC module independent of the AB8500 chargers
1596                  */
1597                 if (!di->vddadc_en_usb) {
1598                         ret = regulator_enable(di->regu);
1599                         if (ret)
1600                                 dev_warn(di->dev,
1601                                         "Failed to enable regulator\n");
1602                         else
1603                                 di->vddadc_en_usb = true;
1604                 }
1605
1606                 /* Enable USB charging */
1607                 dev_dbg(di->dev, "Enable USB: %d uV %d uA\n", vset_uv, ich_out_ua);
1608
1609                 /* Check if the requested voltage or current is valid */
1610                 volt_index = ab8500_voltage_to_regval(vset_uv);
1611                 curr_index = ab8500_current_to_regval(di, ich_out_ua);
1612                 if (volt_index < 0 || curr_index < 0) {
1613                         dev_err(di->dev,
1614                                 "Charger voltage or current too high, "
1615                                 "charging not started\n");
1616                         return -ENXIO;
1617                 }
1618
1619                 /*
1620                  * ChVoltLevel: max voltage up to which battery can be
1621                  * charged
1622                  */
1623                 ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
1624                         AB8500_CH_VOLT_LVL_REG, (u8) volt_index);
1625                 if (ret) {
1626                         dev_err(di->dev, "%s write failed\n", __func__);
1627                         return ret;
1628                 }
1629                 /* Check if VBAT overshoot control should be enabled */
1630                 if (!di->bm->enable_overshoot)
1631                         overshoot = USB_CHG_NO_OVERSHOOT_ENA_N;
1632
1633                 /* Enable USB Charger */
1634                 dev_dbg(di->dev,
1635                         "Enabling USB with write to AB8500_USBCH_CTRL1_REG\n");
1636                 ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
1637                         AB8500_USBCH_CTRL1_REG, USB_CH_ENA | overshoot);
1638                 if (ret) {
1639                         dev_err(di->dev, "%s write failed\n", __func__);
1640                         return ret;
1641                 }
1642
1643                 /* If success power on charging LED indication */
1644                 ret = ab8500_charger_led_en(di, true);
1645                 if (ret < 0)
1646                         dev_err(di->dev, "failed to enable LED\n");
1647
1648                 di->usb.charger_online = 1;
1649
1650                 /* USBChInputCurr: current that can be drawn from the usb */
1651                 ret = ab8500_charger_set_vbus_in_curr(di,
1652                                         di->max_usb_in_curr.usb_type_max_ua);
1653                 if (ret) {
1654                         dev_err(di->dev, "setting USBChInputCurr failed\n");
1655                         return ret;
1656                 }
1657
1658                 /* ChOutputCurentLevel: protected output current */
1659                 ret = ab8500_charger_set_output_curr(di, ich_out_ua);
1660                 if (ret) {
1661                         dev_err(di->dev, "%s "
1662                                 "Failed to set ChOutputCurentLevel\n",
1663                                 __func__);
1664                         return ret;
1665                 }
1666
1667                 queue_delayed_work(di->charger_wq, &di->check_vbat_work, HZ);
1668
1669         } else {
1670                 /* Disable USB charging */
1671                 dev_dbg(di->dev, "%s Disabled USB charging\n", __func__);
1672                 ret = abx500_set_register_interruptible(di->dev,
1673                         AB8500_CHARGER,
1674                         AB8500_USBCH_CTRL1_REG, 0);
1675                 if (ret) {
1676                         dev_err(di->dev,
1677                                 "%s write failed\n", __func__);
1678                         return ret;
1679                 }
1680
1681                 ret = ab8500_charger_led_en(di, false);
1682                 if (ret < 0)
1683                         dev_err(di->dev, "failed to disable LED\n");
1684                 /* USBChInputCurr: current that can be drawn from the usb */
1685                 ret = ab8500_charger_set_vbus_in_curr(di, 0);
1686                 if (ret) {
1687                         dev_err(di->dev, "setting USBChInputCurr failed\n");
1688                         return ret;
1689                 }
1690
1691                 /* ChOutputCurentLevel: protected output current */
1692                 ret = ab8500_charger_set_output_curr(di, 0);
1693                 if (ret) {
1694                         dev_err(di->dev, "%s "
1695                                 "Failed to reset ChOutputCurentLevel\n",
1696                                 __func__);
1697                         return ret;
1698                 }
1699                 di->usb.charger_online = 0;
1700                 di->usb.wd_expired = false;
1701
1702                 /* Disable regulator if enabled */
1703                 if (di->vddadc_en_usb) {
1704                         regulator_disable(di->regu);
1705                         di->vddadc_en_usb = false;
1706                 }
1707
1708                 dev_dbg(di->dev, "%s Disabled USB charging\n", __func__);
1709
1710                 /* Cancel any pending Vbat check work */
1711                 cancel_delayed_work(&di->check_vbat_work);
1712
1713         }
1714         ab8500_power_supply_changed(di, di->usb_chg.psy);
1715
1716         return ret;
1717 }
1718
1719 static int ab8500_external_charger_prepare(struct notifier_block *charger_nb,
1720                                 unsigned long event, void *data)
1721 {
1722         int ret;
1723         struct device *dev = data;
1724         /*Toggle External charger control pin*/
1725         ret = abx500_set_register_interruptible(dev, AB8500_SYS_CTRL1_BLOCK,
1726                                   AB8500_SYS_CHARGER_CONTROL_REG,
1727                                   EXTERNAL_CHARGER_DISABLE_REG_VAL);
1728         if (ret < 0) {
1729                 dev_err(dev, "write reg failed %d\n", ret);
1730                 goto out;
1731         }
1732         ret = abx500_set_register_interruptible(dev, AB8500_SYS_CTRL1_BLOCK,
1733                                   AB8500_SYS_CHARGER_CONTROL_REG,
1734                                   EXTERNAL_CHARGER_ENABLE_REG_VAL);
1735         if (ret < 0)
1736                 dev_err(dev, "Write reg failed %d\n", ret);
1737
1738 out:
1739         return ret;
1740 }
1741
1742 /**
1743  * ab8500_charger_usb_check_enable() - enable usb charging
1744  * @charger:    pointer to the ux500_charger structure
1745  * @vset_uv:    charging voltage in microvolt
1746  * @iset_ua:    charger output current in microampere
1747  *
1748  * Check if the VBUS charger has been disconnected and reconnected without
1749  * AB8500 rising an interrupt. Returns 0 on success.
1750  */
1751 static int ab8500_charger_usb_check_enable(struct ux500_charger *charger,
1752         int vset_uv, int iset_ua)
1753 {
1754         u8 usbch_ctrl1 = 0;
1755         int ret = 0;
1756
1757         struct ab8500_charger *di = to_ab8500_charger_usb_device_info(charger);
1758
1759         if (!di->usb.charger_connected)
1760                 return ret;
1761
1762         ret = abx500_get_register_interruptible(di->dev, AB8500_CHARGER,
1763                                 AB8500_USBCH_CTRL1_REG, &usbch_ctrl1);
1764         if (ret < 0) {
1765                 dev_err(di->dev, "ab8500 read failed %d\n", __LINE__);
1766                 return ret;
1767         }
1768         dev_dbg(di->dev, "USB charger ctrl: 0x%02x\n", usbch_ctrl1);
1769
1770         if (!(usbch_ctrl1 & USB_CH_ENA)) {
1771                 dev_info(di->dev, "Charging has been disabled abnormally and will be re-enabled\n");
1772
1773                 ret = abx500_mask_and_set_register_interruptible(di->dev,
1774                                         AB8500_CHARGER, AB8500_CHARGER_CTRL,
1775                                         DROP_COUNT_RESET, DROP_COUNT_RESET);
1776                 if (ret < 0) {
1777                         dev_err(di->dev, "ab8500 write failed %d\n", __LINE__);
1778                         return ret;
1779                 }
1780
1781                 ret = ab8500_charger_usb_en(&di->usb_chg, true, vset_uv, iset_ua);
1782                 if (ret < 0) {
1783                         dev_err(di->dev, "Failed to enable VBUS charger %d\n",
1784                                         __LINE__);
1785                         return ret;
1786                 }
1787         }
1788         return ret;
1789 }
1790
1791 /**
1792  * ab8500_charger_ac_check_enable() - enable usb charging
1793  * @charger:    pointer to the ux500_charger structure
1794  * @vset_uv:    charging voltage in microvolt
1795  * @iset_ua:    charger output current in micrompere
1796  *
1797  * Check if the AC charger has been disconnected and reconnected without
1798  * AB8500 rising an interrupt. Returns 0 on success.
1799  */
1800 static int ab8500_charger_ac_check_enable(struct ux500_charger *charger,
1801         int vset_uv, int iset_ua)
1802 {
1803         u8 mainch_ctrl1 = 0;
1804         int ret = 0;
1805
1806         struct ab8500_charger *di = to_ab8500_charger_ac_device_info(charger);
1807
1808         if (!di->ac.charger_connected)
1809                 return ret;
1810
1811         ret = abx500_get_register_interruptible(di->dev, AB8500_CHARGER,
1812                                 AB8500_MCH_CTRL1, &mainch_ctrl1);
1813         if (ret < 0) {
1814                 dev_err(di->dev, "ab8500 read failed %d\n", __LINE__);
1815                 return ret;
1816         }
1817         dev_dbg(di->dev, "AC charger ctrl: 0x%02x\n", mainch_ctrl1);
1818
1819         if (!(mainch_ctrl1 & MAIN_CH_ENA)) {
1820                 dev_info(di->dev, "Charging has been disabled abnormally and will be re-enabled\n");
1821
1822                 ret = abx500_mask_and_set_register_interruptible(di->dev,
1823                                         AB8500_CHARGER, AB8500_CHARGER_CTRL,
1824                                         DROP_COUNT_RESET, DROP_COUNT_RESET);
1825
1826                 if (ret < 0) {
1827                         dev_err(di->dev, "ab8500 write failed %d\n", __LINE__);
1828                         return ret;
1829                 }
1830
1831                 ret = ab8500_charger_ac_en(&di->usb_chg, true, vset_uv, iset_ua);
1832                 if (ret < 0) {
1833                         dev_err(di->dev, "failed to enable AC charger %d\n",
1834                                 __LINE__);
1835                         return ret;
1836                 }
1837         }
1838         return ret;
1839 }
1840
1841 /**
1842  * ab8500_charger_watchdog_kick() - kick charger watchdog
1843  * @di:         pointer to the ab8500_charger structure
1844  *
1845  * Kick charger watchdog
1846  * Returns error code in case of failure else 0(on success)
1847  */
1848 static int ab8500_charger_watchdog_kick(struct ux500_charger *charger)
1849 {
1850         int ret;
1851         struct ab8500_charger *di;
1852
1853         if (charger->psy->desc->type == POWER_SUPPLY_TYPE_MAINS)
1854                 di = to_ab8500_charger_ac_device_info(charger);
1855         else if (charger->psy->desc->type == POWER_SUPPLY_TYPE_USB)
1856                 di = to_ab8500_charger_usb_device_info(charger);
1857         else
1858                 return -ENXIO;
1859
1860         ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
1861                 AB8500_CHARG_WD_CTRL, CHARG_WD_KICK);
1862         if (ret)
1863                 dev_err(di->dev, "Failed to kick WD!\n");
1864
1865         return ret;
1866 }
1867
1868 /**
1869  * ab8500_charger_update_charger_current() - update charger current
1870  * @charger:            pointer to the ab8500_charger structure
1871  * @ich_out_ua:         desired output current in microampere
1872  *
1873  * Update the charger output current for the specified charger
1874  * Returns error code in case of failure else 0(on success)
1875  */
1876 static int ab8500_charger_update_charger_current(struct ux500_charger *charger,
1877                 int ich_out_ua)
1878 {
1879         int ret;
1880         struct ab8500_charger *di;
1881
1882         if (charger->psy->desc->type == POWER_SUPPLY_TYPE_MAINS)
1883                 di = to_ab8500_charger_ac_device_info(charger);
1884         else if (charger->psy->desc->type == POWER_SUPPLY_TYPE_USB)
1885                 di = to_ab8500_charger_usb_device_info(charger);
1886         else
1887                 return -ENXIO;
1888
1889         ret = ab8500_charger_set_output_curr(di, ich_out_ua);
1890         if (ret) {
1891                 dev_err(di->dev, "%s "
1892                         "Failed to set ChOutputCurentLevel\n",
1893                         __func__);
1894                 return ret;
1895         }
1896
1897         /* Reset the main and usb drop input current measurement counter */
1898         ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
1899                                 AB8500_CHARGER_CTRL, DROP_COUNT_RESET);
1900         if (ret) {
1901                 dev_err(di->dev, "%s write failed\n", __func__);
1902                 return ret;
1903         }
1904
1905         return ret;
1906 }
1907
1908 static int ab8500_charger_get_ext_psy_data(struct device *dev, void *data)
1909 {
1910         struct power_supply *psy;
1911         struct power_supply *ext = dev_get_drvdata(dev);
1912         const char **supplicants = (const char **)ext->supplied_to;
1913         struct ab8500_charger *di;
1914         union power_supply_propval ret;
1915         int j;
1916         struct ux500_charger *usb_chg;
1917
1918         usb_chg = (struct ux500_charger *)data;
1919         psy = usb_chg->psy;
1920
1921         di = to_ab8500_charger_usb_device_info(usb_chg);
1922
1923         /* For all psy where the driver name appears in any supplied_to */
1924         j = match_string(supplicants, ext->num_supplicants, psy->desc->name);
1925         if (j < 0)
1926                 return 0;
1927
1928         /* Go through all properties for the psy */
1929         for (j = 0; j < ext->desc->num_properties; j++) {
1930                 enum power_supply_property prop;
1931                 prop = ext->desc->properties[j];
1932
1933                 if (power_supply_get_property(ext, prop, &ret))
1934                         continue;
1935
1936                 switch (prop) {
1937                 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
1938                         switch (ext->desc->type) {
1939                         case POWER_SUPPLY_TYPE_BATTERY:
1940                                 di->vbat = ret.intval / 1000;
1941                                 break;
1942                         default:
1943                                 break;
1944                         }
1945                         break;
1946                 default:
1947                         break;
1948                 }
1949         }
1950         return 0;
1951 }
1952
1953 /**
1954  * ab8500_charger_check_vbat_work() - keep vbus current within spec
1955  * @work        pointer to the work_struct structure
1956  *
1957  * Due to a asic bug it is necessary to lower the input current to the vbus
1958  * charger when charging with at some specific levels. This issue is only valid
1959  * for below a certain battery voltage. This function makes sure that the
1960  * the allowed current limit isn't exceeded.
1961  */
1962 static void ab8500_charger_check_vbat_work(struct work_struct *work)
1963 {
1964         int t = 10;
1965         struct ab8500_charger *di = container_of(work,
1966                 struct ab8500_charger, check_vbat_work.work);
1967
1968         class_for_each_device(power_supply_class, NULL,
1969                 di->usb_chg.psy, ab8500_charger_get_ext_psy_data);
1970
1971         /* First run old_vbat is 0. */
1972         if (di->old_vbat == 0)
1973                 di->old_vbat = di->vbat;
1974
1975         if (!((di->old_vbat <= VBAT_TRESH_IP_CUR_RED &&
1976                 di->vbat <= VBAT_TRESH_IP_CUR_RED) ||
1977                 (di->old_vbat > VBAT_TRESH_IP_CUR_RED &&
1978                 di->vbat > VBAT_TRESH_IP_CUR_RED))) {
1979
1980                 dev_dbg(di->dev, "Vbat did cross threshold, curr: %d, new: %d,"
1981                         " old: %d\n", di->max_usb_in_curr.usb_type_max_ua,
1982                         di->vbat, di->old_vbat);
1983                 ab8500_charger_set_vbus_in_curr(di,
1984                                         di->max_usb_in_curr.usb_type_max_ua);
1985                 power_supply_changed(di->usb_chg.psy);
1986         }
1987
1988         di->old_vbat = di->vbat;
1989
1990         /*
1991          * No need to check the battery voltage every second when not close to
1992          * the threshold.
1993          */
1994         if (di->vbat < (VBAT_TRESH_IP_CUR_RED + 100) &&
1995                 (di->vbat > (VBAT_TRESH_IP_CUR_RED - 100)))
1996                         t = 1;
1997
1998         queue_delayed_work(di->charger_wq, &di->check_vbat_work, t * HZ);
1999 }
2000
2001 /**
2002  * ab8500_charger_check_hw_failure_work() - check main charger failure
2003  * @work:       pointer to the work_struct structure
2004  *
2005  * Work queue function for checking the main charger status
2006  */
2007 static void ab8500_charger_check_hw_failure_work(struct work_struct *work)
2008 {
2009         int ret;
2010         u8 reg_value;
2011
2012         struct ab8500_charger *di = container_of(work,
2013                 struct ab8500_charger, check_hw_failure_work.work);
2014
2015         /* Check if the status bits for HW failure is still active */
2016         if (di->flags.mainextchnotok) {
2017                 ret = abx500_get_register_interruptible(di->dev,
2018                         AB8500_CHARGER, AB8500_CH_STATUS2_REG, &reg_value);
2019                 if (ret < 0) {
2020                         dev_err(di->dev, "%s ab8500 read failed\n", __func__);
2021                         return;
2022                 }
2023                 if (!(reg_value & MAIN_CH_NOK)) {
2024                         di->flags.mainextchnotok = false;
2025                         ab8500_power_supply_changed(di, di->ac_chg.psy);
2026                 }
2027         }
2028         if (di->flags.vbus_ovv) {
2029                 ret = abx500_get_register_interruptible(di->dev,
2030                         AB8500_CHARGER, AB8500_CH_USBCH_STAT2_REG,
2031                         &reg_value);
2032                 if (ret < 0) {
2033                         dev_err(di->dev, "%s ab8500 read failed\n", __func__);
2034                         return;
2035                 }
2036                 if (!(reg_value & VBUS_OVV_TH)) {
2037                         di->flags.vbus_ovv = false;
2038                         ab8500_power_supply_changed(di, di->usb_chg.psy);
2039                 }
2040         }
2041         /* If we still have a failure, schedule a new check */
2042         if (di->flags.mainextchnotok || di->flags.vbus_ovv) {
2043                 queue_delayed_work(di->charger_wq,
2044                         &di->check_hw_failure_work, round_jiffies(HZ));
2045         }
2046 }
2047
2048 /**
2049  * ab8500_charger_kick_watchdog_work() - kick the watchdog
2050  * @work:       pointer to the work_struct structure
2051  *
2052  * Work queue function for kicking the charger watchdog.
2053  *
2054  * For ABB revision 1.0 and 1.1 there is a bug in the watchdog
2055  * logic. That means we have to continuously kick the charger
2056  * watchdog even when no charger is connected. This is only
2057  * valid once the AC charger has been enabled. This is
2058  * a bug that is not handled by the algorithm and the
2059  * watchdog have to be kicked by the charger driver
2060  * when the AC charger is disabled
2061  */
2062 static void ab8500_charger_kick_watchdog_work(struct work_struct *work)
2063 {
2064         int ret;
2065
2066         struct ab8500_charger *di = container_of(work,
2067                 struct ab8500_charger, kick_wd_work.work);
2068
2069         ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
2070                 AB8500_CHARG_WD_CTRL, CHARG_WD_KICK);
2071         if (ret)
2072                 dev_err(di->dev, "Failed to kick WD!\n");
2073
2074         /* Schedule a new watchdog kick */
2075         queue_delayed_work(di->charger_wq,
2076                 &di->kick_wd_work, round_jiffies(WD_KICK_INTERVAL));
2077 }
2078
2079 /**
2080  * ab8500_charger_ac_work() - work to get and set main charger status
2081  * @work:       pointer to the work_struct structure
2082  *
2083  * Work queue function for checking the main charger status
2084  */
2085 static void ab8500_charger_ac_work(struct work_struct *work)
2086 {
2087         int ret;
2088
2089         struct ab8500_charger *di = container_of(work,
2090                 struct ab8500_charger, ac_work);
2091
2092         /*
2093          * Since we can't be sure that the events are received
2094          * synchronously, we have the check if the main charger is
2095          * connected by reading the status register
2096          */
2097         ret = ab8500_charger_detect_chargers(di, false);
2098         if (ret < 0)
2099                 return;
2100
2101         if (ret & AC_PW_CONN) {
2102                 di->ac.charger_connected = 1;
2103                 di->ac_conn = true;
2104         } else {
2105                 di->ac.charger_connected = 0;
2106         }
2107
2108         ab8500_power_supply_changed(di, di->ac_chg.psy);
2109         sysfs_notify(&di->ac_chg.psy->dev.kobj, NULL, "present");
2110 }
2111
2112 static void ab8500_charger_usb_attached_work(struct work_struct *work)
2113 {
2114         struct ab8500_charger *di = container_of(work,
2115                                                  struct ab8500_charger,
2116                                                  usb_charger_attached_work.work);
2117         int usbch = (USB_CH_VBUSDROP | USB_CH_VBUSDETDBNC);
2118         int ret, i;
2119         u8 statval;
2120
2121         for (i = 0; i < 10; i++) {
2122                 ret = abx500_get_register_interruptible(di->dev,
2123                                                         AB8500_CHARGER,
2124                                                         AB8500_CH_USBCH_STAT1_REG,
2125                                                         &statval);
2126                 if (ret < 0) {
2127                         dev_err(di->dev, "ab8500 read failed %d\n", __LINE__);
2128                         goto reschedule;
2129                 }
2130                 if ((statval & usbch) != usbch)
2131                         goto reschedule;
2132
2133                 msleep(CHARGER_STATUS_POLL);
2134         }
2135
2136         ab8500_charger_usb_en(&di->usb_chg, 0, 0, 0);
2137
2138         mutex_lock(&di->charger_attached_mutex);
2139         mutex_unlock(&di->charger_attached_mutex);
2140
2141         return;
2142
2143 reschedule:
2144         queue_delayed_work(di->charger_wq,
2145                            &di->usb_charger_attached_work,
2146                            HZ);
2147 }
2148
2149 static void ab8500_charger_ac_attached_work(struct work_struct *work)
2150 {
2151
2152         struct ab8500_charger *di = container_of(work,
2153                                                  struct ab8500_charger,
2154                                                  ac_charger_attached_work.work);
2155         int mainch = (MAIN_CH_STATUS2_MAINCHGDROP |
2156                       MAIN_CH_STATUS2_MAINCHARGERDETDBNC);
2157         int ret, i;
2158         u8 statval;
2159
2160         for (i = 0; i < 10; i++) {
2161                 ret = abx500_get_register_interruptible(di->dev,
2162                                                         AB8500_CHARGER,
2163                                                         AB8500_CH_STATUS2_REG,
2164                                                         &statval);
2165                 if (ret < 0) {
2166                         dev_err(di->dev, "ab8500 read failed %d\n", __LINE__);
2167                         goto reschedule;
2168                 }
2169
2170                 if ((statval & mainch) != mainch)
2171                         goto reschedule;
2172
2173                 msleep(CHARGER_STATUS_POLL);
2174         }
2175
2176         ab8500_charger_ac_en(&di->ac_chg, 0, 0, 0);
2177         queue_work(di->charger_wq, &di->ac_work);
2178
2179         mutex_lock(&di->charger_attached_mutex);
2180         mutex_unlock(&di->charger_attached_mutex);
2181
2182         return;
2183
2184 reschedule:
2185         queue_delayed_work(di->charger_wq,
2186                            &di->ac_charger_attached_work,
2187                            HZ);
2188 }
2189
2190 /**
2191  * ab8500_charger_detect_usb_type_work() - work to detect USB type
2192  * @work:       Pointer to the work_struct structure
2193  *
2194  * Detect the type of USB plugged
2195  */
2196 static void ab8500_charger_detect_usb_type_work(struct work_struct *work)
2197 {
2198         int ret;
2199
2200         struct ab8500_charger *di = container_of(work,
2201                 struct ab8500_charger, detect_usb_type_work);
2202
2203         /*
2204          * Since we can't be sure that the events are received
2205          * synchronously, we have the check if is
2206          * connected by reading the status register
2207          */
2208         ret = ab8500_charger_detect_chargers(di, false);
2209         if (ret < 0)
2210                 return;
2211
2212         if (!(ret & USB_PW_CONN)) {
2213                 dev_dbg(di->dev, "%s di->vbus_detected = false\n", __func__);
2214                 di->vbus_detected = false;
2215                 ab8500_charger_set_usb_connected(di, false);
2216                 ab8500_power_supply_changed(di, di->usb_chg.psy);
2217         } else {
2218                 dev_dbg(di->dev, "%s di->vbus_detected = true\n", __func__);
2219                 di->vbus_detected = true;
2220
2221                 if (is_ab8500_1p1_or_earlier(di->parent)) {
2222                         ret = ab8500_charger_detect_usb_type(di);
2223                         if (!ret) {
2224                                 ab8500_charger_set_usb_connected(di, true);
2225                                 ab8500_power_supply_changed(di,
2226                                                             di->usb_chg.psy);
2227                         }
2228                 } else {
2229                         /*
2230                          * For ABB cut2.0 and onwards we have an IRQ,
2231                          * USB_LINK_STATUS that will be triggered when the USB
2232                          * link status changes. The exception is USB connected
2233                          * during startup. Then we don't get a
2234                          * USB_LINK_STATUS IRQ
2235                          */
2236                         if (di->vbus_detected_start) {
2237                                 di->vbus_detected_start = false;
2238                                 ret = ab8500_charger_detect_usb_type(di);
2239                                 if (!ret) {
2240                                         ab8500_charger_set_usb_connected(di,
2241                                                 true);
2242                                         ab8500_power_supply_changed(di,
2243                                                 di->usb_chg.psy);
2244                                 }
2245                         }
2246                 }
2247         }
2248 }
2249
2250 /**
2251  * ab8500_charger_usb_link_attach_work() - work to detect USB type
2252  * @work:       pointer to the work_struct structure
2253  *
2254  * Detect the type of USB plugged
2255  */
2256 static void ab8500_charger_usb_link_attach_work(struct work_struct *work)
2257 {
2258         struct ab8500_charger *di =
2259                 container_of(work, struct ab8500_charger, attach_work.work);
2260         int ret;
2261
2262         /* Update maximum input current if USB enumeration is not detected */
2263         if (!di->usb.charger_online) {
2264                 ret = ab8500_charger_set_vbus_in_curr(di,
2265                                         di->max_usb_in_curr.usb_type_max_ua);
2266                 if (ret)
2267                         return;
2268         }
2269
2270         ab8500_charger_set_usb_connected(di, true);
2271         ab8500_power_supply_changed(di, di->usb_chg.psy);
2272 }
2273
2274 /**
2275  * ab8500_charger_usb_link_status_work() - work to detect USB type
2276  * @work:       pointer to the work_struct structure
2277  *
2278  * Detect the type of USB plugged
2279  */
2280 static void ab8500_charger_usb_link_status_work(struct work_struct *work)
2281 {
2282         int detected_chargers;
2283         int ret;
2284         u8 val;
2285         u8 link_status;
2286
2287         struct ab8500_charger *di = container_of(work,
2288                 struct ab8500_charger, usb_link_status_work);
2289
2290         /*
2291          * Since we can't be sure that the events are received
2292          * synchronously, we have the check if  is
2293          * connected by reading the status register
2294          */
2295         detected_chargers = ab8500_charger_detect_chargers(di, false);
2296         if (detected_chargers < 0)
2297                 return;
2298
2299         /*
2300          * Some chargers that breaks the USB spec is
2301          * identified as invalid by AB8500 and it refuse
2302          * to start the charging process. but by jumping
2303          * through a few hoops it can be forced to start.
2304          */
2305         if (is_ab8500(di->parent))
2306                 ret = abx500_get_register_interruptible(di->dev, AB8500_USB,
2307                                         AB8500_USB_LINE_STAT_REG, &val);
2308         else
2309                 ret = abx500_get_register_interruptible(di->dev, AB8500_USB,
2310                                         AB8500_USB_LINK1_STAT_REG, &val);
2311
2312         if (ret >= 0)
2313                 dev_dbg(di->dev, "UsbLineStatus register = 0x%02x\n", val);
2314         else
2315                 dev_dbg(di->dev, "Error reading USB link status\n");
2316
2317         if (is_ab8500(di->parent))
2318                 link_status = AB8500_USB_LINK_STATUS;
2319         else
2320                 link_status = AB8505_USB_LINK_STATUS;
2321
2322         if (detected_chargers & USB_PW_CONN) {
2323                 if (((val & link_status) >> USB_LINK_STATUS_SHIFT) ==
2324                                 USB_STAT_NOT_VALID_LINK &&
2325                                 di->invalid_charger_detect_state == 0) {
2326                         dev_dbg(di->dev,
2327                                         "Invalid charger detected, state= 0\n");
2328                         /*Enable charger*/
2329                         abx500_mask_and_set_register_interruptible(di->dev,
2330                                         AB8500_CHARGER, AB8500_USBCH_CTRL1_REG,
2331                                         USB_CH_ENA, USB_CH_ENA);
2332                         /*Enable charger detection*/
2333                         abx500_mask_and_set_register_interruptible(di->dev,
2334                                         AB8500_USB, AB8500_USB_LINE_CTRL2_REG,
2335                                         USB_CH_DET, USB_CH_DET);
2336                         di->invalid_charger_detect_state = 1;
2337                         /*exit and wait for new link status interrupt.*/
2338                         return;
2339
2340                 }
2341                 if (di->invalid_charger_detect_state == 1) {
2342                         dev_dbg(di->dev,
2343                                         "Invalid charger detected, state= 1\n");
2344                         /*Stop charger detection*/
2345                         abx500_mask_and_set_register_interruptible(di->dev,
2346                                         AB8500_USB, AB8500_USB_LINE_CTRL2_REG,
2347                                         USB_CH_DET, 0x00);
2348                         /*Check link status*/
2349                         if (is_ab8500(di->parent))
2350                                 ret = abx500_get_register_interruptible(di->dev,
2351                                         AB8500_USB, AB8500_USB_LINE_STAT_REG,
2352                                         &val);
2353                         else
2354                                 ret = abx500_get_register_interruptible(di->dev,
2355                                         AB8500_USB, AB8500_USB_LINK1_STAT_REG,
2356                                         &val);
2357
2358                         dev_dbg(di->dev, "USB link status= 0x%02x\n",
2359                                 (val & link_status) >> USB_LINK_STATUS_SHIFT);
2360                         di->invalid_charger_detect_state = 2;
2361                 }
2362         } else {
2363                 di->invalid_charger_detect_state = 0;
2364         }
2365
2366         if (!(detected_chargers & USB_PW_CONN)) {
2367                 di->vbus_detected = false;
2368                 ab8500_charger_set_usb_connected(di, false);
2369                 ab8500_power_supply_changed(di, di->usb_chg.psy);
2370                 return;
2371         }
2372
2373         dev_dbg(di->dev,"%s di->vbus_detected = true\n",__func__);
2374         di->vbus_detected = true;
2375         ret = ab8500_charger_read_usb_type(di);
2376         if (ret) {
2377                 if (ret == -ENXIO) {
2378                         /* No valid charger type detected */
2379                         ab8500_charger_set_usb_connected(di, false);
2380                         ab8500_power_supply_changed(di, di->usb_chg.psy);
2381                 }
2382                 return;
2383         }
2384
2385         if (di->usb_device_is_unrecognised) {
2386                 dev_dbg(di->dev,
2387                         "Potential Legacy Charger device. "
2388                         "Delay work for %d msec for USB enum "
2389                         "to finish",
2390                         WAIT_ACA_RID_ENUMERATION);
2391                 queue_delayed_work(di->charger_wq,
2392                                    &di->attach_work,
2393                                    msecs_to_jiffies(WAIT_ACA_RID_ENUMERATION));
2394         } else if (di->is_aca_rid == 1) {
2395                 /* Only wait once */
2396                 di->is_aca_rid++;
2397                 dev_dbg(di->dev,
2398                         "%s Wait %d msec for USB enum to finish",
2399                         __func__, WAIT_ACA_RID_ENUMERATION);
2400                 queue_delayed_work(di->charger_wq,
2401                                    &di->attach_work,
2402                                    msecs_to_jiffies(WAIT_ACA_RID_ENUMERATION));
2403         } else {
2404                 queue_delayed_work(di->charger_wq,
2405                                    &di->attach_work,
2406                                    0);
2407         }
2408 }
2409
2410 static void ab8500_charger_usb_state_changed_work(struct work_struct *work)
2411 {
2412         int ret;
2413         unsigned long flags;
2414
2415         struct ab8500_charger *di = container_of(work,
2416                 struct ab8500_charger, usb_state_changed_work.work);
2417
2418         if (!di->vbus_detected) {
2419                 dev_dbg(di->dev,
2420                         "%s !di->vbus_detected\n",
2421                         __func__);
2422                 return;
2423         }
2424
2425         spin_lock_irqsave(&di->usb_state.usb_lock, flags);
2426         di->usb_state.state = di->usb_state.state_tmp;
2427         di->usb_state.usb_current_ua = di->usb_state.usb_current_tmp_ua;
2428         spin_unlock_irqrestore(&di->usb_state.usb_lock, flags);
2429
2430         dev_dbg(di->dev, "%s USB state: 0x%02x uA: %d\n",
2431                 __func__, di->usb_state.state, di->usb_state.usb_current_ua);
2432
2433         switch (di->usb_state.state) {
2434         case AB8500_BM_USB_STATE_RESET_HS:
2435         case AB8500_BM_USB_STATE_RESET_FS:
2436         case AB8500_BM_USB_STATE_SUSPEND:
2437         case AB8500_BM_USB_STATE_MAX:
2438                 ab8500_charger_set_usb_connected(di, false);
2439                 ab8500_power_supply_changed(di, di->usb_chg.psy);
2440                 break;
2441
2442         case AB8500_BM_USB_STATE_RESUME:
2443                 /*
2444                  * when suspend->resume there should be delay
2445                  * of 1sec for enabling charging
2446                  */
2447                 msleep(1000);
2448                 fallthrough;
2449         case AB8500_BM_USB_STATE_CONFIGURED:
2450                 /*
2451                  * USB is configured, enable charging with the charging
2452                  * input current obtained from USB driver
2453                  */
2454                 if (!ab8500_charger_get_usb_cur(di)) {
2455                         /* Update maximum input current */
2456                         ret = ab8500_charger_set_vbus_in_curr(di,
2457                                         di->max_usb_in_curr.usb_type_max_ua);
2458                         if (ret)
2459                                 return;
2460
2461                         ab8500_charger_set_usb_connected(di, true);
2462                         ab8500_power_supply_changed(di, di->usb_chg.psy);
2463                 }
2464                 break;
2465
2466         default:
2467                 break;
2468         }
2469 }
2470
2471 /**
2472  * ab8500_charger_check_usbchargernotok_work() - check USB chg not ok status
2473  * @work:       pointer to the work_struct structure
2474  *
2475  * Work queue function for checking the USB charger Not OK status
2476  */
2477 static void ab8500_charger_check_usbchargernotok_work(struct work_struct *work)
2478 {
2479         int ret;
2480         u8 reg_value;
2481         bool prev_status;
2482
2483         struct ab8500_charger *di = container_of(work,
2484                 struct ab8500_charger, check_usbchgnotok_work.work);
2485
2486         /* Check if the status bit for usbchargernotok is still active */
2487         ret = abx500_get_register_interruptible(di->dev,
2488                 AB8500_CHARGER, AB8500_CH_USBCH_STAT2_REG, &reg_value);
2489         if (ret < 0) {
2490                 dev_err(di->dev, "%s ab8500 read failed\n", __func__);
2491                 return;
2492         }
2493         prev_status = di->flags.usbchargernotok;
2494
2495         if (reg_value & VBUS_CH_NOK) {
2496                 di->flags.usbchargernotok = true;
2497                 /* Check again in 1sec */
2498                 queue_delayed_work(di->charger_wq,
2499                         &di->check_usbchgnotok_work, HZ);
2500         } else {
2501                 di->flags.usbchargernotok = false;
2502                 di->flags.vbus_collapse = false;
2503         }
2504
2505         if (prev_status != di->flags.usbchargernotok)
2506                 ab8500_power_supply_changed(di, di->usb_chg.psy);
2507 }
2508
2509 /**
2510  * ab8500_charger_check_main_thermal_prot_work() - check main thermal status
2511  * @work:       pointer to the work_struct structure
2512  *
2513  * Work queue function for checking the Main thermal prot status
2514  */
2515 static void ab8500_charger_check_main_thermal_prot_work(
2516         struct work_struct *work)
2517 {
2518         int ret;
2519         u8 reg_value;
2520
2521         struct ab8500_charger *di = container_of(work,
2522                 struct ab8500_charger, check_main_thermal_prot_work);
2523
2524         /* Check if the status bit for main_thermal_prot is still active */
2525         ret = abx500_get_register_interruptible(di->dev,
2526                 AB8500_CHARGER, AB8500_CH_STATUS2_REG, &reg_value);
2527         if (ret < 0) {
2528                 dev_err(di->dev, "%s ab8500 read failed\n", __func__);
2529                 return;
2530         }
2531         if (reg_value & MAIN_CH_TH_PROT)
2532                 di->flags.main_thermal_prot = true;
2533         else
2534                 di->flags.main_thermal_prot = false;
2535
2536         ab8500_power_supply_changed(di, di->ac_chg.psy);
2537 }
2538
2539 /**
2540  * ab8500_charger_check_usb_thermal_prot_work() - check usb thermal status
2541  * @work:       pointer to the work_struct structure
2542  *
2543  * Work queue function for checking the USB thermal prot status
2544  */
2545 static void ab8500_charger_check_usb_thermal_prot_work(
2546         struct work_struct *work)
2547 {
2548         int ret;
2549         u8 reg_value;
2550
2551         struct ab8500_charger *di = container_of(work,
2552                 struct ab8500_charger, check_usb_thermal_prot_work);
2553
2554         /* Check if the status bit for usb_thermal_prot is still active */
2555         ret = abx500_get_register_interruptible(di->dev,
2556                 AB8500_CHARGER, AB8500_CH_USBCH_STAT2_REG, &reg_value);
2557         if (ret < 0) {
2558                 dev_err(di->dev, "%s ab8500 read failed\n", __func__);
2559                 return;
2560         }
2561         if (reg_value & USB_CH_TH_PROT)
2562                 di->flags.usb_thermal_prot = true;
2563         else
2564                 di->flags.usb_thermal_prot = false;
2565
2566         ab8500_power_supply_changed(di, di->usb_chg.psy);
2567 }
2568
2569 /**
2570  * ab8500_charger_mainchunplugdet_handler() - main charger unplugged
2571  * @irq:       interrupt number
2572  * @_di:       pointer to the ab8500_charger structure
2573  *
2574  * Returns IRQ status(IRQ_HANDLED)
2575  */
2576 static irqreturn_t ab8500_charger_mainchunplugdet_handler(int irq, void *_di)
2577 {
2578         struct ab8500_charger *di = _di;
2579
2580         dev_dbg(di->dev, "Main charger unplugged\n");
2581         queue_work(di->charger_wq, &di->ac_work);
2582
2583         cancel_delayed_work_sync(&di->ac_charger_attached_work);
2584         mutex_lock(&di->charger_attached_mutex);
2585         mutex_unlock(&di->charger_attached_mutex);
2586
2587         return IRQ_HANDLED;
2588 }
2589
2590 /**
2591  * ab8500_charger_mainchplugdet_handler() - main charger plugged
2592  * @irq:       interrupt number
2593  * @_di:       pointer to the ab8500_charger structure
2594  *
2595  * Returns IRQ status(IRQ_HANDLED)
2596  */
2597 static irqreturn_t ab8500_charger_mainchplugdet_handler(int irq, void *_di)
2598 {
2599         struct ab8500_charger *di = _di;
2600
2601         dev_dbg(di->dev, "Main charger plugged\n");
2602         queue_work(di->charger_wq, &di->ac_work);
2603
2604         mutex_lock(&di->charger_attached_mutex);
2605         mutex_unlock(&di->charger_attached_mutex);
2606
2607         if (is_ab8500(di->parent))
2608                 queue_delayed_work(di->charger_wq,
2609                            &di->ac_charger_attached_work,
2610                            HZ);
2611         return IRQ_HANDLED;
2612 }
2613
2614 /**
2615  * ab8500_charger_mainextchnotok_handler() - main charger not ok
2616  * @irq:       interrupt number
2617  * @_di:       pointer to the ab8500_charger structure
2618  *
2619  * Returns IRQ status(IRQ_HANDLED)
2620  */
2621 static irqreturn_t ab8500_charger_mainextchnotok_handler(int irq, void *_di)
2622 {
2623         struct ab8500_charger *di = _di;
2624
2625         dev_dbg(di->dev, "Main charger not ok\n");
2626         di->flags.mainextchnotok = true;
2627         ab8500_power_supply_changed(di, di->ac_chg.psy);
2628
2629         /* Schedule a new HW failure check */
2630         queue_delayed_work(di->charger_wq, &di->check_hw_failure_work, 0);
2631
2632         return IRQ_HANDLED;
2633 }
2634
2635 /**
2636  * ab8500_charger_mainchthprotr_handler() - Die temp is above main charger
2637  * thermal protection threshold
2638  * @irq:       interrupt number
2639  * @_di:       pointer to the ab8500_charger structure
2640  *
2641  * Returns IRQ status(IRQ_HANDLED)
2642  */
2643 static irqreturn_t ab8500_charger_mainchthprotr_handler(int irq, void *_di)
2644 {
2645         struct ab8500_charger *di = _di;
2646
2647         dev_dbg(di->dev,
2648                 "Die temp above Main charger thermal protection threshold\n");
2649         queue_work(di->charger_wq, &di->check_main_thermal_prot_work);
2650
2651         return IRQ_HANDLED;
2652 }
2653
2654 /**
2655  * ab8500_charger_mainchthprotf_handler() - Die temp is below main charger
2656  * thermal protection threshold
2657  * @irq:       interrupt number
2658  * @_di:       pointer to the ab8500_charger structure
2659  *
2660  * Returns IRQ status(IRQ_HANDLED)
2661  */
2662 static irqreturn_t ab8500_charger_mainchthprotf_handler(int irq, void *_di)
2663 {
2664         struct ab8500_charger *di = _di;
2665
2666         dev_dbg(di->dev,
2667                 "Die temp ok for Main charger thermal protection threshold\n");
2668         queue_work(di->charger_wq, &di->check_main_thermal_prot_work);
2669
2670         return IRQ_HANDLED;
2671 }
2672
2673 static void ab8500_charger_vbus_drop_end_work(struct work_struct *work)
2674 {
2675         struct ab8500_charger *di = container_of(work,
2676                 struct ab8500_charger, vbus_drop_end_work.work);
2677         int ret, curr_ua;
2678         u8 reg_value;
2679
2680         di->flags.vbus_drop_end = false;
2681
2682         /* Reset the drop counter */
2683         abx500_set_register_interruptible(di->dev,
2684                                   AB8500_CHARGER, AB8500_CHARGER_CTRL, 0x01);
2685
2686         ret = abx500_get_register_interruptible(di->dev, AB8500_CHARGER,
2687                         AB8500_CH_USBCH_STAT2_REG, &reg_value);
2688         if (ret < 0) {
2689                 dev_err(di->dev, "%s read failed\n", __func__);
2690                 return;
2691         }
2692
2693         curr_ua = ab8500_charge_input_curr_map[
2694                 reg_value >> AUTO_VBUS_IN_CURR_LIM_SHIFT];
2695
2696         if (di->max_usb_in_curr.calculated_max_ua != curr_ua) {
2697                 /* USB source is collapsing */
2698                 di->max_usb_in_curr.calculated_max_ua = curr_ua;
2699                 dev_dbg(di->dev,
2700                          "VBUS input current limiting to %d uA\n",
2701                          di->max_usb_in_curr.calculated_max_ua);
2702         } else {
2703                 /*
2704                  * USB source can not give more than this amount.
2705                  * Taking more will collapse the source.
2706                  */
2707                 di->max_usb_in_curr.set_max_ua =
2708                         di->max_usb_in_curr.calculated_max_ua;
2709                 dev_dbg(di->dev,
2710                          "VBUS input current limited to %d uA\n",
2711                          di->max_usb_in_curr.set_max_ua);
2712         }
2713
2714         if (di->usb.charger_connected)
2715                 ab8500_charger_set_vbus_in_curr(di,
2716                                         di->max_usb_in_curr.usb_type_max_ua);
2717 }
2718
2719 /**
2720  * ab8500_charger_vbusdetf_handler() - VBUS falling detected
2721  * @irq:       interrupt number
2722  * @_di:       pointer to the ab8500_charger structure
2723  *
2724  * Returns IRQ status(IRQ_HANDLED)
2725  */
2726 static irqreturn_t ab8500_charger_vbusdetf_handler(int irq, void *_di)
2727 {
2728         struct ab8500_charger *di = _di;
2729
2730         di->vbus_detected = false;
2731         dev_dbg(di->dev, "VBUS falling detected\n");
2732         queue_work(di->charger_wq, &di->detect_usb_type_work);
2733
2734         return IRQ_HANDLED;
2735 }
2736
2737 /**
2738  * ab8500_charger_vbusdetr_handler() - VBUS rising detected
2739  * @irq:       interrupt number
2740  * @_di:       pointer to the ab8500_charger structure
2741  *
2742  * Returns IRQ status(IRQ_HANDLED)
2743  */
2744 static irqreturn_t ab8500_charger_vbusdetr_handler(int irq, void *_di)
2745 {
2746         struct ab8500_charger *di = _di;
2747
2748         di->vbus_detected = true;
2749         dev_dbg(di->dev, "VBUS rising detected\n");
2750
2751         queue_work(di->charger_wq, &di->detect_usb_type_work);
2752
2753         return IRQ_HANDLED;
2754 }
2755
2756 /**
2757  * ab8500_charger_usblinkstatus_handler() - USB link status has changed
2758  * @irq:       interrupt number
2759  * @_di:       pointer to the ab8500_charger structure
2760  *
2761  * Returns IRQ status(IRQ_HANDLED)
2762  */
2763 static irqreturn_t ab8500_charger_usblinkstatus_handler(int irq, void *_di)
2764 {
2765         struct ab8500_charger *di = _di;
2766
2767         dev_dbg(di->dev, "USB link status changed\n");
2768
2769         queue_work(di->charger_wq, &di->usb_link_status_work);
2770
2771         return IRQ_HANDLED;
2772 }
2773
2774 /**
2775  * ab8500_charger_usbchthprotr_handler() - Die temp is above usb charger
2776  * thermal protection threshold
2777  * @irq:       interrupt number
2778  * @_di:       pointer to the ab8500_charger structure
2779  *
2780  * Returns IRQ status(IRQ_HANDLED)
2781  */
2782 static irqreturn_t ab8500_charger_usbchthprotr_handler(int irq, void *_di)
2783 {
2784         struct ab8500_charger *di = _di;
2785
2786         dev_dbg(di->dev,
2787                 "Die temp above USB charger thermal protection threshold\n");
2788         queue_work(di->charger_wq, &di->check_usb_thermal_prot_work);
2789
2790         return IRQ_HANDLED;
2791 }
2792
2793 /**
2794  * ab8500_charger_usbchthprotf_handler() - Die temp is below usb charger
2795  * thermal protection threshold
2796  * @irq:       interrupt number
2797  * @_di:       pointer to the ab8500_charger structure
2798  *
2799  * Returns IRQ status(IRQ_HANDLED)
2800  */
2801 static irqreturn_t ab8500_charger_usbchthprotf_handler(int irq, void *_di)
2802 {
2803         struct ab8500_charger *di = _di;
2804
2805         dev_dbg(di->dev,
2806                 "Die temp ok for USB charger thermal protection threshold\n");
2807         queue_work(di->charger_wq, &di->check_usb_thermal_prot_work);
2808
2809         return IRQ_HANDLED;
2810 }
2811
2812 /**
2813  * ab8500_charger_usbchargernotokr_handler() - USB charger not ok detected
2814  * @irq:       interrupt number
2815  * @_di:       pointer to the ab8500_charger structure
2816  *
2817  * Returns IRQ status(IRQ_HANDLED)
2818  */
2819 static irqreturn_t ab8500_charger_usbchargernotokr_handler(int irq, void *_di)
2820 {
2821         struct ab8500_charger *di = _di;
2822
2823         dev_dbg(di->dev, "Not allowed USB charger detected\n");
2824         queue_delayed_work(di->charger_wq, &di->check_usbchgnotok_work, 0);
2825
2826         return IRQ_HANDLED;
2827 }
2828
2829 /**
2830  * ab8500_charger_chwdexp_handler() - Charger watchdog expired
2831  * @irq:       interrupt number
2832  * @_di:       pointer to the ab8500_charger structure
2833  *
2834  * Returns IRQ status(IRQ_HANDLED)
2835  */
2836 static irqreturn_t ab8500_charger_chwdexp_handler(int irq, void *_di)
2837 {
2838         struct ab8500_charger *di = _di;
2839
2840         dev_dbg(di->dev, "Charger watchdog expired\n");
2841
2842         /*
2843          * The charger that was online when the watchdog expired
2844          * needs to be restarted for charging to start again
2845          */
2846         if (di->ac.charger_online) {
2847                 di->ac.wd_expired = true;
2848                 ab8500_power_supply_changed(di, di->ac_chg.psy);
2849         }
2850         if (di->usb.charger_online) {
2851                 di->usb.wd_expired = true;
2852                 ab8500_power_supply_changed(di, di->usb_chg.psy);
2853         }
2854
2855         return IRQ_HANDLED;
2856 }
2857
2858 /**
2859  * ab8500_charger_vbuschdropend_handler() - VBUS drop removed
2860  * @irq:       interrupt number
2861  * @_di:       pointer to the ab8500_charger structure
2862  *
2863  * Returns IRQ status(IRQ_HANDLED)
2864  */
2865 static irqreturn_t ab8500_charger_vbuschdropend_handler(int irq, void *_di)
2866 {
2867         struct ab8500_charger *di = _di;
2868
2869         dev_dbg(di->dev, "VBUS charger drop ended\n");
2870         di->flags.vbus_drop_end = true;
2871
2872         /*
2873          * VBUS might have dropped due to bad connection.
2874          * Schedule a new input limit set to the value SW requests.
2875          */
2876         queue_delayed_work(di->charger_wq, &di->vbus_drop_end_work,
2877                            round_jiffies(VBUS_IN_CURR_LIM_RETRY_SET_TIME * HZ));
2878
2879         return IRQ_HANDLED;
2880 }
2881
2882 /**
2883  * ab8500_charger_vbusovv_handler() - VBUS overvoltage detected
2884  * @irq:       interrupt number
2885  * @_di:       pointer to the ab8500_charger structure
2886  *
2887  * Returns IRQ status(IRQ_HANDLED)
2888  */
2889 static irqreturn_t ab8500_charger_vbusovv_handler(int irq, void *_di)
2890 {
2891         struct ab8500_charger *di = _di;
2892
2893         dev_dbg(di->dev, "VBUS overvoltage detected\n");
2894         di->flags.vbus_ovv = true;
2895         ab8500_power_supply_changed(di, di->usb_chg.psy);
2896
2897         /* Schedule a new HW failure check */
2898         queue_delayed_work(di->charger_wq, &di->check_hw_failure_work, 0);
2899
2900         return IRQ_HANDLED;
2901 }
2902
2903 /**
2904  * ab8500_charger_ac_get_property() - get the ac/mains properties
2905  * @psy:       pointer to the power_supply structure
2906  * @psp:       pointer to the power_supply_property structure
2907  * @val:       pointer to the power_supply_propval union
2908  *
2909  * This function gets called when an application tries to get the ac/mains
2910  * properties by reading the sysfs files.
2911  * AC/Mains properties are online, present and voltage.
2912  * online:     ac/mains charging is in progress or not
2913  * present:    presence of the ac/mains
2914  * voltage:    AC/Mains voltage
2915  * Returns error code in case of failure else 0(on success)
2916  */
2917 static int ab8500_charger_ac_get_property(struct power_supply *psy,
2918         enum power_supply_property psp,
2919         union power_supply_propval *val)
2920 {
2921         struct ab8500_charger *di;
2922         int ret;
2923
2924         di = to_ab8500_charger_ac_device_info(psy_to_ux500_charger(psy));
2925
2926         switch (psp) {
2927         case POWER_SUPPLY_PROP_HEALTH:
2928                 if (di->flags.mainextchnotok)
2929                         val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
2930                 else if (di->ac.wd_expired || di->usb.wd_expired)
2931                         val->intval = POWER_SUPPLY_HEALTH_DEAD;
2932                 else if (di->flags.main_thermal_prot)
2933                         val->intval = POWER_SUPPLY_HEALTH_OVERHEAT;
2934                 else
2935                         val->intval = POWER_SUPPLY_HEALTH_GOOD;
2936                 break;
2937         case POWER_SUPPLY_PROP_ONLINE:
2938                 val->intval = di->ac.charger_online;
2939                 break;
2940         case POWER_SUPPLY_PROP_PRESENT:
2941                 val->intval = di->ac.charger_connected;
2942                 break;
2943         case POWER_SUPPLY_PROP_VOLTAGE_NOW:
2944                 ret = ab8500_charger_get_ac_voltage(di);
2945                 if (ret >= 0)
2946                         di->ac.charger_voltage_uv = ret;
2947                 /* On error, use previous value */
2948                 val->intval = di->ac.charger_voltage_uv;
2949                 break;
2950         case POWER_SUPPLY_PROP_VOLTAGE_AVG:
2951                 /*
2952                  * This property is used to indicate when CV mode is entered
2953                  * for the AC charger
2954                  */
2955                 di->ac.cv_active = ab8500_charger_ac_cv(di);
2956                 val->intval = di->ac.cv_active;
2957                 break;
2958         case POWER_SUPPLY_PROP_CURRENT_NOW:
2959                 ret = ab8500_charger_get_ac_current(di);
2960                 if (ret >= 0)
2961                         di->ac.charger_current_ua = ret;
2962                 val->intval = di->ac.charger_current_ua;
2963                 break;
2964         default:
2965                 return -EINVAL;
2966         }
2967         return 0;
2968 }
2969
2970 /**
2971  * ab8500_charger_usb_get_property() - get the usb properties
2972  * @psy:        pointer to the power_supply structure
2973  * @psp:        pointer to the power_supply_property structure
2974  * @val:        pointer to the power_supply_propval union
2975  *
2976  * This function gets called when an application tries to get the usb
2977  * properties by reading the sysfs files.
2978  * USB properties are online, present and voltage.
2979  * online:     usb charging is in progress or not
2980  * present:    presence of the usb
2981  * voltage:    vbus voltage
2982  * Returns error code in case of failure else 0(on success)
2983  */
2984 static int ab8500_charger_usb_get_property(struct power_supply *psy,
2985         enum power_supply_property psp,
2986         union power_supply_propval *val)
2987 {
2988         struct ab8500_charger *di;
2989         int ret;
2990
2991         di = to_ab8500_charger_usb_device_info(psy_to_ux500_charger(psy));
2992
2993         switch (psp) {
2994         case POWER_SUPPLY_PROP_HEALTH:
2995                 if (di->flags.usbchargernotok)
2996                         val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
2997                 else if (di->ac.wd_expired || di->usb.wd_expired)
2998                         val->intval = POWER_SUPPLY_HEALTH_DEAD;
2999                 else if (di->flags.usb_thermal_prot)
3000                         val->intval = POWER_SUPPLY_HEALTH_OVERHEAT;
3001                 else if (di->flags.vbus_ovv)
3002                         val->intval = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
3003                 else
3004                         val->intval = POWER_SUPPLY_HEALTH_GOOD;
3005                 break;
3006         case POWER_SUPPLY_PROP_ONLINE:
3007                 val->intval = di->usb.charger_online;
3008                 break;
3009         case POWER_SUPPLY_PROP_PRESENT:
3010                 val->intval = di->usb.charger_connected;
3011                 break;
3012         case POWER_SUPPLY_PROP_VOLTAGE_NOW:
3013                 ret = ab8500_charger_get_vbus_voltage(di);
3014                 if (ret >= 0)
3015                         di->usb.charger_voltage_uv = ret;
3016                 val->intval = di->usb.charger_voltage_uv;
3017                 break;
3018         case POWER_SUPPLY_PROP_VOLTAGE_AVG:
3019                 /*
3020                  * This property is used to indicate when CV mode is entered
3021                  * for the USB charger
3022                  */
3023                 di->usb.cv_active = ab8500_charger_usb_cv(di);
3024                 val->intval = di->usb.cv_active;
3025                 break;
3026         case POWER_SUPPLY_PROP_CURRENT_NOW:
3027                 ret = ab8500_charger_get_usb_current(di);
3028                 if (ret >= 0)
3029                         di->usb.charger_current_ua = ret;
3030                 val->intval = di->usb.charger_current_ua;
3031                 break;
3032         case POWER_SUPPLY_PROP_CURRENT_AVG:
3033                 /*
3034                  * This property is used to indicate when VBUS has collapsed
3035                  * due to too high output current from the USB charger
3036                  */
3037                 if (di->flags.vbus_collapse)
3038                         val->intval = 1;
3039                 else
3040                         val->intval = 0;
3041                 break;
3042         default:
3043                 return -EINVAL;
3044         }
3045         return 0;
3046 }
3047
3048 /**
3049  * ab8500_charger_init_hw_registers() - Set up charger related registers
3050  * @di:         pointer to the ab8500_charger structure
3051  *
3052  * Set up charger OVV, watchdog and maximum voltage registers as well as
3053  * charging of the backup battery
3054  */
3055 static int ab8500_charger_init_hw_registers(struct ab8500_charger *di)
3056 {
3057         int ret = 0;
3058
3059         /* Setup maximum charger current and voltage for ABB cut2.0 */
3060         if (!is_ab8500_1p1_or_earlier(di->parent)) {
3061                 ret = abx500_set_register_interruptible(di->dev,
3062                         AB8500_CHARGER,
3063                         AB8500_CH_VOLT_LVL_MAX_REG, CH_VOL_LVL_4P6);
3064                 if (ret) {
3065                         dev_err(di->dev,
3066                                 "failed to set CH_VOLT_LVL_MAX_REG\n");
3067                         goto out;
3068                 }
3069
3070                 ret = abx500_set_register_interruptible(di->dev,
3071                         AB8500_CHARGER, AB8500_CH_OPT_CRNTLVL_MAX_REG,
3072                         CH_OP_CUR_LVL_1P6);
3073                 if (ret) {
3074                         dev_err(di->dev,
3075                                 "failed to set CH_OPT_CRNTLVL_MAX_REG\n");
3076                         goto out;
3077                 }
3078         }
3079
3080         if (is_ab8505_2p0(di->parent))
3081                 ret = abx500_mask_and_set_register_interruptible(di->dev,
3082                         AB8500_CHARGER,
3083                         AB8500_USBCH_CTRL2_REG,
3084                         VBUS_AUTO_IN_CURR_LIM_ENA,
3085                         VBUS_AUTO_IN_CURR_LIM_ENA);
3086         else
3087                 /*
3088                  * VBUS OVV set to 6.3V and enable automatic current limitation
3089                  */
3090                 ret = abx500_set_register_interruptible(di->dev,
3091                         AB8500_CHARGER,
3092                         AB8500_USBCH_CTRL2_REG,
3093                         VBUS_OVV_SELECT_6P3V | VBUS_AUTO_IN_CURR_LIM_ENA);
3094         if (ret) {
3095                 dev_err(di->dev,
3096                         "failed to set automatic current limitation\n");
3097                 goto out;
3098         }
3099
3100         /* Enable main watchdog in OTP */
3101         ret = abx500_set_register_interruptible(di->dev,
3102                 AB8500_OTP_EMUL, AB8500_OTP_CONF_15, OTP_ENABLE_WD);
3103         if (ret) {
3104                 dev_err(di->dev, "failed to enable main WD in OTP\n");
3105                 goto out;
3106         }
3107
3108         /* Enable main watchdog */
3109         ret = abx500_set_register_interruptible(di->dev,
3110                 AB8500_SYS_CTRL2_BLOCK,
3111                 AB8500_MAIN_WDOG_CTRL_REG, MAIN_WDOG_ENA);
3112         if (ret) {
3113                 dev_err(di->dev, "failed to enable main watchdog\n");
3114                 goto out;
3115         }
3116
3117         /*
3118          * Due to internal synchronisation, Enable and Kick watchdog bits
3119          * cannot be enabled in a single write.
3120          * A minimum delay of 2*32 kHz period (62.5µs) must be inserted
3121          * between writing Enable then Kick bits.
3122          */
3123         udelay(63);
3124
3125         /* Kick main watchdog */
3126         ret = abx500_set_register_interruptible(di->dev,
3127                 AB8500_SYS_CTRL2_BLOCK,
3128                 AB8500_MAIN_WDOG_CTRL_REG,
3129                 (MAIN_WDOG_ENA | MAIN_WDOG_KICK));
3130         if (ret) {
3131                 dev_err(di->dev, "failed to kick main watchdog\n");
3132                 goto out;
3133         }
3134
3135         /* Disable main watchdog */
3136         ret = abx500_set_register_interruptible(di->dev,
3137                 AB8500_SYS_CTRL2_BLOCK,
3138                 AB8500_MAIN_WDOG_CTRL_REG, MAIN_WDOG_DIS);
3139         if (ret) {
3140                 dev_err(di->dev, "failed to disable main watchdog\n");
3141                 goto out;
3142         }
3143
3144         /* Set watchdog timeout */
3145         ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
3146                 AB8500_CH_WD_TIMER_REG, WD_TIMER);
3147         if (ret) {
3148                 dev_err(di->dev, "failed to set charger watchdog timeout\n");
3149                 goto out;
3150         }
3151
3152         ret = ab8500_charger_led_en(di, false);
3153         if (ret < 0) {
3154                 dev_err(di->dev, "failed to disable LED\n");
3155                 goto out;
3156         }
3157
3158         ret = abx500_set_register_interruptible(di->dev,
3159                 AB8500_RTC,
3160                 AB8500_RTC_BACKUP_CHG_REG,
3161                 (di->bm->bkup_bat_v & 0x3) | di->bm->bkup_bat_i);
3162         if (ret) {
3163                 dev_err(di->dev, "failed to setup backup battery charging\n");
3164                 goto out;
3165         }
3166
3167         /* Enable backup battery charging */
3168         ret = abx500_mask_and_set_register_interruptible(di->dev,
3169                 AB8500_RTC, AB8500_RTC_CTRL_REG,
3170                 RTC_BUP_CH_ENA, RTC_BUP_CH_ENA);
3171         if (ret < 0) {
3172                 dev_err(di->dev, "%s mask and set failed\n", __func__);
3173                 goto out;
3174         }
3175
3176 out:
3177         return ret;
3178 }
3179
3180 /*
3181  * ab8500 charger driver interrupts and their respective isr
3182  */
3183 static struct ab8500_charger_interrupts ab8500_charger_irq[] = {
3184         {"MAIN_CH_UNPLUG_DET", ab8500_charger_mainchunplugdet_handler},
3185         {"MAIN_CHARGE_PLUG_DET", ab8500_charger_mainchplugdet_handler},
3186         {"MAIN_EXT_CH_NOT_OK", ab8500_charger_mainextchnotok_handler},
3187         {"MAIN_CH_TH_PROT_R", ab8500_charger_mainchthprotr_handler},
3188         {"MAIN_CH_TH_PROT_F", ab8500_charger_mainchthprotf_handler},
3189         {"VBUS_DET_F", ab8500_charger_vbusdetf_handler},
3190         {"VBUS_DET_R", ab8500_charger_vbusdetr_handler},
3191         {"USB_LINK_STATUS", ab8500_charger_usblinkstatus_handler},
3192         {"USB_CH_TH_PROT_R", ab8500_charger_usbchthprotr_handler},
3193         {"USB_CH_TH_PROT_F", ab8500_charger_usbchthprotf_handler},
3194         {"USB_CHARGER_NOT_OKR", ab8500_charger_usbchargernotokr_handler},
3195         {"VBUS_OVV", ab8500_charger_vbusovv_handler},
3196         {"CH_WD_EXP", ab8500_charger_chwdexp_handler},
3197         {"VBUS_CH_DROP_END", ab8500_charger_vbuschdropend_handler},
3198 };
3199
3200 static int ab8500_charger_usb_notifier_call(struct notifier_block *nb,
3201                 unsigned long event, void *power)
3202 {
3203         struct ab8500_charger *di =
3204                 container_of(nb, struct ab8500_charger, nb);
3205         enum ab8500_usb_state bm_usb_state;
3206         /*
3207          * FIXME: it appears the AB8500 PHY never sends what it should here.
3208          * Fix the PHY driver to properly notify the desired current.
3209          * Also broadcast microampere and not milliampere.
3210          */
3211         unsigned mA = *((unsigned *)power);
3212
3213         if (event != USB_EVENT_VBUS) {
3214                 dev_dbg(di->dev, "not a standard host, returning\n");
3215                 return NOTIFY_DONE;
3216         }
3217
3218         /* TODO: State is fabricate  here. See if charger really needs USB
3219          * state or if mA is enough
3220          */
3221         if ((di->usb_state.usb_current_ua == 2000) && (mA > 2))
3222                 bm_usb_state = AB8500_BM_USB_STATE_RESUME;
3223         else if (mA == 0)
3224                 bm_usb_state = AB8500_BM_USB_STATE_RESET_HS;
3225         else if (mA == 2)
3226                 bm_usb_state = AB8500_BM_USB_STATE_SUSPEND;
3227         else if (mA >= 8) /* 8, 100, 500 */
3228                 bm_usb_state = AB8500_BM_USB_STATE_CONFIGURED;
3229         else /* Should never occur */
3230                 bm_usb_state = AB8500_BM_USB_STATE_RESET_FS;
3231
3232         dev_dbg(di->dev, "%s usb_state: 0x%02x mA: %d\n",
3233                 __func__, bm_usb_state, mA);
3234
3235         spin_lock(&di->usb_state.usb_lock);
3236         di->usb_state.state_tmp = bm_usb_state;
3237         /* FIXME: broadcast ua instead, see above */
3238         di->usb_state.usb_current_tmp_ua = mA * 1000;
3239         spin_unlock(&di->usb_state.usb_lock);
3240
3241         /*
3242          * wait for some time until you get updates from the usb stack
3243          * and negotiations are completed
3244          */
3245         queue_delayed_work(di->charger_wq, &di->usb_state_changed_work, HZ/2);
3246
3247         return NOTIFY_OK;
3248 }
3249
3250 static int __maybe_unused ab8500_charger_resume(struct device *dev)
3251 {
3252         int ret;
3253         struct ab8500_charger *di = dev_get_drvdata(dev);
3254
3255         /*
3256          * For ABB revision 1.0 and 1.1 there is a bug in the watchdog
3257          * logic. That means we have to continuously kick the charger
3258          * watchdog even when no charger is connected. This is only
3259          * valid once the AC charger has been enabled. This is
3260          * a bug that is not handled by the algorithm and the
3261          * watchdog have to be kicked by the charger driver
3262          * when the AC charger is disabled
3263          */
3264         if (di->ac_conn && is_ab8500_1p1_or_earlier(di->parent)) {
3265                 ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
3266                         AB8500_CHARG_WD_CTRL, CHARG_WD_KICK);
3267                 if (ret)
3268                         dev_err(di->dev, "Failed to kick WD!\n");
3269
3270                 /* If not already pending start a new timer */
3271                 queue_delayed_work(di->charger_wq, &di->kick_wd_work,
3272                                    round_jiffies(WD_KICK_INTERVAL));
3273         }
3274
3275         /* If we still have a HW failure, schedule a new check */
3276         if (di->flags.mainextchnotok || di->flags.vbus_ovv) {
3277                 queue_delayed_work(di->charger_wq,
3278                         &di->check_hw_failure_work, 0);
3279         }
3280
3281         if (di->flags.vbus_drop_end)
3282                 queue_delayed_work(di->charger_wq, &di->vbus_drop_end_work, 0);
3283
3284         return 0;
3285 }
3286
3287 static int __maybe_unused ab8500_charger_suspend(struct device *dev)
3288 {
3289         struct ab8500_charger *di = dev_get_drvdata(dev);
3290
3291         /* Cancel any pending jobs */
3292         cancel_delayed_work(&di->check_hw_failure_work);
3293         cancel_delayed_work(&di->vbus_drop_end_work);
3294
3295         flush_delayed_work(&di->attach_work);
3296         flush_delayed_work(&di->usb_charger_attached_work);
3297         flush_delayed_work(&di->ac_charger_attached_work);
3298         flush_delayed_work(&di->check_usbchgnotok_work);
3299         flush_delayed_work(&di->check_vbat_work);
3300         flush_delayed_work(&di->kick_wd_work);
3301
3302         flush_work(&di->usb_link_status_work);
3303         flush_work(&di->ac_work);
3304         flush_work(&di->detect_usb_type_work);
3305
3306         if (atomic_read(&di->current_stepping_sessions))
3307                 return -EAGAIN;
3308
3309         return 0;
3310 }
3311
3312 static struct notifier_block charger_nb = {
3313         .notifier_call = ab8500_external_charger_prepare,
3314 };
3315
3316 static char *supply_interface[] = {
3317         "ab8500_chargalg",
3318         "ab8500_fg",
3319         "ab8500_btemp",
3320 };
3321
3322 static const struct power_supply_desc ab8500_ac_chg_desc = {
3323         .name           = "ab8500_ac",
3324         .type           = POWER_SUPPLY_TYPE_MAINS,
3325         .properties     = ab8500_charger_ac_props,
3326         .num_properties = ARRAY_SIZE(ab8500_charger_ac_props),
3327         .get_property   = ab8500_charger_ac_get_property,
3328 };
3329
3330 static const struct power_supply_desc ab8500_usb_chg_desc = {
3331         .name           = "ab8500_usb",
3332         .type           = POWER_SUPPLY_TYPE_USB,
3333         .properties     = ab8500_charger_usb_props,
3334         .num_properties = ARRAY_SIZE(ab8500_charger_usb_props),
3335         .get_property   = ab8500_charger_usb_get_property,
3336 };
3337
3338 static int ab8500_charger_bind(struct device *dev)
3339 {
3340         struct ab8500_charger *di = dev_get_drvdata(dev);
3341         int ch_stat;
3342         int ret;
3343
3344         /* Create a work queue for the charger */
3345         di->charger_wq = alloc_ordered_workqueue("ab8500_charger_wq",
3346                                                  WQ_MEM_RECLAIM);
3347         if (di->charger_wq == NULL) {
3348                 dev_err(dev, "failed to create work queue\n");
3349                 return -ENOMEM;
3350         }
3351
3352         ch_stat = ab8500_charger_detect_chargers(di, false);
3353
3354         if (ch_stat & AC_PW_CONN) {
3355                 if (is_ab8500(di->parent))
3356                         queue_delayed_work(di->charger_wq,
3357                                            &di->ac_charger_attached_work,
3358                                            HZ);
3359         }
3360         if (ch_stat & USB_PW_CONN) {
3361                 if (is_ab8500(di->parent))
3362                         queue_delayed_work(di->charger_wq,
3363                                            &di->usb_charger_attached_work,
3364                                            HZ);
3365                 di->vbus_detected = true;
3366                 di->vbus_detected_start = true;
3367                 queue_work(di->charger_wq,
3368                            &di->detect_usb_type_work);
3369         }
3370
3371         ret = component_bind_all(dev, di);
3372         if (ret) {
3373                 dev_err(dev, "can't bind component devices\n");
3374                 return ret;
3375         }
3376
3377         return 0;
3378 }
3379
3380 static void ab8500_charger_unbind(struct device *dev)
3381 {
3382         struct ab8500_charger *di = dev_get_drvdata(dev);
3383         int ret;
3384
3385         /* Disable AC charging */
3386         ab8500_charger_ac_en(&di->ac_chg, false, 0, 0);
3387
3388         /* Disable USB charging */
3389         ab8500_charger_usb_en(&di->usb_chg, false, 0, 0);
3390
3391         /* Backup battery voltage and current disable */
3392         ret = abx500_mask_and_set_register_interruptible(di->dev,
3393                 AB8500_RTC, AB8500_RTC_CTRL_REG, RTC_BUP_CH_ENA, 0);
3394         if (ret < 0)
3395                 dev_err(di->dev, "%s mask and set failed\n", __func__);
3396
3397         /* Delete the work queue */
3398         destroy_workqueue(di->charger_wq);
3399
3400         flush_scheduled_work();
3401
3402         /* Unbind fg, btemp, algorithm */
3403         component_unbind_all(dev, di);
3404 }
3405
3406 static const struct component_master_ops ab8500_charger_comp_ops = {
3407         .bind = ab8500_charger_bind,
3408         .unbind = ab8500_charger_unbind,
3409 };
3410
3411 static struct platform_driver *const ab8500_charger_component_drivers[] = {
3412         &ab8500_fg_driver,
3413         &ab8500_btemp_driver,
3414         &ab8500_chargalg_driver,
3415 };
3416
3417 static int ab8500_charger_compare_dev(struct device *dev, void *data)
3418 {
3419         return dev == data;
3420 }
3421
3422 static int ab8500_charger_probe(struct platform_device *pdev)
3423 {
3424         struct device *dev = &pdev->dev;
3425         struct device_node *np = dev->of_node;
3426         struct component_match *match = NULL;
3427         struct power_supply_config ac_psy_cfg = {}, usb_psy_cfg = {};
3428         struct ab8500_charger *di;
3429         int charger_status;
3430         int i, irq;
3431         int ret;
3432
3433         di = devm_kzalloc(dev, sizeof(*di), GFP_KERNEL);
3434         if (!di)
3435                 return -ENOMEM;
3436
3437         di->bm = &ab8500_bm_data;
3438
3439         di->autopower_cfg = of_property_read_bool(np, "autopower_cfg");
3440
3441         /* get parent data */
3442         di->dev = dev;
3443         di->parent = dev_get_drvdata(pdev->dev.parent);
3444
3445         /* Get ADC channels */
3446         di->adc_main_charger_v = devm_iio_channel_get(dev, "main_charger_v");
3447         if (IS_ERR(di->adc_main_charger_v)) {
3448                 ret = dev_err_probe(dev, PTR_ERR(di->adc_main_charger_v),
3449                                     "failed to get ADC main charger voltage\n");
3450                 return ret;
3451         }
3452         di->adc_main_charger_c = devm_iio_channel_get(dev, "main_charger_c");
3453         if (IS_ERR(di->adc_main_charger_c)) {
3454                 ret = dev_err_probe(dev, PTR_ERR(di->adc_main_charger_c),
3455                                     "failed to get ADC main charger current\n");
3456                 return ret;
3457         }
3458         di->adc_vbus_v = devm_iio_channel_get(dev, "vbus_v");
3459         if (IS_ERR(di->adc_vbus_v)) {
3460                 ret = dev_err_probe(dev, PTR_ERR(di->adc_vbus_v),
3461                                     "failed to get ADC USB charger voltage\n");
3462                 return ret;
3463         }
3464         di->adc_usb_charger_c = devm_iio_channel_get(dev, "usb_charger_c");
3465         if (IS_ERR(di->adc_usb_charger_c)) {
3466                 ret = dev_err_probe(dev, PTR_ERR(di->adc_usb_charger_c),
3467                                     "failed to get ADC USB charger current\n");
3468                 return ret;
3469         }
3470
3471         /*
3472          * VDD ADC supply needs to be enabled from this driver when there
3473          * is a charger connected to avoid erroneous BTEMP_HIGH/LOW
3474          * interrupts during charging
3475          */
3476         di->regu = devm_regulator_get(dev, "vddadc");
3477         if (IS_ERR(di->regu)) {
3478                 ret = PTR_ERR(di->regu);
3479                 dev_err(dev, "failed to get vddadc regulator\n");
3480                 return ret;
3481         }
3482
3483         /* Request interrupts */
3484         for (i = 0; i < ARRAY_SIZE(ab8500_charger_irq); i++) {
3485                 irq = platform_get_irq_byname(pdev, ab8500_charger_irq[i].name);
3486                 if (irq < 0)
3487                         return irq;
3488
3489                 ret = devm_request_threaded_irq(dev,
3490                         irq, NULL, ab8500_charger_irq[i].isr,
3491                         IRQF_SHARED | IRQF_NO_SUSPEND | IRQF_ONESHOT,
3492                         ab8500_charger_irq[i].name, di);
3493
3494                 if (ret != 0) {
3495                         dev_err(dev, "failed to request %s IRQ %d: %d\n"
3496                                 , ab8500_charger_irq[i].name, irq, ret);
3497                         return ret;
3498                 }
3499                 dev_dbg(dev, "Requested %s IRQ %d: %d\n",
3500                         ab8500_charger_irq[i].name, irq, ret);
3501         }
3502
3503         /* initialize lock */
3504         spin_lock_init(&di->usb_state.usb_lock);
3505         mutex_init(&di->usb_ipt_crnt_lock);
3506
3507         di->autopower = false;
3508         di->invalid_charger_detect_state = 0;
3509
3510         /* AC and USB supply config */
3511         ac_psy_cfg.of_node = np;
3512         ac_psy_cfg.supplied_to = supply_interface;
3513         ac_psy_cfg.num_supplicants = ARRAY_SIZE(supply_interface);
3514         ac_psy_cfg.drv_data = &di->ac_chg;
3515         usb_psy_cfg.of_node = np;
3516         usb_psy_cfg.supplied_to = supply_interface;
3517         usb_psy_cfg.num_supplicants = ARRAY_SIZE(supply_interface);
3518         usb_psy_cfg.drv_data = &di->usb_chg;
3519
3520         /* AC supply */
3521         /* ux500_charger sub-class */
3522         di->ac_chg.ops.enable = &ab8500_charger_ac_en;
3523         di->ac_chg.ops.check_enable = &ab8500_charger_ac_check_enable;
3524         di->ac_chg.ops.kick_wd = &ab8500_charger_watchdog_kick;
3525         di->ac_chg.ops.update_curr = &ab8500_charger_update_charger_current;
3526         di->ac_chg.max_out_volt_uv = ab8500_charger_voltage_map[
3527                 ARRAY_SIZE(ab8500_charger_voltage_map) - 1];
3528         di->ac_chg.max_out_curr_ua =
3529                 ab8500_charge_output_curr_map[ARRAY_SIZE(ab8500_charge_output_curr_map) - 1];
3530         di->ac_chg.wdt_refresh = CHG_WD_INTERVAL;
3531         /*
3532          * The AB8505 only supports USB charging. If we are not the
3533          * AB8505, register an AC charger.
3534          *
3535          * TODO: if this should be opt-in, add DT properties for this.
3536          */
3537         if (!is_ab8505(di->parent))
3538                 di->ac_chg.enabled = true;
3539         di->ac_chg.external = false;
3540
3541         /* USB supply */
3542         /* ux500_charger sub-class */
3543         di->usb_chg.ops.enable = &ab8500_charger_usb_en;
3544         di->usb_chg.ops.check_enable = &ab8500_charger_usb_check_enable;
3545         di->usb_chg.ops.kick_wd = &ab8500_charger_watchdog_kick;
3546         di->usb_chg.ops.update_curr = &ab8500_charger_update_charger_current;
3547         di->usb_chg.max_out_volt_uv = ab8500_charger_voltage_map[
3548                 ARRAY_SIZE(ab8500_charger_voltage_map) - 1];
3549         di->usb_chg.max_out_curr_ua =
3550                 ab8500_charge_output_curr_map[ARRAY_SIZE(ab8500_charge_output_curr_map) - 1];
3551         di->usb_chg.wdt_refresh = CHG_WD_INTERVAL;
3552         di->usb_chg.external = false;
3553         di->usb_state.usb_current_ua = -1;
3554
3555         mutex_init(&di->charger_attached_mutex);
3556
3557         /* Init work for HW failure check */
3558         INIT_DEFERRABLE_WORK(&di->check_hw_failure_work,
3559                 ab8500_charger_check_hw_failure_work);
3560         INIT_DEFERRABLE_WORK(&di->check_usbchgnotok_work,
3561                 ab8500_charger_check_usbchargernotok_work);
3562
3563         INIT_DELAYED_WORK(&di->ac_charger_attached_work,
3564                           ab8500_charger_ac_attached_work);
3565         INIT_DELAYED_WORK(&di->usb_charger_attached_work,
3566                           ab8500_charger_usb_attached_work);
3567
3568         /*
3569          * For ABB revision 1.0 and 1.1 there is a bug in the watchdog
3570          * logic. That means we have to continuously kick the charger
3571          * watchdog even when no charger is connected. This is only
3572          * valid once the AC charger has been enabled. This is
3573          * a bug that is not handled by the algorithm and the
3574          * watchdog have to be kicked by the charger driver
3575          * when the AC charger is disabled
3576          */
3577         INIT_DEFERRABLE_WORK(&di->kick_wd_work,
3578                 ab8500_charger_kick_watchdog_work);
3579
3580         INIT_DEFERRABLE_WORK(&di->check_vbat_work,
3581                 ab8500_charger_check_vbat_work);
3582
3583         INIT_DELAYED_WORK(&di->attach_work,
3584                 ab8500_charger_usb_link_attach_work);
3585
3586         INIT_DELAYED_WORK(&di->usb_state_changed_work,
3587                 ab8500_charger_usb_state_changed_work);
3588
3589         INIT_DELAYED_WORK(&di->vbus_drop_end_work,
3590                 ab8500_charger_vbus_drop_end_work);
3591
3592         /* Init work for charger detection */
3593         INIT_WORK(&di->usb_link_status_work,
3594                 ab8500_charger_usb_link_status_work);
3595         INIT_WORK(&di->ac_work, ab8500_charger_ac_work);
3596         INIT_WORK(&di->detect_usb_type_work,
3597                 ab8500_charger_detect_usb_type_work);
3598
3599         /* Init work for checking HW status */
3600         INIT_WORK(&di->check_main_thermal_prot_work,
3601                 ab8500_charger_check_main_thermal_prot_work);
3602         INIT_WORK(&di->check_usb_thermal_prot_work,
3603                 ab8500_charger_check_usb_thermal_prot_work);
3604
3605
3606         /* Initialize OVV, and other registers */
3607         ret = ab8500_charger_init_hw_registers(di);
3608         if (ret) {
3609                 dev_err(dev, "failed to initialize ABB registers\n");
3610                 return ret;
3611         }
3612
3613         /* Register AC charger class */
3614         if (di->ac_chg.enabled) {
3615                 di->ac_chg.psy = devm_power_supply_register(dev,
3616                                                        &ab8500_ac_chg_desc,
3617                                                        &ac_psy_cfg);
3618                 if (IS_ERR(di->ac_chg.psy)) {
3619                         dev_err(dev, "failed to register AC charger\n");
3620                         return PTR_ERR(di->ac_chg.psy);
3621                 }
3622         }
3623
3624         /* Register USB charger class */
3625         di->usb_chg.psy = devm_power_supply_register(dev,
3626                                                      &ab8500_usb_chg_desc,
3627                                                      &usb_psy_cfg);
3628         if (IS_ERR(di->usb_chg.psy)) {
3629                 dev_err(dev, "failed to register USB charger\n");
3630                 return PTR_ERR(di->usb_chg.psy);
3631         }
3632
3633         /*
3634          * Check what battery we have, since we always have the USB
3635          * psy, use that as a handle.
3636          */
3637         ret = ab8500_bm_of_probe(di->usb_chg.psy, di->bm);
3638         if (ret)
3639                 return dev_err_probe(dev, ret,
3640                                      "failed to get battery information\n");
3641
3642         /* Identify the connected charger types during startup */
3643         charger_status = ab8500_charger_detect_chargers(di, true);
3644         if (charger_status & AC_PW_CONN) {
3645                 di->ac.charger_connected = 1;
3646                 di->ac_conn = true;
3647                 ab8500_power_supply_changed(di, di->ac_chg.psy);
3648                 sysfs_notify(&di->ac_chg.psy->dev.kobj, NULL, "present");
3649         }
3650
3651         platform_set_drvdata(pdev, di);
3652
3653         /* Create something that will match the subdrivers when we bind */
3654         for (i = 0; i < ARRAY_SIZE(ab8500_charger_component_drivers); i++) {
3655                 struct device_driver *drv = &ab8500_charger_component_drivers[i]->driver;
3656                 struct device *p = NULL, *d;
3657
3658                 while ((d = platform_find_device_by_driver(p, drv))) {
3659                         put_device(p);
3660                         component_match_add(dev, &match,
3661                                             ab8500_charger_compare_dev, d);
3662                         p = d;
3663                 }
3664                 put_device(p);
3665         }
3666         if (!match) {
3667                 dev_err(dev, "no matching components\n");
3668                 ret = -ENODEV;
3669                 goto remove_ab8500_bm;
3670         }
3671         if (IS_ERR(match)) {
3672                 dev_err(dev, "could not create component match\n");
3673                 ret = PTR_ERR(match);
3674                 goto remove_ab8500_bm;
3675         }
3676
3677         /* Notifier for external charger enabling */
3678         if (!di->ac_chg.enabled)
3679                 blocking_notifier_chain_register(
3680                         &charger_notifier_list, &charger_nb);
3681
3682
3683         di->usb_phy = usb_get_phy(USB_PHY_TYPE_USB2);
3684         if (IS_ERR_OR_NULL(di->usb_phy)) {
3685                 dev_err(dev, "failed to get usb transceiver\n");
3686                 ret = -EINVAL;
3687                 goto out_charger_notifier;
3688         }
3689         di->nb.notifier_call = ab8500_charger_usb_notifier_call;
3690         ret = usb_register_notifier(di->usb_phy, &di->nb);
3691         if (ret) {
3692                 dev_err(dev, "failed to register usb notifier\n");
3693                 goto put_usb_phy;
3694         }
3695
3696
3697         ret = component_master_add_with_match(&pdev->dev,
3698                                               &ab8500_charger_comp_ops,
3699                                               match);
3700         if (ret) {
3701                 dev_err(dev, "failed to add component master\n");
3702                 goto free_notifier;
3703         }
3704
3705         return 0;
3706
3707 free_notifier:
3708         usb_unregister_notifier(di->usb_phy, &di->nb);
3709 put_usb_phy:
3710         usb_put_phy(di->usb_phy);
3711 out_charger_notifier:
3712         if (!di->ac_chg.enabled)
3713                 blocking_notifier_chain_unregister(
3714                         &charger_notifier_list, &charger_nb);
3715 remove_ab8500_bm:
3716         ab8500_bm_of_remove(di->usb_chg.psy, di->bm);
3717         return ret;
3718 }
3719
3720 static int ab8500_charger_remove(struct platform_device *pdev)
3721 {
3722         struct ab8500_charger *di = platform_get_drvdata(pdev);
3723
3724         component_master_del(&pdev->dev, &ab8500_charger_comp_ops);
3725
3726         usb_unregister_notifier(di->usb_phy, &di->nb);
3727         ab8500_bm_of_remove(di->usb_chg.psy, di->bm);
3728         usb_put_phy(di->usb_phy);
3729         if (!di->ac_chg.enabled)
3730                 blocking_notifier_chain_unregister(
3731                         &charger_notifier_list, &charger_nb);
3732
3733         return 0;
3734 }
3735
3736 static SIMPLE_DEV_PM_OPS(ab8500_charger_pm_ops, ab8500_charger_suspend, ab8500_charger_resume);
3737
3738 static const struct of_device_id ab8500_charger_match[] = {
3739         { .compatible = "stericsson,ab8500-charger", },
3740         { },
3741 };
3742 MODULE_DEVICE_TABLE(of, ab8500_charger_match);
3743
3744 static struct platform_driver ab8500_charger_driver = {
3745         .probe = ab8500_charger_probe,
3746         .remove = ab8500_charger_remove,
3747         .driver = {
3748                 .name = "ab8500-charger",
3749                 .of_match_table = ab8500_charger_match,
3750                 .pm = &ab8500_charger_pm_ops,
3751         },
3752 };
3753
3754 static int __init ab8500_charger_init(void)
3755 {
3756         int ret;
3757
3758         ret = platform_register_drivers(ab8500_charger_component_drivers,
3759                         ARRAY_SIZE(ab8500_charger_component_drivers));
3760         if (ret)
3761                 return ret;
3762
3763         return platform_driver_register(&ab8500_charger_driver);
3764 }
3765
3766 static void __exit ab8500_charger_exit(void)
3767 {
3768         platform_unregister_drivers(ab8500_charger_component_drivers,
3769                         ARRAY_SIZE(ab8500_charger_component_drivers));
3770         platform_driver_unregister(&ab8500_charger_driver);
3771 }
3772
3773 module_init(ab8500_charger_init);
3774 module_exit(ab8500_charger_exit);
3775
3776 MODULE_LICENSE("GPL v2");
3777 MODULE_AUTHOR("Johan Palsson, Karl Komierowski, Arun R Murthy");
3778 MODULE_ALIAS("platform:ab8500-charger");
3779 MODULE_DESCRIPTION("AB8500 charger management driver");