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"); 1750