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           3800000
 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 interrupts
 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 structure
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 /**
1720  * ab8500_charger_usb_check_enable() - enable usb charging
1721  * @charger:    pointer to the ux500_charger structure
1722  * @vset_uv:    charging voltage in microvolt
1723  * @iset_ua:    charger output current in microampere
1724  *
1725  * Check if the VBUS charger has been disconnected and reconnected without
1726  * AB8500 rising an interrupt. Returns 0 on success.
1727  */
1728 static int ab8500_charger_usb_check_enable(struct ux500_charger *charger,
1729         int vset_uv, int iset_ua)
1730 {
1731         u8 usbch_ctrl1 = 0;
1732         int ret = 0;
1733
1734         struct ab8500_charger *di = to_ab8500_charger_usb_device_info(charger);
1735
1736         if (!di->usb.charger_connected)
1737                 return ret;
1738
1739         ret = abx500_get_register_interruptible(di->dev, AB8500_CHARGER,
1740                                 AB8500_USBCH_CTRL1_REG, &usbch_ctrl1);
1741         if (ret < 0) {
1742                 dev_err(di->dev, "ab8500 read failed %d\n", __LINE__);
1743                 return ret;
1744         }
1745         dev_dbg(di->dev, "USB charger ctrl: 0x%02x\n", usbch_ctrl1);
1746
1747         if (!(usbch_ctrl1 & USB_CH_ENA)) {
1748                 dev_info(di->dev, "Charging has been disabled abnormally and will be re-enabled\n");
1749
1750                 ret = abx500_mask_and_set_register_interruptible(di->dev,
1751                                         AB8500_CHARGER, AB8500_CHARGER_CTRL,
1752                                         DROP_COUNT_RESET, DROP_COUNT_RESET);
1753                 if (ret < 0) {
1754                         dev_err(di->dev, "ab8500 write failed %d\n", __LINE__);
1755                         return ret;
1756                 }
1757
1758                 ret = ab8500_charger_usb_en(&di->usb_chg, true, vset_uv, iset_ua);
1759                 if (ret < 0) {
1760                         dev_err(di->dev, "Failed to enable VBUS charger %d\n",
1761                                         __LINE__);
1762                         return ret;
1763                 }
1764         }
1765         return ret;
1766 }
1767
1768 /**
1769  * ab8500_charger_ac_check_enable() - enable usb charging
1770  * @charger:    pointer to the ux500_charger structure
1771  * @vset_uv:    charging voltage in microvolt
1772  * @iset_ua:    charger output current in micrompere
1773  *
1774  * Check if the AC charger has been disconnected and reconnected without
1775  * AB8500 rising an interrupt. Returns 0 on success.
1776  */
1777 static int ab8500_charger_ac_check_enable(struct ux500_charger *charger,
1778         int vset_uv, int iset_ua)
1779 {
1780         u8 mainch_ctrl1 = 0;
1781         int ret = 0;
1782
1783         struct ab8500_charger *di = to_ab8500_charger_ac_device_info(charger);
1784
1785         if (!di->ac.charger_connected)
1786                 return ret;
1787
1788         ret = abx500_get_register_interruptible(di->dev, AB8500_CHARGER,
1789                                 AB8500_MCH_CTRL1, &mainch_ctrl1);
1790         if (ret < 0) {
1791                 dev_err(di->dev, "ab8500 read failed %d\n", __LINE__);
1792                 return ret;
1793         }
1794         dev_dbg(di->dev, "AC charger ctrl: 0x%02x\n", mainch_ctrl1);
1795
1796         if (!(mainch_ctrl1 & MAIN_CH_ENA)) {
1797                 dev_info(di->dev, "Charging has been disabled abnormally and will be re-enabled\n");
1798
1799                 ret = abx500_mask_and_set_register_interruptible(di->dev,
1800                                         AB8500_CHARGER, AB8500_CHARGER_CTRL,
1801                                         DROP_COUNT_RESET, DROP_COUNT_RESET);
1802
1803                 if (ret < 0) {
1804                         dev_err(di->dev, "ab8500 write failed %d\n", __LINE__);
1805                         return ret;
1806                 }
1807
1808                 ret = ab8500_charger_ac_en(&di->usb_chg, true, vset_uv, iset_ua);
1809                 if (ret < 0) {
1810                         dev_err(di->dev, "failed to enable AC charger %d\n",
1811                                 __LINE__);
1812                         return ret;
1813                 }
1814         }
1815         return ret;
1816 }
1817
1818 /**
1819  * ab8500_charger_watchdog_kick() - kick charger watchdog
1820  * @di:         pointer to the ab8500_charger structure
1821  *
1822  * Kick charger watchdog
1823  * Returns error code in case of failure else 0(on success)
1824  */
1825 static int ab8500_charger_watchdog_kick(struct ux500_charger *charger)
1826 {
1827         int ret;
1828         struct ab8500_charger *di;
1829
1830         if (charger->psy->desc->type == POWER_SUPPLY_TYPE_MAINS)
1831                 di = to_ab8500_charger_ac_device_info(charger);
1832         else if (charger->psy->desc->type == POWER_SUPPLY_TYPE_USB)
1833                 di = to_ab8500_charger_usb_device_info(charger);
1834         else
1835                 return -ENXIO;
1836
1837         ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
1838                 AB8500_CHARG_WD_CTRL, CHARG_WD_KICK);
1839         if (ret)
1840                 dev_err(di->dev, "Failed to kick WD!\n");
1841
1842         return ret;
1843 }
1844
1845 /**
1846  * ab8500_charger_update_charger_current() - update charger current
1847  * @charger:            pointer to the ab8500_charger structure
1848  * @ich_out_ua:         desired output current in microampere
1849  *
1850  * Update the charger output current for the specified charger
1851  * Returns error code in case of failure else 0(on success)
1852  */
1853 static int ab8500_charger_update_charger_current(struct ux500_charger *charger,
1854                 int ich_out_ua)
1855 {
1856         int ret;
1857         struct ab8500_charger *di;
1858
1859         if (charger->psy->desc->type == POWER_SUPPLY_TYPE_MAINS)
1860                 di = to_ab8500_charger_ac_device_info(charger);
1861         else if (charger->psy->desc->type == POWER_SUPPLY_TYPE_USB)
1862                 di = to_ab8500_charger_usb_device_info(charger);
1863         else
1864                 return -ENXIO;
1865
1866         ret = ab8500_charger_set_output_curr(di, ich_out_ua);
1867         if (ret) {
1868                 dev_err(di->dev, "%s "
1869                         "Failed to set ChOutputCurentLevel\n",
1870                         __func__);
1871                 return ret;
1872         }
1873
1874         /* Reset the main and usb drop input current measurement counter */
1875         ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
1876                                 AB8500_CHARGER_CTRL, DROP_COUNT_RESET);
1877         if (ret) {
1878                 dev_err(di->dev, "%s write failed\n", __func__);
1879                 return ret;
1880         }
1881
1882         return ret;
1883 }
1884
1885 static int ab8500_charger_get_ext_psy_data(struct device *dev, void *data)
1886 {
1887         struct power_supply *psy;
1888         struct power_supply *ext = dev_get_drvdata(dev);
1889         const char **supplicants = (const char **)ext->supplied_to;
1890         struct ab8500_charger *di;
1891         union power_supply_propval ret;
1892         int j;
1893         struct ux500_charger *usb_chg;
1894
1895         usb_chg = (struct ux500_charger *)data;
1896         psy = usb_chg->psy;
1897
1898         di = to_ab8500_charger_usb_device_info(usb_chg);
1899
1900         /*
1901          * For all psy where the driver name appears in any supplied_to
1902          * in practice what we will find will always be "ab8500_fg" as
1903          * the fuel gauge is responsible of keeping track of VBAT.
1904          */
1905         j = match_string(supplicants, ext->num_supplicants, psy->desc->name);
1906         if (j < 0)
1907                 return 0;
1908
1909         /* Go through all properties for the psy */
1910         for (j = 0; j < ext->desc->num_properties; j++) {
1911                 enum power_supply_property prop;
1912                 prop = ext->desc->properties[j];
1913
1914                 if (power_supply_get_property(ext, prop, &ret))
1915                         continue;
1916
1917                 switch (prop) {
1918                 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
1919                         switch (ext->desc->type) {
1920                         case POWER_SUPPLY_TYPE_BATTERY:
1921                                 /* This will always be "ab8500_fg" */
1922                                 dev_dbg(di->dev, "get VBAT from %s\n",
1923                                         dev_name(&ext->dev));
1924                                 di->vbat = ret.intval;
1925                                 break;
1926                         default:
1927                                 break;
1928                         }
1929                         break;
1930                 default:
1931                         break;
1932                 }
1933         }
1934         return 0;
1935 }
1936
1937 /**
1938  * ab8500_charger_check_vbat_work() - keep vbus current within spec
1939  * @work        pointer to the work_struct structure
1940  *
1941  * Due to a asic bug it is necessary to lower the input current to the vbus
1942  * charger when charging with at some specific levels. This issue is only valid
1943  * for below a certain battery voltage. This function makes sure that
1944  * the allowed current limit isn't exceeded.
1945  */
1946 static void ab8500_charger_check_vbat_work(struct work_struct *work)
1947 {
1948         int t = 10;
1949         struct ab8500_charger *di = container_of(work,
1950                 struct ab8500_charger, check_vbat_work.work);
1951
1952         class_for_each_device(power_supply_class, NULL,
1953                               &di->usb_chg, ab8500_charger_get_ext_psy_data);
1954
1955         /* First run old_vbat is 0. */
1956         if (di->old_vbat == 0)
1957                 di->old_vbat = di->vbat;
1958
1959         if (!((di->old_vbat <= VBAT_TRESH_IP_CUR_RED &&
1960                 di->vbat <= VBAT_TRESH_IP_CUR_RED) ||
1961                 (di->old_vbat > VBAT_TRESH_IP_CUR_RED &&
1962                 di->vbat > VBAT_TRESH_IP_CUR_RED))) {
1963
1964                 dev_dbg(di->dev, "Vbat did cross threshold, curr: %d, new: %d,"
1965                         " old: %d\n", di->max_usb_in_curr.usb_type_max_ua,
1966                         di->vbat, di->old_vbat);
1967                 ab8500_charger_set_vbus_in_curr(di,
1968                                         di->max_usb_in_curr.usb_type_max_ua);
1969                 power_supply_changed(di->usb_chg.psy);
1970         }
1971
1972         di->old_vbat = di->vbat;
1973
1974         /*
1975          * No need to check the battery voltage every second when not close to
1976          * the threshold.
1977          */
1978         if (di->vbat < (VBAT_TRESH_IP_CUR_RED + 100000) &&
1979                 (di->vbat > (VBAT_TRESH_IP_CUR_RED - 100000)))
1980                         t = 1;
1981
1982         queue_delayed_work(di->charger_wq, &di->check_vbat_work, t * HZ);
1983 }
1984
1985 /**
1986  * ab8500_charger_check_hw_failure_work() - check main charger failure
1987  * @work:       pointer to the work_struct structure
1988  *
1989  * Work queue function for checking the main charger status
1990  */
1991 static void ab8500_charger_check_hw_failure_work(struct work_struct *work)
1992 {
1993         int ret;
1994         u8 reg_value;
1995
1996         struct ab8500_charger *di = container_of(work,
1997                 struct ab8500_charger, check_hw_failure_work.work);
1998
1999         /* Check if the status bits for HW failure is still active */
2000         if (di->flags.mainextchnotok) {
2001                 ret = abx500_get_register_interruptible(di->dev,
2002                         AB8500_CHARGER, AB8500_CH_STATUS2_REG, &reg_value);
2003                 if (ret < 0) {
2004                         dev_err(di->dev, "%s ab8500 read failed\n", __func__);
2005                         return;
2006                 }
2007                 if (!(reg_value & MAIN_CH_NOK)) {
2008                         di->flags.mainextchnotok = false;
2009                         ab8500_power_supply_changed(di, di->ac_chg.psy);
2010                 }
2011         }
2012         if (di->flags.vbus_ovv) {
2013                 ret = abx500_get_register_interruptible(di->dev,
2014                         AB8500_CHARGER, AB8500_CH_USBCH_STAT2_REG,
2015                         &reg_value);
2016                 if (ret < 0) {
2017                         dev_err(di->dev, "%s ab8500 read failed\n", __func__);
2018                         return;
2019                 }
2020                 if (!(reg_value & VBUS_OVV_TH)) {
2021                         di->flags.vbus_ovv = false;
2022                         ab8500_power_supply_changed(di, di->usb_chg.psy);
2023                 }
2024         }
2025         /* If we still have a failure, schedule a new check */
2026         if (di->flags.mainextchnotok || di->flags.vbus_ovv) {
2027                 queue_delayed_work(di->charger_wq,
2028                         &di->check_hw_failure_work, round_jiffies(HZ));
2029         }
2030 }
2031
2032 /**
2033  * ab8500_charger_kick_watchdog_work() - kick the watchdog
2034  * @work:       pointer to the work_struct structure
2035  *
2036  * Work queue function for kicking the charger watchdog.
2037  *
2038  * For ABB revision 1.0 and 1.1 there is a bug in the watchdog
2039  * logic. That means we have to continuously kick the charger
2040  * watchdog even when no charger is connected. This is only
2041  * valid once the AC charger has been enabled. This is
2042  * a bug that is not handled by the algorithm and the
2043  * watchdog have to be kicked by the charger driver
2044  * when the AC charger is disabled
2045  */
2046 static void ab8500_charger_kick_watchdog_work(struct work_struct *work)
2047 {
2048         int ret;
2049
2050         struct ab8500_charger *di = container_of(work,
2051                 struct ab8500_charger, kick_wd_work.work);
2052
2053         ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
2054                 AB8500_CHARG_WD_CTRL, CHARG_WD_KICK);
2055         if (ret)
2056                 dev_err(di->dev, "Failed to kick WD!\n");
2057
2058         /* Schedule a new watchdog kick */
2059         queue_delayed_work(di->charger_wq,
2060                 &di->kick_wd_work, round_jiffies(WD_KICK_INTERVAL));
2061 }
2062
2063 /**
2064  * ab8500_charger_ac_work() - work to get and set main charger status
2065  * @work:       pointer to the work_struct structure
2066  *
2067  * Work queue function for checking the main charger status
2068  */
2069 static void ab8500_charger_ac_work(struct work_struct *work)
2070 {
2071         int ret;
2072
2073         struct ab8500_charger *di = container_of(work,
2074                 struct ab8500_charger, ac_work);
2075
2076         /*
2077          * Since we can't be sure that the events are received
2078          * synchronously, we have the check if the main charger is
2079          * connected by reading the status register
2080          */
2081         ret = ab8500_charger_detect_chargers(di, false);
2082         if (ret < 0)
2083                 return;
2084
2085         if (ret & AC_PW_CONN) {
2086                 di->ac.charger_connected = 1;
2087                 di->ac_conn = true;
2088         } else {
2089                 di->ac.charger_connected = 0;
2090         }
2091
2092         ab8500_power_supply_changed(di, di->ac_chg.psy);
2093         sysfs_notify(&di->ac_chg.psy->dev.kobj, NULL, "present");
2094 }
2095
2096 static void ab8500_charger_usb_attached_work(struct work_struct *work)
2097 {
2098         struct ab8500_charger *di = container_of(work,
2099                                                  struct ab8500_charger,
2100                                                  usb_charger_attached_work.work);
2101         int usbch = (USB_CH_VBUSDROP | USB_CH_VBUSDETDBNC);
2102         int ret, i;
2103         u8 statval;
2104
2105         for (i = 0; i < 10; i++) {
2106                 ret = abx500_get_register_interruptible(di->dev,
2107                                                         AB8500_CHARGER,
2108                                                         AB8500_CH_USBCH_STAT1_REG,
2109                                                         &statval);
2110                 if (ret < 0) {
2111                         dev_err(di->dev, "ab8500 read failed %d\n", __LINE__);
2112                         goto reschedule;
2113                 }
2114                 if ((statval & usbch) != usbch)
2115                         goto reschedule;
2116
2117                 msleep(CHARGER_STATUS_POLL);
2118         }
2119
2120         ab8500_charger_usb_en(&di->usb_chg, 0, 0, 0);
2121
2122         mutex_lock(&di->charger_attached_mutex);
2123         mutex_unlock(&di->charger_attached_mutex);
2124
2125         return;
2126
2127 reschedule:
2128         queue_delayed_work(di->charger_wq,
2129                            &di->usb_charger_attached_work,
2130                            HZ);
2131 }
2132
2133 static void ab8500_charger_ac_attached_work(struct work_struct *work)
2134 {
2135
2136         struct ab8500_charger *di = container_of(work,
2137                                                  struct ab8500_charger,
2138                                                  ac_charger_attached_work.work);
2139         int mainch = (MAIN_CH_STATUS2_MAINCHGDROP |
2140                       MAIN_CH_STATUS2_MAINCHARGERDETDBNC);
2141         int ret, i;
2142         u8 statval;
2143
2144         for (i = 0; i < 10; i++) {
2145                 ret = abx500_get_register_interruptible(di->dev,
2146                                                         AB8500_CHARGER,
2147                                                         AB8500_CH_STATUS2_REG,
2148                                                         &statval);
2149                 if (ret < 0) {
2150                         dev_err(di->dev, "ab8500 read failed %d\n", __LINE__);
2151                         goto reschedule;
2152                 }
2153
2154                 if ((statval & mainch) != mainch)
2155                         goto reschedule;
2156
2157                 msleep(CHARGER_STATUS_POLL);
2158         }
2159
2160         ab8500_charger_ac_en(&di->ac_chg, 0, 0, 0);
2161         queue_work(di->charger_wq, &di->ac_work);
2162
2163         mutex_lock(&di->charger_attached_mutex);
2164         mutex_unlock(&di->charger_attached_mutex);
2165
2166         return;
2167
2168 reschedule:
2169         queue_delayed_work(di->charger_wq,
2170                            &di->ac_charger_attached_work,
2171                            HZ);
2172 }
2173
2174 /**
2175  * ab8500_charger_detect_usb_type_work() - work to detect USB type
2176  * @work:       Pointer to the work_struct structure
2177  *
2178  * Detect the type of USB plugged
2179  */
2180 static void ab8500_charger_detect_usb_type_work(struct work_struct *work)
2181 {
2182         int ret;
2183
2184         struct ab8500_charger *di = container_of(work,
2185                 struct ab8500_charger, detect_usb_type_work);
2186
2187         /*
2188          * Since we can't be sure that the events are received
2189          * synchronously, we have the check if is
2190          * connected by reading the status register
2191          */
2192         ret = ab8500_charger_detect_chargers(di, false);
2193         if (ret < 0)
2194                 return;
2195
2196         if (!(ret & USB_PW_CONN)) {
2197                 dev_dbg(di->dev, "%s di->vbus_detected = false\n", __func__);
2198                 di->vbus_detected = false;
2199                 ab8500_charger_set_usb_connected(di, false);
2200                 ab8500_power_supply_changed(di, di->usb_chg.psy);
2201         } else {
2202                 dev_dbg(di->dev, "%s di->vbus_detected = true\n", __func__);
2203                 di->vbus_detected = true;
2204
2205                 if (is_ab8500_1p1_or_earlier(di->parent)) {
2206                         ret = ab8500_charger_detect_usb_type(di);
2207                         if (!ret) {
2208                                 ab8500_charger_set_usb_connected(di, true);
2209                                 ab8500_power_supply_changed(di,
2210                                                             di->usb_chg.psy);
2211                         }
2212                 } else {
2213                         /*
2214                          * For ABB cut2.0 and onwards we have an IRQ,
2215                          * USB_LINK_STATUS that will be triggered when the USB
2216                          * link status changes. The exception is USB connected
2217                          * during startup. Then we don't get a
2218                          * USB_LINK_STATUS IRQ
2219                          */
2220                         if (di->vbus_detected_start) {
2221                                 di->vbus_detected_start = false;
2222                                 ret = ab8500_charger_detect_usb_type(di);
2223                                 if (!ret) {
2224                                         ab8500_charger_set_usb_connected(di,
2225                                                 true);
2226                                         ab8500_power_supply_changed(di,
2227                                                 di->usb_chg.psy);
2228                                 }
2229                         }
2230                 }
2231         }
2232 }
2233
2234 /**
2235  * ab8500_charger_usb_link_attach_work() - work to detect USB type
2236  * @work:       pointer to the work_struct structure
2237  *
2238  * Detect the type of USB plugged
2239  */
2240 static void ab8500_charger_usb_link_attach_work(struct work_struct *work)
2241 {
2242         struct ab8500_charger *di =
2243                 container_of(work, struct ab8500_charger, attach_work.work);
2244         int ret;
2245
2246         /* Update maximum input current if USB enumeration is not detected */
2247         if (!di->usb.charger_online) {
2248                 ret = ab8500_charger_set_vbus_in_curr(di,
2249                                         di->max_usb_in_curr.usb_type_max_ua);
2250                 if (ret)
2251                         return;
2252         }
2253
2254         ab8500_charger_set_usb_connected(di, true);
2255         ab8500_power_supply_changed(di, di->usb_chg.psy);
2256 }
2257
2258 /**
2259  * ab8500_charger_usb_link_status_work() - work to detect USB type
2260  * @work:       pointer to the work_struct structure
2261  *
2262  * Detect the type of USB plugged
2263  */
2264 static void ab8500_charger_usb_link_status_work(struct work_struct *work)
2265 {
2266         int detected_chargers;
2267         int ret;
2268         u8 val;
2269         u8 link_status;
2270
2271         struct ab8500_charger *di = container_of(work,
2272                 struct ab8500_charger, usb_link_status_work);
2273
2274         /*
2275          * Since we can't be sure that the events are received
2276          * synchronously, we have the check if  is
2277          * connected by reading the status register
2278          */
2279         detected_chargers = ab8500_charger_detect_chargers(di, false);
2280         if (detected_chargers < 0)
2281                 return;
2282
2283         /*
2284          * Some chargers that breaks the USB spec is
2285          * identified as invalid by AB8500 and it refuse
2286          * to start the charging process. but by jumping
2287          * through a few hoops it can be forced to start.
2288          */
2289         if (is_ab8500(di->parent))
2290                 ret = abx500_get_register_interruptible(di->dev, AB8500_USB,
2291                                         AB8500_USB_LINE_STAT_REG, &val);
2292         else
2293                 ret = abx500_get_register_interruptible(di->dev, AB8500_USB,
2294                                         AB8500_USB_LINK1_STAT_REG, &val);
2295
2296         if (ret >= 0)
2297                 dev_dbg(di->dev, "UsbLineStatus register = 0x%02x\n", val);
2298         else
2299                 dev_dbg(di->dev, "Error reading USB link status\n");
2300
2301         if (is_ab8500(di->parent))
2302                 link_status = AB8500_USB_LINK_STATUS;
2303         else
2304                 link_status = AB8505_USB_LINK_STATUS;
2305
2306         if (detected_chargers & USB_PW_CONN) {
2307                 if (((val & link_status) >> USB_LINK_STATUS_SHIFT) ==
2308                                 USB_STAT_NOT_VALID_LINK &&
2309                                 di->invalid_charger_detect_state == 0) {
2310                         dev_dbg(di->dev,
2311                                         "Invalid charger detected, state= 0\n");
2312                         /*Enable charger*/
2313                         abx500_mask_and_set_register_interruptible(di->dev,
2314                                         AB8500_CHARGER, AB8500_USBCH_CTRL1_REG,
2315                                         USB_CH_ENA, USB_CH_ENA);
2316                         /*Enable charger detection*/
2317                         abx500_mask_and_set_register_interruptible(di->dev,
2318                                         AB8500_USB, AB8500_USB_LINE_CTRL2_REG,
2319                                         USB_CH_DET, USB_CH_DET);
2320                         di->invalid_charger_detect_state = 1;
2321                         /*exit and wait for new link status interrupt.*/
2322                         return;
2323
2324                 }
2325                 if (di->invalid_charger_detect_state == 1) {
2326                         dev_dbg(di->dev,
2327                                         "Invalid charger detected, state= 1\n");
2328                         /*Stop charger detection*/
2329                         abx500_mask_and_set_register_interruptible(di->dev,
2330                                         AB8500_USB, AB8500_USB_LINE_CTRL2_REG,
2331                                         USB_CH_DET, 0x00);
2332                         /*Check link status*/
2333                         if (is_ab8500(di->parent))
2334                                 ret = abx500_get_register_interruptible(di->dev,
2335                                         AB8500_USB, AB8500_USB_LINE_STAT_REG,
2336                                         &val);
2337                         else
2338                                 ret = abx500_get_register_interruptible(di->dev,
2339                                         AB8500_USB, AB8500_USB_LINK1_STAT_REG,
2340                                         &val);
2341
2342                         dev_dbg(di->dev, "USB link status= 0x%02x\n",
2343                                 (val & link_status) >> USB_LINK_STATUS_SHIFT);
2344                         di->invalid_charger_detect_state = 2;
2345                 }
2346         } else {
2347                 di->invalid_charger_detect_state = 0;
2348         }
2349
2350         if (!(detected_chargers & USB_PW_CONN)) {
2351                 di->vbus_detected = false;
2352                 ab8500_charger_set_usb_connected(di, false);
2353                 ab8500_power_supply_changed(di, di->usb_chg.psy);
2354                 return;
2355         }
2356
2357         dev_dbg(di->dev,"%s di->vbus_detected = true\n",__func__);
2358         di->vbus_detected = true;
2359         ret = ab8500_charger_read_usb_type(di);
2360         if (ret) {
2361                 if (ret == -ENXIO) {
2362                         /* No valid charger type detected */
2363                         ab8500_charger_set_usb_connected(di, false);
2364                         ab8500_power_supply_changed(di, di->usb_chg.psy);
2365                 }
2366                 return;
2367         }
2368
2369         if (di->usb_device_is_unrecognised) {
2370                 dev_dbg(di->dev,
2371                         "Potential Legacy Charger device. "
2372                         "Delay work for %d msec for USB enum "
2373                         "to finish",
2374                         WAIT_ACA_RID_ENUMERATION);
2375                 queue_delayed_work(di->charger_wq,
2376                                    &di->attach_work,
2377                                    msecs_to_jiffies(WAIT_ACA_RID_ENUMERATION));
2378         } else if (di->is_aca_rid == 1) {
2379                 /* Only wait once */
2380                 di->is_aca_rid++;
2381                 dev_dbg(di->dev,
2382                         "%s Wait %d msec for USB enum to finish",
2383                         __func__, WAIT_ACA_RID_ENUMERATION);
2384                 queue_delayed_work(di->charger_wq,
2385                                    &di->attach_work,
2386                                    msecs_to_jiffies(WAIT_ACA_RID_ENUMERATION));
2387         } else {
2388                 queue_delayed_work(di->charger_wq,
2389                                    &di->attach_work,
2390                                    0);
2391         }
2392 }
2393
2394 static void ab8500_charger_usb_state_changed_work(struct work_struct *work)
2395 {
2396         int ret;
2397         unsigned long flags;
2398
2399         struct ab8500_charger *di = container_of(work,
2400                 struct ab8500_charger, usb_state_changed_work.work);
2401
2402         if (!di->vbus_detected) {
2403                 dev_dbg(di->dev,
2404                         "%s !di->vbus_detected\n",
2405                         __func__);
2406                 return;
2407         }
2408
2409         spin_lock_irqsave(&di->usb_state.usb_lock, flags);
2410         di->usb_state.state = di->usb_state.state_tmp;
2411         di->usb_state.usb_current_ua = di->usb_state.usb_current_tmp_ua;
2412         spin_unlock_irqrestore(&di->usb_state.usb_lock, flags);
2413
2414         dev_dbg(di->dev, "%s USB state: 0x%02x uA: %d\n",
2415                 __func__, di->usb_state.state, di->usb_state.usb_current_ua);
2416
2417         switch (di->usb_state.state) {
2418         case AB8500_BM_USB_STATE_RESET_HS:
2419         case AB8500_BM_USB_STATE_RESET_FS:
2420         case AB8500_BM_USB_STATE_SUSPEND:
2421         case AB8500_BM_USB_STATE_MAX:
2422                 ab8500_charger_set_usb_connected(di, false);
2423                 ab8500_power_supply_changed(di, di->usb_chg.psy);
2424                 break;
2425
2426         case AB8500_BM_USB_STATE_RESUME:
2427                 /*
2428                  * when suspend->resume there should be delay
2429                  * of 1sec for enabling charging
2430                  */
2431                 msleep(1000);
2432                 fallthrough;
2433         case AB8500_BM_USB_STATE_CONFIGURED:
2434                 /*
2435                  * USB is configured, enable charging with the charging
2436                  * input current obtained from USB driver
2437                  */
2438                 if (!ab8500_charger_get_usb_cur(di)) {
2439                         /* Update maximum input current */
2440                         ret = ab8500_charger_set_vbus_in_curr(di,
2441                                         di->max_usb_in_curr.usb_type_max_ua);
2442                         if (ret)
2443                                 return;
2444
2445                         ab8500_charger_set_usb_connected(di, true);
2446                         ab8500_power_supply_changed(di, di->usb_chg.psy);
2447                 }
2448                 break;
2449
2450         default:
2451                 break;
2452         }
2453 }
2454
2455 /**
2456  * ab8500_charger_check_usbchargernotok_work() - check USB chg not ok status
2457  * @work:       pointer to the work_struct structure
2458  *
2459  * Work queue function for checking the USB charger Not OK status
2460  */
2461 static void ab8500_charger_check_usbchargernotok_work(struct work_struct *work)
2462 {
2463         int ret;
2464         u8 reg_value;
2465         bool prev_status;
2466
2467         struct ab8500_charger *di = container_of(work,
2468                 struct ab8500_charger, check_usbchgnotok_work.work);
2469
2470         /* Check if the status bit for usbchargernotok is still active */
2471         ret = abx500_get_register_interruptible(di->dev,
2472                 AB8500_CHARGER, AB8500_CH_USBCH_STAT2_REG, &reg_value);
2473         if (ret < 0) {
2474                 dev_err(di->dev, "%s ab8500 read failed\n", __func__);
2475                 return;
2476         }
2477         prev_status = di->flags.usbchargernotok;
2478
2479         if (reg_value & VBUS_CH_NOK) {
2480                 di->flags.usbchargernotok = true;
2481                 /* Check again in 1sec */
2482                 queue_delayed_work(di->charger_wq,
2483                         &di->check_usbchgnotok_work, HZ);
2484         } else {
2485                 di->flags.usbchargernotok = false;
2486                 di->flags.vbus_collapse = false;
2487         }
2488
2489         if (prev_status != di->flags.usbchargernotok)
2490                 ab8500_power_supply_changed(di, di->usb_chg.psy);
2491 }
2492
2493 /**
2494  * ab8500_charger_check_main_thermal_prot_work() - check main thermal status
2495  * @work:       pointer to the work_struct structure
2496  *
2497  * Work queue function for checking the Main thermal prot status
2498  */
2499 static void ab8500_charger_check_main_thermal_prot_work(
2500         struct work_struct *work)
2501 {
2502         int ret;
2503         u8 reg_value;
2504
2505         struct ab8500_charger *di = container_of(work,
2506                 struct ab8500_charger, check_main_thermal_prot_work);
2507
2508         /* Check if the status bit for main_thermal_prot is still active */
2509         ret = abx500_get_register_interruptible(di->dev,
2510                 AB8500_CHARGER, AB8500_CH_STATUS2_REG, &reg_value);
2511         if (ret < 0) {
2512                 dev_err(di->dev, "%s ab8500 read failed\n", __func__);
2513                 return;
2514         }
2515         if (reg_value & MAIN_CH_TH_PROT)
2516                 di->flags.main_thermal_prot = true;
2517         else
2518                 di->flags.main_thermal_prot = false;
2519
2520         ab8500_power_supply_changed(di, di->ac_chg.psy);
2521 }
2522
2523 /**
2524  * ab8500_charger_check_usb_thermal_prot_work() - check usb thermal status
2525  * @work:       pointer to the work_struct structure
2526  *
2527  * Work queue function for checking the USB thermal prot status
2528  */
2529 static void ab8500_charger_check_usb_thermal_prot_work(
2530         struct work_struct *work)
2531 {
2532         int ret;
2533         u8 reg_value;
2534
2535         struct ab8500_charger *di = container_of(work,
2536                 struct ab8500_charger, check_usb_thermal_prot_work);
2537
2538         /* Check if the status bit for usb_thermal_prot is still active */
2539         ret = abx500_get_register_interruptible(di->dev,
2540                 AB8500_CHARGER, AB8500_CH_USBCH_STAT2_REG, &reg_value);
2541         if (ret < 0) {
2542                 dev_err(di->dev, "%s ab8500 read failed\n", __func__);
2543                 return;
2544         }
2545         if (reg_value & USB_CH_TH_PROT)
2546                 di->flags.usb_thermal_prot = true;
2547         else
2548                 di->flags.usb_thermal_prot = false;
2549
2550         ab8500_power_supply_changed(di, di->usb_chg.psy);
2551 }
2552
2553 /**
2554  * ab8500_charger_mainchunplugdet_handler() - main charger unplugged
2555  * @irq:       interrupt number
2556  * @_di:       pointer to the ab8500_charger structure
2557  *
2558  * Returns IRQ status(IRQ_HANDLED)
2559  */
2560 static irqreturn_t ab8500_charger_mainchunplugdet_handler(int irq, void *_di)
2561 {
2562         struct ab8500_charger *di = _di;
2563
2564         dev_dbg(di->dev, "Main charger unplugged\n");
2565         queue_work(di->charger_wq, &di->ac_work);
2566
2567         cancel_delayed_work_sync(&di->ac_charger_attached_work);
2568         mutex_lock(&di->charger_attached_mutex);
2569         mutex_unlock(&di->charger_attached_mutex);
2570
2571         return IRQ_HANDLED;
2572 }
2573
2574 /**
2575  * ab8500_charger_mainchplugdet_handler() - main charger plugged
2576  * @irq:       interrupt number
2577  * @_di:       pointer to the ab8500_charger structure
2578  *
2579  * Returns IRQ status(IRQ_HANDLED)
2580  */
2581 static irqreturn_t ab8500_charger_mainchplugdet_handler(int irq, void *_di)
2582 {
2583         struct ab8500_charger *di = _di;
2584
2585         dev_dbg(di->dev, "Main charger plugged\n");
2586         queue_work(di->charger_wq, &di->ac_work);
2587
2588         mutex_lock(&di->charger_attached_mutex);
2589         mutex_unlock(&di->charger_attached_mutex);
2590
2591         if (is_ab8500(di->parent))
2592                 queue_delayed_work(di->charger_wq,
2593                            &di->ac_charger_attached_work,
2594                            HZ);
2595         return IRQ_HANDLED;
2596 }
2597
2598 /**
2599  * ab8500_charger_mainextchnotok_handler() - main charger not ok
2600  * @irq:       interrupt number
2601  * @_di:       pointer to the ab8500_charger structure
2602  *
2603  * Returns IRQ status(IRQ_HANDLED)
2604  */
2605 static irqreturn_t ab8500_charger_mainextchnotok_handler(int irq, void *_di)
2606 {
2607         struct ab8500_charger *di = _di;
2608
2609         dev_dbg(di->dev, "Main charger not ok\n");
2610         di->flags.mainextchnotok = true;
2611         ab8500_power_supply_changed(di, di->ac_chg.psy);
2612
2613         /* Schedule a new HW failure check */
2614         queue_delayed_work(di->charger_wq, &di->check_hw_failure_work, 0);
2615
2616         return IRQ_HANDLED;
2617 }
2618
2619 /**
2620  * ab8500_charger_mainchthprotr_handler() - Die temp is above main charger
2621  * thermal protection threshold
2622  * @irq:       interrupt number
2623  * @_di:       pointer to the ab8500_charger structure
2624  *
2625  * Returns IRQ status(IRQ_HANDLED)
2626  */
2627 static irqreturn_t ab8500_charger_mainchthprotr_handler(int irq, void *_di)
2628 {
2629         struct ab8500_charger *di = _di;
2630
2631         dev_dbg(di->dev,
2632                 "Die temp above Main charger thermal protection threshold\n");
2633         queue_work(di->charger_wq, &di->check_main_thermal_prot_work);
2634
2635         return IRQ_HANDLED;
2636 }
2637
2638 /**
2639  * ab8500_charger_mainchthprotf_handler() - Die temp is below main charger
2640  * thermal protection threshold
2641  * @irq:       interrupt number
2642  * @_di:       pointer to the ab8500_charger structure
2643  *
2644  * Returns IRQ status(IRQ_HANDLED)
2645  */
2646 static irqreturn_t ab8500_charger_mainchthprotf_handler(int irq, void *_di)
2647 {
2648         struct ab8500_charger *di = _di;
2649
2650         dev_dbg(di->dev,
2651                 "Die temp ok for Main charger thermal protection threshold\n");
2652         queue_work(di->charger_wq, &di->check_main_thermal_prot_work);
2653
2654         return IRQ_HANDLED;
2655 }
2656
2657 static void ab8500_charger_vbus_drop_end_work(struct work_struct *work)
2658 {
2659         struct ab8500_charger *di = container_of(work,
2660                 struct ab8500_charger, vbus_drop_end_work.work);
2661         int ret, curr_ua;
2662         u8 reg_value;
2663
2664         di->flags.vbus_drop_end = false;
2665
2666         /* Reset the drop counter */
2667         abx500_set_register_interruptible(di->dev,
2668                                   AB8500_CHARGER, AB8500_CHARGER_CTRL, 0x01);
2669
2670         ret = abx500_get_register_interruptible(di->dev, AB8500_CHARGER,
2671                         AB8500_CH_USBCH_STAT2_REG, &reg_value);
2672         if (ret < 0) {
2673                 dev_err(di->dev, "%s read failed\n", __func__);
2674                 return;
2675         }
2676
2677         curr_ua = ab8500_charge_input_curr_map[
2678                 reg_value >> AUTO_VBUS_IN_CURR_LIM_SHIFT];
2679
2680         if (di->max_usb_in_curr.calculated_max_ua != curr_ua) {
2681                 /* USB source is collapsing */
2682                 di->max_usb_in_curr.calculated_max_ua = curr_ua;
2683                 dev_dbg(di->dev,
2684                          "VBUS input current limiting to %d uA\n",
2685                          di->max_usb_in_curr.calculated_max_ua);
2686         } else {
2687                 /*
2688                  * USB source can not give more than this amount.
2689                  * Taking more will collapse the source.
2690                  */
2691                 di->max_usb_in_curr.set_max_ua =
2692                         di->max_usb_in_curr.calculated_max_ua;
2693                 dev_dbg(di->dev,
2694                          "VBUS input current limited to %d uA\n",
2695                          di->max_usb_in_curr.set_max_ua);
2696         }
2697
2698         if (di->usb.charger_connected)
2699                 ab8500_charger_set_vbus_in_curr(di,
2700                                         di->max_usb_in_curr.usb_type_max_ua);
2701 }
2702
2703 /**
2704  * ab8500_charger_vbusdetf_handler() - VBUS falling detected
2705  * @irq:       interrupt number
2706  * @_di:       pointer to the ab8500_charger structure
2707  *
2708  * Returns IRQ status(IRQ_HANDLED)
2709  */
2710 static irqreturn_t ab8500_charger_vbusdetf_handler(int irq, void *_di)
2711 {
2712         struct ab8500_charger *di = _di;
2713
2714         di->vbus_detected = false;
2715         dev_dbg(di->dev, "VBUS falling detected\n");
2716         queue_work(di->charger_wq, &di->detect_usb_type_work);
2717
2718         return IRQ_HANDLED;
2719 }
2720
2721 /**
2722  * ab8500_charger_vbusdetr_handler() - VBUS rising detected
2723  * @irq:       interrupt number
2724  * @_di:       pointer to the ab8500_charger structure
2725  *
2726  * Returns IRQ status(IRQ_HANDLED)
2727  */
2728 static irqreturn_t ab8500_charger_vbusdetr_handler(int irq, void *_di)
2729 {
2730         struct ab8500_charger *di = _di;
2731
2732         di->vbus_detected = true;
2733         dev_dbg(di->dev, "VBUS rising detected\n");
2734
2735         queue_work(di->charger_wq, &di->detect_usb_type_work);
2736
2737         return IRQ_HANDLED;
2738 }
2739
2740 /**
2741  * ab8500_charger_usblinkstatus_handler() - USB link status has changed
2742  * @irq:       interrupt number
2743  * @_di:       pointer to the ab8500_charger structure
2744  *
2745  * Returns IRQ status(IRQ_HANDLED)
2746  */
2747 static irqreturn_t ab8500_charger_usblinkstatus_handler(int irq, void *_di)
2748 {
2749         struct ab8500_charger *di = _di;
2750
2751         dev_dbg(di->dev, "USB link status changed\n");
2752
2753         queue_work(di->charger_wq, &di->usb_link_status_work);
2754
2755         return IRQ_HANDLED;
2756 }
2757
2758 /**
2759  * ab8500_charger_usbchthprotr_handler() - Die temp is above usb charger
2760  * thermal protection threshold
2761  * @irq:       interrupt number
2762  * @_di:       pointer to the ab8500_charger structure
2763  *
2764  * Returns IRQ status(IRQ_HANDLED)
2765  */
2766 static irqreturn_t ab8500_charger_usbchthprotr_handler(int irq, void *_di)
2767 {
2768         struct ab8500_charger *di = _di;
2769
2770         dev_dbg(di->dev,
2771                 "Die temp above USB charger thermal protection threshold\n");
2772         queue_work(di->charger_wq, &di->check_usb_thermal_prot_work);
2773
2774         return IRQ_HANDLED;
2775 }
2776
2777 /**
2778  * ab8500_charger_usbchthprotf_handler() - Die temp is below usb charger
2779  * thermal protection threshold
2780  * @irq:       interrupt number
2781  * @_di:       pointer to the ab8500_charger structure
2782  *
2783  * Returns IRQ status(IRQ_HANDLED)
2784  */
2785 static irqreturn_t ab8500_charger_usbchthprotf_handler(int irq, void *_di)
2786 {
2787         struct ab8500_charger *di = _di;
2788
2789         dev_dbg(di->dev,
2790                 "Die temp ok for USB charger thermal protection threshold\n");
2791         queue_work(di->charger_wq, &di->check_usb_thermal_prot_work);
2792
2793         return IRQ_HANDLED;
2794 }
2795
2796 /**
2797  * ab8500_charger_usbchargernotokr_handler() - USB charger not ok detected
2798  * @irq:       interrupt number
2799  * @_di:       pointer to the ab8500_charger structure
2800  *
2801  * Returns IRQ status(IRQ_HANDLED)
2802  */
2803 static irqreturn_t ab8500_charger_usbchargernotokr_handler(int irq, void *_di)
2804 {
2805         struct ab8500_charger *di = _di;
2806
2807         dev_dbg(di->dev, "Not allowed USB charger detected\n");
2808         queue_delayed_work(di->charger_wq, &di->check_usbchgnotok_work, 0);
2809
2810         return IRQ_HANDLED;
2811 }
2812
2813 /**
2814  * ab8500_charger_chwdexp_handler() - Charger watchdog expired
2815  * @irq:       interrupt number
2816  * @_di:       pointer to the ab8500_charger structure
2817  *
2818  * Returns IRQ status(IRQ_HANDLED)
2819  */
2820 static irqreturn_t ab8500_charger_chwdexp_handler(int irq, void *_di)
2821 {
2822         struct ab8500_charger *di = _di;
2823
2824         dev_dbg(di->dev, "Charger watchdog expired\n");
2825
2826         /*
2827          * The charger that was online when the watchdog expired
2828          * needs to be restarted for charging to start again
2829          */
2830         if (di->ac.charger_online) {
2831                 di->ac.wd_expired = true;
2832                 ab8500_power_supply_changed(di, di->ac_chg.psy);
2833         }
2834         if (di->usb.charger_online) {
2835                 di->usb.wd_expired = true;
2836                 ab8500_power_supply_changed(di, di->usb_chg.psy);
2837         }
2838
2839         return IRQ_HANDLED;
2840 }
2841
2842 /**
2843  * ab8500_charger_vbuschdropend_handler() - VBUS drop removed
2844  * @irq:       interrupt number
2845  * @_di:       pointer to the ab8500_charger structure
2846  *
2847  * Returns IRQ status(IRQ_HANDLED)
2848  */
2849 static irqreturn_t ab8500_charger_vbuschdropend_handler(int irq, void *_di)
2850 {
2851         struct ab8500_charger *di = _di;
2852
2853         dev_dbg(di->dev, "VBUS charger drop ended\n");
2854         di->flags.vbus_drop_end = true;
2855
2856         /*
2857          * VBUS might have dropped due to bad connection.
2858          * Schedule a new input limit set to the value SW requests.
2859          */
2860         queue_delayed_work(di->charger_wq, &di->vbus_drop_end_work,
2861                            round_jiffies(VBUS_IN_CURR_LIM_RETRY_SET_TIME * HZ));
2862
2863         return IRQ_HANDLED;
2864 }
2865
2866 /**
2867  * ab8500_charger_vbusovv_handler() - VBUS overvoltage detected
2868  * @irq:       interrupt number
2869  * @_di:       pointer to the ab8500_charger structure
2870  *
2871  * Returns IRQ status(IRQ_HANDLED)
2872  */
2873 static irqreturn_t ab8500_charger_vbusovv_handler(int irq, void *_di)
2874 {
2875         struct ab8500_charger *di = _di;
2876
2877         dev_dbg(di->dev, "VBUS overvoltage detected\n");
2878         di->flags.vbus_ovv = true;
2879         ab8500_power_supply_changed(di, di->usb_chg.psy);
2880
2881         /* Schedule a new HW failure check */
2882         queue_delayed_work(di->charger_wq, &di->check_hw_failure_work, 0);
2883
2884         return IRQ_HANDLED;
2885 }
2886
2887 /**
2888  * ab8500_charger_ac_get_property() - get the ac/mains properties
2889  * @psy:       pointer to the power_supply structure
2890  * @psp:       pointer to the power_supply_property structure
2891  * @val:       pointer to the power_supply_propval union
2892  *
2893  * This function gets called when an application tries to get the ac/mains
2894  * properties by reading the sysfs files.
2895  * AC/Mains properties are online, present and voltage.
2896  * online:     ac/mains charging is in progress or not
2897  * present:    presence of the ac/mains
2898  * voltage:    AC/Mains voltage
2899  * Returns error code in case of failure else 0(on success)
2900  */
2901 static int ab8500_charger_ac_get_property(struct power_supply *psy,
2902         enum power_supply_property psp,
2903         union power_supply_propval *val)
2904 {
2905         struct ab8500_charger *di;
2906         int ret;
2907
2908         di = to_ab8500_charger_ac_device_info(psy_to_ux500_charger(psy));
2909
2910         switch (psp) {
2911         case POWER_SUPPLY_PROP_HEALTH:
2912                 if (di->flags.mainextchnotok)
2913                         val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
2914                 else if (di->ac.wd_expired || di->usb.wd_expired)
2915                         val->intval = POWER_SUPPLY_HEALTH_DEAD;
2916                 else if (di->flags.main_thermal_prot)
2917                         val->intval = POWER_SUPPLY_HEALTH_OVERHEAT;
2918                 else
2919                         val->intval = POWER_SUPPLY_HEALTH_GOOD;
2920                 break;
2921         case POWER_SUPPLY_PROP_ONLINE:
2922                 val->intval = di->ac.charger_online;
2923                 break;
2924         case POWER_SUPPLY_PROP_PRESENT:
2925                 val->intval = di->ac.charger_connected;
2926                 break;
2927         case POWER_SUPPLY_PROP_VOLTAGE_NOW:
2928                 ret = ab8500_charger_get_ac_voltage(di);
2929                 if (ret >= 0)
2930                         di->ac.charger_voltage_uv = ret;
2931                 /* On error, use previous value */
2932                 val->intval = di->ac.charger_voltage_uv;
2933                 break;
2934         case POWER_SUPPLY_PROP_VOLTAGE_AVG:
2935                 /*
2936                  * This property is used to indicate when CV mode is entered
2937                  * for the AC charger
2938                  */
2939                 di->ac.cv_active = ab8500_charger_ac_cv(di);
2940                 val->intval = di->ac.cv_active;
2941                 break;
2942         case POWER_SUPPLY_PROP_CURRENT_NOW:
2943                 ret = ab8500_charger_get_ac_current(di);
2944                 if (ret >= 0)
2945                         di->ac.charger_current_ua = ret;
2946                 val->intval = di->ac.charger_current_ua;
2947                 break;
2948         default:
2949                 return -EINVAL;
2950         }
2951         return 0;
2952 }
2953
2954 /**
2955  * ab8500_charger_usb_get_property() - get the usb properties
2956  * @psy:        pointer to the power_supply structure
2957  * @psp:        pointer to the power_supply_property structure
2958  * @val:        pointer to the power_supply_propval union
2959  *
2960  * This function gets called when an application tries to get the usb
2961  * properties by reading the sysfs files.
2962  * USB properties are online, present and voltage.
2963  * online:     usb charging is in progress or not
2964  * present:    presence of the usb
2965  * voltage:    vbus voltage
2966  * Returns error code in case of failure else 0(on success)
2967  */
2968 static int ab8500_charger_usb_get_property(struct power_supply *psy,
2969         enum power_supply_property psp,
2970         union power_supply_propval *val)
2971 {
2972         struct ab8500_charger *di;
2973         int ret;
2974
2975         di = to_ab8500_charger_usb_device_info(psy_to_ux500_charger(psy));
2976
2977         switch (psp) {
2978         case POWER_SUPPLY_PROP_HEALTH:
2979                 if (di->flags.usbchargernotok)
2980                         val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
2981                 else if (di->ac.wd_expired || di->usb.wd_expired)
2982                         val->intval = POWER_SUPPLY_HEALTH_DEAD;
2983                 else if (di->flags.usb_thermal_prot)
2984                         val->intval = POWER_SUPPLY_HEALTH_OVERHEAT;
2985                 else if (di->flags.vbus_ovv)
2986                         val->intval = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
2987                 else
2988                         val->intval = POWER_SUPPLY_HEALTH_GOOD;
2989                 break;
2990         case POWER_SUPPLY_PROP_ONLINE:
2991                 val->intval = di->usb.charger_online;
2992                 break;
2993         case POWER_SUPPLY_PROP_PRESENT:
2994                 val->intval = di->usb.charger_connected;
2995                 break;
2996         case POWER_SUPPLY_PROP_VOLTAGE_NOW:
2997                 ret = ab8500_charger_get_vbus_voltage(di);
2998                 if (ret >= 0)
2999                         di->usb.charger_voltage_uv = ret;
3000                 val->intval = di->usb.charger_voltage_uv;
3001                 break;
3002         case POWER_SUPPLY_PROP_VOLTAGE_AVG:
3003                 /*
3004                  * This property is used to indicate when CV mode is entered
3005                  * for the USB charger
3006                  */
3007                 di->usb.cv_active = ab8500_charger_usb_cv(di);
3008                 val->intval = di->usb.cv_active;
3009                 break;
3010         case POWER_SUPPLY_PROP_CURRENT_NOW:
3011                 ret = ab8500_charger_get_usb_current(di);
3012                 if (ret >= 0)
3013                         di->usb.charger_current_ua = ret;
3014                 val->intval = di->usb.charger_current_ua;
3015                 break;
3016         case POWER_SUPPLY_PROP_CURRENT_AVG:
3017                 /*
3018                  * This property is used to indicate when VBUS has collapsed
3019                  * due to too high output current from the USB charger
3020                  */
3021                 if (di->flags.vbus_collapse)
3022                         val->intval = 1;
3023                 else
3024                         val->intval = 0;
3025                 break;
3026         default:
3027                 return -EINVAL;
3028         }
3029         return 0;
3030 }
3031
3032 /**
3033  * ab8500_charger_init_hw_registers() - Set up charger related registers
3034  * @di:         pointer to the ab8500_charger structure
3035  *
3036  * Set up charger OVV, watchdog and maximum voltage registers as well as
3037  * charging of the backup battery
3038  */
3039 static int ab8500_charger_init_hw_registers(struct ab8500_charger *di)
3040 {
3041         int ret = 0;
3042
3043         /* Setup maximum charger current and voltage for ABB cut2.0 */
3044         if (!is_ab8500_1p1_or_earlier(di->parent)) {
3045                 ret = abx500_set_register_interruptible(di->dev,
3046                         AB8500_CHARGER,
3047                         AB8500_CH_VOLT_LVL_MAX_REG, CH_VOL_LVL_4P6);
3048                 if (ret) {
3049                         dev_err(di->dev,
3050                                 "failed to set CH_VOLT_LVL_MAX_REG\n");
3051                         goto out;
3052                 }
3053
3054                 ret = abx500_set_register_interruptible(di->dev,
3055                         AB8500_CHARGER, AB8500_CH_OPT_CRNTLVL_MAX_REG,
3056                         CH_OP_CUR_LVL_1P6);
3057                 if (ret) {
3058                         dev_err(di->dev,
3059                                 "failed to set CH_OPT_CRNTLVL_MAX_REG\n");
3060                         goto out;
3061                 }
3062         }
3063
3064         if (is_ab8505_2p0(di->parent))
3065                 ret = abx500_mask_and_set_register_interruptible(di->dev,
3066                         AB8500_CHARGER,
3067                         AB8500_USBCH_CTRL2_REG,
3068                         VBUS_AUTO_IN_CURR_LIM_ENA,
3069                         VBUS_AUTO_IN_CURR_LIM_ENA);
3070         else
3071                 /*
3072                  * VBUS OVV set to 6.3V and enable automatic current limitation
3073                  */
3074                 ret = abx500_set_register_interruptible(di->dev,
3075                         AB8500_CHARGER,
3076                         AB8500_USBCH_CTRL2_REG,
3077                         VBUS_OVV_SELECT_6P3V | VBUS_AUTO_IN_CURR_LIM_ENA);
3078         if (ret) {
3079                 dev_err(di->dev,
3080                         "failed to set automatic current limitation\n");
3081                 goto out;
3082         }
3083
3084         /* Enable main watchdog in OTP */
3085         ret = abx500_set_register_interruptible(di->dev,
3086                 AB8500_OTP_EMUL, AB8500_OTP_CONF_15, OTP_ENABLE_WD);
3087         if (ret) {
3088                 dev_err(di->dev, "failed to enable main WD in OTP\n");
3089                 goto out;
3090         }
3091
3092         /* Enable main watchdog */
3093         ret = abx500_set_register_interruptible(di->dev,
3094                 AB8500_SYS_CTRL2_BLOCK,
3095                 AB8500_MAIN_WDOG_CTRL_REG, MAIN_WDOG_ENA);
3096         if (ret) {
3097                 dev_err(di->dev, "failed to enable main watchdog\n");
3098                 goto out;
3099         }
3100
3101         /*
3102          * Due to internal synchronisation, Enable and Kick watchdog bits
3103          * cannot be enabled in a single write.
3104          * A minimum delay of 2*32 kHz period (62.5µs) must be inserted
3105          * between writing Enable then Kick bits.
3106          */
3107         udelay(63);
3108
3109         /* Kick main watchdog */
3110         ret = abx500_set_register_interruptible(di->dev,
3111                 AB8500_SYS_CTRL2_BLOCK,
3112                 AB8500_MAIN_WDOG_CTRL_REG,
3113                 (MAIN_WDOG_ENA | MAIN_WDOG_KICK));
3114         if (ret) {
3115                 dev_err(di->dev, "failed to kick main watchdog\n");
3116                 goto out;
3117         }
3118
3119         /* Disable main watchdog */
3120         ret = abx500_set_register_interruptible(di->dev,
3121                 AB8500_SYS_CTRL2_BLOCK,
3122                 AB8500_MAIN_WDOG_CTRL_REG, MAIN_WDOG_DIS);
3123         if (ret) {
3124                 dev_err(di->dev, "failed to disable main watchdog\n");
3125                 goto out;
3126         }
3127
3128         /* Set watchdog timeout */
3129         ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
3130                 AB8500_CH_WD_TIMER_REG, WD_TIMER);
3131         if (ret) {
3132                 dev_err(di->dev, "failed to set charger watchdog timeout\n");
3133                 goto out;
3134         }
3135
3136         ret = ab8500_charger_led_en(di, false);
3137         if (ret < 0) {
3138                 dev_err(di->dev, "failed to disable LED\n");
3139                 goto out;
3140         }
3141
3142         ret = abx500_set_register_interruptible(di->dev,
3143                 AB8500_RTC,
3144                 AB8500_RTC_BACKUP_CHG_REG,
3145                 (di->bm->bkup_bat_v & 0x3) | di->bm->bkup_bat_i);
3146         if (ret) {
3147                 dev_err(di->dev, "failed to setup backup battery charging\n");
3148                 goto out;
3149         }
3150
3151         /* Enable backup battery charging */
3152         ret = abx500_mask_and_set_register_interruptible(di->dev,
3153                 AB8500_RTC, AB8500_RTC_CTRL_REG,
3154                 RTC_BUP_CH_ENA, RTC_BUP_CH_ENA);
3155         if (ret < 0) {
3156                 dev_err(di->dev, "%s mask and set failed\n", __func__);
3157                 goto out;
3158         }
3159
3160 out:
3161         return ret;
3162 }
3163
3164 /*
3165  * ab8500 charger driver interrupts and their respective isr
3166  */
3167 static struct ab8500_charger_interrupts ab8500_charger_irq[] = {
3168         {"MAIN_CH_UNPLUG_DET", ab8500_charger_mainchunplugdet_handler},
3169         {"MAIN_CHARGE_PLUG_DET", ab8500_charger_mainchplugdet_handler},
3170         {"MAIN_EXT_CH_NOT_OK", ab8500_charger_mainextchnotok_handler},
3171         {"MAIN_CH_TH_PROT_R", ab8500_charger_mainchthprotr_handler},
3172         {"MAIN_CH_TH_PROT_F", ab8500_charger_mainchthprotf_handler},
3173         {"VBUS_DET_F", ab8500_charger_vbusdetf_handler},
3174         {"VBUS_DET_R", ab8500_charger_vbusdetr_handler},
3175         {"USB_LINK_STATUS", ab8500_charger_usblinkstatus_handler},
3176         {"USB_CH_TH_PROT_R", ab8500_charger_usbchthprotr_handler},
3177         {"USB_CH_TH_PROT_F", ab8500_charger_usbchthprotf_handler},
3178         {"USB_CHARGER_NOT_OKR", ab8500_charger_usbchargernotokr_handler},
3179         {"VBUS_OVV", ab8500_charger_vbusovv_handler},
3180         {"CH_WD_EXP", ab8500_charger_chwdexp_handler},
3181         {"VBUS_CH_DROP_END", ab8500_charger_vbuschdropend_handler},
3182 };
3183
3184 static int ab8500_charger_usb_notifier_call(struct notifier_block *nb,
3185                 unsigned long event, void *power)
3186 {
3187         struct ab8500_charger *di =
3188                 container_of(nb, struct ab8500_charger, nb);
3189         enum ab8500_usb_state bm_usb_state;
3190         /*
3191          * FIXME: it appears the AB8500 PHY never sends what it should here.
3192          * Fix the PHY driver to properly notify the desired current.
3193          * Also broadcast microampere and not milliampere.
3194          */
3195         unsigned mA = *((unsigned *)power);
3196
3197         if (event != USB_EVENT_VBUS) {
3198                 dev_dbg(di->dev, "not a standard host, returning\n");
3199                 return NOTIFY_DONE;
3200         }
3201
3202         /* TODO: State is fabricate  here. See if charger really needs USB
3203          * state or if mA is enough
3204          */
3205         if ((di->usb_state.usb_current_ua == 2000) && (mA > 2))
3206                 bm_usb_state = AB8500_BM_USB_STATE_RESUME;
3207         else if (mA == 0)
3208                 bm_usb_state = AB8500_BM_USB_STATE_RESET_HS;
3209         else if (mA == 2)
3210                 bm_usb_state = AB8500_BM_USB_STATE_SUSPEND;
3211         else if (mA >= 8) /* 8, 100, 500 */
3212                 bm_usb_state = AB8500_BM_USB_STATE_CONFIGURED;
3213         else /* Should never occur */
3214                 bm_usb_state = AB8500_BM_USB_STATE_RESET_FS;
3215
3216         dev_dbg(di->dev, "%s usb_state: 0x%02x mA: %d\n",
3217                 __func__, bm_usb_state, mA);
3218
3219         spin_lock(&di->usb_state.usb_lock);
3220         di->usb_state.state_tmp = bm_usb_state;
3221         /* FIXME: broadcast ua instead, see above */
3222         di->usb_state.usb_current_tmp_ua = mA * 1000;
3223         spin_unlock(&di->usb_state.usb_lock);
3224
3225         /*
3226          * wait for some time until you get updates from the usb stack
3227          * and negotiations are completed
3228          */
3229         queue_delayed_work(di->charger_wq, &di->usb_state_changed_work, HZ/2);
3230
3231         return NOTIFY_OK;
3232 }
3233
3234 static int __maybe_unused ab8500_charger_resume(struct device *dev)
3235 {
3236         int ret;
3237         struct ab8500_charger *di = dev_get_drvdata(dev);
3238
3239         /*
3240          * For ABB revision 1.0 and 1.1 there is a bug in the watchdog
3241          * logic. That means we have to continuously kick the charger
3242          * watchdog even when no charger is connected. This is only
3243          * valid once the AC charger has been enabled. This is
3244          * a bug that is not handled by the algorithm and the
3245          * watchdog have to be kicked by the charger driver
3246          * when the AC charger is disabled
3247          */
3248         if (di->ac_conn && is_ab8500_1p1_or_earlier(di->parent)) {
3249                 ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
3250                         AB8500_CHARG_WD_CTRL, CHARG_WD_KICK);
3251                 if (ret)
3252                         dev_err(di->dev, "Failed to kick WD!\n");
3253
3254                 /* If not already pending start a new timer */
3255                 queue_delayed_work(di->charger_wq, &di->kick_wd_work,
3256                                    round_jiffies(WD_KICK_INTERVAL));
3257         }
3258
3259         /* If we still have a HW failure, schedule a new check */
3260         if (di->flags.mainextchnotok || di->flags.vbus_ovv) {
3261                 queue_delayed_work(di->charger_wq,
3262                         &di->check_hw_failure_work, 0);
3263         }
3264
3265         if (di->flags.vbus_drop_end)
3266                 queue_delayed_work(di->charger_wq, &di->vbus_drop_end_work, 0);
3267
3268         return 0;
3269 }
3270
3271 static int __maybe_unused ab8500_charger_suspend(struct device *dev)
3272 {
3273         struct ab8500_charger *di = dev_get_drvdata(dev);
3274
3275         /* Cancel any pending jobs */
3276         cancel_delayed_work(&di->check_hw_failure_work);
3277         cancel_delayed_work(&di->vbus_drop_end_work);
3278
3279         flush_delayed_work(&di->attach_work);
3280         flush_delayed_work(&di->usb_charger_attached_work);
3281         flush_delayed_work(&di->ac_charger_attached_work);
3282         flush_delayed_work(&di->check_usbchgnotok_work);
3283         flush_delayed_work(&di->check_vbat_work);
3284         flush_delayed_work(&di->kick_wd_work);
3285
3286         flush_work(&di->usb_link_status_work);
3287         flush_work(&di->ac_work);
3288         flush_work(&di->detect_usb_type_work);
3289
3290         if (atomic_read(&di->current_stepping_sessions))
3291                 return -EAGAIN;
3292
3293         return 0;
3294 }
3295
3296 static char *supply_interface[] = {
3297         "ab8500_chargalg",
3298         "ab8500_fg",
3299         "ab8500_btemp",
3300 };
3301
3302 static const struct power_supply_desc ab8500_ac_chg_desc = {
3303         .name           = "ab8500_ac",
3304         .type           = POWER_SUPPLY_TYPE_MAINS,
3305         .properties     = ab8500_charger_ac_props,
3306         .num_properties = ARRAY_SIZE(ab8500_charger_ac_props),
3307         .get_property   = ab8500_charger_ac_get_property,
3308 };
3309
3310 static const struct power_supply_desc ab8500_usb_chg_desc = {
3311         .name           = "ab8500_usb",
3312         .type           = POWER_SUPPLY_TYPE_USB,
3313         .properties     = ab8500_charger_usb_props,
3314         .num_properties = ARRAY_SIZE(ab8500_charger_usb_props),
3315         .get_property   = ab8500_charger_usb_get_property,
3316 };
3317
3318 static int ab8500_charger_bind(struct device *dev)
3319 {
3320         struct ab8500_charger *di = dev_get_drvdata(dev);
3321         int ch_stat;
3322         int ret;
3323
3324         /* Create a work queue for the charger */
3325         di->charger_wq = alloc_ordered_workqueue("ab8500_charger_wq",
3326                                                  WQ_MEM_RECLAIM);
3327         if (di->charger_wq == NULL) {
3328                 dev_err(dev, "failed to create work queue\n");
3329                 return -ENOMEM;
3330         }
3331
3332         ch_stat = ab8500_charger_detect_chargers(di, false);
3333
3334         if (ch_stat & AC_PW_CONN) {
3335                 if (is_ab8500(di->parent))
3336                         queue_delayed_work(di->charger_wq,
3337                                            &di->ac_charger_attached_work,
3338                                            HZ);
3339         }
3340         if (ch_stat & USB_PW_CONN) {
3341                 if (is_ab8500(di->parent))
3342                         queue_delayed_work(di->charger_wq,
3343                                            &di->usb_charger_attached_work,
3344                                            HZ);
3345                 di->vbus_detected = true;
3346                 di->vbus_detected_start = true;
3347                 queue_work(di->charger_wq,
3348                            &di->detect_usb_type_work);
3349         }
3350
3351         ret = component_bind_all(dev, di);
3352         if (ret) {
3353                 dev_err(dev, "can't bind component devices\n");
3354                 destroy_workqueue(di->charger_wq);
3355                 return ret;
3356         }
3357
3358         return 0;
3359 }
3360
3361 static void ab8500_charger_unbind(struct device *dev)
3362 {
3363         struct ab8500_charger *di = dev_get_drvdata(dev);
3364         int ret;
3365
3366         /* Disable AC charging */
3367         ab8500_charger_ac_en(&di->ac_chg, false, 0, 0);
3368
3369         /* Disable USB charging */
3370         ab8500_charger_usb_en(&di->usb_chg, false, 0, 0);
3371
3372         /* Backup battery voltage and current disable */
3373         ret = abx500_mask_and_set_register_interruptible(di->dev,
3374                 AB8500_RTC, AB8500_RTC_CTRL_REG, RTC_BUP_CH_ENA, 0);
3375         if (ret < 0)
3376                 dev_err(di->dev, "%s mask and set failed\n", __func__);
3377
3378         /* Delete the work queue */
3379         destroy_workqueue(di->charger_wq);
3380
3381         /* Unbind fg, btemp, algorithm */
3382         component_unbind_all(dev, di);
3383 }
3384
3385 static const struct component_master_ops ab8500_charger_comp_ops = {
3386         .bind = ab8500_charger_bind,
3387         .unbind = ab8500_charger_unbind,
3388 };
3389
3390 static struct platform_driver *const ab8500_charger_component_drivers[] = {
3391         &ab8500_fg_driver,
3392         &ab8500_btemp_driver,
3393         &ab8500_chargalg_driver,
3394 };
3395
3396 static int ab8500_charger_probe(struct platform_device *pdev)
3397 {
3398         struct device *dev = &pdev->dev;
3399         struct device_node *np = dev->of_node;
3400         struct component_match *match = NULL;
3401         struct power_supply_config ac_psy_cfg = {}, usb_psy_cfg = {};
3402         struct ab8500_charger *di;
3403         int charger_status;
3404         int i, irq;
3405         int ret;
3406
3407         di = devm_kzalloc(dev, sizeof(*di), GFP_KERNEL);
3408         if (!di)
3409                 return -ENOMEM;
3410
3411         di->bm = &ab8500_bm_data;
3412
3413         di->autopower_cfg = of_property_read_bool(np, "autopower_cfg");
3414
3415         /* get parent data */
3416         di->dev = dev;
3417         di->parent = dev_get_drvdata(pdev->dev.parent);
3418
3419         /* Get ADC channels */
3420         if (!is_ab8505(di->parent)) {
3421                 di->adc_main_charger_v = devm_iio_channel_get(dev, "main_charger_v");
3422                 if (IS_ERR(di->adc_main_charger_v)) {
3423                         ret = dev_err_probe(dev, PTR_ERR(di->adc_main_charger_v),
3424                                             "failed to get ADC main charger voltage\n");
3425                         return ret;
3426                 }
3427                 di->adc_main_charger_c = devm_iio_channel_get(dev, "main_charger_c");
3428                 if (IS_ERR(di->adc_main_charger_c)) {
3429                         ret = dev_err_probe(dev, PTR_ERR(di->adc_main_charger_c),
3430                                             "failed to get ADC main charger current\n");
3431                         return ret;
3432                 }
3433         }
3434         di->adc_vbus_v = devm_iio_channel_get(dev, "vbus_v");
3435         if (IS_ERR(di->adc_vbus_v)) {
3436                 ret = dev_err_probe(dev, PTR_ERR(di->adc_vbus_v),
3437                                     "failed to get ADC USB charger voltage\n");
3438                 return ret;
3439         }
3440         di->adc_usb_charger_c = devm_iio_channel_get(dev, "usb_charger_c");
3441         if (IS_ERR(di->adc_usb_charger_c)) {
3442                 ret = dev_err_probe(dev, PTR_ERR(di->adc_usb_charger_c),
3443                                     "failed to get ADC USB charger current\n");
3444                 return ret;
3445         }
3446
3447         /*
3448          * VDD ADC supply needs to be enabled from this driver when there
3449          * is a charger connected to avoid erroneous BTEMP_HIGH/LOW
3450          * interrupts during charging
3451          */
3452         di->regu = devm_regulator_get(dev, "vddadc");
3453         if (IS_ERR(di->regu)) {
3454                 ret = PTR_ERR(di->regu);
3455                 dev_err(dev, "failed to get vddadc regulator\n");
3456                 return ret;
3457         }
3458
3459         /* Request interrupts */
3460         for (i = 0; i < ARRAY_SIZE(ab8500_charger_irq); i++) {
3461                 irq = platform_get_irq_byname(pdev, ab8500_charger_irq[i].name);
3462                 if (irq < 0)
3463                         return irq;
3464
3465                 ret = devm_request_threaded_irq(dev,
3466                         irq, NULL, ab8500_charger_irq[i].isr,
3467                         IRQF_SHARED | IRQF_NO_SUSPEND | IRQF_ONESHOT,
3468                         ab8500_charger_irq[i].name, di);
3469
3470                 if (ret != 0) {
3471                         dev_err(dev, "failed to request %s IRQ %d: %d\n"
3472                                 , ab8500_charger_irq[i].name, irq, ret);
3473                         return ret;
3474                 }
3475                 dev_dbg(dev, "Requested %s IRQ %d: %d\n",
3476                         ab8500_charger_irq[i].name, irq, ret);
3477         }
3478
3479         /* initialize lock */
3480         spin_lock_init(&di->usb_state.usb_lock);
3481         mutex_init(&di->usb_ipt_crnt_lock);
3482
3483         di->autopower = false;
3484         di->invalid_charger_detect_state = 0;
3485
3486         /* AC and USB supply config */
3487         ac_psy_cfg.of_node = np;
3488         ac_psy_cfg.supplied_to = supply_interface;
3489         ac_psy_cfg.num_supplicants = ARRAY_SIZE(supply_interface);
3490         ac_psy_cfg.drv_data = &di->ac_chg;
3491         usb_psy_cfg.of_node = np;
3492         usb_psy_cfg.supplied_to = supply_interface;
3493         usb_psy_cfg.num_supplicants = ARRAY_SIZE(supply_interface);
3494         usb_psy_cfg.drv_data = &di->usb_chg;
3495
3496         /* AC supply */
3497         /* ux500_charger sub-class */
3498         di->ac_chg.ops.enable = &ab8500_charger_ac_en;
3499         di->ac_chg.ops.check_enable = &ab8500_charger_ac_check_enable;
3500         di->ac_chg.ops.kick_wd = &ab8500_charger_watchdog_kick;
3501         di->ac_chg.ops.update_curr = &ab8500_charger_update_charger_current;
3502         di->ac_chg.max_out_volt_uv = ab8500_charger_voltage_map[
3503                 ARRAY_SIZE(ab8500_charger_voltage_map) - 1];
3504         di->ac_chg.max_out_curr_ua =
3505                 ab8500_charge_output_curr_map[ARRAY_SIZE(ab8500_charge_output_curr_map) - 1];
3506         di->ac_chg.wdt_refresh = CHG_WD_INTERVAL;
3507         /*
3508          * The AB8505 only supports USB charging. If we are not the
3509          * AB8505, register an AC charger.
3510          *
3511          * TODO: if this should be opt-in, add DT properties for this.
3512          */
3513         if (!is_ab8505(di->parent))
3514                 di->ac_chg.enabled = true;
3515
3516         /* USB supply */
3517         /* ux500_charger sub-class */
3518         di->usb_chg.ops.enable = &ab8500_charger_usb_en;
3519         di->usb_chg.ops.check_enable = &ab8500_charger_usb_check_enable;
3520         di->usb_chg.ops.kick_wd = &ab8500_charger_watchdog_kick;
3521         di->usb_chg.ops.update_curr = &ab8500_charger_update_charger_current;
3522         di->usb_chg.max_out_volt_uv = ab8500_charger_voltage_map[
3523                 ARRAY_SIZE(ab8500_charger_voltage_map) - 1];
3524         di->usb_chg.max_out_curr_ua =
3525                 ab8500_charge_output_curr_map[ARRAY_SIZE(ab8500_charge_output_curr_map) - 1];
3526         di->usb_chg.wdt_refresh = CHG_WD_INTERVAL;
3527         di->usb_state.usb_current_ua = -1;
3528
3529         mutex_init(&di->charger_attached_mutex);
3530
3531         /* Init work for HW failure check */
3532         INIT_DEFERRABLE_WORK(&di->check_hw_failure_work,
3533                 ab8500_charger_check_hw_failure_work);
3534         INIT_DEFERRABLE_WORK(&di->check_usbchgnotok_work,
3535                 ab8500_charger_check_usbchargernotok_work);
3536
3537         INIT_DELAYED_WORK(&di->ac_charger_attached_work,
3538                           ab8500_charger_ac_attached_work);
3539         INIT_DELAYED_WORK(&di->usb_charger_attached_work,
3540                           ab8500_charger_usb_attached_work);
3541
3542         /*
3543          * For ABB revision 1.0 and 1.1 there is a bug in the watchdog
3544          * logic. That means we have to continuously kick the charger
3545          * watchdog even when no charger is connected. This is only
3546          * valid once the AC charger has been enabled. This is
3547          * a bug that is not handled by the algorithm and the
3548          * watchdog have to be kicked by the charger driver
3549          * when the AC charger is disabled
3550          */
3551         INIT_DEFERRABLE_WORK(&di->kick_wd_work,
3552                 ab8500_charger_kick_watchdog_work);
3553
3554         INIT_DEFERRABLE_WORK(&di->check_vbat_work,
3555                 ab8500_charger_check_vbat_work);
3556
3557         INIT_DELAYED_WORK(&di->attach_work,
3558                 ab8500_charger_usb_link_attach_work);
3559
3560         INIT_DELAYED_WORK(&di->usb_state_changed_work,
3561                 ab8500_charger_usb_state_changed_work);
3562
3563         INIT_DELAYED_WORK(&di->vbus_drop_end_work,
3564                 ab8500_charger_vbus_drop_end_work);
3565
3566         /* Init work for charger detection */
3567         INIT_WORK(&di->usb_link_status_work,
3568                 ab8500_charger_usb_link_status_work);
3569         INIT_WORK(&di->ac_work, ab8500_charger_ac_work);
3570         INIT_WORK(&di->detect_usb_type_work,
3571                 ab8500_charger_detect_usb_type_work);
3572
3573         /* Init work for checking HW status */
3574         INIT_WORK(&di->check_main_thermal_prot_work,
3575                 ab8500_charger_check_main_thermal_prot_work);
3576         INIT_WORK(&di->check_usb_thermal_prot_work,
3577                 ab8500_charger_check_usb_thermal_prot_work);
3578
3579
3580         /* Initialize OVV, and other registers */
3581         ret = ab8500_charger_init_hw_registers(di);
3582         if (ret) {
3583                 dev_err(dev, "failed to initialize ABB registers\n");
3584                 return ret;
3585         }
3586
3587         /* Register AC charger class */
3588         if (di->ac_chg.enabled) {
3589                 di->ac_chg.psy = devm_power_supply_register(dev,
3590                                                        &ab8500_ac_chg_desc,
3591                                                        &ac_psy_cfg);
3592                 if (IS_ERR(di->ac_chg.psy)) {
3593                         dev_err(dev, "failed to register AC charger\n");
3594                         return PTR_ERR(di->ac_chg.psy);
3595                 }
3596         }
3597
3598         /* Register USB charger class */
3599         di->usb_chg.psy = devm_power_supply_register(dev,
3600                                                      &ab8500_usb_chg_desc,
3601                                                      &usb_psy_cfg);
3602         if (IS_ERR(di->usb_chg.psy)) {
3603                 dev_err(dev, "failed to register USB charger\n");
3604                 return PTR_ERR(di->usb_chg.psy);
3605         }
3606
3607         /*
3608          * Check what battery we have, since we always have the USB
3609          * psy, use that as a handle.
3610          */
3611         ret = ab8500_bm_of_probe(di->usb_chg.psy, di->bm);
3612         if (ret)
3613                 return dev_err_probe(dev, ret,
3614                                      "failed to get battery information\n");
3615
3616         /* Identify the connected charger types during startup */
3617         charger_status = ab8500_charger_detect_chargers(di, true);
3618         if (charger_status & AC_PW_CONN) {
3619                 di->ac.charger_connected = 1;
3620                 di->ac_conn = true;
3621                 ab8500_power_supply_changed(di, di->ac_chg.psy);
3622                 sysfs_notify(&di->ac_chg.psy->dev.kobj, NULL, "present");
3623         }
3624
3625         platform_set_drvdata(pdev, di);
3626
3627         /* Create something that will match the subdrivers when we bind */
3628         for (i = 0; i < ARRAY_SIZE(ab8500_charger_component_drivers); i++) {
3629                 struct device_driver *drv = &ab8500_charger_component_drivers[i]->driver;
3630                 struct device *p = NULL, *d;
3631
3632                 while ((d = platform_find_device_by_driver(p, drv))) {
3633                         put_device(p);
3634                         component_match_add(dev, &match, component_compare_dev, d);
3635                         p = d;
3636                 }
3637                 put_device(p);
3638         }
3639         if (!match) {
3640                 dev_err(dev, "no matching components\n");
3641                 ret = -ENODEV;
3642                 goto remove_ab8500_bm;
3643         }
3644         if (IS_ERR(match)) {
3645                 dev_err(dev, "could not create component match\n");
3646                 ret = PTR_ERR(match);
3647                 goto remove_ab8500_bm;
3648         }
3649
3650         di->usb_phy = usb_get_phy(USB_PHY_TYPE_USB2);
3651         if (IS_ERR_OR_NULL(di->usb_phy)) {
3652                 dev_err(dev, "failed to get usb transceiver\n");
3653                 ret = -EINVAL;
3654                 goto remove_ab8500_bm;
3655         }
3656         di->nb.notifier_call = ab8500_charger_usb_notifier_call;
3657         ret = usb_register_notifier(di->usb_phy, &di->nb);
3658         if (ret) {
3659                 dev_err(dev, "failed to register usb notifier\n");
3660                 goto put_usb_phy;
3661         }
3662
3663         ret = component_master_add_with_match(&pdev->dev,
3664                                               &ab8500_charger_comp_ops,
3665                                               match);
3666         if (ret) {
3667                 dev_err(dev, "failed to add component master\n");
3668                 goto free_notifier;
3669         }
3670
3671         return 0;
3672
3673 free_notifier:
3674         usb_unregister_notifier(di->usb_phy, &di->nb);
3675 put_usb_phy:
3676         usb_put_phy(di->usb_phy);
3677 remove_ab8500_bm:
3678         ab8500_bm_of_remove(di->usb_chg.psy, di->bm);
3679         return ret;
3680 }
3681
3682 static void ab8500_charger_remove(struct platform_device *pdev)
3683 {
3684         struct ab8500_charger *di = platform_get_drvdata(pdev);
3685
3686         component_master_del(&pdev->dev, &ab8500_charger_comp_ops);
3687
3688         usb_unregister_notifier(di->usb_phy, &di->nb);
3689         ab8500_bm_of_remove(di->usb_chg.psy, di->bm);
3690         usb_put_phy(di->usb_phy);
3691 }
3692
3693 static SIMPLE_DEV_PM_OPS(ab8500_charger_pm_ops, ab8500_charger_suspend, ab8500_charger_resume);
3694
3695 static const struct of_device_id ab8500_charger_match[] = {
3696         { .compatible = "stericsson,ab8500-charger", },
3697         { },
3698 };
3699 MODULE_DEVICE_TABLE(of, ab8500_charger_match);
3700
3701 static struct platform_driver ab8500_charger_driver = {
3702         .probe = ab8500_charger_probe,
3703         .remove_new = ab8500_charger_remove,
3704         .driver = {
3705                 .name = "ab8500-charger",
3706                 .of_match_table = ab8500_charger_match,
3707                 .pm = &ab8500_charger_pm_ops,
3708         },
3709 };
3710
3711 static int __init ab8500_charger_init(void)
3712 {
3713         int ret;
3714
3715         ret = platform_register_drivers(ab8500_charger_component_drivers,
3716                         ARRAY_SIZE(ab8500_charger_component_drivers));
3717         if (ret)
3718                 return ret;
3719
3720         ret = platform_driver_register(&ab8500_charger_driver);
3721         if (ret) {
3722                 platform_unregister_drivers(ab8500_charger_component_drivers,
3723                                 ARRAY_SIZE(ab8500_charger_component_drivers));
3724                 return ret;
3725         }
3726
3727         return 0;
3728 }
3729
3730 static void __exit ab8500_charger_exit(void)
3731 {
3732         platform_unregister_drivers(ab8500_charger_component_drivers,
3733                         ARRAY_SIZE(ab8500_charger_component_drivers));
3734         platform_driver_unregister(&ab8500_charger_driver);
3735 }
3736
3737 module_init(ab8500_charger_init);
3738 module_exit(ab8500_charger_exit);
3739
3740 MODULE_LICENSE("GPL v2");
3741 MODULE_AUTHOR("Johan Palsson, Karl Komierowski, Arun R Murthy");
3742 MODULE_ALIAS("platform:ab8500-charger");
3743 MODULE_DESCRIPTION("AB8500 charger management driver");