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