drivers/power/supply/bq256xx_charger.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 // BQ256XX Battery Charger Driver
   3 // Copyright (C) 2020 Texas Instruments Incorporated - http://www.ti.com/
   4
   5 #include <linux/err.h>
   6 #include <linux/i2c.h>
   7 #include <linux/init.h>
   8 #include <linux/interrupt.h>
   9 #include <linux/kernel.h>
  10 #include <linux/module.h>
  11 #include <linux/gpio/consumer.h>
  12 #include <linux/power_supply.h>
  13 #include <linux/regmap.h>
  14 #include <linux/types.h>
  15 #include <linux/usb/phy.h>
  16 #include <linux/device.h>
  17 #include <linux/moduleparam.h>
  18 #include <linux/slab.h>
  19 #include <linux/acpi.h>
  20
  21 #define BQ256XX_MANUFACTURER "Texas Instruments"
  22
  23 #define BQ256XX_INPUT_CURRENT_LIMIT             0x00
  24 #define BQ256XX_CHARGER_CONTROL_0               0x01
  25 #define BQ256XX_CHARGE_CURRENT_LIMIT            0x02
  26 #define BQ256XX_PRECHG_AND_TERM_CURR_LIM        0x03
  27 #define BQ256XX_BATTERY_VOLTAGE_LIMIT           0x04
  28 #define BQ256XX_CHARGER_CONTROL_1               0x05
  29 #define BQ256XX_CHARGER_CONTROL_2               0x06
  30 #define BQ256XX_CHARGER_CONTROL_3               0x07
  31 #define BQ256XX_CHARGER_STATUS_0                0x08
  32 #define BQ256XX_CHARGER_STATUS_1                0x09
  33 #define BQ256XX_CHARGER_STATUS_2                0x0a
  34 #define BQ256XX_PART_INFORMATION                0x0b
  35 #define BQ256XX_CHARGER_CONTROL_4               0x0c
  36
  37 #define BQ256XX_IINDPM_MASK             GENMASK(4, 0)
  38 #define BQ256XX_IINDPM_STEP_uA          100000
  39 #define BQ256XX_IINDPM_OFFSET_uA        100000
  40 #define BQ256XX_IINDPM_MIN_uA           100000
  41 #define BQ256XX_IINDPM_MAX_uA           3200000
  42 #define BQ256XX_IINDPM_DEF_uA           2400000
  43
  44 #define BQ256XX_VINDPM_MASK             GENMASK(3, 0)
  45 #define BQ256XX_VINDPM_STEP_uV          100000
  46 #define BQ256XX_VINDPM_OFFSET_uV        3900000
  47 #define BQ256XX_VINDPM_MIN_uV           3900000
  48 #define BQ256XX_VINDPM_MAX_uV           5400000
  49 #define BQ256XX_VINDPM_DEF_uV           4500000
  50
  51 #define BQ256XX_VBATREG_MASK            GENMASK(7, 3)
  52 #define BQ2560X_VBATREG_STEP_uV         32000
  53 #define BQ2560X_VBATREG_OFFSET_uV       3856000
  54 #define BQ2560X_VBATREG_MIN_uV          3856000
  55 #define BQ2560X_VBATREG_MAX_uV          4624000
  56 #define BQ2560X_VBATREG_DEF_uV          4208000
  57 #define BQ25601D_VBATREG_OFFSET_uV      3847000
  58 #define BQ25601D_VBATREG_MIN_uV         3847000
  59 #define BQ25601D_VBATREG_MAX_uV         4615000
  60 #define BQ25601D_VBATREG_DEF_uV         4199000
  61 #define BQ2561X_VBATREG_STEP_uV         10000
  62 #define BQ25611D_VBATREG_MIN_uV         3494000
  63 #define BQ25611D_VBATREG_MAX_uV         4510000
  64 #define BQ25611D_VBATREG_DEF_uV         4190000
  65 #define BQ25618_VBATREG_MIN_uV          3504000
  66 #define BQ25618_VBATREG_MAX_uV          4500000
  67 #define BQ25618_VBATREG_DEF_uV          4200000
  68 #define BQ256XX_VBATREG_BIT_SHIFT       3
  69 #define BQ2561X_VBATREG_THRESH          0x8
  70 #define BQ25611D_VBATREG_THRESH_uV      4290000
  71 #define BQ25618_VBATREG_THRESH_uV       4300000
  72
  73 #define BQ256XX_ITERM_MASK              GENMASK(3, 0)
  74 #define BQ256XX_ITERM_STEP_uA           60000
  75 #define BQ256XX_ITERM_OFFSET_uA         60000
  76 #define BQ256XX_ITERM_MIN_uA            60000
  77 #define BQ256XX_ITERM_MAX_uA            780000
  78 #define BQ256XX_ITERM_DEF_uA            180000
  79 #define BQ25618_ITERM_STEP_uA           20000
  80 #define BQ25618_ITERM_OFFSET_uA         20000
  81 #define BQ25618_ITERM_MIN_uA            20000
  82 #define BQ25618_ITERM_MAX_uA            260000
  83 #define BQ25618_ITERM_DEF_uA            60000
  84
  85 #define BQ256XX_IPRECHG_MASK            GENMASK(7, 4)
  86 #define BQ256XX_IPRECHG_STEP_uA         60000
  87 #define BQ256XX_IPRECHG_OFFSET_uA       60000
  88 #define BQ256XX_IPRECHG_MIN_uA          60000
  89 #define BQ256XX_IPRECHG_MAX_uA          780000
  90 #define BQ256XX_IPRECHG_DEF_uA          180000
  91 #define BQ25618_IPRECHG_STEP_uA         20000
  92 #define BQ25618_IPRECHG_OFFSET_uA       20000
  93 #define BQ25618_IPRECHG_MIN_uA          20000
  94 #define BQ25618_IPRECHG_MAX_uA          260000
  95 #define BQ25618_IPRECHG_DEF_uA          40000
  96 #define BQ256XX_IPRECHG_BIT_SHIFT       4
  97
  98 #define BQ256XX_ICHG_MASK               GENMASK(5, 0)
  99 #define BQ256XX_ICHG_STEP_uA            60000
 100 #define BQ256XX_ICHG_MIN_uA             0
 101 #define BQ256XX_ICHG_MAX_uA             3000000
 102 #define BQ2560X_ICHG_DEF_uA             2040000
 103 #define BQ25611D_ICHG_DEF_uA            1020000
 104 #define BQ25618_ICHG_STEP_uA            20000
 105 #define BQ25618_ICHG_MIN_uA             0
 106 #define BQ25618_ICHG_MAX_uA             1500000
 107 #define BQ25618_ICHG_DEF_uA             340000
 108 #define BQ25618_ICHG_THRESH             0x3c
 109 #define BQ25618_ICHG_THRESH_uA          1180000
 110
 111 #define BQ256XX_VBUS_STAT_MASK          GENMASK(7, 5)
 112 #define BQ256XX_VBUS_STAT_NO_INPUT      0
 113 #define BQ256XX_VBUS_STAT_USB_SDP       BIT(5)
 114 #define BQ256XX_VBUS_STAT_USB_CDP       BIT(6)
 115 #define BQ256XX_VBUS_STAT_USB_DCP       (BIT(6) | BIT(5))
 116 #define BQ256XX_VBUS_STAT_USB_OTG       (BIT(7) | BIT(6) | BIT(5))
 117
 118 #define BQ256XX_CHRG_STAT_MASK          GENMASK(4, 3)
 119 #define BQ256XX_CHRG_STAT_NOT_CHRGING   0
 120 #define BQ256XX_CHRG_STAT_PRECHRGING    BIT(3)
 121 #define BQ256XX_CHRG_STAT_FAST_CHRGING  BIT(4)
 122 #define BQ256XX_CHRG_STAT_CHRG_TERM     (BIT(4) | BIT(3))
 123
 124 #define BQ256XX_PG_STAT_MASK            BIT(2)
 125 #define BQ256XX_WDT_FAULT_MASK          BIT(7)
 126 #define BQ256XX_CHRG_FAULT_MASK         GENMASK(5, 4)
 127 #define BQ256XX_CHRG_FAULT_NORMAL       0
 128 #define BQ256XX_CHRG_FAULT_INPUT        BIT(4)
 129 #define BQ256XX_CHRG_FAULT_THERM        BIT(5)
 130 #define BQ256XX_CHRG_FAULT_CST_EXPIRE   (BIT(5) | BIT(4))
 131 #define BQ256XX_BAT_FAULT_MASK          BIT(3)
 132 #define BQ256XX_NTC_FAULT_MASK          GENMASK(2, 0)
 133 #define BQ256XX_NTC_FAULT_WARM          BIT(1)
 134 #define BQ256XX_NTC_FAULT_COOL          (BIT(1) | BIT(0))
 135 #define BQ256XX_NTC_FAULT_COLD          (BIT(2) | BIT(0))
 136 #define BQ256XX_NTC_FAULT_HOT           (BIT(2) | BIT(1))
 137
 138 #define BQ256XX_NUM_WD_VAL      4
 139 #define BQ256XX_WATCHDOG_MASK   GENMASK(5, 4)
 140 #define BQ256XX_WATCHDOG_MAX    1600000
 141 #define BQ256XX_WATCHDOG_DIS    0
 142 #define BQ256XX_WDT_BIT_SHIFT   4
 143
 144 #define BQ256XX_REG_RST         BIT(7)
 145
 146 /**
 147  * struct bq256xx_init_data -
 148  * @ichg: fast charge current
 149  * @iindpm: input current limit
 150  * @vbatreg: charge voltage
 151  * @iterm: termination current
 152  * @iprechg: precharge current
 153  * @vindpm: input voltage limit
 154  * @ichg_max: maximum fast charge current
 155  * @vbatreg_max: maximum charge voltage
 156  */
 157 struct bq256xx_init_data {
 158         u32 ichg;
 159         u32 iindpm;
 160         u32 vbatreg;
 161         u32 iterm;
 162         u32 iprechg;
 163         u32 vindpm;
 164         u32 ichg_max;
 165         u32 vbatreg_max;
 166 };
 167
 168 /**
 169  * struct bq256xx_state -
 170  * @vbus_stat: VBUS status according to BQ256XX_CHARGER_STATUS_0
 171  * @chrg_stat: charging status according to BQ256XX_CHARGER_STATUS_0
 172  * @online: PG status according to BQ256XX_CHARGER_STATUS_0
 173  *
 174  * @wdt_fault: watchdog fault according to BQ256XX_CHARGER_STATUS_1
 175  * @bat_fault: battery fault according to BQ256XX_CHARGER_STATUS_1
 176  * @chrg_fault: charging fault according to BQ256XX_CHARGER_STATUS_1
 177  * @ntc_fault: TS fault according to BQ256XX_CHARGER_STATUS_1
 178  */
 179 struct bq256xx_state {
 180         u8 vbus_stat;
 181         u8 chrg_stat;
 182         bool online;
 183
 184         u8 wdt_fault;
 185         u8 bat_fault;
 186         u8 chrg_fault;
 187         u8 ntc_fault;
 188 };
 189
 190 enum bq256xx_id {
 191         BQ25600,
 192         BQ25600D,
 193         BQ25601,
 194         BQ25601D,
 195         BQ25618,
 196         BQ25619,
 197         BQ25611D,
 198 };
 199
 200 /**
 201  * struct bq256xx_device -
 202  * @client: i2c client structure
 203  * @regmap: register map structure
 204  * @dev: device structure
 205  * @lock: mutex lock structure
 206  *
 207  * @usb2_phy: usb_phy identifier
 208  * @usb3_phy: usb_phy identifier
 209  * @usb_nb: notifier block
 210  * @usb_work: usb work queue
 211  * @usb_event: usb_event code
 212  *
 213  * @model_name: i2c name string
 214  *
 215  * @init_data: initialization data
 216  * @chip_info: device variant information
 217  * @state: device status and faults
 218  * @watchdog_timer: watchdog timer value in milliseconds
 219  */
 220 struct bq256xx_device {
 221         struct i2c_client *client;
 222         struct device *dev;
 223         struct power_supply *charger;
 224         struct power_supply *battery;
 225         struct mutex lock;
 226         struct regmap *regmap;
 227
 228         struct usb_phy *usb2_phy;
 229         struct usb_phy *usb3_phy;
 230         struct notifier_block usb_nb;
 231         struct work_struct usb_work;
 232         unsigned long usb_event;
 233
 234         char model_name[I2C_NAME_SIZE];
 235
 236         struct bq256xx_init_data init_data;
 237         const struct bq256xx_chip_info *chip_info;
 238         struct bq256xx_state state;
 239         int watchdog_timer;
 240 };
 241
 242 /**
 243  * struct bq256xx_chip_info -
 244  * @model_id: device instance
 245  *
 246  * @bq256xx_regmap_config: regmap configuration struct
 247  * @bq256xx_get_ichg: pointer to instance specific get_ichg function
 248  * @bq256xx_get_iindpm: pointer to instance specific get_iindpm function
 249  * @bq256xx_get_vbatreg: pointer to instance specific get_vbatreg function
 250  * @bq256xx_get_iterm: pointer to instance specific get_iterm function
 251  * @bq256xx_get_iprechg: pointer to instance specific get_iprechg function
 252  * @bq256xx_get_vindpm: pointer to instance specific get_vindpm function
 253  *
 254  * @bq256xx_set_ichg: pointer to instance specific set_ichg function
 255  * @bq256xx_set_iindpm: pointer to instance specific set_iindpm function
 256  * @bq256xx_set_vbatreg: pointer to instance specific set_vbatreg function
 257  * @bq256xx_set_iterm: pointer to instance specific set_iterm function
 258  * @bq256xx_set_iprechg: pointer to instance specific set_iprechg function
 259  * @bq256xx_set_vindpm: pointer to instance specific set_vindpm function
 260  *
 261  * @bq256xx_def_ichg: default ichg value in microamps
 262  * @bq256xx_def_iindpm: default iindpm value in microamps
 263  * @bq256xx_def_vbatreg: default vbatreg value in microvolts
 264  * @bq256xx_def_iterm: default iterm value in microamps
 265  * @bq256xx_def_iprechg: default iprechg value in microamps
 266  * @bq256xx_def_vindpm: default vindpm value in microvolts
 267  *
 268  * @bq256xx_max_ichg: maximum charge current in microamps
 269  * @bq256xx_max_vbatreg: maximum battery regulation voltage in microvolts
 270  *
 271  * @has_usb_detect: indicates whether device has BC1.2 detection
 272  */
 273 struct bq256xx_chip_info {
 274         int model_id;
 275
 276         const struct regmap_config *bq256xx_regmap_config;
 277
 278         int (*bq256xx_get_ichg)(struct bq256xx_device *bq);
 279         int (*bq256xx_get_iindpm)(struct bq256xx_device *bq);
 280         int (*bq256xx_get_vbatreg)(struct bq256xx_device *bq);
 281         int (*bq256xx_get_iterm)(struct bq256xx_device *bq);
 282         int (*bq256xx_get_iprechg)(struct bq256xx_device *bq);
 283         int (*bq256xx_get_vindpm)(struct bq256xx_device *bq);
 284
 285         int (*bq256xx_set_ichg)(struct bq256xx_device *bq, int ichg);
 286         int (*bq256xx_set_iindpm)(struct bq256xx_device *bq, int iindpm);
 287         int (*bq256xx_set_vbatreg)(struct bq256xx_device *bq, int vbatreg);
 288         int (*bq256xx_set_iterm)(struct bq256xx_device *bq, int iterm);
 289         int (*bq256xx_set_iprechg)(struct bq256xx_device *bq, int iprechg);
 290         int (*bq256xx_set_vindpm)(struct bq256xx_device *bq, int vindpm);
 291
 292         int bq256xx_def_ichg;
 293         int bq256xx_def_iindpm;
 294         int bq256xx_def_vbatreg;
 295         int bq256xx_def_iterm;
 296         int bq256xx_def_iprechg;
 297         int bq256xx_def_vindpm;
 298
 299         int bq256xx_max_ichg;
 300         int bq256xx_max_vbatreg;
 301
 302         bool has_usb_detect;
 303 };
 304
 305 static int bq256xx_watchdog_time[BQ256XX_NUM_WD_VAL] = {
 306         0, 40000, 80000, 1600000
 307 };
 308
 309 static const int bq25611d_vbatreg_values[] = {
 310         3494000, 3590000, 3686000, 3790000, 3894000, 3990000, 4090000, 4140000,
 311         4190000
 312 };
 313
 314 static const int bq25618_619_vbatreg_values[] = {
 315         3504000, 3600000, 3696000, 3800000, 3904000, 4000000, 4100000, 4150000,
 316         4200000
 317 };
 318
 319 static const int bq25618_619_ichg_values[] = {
 320         1290000, 1360000, 1430000, 1500000
 321 };
 322
 323 static enum power_supply_usb_type bq256xx_usb_type[] = {
 324         POWER_SUPPLY_USB_TYPE_SDP,
 325         POWER_SUPPLY_USB_TYPE_CDP,
 326         POWER_SUPPLY_USB_TYPE_DCP,
 327         POWER_SUPPLY_USB_TYPE_UNKNOWN,
 328         POWER_SUPPLY_USB_TYPE_ACA,
 329 };
 330
 331 static int bq256xx_array_parse(int array_size, int val, const int array[])
 332 {
 333         int i = 0;
 334
 335         if (val < array[i])
 336                 return i - 1;
 337
 338         if (val >= array[array_size - 1])
 339                 return array_size - 1;
 340
 341         for (i = 1; i < array_size; i++) {
 342                 if (val == array[i])
 343                         return i;
 344
 345                 if (val > array[i - 1] && val < array[i]) {
 346                         if (val < array[i])
 347                                 return i - 1;
 348                         else
 349                                 return i;
 350                 }
 351         }
 352         return -EINVAL;
 353 }
 354
 355 static int bq256xx_usb_notifier(struct notifier_block *nb, unsigned long val,
 356                                 void *priv)
 357 {
 358         struct bq256xx_device *bq =
 359                         container_of(nb, struct bq256xx_device, usb_nb);
 360
 361         bq->usb_event = val;
 362         queue_work(system_power_efficient_wq, &bq->usb_work);
 363
 364         return NOTIFY_OK;
 365 }
 366
 367 static void bq256xx_usb_work(struct work_struct *data)
 368 {
 369         struct bq256xx_device *bq =
 370                         container_of(data, struct bq256xx_device, usb_work);
 371
 372         switch (bq->usb_event) {
 373         case USB_EVENT_ID:
 374                 break;
 375         case USB_EVENT_NONE:
 376                 power_supply_changed(bq->charger);
 377                 break;
 378         default:
 379                 dev_err(bq->dev, "Error switching to charger mode.\n");
 380                 break;
 381         }
 382 }
 383
 384 static struct reg_default bq2560x_reg_defs[] = {
 385         {BQ256XX_INPUT_CURRENT_LIMIT, 0x17},
 386         {BQ256XX_CHARGER_CONTROL_0, 0x1a},
 387         {BQ256XX_CHARGE_CURRENT_LIMIT, 0xa2},
 388         {BQ256XX_PRECHG_AND_TERM_CURR_LIM, 0x22},
 389         {BQ256XX_BATTERY_VOLTAGE_LIMIT, 0x58},
 390         {BQ256XX_CHARGER_CONTROL_1, 0x9f},
 391         {BQ256XX_CHARGER_CONTROL_2, 0x66},
 392         {BQ256XX_CHARGER_CONTROL_3, 0x4c},
 393 };
 394
 395 static struct reg_default bq25611d_reg_defs[] = {
 396         {BQ256XX_INPUT_CURRENT_LIMIT, 0x17},
 397         {BQ256XX_CHARGER_CONTROL_0, 0x1a},
 398         {BQ256XX_CHARGE_CURRENT_LIMIT, 0x91},
 399         {BQ256XX_PRECHG_AND_TERM_CURR_LIM, 0x12},
 400         {BQ256XX_BATTERY_VOLTAGE_LIMIT, 0x40},
 401         {BQ256XX_CHARGER_CONTROL_1, 0x9e},
 402         {BQ256XX_CHARGER_CONTROL_2, 0xe6},
 403         {BQ256XX_CHARGER_CONTROL_3, 0x4c},
 404         {BQ256XX_PART_INFORMATION, 0x54},
 405         {BQ256XX_CHARGER_CONTROL_4, 0x75},
 406 };
 407
 408 static struct reg_default bq25618_619_reg_defs[] = {
 409         {BQ256XX_INPUT_CURRENT_LIMIT, 0x17},
 410         {BQ256XX_CHARGER_CONTROL_0, 0x1a},
 411         {BQ256XX_CHARGE_CURRENT_LIMIT, 0x91},
 412         {BQ256XX_PRECHG_AND_TERM_CURR_LIM, 0x12},
 413         {BQ256XX_BATTERY_VOLTAGE_LIMIT, 0x40},
 414         {BQ256XX_CHARGER_CONTROL_1, 0x9e},
 415         {BQ256XX_CHARGER_CONTROL_2, 0xe6},
 416         {BQ256XX_CHARGER_CONTROL_3, 0x4c},
 417         {BQ256XX_PART_INFORMATION, 0x2c},
 418         {BQ256XX_CHARGER_CONTROL_4, 0x75},
 419 };
 420
 421 static int bq256xx_get_state(struct bq256xx_device *bq,
 422                                 struct bq256xx_state *state)
 423 {
 424         unsigned int charger_status_0;
 425         unsigned int charger_status_1;
 426         int ret;
 427
 428         ret = regmap_read(bq->regmap, BQ256XX_CHARGER_STATUS_0,
 429                                                 &charger_status_0);
 430         if (ret)
 431                 return ret;
 432
 433         ret = regmap_read(bq->regmap, BQ256XX_CHARGER_STATUS_1,
 434                                                 &charger_status_1);
 435         if (ret)
 436                 return ret;
 437
 438         state->vbus_stat = charger_status_0 & BQ256XX_VBUS_STAT_MASK;
 439         state->chrg_stat = charger_status_0 & BQ256XX_CHRG_STAT_MASK;
 440         state->online = charger_status_0 & BQ256XX_PG_STAT_MASK;
 441
 442         state->wdt_fault = charger_status_1 & BQ256XX_WDT_FAULT_MASK;
 443         state->bat_fault = charger_status_1 & BQ256XX_BAT_FAULT_MASK;
 444         state->chrg_fault = charger_status_1 & BQ256XX_CHRG_FAULT_MASK;
 445         state->ntc_fault = charger_status_1 & BQ256XX_NTC_FAULT_MASK;
 446
 447         return 0;
 448 }
 449
 450 static int bq256xx_get_ichg_curr(struct bq256xx_device *bq)
 451 {
 452         unsigned int charge_current_limit;
 453         unsigned int ichg_reg_code;
 454         int ret;
 455
 456         ret = regmap_read(bq->regmap, BQ256XX_CHARGE_CURRENT_LIMIT,
 457                                                 &charge_current_limit);
 458         if (ret)
 459                 return ret;
 460
 461         ichg_reg_code = charge_current_limit & BQ256XX_ICHG_MASK;
 462
 463         return ichg_reg_code * BQ256XX_ICHG_STEP_uA;
 464 }
 465
 466 static int bq25618_619_get_ichg_curr(struct bq256xx_device *bq)
 467 {
 468         unsigned int charge_current_limit;
 469         unsigned int ichg_reg_code;
 470         int ret;
 471
 472         ret = regmap_read(bq->regmap, BQ256XX_CHARGE_CURRENT_LIMIT,
 473                                                 &charge_current_limit);
 474         if (ret)
 475                 return ret;
 476
 477         ichg_reg_code = charge_current_limit & BQ256XX_ICHG_MASK;
 478
 479         if (ichg_reg_code < BQ25618_ICHG_THRESH)
 480                 return ichg_reg_code * BQ25618_ICHG_STEP_uA;
 481
 482         return bq25618_619_ichg_values[ichg_reg_code - BQ25618_ICHG_THRESH];
 483 }
 484
 485 static int bq256xx_set_ichg_curr(struct bq256xx_device *bq, int ichg)
 486 {
 487         unsigned int ichg_reg_code;
 488         int ichg_max = bq->init_data.ichg_max;
 489
 490         ichg = clamp(ichg, BQ256XX_ICHG_MIN_uA, ichg_max);
 491         ichg_reg_code = ichg / BQ256XX_ICHG_STEP_uA;
 492
 493         return regmap_update_bits(bq->regmap, BQ256XX_CHARGE_CURRENT_LIMIT,
 494                                         BQ256XX_ICHG_MASK, ichg_reg_code);
 495 }
 496
 497 static int bq25618_619_set_ichg_curr(struct bq256xx_device *bq, int ichg)
 498 {
 499         int array_size = ARRAY_SIZE(bq25618_619_ichg_values);
 500         unsigned int ichg_reg_code;
 501         int ichg_max = bq->init_data.ichg_max;
 502
 503         ichg = clamp(ichg, BQ25618_ICHG_MIN_uA, ichg_max);
 504
 505         if (ichg <= BQ25618_ICHG_THRESH_uA) {
 506                 ichg_reg_code = ichg / BQ25618_ICHG_STEP_uA;
 507         } else {
 508                 ichg_reg_code = bq256xx_array_parse(array_size, ichg,
 509                         bq25618_619_ichg_values) + BQ25618_ICHG_THRESH;
 510         }
 511
 512         return regmap_update_bits(bq->regmap, BQ256XX_CHARGE_CURRENT_LIMIT,
 513                                         BQ256XX_ICHG_MASK, ichg_reg_code);
 514 }
 515
 516 static int bq25618_619_get_chrg_volt(struct bq256xx_device *bq)
 517 {
 518         unsigned int battery_volt_lim;
 519         unsigned int vbatreg_reg_code;
 520         int ret;
 521
 522         ret = regmap_read(bq->regmap, BQ256XX_BATTERY_VOLTAGE_LIMIT,
 523                                                         &battery_volt_lim);
 524
 525         if (ret)
 526                 return ret;
 527
 528         vbatreg_reg_code = (battery_volt_lim & BQ256XX_VBATREG_MASK) >>
 529                                                 BQ256XX_VBATREG_BIT_SHIFT;
 530
 531         if (vbatreg_reg_code > BQ2561X_VBATREG_THRESH)
 532                 return ((vbatreg_reg_code - BQ2561X_VBATREG_THRESH) *
 533                                         BQ2561X_VBATREG_STEP_uV) +
 534                                         BQ25618_VBATREG_THRESH_uV;
 535
 536         return bq25618_619_vbatreg_values[vbatreg_reg_code];
 537 }
 538
 539 static int bq25611d_get_chrg_volt(struct bq256xx_device *bq)
 540 {
 541         unsigned int battery_volt_lim;
 542         unsigned int vbatreg_reg_code;
 543         int ret;
 544
 545         ret = regmap_read(bq->regmap, BQ256XX_BATTERY_VOLTAGE_LIMIT,
 546                                                         &battery_volt_lim);
 547         if (ret)
 548                 return ret;
 549
 550         vbatreg_reg_code = (battery_volt_lim & BQ256XX_VBATREG_MASK) >>
 551                                                 BQ256XX_VBATREG_BIT_SHIFT;
 552
 553         if (vbatreg_reg_code > BQ2561X_VBATREG_THRESH)
 554                 return ((vbatreg_reg_code - BQ2561X_VBATREG_THRESH) *
 555                                         BQ2561X_VBATREG_STEP_uV) +
 556                                         BQ25611D_VBATREG_THRESH_uV;
 557
 558         return bq25611d_vbatreg_values[vbatreg_reg_code];
 559 }
 560
 561 static int bq2560x_get_chrg_volt(struct bq256xx_device *bq)
 562 {
 563         unsigned int battery_volt_lim;
 564         unsigned int vbatreg_reg_code;
 565         int ret;
 566
 567         ret = regmap_read(bq->regmap, BQ256XX_BATTERY_VOLTAGE_LIMIT,
 568                                                         &battery_volt_lim);
 569         if (ret)
 570                 return ret;
 571
 572         vbatreg_reg_code = (battery_volt_lim & BQ256XX_VBATREG_MASK) >>
 573                                                 BQ256XX_VBATREG_BIT_SHIFT;
 574
 575         return (vbatreg_reg_code * BQ2560X_VBATREG_STEP_uV)
 576                                         + BQ2560X_VBATREG_OFFSET_uV;
 577 }
 578
 579 static int bq25601d_get_chrg_volt(struct bq256xx_device *bq)
 580 {
 581         unsigned int battery_volt_lim;
 582         unsigned int vbatreg_reg_code;
 583         int ret;
 584
 585         ret = regmap_read(bq->regmap, BQ256XX_BATTERY_VOLTAGE_LIMIT,
 586                                                         &battery_volt_lim);
 587         if (ret)
 588                 return ret;
 589
 590         vbatreg_reg_code = (battery_volt_lim & BQ256XX_VBATREG_MASK) >>
 591                                                 BQ256XX_VBATREG_BIT_SHIFT;
 592
 593         return (vbatreg_reg_code * BQ2560X_VBATREG_STEP_uV)
 594                                         + BQ25601D_VBATREG_OFFSET_uV;
 595 }
 596
 597 static int bq25618_619_set_chrg_volt(struct bq256xx_device *bq, int vbatreg)
 598 {
 599         int array_size = ARRAY_SIZE(bq25618_619_vbatreg_values);
 600         unsigned int vbatreg_reg_code;
 601         int vbatreg_max = bq->init_data.vbatreg_max;
 602
 603         vbatreg = clamp(vbatreg, BQ25618_VBATREG_MIN_uV, vbatreg_max);
 604
 605         if (vbatreg > BQ25618_VBATREG_THRESH_uV)
 606                 vbatreg_reg_code = ((vbatreg -
 607                 BQ25618_VBATREG_THRESH_uV) /
 608                 (BQ2561X_VBATREG_STEP_uV)) + BQ2561X_VBATREG_THRESH;
 609         else {
 610                 vbatreg_reg_code = bq256xx_array_parse(array_size, vbatreg,
 611                                                 bq25618_619_vbatreg_values);
 612         }
 613
 614         return regmap_update_bits(bq->regmap, BQ256XX_BATTERY_VOLTAGE_LIMIT,
 615                                 BQ256XX_VBATREG_MASK, vbatreg_reg_code <<
 616                                                 BQ256XX_VBATREG_BIT_SHIFT);
 617 }
 618
 619 static int bq25611d_set_chrg_volt(struct bq256xx_device *bq, int vbatreg)
 620 {
 621         int array_size = ARRAY_SIZE(bq25611d_vbatreg_values);
 622         unsigned int vbatreg_reg_code;
 623         int vbatreg_max = bq->init_data.vbatreg_max;
 624
 625         vbatreg = clamp(vbatreg, BQ25611D_VBATREG_MIN_uV, vbatreg_max);
 626
 627         if (vbatreg > BQ25611D_VBATREG_THRESH_uV)
 628                 vbatreg_reg_code = ((vbatreg -
 629                 BQ25611D_VBATREG_THRESH_uV) /
 630                 (BQ2561X_VBATREG_STEP_uV)) + BQ2561X_VBATREG_THRESH;
 631         else {
 632                 vbatreg_reg_code = bq256xx_array_parse(array_size, vbatreg,
 633                                                 bq25611d_vbatreg_values);
 634         }
 635
 636         return regmap_update_bits(bq->regmap, BQ256XX_BATTERY_VOLTAGE_LIMIT,
 637                                 BQ256XX_VBATREG_MASK, vbatreg_reg_code <<
 638                                                 BQ256XX_VBATREG_BIT_SHIFT);
 639 }
 640
 641 static int bq2560x_set_chrg_volt(struct bq256xx_device *bq, int vbatreg)
 642 {
 643         unsigned int vbatreg_reg_code;
 644         int vbatreg_max = bq->init_data.vbatreg_max;
 645
 646         vbatreg = clamp(vbatreg, BQ2560X_VBATREG_MIN_uV, vbatreg_max);
 647
 648         vbatreg_reg_code = (vbatreg - BQ2560X_VBATREG_OFFSET_uV) /
 649                                                 BQ2560X_VBATREG_STEP_uV;
 650
 651         return regmap_update_bits(bq->regmap, BQ256XX_BATTERY_VOLTAGE_LIMIT,
 652                                 BQ256XX_VBATREG_MASK, vbatreg_reg_code <<
 653                                                 BQ256XX_VBATREG_BIT_SHIFT);
 654 }
 655
 656 static int bq25601d_set_chrg_volt(struct bq256xx_device *bq, int vbatreg)
 657 {
 658         unsigned int vbatreg_reg_code;
 659         int vbatreg_max = bq->init_data.vbatreg_max;
 660
 661         vbatreg = clamp(vbatreg, BQ25601D_VBATREG_MIN_uV, vbatreg_max);
 662
 663         vbatreg_reg_code = (vbatreg - BQ25601D_VBATREG_OFFSET_uV) /
 664                                                 BQ2560X_VBATREG_STEP_uV;
 665
 666         return regmap_update_bits(bq->regmap, BQ256XX_BATTERY_VOLTAGE_LIMIT,
 667                                 BQ256XX_VBATREG_MASK, vbatreg_reg_code <<
 668                                                 BQ256XX_VBATREG_BIT_SHIFT);
 669 }
 670
 671 static int bq256xx_get_prechrg_curr(struct bq256xx_device *bq)
 672 {
 673         unsigned int prechg_and_term_curr_lim;
 674         unsigned int iprechg_reg_code;
 675         int ret;
 676
 677         ret = regmap_read(bq->regmap, BQ256XX_PRECHG_AND_TERM_CURR_LIM,
 678                                                 &prechg_and_term_curr_lim);
 679         if (ret)
 680                 return ret;
 681
 682         iprechg_reg_code = (prechg_and_term_curr_lim & BQ256XX_IPRECHG_MASK)
 683                                                 >> BQ256XX_IPRECHG_BIT_SHIFT;
 684
 685         return (iprechg_reg_code * BQ256XX_IPRECHG_STEP_uA) +
 686                                                 BQ256XX_IPRECHG_OFFSET_uA;
 687 }
 688
 689 static int bq256xx_set_prechrg_curr(struct bq256xx_device *bq, int iprechg)
 690 {
 691         unsigned int iprechg_reg_code;
 692
 693         iprechg = clamp(iprechg, BQ256XX_IPRECHG_MIN_uA,
 694                                                 BQ256XX_IPRECHG_MAX_uA);
 695
 696         iprechg_reg_code = ((iprechg - BQ256XX_IPRECHG_OFFSET_uA) /
 697                         BQ256XX_IPRECHG_STEP_uA) << BQ256XX_IPRECHG_BIT_SHIFT;
 698
 699         return regmap_update_bits(bq->regmap, BQ256XX_PRECHG_AND_TERM_CURR_LIM,
 700                                 BQ256XX_IPRECHG_MASK, iprechg_reg_code);
 701 }
 702
 703 static int bq25618_619_get_prechrg_curr(struct bq256xx_device *bq)
 704 {
 705         unsigned int prechg_and_term_curr_lim;
 706         unsigned int iprechg_reg_code;
 707         int ret;
 708
 709         ret = regmap_read(bq->regmap, BQ256XX_PRECHG_AND_TERM_CURR_LIM,
 710                                                 &prechg_and_term_curr_lim);
 711         if (ret)
 712                 return ret;
 713
 714         iprechg_reg_code = (prechg_and_term_curr_lim & BQ256XX_IPRECHG_MASK)
 715                                                 >> BQ256XX_IPRECHG_BIT_SHIFT;
 716
 717         return (iprechg_reg_code * BQ25618_IPRECHG_STEP_uA) +
 718                                                 BQ25618_IPRECHG_OFFSET_uA;
 719 }
 720
 721 static int bq25618_619_set_prechrg_curr(struct bq256xx_device *bq, int iprechg)
 722 {
 723         unsigned int iprechg_reg_code;
 724
 725         iprechg = clamp(iprechg, BQ25618_IPRECHG_MIN_uA,
 726                                                 BQ25618_IPRECHG_MAX_uA);
 727
 728         iprechg_reg_code = ((iprechg - BQ25618_IPRECHG_OFFSET_uA) /
 729                         BQ25618_IPRECHG_STEP_uA) << BQ256XX_IPRECHG_BIT_SHIFT;
 730
 731         return regmap_update_bits(bq->regmap, BQ256XX_PRECHG_AND_TERM_CURR_LIM,
 732                                 BQ256XX_IPRECHG_MASK, iprechg_reg_code);
 733 }
 734
 735 static int bq256xx_get_term_curr(struct bq256xx_device *bq)
 736 {
 737         unsigned int prechg_and_term_curr_lim;
 738         unsigned int iterm_reg_code;
 739         int ret;
 740
 741         ret = regmap_read(bq->regmap, BQ256XX_PRECHG_AND_TERM_CURR_LIM,
 742                                                 &prechg_and_term_curr_lim);
 743         if (ret)
 744                 return ret;
 745
 746         iterm_reg_code = prechg_and_term_curr_lim & BQ256XX_ITERM_MASK;
 747
 748         return (iterm_reg_code * BQ256XX_ITERM_STEP_uA) +
 749                                                 BQ256XX_ITERM_OFFSET_uA;
 750 }
 751
 752 static int bq256xx_set_term_curr(struct bq256xx_device *bq, int iterm)
 753 {
 754         unsigned int iterm_reg_code;
 755
 756         iterm = clamp(iterm, BQ256XX_ITERM_MIN_uA, BQ256XX_ITERM_MAX_uA);
 757
 758         iterm_reg_code = (iterm - BQ256XX_ITERM_OFFSET_uA) /
 759                                                         BQ256XX_ITERM_STEP_uA;
 760
 761         return regmap_update_bits(bq->regmap, BQ256XX_PRECHG_AND_TERM_CURR_LIM,
 762                                 BQ256XX_ITERM_MASK, iterm_reg_code);
 763 }
 764
 765 static int bq25618_619_get_term_curr(struct bq256xx_device *bq)
 766 {
 767         unsigned int prechg_and_term_curr_lim;
 768         unsigned int iterm_reg_code;
 769         int ret;
 770
 771         ret = regmap_read(bq->regmap, BQ256XX_PRECHG_AND_TERM_CURR_LIM,
 772                                                 &prechg_and_term_curr_lim);
 773         if (ret)
 774                 return ret;
 775
 776         iterm_reg_code = prechg_and_term_curr_lim & BQ256XX_ITERM_MASK;
 777
 778         return (iterm_reg_code * BQ25618_ITERM_STEP_uA) +
 779                                                 BQ25618_ITERM_OFFSET_uA;
 780 }
 781
 782 static int bq25618_619_set_term_curr(struct bq256xx_device *bq, int iterm)
 783 {
 784         unsigned int iterm_reg_code;
 785
 786         iterm = clamp(iterm, BQ25618_ITERM_MIN_uA, BQ25618_ITERM_MAX_uA);
 787
 788         iterm_reg_code = (iterm - BQ25618_ITERM_OFFSET_uA) /
 789                                                         BQ25618_ITERM_STEP_uA;
 790
 791         return regmap_update_bits(bq->regmap, BQ256XX_PRECHG_AND_TERM_CURR_LIM,
 792                                 BQ256XX_ITERM_MASK, iterm_reg_code);
 793 }
 794
 795 static int bq256xx_get_input_volt_lim(struct bq256xx_device *bq)
 796 {
 797         unsigned int charger_control_2;
 798         unsigned int vindpm_reg_code;
 799         int ret;
 800
 801         ret = regmap_read(bq->regmap, BQ256XX_CHARGER_CONTROL_2,
 802                                                 &charger_control_2);
 803         if (ret)
 804                 return ret;
 805
 806         vindpm_reg_code = charger_control_2 & BQ256XX_VINDPM_MASK;
 807
 808         return (vindpm_reg_code * BQ256XX_VINDPM_STEP_uV) +
 809                                                 BQ256XX_VINDPM_OFFSET_uV;
 810 }
 811
 812 static int bq256xx_set_input_volt_lim(struct bq256xx_device *bq, int vindpm)
 813 {
 814         unsigned int vindpm_reg_code;
 815
 816         vindpm = clamp(vindpm, BQ256XX_VINDPM_MIN_uV, BQ256XX_VINDPM_MAX_uV);
 817
 818         vindpm_reg_code = (vindpm - BQ256XX_VINDPM_OFFSET_uV) /
 819                                                 BQ256XX_VINDPM_STEP_uV;
 820
 821         return regmap_update_bits(bq->regmap, BQ256XX_CHARGER_CONTROL_2,
 822                                         BQ256XX_VINDPM_MASK, vindpm_reg_code);
 823 }
 824
 825 static int bq256xx_get_input_curr_lim(struct bq256xx_device *bq)
 826 {
 827         unsigned int input_current_limit;
 828         unsigned int iindpm_reg_code;
 829         int ret;
 830
 831         ret = regmap_read(bq->regmap, BQ256XX_INPUT_CURRENT_LIMIT,
 832                                                 &input_current_limit);
 833         if (ret)
 834                 return ret;
 835
 836         iindpm_reg_code = input_current_limit & BQ256XX_IINDPM_MASK;
 837
 838         return (iindpm_reg_code * BQ256XX_IINDPM_STEP_uA) +
 839                                                 BQ256XX_IINDPM_OFFSET_uA;
 840 }
 841
 842 static int bq256xx_set_input_curr_lim(struct bq256xx_device *bq, int iindpm)
 843 {
 844         unsigned int iindpm_reg_code;
 845
 846         iindpm = clamp(iindpm, BQ256XX_IINDPM_MIN_uA, BQ256XX_IINDPM_MAX_uA);
 847
 848         iindpm_reg_code = (iindpm - BQ256XX_IINDPM_OFFSET_uA) /
 849                                                         BQ256XX_IINDPM_STEP_uA;
 850
 851         return regmap_update_bits(bq->regmap, BQ256XX_INPUT_CURRENT_LIMIT,
 852                                         BQ256XX_IINDPM_MASK, iindpm_reg_code);
 853 }
 854
 855 static void bq256xx_charger_reset(void *data)
 856 {
 857         struct bq256xx_device *bq = data;
 858
 859         regmap_update_bits(bq->regmap, BQ256XX_PART_INFORMATION,
 860                                         BQ256XX_REG_RST, BQ256XX_REG_RST);
 861
 862         if (!IS_ERR_OR_NULL(bq->usb2_phy))
 863                 usb_unregister_notifier(bq->usb2_phy, &bq->usb_nb);
 864
 865         if (!IS_ERR_OR_NULL(bq->usb3_phy))
 866                 usb_unregister_notifier(bq->usb3_phy, &bq->usb_nb);
 867 }
 868
 869 static int bq256xx_set_charger_property(struct power_supply *psy,
 870                 enum power_supply_property prop,
 871                 const union power_supply_propval *val)
 872 {
 873         struct bq256xx_device *bq = power_supply_get_drvdata(psy);
 874         int ret = -EINVAL;
 875
 876         switch (prop) {
 877         case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
 878                 ret = bq->chip_info->bq256xx_set_iindpm(bq, val->intval);
 879                 if (ret)
 880                         return ret;
 881                 break;
 882
 883         case POWER_SUPPLY_PROP_STATUS:
 884                 break;
 885
 886         case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
 887                 ret = bq->chip_info->bq256xx_set_vbatreg(bq, val->intval);
 888                 if (ret)
 889                         return ret;
 890                 break;
 891
 892         case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
 893                 ret = bq->chip_info->bq256xx_set_ichg(bq, val->intval);
 894                 if (ret)
 895                         return ret;
 896                 break;
 897
 898         case POWER_SUPPLY_PROP_PRECHARGE_CURRENT:
 899                 ret = bq->chip_info->bq256xx_set_iprechg(bq, val->intval);
 900                 if (ret)
 901                         return ret;
 902                 break;
 903
 904         case POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT:
 905                 ret = bq->chip_info->bq256xx_set_iterm(bq, val->intval);
 906                 if (ret)
 907                         return ret;
 908                 break;
 909
 910         case POWER_SUPPLY_PROP_INPUT_VOLTAGE_LIMIT:
 911                 ret = bq->chip_info->bq256xx_set_vindpm(bq, val->intval);
 912                 if (ret)
 913                         return ret;
 914                 break;
 915
 916         default:
 917                 break;
 918         }
 919
 920         return ret;
 921 }
 922
 923
 924 static int bq256xx_get_battery_property(struct power_supply *psy,
 925                                 enum power_supply_property psp,
 926                                 union power_supply_propval *val)
 927 {
 928         struct bq256xx_device *bq = power_supply_get_drvdata(psy);
 929
 930         switch (psp) {
 931         case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX:
 932                 val->intval = bq->init_data.ichg_max;
 933                 break;
 934
 935         case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX:
 936                 val->intval = bq->init_data.vbatreg_max;
 937                 break;
 938
 939         default:
 940                 return -EINVAL;
 941         }
 942
 943         return 0;
 944 }
 945
 946 static int bq256xx_get_charger_property(struct power_supply *psy,
 947                                 enum power_supply_property psp,
 948                                 union power_supply_propval *val)
 949 {
 950         struct bq256xx_device *bq = power_supply_get_drvdata(psy);
 951         struct bq256xx_state state;
 952         int ret = 0;
 953
 954         mutex_lock(&bq->lock);
 955         ret = bq256xx_get_state(bq, &state);
 956         mutex_unlock(&bq->lock);
 957         if (ret)
 958                 return ret;
 959
 960         switch (psp) {
 961         case POWER_SUPPLY_PROP_STATUS:
 962                 if (state.vbus_stat == BQ256XX_VBUS_STAT_NO_INPUT ||
 963                     state.vbus_stat == BQ256XX_VBUS_STAT_USB_OTG)
 964                         val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
 965                 else if (state.chrg_stat == BQ256XX_CHRG_STAT_NOT_CHRGING)
 966                         val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING;
 967                 else if (state.chrg_stat == BQ256XX_CHRG_STAT_CHRG_TERM)
 968                         val->intval = POWER_SUPPLY_STATUS_FULL;
 969                 else
 970                         val->intval = POWER_SUPPLY_STATUS_CHARGING;
 971                 break;
 972
 973         case POWER_SUPPLY_PROP_HEALTH:
 974                 val->intval = POWER_SUPPLY_HEALTH_UNKNOWN;
 975                 if (state.wdt_fault) {
 976                         val->intval =
 977                                 POWER_SUPPLY_HEALTH_WATCHDOG_TIMER_EXPIRE;
 978                 } else if (state.bat_fault) {
 979                         val->intval = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
 980                 } else {
 981                         switch (state.chrg_stat) {
 982                         case BQ256XX_CHRG_FAULT_INPUT:
 983                                 val->intval =
 984                                         POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
 985                                 break;
 986                         case BQ256XX_CHRG_FAULT_THERM:
 987                                 val->intval = POWER_SUPPLY_HEALTH_OVERHEAT;
 988                                 break;
 989                         case BQ256XX_CHRG_FAULT_CST_EXPIRE:
 990                                 val->intval =
 991                                 POWER_SUPPLY_HEALTH_SAFETY_TIMER_EXPIRE;
 992                                 break;
 993                         default:
 994                                 break;
 995                         }
 996
 997                         switch (state.ntc_fault) {
 998                         case BQ256XX_NTC_FAULT_WARM:
 999                                 val->intval = POWER_SUPPLY_HEALTH_WARM;
1000                                 break;
1001                         case BQ256XX_NTC_FAULT_COOL:
1002                                 val->intval = POWER_SUPPLY_HEALTH_COOL;
1003                                 break;
1004                         case BQ256XX_NTC_FAULT_COLD:
1005                                 val->intval = POWER_SUPPLY_HEALTH_COLD;
1006                                 break;
1007                         case BQ256XX_NTC_FAULT_HOT:
1008                                 val->intval = POWER_SUPPLY_HEALTH_HOT;
1009                                 break;
1010                         default:
1011                                 val->intval = POWER_SUPPLY_HEALTH_GOOD;
1012                                 break;
1013                         }
1014                 }
1015                 break;
1016
1017         case POWER_SUPPLY_PROP_USB_TYPE:
1018                 if (bq->chip_info->has_usb_detect) {
1019                         switch (state.vbus_stat) {
1020                         case BQ256XX_VBUS_STAT_USB_SDP:
1021                                 val->intval = POWER_SUPPLY_USB_TYPE_SDP;
1022                                 break;
1023                         case BQ256XX_VBUS_STAT_USB_CDP:
1024                                 val->intval = POWER_SUPPLY_USB_TYPE_CDP;
1025                                 break;
1026                         case BQ256XX_VBUS_STAT_USB_DCP:
1027                                 val->intval = POWER_SUPPLY_USB_TYPE_DCP;
1028                                 break;
1029                         case BQ256XX_VBUS_STAT_USB_OTG:
1030                                 val->intval = POWER_SUPPLY_USB_TYPE_ACA;
1031                                 break;
1032                         default:
1033                                 val->intval = POWER_SUPPLY_USB_TYPE_UNKNOWN;
1034                                 break;
1035                         }
1036                 } else {
1037                         switch (state.vbus_stat) {
1038                         case BQ256XX_VBUS_STAT_USB_SDP:
1039                                 val->intval = POWER_SUPPLY_USB_TYPE_SDP;
1040                                 break;
1041                         case BQ256XX_VBUS_STAT_USB_OTG:
1042                                 val->intval = POWER_SUPPLY_USB_TYPE_ACA;
1043                                 break;
1044                         default:
1045                                 val->intval = POWER_SUPPLY_USB_TYPE_UNKNOWN;
1046                                 break;
1047                         }
1048                 }
1049                 break;
1050
1051         case POWER_SUPPLY_PROP_CHARGE_TYPE:
1052                 switch (state.chrg_stat) {
1053                 case BQ256XX_CHRG_STAT_NOT_CHRGING:
1054                         val->intval = POWER_SUPPLY_CHARGE_TYPE_NONE;
1055                         break;
1056                 case BQ256XX_CHRG_STAT_PRECHRGING:
1057                         val->intval = POWER_SUPPLY_CHARGE_TYPE_TRICKLE;
1058                         break;
1059                 case BQ256XX_CHRG_STAT_FAST_CHRGING:
1060                         val->intval = POWER_SUPPLY_CHARGE_TYPE_FAST;
1061                         break;
1062                 case BQ256XX_CHRG_STAT_CHRG_TERM:
1063                         val->intval = POWER_SUPPLY_CHARGE_TYPE_TRICKLE;
1064                         break;
1065                 default:
1066                         val->intval = POWER_SUPPLY_CHARGE_TYPE_UNKNOWN;
1067                 }
1068                 break;
1069
1070         case POWER_SUPPLY_PROP_MANUFACTURER:
1071                 val->strval = BQ256XX_MANUFACTURER;
1072                 break;
1073
1074         case POWER_SUPPLY_PROP_MODEL_NAME:
1075                 val->strval = bq->model_name;
1076                 break;
1077
1078         case POWER_SUPPLY_PROP_ONLINE:
1079                 val->intval = state.online;
1080                 break;
1081
1082         case POWER_SUPPLY_PROP_INPUT_VOLTAGE_LIMIT:
1083                 ret = bq->chip_info->bq256xx_get_vindpm(bq);
1084                 if (ret < 0)
1085                         return ret;
1086                 val->intval = ret;
1087                 break;
1088
1089         case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
1090                 ret = bq->chip_info->bq256xx_get_iindpm(bq);
1091                 if (ret < 0)
1092                         return ret;
1093                 val->intval = ret;
1094                 break;
1095
1096         case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
1097                 ret = bq->chip_info->bq256xx_get_vbatreg(bq);
1098                 if (ret < 0)
1099                         return ret;
1100                 val->intval = ret;
1101                 break;
1102
1103         case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
1104                 ret = bq->chip_info->bq256xx_get_ichg(bq);
1105                 if (ret < 0)
1106                         return ret;
1107                 val->intval = ret;
1108                 break;
1109
1110         case POWER_SUPPLY_PROP_PRECHARGE_CURRENT:
1111                 ret = bq->chip_info->bq256xx_get_iprechg(bq);
1112                 if (ret < 0)
1113                         return ret;
1114                 val->intval = ret;
1115                 break;
1116
1117         case POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT:
1118                 ret = bq->chip_info->bq256xx_get_iterm(bq);
1119                 if (ret < 0)
1120                         return ret;
1121                 val->intval = ret;
1122                 break;
1123
1124         default:
1125                 return -EINVAL;
1126         }
1127
1128         return ret;
1129 }
1130
1131 static bool bq256xx_state_changed(struct bq256xx_device *bq,
1132                                   struct bq256xx_state *new_state)
1133 {
1134         struct bq256xx_state old_state;
1135
1136         mutex_lock(&bq->lock);
1137         old_state = bq->state;
1138         mutex_unlock(&bq->lock);
1139
1140         return memcmp(&old_state, new_state, sizeof(struct bq256xx_state)) != 0;
1141 }
1142
1143 static irqreturn_t bq256xx_irq_handler_thread(int irq, void *private)
1144 {
1145         struct bq256xx_device *bq = private;
1146         struct bq256xx_state state;
1147         int ret;
1148
1149         ret = bq256xx_get_state(bq, &state);
1150         if (ret < 0)
1151                 goto irq_out;
1152
1153         if (!bq256xx_state_changed(bq, &state))
1154                 goto irq_out;
1155
1156         mutex_lock(&bq->lock);
1157         bq->state = state;
1158         mutex_unlock(&bq->lock);
1159
1160         power_supply_changed(bq->charger);
1161
1162 irq_out:
1163         return IRQ_HANDLED;
1164 }
1165
1166 static enum power_supply_property bq256xx_power_supply_props[] = {
1167         POWER_SUPPLY_PROP_MANUFACTURER,
1168         POWER_SUPPLY_PROP_MODEL_NAME,
1169         POWER_SUPPLY_PROP_STATUS,
1170         POWER_SUPPLY_PROP_ONLINE,
1171         POWER_SUPPLY_PROP_HEALTH,
1172         POWER_SUPPLY_PROP_INPUT_VOLTAGE_LIMIT,
1173         POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT,
1174         POWER_SUPPLY_PROP_CHARGE_TYPE,
1175         POWER_SUPPLY_PROP_USB_TYPE,
1176         POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT,
1177         POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE,
1178         POWER_SUPPLY_PROP_PRECHARGE_CURRENT,
1179         POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT,
1180 };
1181
1182 static enum power_supply_property bq256xx_battery_props[] = {
1183         POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX,
1184         POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX,
1185 };
1186
1187 static int bq256xx_property_is_writeable(struct power_supply *psy,
1188                                          enum power_supply_property prop)
1189 {
1190         switch (prop) {
1191         case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
1192         case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
1193         case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
1194         case POWER_SUPPLY_PROP_PRECHARGE_CURRENT:
1195         case POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT:
1196         case POWER_SUPPLY_PROP_STATUS:
1197         case POWER_SUPPLY_PROP_INPUT_VOLTAGE_LIMIT:
1198                 return true;
1199         default:
1200                 return false;
1201         }
1202 }
1203
1204 static const struct power_supply_desc bq256xx_power_supply_desc = {
1205         .name = "bq256xx-charger",
1206         .type = POWER_SUPPLY_TYPE_USB,
1207         .usb_types = bq256xx_usb_type,
1208         .num_usb_types = ARRAY_SIZE(bq256xx_usb_type),
1209         .properties = bq256xx_power_supply_props,
1210         .num_properties = ARRAY_SIZE(bq256xx_power_supply_props),
1211         .get_property = bq256xx_get_charger_property,
1212         .set_property = bq256xx_set_charger_property,
1213         .property_is_writeable = bq256xx_property_is_writeable,
1214 };
1215
1216 static struct power_supply_desc bq256xx_battery_desc = {
1217         .name                   = "bq256xx-battery",
1218         .type                   = POWER_SUPPLY_TYPE_BATTERY,
1219         .get_property           = bq256xx_get_battery_property,
1220         .properties             = bq256xx_battery_props,
1221         .num_properties         = ARRAY_SIZE(bq256xx_battery_props),
1222         .property_is_writeable  = bq256xx_property_is_writeable,
1223 };
1224
1225
1226 static bool bq256xx_is_volatile_reg(struct device *dev, unsigned int reg)
1227 {
1228         switch (reg) {
1229         case BQ256XX_INPUT_CURRENT_LIMIT:
1230         case BQ256XX_CHARGER_STATUS_0...BQ256XX_CHARGER_STATUS_2:
1231                 return true;
1232         default:
1233                 return false;
1234         }
1235 }
1236
1237 static const struct regmap_config bq25600_regmap_config = {
1238         .reg_bits = 8,
1239         .val_bits = 8,
1240
1241         .max_register = BQ256XX_PART_INFORMATION,
1242         .reg_defaults   = bq2560x_reg_defs,
1243         .num_reg_defaults = ARRAY_SIZE(bq2560x_reg_defs),
1244         .cache_type = REGCACHE_FLAT,
1245         .volatile_reg = bq256xx_is_volatile_reg,
1246 };
1247
1248 static const struct regmap_config bq25611d_regmap_config = {
1249         .reg_bits = 8,
1250         .val_bits = 8,
1251
1252         .max_register = BQ256XX_CHARGER_CONTROL_4,
1253         .reg_defaults   = bq25611d_reg_defs,
1254         .num_reg_defaults = ARRAY_SIZE(bq25611d_reg_defs),
1255         .cache_type = REGCACHE_FLAT,
1256         .volatile_reg = bq256xx_is_volatile_reg,
1257 };
1258
1259 static const struct regmap_config bq25618_619_regmap_config = {
1260         .reg_bits = 8,
1261         .val_bits = 8,
1262
1263         .max_register = BQ256XX_CHARGER_CONTROL_4,
1264         .reg_defaults   = bq25618_619_reg_defs,
1265         .num_reg_defaults = ARRAY_SIZE(bq25618_619_reg_defs),
1266         .cache_type = REGCACHE_FLAT,
1267         .volatile_reg = bq256xx_is_volatile_reg,
1268 };
1269
1270 static const struct bq256xx_chip_info bq256xx_chip_info_tbl[] = {
1271         [BQ25600] = {
1272                 .model_id = BQ25600,
1273                 .bq256xx_regmap_config = &bq25600_regmap_config,
1274                 .bq256xx_get_ichg = bq256xx_get_ichg_curr,
1275                 .bq256xx_get_iindpm = bq256xx_get_input_curr_lim,
1276                 .bq256xx_get_vbatreg = bq2560x_get_chrg_volt,
1277                 .bq256xx_get_iterm = bq256xx_get_term_curr,
1278                 .bq256xx_get_iprechg = bq256xx_get_prechrg_curr,
1279                 .bq256xx_get_vindpm = bq256xx_get_input_volt_lim,
1280
1281                 .bq256xx_set_ichg = bq256xx_set_ichg_curr,
1282                 .bq256xx_set_iindpm = bq256xx_set_input_curr_lim,
1283                 .bq256xx_set_vbatreg = bq2560x_set_chrg_volt,
1284                 .bq256xx_set_iterm = bq256xx_set_term_curr,
1285                 .bq256xx_set_iprechg = bq256xx_set_prechrg_curr,
1286                 .bq256xx_set_vindpm = bq256xx_set_input_volt_lim,
1287
1288                 .bq256xx_def_ichg = BQ2560X_ICHG_DEF_uA,
1289                 .bq256xx_def_iindpm = BQ256XX_IINDPM_DEF_uA,
1290                 .bq256xx_def_vbatreg = BQ2560X_VBATREG_DEF_uV,
1291                 .bq256xx_def_iterm = BQ256XX_ITERM_DEF_uA,
1292                 .bq256xx_def_iprechg = BQ256XX_IPRECHG_DEF_uA,
1293                 .bq256xx_def_vindpm = BQ256XX_VINDPM_DEF_uV,
1294
1295                 .bq256xx_max_ichg = BQ256XX_ICHG_MAX_uA,
1296                 .bq256xx_max_vbatreg = BQ2560X_VBATREG_MAX_uV,
1297
1298                 .has_usb_detect = false,
1299         },
1300
1301         [BQ25600D] = {
1302                 .model_id = BQ25600D,
1303                 .bq256xx_regmap_config = &bq25600_regmap_config,
1304                 .bq256xx_get_ichg = bq256xx_get_ichg_curr,
1305                 .bq256xx_get_iindpm = bq256xx_get_input_curr_lim,
1306                 .bq256xx_get_vbatreg = bq2560x_get_chrg_volt,
1307                 .bq256xx_get_iterm = bq256xx_get_term_curr,
1308                 .bq256xx_get_iprechg = bq256xx_get_prechrg_curr,
1309                 .bq256xx_get_vindpm = bq256xx_get_input_volt_lim,
1310
1311                 .bq256xx_set_ichg = bq256xx_set_ichg_curr,
1312                 .bq256xx_set_iindpm = bq256xx_set_input_curr_lim,
1313                 .bq256xx_set_vbatreg = bq2560x_set_chrg_volt,
1314                 .bq256xx_set_iterm = bq256xx_set_term_curr,
1315                 .bq256xx_set_iprechg = bq256xx_set_prechrg_curr,
1316                 .bq256xx_set_vindpm = bq256xx_set_input_volt_lim,
1317
1318                 .bq256xx_def_ichg = BQ2560X_ICHG_DEF_uA,
1319                 .bq256xx_def_iindpm = BQ256XX_IINDPM_DEF_uA,
1320                 .bq256xx_def_vbatreg = BQ2560X_VBATREG_DEF_uV,
1321                 .bq256xx_def_iterm = BQ256XX_ITERM_DEF_uA,
1322                 .bq256xx_def_iprechg = BQ256XX_IPRECHG_DEF_uA,
1323                 .bq256xx_def_vindpm = BQ256XX_VINDPM_DEF_uV,
1324
1325                 .bq256xx_max_ichg = BQ256XX_ICHG_MAX_uA,
1326                 .bq256xx_max_vbatreg = BQ2560X_VBATREG_MAX_uV,
1327
1328                 .has_usb_detect = true,
1329         },
1330
1331         [BQ25601] = {
1332                 .model_id = BQ25601,
1333                 .bq256xx_regmap_config = &bq25600_regmap_config,
1334                 .bq256xx_get_ichg = bq256xx_get_ichg_curr,
1335                 .bq256xx_get_iindpm = bq256xx_get_input_curr_lim,
1336                 .bq256xx_get_vbatreg = bq2560x_get_chrg_volt,
1337                 .bq256xx_get_iterm = bq256xx_get_term_curr,
1338                 .bq256xx_get_iprechg = bq256xx_get_prechrg_curr,
1339                 .bq256xx_get_vindpm = bq256xx_get_input_volt_lim,
1340
1341                 .bq256xx_set_ichg = bq256xx_set_ichg_curr,
1342                 .bq256xx_set_iindpm = bq256xx_set_input_curr_lim,
1343                 .bq256xx_set_vbatreg = bq2560x_set_chrg_volt,
1344                 .bq256xx_set_iterm = bq256xx_set_term_curr,
1345                 .bq256xx_set_iprechg = bq256xx_set_prechrg_curr,
1346                 .bq256xx_set_vindpm = bq256xx_set_input_volt_lim,
1347
1348                 .bq256xx_def_ichg = BQ2560X_ICHG_DEF_uA,
1349                 .bq256xx_def_iindpm = BQ256XX_IINDPM_DEF_uA,
1350                 .bq256xx_def_vbatreg = BQ2560X_VBATREG_DEF_uV,
1351                 .bq256xx_def_iterm = BQ256XX_ITERM_DEF_uA,
1352                 .bq256xx_def_iprechg = BQ256XX_IPRECHG_DEF_uA,
1353                 .bq256xx_def_vindpm = BQ256XX_VINDPM_DEF_uV,
1354
1355                 .bq256xx_max_ichg = BQ256XX_ICHG_MAX_uA,
1356                 .bq256xx_max_vbatreg = BQ2560X_VBATREG_MAX_uV,
1357
1358                 .has_usb_detect = false,
1359         },
1360
1361         [BQ25601D] = {
1362                 .model_id = BQ25601D,
1363                 .bq256xx_regmap_config = &bq25600_regmap_config,
1364                 .bq256xx_get_ichg = bq256xx_get_ichg_curr,
1365                 .bq256xx_get_iindpm = bq256xx_get_input_curr_lim,
1366                 .bq256xx_get_vbatreg = bq25601d_get_chrg_volt,
1367                 .bq256xx_get_iterm = bq256xx_get_term_curr,
1368                 .bq256xx_get_iprechg = bq256xx_get_prechrg_curr,
1369                 .bq256xx_get_vindpm = bq256xx_get_input_volt_lim,
1370
1371                 .bq256xx_set_ichg = bq256xx_set_ichg_curr,
1372                 .bq256xx_set_iindpm = bq256xx_set_input_curr_lim,
1373                 .bq256xx_set_vbatreg = bq25601d_set_chrg_volt,
1374                 .bq256xx_set_iterm = bq256xx_set_term_curr,
1375                 .bq256xx_set_iprechg = bq256xx_set_prechrg_curr,
1376                 .bq256xx_set_vindpm = bq256xx_set_input_volt_lim,
1377
1378                 .bq256xx_def_ichg = BQ2560X_ICHG_DEF_uA,
1379                 .bq256xx_def_iindpm = BQ256XX_IINDPM_DEF_uA,
1380                 .bq256xx_def_vbatreg = BQ2560X_VBATREG_DEF_uV,
1381                 .bq256xx_def_iterm = BQ256XX_ITERM_DEF_uA,
1382                 .bq256xx_def_iprechg = BQ256XX_IPRECHG_DEF_uA,
1383                 .bq256xx_def_vindpm = BQ256XX_VINDPM_DEF_uV,
1384
1385                 .bq256xx_max_ichg = BQ256XX_ICHG_MAX_uA,
1386                 .bq256xx_max_vbatreg = BQ2560X_VBATREG_MAX_uV,
1387
1388                 .has_usb_detect = true,
1389         },
1390
1391         [BQ25611D] = {
1392                 .model_id = BQ25611D,
1393                 .bq256xx_regmap_config = &bq25611d_regmap_config,
1394                 .bq256xx_get_ichg = bq256xx_get_ichg_curr,
1395                 .bq256xx_get_iindpm = bq256xx_get_input_curr_lim,
1396                 .bq256xx_get_vbatreg = bq25611d_get_chrg_volt,
1397                 .bq256xx_get_iterm = bq256xx_get_term_curr,
1398                 .bq256xx_get_iprechg = bq256xx_get_prechrg_curr,
1399                 .bq256xx_get_vindpm = bq256xx_get_input_volt_lim,
1400
1401                 .bq256xx_set_ichg = bq256xx_set_ichg_curr,
1402                 .bq256xx_set_iindpm = bq256xx_set_input_curr_lim,
1403                 .bq256xx_set_vbatreg = bq25611d_set_chrg_volt,
1404                 .bq256xx_set_iterm = bq256xx_set_term_curr,
1405                 .bq256xx_set_iprechg = bq256xx_set_prechrg_curr,
1406                 .bq256xx_set_vindpm = bq256xx_set_input_volt_lim,
1407
1408                 .bq256xx_def_ichg = BQ25611D_ICHG_DEF_uA,
1409                 .bq256xx_def_iindpm = BQ256XX_IINDPM_DEF_uA,
1410                 .bq256xx_def_vbatreg = BQ25611D_VBATREG_DEF_uV,
1411                 .bq256xx_def_iterm = BQ256XX_ITERM_DEF_uA,
1412                 .bq256xx_def_iprechg = BQ256XX_IPRECHG_DEF_uA,
1413                 .bq256xx_def_vindpm = BQ256XX_VINDPM_DEF_uV,
1414
1415                 .bq256xx_max_ichg = BQ256XX_ICHG_MAX_uA,
1416                 .bq256xx_max_vbatreg = BQ25611D_VBATREG_MAX_uV,
1417
1418                 .has_usb_detect = true,
1419         },
1420
1421         [BQ25618] = {
1422                 .model_id = BQ25618,
1423                 .bq256xx_regmap_config = &bq25618_619_regmap_config,
1424                 .bq256xx_get_ichg = bq25618_619_get_ichg_curr,
1425                 .bq256xx_get_iindpm = bq256xx_get_input_curr_lim,
1426                 .bq256xx_get_vbatreg = bq25618_619_get_chrg_volt,
1427                 .bq256xx_get_iterm = bq25618_619_get_term_curr,
1428                 .bq256xx_get_iprechg = bq25618_619_get_prechrg_curr,
1429                 .bq256xx_get_vindpm = bq256xx_get_input_volt_lim,
1430
1431                 .bq256xx_set_ichg = bq25618_619_set_ichg_curr,
1432                 .bq256xx_set_iindpm = bq256xx_set_input_curr_lim,
1433                 .bq256xx_set_vbatreg = bq25618_619_set_chrg_volt,
1434                 .bq256xx_set_iterm = bq25618_619_set_term_curr,
1435                 .bq256xx_set_iprechg = bq25618_619_set_prechrg_curr,
1436                 .bq256xx_set_vindpm = bq256xx_set_input_volt_lim,
1437
1438                 .bq256xx_def_ichg = BQ25618_ICHG_DEF_uA,
1439                 .bq256xx_def_iindpm = BQ256XX_IINDPM_DEF_uA,
1440                 .bq256xx_def_vbatreg = BQ25618_VBATREG_DEF_uV,
1441                 .bq256xx_def_iterm = BQ25618_ITERM_DEF_uA,
1442                 .bq256xx_def_iprechg = BQ25618_IPRECHG_DEF_uA,
1443                 .bq256xx_def_vindpm = BQ256XX_VINDPM_DEF_uV,
1444
1445                 .bq256xx_max_ichg = BQ25618_ICHG_MAX_uA,
1446                 .bq256xx_max_vbatreg = BQ25618_VBATREG_MAX_uV,
1447
1448                 .has_usb_detect = false,
1449         },
1450
1451         [BQ25619] = {
1452                 .model_id = BQ25619,
1453                 .bq256xx_regmap_config = &bq25618_619_regmap_config,
1454                 .bq256xx_get_ichg = bq25618_619_get_ichg_curr,
1455                 .bq256xx_get_iindpm = bq256xx_get_input_curr_lim,
1456                 .bq256xx_get_vbatreg = bq25618_619_get_chrg_volt,
1457                 .bq256xx_get_iterm = bq25618_619_get_term_curr,
1458                 .bq256xx_get_iprechg = bq25618_619_get_prechrg_curr,
1459                 .bq256xx_get_vindpm = bq256xx_get_input_volt_lim,
1460
1461                 .bq256xx_set_ichg = bq25618_619_set_ichg_curr,
1462                 .bq256xx_set_iindpm = bq256xx_set_input_curr_lim,
1463                 .bq256xx_set_vbatreg = bq25618_619_set_chrg_volt,
1464                 .bq256xx_set_iterm = bq25618_619_set_term_curr,
1465                 .bq256xx_set_iprechg = bq25618_619_set_prechrg_curr,
1466                 .bq256xx_set_vindpm = bq256xx_set_input_volt_lim,
1467
1468                 .bq256xx_def_ichg = BQ25618_ICHG_DEF_uA,
1469                 .bq256xx_def_iindpm = BQ256XX_IINDPM_DEF_uA,
1470                 .bq256xx_def_vbatreg = BQ25618_VBATREG_DEF_uV,
1471                 .bq256xx_def_iterm = BQ25618_ITERM_DEF_uA,
1472                 .bq256xx_def_iprechg = BQ25618_IPRECHG_DEF_uA,
1473                 .bq256xx_def_vindpm = BQ256XX_VINDPM_DEF_uV,
1474
1475                 .bq256xx_max_ichg = BQ25618_ICHG_MAX_uA,
1476                 .bq256xx_max_vbatreg = BQ25618_VBATREG_MAX_uV,
1477
1478                 .has_usb_detect = false,
1479         },
1480 };
1481
1482 static int bq256xx_power_supply_init(struct bq256xx_device *bq,
1483                 struct power_supply_config *psy_cfg, struct device *dev)
1484 {
1485         bq->charger = devm_power_supply_register(bq->dev,
1486                                                  &bq256xx_power_supply_desc,
1487                                                  psy_cfg);
1488         if (IS_ERR(bq->charger)) {
1489                 dev_err(dev, "power supply register charger failed\n");
1490                 return PTR_ERR(bq->charger);
1491         }
1492
1493         bq->battery = devm_power_supply_register(bq->dev,
1494                                                       &bq256xx_battery_desc,
1495                                                       psy_cfg);
1496         if (IS_ERR(bq->battery)) {
1497                 dev_err(dev, "power supply register battery failed\n");
1498                 return PTR_ERR(bq->battery);
1499         }
1500         return 0;
1501 }
1502
1503 static int bq256xx_hw_init(struct bq256xx_device *bq)
1504 {
1505         struct power_supply_battery_info bat_info = { };
1506         int wd_reg_val = BQ256XX_WATCHDOG_DIS;
1507         int ret = 0;
1508         int i;
1509
1510         for (i = 0; i < BQ256XX_NUM_WD_VAL; i++) {
1511                 if (bq->watchdog_timer == bq256xx_watchdog_time[i]) {
1512                         wd_reg_val = i;
1513                         break;
1514                 }
1515                 if (bq->watchdog_timer > bq256xx_watchdog_time[i] &&
1516                     bq->watchdog_timer < bq256xx_watchdog_time[i + 1])
1517                         wd_reg_val = i;
1518         }
1519         ret = regmap_update_bits(bq->regmap, BQ256XX_CHARGER_CONTROL_1,
1520                                  BQ256XX_WATCHDOG_MASK, wd_reg_val <<
1521                                                 BQ256XX_WDT_BIT_SHIFT);
1522
1523         ret = power_supply_get_battery_info(bq->charger, &bat_info);
1524         if (ret) {
1525                 dev_warn(bq->dev, "battery info missing, default values will be applied\n");
1526
1527                 bat_info.constant_charge_current_max_ua =
1528                                 bq->chip_info->bq256xx_def_ichg;
1529
1530                 bat_info.constant_charge_voltage_max_uv =
1531                                 bq->chip_info->bq256xx_def_vbatreg;
1532
1533                 bat_info.precharge_current_ua =
1534                                 bq->chip_info->bq256xx_def_iprechg;
1535
1536                 bat_info.charge_term_current_ua =
1537                                 bq->chip_info->bq256xx_def_iterm;
1538
1539                 bq->init_data.ichg_max =
1540                                 bq->chip_info->bq256xx_max_ichg;
1541
1542                 bq->init_data.vbatreg_max =
1543                                 bq->chip_info->bq256xx_max_vbatreg;
1544         } else {
1545                 bq->init_data.ichg_max =
1546                         bat_info.constant_charge_current_max_ua;
1547
1548                 bq->init_data.vbatreg_max =
1549                         bat_info.constant_charge_voltage_max_uv;
1550         }
1551
1552         ret = bq->chip_info->bq256xx_set_vindpm(bq, bq->init_data.vindpm);
1553         if (ret)
1554                 return ret;
1555
1556         ret = bq->chip_info->bq256xx_set_iindpm(bq, bq->init_data.iindpm);
1557         if (ret)
1558                 return ret;
1559
1560         ret = bq->chip_info->bq256xx_set_ichg(bq,
1561                                 bat_info.constant_charge_current_max_ua);
1562         if (ret)
1563                 return ret;
1564
1565         ret = bq->chip_info->bq256xx_set_iprechg(bq,
1566                                 bat_info.precharge_current_ua);
1567         if (ret)
1568                 return ret;
1569
1570         ret = bq->chip_info->bq256xx_set_vbatreg(bq,
1571                                 bat_info.constant_charge_voltage_max_uv);
1572         if (ret)
1573                 return ret;
1574
1575         ret = bq->chip_info->bq256xx_set_iterm(bq,
1576                                 bat_info.charge_term_current_ua);
1577         if (ret)
1578                 return ret;
1579
1580         power_supply_put_battery_info(bq->charger, &bat_info);
1581
1582         return 0;
1583 }
1584
1585 static int bq256xx_parse_dt(struct bq256xx_device *bq,
1586                 struct power_supply_config *psy_cfg, struct device *dev)
1587 {
1588         int ret = 0;
1589
1590         psy_cfg->drv_data = bq;
1591         psy_cfg->of_node = dev->of_node;
1592
1593         ret = device_property_read_u32(bq->dev, "ti,watchdog-timeout-ms",
1594                                        &bq->watchdog_timer);
1595         if (ret)
1596                 bq->watchdog_timer = BQ256XX_WATCHDOG_DIS;
1597
1598         if (bq->watchdog_timer > BQ256XX_WATCHDOG_MAX ||
1599             bq->watchdog_timer < BQ256XX_WATCHDOG_DIS)
1600                 return -EINVAL;
1601
1602         ret = device_property_read_u32(bq->dev,
1603                                        "input-voltage-limit-microvolt",
1604                                        &bq->init_data.vindpm);
1605         if (ret)
1606                 bq->init_data.vindpm = bq->chip_info->bq256xx_def_vindpm;
1607
1608         ret = device_property_read_u32(bq->dev,
1609                                        "input-current-limit-microamp",
1610                                        &bq->init_data.iindpm);
1611         if (ret)
1612                 bq->init_data.iindpm = bq->chip_info->bq256xx_def_iindpm;
1613
1614         return 0;
1615 }
1616
1617 static int bq256xx_probe(struct i2c_client *client,
1618                          const struct i2c_device_id *id)
1619 {
1620         struct device *dev = &client->dev;
1621         struct bq256xx_device *bq;
1622         struct power_supply_config psy_cfg = { };
1623
1624         int ret;
1625
1626         bq = devm_kzalloc(dev, sizeof(*bq), GFP_KERNEL);
1627         if (!bq)
1628                 return -ENOMEM;
1629
1630         bq->client = client;
1631         bq->dev = dev;
1632         bq->chip_info = &bq256xx_chip_info_tbl[id->driver_data];
1633
1634         mutex_init(&bq->lock);
1635
1636         strncpy(bq->model_name, id->name, I2C_NAME_SIZE);
1637
1638         bq->regmap = devm_regmap_init_i2c(client,
1639                                         bq->chip_info->bq256xx_regmap_config);
1640
1641         if (IS_ERR(bq->regmap)) {
1642                 dev_err(dev, "Failed to allocate register map\n");
1643                 return PTR_ERR(bq->regmap);
1644         }
1645
1646         i2c_set_clientdata(client, bq);
1647
1648         ret = bq256xx_parse_dt(bq, &psy_cfg, dev);
1649         if (ret) {
1650                 dev_err(dev, "Failed to read device tree properties%d\n", ret);
1651                 return ret;
1652         }
1653
1654         ret = devm_add_action_or_reset(dev, bq256xx_charger_reset, bq);
1655         if (ret)
1656                 return ret;
1657
1658         /* OTG reporting */
1659         bq->usb2_phy = devm_usb_get_phy(dev, USB_PHY_TYPE_USB2);
1660         if (!IS_ERR_OR_NULL(bq->usb2_phy)) {
1661                 INIT_WORK(&bq->usb_work, bq256xx_usb_work);
1662                 bq->usb_nb.notifier_call = bq256xx_usb_notifier;
1663                 usb_register_notifier(bq->usb2_phy, &bq->usb_nb);
1664         }
1665
1666         bq->usb3_phy = devm_usb_get_phy(dev, USB_PHY_TYPE_USB3);
1667         if (!IS_ERR_OR_NULL(bq->usb3_phy)) {
1668                 INIT_WORK(&bq->usb_work, bq256xx_usb_work);
1669                 bq->usb_nb.notifier_call = bq256xx_usb_notifier;
1670                 usb_register_notifier(bq->usb3_phy, &bq->usb_nb);
1671         }
1672
1673         if (client->irq) {
1674                 ret = devm_request_threaded_irq(dev, client->irq, NULL,
1675                                                 bq256xx_irq_handler_thread,
1676                                                 IRQF_TRIGGER_FALLING |
1677                                                 IRQF_ONESHOT,
1678                                                 dev_name(&client->dev), bq);
1679                 if (ret < 0) {
1680                         dev_err(dev, "get irq fail: %d\n", ret);
1681                         return ret;
1682                 }
1683         }
1684
1685         ret = bq256xx_power_supply_init(bq, &psy_cfg, dev);
1686         if (ret) {
1687                 dev_err(dev, "Failed to register power supply\n");
1688                 return ret;
1689         }
1690
1691         ret = bq256xx_hw_init(bq);
1692         if (ret) {
1693                 dev_err(dev, "Cannot initialize the chip.\n");
1694                 return ret;
1695         }
1696
1697         return ret;
1698 }
1699
1700 static const struct i2c_device_id bq256xx_i2c_ids[] = {
1701         { "bq25600", BQ25600 },
1702         { "bq25600d", BQ25600D },
1703         { "bq25601", BQ25601 },
1704         { "bq25601d", BQ25601D },
1705         { "bq25611d", BQ25611D },
1706         { "bq25618", BQ25618 },
1707         { "bq25619", BQ25619 },
1708         {},
1709 };
1710 MODULE_DEVICE_TABLE(i2c, bq256xx_i2c_ids);
1711
1712 static const struct of_device_id bq256xx_of_match[] = {
1713         { .compatible = "ti,bq25600", .data = (void *)BQ25600 },
1714         { .compatible = "ti,bq25600d", .data = (void *)BQ25600D },
1715         { .compatible = "ti,bq25601", .data = (void *)BQ25601 },
1716         { .compatible = "ti,bq25601d", .data = (void *)BQ25601D },
1717         { .compatible = "ti,bq25611d", .data = (void *)BQ25611D },
1718         { .compatible = "ti,bq25618", .data = (void *)BQ25618 },
1719         { .compatible = "ti,bq25619", .data = (void *)BQ25619 },
1720         { },
1721 };
1722 MODULE_DEVICE_TABLE(of, bq256xx_of_match);
1723
1724 static const struct acpi_device_id bq256xx_acpi_match[] = {
1725         { "bq25600", BQ25600 },
1726         { "bq25600d", BQ25600D },
1727         { "bq25601", BQ25601 },
1728         { "bq25601d", BQ25601D },
1729         { "bq25611d", BQ25611D },
1730         { "bq25618", BQ25618 },
1731         { "bq25619", BQ25619 },
1732         {},
1733 };
1734 MODULE_DEVICE_TABLE(acpi, bq256xx_acpi_match);
1735
1736 static struct i2c_driver bq256xx_driver = {
1737         .driver = {
1738                 .name = "bq256xx-charger",
1739                 .of_match_table = bq256xx_of_match,
1740                 .acpi_match_table = bq256xx_acpi_match,
1741         },
1742         .probe = bq256xx_probe,
1743         .id_table = bq256xx_i2c_ids,
1744 };
1745 module_i2c_driver(bq256xx_driver);
1746
1747 MODULE_AUTHOR("Ricardo Rivera-Matos <r-rivera-matos@ti.com>");
1748 MODULE_DESCRIPTION("bq256xx charger driver");
1749 MODULE_LICENSE("GPL v2");