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