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