drivers/power/ab8500_charger.c

   1 /*
   2  * Copyright (C) ST-Ericsson SA 2012
   3  *
   4  * Charger driver for AB8500
   5  *
   6  * License Terms: GNU General Public License v2
   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/interrupt.h>
  17 #include <linux/delay.h>
  18 #include <linux/slab.h>
  19 #include <linux/platform_device.h>
  20 #include <linux/power_supply.h>
  21 #include <linux/completion.h>
  22 #include <linux/regulator/consumer.h>
  23 #include <linux/err.h>
  24 #include <linux/workqueue.h>
  25 #include <linux/kobject.h>
  26 #include <linux/of.h>
  27 #include <linux/mfd/core.h>
  28 #include <linux/mfd/abx500/ab8500.h>
  29 #include <linux/mfd/abx500.h>
  30 #include <linux/mfd/abx500/ab8500-bm.h>
  31 #include <linux/mfd/abx500/ab8500-gpadc.h>
  32 #include <linux/mfd/abx500/ux500_chargalg.h>
  33 #include <linux/usb/otg.h>
  34
  35 /* Charger constants */
  36 #define NO_PW_CONN                      0
  37 #define AC_PW_CONN                      1
  38 #define USB_PW_CONN                     2
  39
  40 #define MAIN_WDOG_ENA                   0x01
  41 #define MAIN_WDOG_KICK                  0x02
  42 #define MAIN_WDOG_DIS                   0x00
  43 #define CHARG_WD_KICK                   0x01
  44 #define MAIN_CH_ENA                     0x01
  45 #define MAIN_CH_NO_OVERSHOOT_ENA_N      0x02
  46 #define USB_CH_ENA                      0x01
  47 #define USB_CHG_NO_OVERSHOOT_ENA_N      0x02
  48 #define MAIN_CH_DET                     0x01
  49 #define MAIN_CH_CV_ON                   0x04
  50 #define USB_CH_CV_ON                    0x08
  51 #define VBUS_DET_DBNC100                0x02
  52 #define VBUS_DET_DBNC1                  0x01
  53 #define OTP_ENABLE_WD                   0x01
  54
  55 #define MAIN_CH_INPUT_CURR_SHIFT        4
  56 #define VBUS_IN_CURR_LIM_SHIFT          4
  57
  58 #define LED_INDICATOR_PWM_ENA           0x01
  59 #define LED_INDICATOR_PWM_DIS           0x00
  60 #define LED_IND_CUR_5MA                 0x04
  61 #define LED_INDICATOR_PWM_DUTY_252_256  0xBF
  62
  63 /* HW failure constants */
  64 #define MAIN_CH_TH_PROT                 0x02
  65 #define VBUS_CH_NOK                     0x08
  66 #define USB_CH_TH_PROT                  0x02
  67 #define VBUS_OVV_TH                     0x01
  68 #define MAIN_CH_NOK                     0x01
  69 #define VBUS_DET                        0x80
  70
  71 /* UsbLineStatus register bit masks */
  72 #define AB8500_USB_LINK_STATUS          0x78
  73 #define AB8500_STD_HOST_SUSP            0x18
  74
  75 /* Watchdog timeout constant */
  76 #define WD_TIMER                        0x30 /* 4min */
  77 #define WD_KICK_INTERVAL                (60 * HZ)
  78
  79 /* Lowest charger voltage is 3.39V -> 0x4E */
  80 #define LOW_VOLT_REG                    0x4E
  81
  82 /* Step up/down delay in us */
  83 #define STEP_UDELAY                     1000
  84
  85 /* UsbLineStatus register - usb types */
  86 enum ab8500_charger_link_status {
  87         USB_STAT_NOT_CONFIGURED,
  88         USB_STAT_STD_HOST_NC,
  89         USB_STAT_STD_HOST_C_NS,
  90         USB_STAT_STD_HOST_C_S,
  91         USB_STAT_HOST_CHG_NM,
  92         USB_STAT_HOST_CHG_HS,
  93         USB_STAT_HOST_CHG_HS_CHIRP,
  94         USB_STAT_DEDICATED_CHG,
  95         USB_STAT_ACA_RID_A,
  96         USB_STAT_ACA_RID_B,
  97         USB_STAT_ACA_RID_C_NM,
  98         USB_STAT_ACA_RID_C_HS,
  99         USB_STAT_ACA_RID_C_HS_CHIRP,
 100         USB_STAT_HM_IDGND,
 101         USB_STAT_RESERVED,
 102         USB_STAT_NOT_VALID_LINK,
 103 };
 104
 105 enum ab8500_usb_state {
 106         AB8500_BM_USB_STATE_RESET_HS,   /* HighSpeed Reset */
 107         AB8500_BM_USB_STATE_RESET_FS,   /* FullSpeed/LowSpeed Reset */
 108         AB8500_BM_USB_STATE_CONFIGURED,
 109         AB8500_BM_USB_STATE_SUSPEND,
 110         AB8500_BM_USB_STATE_RESUME,
 111         AB8500_BM_USB_STATE_MAX,
 112 };
 113
 114 /* VBUS input current limits supported in AB8500 in mA */
 115 #define USB_CH_IP_CUR_LVL_0P05          50
 116 #define USB_CH_IP_CUR_LVL_0P09          98
 117 #define USB_CH_IP_CUR_LVL_0P19          193
 118 #define USB_CH_IP_CUR_LVL_0P29          290
 119 #define USB_CH_IP_CUR_LVL_0P38          380
 120 #define USB_CH_IP_CUR_LVL_0P45          450
 121 #define USB_CH_IP_CUR_LVL_0P5           500
 122 #define USB_CH_IP_CUR_LVL_0P6           600
 123 #define USB_CH_IP_CUR_LVL_0P7           700
 124 #define USB_CH_IP_CUR_LVL_0P8           800
 125 #define USB_CH_IP_CUR_LVL_0P9           900
 126 #define USB_CH_IP_CUR_LVL_1P0           1000
 127 #define USB_CH_IP_CUR_LVL_1P1           1100
 128 #define USB_CH_IP_CUR_LVL_1P3           1300
 129 #define USB_CH_IP_CUR_LVL_1P4           1400
 130 #define USB_CH_IP_CUR_LVL_1P5           1500
 131
 132 #define VBAT_TRESH_IP_CUR_RED           3800
 133
 134 #define to_ab8500_charger_usb_device_info(x) container_of((x), \
 135         struct ab8500_charger, usb_chg)
 136 #define to_ab8500_charger_ac_device_info(x) container_of((x), \
 137         struct ab8500_charger, ac_chg)
 138
 139 /**
 140  * struct ab8500_charger_interrupts - ab8500 interupts
 141  * @name:       name of the interrupt
 142  * @isr         function pointer to the isr
 143  */
 144 struct ab8500_charger_interrupts {
 145         char *name;
 146         irqreturn_t (*isr)(int irq, void *data);
 147 };
 148
 149 struct ab8500_charger_info {
 150         int charger_connected;
 151         int charger_online;
 152         int charger_voltage;
 153         int cv_active;
 154         bool wd_expired;
 155 };
 156
 157 struct ab8500_charger_event_flags {
 158         bool mainextchnotok;
 159         bool main_thermal_prot;
 160         bool usb_thermal_prot;
 161         bool vbus_ovv;
 162         bool usbchargernotok;
 163         bool chgwdexp;
 164         bool vbus_collapse;
 165 };
 166
 167 struct ab8500_charger_usb_state {
 168         bool usb_changed;
 169         int usb_current;
 170         enum ab8500_usb_state state;
 171         spinlock_t usb_lock;
 172 };
 173
 174 /**
 175  * struct ab8500_charger - ab8500 Charger device information
 176  * @dev:                Pointer to the structure device
 177  * @max_usb_in_curr:    Max USB charger input current
 178  * @vbus_detected:      VBUS detected
 179  * @vbus_detected_start:
 180  *                      VBUS detected during startup
 181  * @ac_conn:            This will be true when the AC charger has been plugged
 182  * @vddadc_en_ac:       Indicate if VDD ADC supply is enabled because AC
 183  *                      charger is enabled
 184  * @vddadc_en_usb:      Indicate if VDD ADC supply is enabled because USB
 185  *                      charger is enabled
 186  * @vbat                Battery voltage
 187  * @old_vbat            Previously measured battery voltage
 188  * @autopower           Indicate if we should have automatic pwron after pwrloss
 189  * @autopower_cfg       platform specific power config support for "pwron after pwrloss"
 190  * @parent:             Pointer to the struct ab8500
 191  * @gpadc:              Pointer to the struct gpadc
 192  * @bm:                 Platform specific battery management information
 193  * @flags:              Structure for information about events triggered
 194  * @usb_state:          Structure for usb stack information
 195  * @ac_chg:             AC charger power supply
 196  * @usb_chg:            USB charger power supply
 197  * @ac:                 Structure that holds the AC charger properties
 198  * @usb:                Structure that holds the USB charger properties
 199  * @regu:               Pointer to the struct regulator
 200  * @charger_wq:         Work queue for the IRQs and checking HW state
 201  * @check_vbat_work     Work for checking vbat threshold to adjust vbus current
 202  * @check_hw_failure_work:      Work for checking HW state
 203  * @check_usbchgnotok_work:     Work for checking USB charger not ok status
 204  * @kick_wd_work:               Work for kicking the charger watchdog in case
 205  *                              of ABB rev 1.* due to the watchog logic bug
 206  * @ac_work:                    Work for checking AC charger connection
 207  * @detect_usb_type_work:       Work for detecting the USB type connected
 208  * @usb_link_status_work:       Work for checking the new USB link status
 209  * @usb_state_changed_work:     Work for checking USB state
 210  * @check_main_thermal_prot_work:
 211  *                              Work for checking Main thermal status
 212  * @check_usb_thermal_prot_work:
 213  *                              Work for checking USB thermal status
 214  */
 215 struct ab8500_charger {
 216         struct device *dev;
 217         int max_usb_in_curr;
 218         bool vbus_detected;
 219         bool vbus_detected_start;
 220         bool ac_conn;
 221         bool vddadc_en_ac;
 222         bool vddadc_en_usb;
 223         int vbat;
 224         int old_vbat;
 225         bool autopower;
 226         bool autopower_cfg;
 227         struct ab8500 *parent;
 228         struct ab8500_gpadc *gpadc;
 229         struct abx500_bm_data *bm;
 230         struct ab8500_charger_event_flags flags;
 231         struct ab8500_charger_usb_state usb_state;
 232         struct ux500_charger ac_chg;
 233         struct ux500_charger usb_chg;
 234         struct ab8500_charger_info ac;
 235         struct ab8500_charger_info usb;
 236         struct regulator *regu;
 237         struct workqueue_struct *charger_wq;
 238         struct delayed_work check_vbat_work;
 239         struct delayed_work check_hw_failure_work;
 240         struct delayed_work check_usbchgnotok_work;
 241         struct delayed_work kick_wd_work;
 242         struct work_struct ac_work;
 243         struct work_struct detect_usb_type_work;
 244         struct work_struct usb_link_status_work;
 245         struct work_struct usb_state_changed_work;
 246         struct work_struct check_main_thermal_prot_work;
 247         struct work_struct check_usb_thermal_prot_work;
 248         struct usb_phy *usb_phy;
 249         struct notifier_block nb;
 250 };
 251
 252 /* AC properties */
 253 static enum power_supply_property ab8500_charger_ac_props[] = {
 254         POWER_SUPPLY_PROP_HEALTH,
 255         POWER_SUPPLY_PROP_PRESENT,
 256         POWER_SUPPLY_PROP_ONLINE,
 257         POWER_SUPPLY_PROP_VOLTAGE_NOW,
 258         POWER_SUPPLY_PROP_VOLTAGE_AVG,
 259         POWER_SUPPLY_PROP_CURRENT_NOW,
 260 };
 261
 262 /* USB properties */
 263 static enum power_supply_property ab8500_charger_usb_props[] = {
 264         POWER_SUPPLY_PROP_HEALTH,
 265         POWER_SUPPLY_PROP_CURRENT_AVG,
 266         POWER_SUPPLY_PROP_PRESENT,
 267         POWER_SUPPLY_PROP_ONLINE,
 268         POWER_SUPPLY_PROP_VOLTAGE_NOW,
 269         POWER_SUPPLY_PROP_VOLTAGE_AVG,
 270         POWER_SUPPLY_PROP_CURRENT_NOW,
 271 };
 272
 273 /**
 274  * ab8500_power_loss_handling - set how we handle powerloss.
 275  * @di:         pointer to the ab8500_charger structure
 276  *
 277  * Magic nummbers are from STE HW department.
 278  */
 279 static void ab8500_power_loss_handling(struct ab8500_charger *di)
 280 {
 281         u8 reg;
 282         int ret;
 283
 284         dev_dbg(di->dev, "Autopower : %d\n", di->autopower);
 285
 286         /* read the autopower register */
 287         ret = abx500_get_register_interruptible(di->dev, 0x15, 0x00, &reg);
 288         if (ret) {
 289                 dev_err(di->dev, "%d write failed\n", __LINE__);
 290                 return;
 291         }
 292
 293         /* enable the OPT emulation registers */
 294         ret = abx500_set_register_interruptible(di->dev, 0x11, 0x00, 0x2);
 295         if (ret) {
 296                 dev_err(di->dev, "%d write failed\n", __LINE__);
 297                 return;
 298         }
 299
 300         if (di->autopower)
 301                 reg |= 0x8;
 302         else
 303                 reg &= ~0x8;
 304
 305         /* write back the changed value to autopower reg */
 306         ret = abx500_set_register_interruptible(di->dev, 0x15, 0x00, reg);
 307         if (ret) {
 308                 dev_err(di->dev, "%d write failed\n", __LINE__);
 309                 return;
 310         }
 311
 312         /* disable the set OTP registers again */
 313         ret = abx500_set_register_interruptible(di->dev, 0x11, 0x00, 0x0);
 314         if (ret) {
 315                 dev_err(di->dev, "%d write failed\n", __LINE__);
 316                 return;
 317         }
 318 }
 319
 320 /**
 321  * ab8500_power_supply_changed - a wrapper with local extentions for
 322  * power_supply_changed
 323  * @di:   pointer to the ab8500_charger structure
 324  * @psy:  pointer to power_supply_that have changed.
 325  *
 326  */
 327 static void ab8500_power_supply_changed(struct ab8500_charger *di,
 328                                         struct power_supply *psy)
 329 {
 330         if (di->autopower_cfg) {
 331                 if (!di->usb.charger_connected &&
 332                     !di->ac.charger_connected &&
 333                     di->autopower) {
 334                         di->autopower = false;
 335                         ab8500_power_loss_handling(di);
 336                 } else if (!di->autopower &&
 337                            (di->ac.charger_connected ||
 338                             di->usb.charger_connected)) {
 339                         di->autopower = true;
 340                         ab8500_power_loss_handling(di);
 341                 }
 342         }
 343         power_supply_changed(psy);
 344 }
 345
 346 static void ab8500_charger_set_usb_connected(struct ab8500_charger *di,
 347         bool connected)
 348 {
 349         if (connected != di->usb.charger_connected) {
 350                 dev_dbg(di->dev, "USB connected:%i\n", connected);
 351                 di->usb.charger_connected = connected;
 352                 sysfs_notify(&di->usb_chg.psy.dev->kobj, NULL, "present");
 353         }
 354 }
 355
 356 /**
 357  * ab8500_charger_get_ac_voltage() - get ac charger voltage
 358  * @di:         pointer to the ab8500_charger structure
 359  *
 360  * Returns ac charger voltage (on success)
 361  */
 362 static int ab8500_charger_get_ac_voltage(struct ab8500_charger *di)
 363 {
 364         int vch;
 365
 366         /* Only measure voltage if the charger is connected */
 367         if (di->ac.charger_connected) {
 368                 vch = ab8500_gpadc_convert(di->gpadc, MAIN_CHARGER_V);
 369                 if (vch < 0)
 370                         dev_err(di->dev, "%s gpadc conv failed,\n", __func__);
 371         } else {
 372                 vch = 0;
 373         }
 374         return vch;
 375 }
 376
 377 /**
 378  * ab8500_charger_ac_cv() - check if the main charger is in CV mode
 379  * @di:         pointer to the ab8500_charger structure
 380  *
 381  * Returns ac charger CV mode (on success) else error code
 382  */
 383 static int ab8500_charger_ac_cv(struct ab8500_charger *di)
 384 {
 385         u8 val;
 386         int ret = 0;
 387
 388         /* Only check CV mode if the charger is online */
 389         if (di->ac.charger_online) {
 390                 ret = abx500_get_register_interruptible(di->dev, AB8500_CHARGER,
 391                         AB8500_CH_STATUS1_REG, &val);
 392                 if (ret < 0) {
 393                         dev_err(di->dev, "%s ab8500 read failed\n", __func__);
 394                         return 0;
 395                 }
 396
 397                 if (val & MAIN_CH_CV_ON)
 398                         ret = 1;
 399                 else
 400                         ret = 0;
 401         }
 402
 403         return ret;
 404 }
 405
 406 /**
 407  * ab8500_charger_get_vbus_voltage() - get vbus voltage
 408  * @di:         pointer to the ab8500_charger structure
 409  *
 410  * This function returns the vbus voltage.
 411  * Returns vbus voltage (on success)
 412  */
 413 static int ab8500_charger_get_vbus_voltage(struct ab8500_charger *di)
 414 {
 415         int vch;
 416
 417         /* Only measure voltage if the charger is connected */
 418         if (di->usb.charger_connected) {
 419                 vch = ab8500_gpadc_convert(di->gpadc, VBUS_V);
 420                 if (vch < 0)
 421                         dev_err(di->dev, "%s gpadc conv failed\n", __func__);
 422         } else {
 423                 vch = 0;
 424         }
 425         return vch;
 426 }
 427
 428 /**
 429  * ab8500_charger_get_usb_current() - get usb charger current
 430  * @di:         pointer to the ab8500_charger structure
 431  *
 432  * This function returns the usb charger current.
 433  * Returns usb current (on success) and error code on failure
 434  */
 435 static int ab8500_charger_get_usb_current(struct ab8500_charger *di)
 436 {
 437         int ich;
 438
 439         /* Only measure current if the charger is online */
 440         if (di->usb.charger_online) {
 441                 ich = ab8500_gpadc_convert(di->gpadc, USB_CHARGER_C);
 442                 if (ich < 0)
 443                         dev_err(di->dev, "%s gpadc conv failed\n", __func__);
 444         } else {
 445                 ich = 0;
 446         }
 447         return ich;
 448 }
 449
 450 /**
 451  * ab8500_charger_get_ac_current() - get ac charger current
 452  * @di:         pointer to the ab8500_charger structure
 453  *
 454  * This function returns the ac charger current.
 455  * Returns ac current (on success) and error code on failure.
 456  */
 457 static int ab8500_charger_get_ac_current(struct ab8500_charger *di)
 458 {
 459         int ich;
 460
 461         /* Only measure current if the charger is online */
 462         if (di->ac.charger_online) {
 463                 ich = ab8500_gpadc_convert(di->gpadc, MAIN_CHARGER_C);
 464                 if (ich < 0)
 465                         dev_err(di->dev, "%s gpadc conv failed\n", __func__);
 466         } else {
 467                 ich = 0;
 468         }
 469         return ich;
 470 }
 471
 472 /**
 473  * ab8500_charger_usb_cv() - check if the usb charger is in CV mode
 474  * @di:         pointer to the ab8500_charger structure
 475  *
 476  * Returns ac charger CV mode (on success) else error code
 477  */
 478 static int ab8500_charger_usb_cv(struct ab8500_charger *di)
 479 {
 480         int ret;
 481         u8 val;
 482
 483         /* Only check CV mode if the charger is online */
 484         if (di->usb.charger_online) {
 485                 ret = abx500_get_register_interruptible(di->dev, AB8500_CHARGER,
 486                         AB8500_CH_USBCH_STAT1_REG, &val);
 487                 if (ret < 0) {
 488                         dev_err(di->dev, "%s ab8500 read failed\n", __func__);
 489                         return 0;
 490                 }
 491
 492                 if (val & USB_CH_CV_ON)
 493                         ret = 1;
 494                 else
 495                         ret = 0;
 496         } else {
 497                 ret = 0;
 498         }
 499
 500         return ret;
 501 }
 502
 503 /**
 504  * ab8500_charger_detect_chargers() - Detect the connected chargers
 505  * @di:         pointer to the ab8500_charger structure
 506  *
 507  * Returns the type of charger connected.
 508  * For USB it will not mean we can actually charge from it
 509  * but that there is a USB cable connected that we have to
 510  * identify. This is used during startup when we don't get
 511  * interrupts of the charger detection
 512  *
 513  * Returns an integer value, that means,
 514  * NO_PW_CONN  no power supply is connected
 515  * AC_PW_CONN  if the AC power supply is connected
 516  * USB_PW_CONN  if the USB power supply is connected
 517  * AC_PW_CONN + USB_PW_CONN if USB and AC power supplies are both connected
 518  */
 519 static int ab8500_charger_detect_chargers(struct ab8500_charger *di)
 520 {
 521         int result = NO_PW_CONN;
 522         int ret;
 523         u8 val;
 524
 525         /* Check for AC charger */
 526         ret = abx500_get_register_interruptible(di->dev, AB8500_CHARGER,
 527                 AB8500_CH_STATUS1_REG, &val);
 528         if (ret < 0) {
 529                 dev_err(di->dev, "%s ab8500 read failed\n", __func__);
 530                 return ret;
 531         }
 532
 533         if (val & MAIN_CH_DET)
 534                 result = AC_PW_CONN;
 535
 536         /* Check for USB charger */
 537         ret = abx500_get_register_interruptible(di->dev, AB8500_CHARGER,
 538                 AB8500_CH_USBCH_STAT1_REG, &val);
 539         if (ret < 0) {
 540                 dev_err(di->dev, "%s ab8500 read failed\n", __func__);
 541                 return ret;
 542         }
 543
 544         if ((val & VBUS_DET_DBNC1) && (val & VBUS_DET_DBNC100))
 545                 result |= USB_PW_CONN;
 546
 547         return result;
 548 }
 549
 550 /**
 551  * ab8500_charger_max_usb_curr() - get the max curr for the USB type
 552  * @di:                 pointer to the ab8500_charger structure
 553  * @link_status:        the identified USB type
 554  *
 555  * Get the maximum current that is allowed to be drawn from the host
 556  * based on the USB type.
 557  * Returns error code in case of failure else 0 on success
 558  */
 559 static int ab8500_charger_max_usb_curr(struct ab8500_charger *di,
 560         enum ab8500_charger_link_status link_status)
 561 {
 562         int ret = 0;
 563
 564         switch (link_status) {
 565         case USB_STAT_STD_HOST_NC:
 566         case USB_STAT_STD_HOST_C_NS:
 567         case USB_STAT_STD_HOST_C_S:
 568                 dev_dbg(di->dev, "USB Type - Standard host is "
 569                         "detected through USB driver\n");
 570                 di->max_usb_in_curr = USB_CH_IP_CUR_LVL_0P09;
 571                 break;
 572         case USB_STAT_HOST_CHG_HS_CHIRP:
 573                 di->max_usb_in_curr = USB_CH_IP_CUR_LVL_0P5;
 574                 break;
 575         case USB_STAT_HOST_CHG_HS:
 576         case USB_STAT_ACA_RID_C_HS:
 577                 di->max_usb_in_curr = USB_CH_IP_CUR_LVL_0P9;
 578                 break;
 579         case USB_STAT_ACA_RID_A:
 580                 /*
 581                  * Dedicated charger level minus maximum current accessory
 582                  * can consume (300mA). Closest level is 1100mA
 583                  */
 584                 di->max_usb_in_curr = USB_CH_IP_CUR_LVL_1P1;
 585                 break;
 586         case USB_STAT_ACA_RID_B:
 587                 /*
 588                  * Dedicated charger level minus 120mA (20mA for ACA and
 589                  * 100mA for potential accessory). Closest level is 1300mA
 590                  */
 591                 di->max_usb_in_curr = USB_CH_IP_CUR_LVL_1P3;
 592                 break;
 593         case USB_STAT_DEDICATED_CHG:
 594         case USB_STAT_HOST_CHG_NM:
 595         case USB_STAT_ACA_RID_C_HS_CHIRP:
 596         case USB_STAT_ACA_RID_C_NM:
 597                 di->max_usb_in_curr = USB_CH_IP_CUR_LVL_1P5;
 598                 break;
 599         case USB_STAT_RESERVED:
 600                 /*
 601                  * This state is used to indicate that VBUS has dropped below
 602                  * the detection level 4 times in a row. This is due to the
 603                  * charger output current is set to high making the charger
 604                  * voltage collapse. This have to be propagated through to
 605                  * chargalg. This is done using the property
 606                  * POWER_SUPPLY_PROP_CURRENT_AVG = 1
 607                  */
 608                 di->flags.vbus_collapse = true;
 609                 dev_dbg(di->dev, "USB Type - USB_STAT_RESERVED "
 610                         "VBUS has collapsed\n");
 611                 ret = -1;
 612                 break;
 613         case USB_STAT_HM_IDGND:
 614         case USB_STAT_NOT_CONFIGURED:
 615         case USB_STAT_NOT_VALID_LINK:
 616                 dev_err(di->dev, "USB Type - Charging not allowed\n");
 617                 di->max_usb_in_curr = USB_CH_IP_CUR_LVL_0P05;
 618                 ret = -ENXIO;
 619                 break;
 620         default:
 621                 dev_err(di->dev, "USB Type - Unknown\n");
 622                 di->max_usb_in_curr = USB_CH_IP_CUR_LVL_0P05;
 623                 ret = -ENXIO;
 624                 break;
 625         };
 626
 627         dev_dbg(di->dev, "USB Type - 0x%02x MaxCurr: %d",
 628                 link_status, di->max_usb_in_curr);
 629
 630         return ret;
 631 }
 632
 633 /**
 634  * ab8500_charger_read_usb_type() - read the type of usb connected
 635  * @di:         pointer to the ab8500_charger structure
 636  *
 637  * Detect the type of the plugged USB
 638  * Returns error code in case of failure else 0 on success
 639  */
 640 static int ab8500_charger_read_usb_type(struct ab8500_charger *di)
 641 {
 642         int ret;
 643         u8 val;
 644
 645         ret = abx500_get_register_interruptible(di->dev,
 646                 AB8500_INTERRUPT, AB8500_IT_SOURCE21_REG, &val);
 647         if (ret < 0) {
 648                 dev_err(di->dev, "%s ab8500 read failed\n", __func__);
 649                 return ret;
 650         }
 651         ret = abx500_get_register_interruptible(di->dev, AB8500_USB,
 652                 AB8500_USB_LINE_STAT_REG, &val);
 653         if (ret < 0) {
 654                 dev_err(di->dev, "%s ab8500 read failed\n", __func__);
 655                 return ret;
 656         }
 657
 658         /* get the USB type */
 659         val = (val & AB8500_USB_LINK_STATUS) >> 3;
 660         ret = ab8500_charger_max_usb_curr(di,
 661                 (enum ab8500_charger_link_status) val);
 662
 663         return ret;
 664 }
 665
 666 /**
 667  * ab8500_charger_detect_usb_type() - get the type of usb connected
 668  * @di:         pointer to the ab8500_charger structure
 669  *
 670  * Detect the type of the plugged USB
 671  * Returns error code in case of failure else 0 on success
 672  */
 673 static int ab8500_charger_detect_usb_type(struct ab8500_charger *di)
 674 {
 675         int i, ret;
 676         u8 val;
 677
 678         /*
 679          * On getting the VBUS rising edge detect interrupt there
 680          * is a 250ms delay after which the register UsbLineStatus
 681          * is filled with valid data.
 682          */
 683         for (i = 0; i < 10; i++) {
 684                 msleep(250);
 685                 ret = abx500_get_register_interruptible(di->dev,
 686                         AB8500_INTERRUPT, AB8500_IT_SOURCE21_REG,
 687                         &val);
 688                 if (ret < 0) {
 689                         dev_err(di->dev, "%s ab8500 read failed\n", __func__);
 690                         return ret;
 691                 }
 692                 ret = abx500_get_register_interruptible(di->dev, AB8500_USB,
 693                         AB8500_USB_LINE_STAT_REG, &val);
 694                 if (ret < 0) {
 695                         dev_err(di->dev, "%s ab8500 read failed\n", __func__);
 696                         return ret;
 697                 }
 698                 /*
 699                  * Until the IT source register is read the UsbLineStatus
 700                  * register is not updated, hence doing the same
 701                  * Revisit this:
 702                  */
 703
 704                 /* get the USB type */
 705                 val = (val & AB8500_USB_LINK_STATUS) >> 3;
 706                 if (val)
 707                         break;
 708         }
 709         ret = ab8500_charger_max_usb_curr(di,
 710                 (enum ab8500_charger_link_status) val);
 711
 712         return ret;
 713 }
 714
 715 /*
 716  * This array maps the raw hex value to charger voltage used by the AB8500
 717  * Values taken from the UM0836
 718  */
 719 static int ab8500_charger_voltage_map[] = {
 720         3500 ,
 721         3525 ,
 722         3550 ,
 723         3575 ,
 724         3600 ,
 725         3625 ,
 726         3650 ,
 727         3675 ,
 728         3700 ,
 729         3725 ,
 730         3750 ,
 731         3775 ,
 732         3800 ,
 733         3825 ,
 734         3850 ,
 735         3875 ,
 736         3900 ,
 737         3925 ,
 738         3950 ,
 739         3975 ,
 740         4000 ,
 741         4025 ,
 742         4050 ,
 743         4060 ,
 744         4070 ,
 745         4080 ,
 746         4090 ,
 747         4100 ,
 748         4110 ,
 749         4120 ,
 750         4130 ,
 751         4140 ,
 752         4150 ,
 753         4160 ,
 754         4170 ,
 755         4180 ,
 756         4190 ,
 757         4200 ,
 758         4210 ,
 759         4220 ,
 760         4230 ,
 761         4240 ,
 762         4250 ,
 763         4260 ,
 764         4270 ,
 765         4280 ,
 766         4290 ,
 767         4300 ,
 768         4310 ,
 769         4320 ,
 770         4330 ,
 771         4340 ,
 772         4350 ,
 773         4360 ,
 774         4370 ,
 775         4380 ,
 776         4390 ,
 777         4400 ,
 778         4410 ,
 779         4420 ,
 780         4430 ,
 781         4440 ,
 782         4450 ,
 783         4460 ,
 784         4470 ,
 785         4480 ,
 786         4490 ,
 787         4500 ,
 788         4510 ,
 789         4520 ,
 790         4530 ,
 791         4540 ,
 792         4550 ,
 793         4560 ,
 794         4570 ,
 795         4580 ,
 796         4590 ,
 797         4600 ,
 798 };
 799
 800 /*
 801  * This array maps the raw hex value to charger current used by the AB8500
 802  * Values taken from the UM0836
 803  */
 804 static int ab8500_charger_current_map[] = {
 805         100 ,
 806         200 ,
 807         300 ,
 808         400 ,
 809         500 ,
 810         600 ,
 811         700 ,
 812         800 ,
 813         900 ,
 814         1000 ,
 815         1100 ,
 816         1200 ,
 817         1300 ,
 818         1400 ,
 819         1500 ,
 820 };
 821
 822 /*
 823  * This array maps the raw hex value to VBUS input current used by the AB8500
 824  * Values taken from the UM0836
 825  */
 826 static int ab8500_charger_vbus_in_curr_map[] = {
 827         USB_CH_IP_CUR_LVL_0P05,
 828         USB_CH_IP_CUR_LVL_0P09,
 829         USB_CH_IP_CUR_LVL_0P19,
 830         USB_CH_IP_CUR_LVL_0P29,
 831         USB_CH_IP_CUR_LVL_0P38,
 832         USB_CH_IP_CUR_LVL_0P45,
 833         USB_CH_IP_CUR_LVL_0P5,
 834         USB_CH_IP_CUR_LVL_0P6,
 835         USB_CH_IP_CUR_LVL_0P7,
 836         USB_CH_IP_CUR_LVL_0P8,
 837         USB_CH_IP_CUR_LVL_0P9,
 838         USB_CH_IP_CUR_LVL_1P0,
 839         USB_CH_IP_CUR_LVL_1P1,
 840         USB_CH_IP_CUR_LVL_1P3,
 841         USB_CH_IP_CUR_LVL_1P4,
 842         USB_CH_IP_CUR_LVL_1P5,
 843 };
 844
 845 static int ab8500_voltage_to_regval(int voltage)
 846 {
 847         int i;
 848
 849         /* Special case for voltage below 3.5V */
 850         if (voltage < ab8500_charger_voltage_map[0])
 851                 return LOW_VOLT_REG;
 852
 853         for (i = 1; i < ARRAY_SIZE(ab8500_charger_voltage_map); i++) {
 854                 if (voltage < ab8500_charger_voltage_map[i])
 855                         return i - 1;
 856         }
 857
 858         /* If not last element, return error */
 859         i = ARRAY_SIZE(ab8500_charger_voltage_map) - 1;
 860         if (voltage == ab8500_charger_voltage_map[i])
 861                 return i;
 862         else
 863                 return -1;
 864 }
 865
 866 static int ab8500_current_to_regval(int curr)
 867 {
 868         int i;
 869
 870         if (curr < ab8500_charger_current_map[0])
 871                 return 0;
 872
 873         for (i = 0; i < ARRAY_SIZE(ab8500_charger_current_map); i++) {
 874                 if (curr < ab8500_charger_current_map[i])
 875                         return i - 1;
 876         }
 877
 878         /* If not last element, return error */
 879         i = ARRAY_SIZE(ab8500_charger_current_map) - 1;
 880         if (curr == ab8500_charger_current_map[i])
 881                 return i;
 882         else
 883                 return -1;
 884 }
 885
 886 static int ab8500_vbus_in_curr_to_regval(int curr)
 887 {
 888         int i;
 889
 890         if (curr < ab8500_charger_vbus_in_curr_map[0])
 891                 return 0;
 892
 893         for (i = 0; i < ARRAY_SIZE(ab8500_charger_vbus_in_curr_map); i++) {
 894                 if (curr < ab8500_charger_vbus_in_curr_map[i])
 895                         return i - 1;
 896         }
 897
 898         /* If not last element, return error */
 899         i = ARRAY_SIZE(ab8500_charger_vbus_in_curr_map) - 1;
 900         if (curr == ab8500_charger_vbus_in_curr_map[i])
 901                 return i;
 902         else
 903                 return -1;
 904 }
 905
 906 /**
 907  * ab8500_charger_get_usb_cur() - get usb current
 908  * @di:         pointer to the ab8500_charger structre
 909  *
 910  * The usb stack provides the maximum current that can be drawn from
 911  * the standard usb host. This will be in mA.
 912  * This function converts current in mA to a value that can be written
 913  * to the register. Returns -1 if charging is not allowed
 914  */
 915 static int ab8500_charger_get_usb_cur(struct ab8500_charger *di)
 916 {
 917         switch (di->usb_state.usb_current) {
 918         case 100:
 919                 di->max_usb_in_curr = USB_CH_IP_CUR_LVL_0P09;
 920                 break;
 921         case 200:
 922                 di->max_usb_in_curr = USB_CH_IP_CUR_LVL_0P19;
 923                 break;
 924         case 300:
 925                 di->max_usb_in_curr = USB_CH_IP_CUR_LVL_0P29;
 926                 break;
 927         case 400:
 928                 di->max_usb_in_curr = USB_CH_IP_CUR_LVL_0P38;
 929                 break;
 930         case 500:
 931                 di->max_usb_in_curr = USB_CH_IP_CUR_LVL_0P5;
 932                 break;
 933         default:
 934                 di->max_usb_in_curr = USB_CH_IP_CUR_LVL_0P05;
 935                 return -1;
 936                 break;
 937         };
 938         return 0;
 939 }
 940
 941 /**
 942  * ab8500_charger_set_current() - set charger current
 943  * @di:         pointer to the ab8500_charger structure
 944  * @ich:        charger current, in mA
 945  * @reg:        select what charger register to set
 946  *
 947  * Set charger current.
 948  * There is no state machine in the AB to step up/down the charger
 949  * current to avoid dips and spikes on MAIN, VBUS and VBAT when
 950  * charging is started. Instead we need to implement
 951  * this charger current step-up/down here.
 952  * Returns error code in case of failure else 0(on success)
 953  */
 954 static int ab8500_charger_set_current(struct ab8500_charger *di,
 955         int ich, int reg)
 956 {
 957         int ret, i;
 958         int curr_index, prev_curr_index, shift_value;
 959         u8 reg_value;
 960
 961         switch (reg) {
 962         case AB8500_MCH_IPT_CURLVL_REG:
 963                 shift_value = MAIN_CH_INPUT_CURR_SHIFT;
 964                 curr_index = ab8500_current_to_regval(ich);
 965                 break;
 966         case AB8500_USBCH_IPT_CRNTLVL_REG:
 967                 shift_value = VBUS_IN_CURR_LIM_SHIFT;
 968                 curr_index = ab8500_vbus_in_curr_to_regval(ich);
 969                 break;
 970         case AB8500_CH_OPT_CRNTLVL_REG:
 971                 shift_value = 0;
 972                 curr_index = ab8500_current_to_regval(ich);
 973                 break;
 974         default:
 975                 dev_err(di->dev, "%s current register not valid\n", __func__);
 976                 return -ENXIO;
 977         }
 978
 979         if (curr_index < 0) {
 980                 dev_err(di->dev, "requested current limit out-of-range\n");
 981                 return -ENXIO;
 982         }
 983
 984         ret = abx500_get_register_interruptible(di->dev, AB8500_CHARGER,
 985                 reg, &reg_value);
 986         if (ret < 0) {
 987                 dev_err(di->dev, "%s read failed\n", __func__);
 988                 return ret;
 989         }
 990         prev_curr_index = (reg_value >> shift_value);
 991
 992         /* only update current if it's been changed */
 993         if (prev_curr_index == curr_index)
 994                 return 0;
 995
 996         dev_dbg(di->dev, "%s set charger current: %d mA for reg: 0x%02x\n",
 997                 __func__, ich, reg);
 998
 999         if (prev_curr_index > curr_index) {
1000                 for (i = prev_curr_index - 1; i >= curr_index; i--) {
1001                         ret = abx500_set_register_interruptible(di->dev,
1002                                 AB8500_CHARGER, reg, (u8) i << shift_value);
1003                         if (ret) {
1004                                 dev_err(di->dev, "%s write failed\n", __func__);
1005                                 return ret;
1006                         }
1007                         usleep_range(STEP_UDELAY, STEP_UDELAY * 2);
1008                 }
1009         } else {
1010                 for (i = prev_curr_index + 1; i <= curr_index; i++) {
1011                         ret = abx500_set_register_interruptible(di->dev,
1012                                 AB8500_CHARGER, reg, (u8) i << shift_value);
1013                         if (ret) {
1014                                 dev_err(di->dev, "%s write failed\n", __func__);
1015                                 return ret;
1016                         }
1017                         usleep_range(STEP_UDELAY, STEP_UDELAY * 2);
1018                 }
1019         }
1020         return ret;
1021 }
1022
1023 /**
1024  * ab8500_charger_set_vbus_in_curr() - set VBUS input current limit
1025  * @di:         pointer to the ab8500_charger structure
1026  * @ich_in:     charger input current limit
1027  *
1028  * Sets the current that can be drawn from the USB host
1029  * Returns error code in case of failure else 0(on success)
1030  */
1031 static int ab8500_charger_set_vbus_in_curr(struct ab8500_charger *di,
1032                 int ich_in)
1033 {
1034         int min_value;
1035
1036         /* We should always use to lowest current limit */
1037         min_value = min(di->bm->chg_params->usb_curr_max, ich_in);
1038
1039         switch (min_value) {
1040         case 100:
1041                 if (di->vbat < VBAT_TRESH_IP_CUR_RED)
1042                         min_value = USB_CH_IP_CUR_LVL_0P05;
1043                 break;
1044         case 500:
1045                 if (di->vbat < VBAT_TRESH_IP_CUR_RED)
1046                         min_value = USB_CH_IP_CUR_LVL_0P45;
1047                 break;
1048         default:
1049                 break;
1050         }
1051
1052         return ab8500_charger_set_current(di, min_value,
1053                 AB8500_USBCH_IPT_CRNTLVL_REG);
1054 }
1055
1056 /**
1057  * ab8500_charger_set_main_in_curr() - set main charger input current
1058  * @di:         pointer to the ab8500_charger structure
1059  * @ich_in:     input charger current, in mA
1060  *
1061  * Set main charger input current.
1062  * Returns error code in case of failure else 0(on success)
1063  */
1064 static int ab8500_charger_set_main_in_curr(struct ab8500_charger *di,
1065         int ich_in)
1066 {
1067         return ab8500_charger_set_current(di, ich_in,
1068                 AB8500_MCH_IPT_CURLVL_REG);
1069 }
1070
1071 /**
1072  * ab8500_charger_set_output_curr() - set charger output current
1073  * @di:         pointer to the ab8500_charger structure
1074  * @ich_out:    output charger current, in mA
1075  *
1076  * Set charger output current.
1077  * Returns error code in case of failure else 0(on success)
1078  */
1079 static int ab8500_charger_set_output_curr(struct ab8500_charger *di,
1080         int ich_out)
1081 {
1082         return ab8500_charger_set_current(di, ich_out,
1083                 AB8500_CH_OPT_CRNTLVL_REG);
1084 }
1085
1086 /**
1087  * ab8500_charger_led_en() - turn on/off chargign led
1088  * @di:         pointer to the ab8500_charger structure
1089  * @on:         flag to turn on/off the chargign led
1090  *
1091  * Power ON/OFF charging LED indication
1092  * Returns error code in case of failure else 0(on success)
1093  */
1094 static int ab8500_charger_led_en(struct ab8500_charger *di, int on)
1095 {
1096         int ret;
1097
1098         if (on) {
1099                 /* Power ON charging LED indicator, set LED current to 5mA */
1100                 ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
1101                         AB8500_LED_INDICATOR_PWM_CTRL,
1102                         (LED_IND_CUR_5MA | LED_INDICATOR_PWM_ENA));
1103                 if (ret) {
1104                         dev_err(di->dev, "Power ON LED failed\n");
1105                         return ret;
1106                 }
1107                 /* LED indicator PWM duty cycle 252/256 */
1108                 ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
1109                         AB8500_LED_INDICATOR_PWM_DUTY,
1110                         LED_INDICATOR_PWM_DUTY_252_256);
1111                 if (ret) {
1112                         dev_err(di->dev, "Set LED PWM duty cycle failed\n");
1113                         return ret;
1114                 }
1115         } else {
1116                 /* Power off charging LED indicator */
1117                 ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
1118                         AB8500_LED_INDICATOR_PWM_CTRL,
1119                         LED_INDICATOR_PWM_DIS);
1120                 if (ret) {
1121                         dev_err(di->dev, "Power-off LED failed\n");
1122                         return ret;
1123                 }
1124         }
1125
1126         return ret;
1127 }
1128
1129 /**
1130  * ab8500_charger_ac_en() - enable or disable ac charging
1131  * @di:         pointer to the ab8500_charger structure
1132  * @enable:     enable/disable flag
1133  * @vset:       charging voltage
1134  * @iset:       charging current
1135  *
1136  * Enable/Disable AC/Mains charging and turns on/off the charging led
1137  * respectively.
1138  **/
1139 static int ab8500_charger_ac_en(struct ux500_charger *charger,
1140         int enable, int vset, int iset)
1141 {
1142         int ret;
1143         int volt_index;
1144         int curr_index;
1145         int input_curr_index;
1146         u8 overshoot = 0;
1147
1148         struct ab8500_charger *di = to_ab8500_charger_ac_device_info(charger);
1149
1150         if (enable) {
1151                 /* Check if AC is connected */
1152                 if (!di->ac.charger_connected) {
1153                         dev_err(di->dev, "AC charger not connected\n");
1154                         return -ENXIO;
1155                 }
1156
1157                 /* Enable AC charging */
1158                 dev_dbg(di->dev, "Enable AC: %dmV %dmA\n", vset, iset);
1159
1160                 /*
1161                  * Due to a bug in AB8500, BTEMP_HIGH/LOW interrupts
1162                  * will be triggered everytime we enable the VDD ADC supply.
1163                  * This will turn off charging for a short while.
1164                  * It can be avoided by having the supply on when
1165                  * there is a charger enabled. Normally the VDD ADC supply
1166                  * is enabled everytime a GPADC conversion is triggered. We will
1167                  * force it to be enabled from this driver to have
1168                  * the GPADC module independant of the AB8500 chargers
1169                  */
1170                 if (!di->vddadc_en_ac) {
1171                         regulator_enable(di->regu);
1172                         di->vddadc_en_ac = true;
1173                 }
1174
1175                 /* Check if the requested voltage or current is valid */
1176                 volt_index = ab8500_voltage_to_regval(vset);
1177                 curr_index = ab8500_current_to_regval(iset);
1178                 input_curr_index = ab8500_current_to_regval(
1179                         di->bm->chg_params->ac_curr_max);
1180                 if (volt_index < 0 || curr_index < 0 || input_curr_index < 0) {
1181                         dev_err(di->dev,
1182                                 "Charger voltage or current too high, "
1183                                 "charging not started\n");
1184                         return -ENXIO;
1185                 }
1186
1187                 /* ChVoltLevel: maximum battery charging voltage */
1188                 ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
1189                         AB8500_CH_VOLT_LVL_REG, (u8) volt_index);
1190                 if (ret) {
1191                         dev_err(di->dev, "%s write failed\n", __func__);
1192                         return ret;
1193                 }
1194                 /* MainChInputCurr: current that can be drawn from the charger*/
1195                 ret = ab8500_charger_set_main_in_curr(di,
1196                         di->bm->chg_params->ac_curr_max);
1197                 if (ret) {
1198                         dev_err(di->dev, "%s Failed to set MainChInputCurr\n",
1199                                 __func__);
1200                         return ret;
1201                 }
1202                 /* ChOutputCurentLevel: protected output current */
1203                 ret = ab8500_charger_set_output_curr(di, iset);
1204                 if (ret) {
1205                         dev_err(di->dev, "%s "
1206                                 "Failed to set ChOutputCurentLevel\n",
1207                                 __func__);
1208                         return ret;
1209                 }
1210
1211                 /* Check if VBAT overshoot control should be enabled */
1212                 if (!di->bm->enable_overshoot)
1213                         overshoot = MAIN_CH_NO_OVERSHOOT_ENA_N;
1214
1215                 /* Enable Main Charger */
1216                 ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
1217                         AB8500_MCH_CTRL1, MAIN_CH_ENA | overshoot);
1218                 if (ret) {
1219                         dev_err(di->dev, "%s write failed\n", __func__);
1220                         return ret;
1221                 }
1222
1223                 /* Power on charging LED indication */
1224                 ret = ab8500_charger_led_en(di, true);
1225                 if (ret < 0)
1226                         dev_err(di->dev, "failed to enable LED\n");
1227
1228                 di->ac.charger_online = 1;
1229         } else {
1230                 /* Disable AC charging */
1231                 if (is_ab8500_1p1_or_earlier(di->parent)) {
1232                         /*
1233                          * For ABB revision 1.0 and 1.1 there is a bug in the
1234                          * watchdog logic. That means we have to continously
1235                          * kick the charger watchdog even when no charger is
1236                          * connected. This is only valid once the AC charger
1237                          * has been enabled. This is a bug that is not handled
1238                          * by the algorithm and the watchdog have to be kicked
1239                          * by the charger driver when the AC charger
1240                          * is disabled
1241                          */
1242                         if (di->ac_conn) {
1243                                 queue_delayed_work(di->charger_wq,
1244                                         &di->kick_wd_work,
1245                                         round_jiffies(WD_KICK_INTERVAL));
1246                         }
1247
1248                         /*
1249                          * We can't turn off charging completely
1250                          * due to a bug in AB8500 cut1.
1251                          * If we do, charging will not start again.
1252                          * That is why we set the lowest voltage
1253                          * and current possible
1254                          */
1255                         ret = abx500_set_register_interruptible(di->dev,
1256                                 AB8500_CHARGER,
1257                                 AB8500_CH_VOLT_LVL_REG, CH_VOL_LVL_3P5);
1258                         if (ret) {
1259                                 dev_err(di->dev,
1260                                         "%s write failed\n", __func__);
1261                                 return ret;
1262                         }
1263
1264                         ret = ab8500_charger_set_output_curr(di, 0);
1265                         if (ret) {
1266                                 dev_err(di->dev, "%s "
1267                                         "Failed to set ChOutputCurentLevel\n",
1268                                         __func__);
1269                                 return ret;
1270                         }
1271                 } else {
1272                         ret = abx500_set_register_interruptible(di->dev,
1273                                 AB8500_CHARGER,
1274                                 AB8500_MCH_CTRL1, 0);
1275                         if (ret) {
1276                                 dev_err(di->dev,
1277                                         "%s write failed\n", __func__);
1278                                 return ret;
1279                         }
1280                 }
1281
1282                 ret = ab8500_charger_led_en(di, false);
1283                 if (ret < 0)
1284                         dev_err(di->dev, "failed to disable LED\n");
1285
1286                 di->ac.charger_online = 0;
1287                 di->ac.wd_expired = false;
1288
1289                 /* Disable regulator if enabled */
1290                 if (di->vddadc_en_ac) {
1291                         regulator_disable(di->regu);
1292                         di->vddadc_en_ac = false;
1293                 }
1294
1295                 dev_dbg(di->dev, "%s Disabled AC charging\n", __func__);
1296         }
1297         ab8500_power_supply_changed(di, &di->ac_chg.psy);
1298
1299         return ret;
1300 }
1301
1302 /**
1303  * ab8500_charger_usb_en() - enable usb charging
1304  * @di:         pointer to the ab8500_charger structure
1305  * @enable:     enable/disable flag
1306  * @vset:       charging voltage
1307  * @ich_out:    charger output current
1308  *
1309  * Enable/Disable USB charging and turns on/off the charging led respectively.
1310  * Returns error code in case of failure else 0(on success)
1311  */
1312 static int ab8500_charger_usb_en(struct ux500_charger *charger,
1313         int enable, int vset, int ich_out)
1314 {
1315         int ret;
1316         int volt_index;
1317         int curr_index;
1318         u8 overshoot = 0;
1319
1320         struct ab8500_charger *di = to_ab8500_charger_usb_device_info(charger);
1321
1322         if (enable) {
1323                 /* Check if USB is connected */
1324                 if (!di->usb.charger_connected) {
1325                         dev_err(di->dev, "USB charger not connected\n");
1326                         return -ENXIO;
1327                 }
1328
1329                 /*
1330                  * Due to a bug in AB8500, BTEMP_HIGH/LOW interrupts
1331                  * will be triggered everytime we enable the VDD ADC supply.
1332                  * This will turn off charging for a short while.
1333                  * It can be avoided by having the supply on when
1334                  * there is a charger enabled. Normally the VDD ADC supply
1335                  * is enabled everytime a GPADC conversion is triggered. We will
1336                  * force it to be enabled from this driver to have
1337                  * the GPADC module independant of the AB8500 chargers
1338                  */
1339                 if (!di->vddadc_en_usb) {
1340                         regulator_enable(di->regu);
1341                         di->vddadc_en_usb = true;
1342                 }
1343
1344                 /* Enable USB charging */
1345                 dev_dbg(di->dev, "Enable USB: %dmV %dmA\n", vset, ich_out);
1346
1347                 /* Check if the requested voltage or current is valid */
1348                 volt_index = ab8500_voltage_to_regval(vset);
1349                 curr_index = ab8500_current_to_regval(ich_out);
1350                 if (volt_index < 0 || curr_index < 0) {
1351                         dev_err(di->dev,
1352                                 "Charger voltage or current too high, "
1353                                 "charging not started\n");
1354                         return -ENXIO;
1355                 }
1356
1357                 /* ChVoltLevel: max voltage upto which battery can be charged */
1358                 ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
1359                         AB8500_CH_VOLT_LVL_REG, (u8) volt_index);
1360                 if (ret) {
1361                         dev_err(di->dev, "%s write failed\n", __func__);
1362                         return ret;
1363                 }
1364                 /* USBChInputCurr: current that can be drawn from the usb */
1365                 ret = ab8500_charger_set_vbus_in_curr(di, di->max_usb_in_curr);
1366                 if (ret) {
1367                         dev_err(di->dev, "setting USBChInputCurr failed\n");
1368                         return ret;
1369                 }
1370                 /* ChOutputCurentLevel: protected output current */
1371                 ret = ab8500_charger_set_output_curr(di, ich_out);
1372                 if (ret) {
1373                         dev_err(di->dev, "%s "
1374                                 "Failed to set ChOutputCurentLevel\n",
1375                                 __func__);
1376                         return ret;
1377                 }
1378                 /* Check if VBAT overshoot control should be enabled */
1379                 if (!di->bm->enable_overshoot)
1380                         overshoot = USB_CHG_NO_OVERSHOOT_ENA_N;
1381
1382                 /* Enable USB Charger */
1383                 ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
1384                         AB8500_USBCH_CTRL1_REG, USB_CH_ENA | overshoot);
1385                 if (ret) {
1386                         dev_err(di->dev, "%s write failed\n", __func__);
1387                         return ret;
1388                 }
1389
1390                 /* If success power on charging LED indication */
1391                 ret = ab8500_charger_led_en(di, true);
1392                 if (ret < 0)
1393                         dev_err(di->dev, "failed to enable LED\n");
1394
1395                 queue_delayed_work(di->charger_wq, &di->check_vbat_work, HZ);
1396
1397                 di->usb.charger_online = 1;
1398         } else {
1399                 /* Disable USB charging */
1400                 ret = abx500_set_register_interruptible(di->dev,
1401                         AB8500_CHARGER,
1402                         AB8500_USBCH_CTRL1_REG, 0);
1403                 if (ret) {
1404                         dev_err(di->dev,
1405                                 "%s write failed\n", __func__);
1406                         return ret;
1407                 }
1408
1409                 ret = ab8500_charger_led_en(di, false);
1410                 if (ret < 0)
1411                         dev_err(di->dev, "failed to disable LED\n");
1412
1413                 di->usb.charger_online = 0;
1414                 di->usb.wd_expired = false;
1415
1416                 /* Disable regulator if enabled */
1417                 if (di->vddadc_en_usb) {
1418                         regulator_disable(di->regu);
1419                         di->vddadc_en_usb = false;
1420                 }
1421
1422                 dev_dbg(di->dev, "%s Disabled USB charging\n", __func__);
1423
1424                 /* Cancel any pending Vbat check work */
1425                 if (delayed_work_pending(&di->check_vbat_work))
1426                         cancel_delayed_work(&di->check_vbat_work);
1427
1428         }
1429         ab8500_power_supply_changed(di, &di->usb_chg.psy);
1430
1431         return ret;
1432 }
1433
1434 /**
1435  * ab8500_charger_watchdog_kick() - kick charger watchdog
1436  * @di:         pointer to the ab8500_charger structure
1437  *
1438  * Kick charger watchdog
1439  * Returns error code in case of failure else 0(on success)
1440  */
1441 static int ab8500_charger_watchdog_kick(struct ux500_charger *charger)
1442 {
1443         int ret;
1444         struct ab8500_charger *di;
1445
1446         if (charger->psy.type == POWER_SUPPLY_TYPE_MAINS)
1447                 di = to_ab8500_charger_ac_device_info(charger);
1448         else if (charger->psy.type == POWER_SUPPLY_TYPE_USB)
1449                 di = to_ab8500_charger_usb_device_info(charger);
1450         else
1451                 return -ENXIO;
1452
1453         ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
1454                 AB8500_CHARG_WD_CTRL, CHARG_WD_KICK);
1455         if (ret)
1456                 dev_err(di->dev, "Failed to kick WD!\n");
1457
1458         return ret;
1459 }
1460
1461 /**
1462  * ab8500_charger_update_charger_current() - update charger current
1463  * @di:         pointer to the ab8500_charger structure
1464  *
1465  * Update the charger output current for the specified charger
1466  * Returns error code in case of failure else 0(on success)
1467  */
1468 static int ab8500_charger_update_charger_current(struct ux500_charger *charger,
1469                 int ich_out)
1470 {
1471         int ret;
1472         struct ab8500_charger *di;
1473
1474         if (charger->psy.type == POWER_SUPPLY_TYPE_MAINS)
1475                 di = to_ab8500_charger_ac_device_info(charger);
1476         else if (charger->psy.type == POWER_SUPPLY_TYPE_USB)
1477                 di = to_ab8500_charger_usb_device_info(charger);
1478         else
1479                 return -ENXIO;
1480
1481         ret = ab8500_charger_set_output_curr(di, ich_out);
1482         if (ret) {
1483                 dev_err(di->dev, "%s "
1484                         "Failed to set ChOutputCurentLevel\n",
1485                         __func__);
1486                 return ret;
1487         }
1488
1489         /* Reset the main and usb drop input current measurement counter */
1490         ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
1491                                 AB8500_CHARGER_CTRL,
1492                                 0x1);
1493         if (ret) {
1494                 dev_err(di->dev, "%s write failed\n", __func__);
1495                 return ret;
1496         }
1497
1498         return ret;
1499 }
1500
1501 static int ab8500_charger_get_ext_psy_data(struct device *dev, void *data)
1502 {
1503         struct power_supply *psy;
1504         struct power_supply *ext;
1505         struct ab8500_charger *di;
1506         union power_supply_propval ret;
1507         int i, j;
1508         bool psy_found = false;
1509         struct ux500_charger *usb_chg;
1510
1511         usb_chg = (struct ux500_charger *)data;
1512         psy = &usb_chg->psy;
1513
1514         di = to_ab8500_charger_usb_device_info(usb_chg);
1515
1516         ext = dev_get_drvdata(dev);
1517
1518         /* For all psy where the driver name appears in any supplied_to */
1519         for (i = 0; i < ext->num_supplicants; i++) {
1520                 if (!strcmp(ext->supplied_to[i], psy->name))
1521                         psy_found = true;
1522         }
1523
1524         if (!psy_found)
1525                 return 0;
1526
1527         /* Go through all properties for the psy */
1528         for (j = 0; j < ext->num_properties; j++) {
1529                 enum power_supply_property prop;
1530                 prop = ext->properties[j];
1531
1532                 if (ext->get_property(ext, prop, &ret))
1533                         continue;
1534
1535                 switch (prop) {
1536                 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
1537                         switch (ext->type) {
1538                         case POWER_SUPPLY_TYPE_BATTERY:
1539                                 di->vbat = ret.intval / 1000;
1540                                 break;
1541                         default:
1542                                 break;
1543                         }
1544                         break;
1545                 default:
1546                         break;
1547                 }
1548         }
1549         return 0;
1550 }
1551
1552 /**
1553  * ab8500_charger_check_vbat_work() - keep vbus current within spec
1554  * @work        pointer to the work_struct structure
1555  *
1556  * Due to a asic bug it is necessary to lower the input current to the vbus
1557  * charger when charging with at some specific levels. This issue is only valid
1558  * for below a certain battery voltage. This function makes sure that the
1559  * the allowed current limit isn't exceeded.
1560  */
1561 static void ab8500_charger_check_vbat_work(struct work_struct *work)
1562 {
1563         int t = 10;
1564         struct ab8500_charger *di = container_of(work,
1565                 struct ab8500_charger, check_vbat_work.work);
1566
1567         class_for_each_device(power_supply_class, NULL,
1568                 &di->usb_chg.psy, ab8500_charger_get_ext_psy_data);
1569
1570         /* First run old_vbat is 0. */
1571         if (di->old_vbat == 0)
1572                 di->old_vbat = di->vbat;
1573
1574         if (!((di->old_vbat <= VBAT_TRESH_IP_CUR_RED &&
1575                 di->vbat <= VBAT_TRESH_IP_CUR_RED) ||
1576                 (di->old_vbat > VBAT_TRESH_IP_CUR_RED &&
1577                 di->vbat > VBAT_TRESH_IP_CUR_RED))) {
1578
1579                 dev_dbg(di->dev, "Vbat did cross threshold, curr: %d, new: %d,"
1580                         " old: %d\n", di->max_usb_in_curr, di->vbat,
1581                         di->old_vbat);
1582                 ab8500_charger_set_vbus_in_curr(di, di->max_usb_in_curr);
1583                 power_supply_changed(&di->usb_chg.psy);
1584         }
1585
1586         di->old_vbat = di->vbat;
1587
1588         /*
1589          * No need to check the battery voltage every second when not close to
1590          * the threshold.
1591          */
1592         if (di->vbat < (VBAT_TRESH_IP_CUR_RED + 100) &&
1593                 (di->vbat > (VBAT_TRESH_IP_CUR_RED - 100)))
1594                         t = 1;
1595
1596         queue_delayed_work(di->charger_wq, &di->check_vbat_work, t * HZ);
1597 }
1598
1599 /**
1600  * ab8500_charger_check_hw_failure_work() - check main charger failure
1601  * @work:       pointer to the work_struct structure
1602  *
1603  * Work queue function for checking the main charger status
1604  */
1605 static void ab8500_charger_check_hw_failure_work(struct work_struct *work)
1606 {
1607         int ret;
1608         u8 reg_value;
1609
1610         struct ab8500_charger *di = container_of(work,
1611                 struct ab8500_charger, check_hw_failure_work.work);
1612
1613         /* Check if the status bits for HW failure is still active */
1614         if (di->flags.mainextchnotok) {
1615                 ret = abx500_get_register_interruptible(di->dev,
1616                         AB8500_CHARGER, AB8500_CH_STATUS2_REG, &reg_value);
1617                 if (ret < 0) {
1618                         dev_err(di->dev, "%s ab8500 read failed\n", __func__);
1619                         return;
1620                 }
1621                 if (!(reg_value & MAIN_CH_NOK)) {
1622                         di->flags.mainextchnotok = false;
1623                         ab8500_power_supply_changed(di, &di->ac_chg.psy);
1624                 }
1625         }
1626         if (di->flags.vbus_ovv) {
1627                 ret = abx500_get_register_interruptible(di->dev,
1628                         AB8500_CHARGER, AB8500_CH_USBCH_STAT2_REG,
1629                         &reg_value);
1630                 if (ret < 0) {
1631                         dev_err(di->dev, "%s ab8500 read failed\n", __func__);
1632                         return;
1633                 }
1634                 if (!(reg_value & VBUS_OVV_TH)) {
1635                         di->flags.vbus_ovv = false;
1636                         ab8500_power_supply_changed(di, &di->usb_chg.psy);
1637                 }
1638         }
1639         /* If we still have a failure, schedule a new check */
1640         if (di->flags.mainextchnotok || di->flags.vbus_ovv) {
1641                 queue_delayed_work(di->charger_wq,
1642                         &di->check_hw_failure_work, round_jiffies(HZ));
1643         }
1644 }
1645
1646 /**
1647  * ab8500_charger_kick_watchdog_work() - kick the watchdog
1648  * @work:       pointer to the work_struct structure
1649  *
1650  * Work queue function for kicking the charger watchdog.
1651  *
1652  * For ABB revision 1.0 and 1.1 there is a bug in the watchdog
1653  * logic. That means we have to continously kick the charger
1654  * watchdog even when no charger is connected. This is only
1655  * valid once the AC charger has been enabled. This is
1656  * a bug that is not handled by the algorithm and the
1657  * watchdog have to be kicked by the charger driver
1658  * when the AC charger is disabled
1659  */
1660 static void ab8500_charger_kick_watchdog_work(struct work_struct *work)
1661 {
1662         int ret;
1663
1664         struct ab8500_charger *di = container_of(work,
1665                 struct ab8500_charger, kick_wd_work.work);
1666
1667         ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
1668                 AB8500_CHARG_WD_CTRL, CHARG_WD_KICK);
1669         if (ret)
1670                 dev_err(di->dev, "Failed to kick WD!\n");
1671
1672         /* Schedule a new watchdog kick */
1673         queue_delayed_work(di->charger_wq,
1674                 &di->kick_wd_work, round_jiffies(WD_KICK_INTERVAL));
1675 }
1676
1677 /**
1678  * ab8500_charger_ac_work() - work to get and set main charger status
1679  * @work:       pointer to the work_struct structure
1680  *
1681  * Work queue function for checking the main charger status
1682  */
1683 static void ab8500_charger_ac_work(struct work_struct *work)
1684 {
1685         int ret;
1686
1687         struct ab8500_charger *di = container_of(work,
1688                 struct ab8500_charger, ac_work);
1689
1690         /*
1691          * Since we can't be sure that the events are received
1692          * synchronously, we have the check if the main charger is
1693          * connected by reading the status register
1694          */
1695         ret = ab8500_charger_detect_chargers(di);
1696         if (ret < 0)
1697                 return;
1698
1699         if (ret & AC_PW_CONN) {
1700                 di->ac.charger_connected = 1;
1701                 di->ac_conn = true;
1702         } else {
1703                 di->ac.charger_connected = 0;
1704         }
1705
1706         ab8500_power_supply_changed(di, &di->ac_chg.psy);
1707         sysfs_notify(&di->ac_chg.psy.dev->kobj, NULL, "present");
1708 }
1709
1710 /**
1711  * ab8500_charger_detect_usb_type_work() - work to detect USB type
1712  * @work:       Pointer to the work_struct structure
1713  *
1714  * Detect the type of USB plugged
1715  */
1716 static void ab8500_charger_detect_usb_type_work(struct work_struct *work)
1717 {
1718         int ret;
1719
1720         struct ab8500_charger *di = container_of(work,
1721                 struct ab8500_charger, detect_usb_type_work);
1722
1723         /*
1724          * Since we can't be sure that the events are received
1725          * synchronously, we have the check if is
1726          * connected by reading the status register
1727          */
1728         ret = ab8500_charger_detect_chargers(di);
1729         if (ret < 0)
1730                 return;
1731
1732         if (!(ret & USB_PW_CONN)) {
1733                 di->vbus_detected = 0;
1734                 ab8500_charger_set_usb_connected(di, false);
1735                 ab8500_power_supply_changed(di, &di->usb_chg.psy);
1736         } else {
1737                 di->vbus_detected = 1;
1738
1739                 if (is_ab8500_1p1_or_earlier(di->parent)) {
1740                         ret = ab8500_charger_detect_usb_type(di);
1741                         if (!ret) {
1742                                 ab8500_charger_set_usb_connected(di, true);
1743                                 ab8500_power_supply_changed(di,
1744                                                             &di->usb_chg.psy);
1745                         }
1746                 } else {
1747                         /* For ABB cut2.0 and onwards we have an IRQ,
1748                          * USB_LINK_STATUS that will be triggered when the USB
1749                          * link status changes. The exception is USB connected
1750                          * during startup. Then we don't get a
1751                          * USB_LINK_STATUS IRQ
1752                          */
1753                         if (di->vbus_detected_start) {
1754                                 di->vbus_detected_start = false;
1755                                 ret = ab8500_charger_detect_usb_type(di);
1756                                 if (!ret) {
1757                                         ab8500_charger_set_usb_connected(di,
1758                                                 true);
1759                                         ab8500_power_supply_changed(di,
1760                                                 &di->usb_chg.psy);
1761                                 }
1762                         }
1763                 }
1764         }
1765 }
1766
1767 /**
1768  * ab8500_charger_usb_link_status_work() - work to detect USB type
1769  * @work:       pointer to the work_struct structure
1770  *
1771  * Detect the type of USB plugged
1772  */
1773 static void ab8500_charger_usb_link_status_work(struct work_struct *work)
1774 {
1775         int ret;
1776
1777         struct ab8500_charger *di = container_of(work,
1778                 struct ab8500_charger, usb_link_status_work);
1779
1780         /*
1781          * Since we can't be sure that the events are received
1782          * synchronously, we have the check if  is
1783          * connected by reading the status register
1784          */
1785         ret = ab8500_charger_detect_chargers(di);
1786         if (ret < 0)
1787                 return;
1788
1789         if (!(ret & USB_PW_CONN)) {
1790                 di->vbus_detected = 0;
1791                 ab8500_charger_set_usb_connected(di, false);
1792                 ab8500_power_supply_changed(di, &di->usb_chg.psy);
1793         } else {
1794                 di->vbus_detected = 1;
1795                 ret = ab8500_charger_read_usb_type(di);
1796                 if (!ret) {
1797                         /* Update maximum input current */
1798                         ret = ab8500_charger_set_vbus_in_curr(di,
1799                                         di->max_usb_in_curr);
1800                         if (ret)
1801                                 return;
1802
1803                         ab8500_charger_set_usb_connected(di, true);
1804                         ab8500_power_supply_changed(di, &di->usb_chg.psy);
1805                 } else if (ret == -ENXIO) {
1806                         /* No valid charger type detected */
1807                         ab8500_charger_set_usb_connected(di, false);
1808                         ab8500_power_supply_changed(di, &di->usb_chg.psy);
1809                 }
1810         }
1811 }
1812
1813 static void ab8500_charger_usb_state_changed_work(struct work_struct *work)
1814 {
1815         int ret;
1816         unsigned long flags;
1817
1818         struct ab8500_charger *di = container_of(work,
1819                 struct ab8500_charger, usb_state_changed_work);
1820
1821         if (!di->vbus_detected)
1822                 return;
1823
1824         spin_lock_irqsave(&di->usb_state.usb_lock, flags);
1825         di->usb_state.usb_changed = false;
1826         spin_unlock_irqrestore(&di->usb_state.usb_lock, flags);
1827
1828         /*
1829          * wait for some time until you get updates from the usb stack
1830          * and negotiations are completed
1831          */
1832         msleep(250);
1833
1834         if (di->usb_state.usb_changed)
1835                 return;
1836
1837         dev_dbg(di->dev, "%s USB state: 0x%02x mA: %d\n",
1838                 __func__, di->usb_state.state, di->usb_state.usb_current);
1839
1840         switch (di->usb_state.state) {
1841         case AB8500_BM_USB_STATE_RESET_HS:
1842         case AB8500_BM_USB_STATE_RESET_FS:
1843         case AB8500_BM_USB_STATE_SUSPEND:
1844         case AB8500_BM_USB_STATE_MAX:
1845                 ab8500_charger_set_usb_connected(di, false);
1846                 ab8500_power_supply_changed(di, &di->usb_chg.psy);
1847                 break;
1848
1849         case AB8500_BM_USB_STATE_RESUME:
1850                 /*
1851                  * when suspend->resume there should be delay
1852                  * of 1sec for enabling charging
1853                  */
1854                 msleep(1000);
1855                 /* Intentional fall through */
1856         case AB8500_BM_USB_STATE_CONFIGURED:
1857                 /*
1858                  * USB is configured, enable charging with the charging
1859                  * input current obtained from USB driver
1860                  */
1861                 if (!ab8500_charger_get_usb_cur(di)) {
1862                         /* Update maximum input current */
1863                         ret = ab8500_charger_set_vbus_in_curr(di,
1864                                         di->max_usb_in_curr);
1865                         if (ret)
1866                                 return;
1867
1868                         ab8500_charger_set_usb_connected(di, true);
1869                         ab8500_power_supply_changed(di, &di->usb_chg.psy);
1870                 }
1871                 break;
1872
1873         default:
1874                 break;
1875         };
1876 }
1877
1878 /**
1879  * ab8500_charger_check_usbchargernotok_work() - check USB chg not ok status
1880  * @work:       pointer to the work_struct structure
1881  *
1882  * Work queue function for checking the USB charger Not OK status
1883  */
1884 static void ab8500_charger_check_usbchargernotok_work(struct work_struct *work)
1885 {
1886         int ret;
1887         u8 reg_value;
1888         bool prev_status;
1889
1890         struct ab8500_charger *di = container_of(work,
1891                 struct ab8500_charger, check_usbchgnotok_work.work);
1892
1893         /* Check if the status bit for usbchargernotok is still active */
1894         ret = abx500_get_register_interruptible(di->dev,
1895                 AB8500_CHARGER, AB8500_CH_USBCH_STAT2_REG, &reg_value);
1896         if (ret < 0) {
1897                 dev_err(di->dev, "%s ab8500 read failed\n", __func__);
1898                 return;
1899         }
1900         prev_status = di->flags.usbchargernotok;
1901
1902         if (reg_value & VBUS_CH_NOK) {
1903                 di->flags.usbchargernotok = true;
1904                 /* Check again in 1sec */
1905                 queue_delayed_work(di->charger_wq,
1906                         &di->check_usbchgnotok_work, HZ);
1907         } else {
1908                 di->flags.usbchargernotok = false;
1909                 di->flags.vbus_collapse = false;
1910         }
1911
1912         if (prev_status != di->flags.usbchargernotok)
1913                 ab8500_power_supply_changed(di, &di->usb_chg.psy);
1914 }
1915
1916 /**
1917  * ab8500_charger_check_main_thermal_prot_work() - check main thermal status
1918  * @work:       pointer to the work_struct structure
1919  *
1920  * Work queue function for checking the Main thermal prot status
1921  */
1922 static void ab8500_charger_check_main_thermal_prot_work(
1923         struct work_struct *work)
1924 {
1925         int ret;
1926         u8 reg_value;
1927
1928         struct ab8500_charger *di = container_of(work,
1929                 struct ab8500_charger, check_main_thermal_prot_work);
1930
1931         /* Check if the status bit for main_thermal_prot is still active */
1932         ret = abx500_get_register_interruptible(di->dev,
1933                 AB8500_CHARGER, AB8500_CH_STATUS2_REG, &reg_value);
1934         if (ret < 0) {
1935                 dev_err(di->dev, "%s ab8500 read failed\n", __func__);
1936                 return;
1937         }
1938         if (reg_value & MAIN_CH_TH_PROT)
1939                 di->flags.main_thermal_prot = true;
1940         else
1941                 di->flags.main_thermal_prot = false;
1942
1943         ab8500_power_supply_changed(di, &di->ac_chg.psy);
1944 }
1945
1946 /**
1947  * ab8500_charger_check_usb_thermal_prot_work() - check usb thermal status
1948  * @work:       pointer to the work_struct structure
1949  *
1950  * Work queue function for checking the USB thermal prot status
1951  */
1952 static void ab8500_charger_check_usb_thermal_prot_work(
1953         struct work_struct *work)
1954 {
1955         int ret;
1956         u8 reg_value;
1957
1958         struct ab8500_charger *di = container_of(work,
1959                 struct ab8500_charger, check_usb_thermal_prot_work);
1960
1961         /* Check if the status bit for usb_thermal_prot is still active */
1962         ret = abx500_get_register_interruptible(di->dev,
1963                 AB8500_CHARGER, AB8500_CH_USBCH_STAT2_REG, &reg_value);
1964         if (ret < 0) {
1965                 dev_err(di->dev, "%s ab8500 read failed\n", __func__);
1966                 return;
1967         }
1968         if (reg_value & USB_CH_TH_PROT)
1969                 di->flags.usb_thermal_prot = true;
1970         else
1971                 di->flags.usb_thermal_prot = false;
1972
1973         ab8500_power_supply_changed(di, &di->usb_chg.psy);
1974 }
1975
1976 /**
1977  * ab8500_charger_mainchunplugdet_handler() - main charger unplugged
1978  * @irq:       interrupt number
1979  * @_di:       pointer to the ab8500_charger structure
1980  *
1981  * Returns IRQ status(IRQ_HANDLED)
1982  */
1983 static irqreturn_t ab8500_charger_mainchunplugdet_handler(int irq, void *_di)
1984 {
1985         struct ab8500_charger *di = _di;
1986
1987         dev_dbg(di->dev, "Main charger unplugged\n");
1988         queue_work(di->charger_wq, &di->ac_work);
1989
1990         return IRQ_HANDLED;
1991 }
1992
1993 /**
1994  * ab8500_charger_mainchplugdet_handler() - main charger plugged
1995  * @irq:       interrupt number
1996  * @_di:       pointer to the ab8500_charger structure
1997  *
1998  * Returns IRQ status(IRQ_HANDLED)
1999  */
2000 static irqreturn_t ab8500_charger_mainchplugdet_handler(int irq, void *_di)
2001 {
2002         struct ab8500_charger *di = _di;
2003
2004         dev_dbg(di->dev, "Main charger plugged\n");
2005         queue_work(di->charger_wq, &di->ac_work);
2006
2007         return IRQ_HANDLED;
2008 }
2009
2010 /**
2011  * ab8500_charger_mainextchnotok_handler() - main charger not ok
2012  * @irq:       interrupt number
2013  * @_di:       pointer to the ab8500_charger structure
2014  *
2015  * Returns IRQ status(IRQ_HANDLED)
2016  */
2017 static irqreturn_t ab8500_charger_mainextchnotok_handler(int irq, void *_di)
2018 {
2019         struct ab8500_charger *di = _di;
2020
2021         dev_dbg(di->dev, "Main charger not ok\n");
2022         di->flags.mainextchnotok = true;
2023         ab8500_power_supply_changed(di, &di->ac_chg.psy);
2024
2025         /* Schedule a new HW failure check */
2026         queue_delayed_work(di->charger_wq, &di->check_hw_failure_work, 0);
2027
2028         return IRQ_HANDLED;
2029 }
2030
2031 /**
2032  * ab8500_charger_mainchthprotr_handler() - Die temp is above main charger
2033  * thermal protection threshold
2034  * @irq:       interrupt number
2035  * @_di:       pointer to the ab8500_charger structure
2036  *
2037  * Returns IRQ status(IRQ_HANDLED)
2038  */
2039 static irqreturn_t ab8500_charger_mainchthprotr_handler(int irq, void *_di)
2040 {
2041         struct ab8500_charger *di = _di;
2042
2043         dev_dbg(di->dev,
2044                 "Die temp above Main charger thermal protection threshold\n");
2045         queue_work(di->charger_wq, &di->check_main_thermal_prot_work);
2046
2047         return IRQ_HANDLED;
2048 }
2049
2050 /**
2051  * ab8500_charger_mainchthprotf_handler() - Die temp is below main charger
2052  * thermal protection threshold
2053  * @irq:       interrupt number
2054  * @_di:       pointer to the ab8500_charger structure
2055  *
2056  * Returns IRQ status(IRQ_HANDLED)
2057  */
2058 static irqreturn_t ab8500_charger_mainchthprotf_handler(int irq, void *_di)
2059 {
2060         struct ab8500_charger *di = _di;
2061
2062         dev_dbg(di->dev,
2063                 "Die temp ok for Main charger thermal protection threshold\n");
2064         queue_work(di->charger_wq, &di->check_main_thermal_prot_work);
2065
2066         return IRQ_HANDLED;
2067 }
2068
2069 /**
2070  * ab8500_charger_vbusdetf_handler() - VBUS falling detected
2071  * @irq:       interrupt number
2072  * @_di:       pointer to the ab8500_charger structure
2073  *
2074  * Returns IRQ status(IRQ_HANDLED)
2075  */
2076 static irqreturn_t ab8500_charger_vbusdetf_handler(int irq, void *_di)
2077 {
2078         struct ab8500_charger *di = _di;
2079
2080         dev_dbg(di->dev, "VBUS falling detected\n");
2081         queue_work(di->charger_wq, &di->detect_usb_type_work);
2082
2083         return IRQ_HANDLED;
2084 }
2085
2086 /**
2087  * ab8500_charger_vbusdetr_handler() - VBUS rising detected
2088  * @irq:       interrupt number
2089  * @_di:       pointer to the ab8500_charger structure
2090  *
2091  * Returns IRQ status(IRQ_HANDLED)
2092  */
2093 static irqreturn_t ab8500_charger_vbusdetr_handler(int irq, void *_di)
2094 {
2095         struct ab8500_charger *di = _di;
2096
2097         di->vbus_detected = true;
2098         dev_dbg(di->dev, "VBUS rising detected\n");
2099         queue_work(di->charger_wq, &di->detect_usb_type_work);
2100
2101         return IRQ_HANDLED;
2102 }
2103
2104 /**
2105  * ab8500_charger_usblinkstatus_handler() - USB link status has changed
2106  * @irq:       interrupt number
2107  * @_di:       pointer to the ab8500_charger structure
2108  *
2109  * Returns IRQ status(IRQ_HANDLED)
2110  */
2111 static irqreturn_t ab8500_charger_usblinkstatus_handler(int irq, void *_di)
2112 {
2113         struct ab8500_charger *di = _di;
2114
2115         dev_dbg(di->dev, "USB link status changed\n");
2116
2117         queue_work(di->charger_wq, &di->usb_link_status_work);
2118
2119         return IRQ_HANDLED;
2120 }
2121
2122 /**
2123  * ab8500_charger_usbchthprotr_handler() - Die temp is above usb charger
2124  * thermal protection threshold
2125  * @irq:       interrupt number
2126  * @_di:       pointer to the ab8500_charger structure
2127  *
2128  * Returns IRQ status(IRQ_HANDLED)
2129  */
2130 static irqreturn_t ab8500_charger_usbchthprotr_handler(int irq, void *_di)
2131 {
2132         struct ab8500_charger *di = _di;
2133
2134         dev_dbg(di->dev,
2135                 "Die temp above USB charger thermal protection threshold\n");
2136         queue_work(di->charger_wq, &di->check_usb_thermal_prot_work);
2137
2138         return IRQ_HANDLED;
2139 }
2140
2141 /**
2142  * ab8500_charger_usbchthprotf_handler() - Die temp is below usb charger
2143  * thermal protection threshold
2144  * @irq:       interrupt number
2145  * @_di:       pointer to the ab8500_charger structure
2146  *
2147  * Returns IRQ status(IRQ_HANDLED)
2148  */
2149 static irqreturn_t ab8500_charger_usbchthprotf_handler(int irq, void *_di)
2150 {
2151         struct ab8500_charger *di = _di;
2152
2153         dev_dbg(di->dev,
2154                 "Die temp ok for USB charger thermal protection threshold\n");
2155         queue_work(di->charger_wq, &di->check_usb_thermal_prot_work);
2156
2157         return IRQ_HANDLED;
2158 }
2159
2160 /**
2161  * ab8500_charger_usbchargernotokr_handler() - USB charger not ok detected
2162  * @irq:       interrupt number
2163  * @_di:       pointer to the ab8500_charger structure
2164  *
2165  * Returns IRQ status(IRQ_HANDLED)
2166  */
2167 static irqreturn_t ab8500_charger_usbchargernotokr_handler(int irq, void *_di)
2168 {
2169         struct ab8500_charger *di = _di;
2170
2171         dev_dbg(di->dev, "Not allowed USB charger detected\n");
2172         queue_delayed_work(di->charger_wq, &di->check_usbchgnotok_work, 0);
2173
2174         return IRQ_HANDLED;
2175 }
2176
2177 /**
2178  * ab8500_charger_chwdexp_handler() - Charger watchdog expired
2179  * @irq:       interrupt number
2180  * @_di:       pointer to the ab8500_charger structure
2181  *
2182  * Returns IRQ status(IRQ_HANDLED)
2183  */
2184 static irqreturn_t ab8500_charger_chwdexp_handler(int irq, void *_di)
2185 {
2186         struct ab8500_charger *di = _di;
2187
2188         dev_dbg(di->dev, "Charger watchdog expired\n");
2189
2190         /*
2191          * The charger that was online when the watchdog expired
2192          * needs to be restarted for charging to start again
2193          */
2194         if (di->ac.charger_online) {
2195                 di->ac.wd_expired = true;
2196                 ab8500_power_supply_changed(di, &di->ac_chg.psy);
2197         }
2198         if (di->usb.charger_online) {
2199                 di->usb.wd_expired = true;
2200                 ab8500_power_supply_changed(di, &di->usb_chg.psy);
2201         }
2202
2203         return IRQ_HANDLED;
2204 }
2205
2206 /**
2207  * ab8500_charger_vbusovv_handler() - VBUS overvoltage detected
2208  * @irq:       interrupt number
2209  * @_di:       pointer to the ab8500_charger structure
2210  *
2211  * Returns IRQ status(IRQ_HANDLED)
2212  */
2213 static irqreturn_t ab8500_charger_vbusovv_handler(int irq, void *_di)
2214 {
2215         struct ab8500_charger *di = _di;
2216
2217         dev_dbg(di->dev, "VBUS overvoltage detected\n");
2218         di->flags.vbus_ovv = true;
2219         ab8500_power_supply_changed(di, &di->usb_chg.psy);
2220
2221         /* Schedule a new HW failure check */
2222         queue_delayed_work(di->charger_wq, &di->check_hw_failure_work, 0);
2223
2224         return IRQ_HANDLED;
2225 }
2226
2227 /**
2228  * ab8500_charger_ac_get_property() - get the ac/mains properties
2229  * @psy:       pointer to the power_supply structure
2230  * @psp:       pointer to the power_supply_property structure
2231  * @val:       pointer to the power_supply_propval union
2232  *
2233  * This function gets called when an application tries to get the ac/mains
2234  * properties by reading the sysfs files.
2235  * AC/Mains properties are online, present and voltage.
2236  * online:     ac/mains charging is in progress or not
2237  * present:    presence of the ac/mains
2238  * voltage:    AC/Mains voltage
2239  * Returns error code in case of failure else 0(on success)
2240  */
2241 static int ab8500_charger_ac_get_property(struct power_supply *psy,
2242         enum power_supply_property psp,
2243         union power_supply_propval *val)
2244 {
2245         struct ab8500_charger *di;
2246
2247         di = to_ab8500_charger_ac_device_info(psy_to_ux500_charger(psy));
2248
2249         switch (psp) {
2250         case POWER_SUPPLY_PROP_HEALTH:
2251                 if (di->flags.mainextchnotok)
2252                         val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
2253                 else if (di->ac.wd_expired || di->usb.wd_expired)
2254                         val->intval = POWER_SUPPLY_HEALTH_DEAD;
2255                 else if (di->flags.main_thermal_prot)
2256                         val->intval = POWER_SUPPLY_HEALTH_OVERHEAT;
2257                 else
2258                         val->intval = POWER_SUPPLY_HEALTH_GOOD;
2259                 break;
2260         case POWER_SUPPLY_PROP_ONLINE:
2261                 val->intval = di->ac.charger_online;
2262                 break;
2263         case POWER_SUPPLY_PROP_PRESENT:
2264                 val->intval = di->ac.charger_connected;
2265                 break;
2266         case POWER_SUPPLY_PROP_VOLTAGE_NOW:
2267                 di->ac.charger_voltage = ab8500_charger_get_ac_voltage(di);
2268                 val->intval = di->ac.charger_voltage * 1000;
2269                 break;
2270         case POWER_SUPPLY_PROP_VOLTAGE_AVG:
2271                 /*
2272                  * This property is used to indicate when CV mode is entered
2273                  * for the AC charger
2274                  */
2275                 di->ac.cv_active = ab8500_charger_ac_cv(di);
2276                 val->intval = di->ac.cv_active;
2277                 break;
2278         case POWER_SUPPLY_PROP_CURRENT_NOW:
2279                 val->intval = ab8500_charger_get_ac_current(di) * 1000;
2280                 break;
2281         default:
2282                 return -EINVAL;
2283         }
2284         return 0;
2285 }
2286
2287 /**
2288  * ab8500_charger_usb_get_property() - get the usb properties
2289  * @psy:        pointer to the power_supply structure
2290  * @psp:        pointer to the power_supply_property structure
2291  * @val:        pointer to the power_supply_propval union
2292  *
2293  * This function gets called when an application tries to get the usb
2294  * properties by reading the sysfs files.
2295  * USB properties are online, present and voltage.
2296  * online:     usb charging is in progress or not
2297  * present:    presence of the usb
2298  * voltage:    vbus voltage
2299  * Returns error code in case of failure else 0(on success)
2300  */
2301 static int ab8500_charger_usb_get_property(struct power_supply *psy,
2302         enum power_supply_property psp,
2303         union power_supply_propval *val)
2304 {
2305         struct ab8500_charger *di;
2306
2307         di = to_ab8500_charger_usb_device_info(psy_to_ux500_charger(psy));
2308
2309         switch (psp) {
2310         case POWER_SUPPLY_PROP_HEALTH:
2311                 if (di->flags.usbchargernotok)
2312                         val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
2313                 else if (di->ac.wd_expired || di->usb.wd_expired)
2314                         val->intval = POWER_SUPPLY_HEALTH_DEAD;
2315                 else if (di->flags.usb_thermal_prot)
2316                         val->intval = POWER_SUPPLY_HEALTH_OVERHEAT;
2317                 else if (di->flags.vbus_ovv)
2318                         val->intval = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
2319                 else
2320                         val->intval = POWER_SUPPLY_HEALTH_GOOD;
2321                 break;
2322         case POWER_SUPPLY_PROP_ONLINE:
2323                 val->intval = di->usb.charger_online;
2324                 break;
2325         case POWER_SUPPLY_PROP_PRESENT:
2326                 val->intval = di->usb.charger_connected;
2327                 break;
2328         case POWER_SUPPLY_PROP_VOLTAGE_NOW:
2329                 di->usb.charger_voltage = ab8500_charger_get_vbus_voltage(di);
2330                 val->intval = di->usb.charger_voltage * 1000;
2331                 break;
2332         case POWER_SUPPLY_PROP_VOLTAGE_AVG:
2333                 /*
2334                  * This property is used to indicate when CV mode is entered
2335                  * for the USB charger
2336                  */
2337                 di->usb.cv_active = ab8500_charger_usb_cv(di);
2338                 val->intval = di->usb.cv_active;
2339                 break;
2340         case POWER_SUPPLY_PROP_CURRENT_NOW:
2341                 val->intval = ab8500_charger_get_usb_current(di) * 1000;
2342                 break;
2343         case POWER_SUPPLY_PROP_CURRENT_AVG:
2344                 /*
2345                  * This property is used to indicate when VBUS has collapsed
2346                  * due to too high output current from the USB charger
2347                  */
2348                 if (di->flags.vbus_collapse)
2349                         val->intval = 1;
2350                 else
2351                         val->intval = 0;
2352                 break;
2353         default:
2354                 return -EINVAL;
2355         }
2356         return 0;
2357 }
2358
2359 /**
2360  * ab8500_charger_init_hw_registers() - Set up charger related registers
2361  * @di:         pointer to the ab8500_charger structure
2362  *
2363  * Set up charger OVV, watchdog and maximum voltage registers as well as
2364  * charging of the backup battery
2365  */
2366 static int ab8500_charger_init_hw_registers(struct ab8500_charger *di)
2367 {
2368         int ret = 0;
2369
2370         /* Setup maximum charger current and voltage for ABB cut2.0 */
2371         if (!is_ab8500_1p1_or_earlier(di->parent)) {
2372                 ret = abx500_set_register_interruptible(di->dev,
2373                         AB8500_CHARGER,
2374                         AB8500_CH_VOLT_LVL_MAX_REG, CH_VOL_LVL_4P6);
2375                 if (ret) {
2376                         dev_err(di->dev,
2377                                 "failed to set CH_VOLT_LVL_MAX_REG\n");
2378                         goto out;
2379                 }
2380
2381                 ret = abx500_set_register_interruptible(di->dev,
2382                         AB8500_CHARGER,
2383                         AB8500_CH_OPT_CRNTLVL_MAX_REG, CH_OP_CUR_LVL_1P6);
2384                 if (ret) {
2385                         dev_err(di->dev,
2386                                 "failed to set CH_OPT_CRNTLVL_MAX_REG\n");
2387                         goto out;
2388                 }
2389         }
2390
2391         /* VBUS OVV set to 6.3V and enable automatic current limitiation */
2392         ret = abx500_set_register_interruptible(di->dev,
2393                 AB8500_CHARGER,
2394                 AB8500_USBCH_CTRL2_REG,
2395                 VBUS_OVV_SELECT_6P3V | VBUS_AUTO_IN_CURR_LIM_ENA);
2396         if (ret) {
2397                 dev_err(di->dev, "failed to set VBUS OVV\n");
2398                 goto out;
2399         }
2400
2401         /* Enable main watchdog in OTP */
2402         ret = abx500_set_register_interruptible(di->dev,
2403                 AB8500_OTP_EMUL, AB8500_OTP_CONF_15, OTP_ENABLE_WD);
2404         if (ret) {
2405                 dev_err(di->dev, "failed to enable main WD in OTP\n");
2406                 goto out;
2407         }
2408
2409         /* Enable main watchdog */
2410         ret = abx500_set_register_interruptible(di->dev,
2411                 AB8500_SYS_CTRL2_BLOCK,
2412                 AB8500_MAIN_WDOG_CTRL_REG, MAIN_WDOG_ENA);
2413         if (ret) {
2414                 dev_err(di->dev, "faile to enable main watchdog\n");
2415                 goto out;
2416         }
2417
2418         /*
2419          * Due to internal synchronisation, Enable and Kick watchdog bits
2420          * cannot be enabled in a single write.
2421          * A minimum delay of 2*32 kHz period (62.5µs) must be inserted
2422          * between writing Enable then Kick bits.
2423          */
2424         udelay(63);
2425
2426         /* Kick main watchdog */
2427         ret = abx500_set_register_interruptible(di->dev,
2428                 AB8500_SYS_CTRL2_BLOCK,
2429                 AB8500_MAIN_WDOG_CTRL_REG,
2430                 (MAIN_WDOG_ENA | MAIN_WDOG_KICK));
2431         if (ret) {
2432                 dev_err(di->dev, "failed to kick main watchdog\n");
2433                 goto out;
2434         }
2435
2436         /* Disable main watchdog */
2437         ret = abx500_set_register_interruptible(di->dev,
2438                 AB8500_SYS_CTRL2_BLOCK,
2439                 AB8500_MAIN_WDOG_CTRL_REG, MAIN_WDOG_DIS);
2440         if (ret) {
2441                 dev_err(di->dev, "failed to disable main watchdog\n");
2442                 goto out;
2443         }
2444
2445         /* Set watchdog timeout */
2446         ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
2447                 AB8500_CH_WD_TIMER_REG, WD_TIMER);
2448         if (ret) {
2449                 dev_err(di->dev, "failed to set charger watchdog timeout\n");
2450                 goto out;
2451         }
2452
2453         /* Backup battery voltage and current */
2454         ret = abx500_set_register_interruptible(di->dev,
2455                 AB8500_RTC,
2456                 AB8500_RTC_BACKUP_CHG_REG,
2457                 di->bm->bkup_bat_v |
2458                 di->bm->bkup_bat_i);
2459         if (ret) {
2460                 dev_err(di->dev, "failed to setup backup battery charging\n");
2461                 goto out;
2462         }
2463
2464         /* Enable backup battery charging */
2465         abx500_mask_and_set_register_interruptible(di->dev,
2466                 AB8500_RTC, AB8500_RTC_CTRL_REG,
2467                 RTC_BUP_CH_ENA, RTC_BUP_CH_ENA);
2468         if (ret < 0)
2469                 dev_err(di->dev, "%s mask and set failed\n", __func__);
2470
2471 out:
2472         return ret;
2473 }
2474
2475 /*
2476  * ab8500 charger driver interrupts and their respective isr
2477  */
2478 static struct ab8500_charger_interrupts ab8500_charger_irq[] = {
2479         {"MAIN_CH_UNPLUG_DET", ab8500_charger_mainchunplugdet_handler},
2480         {"MAIN_CHARGE_PLUG_DET", ab8500_charger_mainchplugdet_handler},
2481         {"MAIN_EXT_CH_NOT_OK", ab8500_charger_mainextchnotok_handler},
2482         {"MAIN_CH_TH_PROT_R", ab8500_charger_mainchthprotr_handler},
2483         {"MAIN_CH_TH_PROT_F", ab8500_charger_mainchthprotf_handler},
2484         {"VBUS_DET_F", ab8500_charger_vbusdetf_handler},
2485         {"VBUS_DET_R", ab8500_charger_vbusdetr_handler},
2486         {"USB_LINK_STATUS", ab8500_charger_usblinkstatus_handler},
2487         {"USB_CH_TH_PROT_R", ab8500_charger_usbchthprotr_handler},
2488         {"USB_CH_TH_PROT_F", ab8500_charger_usbchthprotf_handler},
2489         {"USB_CHARGER_NOT_OKR", ab8500_charger_usbchargernotokr_handler},
2490         {"VBUS_OVV", ab8500_charger_vbusovv_handler},
2491         {"CH_WD_EXP", ab8500_charger_chwdexp_handler},
2492 };
2493
2494 static int ab8500_charger_usb_notifier_call(struct notifier_block *nb,
2495                 unsigned long event, void *power)
2496 {
2497         struct ab8500_charger *di =
2498                 container_of(nb, struct ab8500_charger, nb);
2499         enum ab8500_usb_state bm_usb_state;
2500         unsigned mA = *((unsigned *)power);
2501
2502         if (event != USB_EVENT_VBUS) {
2503                 dev_dbg(di->dev, "not a standard host, returning\n");
2504                 return NOTIFY_DONE;
2505         }
2506
2507         /* TODO: State is fabricate  here. See if charger really needs USB
2508          * state or if mA is enough
2509          */
2510         if ((di->usb_state.usb_current == 2) && (mA > 2))
2511                 bm_usb_state = AB8500_BM_USB_STATE_RESUME;
2512         else if (mA == 0)
2513                 bm_usb_state = AB8500_BM_USB_STATE_RESET_HS;
2514         else if (mA == 2)
2515                 bm_usb_state = AB8500_BM_USB_STATE_SUSPEND;
2516         else if (mA >= 8) /* 8, 100, 500 */
2517                 bm_usb_state = AB8500_BM_USB_STATE_CONFIGURED;
2518         else /* Should never occur */
2519                 bm_usb_state = AB8500_BM_USB_STATE_RESET_FS;
2520
2521         dev_dbg(di->dev, "%s usb_state: 0x%02x mA: %d\n",
2522                 __func__, bm_usb_state, mA);
2523
2524         spin_lock(&di->usb_state.usb_lock);
2525         di->usb_state.usb_changed = true;
2526         spin_unlock(&di->usb_state.usb_lock);
2527
2528         di->usb_state.state = bm_usb_state;
2529         di->usb_state.usb_current = mA;
2530
2531         queue_work(di->charger_wq, &di->usb_state_changed_work);
2532
2533         return NOTIFY_OK;
2534 }
2535
2536 #if defined(CONFIG_PM)
2537 static int ab8500_charger_resume(struct platform_device *pdev)
2538 {
2539         int ret;
2540         struct ab8500_charger *di = platform_get_drvdata(pdev);
2541
2542         /*
2543          * For ABB revision 1.0 and 1.1 there is a bug in the watchdog
2544          * logic. That means we have to continously kick the charger
2545          * watchdog even when no charger is connected. This is only
2546          * valid once the AC charger has been enabled. This is
2547          * a bug that is not handled by the algorithm and the
2548          * watchdog have to be kicked by the charger driver
2549          * when the AC charger is disabled
2550          */
2551         if (di->ac_conn && is_ab8500_1p1_or_earlier(di->parent)) {
2552                 ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
2553                         AB8500_CHARG_WD_CTRL, CHARG_WD_KICK);
2554                 if (ret)
2555                         dev_err(di->dev, "Failed to kick WD!\n");
2556
2557                 /* If not already pending start a new timer */
2558                 if (!delayed_work_pending(
2559                         &di->kick_wd_work)) {
2560                         queue_delayed_work(di->charger_wq, &di->kick_wd_work,
2561                                 round_jiffies(WD_KICK_INTERVAL));
2562                 }
2563         }
2564
2565         /* If we still have a HW failure, schedule a new check */
2566         if (di->flags.mainextchnotok || di->flags.vbus_ovv) {
2567                 queue_delayed_work(di->charger_wq,
2568                         &di->check_hw_failure_work, 0);
2569         }
2570
2571         return 0;
2572 }
2573
2574 static int ab8500_charger_suspend(struct platform_device *pdev,
2575         pm_message_t state)
2576 {
2577         struct ab8500_charger *di = platform_get_drvdata(pdev);
2578
2579         /* Cancel any pending HW failure check */
2580         if (delayed_work_pending(&di->check_hw_failure_work))
2581                 cancel_delayed_work(&di->check_hw_failure_work);
2582
2583         return 0;
2584 }
2585 #else
2586 #define ab8500_charger_suspend      NULL
2587 #define ab8500_charger_resume       NULL
2588 #endif
2589
2590 static int ab8500_charger_remove(struct platform_device *pdev)
2591 {
2592         struct ab8500_charger *di = platform_get_drvdata(pdev);
2593         int i, irq, ret;
2594
2595         /* Disable AC charging */
2596         ab8500_charger_ac_en(&di->ac_chg, false, 0, 0);
2597
2598         /* Disable USB charging */
2599         ab8500_charger_usb_en(&di->usb_chg, false, 0, 0);
2600
2601         /* Disable interrupts */
2602         for (i = 0; i < ARRAY_SIZE(ab8500_charger_irq); i++) {
2603                 irq = platform_get_irq_byname(pdev, ab8500_charger_irq[i].name);
2604                 free_irq(irq, di);
2605         }
2606
2607         /* disable the regulator */
2608         regulator_put(di->regu);
2609
2610         /* Backup battery voltage and current disable */
2611         ret = abx500_mask_and_set_register_interruptible(di->dev,
2612                 AB8500_RTC, AB8500_RTC_CTRL_REG, RTC_BUP_CH_ENA, 0);
2613         if (ret < 0)
2614                 dev_err(di->dev, "%s mask and set failed\n", __func__);
2615
2616         usb_unregister_notifier(di->usb_phy, &di->nb);
2617         usb_put_phy(di->usb_phy);
2618
2619         /* Delete the work queue */
2620         destroy_workqueue(di->charger_wq);
2621
2622         flush_scheduled_work();
2623         power_supply_unregister(&di->usb_chg.psy);
2624         power_supply_unregister(&di->ac_chg.psy);
2625         platform_set_drvdata(pdev, NULL);
2626
2627         return 0;
2628 }
2629
2630 static char *supply_interface[] = {
2631         "ab8500_chargalg",
2632         "ab8500_fg",
2633         "ab8500_btemp",
2634 };
2635
2636 static int ab8500_charger_probe(struct platform_device *pdev)
2637 {
2638         struct device_node *np = pdev->dev.of_node;
2639         struct abx500_bm_data *plat = pdev->dev.platform_data;
2640         struct ab8500_charger *di;
2641         int irq, i, charger_status, ret = 0;
2642
2643         di = devm_kzalloc(&pdev->dev, sizeof(*di), GFP_KERNEL);
2644         if (!di) {
2645                 dev_err(&pdev->dev, "%s no mem for ab8500_charger\n", __func__);
2646                 return -ENOMEM;
2647         }
2648
2649         if (!plat) {
2650                 dev_err(&pdev->dev, "no battery management data supplied\n");
2651                 return -EINVAL;
2652         }
2653         di->bm = plat;
2654
2655         if (np) {
2656                 ret = ab8500_bm_of_probe(&pdev->dev, np, di->bm);
2657                 if (ret) {
2658                         dev_err(&pdev->dev, "failed to get battery information\n");
2659                         return ret;
2660                 }
2661                 di->autopower_cfg = of_property_read_bool(np, "autopower_cfg");
2662         } else
2663                 di->autopower_cfg = false;
2664
2665         /* get parent data */
2666         di->dev = &pdev->dev;
2667         di->parent = dev_get_drvdata(pdev->dev.parent);
2668         di->gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
2669
2670         /* initialize lock */
2671         spin_lock_init(&di->usb_state.usb_lock);
2672
2673         di->autopower = false;
2674
2675         /* AC supply */
2676         /* power_supply base class */
2677         di->ac_chg.psy.name = "ab8500_ac";
2678         di->ac_chg.psy.type = POWER_SUPPLY_TYPE_MAINS;
2679         di->ac_chg.psy.properties = ab8500_charger_ac_props;
2680         di->ac_chg.psy.num_properties = ARRAY_SIZE(ab8500_charger_ac_props);
2681         di->ac_chg.psy.get_property = ab8500_charger_ac_get_property;
2682         di->ac_chg.psy.supplied_to = supply_interface;
2683         di->ac_chg.psy.num_supplicants = ARRAY_SIZE(supply_interface),
2684         /* ux500_charger sub-class */
2685         di->ac_chg.ops.enable = &ab8500_charger_ac_en;
2686         di->ac_chg.ops.kick_wd = &ab8500_charger_watchdog_kick;
2687         di->ac_chg.ops.update_curr = &ab8500_charger_update_charger_current;
2688         di->ac_chg.max_out_volt = ab8500_charger_voltage_map[
2689                 ARRAY_SIZE(ab8500_charger_voltage_map) - 1];
2690         di->ac_chg.max_out_curr = ab8500_charger_current_map[
2691                 ARRAY_SIZE(ab8500_charger_current_map) - 1];
2692
2693         /* USB supply */
2694         /* power_supply base class */
2695         di->usb_chg.psy.name = "ab8500_usb";
2696         di->usb_chg.psy.type = POWER_SUPPLY_TYPE_USB;
2697         di->usb_chg.psy.properties = ab8500_charger_usb_props;
2698         di->usb_chg.psy.num_properties = ARRAY_SIZE(ab8500_charger_usb_props);
2699         di->usb_chg.psy.get_property = ab8500_charger_usb_get_property;
2700         di->usb_chg.psy.supplied_to = supply_interface;
2701         di->usb_chg.psy.num_supplicants = ARRAY_SIZE(supply_interface),
2702         /* ux500_charger sub-class */
2703         di->usb_chg.ops.enable = &ab8500_charger_usb_en;
2704         di->usb_chg.ops.kick_wd = &ab8500_charger_watchdog_kick;
2705         di->usb_chg.ops.update_curr = &ab8500_charger_update_charger_current;
2706         di->usb_chg.max_out_volt = ab8500_charger_voltage_map[
2707                 ARRAY_SIZE(ab8500_charger_voltage_map) - 1];
2708         di->usb_chg.max_out_curr = ab8500_charger_current_map[
2709                 ARRAY_SIZE(ab8500_charger_current_map) - 1];
2710
2711
2712         /* Create a work queue for the charger */
2713         di->charger_wq =
2714                 create_singlethread_workqueue("ab8500_charger_wq");
2715         if (di->charger_wq == NULL) {
2716                 dev_err(di->dev, "failed to create work queue\n");
2717                 return -ENOMEM;
2718         }
2719
2720         /* Init work for HW failure check */
2721         INIT_DEFERRABLE_WORK(&di->check_hw_failure_work,
2722                 ab8500_charger_check_hw_failure_work);
2723         INIT_DEFERRABLE_WORK(&di->check_usbchgnotok_work,
2724                 ab8500_charger_check_usbchargernotok_work);
2725
2726         /*
2727          * For ABB revision 1.0 and 1.1 there is a bug in the watchdog
2728          * logic. That means we have to continously kick the charger
2729          * watchdog even when no charger is connected. This is only
2730          * valid once the AC charger has been enabled. This is
2731          * a bug that is not handled by the algorithm and the
2732          * watchdog have to be kicked by the charger driver
2733          * when the AC charger is disabled
2734          */
2735         INIT_DEFERRABLE_WORK(&di->kick_wd_work,
2736                 ab8500_charger_kick_watchdog_work);
2737
2738         INIT_DEFERRABLE_WORK(&di->check_vbat_work,
2739                 ab8500_charger_check_vbat_work);
2740
2741         /* Init work for charger detection */
2742         INIT_WORK(&di->usb_link_status_work,
2743                 ab8500_charger_usb_link_status_work);
2744         INIT_WORK(&di->ac_work, ab8500_charger_ac_work);
2745         INIT_WORK(&di->detect_usb_type_work,
2746                 ab8500_charger_detect_usb_type_work);
2747
2748         INIT_WORK(&di->usb_state_changed_work,
2749                 ab8500_charger_usb_state_changed_work);
2750
2751         /* Init work for checking HW status */
2752         INIT_WORK(&di->check_main_thermal_prot_work,
2753                 ab8500_charger_check_main_thermal_prot_work);
2754         INIT_WORK(&di->check_usb_thermal_prot_work,
2755                 ab8500_charger_check_usb_thermal_prot_work);
2756
2757         /*
2758          * VDD ADC supply needs to be enabled from this driver when there
2759          * is a charger connected to avoid erroneous BTEMP_HIGH/LOW
2760          * interrupts during charging
2761          */
2762         di->regu = regulator_get(di->dev, "vddadc");
2763         if (IS_ERR(di->regu)) {
2764                 ret = PTR_ERR(di->regu);
2765                 dev_err(di->dev, "failed to get vddadc regulator\n");
2766                 goto free_charger_wq;
2767         }
2768
2769
2770         /* Initialize OVV, and other registers */
2771         ret = ab8500_charger_init_hw_registers(di);
2772         if (ret) {
2773                 dev_err(di->dev, "failed to initialize ABB registers\n");
2774                 goto free_regulator;
2775         }
2776
2777         /* Register AC charger class */
2778         ret = power_supply_register(di->dev, &di->ac_chg.psy);
2779         if (ret) {
2780                 dev_err(di->dev, "failed to register AC charger\n");
2781                 goto free_regulator;
2782         }
2783
2784         /* Register USB charger class */
2785         ret = power_supply_register(di->dev, &di->usb_chg.psy);
2786         if (ret) {
2787                 dev_err(di->dev, "failed to register USB charger\n");
2788                 goto free_ac;
2789         }
2790
2791         di->usb_phy = usb_get_phy(USB_PHY_TYPE_USB2);
2792         if (IS_ERR_OR_NULL(di->usb_phy)) {
2793                 dev_err(di->dev, "failed to get usb transceiver\n");
2794                 ret = -EINVAL;
2795                 goto free_usb;
2796         }
2797         di->nb.notifier_call = ab8500_charger_usb_notifier_call;
2798         ret = usb_register_notifier(di->usb_phy, &di->nb);
2799         if (ret) {
2800                 dev_err(di->dev, "failed to register usb notifier\n");
2801                 goto put_usb_phy;
2802         }
2803
2804         /* Identify the connected charger types during startup */
2805         charger_status = ab8500_charger_detect_chargers(di);
2806         if (charger_status & AC_PW_CONN) {
2807                 di->ac.charger_connected = 1;
2808                 di->ac_conn = true;
2809                 ab8500_power_supply_changed(di, &di->ac_chg.psy);
2810                 sysfs_notify(&di->ac_chg.psy.dev->kobj, NULL, "present");
2811         }
2812
2813         if (charger_status & USB_PW_CONN) {
2814                 dev_dbg(di->dev, "VBUS Detect during startup\n");
2815                 di->vbus_detected = true;
2816                 di->vbus_detected_start = true;
2817                 queue_work(di->charger_wq,
2818                         &di->detect_usb_type_work);
2819         }
2820
2821         /* Register interrupts */
2822         for (i = 0; i < ARRAY_SIZE(ab8500_charger_irq); i++) {
2823                 irq = platform_get_irq_byname(pdev, ab8500_charger_irq[i].name);
2824                 ret = request_threaded_irq(irq, NULL, ab8500_charger_irq[i].isr,
2825                         IRQF_SHARED | IRQF_NO_SUSPEND,
2826                         ab8500_charger_irq[i].name, di);
2827
2828                 if (ret != 0) {
2829                         dev_err(di->dev, "failed to request %s IRQ %d: %d\n"
2830                                 , ab8500_charger_irq[i].name, irq, ret);
2831                         goto free_irq;
2832                 }
2833                 dev_dbg(di->dev, "Requested %s IRQ %d: %d\n",
2834                         ab8500_charger_irq[i].name, irq, ret);
2835         }
2836
2837         platform_set_drvdata(pdev, di);
2838
2839         return ret;
2840
2841 free_irq:
2842         usb_unregister_notifier(di->usb_phy, &di->nb);
2843
2844         /* We also have to free all successfully registered irqs */
2845         for (i = i - 1; i >= 0; i--) {
2846                 irq = platform_get_irq_byname(pdev, ab8500_charger_irq[i].name);
2847                 free_irq(irq, di);
2848         }
2849 put_usb_phy:
2850         usb_put_phy(di->usb_phy);
2851 free_usb:
2852         power_supply_unregister(&di->usb_chg.psy);
2853 free_ac:
2854         power_supply_unregister(&di->ac_chg.psy);
2855 free_regulator:
2856         regulator_put(di->regu);
2857 free_charger_wq:
2858         destroy_workqueue(di->charger_wq);
2859         return ret;
2860 }
2861
2862 static const struct of_device_id ab8500_charger_match[] = {
2863         { .compatible = "stericsson,ab8500-charger", },
2864         { },
2865 };
2866
2867 static struct platform_driver ab8500_charger_driver = {
2868         .probe = ab8500_charger_probe,
2869         .remove = ab8500_charger_remove,
2870         .suspend = ab8500_charger_suspend,
2871         .resume = ab8500_charger_resume,
2872         .driver = {
2873                 .name = "ab8500-charger",
2874                 .owner = THIS_MODULE,
2875                 .of_match_table = ab8500_charger_match,
2876         },
2877 };
2878
2879 static int __init ab8500_charger_init(void)
2880 {
2881         return platform_driver_register(&ab8500_charger_driver);
2882 }
2883
2884 static void __exit ab8500_charger_exit(void)
2885 {
2886         platform_driver_unregister(&ab8500_charger_driver);
2887 }
2888
2889 subsys_initcall_sync(ab8500_charger_init);
2890 module_exit(ab8500_charger_exit);
2891
2892 MODULE_LICENSE("GPL v2");
2893 MODULE_AUTHOR("Johan Palsson, Karl Komierowski, Arun R Murthy");
2894 MODULE_ALIAS("platform:ab8500-charger");
2895 MODULE_DESCRIPTION("AB8500 charger management driver");