Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0
0002 // BQ256XX Battery Charger Driver
0003 // Copyright (C) 2020 Texas Instruments Incorporated - http://www.ti.com/
0004 
0005 #include <linux/err.h>
0006 #include <linux/i2c.h>
0007 #include <linux/init.h>
0008 #include <linux/interrupt.h>
0009 #include <linux/kernel.h>
0010 #include <linux/module.h>
0011 #include <linux/gpio/consumer.h>
0012 #include <linux/power_supply.h>
0013 #include <linux/regmap.h>
0014 #include <linux/types.h>
0015 #include <linux/usb/phy.h>
0016 #include <linux/device.h>
0017 #include <linux/moduleparam.h>
0018 #include <linux/slab.h>
0019 #include <linux/acpi.h>
0020 
0021 #define BQ256XX_MANUFACTURER "Texas Instruments"
0022 
0023 #define BQ256XX_INPUT_CURRENT_LIMIT     0x00
0024 #define BQ256XX_CHARGER_CONTROL_0       0x01
0025 #define BQ256XX_CHARGE_CURRENT_LIMIT        0x02
0026 #define BQ256XX_PRECHG_AND_TERM_CURR_LIM    0x03
0027 #define BQ256XX_BATTERY_VOLTAGE_LIMIT       0x04
0028 #define BQ256XX_CHARGER_CONTROL_1       0x05
0029 #define BQ256XX_CHARGER_CONTROL_2       0x06
0030 #define BQ256XX_CHARGER_CONTROL_3       0x07
0031 #define BQ256XX_CHARGER_STATUS_0        0x08
0032 #define BQ256XX_CHARGER_STATUS_1        0x09
0033 #define BQ256XX_CHARGER_STATUS_2        0x0a
0034 #define BQ256XX_PART_INFORMATION        0x0b
0035 #define BQ256XX_CHARGER_CONTROL_4       0x0c
0036 
0037 #define BQ256XX_IINDPM_MASK     GENMASK(4, 0)
0038 #define BQ256XX_IINDPM_STEP_uA      100000
0039 #define BQ256XX_IINDPM_OFFSET_uA    100000
0040 #define BQ256XX_IINDPM_MIN_uA       100000
0041 #define BQ256XX_IINDPM_MAX_uA       3200000
0042 #define BQ256XX_IINDPM_DEF_uA       2400000
0043 
0044 #define BQ256XX_VINDPM_MASK     GENMASK(3, 0)
0045 #define BQ256XX_VINDPM_STEP_uV      100000
0046 #define BQ256XX_VINDPM_OFFSET_uV    3900000
0047 #define BQ256XX_VINDPM_MIN_uV       3900000
0048 #define BQ256XX_VINDPM_MAX_uV       5400000
0049 #define BQ256XX_VINDPM_DEF_uV       4500000
0050 
0051 #define BQ256XX_VBATREG_MASK        GENMASK(7, 3)
0052 #define BQ2560X_VBATREG_STEP_uV     32000
0053 #define BQ2560X_VBATREG_OFFSET_uV   3856000
0054 #define BQ2560X_VBATREG_MIN_uV      3856000
0055 #define BQ2560X_VBATREG_MAX_uV      4624000
0056 #define BQ2560X_VBATREG_DEF_uV      4208000
0057 #define BQ25601D_VBATREG_OFFSET_uV  3847000
0058 #define BQ25601D_VBATREG_MIN_uV     3847000
0059 #define BQ25601D_VBATREG_MAX_uV     4615000
0060 #define BQ25601D_VBATREG_DEF_uV     4199000
0061 #define BQ2561X_VBATREG_STEP_uV     10000
0062 #define BQ25611D_VBATREG_MIN_uV     3494000
0063 #define BQ25611D_VBATREG_MAX_uV     4510000
0064 #define BQ25611D_VBATREG_DEF_uV     4190000
0065 #define BQ25618_VBATREG_MIN_uV      3504000
0066 #define BQ25618_VBATREG_MAX_uV      4500000
0067 #define BQ25618_VBATREG_DEF_uV      4200000
0068 #define BQ256XX_VBATREG_BIT_SHIFT   3
0069 #define BQ2561X_VBATREG_THRESH      0x8
0070 #define BQ25611D_VBATREG_THRESH_uV  4290000
0071 #define BQ25618_VBATREG_THRESH_uV   4300000
0072 
0073 #define BQ256XX_ITERM_MASK      GENMASK(3, 0)
0074 #define BQ256XX_ITERM_STEP_uA       60000
0075 #define BQ256XX_ITERM_OFFSET_uA     60000
0076 #define BQ256XX_ITERM_MIN_uA        60000
0077 #define BQ256XX_ITERM_MAX_uA        780000
0078 #define BQ256XX_ITERM_DEF_uA        180000
0079 #define BQ25618_ITERM_STEP_uA       20000
0080 #define BQ25618_ITERM_OFFSET_uA     20000
0081 #define BQ25618_ITERM_MIN_uA        20000
0082 #define BQ25618_ITERM_MAX_uA        260000
0083 #define BQ25618_ITERM_DEF_uA        60000
0084 
0085 #define BQ256XX_IPRECHG_MASK        GENMASK(7, 4)
0086 #define BQ256XX_IPRECHG_STEP_uA     60000
0087 #define BQ256XX_IPRECHG_OFFSET_uA   60000
0088 #define BQ256XX_IPRECHG_MIN_uA      60000
0089 #define BQ256XX_IPRECHG_MAX_uA      780000
0090 #define BQ256XX_IPRECHG_DEF_uA      180000
0091 #define BQ25618_IPRECHG_STEP_uA     20000
0092 #define BQ25618_IPRECHG_OFFSET_uA   20000
0093 #define BQ25618_IPRECHG_MIN_uA      20000
0094 #define BQ25618_IPRECHG_MAX_uA      260000
0095 #define BQ25618_IPRECHG_DEF_uA      40000
0096 #define BQ256XX_IPRECHG_BIT_SHIFT   4
0097 
0098 #define BQ256XX_ICHG_MASK       GENMASK(5, 0)
0099 #define BQ256XX_ICHG_STEP_uA        60000
0100 #define BQ256XX_ICHG_MIN_uA     0
0101 #define BQ256XX_ICHG_MAX_uA     3000000
0102 #define BQ2560X_ICHG_DEF_uA     2040000
0103 #define BQ25611D_ICHG_DEF_uA        1020000
0104 #define BQ25618_ICHG_STEP_uA        20000
0105 #define BQ25618_ICHG_MIN_uA     0
0106 #define BQ25618_ICHG_MAX_uA     1500000
0107 #define BQ25618_ICHG_DEF_uA     340000
0108 #define BQ25618_ICHG_THRESH     0x3c
0109 #define BQ25618_ICHG_THRESH_uA      1180000
0110 
0111 #define BQ256XX_VBUS_STAT_MASK      GENMASK(7, 5)
0112 #define BQ256XX_VBUS_STAT_NO_INPUT  0
0113 #define BQ256XX_VBUS_STAT_USB_SDP   BIT(5)
0114 #define BQ256XX_VBUS_STAT_USB_CDP   BIT(6)
0115 #define BQ256XX_VBUS_STAT_USB_DCP   (BIT(6) | BIT(5))
0116 #define BQ256XX_VBUS_STAT_USB_OTG   (BIT(7) | BIT(6) | BIT(5))
0117 
0118 #define BQ256XX_CHRG_STAT_MASK      GENMASK(4, 3)
0119 #define BQ256XX_CHRG_STAT_NOT_CHRGING   0
0120 #define BQ256XX_CHRG_STAT_PRECHRGING    BIT(3)
0121 #define BQ256XX_CHRG_STAT_FAST_CHRGING  BIT(4)
0122 #define BQ256XX_CHRG_STAT_CHRG_TERM (BIT(4) | BIT(3))
0123 
0124 #define BQ256XX_PG_STAT_MASK        BIT(2)
0125 #define BQ256XX_WDT_FAULT_MASK      BIT(7)
0126 #define BQ256XX_CHRG_FAULT_MASK     GENMASK(5, 4)
0127 #define BQ256XX_CHRG_FAULT_NORMAL   0
0128 #define BQ256XX_CHRG_FAULT_INPUT    BIT(4)
0129 #define BQ256XX_CHRG_FAULT_THERM    BIT(5)
0130 #define BQ256XX_CHRG_FAULT_CST_EXPIRE   (BIT(5) | BIT(4))
0131 #define BQ256XX_BAT_FAULT_MASK      BIT(3)
0132 #define BQ256XX_NTC_FAULT_MASK      GENMASK(2, 0)
0133 #define BQ256XX_NTC_FAULT_WARM      BIT(1)
0134 #define BQ256XX_NTC_FAULT_COOL      (BIT(1) | BIT(0))
0135 #define BQ256XX_NTC_FAULT_COLD      (BIT(2) | BIT(0))
0136 #define BQ256XX_NTC_FAULT_HOT       (BIT(2) | BIT(1))
0137 
0138 #define BQ256XX_NUM_WD_VAL  4
0139 #define BQ256XX_WATCHDOG_MASK   GENMASK(5, 4)
0140 #define BQ256XX_WATCHDOG_MAX    1600000
0141 #define BQ256XX_WATCHDOG_DIS    0
0142 #define BQ256XX_WDT_BIT_SHIFT   4
0143 
0144 #define BQ256XX_REG_RST     BIT(7)
0145 
0146 /**
0147  * struct bq256xx_init_data -
0148  * @ichg: fast charge current
0149  * @iindpm: input current limit
0150  * @vbatreg: charge voltage
0151  * @iterm: termination current
0152  * @iprechg: precharge current
0153  * @vindpm: input voltage limit
0154  * @ichg_max: maximum fast charge current
0155  * @vbatreg_max: maximum charge voltage
0156  */
0157 struct bq256xx_init_data {
0158     u32 ichg;
0159     u32 iindpm;
0160     u32 vbatreg;
0161     u32 iterm;
0162     u32 iprechg;
0163     u32 vindpm;
0164     u32 ichg_max;
0165     u32 vbatreg_max;
0166 };
0167 
0168 /**
0169  * struct bq256xx_state -
0170  * @vbus_stat: VBUS status according to BQ256XX_CHARGER_STATUS_0
0171  * @chrg_stat: charging status according to BQ256XX_CHARGER_STATUS_0
0172  * @online: PG status according to BQ256XX_CHARGER_STATUS_0
0173  *
0174  * @wdt_fault: watchdog fault according to BQ256XX_CHARGER_STATUS_1
0175  * @bat_fault: battery fault according to BQ256XX_CHARGER_STATUS_1
0176  * @chrg_fault: charging fault according to BQ256XX_CHARGER_STATUS_1
0177  * @ntc_fault: TS fault according to BQ256XX_CHARGER_STATUS_1
0178  */
0179 struct bq256xx_state {
0180     u8 vbus_stat;
0181     u8 chrg_stat;
0182     bool online;
0183 
0184     u8 wdt_fault;
0185     u8 bat_fault;
0186     u8 chrg_fault;
0187     u8 ntc_fault;
0188 };
0189 
0190 enum bq256xx_id {
0191     BQ25600,
0192     BQ25600D,
0193     BQ25601,
0194     BQ25601D,
0195     BQ25618,
0196     BQ25619,
0197     BQ25611D,
0198 };
0199 
0200 /**
0201  * struct bq256xx_device -
0202  * @client: i2c client structure
0203  * @regmap: register map structure
0204  * @dev: device structure
0205  * @charger: power supply registered for the charger
0206  * @battery: power supply registered for the battery
0207  * @lock: mutex lock structure
0208  *
0209  * @usb2_phy: usb_phy identifier
0210  * @usb3_phy: usb_phy identifier
0211  * @usb_nb: notifier block
0212  * @usb_work: usb work queue
0213  * @usb_event: usb_event code
0214  *
0215  * @model_name: i2c name string
0216  *
0217  * @init_data: initialization data
0218  * @chip_info: device variant information
0219  * @state: device status and faults
0220  * @watchdog_timer: watchdog timer value in milliseconds
0221  */
0222 struct bq256xx_device {
0223     struct i2c_client *client;
0224     struct device *dev;
0225     struct power_supply *charger;
0226     struct power_supply *battery;
0227     struct mutex lock;
0228     struct regmap *regmap;
0229 
0230     struct usb_phy *usb2_phy;
0231     struct usb_phy *usb3_phy;
0232     struct notifier_block usb_nb;
0233     struct work_struct usb_work;
0234     unsigned long usb_event;
0235 
0236     char model_name[I2C_NAME_SIZE];
0237 
0238     struct bq256xx_init_data init_data;
0239     const struct bq256xx_chip_info *chip_info;
0240     struct bq256xx_state state;
0241     int watchdog_timer;
0242 };
0243 
0244 /**
0245  * struct bq256xx_chip_info -
0246  * @model_id: device instance
0247  *
0248  * @bq256xx_regmap_config: regmap configuration struct
0249  * @bq256xx_get_ichg: pointer to instance specific get_ichg function
0250  * @bq256xx_get_iindpm: pointer to instance specific get_iindpm function
0251  * @bq256xx_get_vbatreg: pointer to instance specific get_vbatreg function
0252  * @bq256xx_get_iterm: pointer to instance specific get_iterm function
0253  * @bq256xx_get_iprechg: pointer to instance specific get_iprechg function
0254  * @bq256xx_get_vindpm: pointer to instance specific get_vindpm function
0255  *
0256  * @bq256xx_set_ichg: pointer to instance specific set_ichg function
0257  * @bq256xx_set_iindpm: pointer to instance specific set_iindpm function
0258  * @bq256xx_set_vbatreg: pointer to instance specific set_vbatreg function
0259  * @bq256xx_set_iterm: pointer to instance specific set_iterm function
0260  * @bq256xx_set_iprechg: pointer to instance specific set_iprechg function
0261  * @bq256xx_set_vindpm: pointer to instance specific set_vindpm function
0262  *
0263  * @bq256xx_def_ichg: default ichg value in microamps
0264  * @bq256xx_def_iindpm: default iindpm value in microamps
0265  * @bq256xx_def_vbatreg: default vbatreg value in microvolts
0266  * @bq256xx_def_iterm: default iterm value in microamps
0267  * @bq256xx_def_iprechg: default iprechg value in microamps
0268  * @bq256xx_def_vindpm: default vindpm value in microvolts
0269  *
0270  * @bq256xx_max_ichg: maximum charge current in microamps
0271  * @bq256xx_max_vbatreg: maximum battery regulation voltage in microvolts
0272  *
0273  * @has_usb_detect: indicates whether device has BC1.2 detection
0274  */
0275 struct bq256xx_chip_info {
0276     int model_id;
0277 
0278     const struct regmap_config *bq256xx_regmap_config;
0279 
0280     int (*bq256xx_get_ichg)(struct bq256xx_device *bq);
0281     int (*bq256xx_get_iindpm)(struct bq256xx_device *bq);
0282     int (*bq256xx_get_vbatreg)(struct bq256xx_device *bq);
0283     int (*bq256xx_get_iterm)(struct bq256xx_device *bq);
0284     int (*bq256xx_get_iprechg)(struct bq256xx_device *bq);
0285     int (*bq256xx_get_vindpm)(struct bq256xx_device *bq);
0286 
0287     int (*bq256xx_set_ichg)(struct bq256xx_device *bq, int ichg);
0288     int (*bq256xx_set_iindpm)(struct bq256xx_device *bq, int iindpm);
0289     int (*bq256xx_set_vbatreg)(struct bq256xx_device *bq, int vbatreg);
0290     int (*bq256xx_set_iterm)(struct bq256xx_device *bq, int iterm);
0291     int (*bq256xx_set_iprechg)(struct bq256xx_device *bq, int iprechg);
0292     int (*bq256xx_set_vindpm)(struct bq256xx_device *bq, int vindpm);
0293 
0294     int bq256xx_def_ichg;
0295     int bq256xx_def_iindpm;
0296     int bq256xx_def_vbatreg;
0297     int bq256xx_def_iterm;
0298     int bq256xx_def_iprechg;
0299     int bq256xx_def_vindpm;
0300 
0301     int bq256xx_max_ichg;
0302     int bq256xx_max_vbatreg;
0303 
0304     bool has_usb_detect;
0305 };
0306 
0307 static int bq256xx_watchdog_time[BQ256XX_NUM_WD_VAL] = {
0308     0, 40000, 80000, 1600000
0309 };
0310 
0311 static const int bq25611d_vbatreg_values[] = {
0312     3494000, 3590000, 3686000, 3790000, 3894000, 3990000, 4090000, 4140000,
0313     4190000
0314 };
0315 
0316 static const int bq25618_619_vbatreg_values[] = {
0317     3504000, 3600000, 3696000, 3800000, 3904000, 4000000, 4100000, 4150000,
0318     4200000
0319 };
0320 
0321 static const int bq25618_619_ichg_values[] = {
0322     1290000, 1360000, 1430000, 1500000
0323 };
0324 
0325 static enum power_supply_usb_type bq256xx_usb_type[] = {
0326     POWER_SUPPLY_USB_TYPE_SDP,
0327     POWER_SUPPLY_USB_TYPE_CDP,
0328     POWER_SUPPLY_USB_TYPE_DCP,
0329     POWER_SUPPLY_USB_TYPE_UNKNOWN,
0330     POWER_SUPPLY_USB_TYPE_ACA,
0331 };
0332 
0333 static int bq256xx_array_parse(int array_size, int val, const int array[])
0334 {
0335     int i = 0;
0336 
0337     if (val < array[i])
0338         return i - 1;
0339 
0340     if (val >= array[array_size - 1])
0341         return array_size - 1;
0342 
0343     for (i = 1; i < array_size; i++) {
0344         if (val == array[i])
0345             return i;
0346 
0347         if (val > array[i - 1] && val < array[i]) {
0348             if (val < array[i])
0349                 return i - 1;
0350             else
0351                 return i;
0352         }
0353     }
0354     return -EINVAL;
0355 }
0356 
0357 static int bq256xx_usb_notifier(struct notifier_block *nb, unsigned long val,
0358                 void *priv)
0359 {
0360     struct bq256xx_device *bq =
0361             container_of(nb, struct bq256xx_device, usb_nb);
0362 
0363     bq->usb_event = val;
0364     queue_work(system_power_efficient_wq, &bq->usb_work);
0365 
0366     return NOTIFY_OK;
0367 }
0368 
0369 static void bq256xx_usb_work(struct work_struct *data)
0370 {
0371     struct bq256xx_device *bq =
0372             container_of(data, struct bq256xx_device, usb_work);
0373 
0374     switch (bq->usb_event) {
0375     case USB_EVENT_ID:
0376         break;
0377     case USB_EVENT_NONE:
0378         power_supply_changed(bq->charger);
0379         break;
0380     default:
0381         dev_err(bq->dev, "Error switching to charger mode.\n");
0382         break;
0383     }
0384 }
0385 
0386 static struct reg_default bq2560x_reg_defs[] = {
0387     {BQ256XX_INPUT_CURRENT_LIMIT, 0x17},
0388     {BQ256XX_CHARGER_CONTROL_0, 0x1a},
0389     {BQ256XX_CHARGE_CURRENT_LIMIT, 0xa2},
0390     {BQ256XX_PRECHG_AND_TERM_CURR_LIM, 0x22},
0391     {BQ256XX_BATTERY_VOLTAGE_LIMIT, 0x58},
0392     {BQ256XX_CHARGER_CONTROL_1, 0x9f},
0393     {BQ256XX_CHARGER_CONTROL_2, 0x66},
0394     {BQ256XX_CHARGER_CONTROL_3, 0x4c},
0395 };
0396 
0397 static struct reg_default bq25611d_reg_defs[] = {
0398     {BQ256XX_INPUT_CURRENT_LIMIT, 0x17},
0399     {BQ256XX_CHARGER_CONTROL_0, 0x1a},
0400     {BQ256XX_CHARGE_CURRENT_LIMIT, 0x91},
0401     {BQ256XX_PRECHG_AND_TERM_CURR_LIM, 0x12},
0402     {BQ256XX_BATTERY_VOLTAGE_LIMIT, 0x40},
0403     {BQ256XX_CHARGER_CONTROL_1, 0x9e},
0404     {BQ256XX_CHARGER_CONTROL_2, 0xe6},
0405     {BQ256XX_CHARGER_CONTROL_3, 0x4c},
0406     {BQ256XX_PART_INFORMATION, 0x54},
0407     {BQ256XX_CHARGER_CONTROL_4, 0x75},
0408 };
0409 
0410 static struct reg_default bq25618_619_reg_defs[] = {
0411     {BQ256XX_INPUT_CURRENT_LIMIT, 0x17},
0412     {BQ256XX_CHARGER_CONTROL_0, 0x1a},
0413     {BQ256XX_CHARGE_CURRENT_LIMIT, 0x91},
0414     {BQ256XX_PRECHG_AND_TERM_CURR_LIM, 0x12},
0415     {BQ256XX_BATTERY_VOLTAGE_LIMIT, 0x40},
0416     {BQ256XX_CHARGER_CONTROL_1, 0x9e},
0417     {BQ256XX_CHARGER_CONTROL_2, 0xe6},
0418     {BQ256XX_CHARGER_CONTROL_3, 0x4c},
0419     {BQ256XX_PART_INFORMATION, 0x2c},
0420     {BQ256XX_CHARGER_CONTROL_4, 0x75},
0421 };
0422 
0423 static int bq256xx_get_state(struct bq256xx_device *bq,
0424                 struct bq256xx_state *state)
0425 {
0426     unsigned int charger_status_0;
0427     unsigned int charger_status_1;
0428     int ret;
0429 
0430     ret = regmap_read(bq->regmap, BQ256XX_CHARGER_STATUS_0,
0431                         &charger_status_0);
0432     if (ret)
0433         return ret;
0434 
0435     ret = regmap_read(bq->regmap, BQ256XX_CHARGER_STATUS_1,
0436                         &charger_status_1);
0437     if (ret)
0438         return ret;
0439 
0440     state->vbus_stat = charger_status_0 & BQ256XX_VBUS_STAT_MASK;
0441     state->chrg_stat = charger_status_0 & BQ256XX_CHRG_STAT_MASK;
0442     state->online = charger_status_0 & BQ256XX_PG_STAT_MASK;
0443 
0444     state->wdt_fault = charger_status_1 & BQ256XX_WDT_FAULT_MASK;
0445     state->bat_fault = charger_status_1 & BQ256XX_BAT_FAULT_MASK;
0446     state->chrg_fault = charger_status_1 & BQ256XX_CHRG_FAULT_MASK;
0447     state->ntc_fault = charger_status_1 & BQ256XX_NTC_FAULT_MASK;
0448 
0449     return 0;
0450 }
0451 
0452 static int bq256xx_get_ichg_curr(struct bq256xx_device *bq)
0453 {
0454     unsigned int charge_current_limit;
0455     unsigned int ichg_reg_code;
0456     int ret;
0457 
0458     ret = regmap_read(bq->regmap, BQ256XX_CHARGE_CURRENT_LIMIT,
0459                         &charge_current_limit);
0460     if (ret)
0461         return ret;
0462 
0463     ichg_reg_code = charge_current_limit & BQ256XX_ICHG_MASK;
0464 
0465     return ichg_reg_code * BQ256XX_ICHG_STEP_uA;
0466 }
0467 
0468 static int bq25618_619_get_ichg_curr(struct bq256xx_device *bq)
0469 {
0470     unsigned int charge_current_limit;
0471     unsigned int ichg_reg_code;
0472     int ret;
0473 
0474     ret = regmap_read(bq->regmap, BQ256XX_CHARGE_CURRENT_LIMIT,
0475                         &charge_current_limit);
0476     if (ret)
0477         return ret;
0478 
0479     ichg_reg_code = charge_current_limit & BQ256XX_ICHG_MASK;
0480 
0481     if (ichg_reg_code < BQ25618_ICHG_THRESH)
0482         return ichg_reg_code * BQ25618_ICHG_STEP_uA;
0483 
0484     return bq25618_619_ichg_values[ichg_reg_code - BQ25618_ICHG_THRESH];
0485 }
0486 
0487 static int bq256xx_set_ichg_curr(struct bq256xx_device *bq, int ichg)
0488 {
0489     unsigned int ichg_reg_code;
0490     int ichg_max = bq->init_data.ichg_max;
0491 
0492     ichg = clamp(ichg, BQ256XX_ICHG_MIN_uA, ichg_max);
0493     ichg_reg_code = ichg / BQ256XX_ICHG_STEP_uA;
0494 
0495     return regmap_update_bits(bq->regmap, BQ256XX_CHARGE_CURRENT_LIMIT,
0496                     BQ256XX_ICHG_MASK, ichg_reg_code);
0497 }
0498 
0499 static int bq25618_619_set_ichg_curr(struct bq256xx_device *bq, int ichg)
0500 {
0501     int array_size = ARRAY_SIZE(bq25618_619_ichg_values);
0502     unsigned int ichg_reg_code;
0503     int ichg_max = bq->init_data.ichg_max;
0504 
0505     ichg = clamp(ichg, BQ25618_ICHG_MIN_uA, ichg_max);
0506 
0507     if (ichg <= BQ25618_ICHG_THRESH_uA) {
0508         ichg_reg_code = ichg / BQ25618_ICHG_STEP_uA;
0509     } else {
0510         ichg_reg_code = bq256xx_array_parse(array_size, ichg,
0511             bq25618_619_ichg_values) + BQ25618_ICHG_THRESH;
0512     }
0513 
0514     return regmap_update_bits(bq->regmap, BQ256XX_CHARGE_CURRENT_LIMIT,
0515                     BQ256XX_ICHG_MASK, ichg_reg_code);
0516 }
0517 
0518 static int bq25618_619_get_chrg_volt(struct bq256xx_device *bq)
0519 {
0520     unsigned int battery_volt_lim;
0521     unsigned int vbatreg_reg_code;
0522     int ret;
0523 
0524     ret = regmap_read(bq->regmap, BQ256XX_BATTERY_VOLTAGE_LIMIT,
0525                             &battery_volt_lim);
0526 
0527     if (ret)
0528         return ret;
0529 
0530     vbatreg_reg_code = (battery_volt_lim & BQ256XX_VBATREG_MASK) >>
0531                         BQ256XX_VBATREG_BIT_SHIFT;
0532 
0533     if (vbatreg_reg_code > BQ2561X_VBATREG_THRESH)
0534         return ((vbatreg_reg_code - BQ2561X_VBATREG_THRESH) *
0535                     BQ2561X_VBATREG_STEP_uV) +
0536                     BQ25618_VBATREG_THRESH_uV;
0537 
0538     return bq25618_619_vbatreg_values[vbatreg_reg_code];
0539 }
0540 
0541 static int bq25611d_get_chrg_volt(struct bq256xx_device *bq)
0542 {
0543     unsigned int battery_volt_lim;
0544     unsigned int vbatreg_reg_code;
0545     int ret;
0546 
0547     ret = regmap_read(bq->regmap, BQ256XX_BATTERY_VOLTAGE_LIMIT,
0548                             &battery_volt_lim);
0549     if (ret)
0550         return ret;
0551 
0552     vbatreg_reg_code = (battery_volt_lim & BQ256XX_VBATREG_MASK) >>
0553                         BQ256XX_VBATREG_BIT_SHIFT;
0554 
0555     if (vbatreg_reg_code > BQ2561X_VBATREG_THRESH)
0556         return ((vbatreg_reg_code - BQ2561X_VBATREG_THRESH) *
0557                     BQ2561X_VBATREG_STEP_uV) +
0558                     BQ25611D_VBATREG_THRESH_uV;
0559 
0560     return bq25611d_vbatreg_values[vbatreg_reg_code];
0561 }
0562 
0563 static int bq2560x_get_chrg_volt(struct bq256xx_device *bq)
0564 {
0565     unsigned int battery_volt_lim;
0566     unsigned int vbatreg_reg_code;
0567     int ret;
0568 
0569     ret = regmap_read(bq->regmap, BQ256XX_BATTERY_VOLTAGE_LIMIT,
0570                             &battery_volt_lim);
0571     if (ret)
0572         return ret;
0573 
0574     vbatreg_reg_code = (battery_volt_lim & BQ256XX_VBATREG_MASK) >>
0575                         BQ256XX_VBATREG_BIT_SHIFT;
0576 
0577     return (vbatreg_reg_code * BQ2560X_VBATREG_STEP_uV)
0578                     + BQ2560X_VBATREG_OFFSET_uV;
0579 }
0580 
0581 static int bq25601d_get_chrg_volt(struct bq256xx_device *bq)
0582 {
0583     unsigned int battery_volt_lim;
0584     unsigned int vbatreg_reg_code;
0585     int ret;
0586 
0587     ret = regmap_read(bq->regmap, BQ256XX_BATTERY_VOLTAGE_LIMIT,
0588                             &battery_volt_lim);
0589     if (ret)
0590         return ret;
0591 
0592     vbatreg_reg_code = (battery_volt_lim & BQ256XX_VBATREG_MASK) >>
0593                         BQ256XX_VBATREG_BIT_SHIFT;
0594 
0595     return (vbatreg_reg_code * BQ2560X_VBATREG_STEP_uV)
0596                     + BQ25601D_VBATREG_OFFSET_uV;
0597 }
0598 
0599 static int bq25618_619_set_chrg_volt(struct bq256xx_device *bq, int vbatreg)
0600 {
0601     int array_size = ARRAY_SIZE(bq25618_619_vbatreg_values);
0602     unsigned int vbatreg_reg_code;
0603     int vbatreg_max = bq->init_data.vbatreg_max;
0604 
0605     vbatreg = clamp(vbatreg, BQ25618_VBATREG_MIN_uV, vbatreg_max);
0606 
0607     if (vbatreg > BQ25618_VBATREG_THRESH_uV)
0608         vbatreg_reg_code = ((vbatreg -
0609         BQ25618_VBATREG_THRESH_uV) /
0610         (BQ2561X_VBATREG_STEP_uV)) + BQ2561X_VBATREG_THRESH;
0611     else {
0612         vbatreg_reg_code = bq256xx_array_parse(array_size, vbatreg,
0613                         bq25618_619_vbatreg_values);
0614     }
0615 
0616     return regmap_update_bits(bq->regmap, BQ256XX_BATTERY_VOLTAGE_LIMIT,
0617                 BQ256XX_VBATREG_MASK, vbatreg_reg_code <<
0618                         BQ256XX_VBATREG_BIT_SHIFT);
0619 }
0620 
0621 static int bq25611d_set_chrg_volt(struct bq256xx_device *bq, int vbatreg)
0622 {
0623     int array_size = ARRAY_SIZE(bq25611d_vbatreg_values);
0624     unsigned int vbatreg_reg_code;
0625     int vbatreg_max = bq->init_data.vbatreg_max;
0626 
0627     vbatreg = clamp(vbatreg, BQ25611D_VBATREG_MIN_uV, vbatreg_max);
0628 
0629     if (vbatreg > BQ25611D_VBATREG_THRESH_uV)
0630         vbatreg_reg_code = ((vbatreg -
0631         BQ25611D_VBATREG_THRESH_uV) /
0632         (BQ2561X_VBATREG_STEP_uV)) + BQ2561X_VBATREG_THRESH;
0633     else {
0634         vbatreg_reg_code = bq256xx_array_parse(array_size, vbatreg,
0635                         bq25611d_vbatreg_values);
0636     }
0637 
0638     return regmap_update_bits(bq->regmap, BQ256XX_BATTERY_VOLTAGE_LIMIT,
0639                 BQ256XX_VBATREG_MASK, vbatreg_reg_code <<
0640                         BQ256XX_VBATREG_BIT_SHIFT);
0641 }
0642 
0643 static int bq2560x_set_chrg_volt(struct bq256xx_device *bq, int vbatreg)
0644 {
0645     unsigned int vbatreg_reg_code;
0646     int vbatreg_max = bq->init_data.vbatreg_max;
0647 
0648     vbatreg = clamp(vbatreg, BQ2560X_VBATREG_MIN_uV, vbatreg_max);
0649 
0650     vbatreg_reg_code = (vbatreg - BQ2560X_VBATREG_OFFSET_uV) /
0651                         BQ2560X_VBATREG_STEP_uV;
0652 
0653     return regmap_update_bits(bq->regmap, BQ256XX_BATTERY_VOLTAGE_LIMIT,
0654                 BQ256XX_VBATREG_MASK, vbatreg_reg_code <<
0655                         BQ256XX_VBATREG_BIT_SHIFT);
0656 }
0657 
0658 static int bq25601d_set_chrg_volt(struct bq256xx_device *bq, int vbatreg)
0659 {
0660     unsigned int vbatreg_reg_code;
0661     int vbatreg_max = bq->init_data.vbatreg_max;
0662 
0663     vbatreg = clamp(vbatreg, BQ25601D_VBATREG_MIN_uV, vbatreg_max);
0664 
0665     vbatreg_reg_code = (vbatreg - BQ25601D_VBATREG_OFFSET_uV) /
0666                         BQ2560X_VBATREG_STEP_uV;
0667 
0668     return regmap_update_bits(bq->regmap, BQ256XX_BATTERY_VOLTAGE_LIMIT,
0669                 BQ256XX_VBATREG_MASK, vbatreg_reg_code <<
0670                         BQ256XX_VBATREG_BIT_SHIFT);
0671 }
0672 
0673 static int bq256xx_get_prechrg_curr(struct bq256xx_device *bq)
0674 {
0675     unsigned int prechg_and_term_curr_lim;
0676     unsigned int iprechg_reg_code;
0677     int ret;
0678 
0679     ret = regmap_read(bq->regmap, BQ256XX_PRECHG_AND_TERM_CURR_LIM,
0680                         &prechg_and_term_curr_lim);
0681     if (ret)
0682         return ret;
0683 
0684     iprechg_reg_code = (prechg_and_term_curr_lim & BQ256XX_IPRECHG_MASK)
0685                         >> BQ256XX_IPRECHG_BIT_SHIFT;
0686 
0687     return (iprechg_reg_code * BQ256XX_IPRECHG_STEP_uA) +
0688                         BQ256XX_IPRECHG_OFFSET_uA;
0689 }
0690 
0691 static int bq256xx_set_prechrg_curr(struct bq256xx_device *bq, int iprechg)
0692 {
0693     unsigned int iprechg_reg_code;
0694 
0695     iprechg = clamp(iprechg, BQ256XX_IPRECHG_MIN_uA,
0696                         BQ256XX_IPRECHG_MAX_uA);
0697 
0698     iprechg_reg_code = ((iprechg - BQ256XX_IPRECHG_OFFSET_uA) /
0699             BQ256XX_IPRECHG_STEP_uA) << BQ256XX_IPRECHG_BIT_SHIFT;
0700 
0701     return regmap_update_bits(bq->regmap, BQ256XX_PRECHG_AND_TERM_CURR_LIM,
0702                 BQ256XX_IPRECHG_MASK, iprechg_reg_code);
0703 }
0704 
0705 static int bq25618_619_get_prechrg_curr(struct bq256xx_device *bq)
0706 {
0707     unsigned int prechg_and_term_curr_lim;
0708     unsigned int iprechg_reg_code;
0709     int ret;
0710 
0711     ret = regmap_read(bq->regmap, BQ256XX_PRECHG_AND_TERM_CURR_LIM,
0712                         &prechg_and_term_curr_lim);
0713     if (ret)
0714         return ret;
0715 
0716     iprechg_reg_code = (prechg_and_term_curr_lim & BQ256XX_IPRECHG_MASK)
0717                         >> BQ256XX_IPRECHG_BIT_SHIFT;
0718 
0719     return (iprechg_reg_code * BQ25618_IPRECHG_STEP_uA) +
0720                         BQ25618_IPRECHG_OFFSET_uA;
0721 }
0722 
0723 static int bq25618_619_set_prechrg_curr(struct bq256xx_device *bq, int iprechg)
0724 {
0725     unsigned int iprechg_reg_code;
0726 
0727     iprechg = clamp(iprechg, BQ25618_IPRECHG_MIN_uA,
0728                         BQ25618_IPRECHG_MAX_uA);
0729 
0730     iprechg_reg_code = ((iprechg - BQ25618_IPRECHG_OFFSET_uA) /
0731             BQ25618_IPRECHG_STEP_uA) << BQ256XX_IPRECHG_BIT_SHIFT;
0732 
0733     return regmap_update_bits(bq->regmap, BQ256XX_PRECHG_AND_TERM_CURR_LIM,
0734                 BQ256XX_IPRECHG_MASK, iprechg_reg_code);
0735 }
0736 
0737 static int bq256xx_get_term_curr(struct bq256xx_device *bq)
0738 {
0739     unsigned int prechg_and_term_curr_lim;
0740     unsigned int iterm_reg_code;
0741     int ret;
0742 
0743     ret = regmap_read(bq->regmap, BQ256XX_PRECHG_AND_TERM_CURR_LIM,
0744                         &prechg_and_term_curr_lim);
0745     if (ret)
0746         return ret;
0747 
0748     iterm_reg_code = prechg_and_term_curr_lim & BQ256XX_ITERM_MASK;
0749 
0750     return (iterm_reg_code * BQ256XX_ITERM_STEP_uA) +
0751                         BQ256XX_ITERM_OFFSET_uA;
0752 }
0753 
0754 static int bq256xx_set_term_curr(struct bq256xx_device *bq, int iterm)
0755 {
0756     unsigned int iterm_reg_code;
0757 
0758     iterm = clamp(iterm, BQ256XX_ITERM_MIN_uA, BQ256XX_ITERM_MAX_uA);
0759 
0760     iterm_reg_code = (iterm - BQ256XX_ITERM_OFFSET_uA) /
0761                             BQ256XX_ITERM_STEP_uA;
0762 
0763     return regmap_update_bits(bq->regmap, BQ256XX_PRECHG_AND_TERM_CURR_LIM,
0764                 BQ256XX_ITERM_MASK, iterm_reg_code);
0765 }
0766 
0767 static int bq25618_619_get_term_curr(struct bq256xx_device *bq)
0768 {
0769     unsigned int prechg_and_term_curr_lim;
0770     unsigned int iterm_reg_code;
0771     int ret;
0772 
0773     ret = regmap_read(bq->regmap, BQ256XX_PRECHG_AND_TERM_CURR_LIM,
0774                         &prechg_and_term_curr_lim);
0775     if (ret)
0776         return ret;
0777 
0778     iterm_reg_code = prechg_and_term_curr_lim & BQ256XX_ITERM_MASK;
0779 
0780     return (iterm_reg_code * BQ25618_ITERM_STEP_uA) +
0781                         BQ25618_ITERM_OFFSET_uA;
0782 }
0783 
0784 static int bq25618_619_set_term_curr(struct bq256xx_device *bq, int iterm)
0785 {
0786     unsigned int iterm_reg_code;
0787 
0788     iterm = clamp(iterm, BQ25618_ITERM_MIN_uA, BQ25618_ITERM_MAX_uA);
0789 
0790     iterm_reg_code = (iterm - BQ25618_ITERM_OFFSET_uA) /
0791                             BQ25618_ITERM_STEP_uA;
0792 
0793     return regmap_update_bits(bq->regmap, BQ256XX_PRECHG_AND_TERM_CURR_LIM,
0794                 BQ256XX_ITERM_MASK, iterm_reg_code);
0795 }
0796 
0797 static int bq256xx_get_input_volt_lim(struct bq256xx_device *bq)
0798 {
0799     unsigned int charger_control_2;
0800     unsigned int vindpm_reg_code;
0801     int ret;
0802 
0803     ret = regmap_read(bq->regmap, BQ256XX_CHARGER_CONTROL_2,
0804                         &charger_control_2);
0805     if (ret)
0806         return ret;
0807 
0808     vindpm_reg_code = charger_control_2 & BQ256XX_VINDPM_MASK;
0809 
0810     return (vindpm_reg_code * BQ256XX_VINDPM_STEP_uV) +
0811                         BQ256XX_VINDPM_OFFSET_uV;
0812 }
0813 
0814 static int bq256xx_set_input_volt_lim(struct bq256xx_device *bq, int vindpm)
0815 {
0816     unsigned int vindpm_reg_code;
0817 
0818     vindpm = clamp(vindpm, BQ256XX_VINDPM_MIN_uV, BQ256XX_VINDPM_MAX_uV);
0819 
0820     vindpm_reg_code = (vindpm - BQ256XX_VINDPM_OFFSET_uV) /
0821                         BQ256XX_VINDPM_STEP_uV;
0822 
0823     return regmap_update_bits(bq->regmap, BQ256XX_CHARGER_CONTROL_2,
0824                     BQ256XX_VINDPM_MASK, vindpm_reg_code);
0825 }
0826 
0827 static int bq256xx_get_input_curr_lim(struct bq256xx_device *bq)
0828 {
0829     unsigned int input_current_limit;
0830     unsigned int iindpm_reg_code;
0831     int ret;
0832 
0833     ret = regmap_read(bq->regmap, BQ256XX_INPUT_CURRENT_LIMIT,
0834                         &input_current_limit);
0835     if (ret)
0836         return ret;
0837 
0838     iindpm_reg_code = input_current_limit & BQ256XX_IINDPM_MASK;
0839 
0840     return (iindpm_reg_code * BQ256XX_IINDPM_STEP_uA) +
0841                         BQ256XX_IINDPM_OFFSET_uA;
0842 }
0843 
0844 static int bq256xx_set_input_curr_lim(struct bq256xx_device *bq, int iindpm)
0845 {
0846     unsigned int iindpm_reg_code;
0847 
0848     iindpm = clamp(iindpm, BQ256XX_IINDPM_MIN_uA, BQ256XX_IINDPM_MAX_uA);
0849 
0850     iindpm_reg_code = (iindpm - BQ256XX_IINDPM_OFFSET_uA) /
0851                             BQ256XX_IINDPM_STEP_uA;
0852 
0853     return regmap_update_bits(bq->regmap, BQ256XX_INPUT_CURRENT_LIMIT,
0854                     BQ256XX_IINDPM_MASK, iindpm_reg_code);
0855 }
0856 
0857 static void bq256xx_charger_reset(void *data)
0858 {
0859     struct bq256xx_device *bq = data;
0860 
0861     regmap_update_bits(bq->regmap, BQ256XX_PART_INFORMATION,
0862                     BQ256XX_REG_RST, BQ256XX_REG_RST);
0863 
0864     if (!IS_ERR_OR_NULL(bq->usb2_phy))
0865         usb_unregister_notifier(bq->usb2_phy, &bq->usb_nb);
0866 
0867     if (!IS_ERR_OR_NULL(bq->usb3_phy))
0868         usb_unregister_notifier(bq->usb3_phy, &bq->usb_nb);
0869 }
0870 
0871 static int bq256xx_set_charger_property(struct power_supply *psy,
0872         enum power_supply_property prop,
0873         const union power_supply_propval *val)
0874 {
0875     struct bq256xx_device *bq = power_supply_get_drvdata(psy);
0876     int ret = -EINVAL;
0877 
0878     switch (prop) {
0879     case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
0880         ret = bq->chip_info->bq256xx_set_iindpm(bq, val->intval);
0881         if (ret)
0882             return ret;
0883         break;
0884 
0885     case POWER_SUPPLY_PROP_STATUS:
0886         break;
0887 
0888     case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
0889         ret = bq->chip_info->bq256xx_set_vbatreg(bq, val->intval);
0890         if (ret)
0891             return ret;
0892         break;
0893 
0894     case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
0895         ret = bq->chip_info->bq256xx_set_ichg(bq, val->intval);
0896         if (ret)
0897             return ret;
0898         break;
0899 
0900     case POWER_SUPPLY_PROP_PRECHARGE_CURRENT:
0901         ret = bq->chip_info->bq256xx_set_iprechg(bq, val->intval);
0902         if (ret)
0903             return ret;
0904         break;
0905 
0906     case POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT:
0907         ret = bq->chip_info->bq256xx_set_iterm(bq, val->intval);
0908         if (ret)
0909             return ret;
0910         break;
0911 
0912     case POWER_SUPPLY_PROP_INPUT_VOLTAGE_LIMIT:
0913         ret = bq->chip_info->bq256xx_set_vindpm(bq, val->intval);
0914         if (ret)
0915             return ret;
0916         break;
0917 
0918     default:
0919         break;
0920     }
0921 
0922     return ret;
0923 }
0924 
0925 
0926 static int bq256xx_get_battery_property(struct power_supply *psy,
0927                 enum power_supply_property psp,
0928                 union power_supply_propval *val)
0929 {
0930     struct bq256xx_device *bq = power_supply_get_drvdata(psy);
0931 
0932     switch (psp) {
0933     case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX:
0934         val->intval = bq->init_data.ichg_max;
0935         break;
0936 
0937     case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX:
0938         val->intval = bq->init_data.vbatreg_max;
0939         break;
0940 
0941     default:
0942         return -EINVAL;
0943     }
0944 
0945     return 0;
0946 }
0947 
0948 static int bq256xx_get_charger_property(struct power_supply *psy,
0949                 enum power_supply_property psp,
0950                 union power_supply_propval *val)
0951 {
0952     struct bq256xx_device *bq = power_supply_get_drvdata(psy);
0953     struct bq256xx_state state;
0954     int ret = 0;
0955 
0956     mutex_lock(&bq->lock);
0957     ret = bq256xx_get_state(bq, &state);
0958     mutex_unlock(&bq->lock);
0959     if (ret)
0960         return ret;
0961 
0962     switch (psp) {
0963     case POWER_SUPPLY_PROP_STATUS:
0964         if (state.vbus_stat == BQ256XX_VBUS_STAT_NO_INPUT ||
0965             state.vbus_stat == BQ256XX_VBUS_STAT_USB_OTG)
0966             val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
0967         else if (state.chrg_stat == BQ256XX_CHRG_STAT_NOT_CHRGING)
0968             val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING;
0969         else if (state.chrg_stat == BQ256XX_CHRG_STAT_CHRG_TERM)
0970             val->intval = POWER_SUPPLY_STATUS_FULL;
0971         else
0972             val->intval = POWER_SUPPLY_STATUS_CHARGING;
0973         break;
0974 
0975     case POWER_SUPPLY_PROP_HEALTH:
0976         val->intval = POWER_SUPPLY_HEALTH_UNKNOWN;
0977         if (state.wdt_fault) {
0978             val->intval =
0979                 POWER_SUPPLY_HEALTH_WATCHDOG_TIMER_EXPIRE;
0980         } else if (state.bat_fault) {
0981             val->intval = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
0982         } else {
0983             switch (state.chrg_stat) {
0984             case BQ256XX_CHRG_FAULT_INPUT:
0985                 val->intval =
0986                     POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
0987                 break;
0988             case BQ256XX_CHRG_FAULT_THERM:
0989                 val->intval = POWER_SUPPLY_HEALTH_OVERHEAT;
0990                 break;
0991             case BQ256XX_CHRG_FAULT_CST_EXPIRE:
0992                 val->intval =
0993                 POWER_SUPPLY_HEALTH_SAFETY_TIMER_EXPIRE;
0994                 break;
0995             default:
0996                 break;
0997             }
0998 
0999             switch (state.ntc_fault) {
1000             case BQ256XX_NTC_FAULT_WARM:
1001                 val->intval = POWER_SUPPLY_HEALTH_WARM;
1002                 break;
1003             case BQ256XX_NTC_FAULT_COOL:
1004                 val->intval = POWER_SUPPLY_HEALTH_COOL;
1005                 break;
1006             case BQ256XX_NTC_FAULT_COLD:
1007                 val->intval = POWER_SUPPLY_HEALTH_COLD;
1008                 break;
1009             case BQ256XX_NTC_FAULT_HOT:
1010                 val->intval = POWER_SUPPLY_HEALTH_HOT;
1011                 break;
1012             default:
1013                 val->intval = POWER_SUPPLY_HEALTH_GOOD;
1014                 break;
1015             }
1016         }
1017         break;
1018 
1019     case POWER_SUPPLY_PROP_USB_TYPE:
1020         if (bq->chip_info->has_usb_detect) {
1021             switch (state.vbus_stat) {
1022             case BQ256XX_VBUS_STAT_USB_SDP:
1023                 val->intval = POWER_SUPPLY_USB_TYPE_SDP;
1024                 break;
1025             case BQ256XX_VBUS_STAT_USB_CDP:
1026                 val->intval = POWER_SUPPLY_USB_TYPE_CDP;
1027                 break;
1028             case BQ256XX_VBUS_STAT_USB_DCP:
1029                 val->intval = POWER_SUPPLY_USB_TYPE_DCP;
1030                 break;
1031             case BQ256XX_VBUS_STAT_USB_OTG:
1032                 val->intval = POWER_SUPPLY_USB_TYPE_ACA;
1033                 break;
1034             default:
1035                 val->intval = POWER_SUPPLY_USB_TYPE_UNKNOWN;
1036                 break;
1037             }
1038         } else {
1039             switch (state.vbus_stat) {
1040             case BQ256XX_VBUS_STAT_USB_SDP:
1041                 val->intval = POWER_SUPPLY_USB_TYPE_SDP;
1042                 break;
1043             case BQ256XX_VBUS_STAT_USB_OTG:
1044                 val->intval = POWER_SUPPLY_USB_TYPE_ACA;
1045                 break;
1046             default:
1047                 val->intval = POWER_SUPPLY_USB_TYPE_UNKNOWN;
1048                 break;
1049             }
1050         }
1051         break;
1052 
1053     case POWER_SUPPLY_PROP_CHARGE_TYPE:
1054         switch (state.chrg_stat) {
1055         case BQ256XX_CHRG_STAT_NOT_CHRGING:
1056             val->intval = POWER_SUPPLY_CHARGE_TYPE_NONE;
1057             break;
1058         case BQ256XX_CHRG_STAT_PRECHRGING:
1059             val->intval = POWER_SUPPLY_CHARGE_TYPE_TRICKLE;
1060             break;
1061         case BQ256XX_CHRG_STAT_FAST_CHRGING:
1062             val->intval = POWER_SUPPLY_CHARGE_TYPE_FAST;
1063             break;
1064         case BQ256XX_CHRG_STAT_CHRG_TERM:
1065             val->intval = POWER_SUPPLY_CHARGE_TYPE_TRICKLE;
1066             break;
1067         default:
1068             val->intval = POWER_SUPPLY_CHARGE_TYPE_UNKNOWN;
1069         }
1070         break;
1071 
1072     case POWER_SUPPLY_PROP_MANUFACTURER:
1073         val->strval = BQ256XX_MANUFACTURER;
1074         break;
1075 
1076     case POWER_SUPPLY_PROP_MODEL_NAME:
1077         val->strval = bq->model_name;
1078         break;
1079 
1080     case POWER_SUPPLY_PROP_ONLINE:
1081         val->intval = state.online;
1082         break;
1083 
1084     case POWER_SUPPLY_PROP_INPUT_VOLTAGE_LIMIT:
1085         ret = bq->chip_info->bq256xx_get_vindpm(bq);
1086         if (ret < 0)
1087             return ret;
1088         val->intval = ret;
1089         break;
1090 
1091     case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
1092         ret = bq->chip_info->bq256xx_get_iindpm(bq);
1093         if (ret < 0)
1094             return ret;
1095         val->intval = ret;
1096         break;
1097 
1098     case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
1099         ret = bq->chip_info->bq256xx_get_vbatreg(bq);
1100         if (ret < 0)
1101             return ret;
1102         val->intval = ret;
1103         break;
1104 
1105     case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
1106         ret = bq->chip_info->bq256xx_get_ichg(bq);
1107         if (ret < 0)
1108             return ret;
1109         val->intval = ret;
1110         break;
1111 
1112     case POWER_SUPPLY_PROP_PRECHARGE_CURRENT:
1113         ret = bq->chip_info->bq256xx_get_iprechg(bq);
1114         if (ret < 0)
1115             return ret;
1116         val->intval = ret;
1117         break;
1118 
1119     case POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT:
1120         ret = bq->chip_info->bq256xx_get_iterm(bq);
1121         if (ret < 0)
1122             return ret;
1123         val->intval = ret;
1124         break;
1125 
1126     default:
1127         return -EINVAL;
1128     }
1129 
1130     return ret;
1131 }
1132 
1133 static bool bq256xx_state_changed(struct bq256xx_device *bq,
1134                   struct bq256xx_state *new_state)
1135 {
1136     struct bq256xx_state old_state;
1137 
1138     mutex_lock(&bq->lock);
1139     old_state = bq->state;
1140     mutex_unlock(&bq->lock);
1141 
1142     return memcmp(&old_state, new_state, sizeof(struct bq256xx_state)) != 0;
1143 }
1144 
1145 static irqreturn_t bq256xx_irq_handler_thread(int irq, void *private)
1146 {
1147     struct bq256xx_device *bq = private;
1148     struct bq256xx_state state;
1149     int ret;
1150 
1151     ret = bq256xx_get_state(bq, &state);
1152     if (ret < 0)
1153         goto irq_out;
1154 
1155     if (!bq256xx_state_changed(bq, &state))
1156         goto irq_out;
1157 
1158     mutex_lock(&bq->lock);
1159     bq->state = state;
1160     mutex_unlock(&bq->lock);
1161 
1162     power_supply_changed(bq->charger);
1163 
1164 irq_out:
1165     return IRQ_HANDLED;
1166 }
1167 
1168 static enum power_supply_property bq256xx_power_supply_props[] = {
1169     POWER_SUPPLY_PROP_MANUFACTURER,
1170     POWER_SUPPLY_PROP_MODEL_NAME,
1171     POWER_SUPPLY_PROP_STATUS,
1172     POWER_SUPPLY_PROP_ONLINE,
1173     POWER_SUPPLY_PROP_HEALTH,
1174     POWER_SUPPLY_PROP_INPUT_VOLTAGE_LIMIT,
1175     POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT,
1176     POWER_SUPPLY_PROP_CHARGE_TYPE,
1177     POWER_SUPPLY_PROP_USB_TYPE,
1178     POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT,
1179     POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE,
1180     POWER_SUPPLY_PROP_PRECHARGE_CURRENT,
1181     POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT,
1182 };
1183 
1184 static enum power_supply_property bq256xx_battery_props[] = {
1185     POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX,
1186     POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX,
1187 };
1188 
1189 static int bq256xx_property_is_writeable(struct power_supply *psy,
1190                      enum power_supply_property prop)
1191 {
1192     switch (prop) {
1193     case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
1194     case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
1195     case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
1196     case POWER_SUPPLY_PROP_PRECHARGE_CURRENT:
1197     case POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT:
1198     case POWER_SUPPLY_PROP_STATUS:
1199     case POWER_SUPPLY_PROP_INPUT_VOLTAGE_LIMIT:
1200         return true;
1201     default:
1202         return false;
1203     }
1204 }
1205 
1206 static const struct power_supply_desc bq256xx_power_supply_desc = {
1207     .name = "bq256xx-charger",
1208     .type = POWER_SUPPLY_TYPE_USB,
1209     .usb_types = bq256xx_usb_type,
1210     .num_usb_types = ARRAY_SIZE(bq256xx_usb_type),
1211     .properties = bq256xx_power_supply_props,
1212     .num_properties = ARRAY_SIZE(bq256xx_power_supply_props),
1213     .get_property = bq256xx_get_charger_property,
1214     .set_property = bq256xx_set_charger_property,
1215     .property_is_writeable = bq256xx_property_is_writeable,
1216 };
1217 
1218 static struct power_supply_desc bq256xx_battery_desc = {
1219     .name           = "bq256xx-battery",
1220     .type           = POWER_SUPPLY_TYPE_BATTERY,
1221     .get_property       = bq256xx_get_battery_property,
1222     .properties     = bq256xx_battery_props,
1223     .num_properties     = ARRAY_SIZE(bq256xx_battery_props),
1224     .property_is_writeable  = bq256xx_property_is_writeable,
1225 };
1226 
1227 
1228 static bool bq256xx_is_volatile_reg(struct device *dev, unsigned int reg)
1229 {
1230     switch (reg) {
1231     case BQ256XX_INPUT_CURRENT_LIMIT:
1232     case BQ256XX_CHARGER_STATUS_0...BQ256XX_CHARGER_STATUS_2:
1233         return true;
1234     default:
1235         return false;
1236     }
1237 }
1238 
1239 static const struct regmap_config bq25600_regmap_config = {
1240     .reg_bits = 8,
1241     .val_bits = 8,
1242 
1243     .max_register = BQ256XX_PART_INFORMATION,
1244     .reg_defaults   = bq2560x_reg_defs,
1245     .num_reg_defaults = ARRAY_SIZE(bq2560x_reg_defs),
1246     .cache_type = REGCACHE_FLAT,
1247     .volatile_reg = bq256xx_is_volatile_reg,
1248 };
1249 
1250 static const struct regmap_config bq25611d_regmap_config = {
1251     .reg_bits = 8,
1252     .val_bits = 8,
1253 
1254     .max_register = BQ256XX_CHARGER_CONTROL_4,
1255     .reg_defaults   = bq25611d_reg_defs,
1256     .num_reg_defaults = ARRAY_SIZE(bq25611d_reg_defs),
1257     .cache_type = REGCACHE_FLAT,
1258     .volatile_reg = bq256xx_is_volatile_reg,
1259 };
1260 
1261 static const struct regmap_config bq25618_619_regmap_config = {
1262     .reg_bits = 8,
1263     .val_bits = 8,
1264 
1265     .max_register = BQ256XX_CHARGER_CONTROL_4,
1266     .reg_defaults   = bq25618_619_reg_defs,
1267     .num_reg_defaults = ARRAY_SIZE(bq25618_619_reg_defs),
1268     .cache_type = REGCACHE_FLAT,
1269     .volatile_reg = bq256xx_is_volatile_reg,
1270 };
1271 
1272 static const struct bq256xx_chip_info bq256xx_chip_info_tbl[] = {
1273     [BQ25600] = {
1274         .model_id = BQ25600,
1275         .bq256xx_regmap_config = &bq25600_regmap_config,
1276         .bq256xx_get_ichg = bq256xx_get_ichg_curr,
1277         .bq256xx_get_iindpm = bq256xx_get_input_curr_lim,
1278         .bq256xx_get_vbatreg = bq2560x_get_chrg_volt,
1279         .bq256xx_get_iterm = bq256xx_get_term_curr,
1280         .bq256xx_get_iprechg = bq256xx_get_prechrg_curr,
1281         .bq256xx_get_vindpm = bq256xx_get_input_volt_lim,
1282 
1283         .bq256xx_set_ichg = bq256xx_set_ichg_curr,
1284         .bq256xx_set_iindpm = bq256xx_set_input_curr_lim,
1285         .bq256xx_set_vbatreg = bq2560x_set_chrg_volt,
1286         .bq256xx_set_iterm = bq256xx_set_term_curr,
1287         .bq256xx_set_iprechg = bq256xx_set_prechrg_curr,
1288         .bq256xx_set_vindpm = bq256xx_set_input_volt_lim,
1289 
1290         .bq256xx_def_ichg = BQ2560X_ICHG_DEF_uA,
1291         .bq256xx_def_iindpm = BQ256XX_IINDPM_DEF_uA,
1292         .bq256xx_def_vbatreg = BQ2560X_VBATREG_DEF_uV,
1293         .bq256xx_def_iterm = BQ256XX_ITERM_DEF_uA,
1294         .bq256xx_def_iprechg = BQ256XX_IPRECHG_DEF_uA,
1295         .bq256xx_def_vindpm = BQ256XX_VINDPM_DEF_uV,
1296 
1297         .bq256xx_max_ichg = BQ256XX_ICHG_MAX_uA,
1298         .bq256xx_max_vbatreg = BQ2560X_VBATREG_MAX_uV,
1299 
1300         .has_usb_detect = false,
1301     },
1302 
1303     [BQ25600D] = {
1304         .model_id = BQ25600D,
1305         .bq256xx_regmap_config = &bq25600_regmap_config,
1306         .bq256xx_get_ichg = bq256xx_get_ichg_curr,
1307         .bq256xx_get_iindpm = bq256xx_get_input_curr_lim,
1308         .bq256xx_get_vbatreg = bq2560x_get_chrg_volt,
1309         .bq256xx_get_iterm = bq256xx_get_term_curr,
1310         .bq256xx_get_iprechg = bq256xx_get_prechrg_curr,
1311         .bq256xx_get_vindpm = bq256xx_get_input_volt_lim,
1312 
1313         .bq256xx_set_ichg = bq256xx_set_ichg_curr,
1314         .bq256xx_set_iindpm = bq256xx_set_input_curr_lim,
1315         .bq256xx_set_vbatreg = bq2560x_set_chrg_volt,
1316         .bq256xx_set_iterm = bq256xx_set_term_curr,
1317         .bq256xx_set_iprechg = bq256xx_set_prechrg_curr,
1318         .bq256xx_set_vindpm = bq256xx_set_input_volt_lim,
1319 
1320         .bq256xx_def_ichg = BQ2560X_ICHG_DEF_uA,
1321         .bq256xx_def_iindpm = BQ256XX_IINDPM_DEF_uA,
1322         .bq256xx_def_vbatreg = BQ2560X_VBATREG_DEF_uV,
1323         .bq256xx_def_iterm = BQ256XX_ITERM_DEF_uA,
1324         .bq256xx_def_iprechg = BQ256XX_IPRECHG_DEF_uA,
1325         .bq256xx_def_vindpm = BQ256XX_VINDPM_DEF_uV,
1326 
1327         .bq256xx_max_ichg = BQ256XX_ICHG_MAX_uA,
1328         .bq256xx_max_vbatreg = BQ2560X_VBATREG_MAX_uV,
1329 
1330         .has_usb_detect = true,
1331     },
1332 
1333     [BQ25601] = {
1334         .model_id = BQ25601,
1335         .bq256xx_regmap_config = &bq25600_regmap_config,
1336         .bq256xx_get_ichg = bq256xx_get_ichg_curr,
1337         .bq256xx_get_iindpm = bq256xx_get_input_curr_lim,
1338         .bq256xx_get_vbatreg = bq2560x_get_chrg_volt,
1339         .bq256xx_get_iterm = bq256xx_get_term_curr,
1340         .bq256xx_get_iprechg = bq256xx_get_prechrg_curr,
1341         .bq256xx_get_vindpm = bq256xx_get_input_volt_lim,
1342 
1343         .bq256xx_set_ichg = bq256xx_set_ichg_curr,
1344         .bq256xx_set_iindpm = bq256xx_set_input_curr_lim,
1345         .bq256xx_set_vbatreg = bq2560x_set_chrg_volt,
1346         .bq256xx_set_iterm = bq256xx_set_term_curr,
1347         .bq256xx_set_iprechg = bq256xx_set_prechrg_curr,
1348         .bq256xx_set_vindpm = bq256xx_set_input_volt_lim,
1349 
1350         .bq256xx_def_ichg = BQ2560X_ICHG_DEF_uA,
1351         .bq256xx_def_iindpm = BQ256XX_IINDPM_DEF_uA,
1352         .bq256xx_def_vbatreg = BQ2560X_VBATREG_DEF_uV,
1353         .bq256xx_def_iterm = BQ256XX_ITERM_DEF_uA,
1354         .bq256xx_def_iprechg = BQ256XX_IPRECHG_DEF_uA,
1355         .bq256xx_def_vindpm = BQ256XX_VINDPM_DEF_uV,
1356 
1357         .bq256xx_max_ichg = BQ256XX_ICHG_MAX_uA,
1358         .bq256xx_max_vbatreg = BQ2560X_VBATREG_MAX_uV,
1359 
1360         .has_usb_detect = false,
1361     },
1362 
1363     [BQ25601D] = {
1364         .model_id = BQ25601D,
1365         .bq256xx_regmap_config = &bq25600_regmap_config,
1366         .bq256xx_get_ichg = bq256xx_get_ichg_curr,
1367         .bq256xx_get_iindpm = bq256xx_get_input_curr_lim,
1368         .bq256xx_get_vbatreg = bq25601d_get_chrg_volt,
1369         .bq256xx_get_iterm = bq256xx_get_term_curr,
1370         .bq256xx_get_iprechg = bq256xx_get_prechrg_curr,
1371         .bq256xx_get_vindpm = bq256xx_get_input_volt_lim,
1372 
1373         .bq256xx_set_ichg = bq256xx_set_ichg_curr,
1374         .bq256xx_set_iindpm = bq256xx_set_input_curr_lim,
1375         .bq256xx_set_vbatreg = bq25601d_set_chrg_volt,
1376         .bq256xx_set_iterm = bq256xx_set_term_curr,
1377         .bq256xx_set_iprechg = bq256xx_set_prechrg_curr,
1378         .bq256xx_set_vindpm = bq256xx_set_input_volt_lim,
1379 
1380         .bq256xx_def_ichg = BQ2560X_ICHG_DEF_uA,
1381         .bq256xx_def_iindpm = BQ256XX_IINDPM_DEF_uA,
1382         .bq256xx_def_vbatreg = BQ2560X_VBATREG_DEF_uV,
1383         .bq256xx_def_iterm = BQ256XX_ITERM_DEF_uA,
1384         .bq256xx_def_iprechg = BQ256XX_IPRECHG_DEF_uA,
1385         .bq256xx_def_vindpm = BQ256XX_VINDPM_DEF_uV,
1386 
1387         .bq256xx_max_ichg = BQ256XX_ICHG_MAX_uA,
1388         .bq256xx_max_vbatreg = BQ2560X_VBATREG_MAX_uV,
1389 
1390         .has_usb_detect = true,
1391     },
1392 
1393     [BQ25611D] = {
1394         .model_id = BQ25611D,
1395         .bq256xx_regmap_config = &bq25611d_regmap_config,
1396         .bq256xx_get_ichg = bq256xx_get_ichg_curr,
1397         .bq256xx_get_iindpm = bq256xx_get_input_curr_lim,
1398         .bq256xx_get_vbatreg = bq25611d_get_chrg_volt,
1399         .bq256xx_get_iterm = bq256xx_get_term_curr,
1400         .bq256xx_get_iprechg = bq256xx_get_prechrg_curr,
1401         .bq256xx_get_vindpm = bq256xx_get_input_volt_lim,
1402 
1403         .bq256xx_set_ichg = bq256xx_set_ichg_curr,
1404         .bq256xx_set_iindpm = bq256xx_set_input_curr_lim,
1405         .bq256xx_set_vbatreg = bq25611d_set_chrg_volt,
1406         .bq256xx_set_iterm = bq256xx_set_term_curr,
1407         .bq256xx_set_iprechg = bq256xx_set_prechrg_curr,
1408         .bq256xx_set_vindpm = bq256xx_set_input_volt_lim,
1409 
1410         .bq256xx_def_ichg = BQ25611D_ICHG_DEF_uA,
1411         .bq256xx_def_iindpm = BQ256XX_IINDPM_DEF_uA,
1412         .bq256xx_def_vbatreg = BQ25611D_VBATREG_DEF_uV,
1413         .bq256xx_def_iterm = BQ256XX_ITERM_DEF_uA,
1414         .bq256xx_def_iprechg = BQ256XX_IPRECHG_DEF_uA,
1415         .bq256xx_def_vindpm = BQ256XX_VINDPM_DEF_uV,
1416 
1417         .bq256xx_max_ichg = BQ256XX_ICHG_MAX_uA,
1418         .bq256xx_max_vbatreg = BQ25611D_VBATREG_MAX_uV,
1419 
1420         .has_usb_detect = true,
1421     },
1422 
1423     [BQ25618] = {
1424         .model_id = BQ25618,
1425         .bq256xx_regmap_config = &bq25618_619_regmap_config,
1426         .bq256xx_get_ichg = bq25618_619_get_ichg_curr,
1427         .bq256xx_get_iindpm = bq256xx_get_input_curr_lim,
1428         .bq256xx_get_vbatreg = bq25618_619_get_chrg_volt,
1429         .bq256xx_get_iterm = bq25618_619_get_term_curr,
1430         .bq256xx_get_iprechg = bq25618_619_get_prechrg_curr,
1431         .bq256xx_get_vindpm = bq256xx_get_input_volt_lim,
1432 
1433         .bq256xx_set_ichg = bq25618_619_set_ichg_curr,
1434         .bq256xx_set_iindpm = bq256xx_set_input_curr_lim,
1435         .bq256xx_set_vbatreg = bq25618_619_set_chrg_volt,
1436         .bq256xx_set_iterm = bq25618_619_set_term_curr,
1437         .bq256xx_set_iprechg = bq25618_619_set_prechrg_curr,
1438         .bq256xx_set_vindpm = bq256xx_set_input_volt_lim,
1439 
1440         .bq256xx_def_ichg = BQ25618_ICHG_DEF_uA,
1441         .bq256xx_def_iindpm = BQ256XX_IINDPM_DEF_uA,
1442         .bq256xx_def_vbatreg = BQ25618_VBATREG_DEF_uV,
1443         .bq256xx_def_iterm = BQ25618_ITERM_DEF_uA,
1444         .bq256xx_def_iprechg = BQ25618_IPRECHG_DEF_uA,
1445         .bq256xx_def_vindpm = BQ256XX_VINDPM_DEF_uV,
1446 
1447         .bq256xx_max_ichg = BQ25618_ICHG_MAX_uA,
1448         .bq256xx_max_vbatreg = BQ25618_VBATREG_MAX_uV,
1449 
1450         .has_usb_detect = false,
1451     },
1452 
1453     [BQ25619] = {
1454         .model_id = BQ25619,
1455         .bq256xx_regmap_config = &bq25618_619_regmap_config,
1456         .bq256xx_get_ichg = bq25618_619_get_ichg_curr,
1457         .bq256xx_get_iindpm = bq256xx_get_input_curr_lim,
1458         .bq256xx_get_vbatreg = bq25618_619_get_chrg_volt,
1459         .bq256xx_get_iterm = bq25618_619_get_term_curr,
1460         .bq256xx_get_iprechg = bq25618_619_get_prechrg_curr,
1461         .bq256xx_get_vindpm = bq256xx_get_input_volt_lim,
1462 
1463         .bq256xx_set_ichg = bq25618_619_set_ichg_curr,
1464         .bq256xx_set_iindpm = bq256xx_set_input_curr_lim,
1465         .bq256xx_set_vbatreg = bq25618_619_set_chrg_volt,
1466         .bq256xx_set_iterm = bq25618_619_set_term_curr,
1467         .bq256xx_set_iprechg = bq25618_619_set_prechrg_curr,
1468         .bq256xx_set_vindpm = bq256xx_set_input_volt_lim,
1469 
1470         .bq256xx_def_ichg = BQ25618_ICHG_DEF_uA,
1471         .bq256xx_def_iindpm = BQ256XX_IINDPM_DEF_uA,
1472         .bq256xx_def_vbatreg = BQ25618_VBATREG_DEF_uV,
1473         .bq256xx_def_iterm = BQ25618_ITERM_DEF_uA,
1474         .bq256xx_def_iprechg = BQ25618_IPRECHG_DEF_uA,
1475         .bq256xx_def_vindpm = BQ256XX_VINDPM_DEF_uV,
1476 
1477         .bq256xx_max_ichg = BQ25618_ICHG_MAX_uA,
1478         .bq256xx_max_vbatreg = BQ25618_VBATREG_MAX_uV,
1479 
1480         .has_usb_detect = false,
1481     },
1482 };
1483 
1484 static int bq256xx_power_supply_init(struct bq256xx_device *bq,
1485         struct power_supply_config *psy_cfg, struct device *dev)
1486 {
1487     bq->charger = devm_power_supply_register(bq->dev,
1488                          &bq256xx_power_supply_desc,
1489                          psy_cfg);
1490     if (IS_ERR(bq->charger)) {
1491         dev_err(dev, "power supply register charger failed\n");
1492         return PTR_ERR(bq->charger);
1493     }
1494 
1495     bq->battery = devm_power_supply_register(bq->dev,
1496                               &bq256xx_battery_desc,
1497                               psy_cfg);
1498     if (IS_ERR(bq->battery)) {
1499         dev_err(dev, "power supply register battery failed\n");
1500         return PTR_ERR(bq->battery);
1501     }
1502     return 0;
1503 }
1504 
1505 static int bq256xx_hw_init(struct bq256xx_device *bq)
1506 {
1507     struct power_supply_battery_info *bat_info;
1508     int wd_reg_val = BQ256XX_WATCHDOG_DIS;
1509     int ret = 0;
1510     int i;
1511 
1512     for (i = 0; i < BQ256XX_NUM_WD_VAL; i++) {
1513         if (bq->watchdog_timer == bq256xx_watchdog_time[i]) {
1514             wd_reg_val = i;
1515             break;
1516         }
1517         if (bq->watchdog_timer > bq256xx_watchdog_time[i] &&
1518             bq->watchdog_timer < bq256xx_watchdog_time[i + 1])
1519             wd_reg_val = i;
1520     }
1521     ret = regmap_update_bits(bq->regmap, BQ256XX_CHARGER_CONTROL_1,
1522                  BQ256XX_WATCHDOG_MASK, wd_reg_val <<
1523                         BQ256XX_WDT_BIT_SHIFT);
1524 
1525     ret = power_supply_get_battery_info(bq->charger, &bat_info);
1526     if (ret == -ENOMEM)
1527         return ret;
1528 
1529     if (ret) {
1530         dev_warn(bq->dev, "battery info missing, default values will be applied\n");
1531 
1532         bat_info->constant_charge_current_max_ua =
1533                 bq->chip_info->bq256xx_def_ichg;
1534 
1535         bat_info->constant_charge_voltage_max_uv =
1536                 bq->chip_info->bq256xx_def_vbatreg;
1537 
1538         bat_info->precharge_current_ua =
1539                 bq->chip_info->bq256xx_def_iprechg;
1540 
1541         bat_info->charge_term_current_ua =
1542                 bq->chip_info->bq256xx_def_iterm;
1543 
1544         bq->init_data.ichg_max =
1545                 bq->chip_info->bq256xx_max_ichg;
1546 
1547         bq->init_data.vbatreg_max =
1548                 bq->chip_info->bq256xx_max_vbatreg;
1549     } else {
1550         bq->init_data.ichg_max =
1551             bat_info->constant_charge_current_max_ua;
1552 
1553         bq->init_data.vbatreg_max =
1554             bat_info->constant_charge_voltage_max_uv;
1555     }
1556 
1557     ret = bq->chip_info->bq256xx_set_vindpm(bq, bq->init_data.vindpm);
1558     if (ret)
1559         return ret;
1560 
1561     ret = bq->chip_info->bq256xx_set_iindpm(bq, bq->init_data.iindpm);
1562     if (ret)
1563         return ret;
1564 
1565     ret = bq->chip_info->bq256xx_set_ichg(bq,
1566                 bat_info->constant_charge_current_max_ua);
1567     if (ret)
1568         return ret;
1569 
1570     ret = bq->chip_info->bq256xx_set_iprechg(bq,
1571                 bat_info->precharge_current_ua);
1572     if (ret)
1573         return ret;
1574 
1575     ret = bq->chip_info->bq256xx_set_vbatreg(bq,
1576                 bat_info->constant_charge_voltage_max_uv);
1577     if (ret)
1578         return ret;
1579 
1580     ret = bq->chip_info->bq256xx_set_iterm(bq,
1581                 bat_info->charge_term_current_ua);
1582     if (ret)
1583         return ret;
1584 
1585     power_supply_put_battery_info(bq->charger, bat_info);
1586 
1587     return 0;
1588 }
1589 
1590 static int bq256xx_parse_dt(struct bq256xx_device *bq,
1591         struct power_supply_config *psy_cfg, struct device *dev)
1592 {
1593     int ret = 0;
1594 
1595     psy_cfg->drv_data = bq;
1596     psy_cfg->of_node = dev->of_node;
1597 
1598     ret = device_property_read_u32(bq->dev, "ti,watchdog-timeout-ms",
1599                        &bq->watchdog_timer);
1600     if (ret)
1601         bq->watchdog_timer = BQ256XX_WATCHDOG_DIS;
1602 
1603     if (bq->watchdog_timer > BQ256XX_WATCHDOG_MAX ||
1604         bq->watchdog_timer < BQ256XX_WATCHDOG_DIS)
1605         return -EINVAL;
1606 
1607     ret = device_property_read_u32(bq->dev,
1608                        "input-voltage-limit-microvolt",
1609                        &bq->init_data.vindpm);
1610     if (ret)
1611         bq->init_data.vindpm = bq->chip_info->bq256xx_def_vindpm;
1612 
1613     ret = device_property_read_u32(bq->dev,
1614                        "input-current-limit-microamp",
1615                        &bq->init_data.iindpm);
1616     if (ret)
1617         bq->init_data.iindpm = bq->chip_info->bq256xx_def_iindpm;
1618 
1619     return 0;
1620 }
1621 
1622 static int bq256xx_probe(struct i2c_client *client,
1623              const struct i2c_device_id *id)
1624 {
1625     struct device *dev = &client->dev;
1626     struct bq256xx_device *bq;
1627     struct power_supply_config psy_cfg = { };
1628 
1629     int ret;
1630 
1631     bq = devm_kzalloc(dev, sizeof(*bq), GFP_KERNEL);
1632     if (!bq)
1633         return -ENOMEM;
1634 
1635     bq->client = client;
1636     bq->dev = dev;
1637     bq->chip_info = &bq256xx_chip_info_tbl[id->driver_data];
1638 
1639     mutex_init(&bq->lock);
1640 
1641     strncpy(bq->model_name, id->name, I2C_NAME_SIZE);
1642 
1643     bq->regmap = devm_regmap_init_i2c(client,
1644                     bq->chip_info->bq256xx_regmap_config);
1645 
1646     if (IS_ERR(bq->regmap)) {
1647         dev_err(dev, "Failed to allocate register map\n");
1648         return PTR_ERR(bq->regmap);
1649     }
1650 
1651     i2c_set_clientdata(client, bq);
1652 
1653     ret = bq256xx_parse_dt(bq, &psy_cfg, dev);
1654     if (ret) {
1655         dev_err(dev, "Failed to read device tree properties%d\n", ret);
1656         return ret;
1657     }
1658 
1659     ret = devm_add_action_or_reset(dev, bq256xx_charger_reset, bq);
1660     if (ret)
1661         return ret;
1662 
1663     /* OTG reporting */
1664     bq->usb2_phy = devm_usb_get_phy(dev, USB_PHY_TYPE_USB2);
1665     if (!IS_ERR_OR_NULL(bq->usb2_phy)) {
1666         INIT_WORK(&bq->usb_work, bq256xx_usb_work);
1667         bq->usb_nb.notifier_call = bq256xx_usb_notifier;
1668         usb_register_notifier(bq->usb2_phy, &bq->usb_nb);
1669     }
1670 
1671     bq->usb3_phy = devm_usb_get_phy(dev, USB_PHY_TYPE_USB3);
1672     if (!IS_ERR_OR_NULL(bq->usb3_phy)) {
1673         INIT_WORK(&bq->usb_work, bq256xx_usb_work);
1674         bq->usb_nb.notifier_call = bq256xx_usb_notifier;
1675         usb_register_notifier(bq->usb3_phy, &bq->usb_nb);
1676     }
1677 
1678     if (client->irq) {
1679         ret = devm_request_threaded_irq(dev, client->irq, NULL,
1680                         bq256xx_irq_handler_thread,
1681                         IRQF_TRIGGER_FALLING |
1682                         IRQF_ONESHOT,
1683                         dev_name(&client->dev), bq);
1684         if (ret < 0) {
1685             dev_err(dev, "get irq fail: %d\n", ret);
1686             return ret;
1687         }
1688     }
1689 
1690     ret = bq256xx_power_supply_init(bq, &psy_cfg, dev);
1691     if (ret) {
1692         dev_err(dev, "Failed to register power supply\n");
1693         return ret;
1694     }
1695 
1696     ret = bq256xx_hw_init(bq);
1697     if (ret) {
1698         dev_err(dev, "Cannot initialize the chip.\n");
1699         return ret;
1700     }
1701 
1702     return ret;
1703 }
1704 
1705 static const struct i2c_device_id bq256xx_i2c_ids[] = {
1706     { "bq25600", BQ25600 },
1707     { "bq25600d", BQ25600D },
1708     { "bq25601", BQ25601 },
1709     { "bq25601d", BQ25601D },
1710     { "bq25611d", BQ25611D },
1711     { "bq25618", BQ25618 },
1712     { "bq25619", BQ25619 },
1713     {},
1714 };
1715 MODULE_DEVICE_TABLE(i2c, bq256xx_i2c_ids);
1716 
1717 static const struct of_device_id bq256xx_of_match[] = {
1718     { .compatible = "ti,bq25600", .data = (void *)BQ25600 },
1719     { .compatible = "ti,bq25600d", .data = (void *)BQ25600D },
1720     { .compatible = "ti,bq25601", .data = (void *)BQ25601 },
1721     { .compatible = "ti,bq25601d", .data = (void *)BQ25601D },
1722     { .compatible = "ti,bq25611d", .data = (void *)BQ25611D },
1723     { .compatible = "ti,bq25618", .data = (void *)BQ25618 },
1724     { .compatible = "ti,bq25619", .data = (void *)BQ25619 },
1725     { },
1726 };
1727 MODULE_DEVICE_TABLE(of, bq256xx_of_match);
1728 
1729 static const struct acpi_device_id bq256xx_acpi_match[] = {
1730     { "bq25600", BQ25600 },
1731     { "bq25600d", BQ25600D },
1732     { "bq25601", BQ25601 },
1733     { "bq25601d", BQ25601D },
1734     { "bq25611d", BQ25611D },
1735     { "bq25618", BQ25618 },
1736     { "bq25619", BQ25619 },
1737     {},
1738 };
1739 MODULE_DEVICE_TABLE(acpi, bq256xx_acpi_match);
1740 
1741 static struct i2c_driver bq256xx_driver = {
1742     .driver = {
1743         .name = "bq256xx-charger",
1744         .of_match_table = bq256xx_of_match,
1745         .acpi_match_table = bq256xx_acpi_match,
1746     },
1747     .probe = bq256xx_probe,
1748     .id_table = bq256xx_i2c_ids,
1749 };
1750 module_i2c_driver(bq256xx_driver);
1751 
1752 MODULE_AUTHOR("Ricardo Rivera-Matos <r-rivera-matos@ti.com>");
1753 MODULE_DESCRIPTION("bq256xx charger driver");
1754 MODULE_LICENSE("GPL v2");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!