1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Driver for TI BQ25630 charger. 4 * 5 * Copyright (C) 2026 Axis Communications AB 6 */ 7 8 #include <linux/delay.h> 9 #include <linux/device.h> 10 #include <linux/i2c.h> 11 #include <linux/module.h> 12 #include <linux/regmap.h> 13 14 #include <linux/power_supply.h> 15 16 #define BQ25630_DRV_NAME "bq25630-charger" 17 18 /* Registers. */ 19 #define BQ25630_REG_CHARGE_CURRENT_LIMIT 0x02 20 #define BQ25630_REG_CHARGE_VOLTAGE_LIMIT 0x04 21 #define BQ25630_REG_INPUT_CURRENT_LIMIT 0x06 22 #define BQ25630_REG_INPUT_VOLTAGE_LIMIT 0x08 23 #define BQ25630_REG_IOTG_REGULATION 0x0a 24 #define BQ25630_REG_VOTG_REGULATION 0x0c 25 #define BQ25630_REG_MINIMAL_SYSTEM_VOLTAGE 0x0e 26 #define BQ25630_REG_PRECHARGE_CONTROL 0x10 27 #define BQ25630_REG_TERMINATION_CONTROL 0x12 28 #define BQ25630_REG_CHARGE_TIMER_CONTROL 0x14 29 #define BQ25630_REG_CHARGER_CONTROL_0 0x15 30 #define BQ25630_REG_CHARGER_CONTROL_1 0x16 31 #define BQ25630_REG_CHARGER_CONTROL_2 0x17 32 #define BQ25630_REG_CHARGER_CONTROL_3 0x18 33 #define BQ25630_REG_CHARGER_CONTROL_4 0x19 34 #define BQ25630_REG_CHARGER_CONTROL_5 0x1a 35 #define BQ25630_REG_NTC_CONTROL_0 0x1b 36 #define BQ25630_REG_NTC_CONTROL_1 0x1c 37 #define BQ25630_REG_NTC_CONTROL_2 0x1d 38 #define BQ25630_REG_NTC_CONTROL_3 0x1e 39 #define BQ25630_REG_CHARGER_STATUS_0 0x1f 40 #define BQ25630_REG_CHARGER_STATUS_1 0x20 41 #define BQ25630_REG_CHARGER_STATUS_2 0x21 42 #define BQ25630_REG_FAULT_STATUS 0x22 43 #define BQ25630_REG_CHARGER_FLAG_0 0x23 44 #define BQ25630_REG_CHARGER_FLAG_1 0x24 45 #define BQ25630_REG_FAULT_FLAG 0x25 46 #define BQ25630_REG_CHARGER_MASK_0 0x26 47 #define BQ25630_REG_CHARGER_MASK_1 0x27 48 #define BQ25630_REG_FAULT_MASK 0x28 49 #define BQ25630_REG_ICO_CURRENT_LIMIT 0x29 50 #define BQ25630_REG_ADC_CONTROL 0x2b 51 #define BQ25630_REG_ADC_CHANNEL_DISABLE_1 0x2c 52 #define BQ25630_REG_IBUS_ADC 0x32 53 #define BQ25630_REG_IBAT_ADC 0x34 54 #define BQ25630_REG_VBUS_ADC 0x36 55 #define BQ25630_REG_VPMID_ADC 0x38 56 #define BQ25630_REG_VBAT_ADC 0x3a 57 #define BQ25630_REG_VSYS_ADC 0x3c 58 #define BQ25630_REG_TS_ADC 0x3e 59 #define BQ25630_REG_TDIE_ADC 0x40 60 #define BQ25630_REG_USB_C_CONTROL_0 0x44 61 #define BQ25630_REG_USB_C_CONTROL_1 0x45 62 #define BQ25630_REG_LIQUID_CONTROL_0 0x46 63 #define BQ25630_REG_LIQUID_CONTROL_1 0x47 64 #define BQ25630_REG_USB_C_INFORMATION_0 0x48 65 #define BQ25630_REG_USB_C_INFORMATION_1 0x49 66 #define BQ25630_REG_USB_DAC_CONTROL_0 0x4a 67 #define BQ25630_REG_USB_DAC_CONTROL_1 0x4b 68 #define BQ25630_REG_PART_INFORMATION 0x4d 69 70 #define BQ25630_NR_STAT_REGS \ 71 (BQ25630_REG_FAULT_FLAG - BQ25630_REG_CHARGER_STATUS_0 + 1) 72 73 /* Charge current limits. */ 74 #define BQ25630_ICHG_MIN_REGVAL 0x04 75 #define BQ25630_ICHG_MIN 80000 76 #define BQ25630_ICHG_MAX 5040000 77 #define BQ25630_ICHG_STEP 20000 78 79 /* Charge voltage limits. */ 80 #define BQ25630_VREG_MIN_REGVAL 0x15e 81 #define BQ25630_VREG_MIN 3500000 82 #define BQ25630_VREG_MAX 4800000 83 #define BQ25630_VREG_STEP 10000 84 85 /* Input current limits. */ 86 #define BQ25630_IINDPM_MIN_REGVAL 0x0a 87 #define BQ25630_IINDPM_MIN 100000 88 #define BQ25630_IINDPM_MAX 3200000 89 #define BQ25630_IINDPM_STEP 10000 90 91 /* Input voltage limits. */ 92 #define BQ25630_VINDPM_MIN_REGVAL 0x5f 93 #define BQ25630_VINDPM_MIN 3800000 94 #define BQ25630_VINDPM_MAX 16800000 95 #define BQ25630_VINDPM_STEP 40000 96 97 /* Minimal system voltage limits. */ 98 #define BQ25630_VSYSMIN_MIN_REGVAL 0x20 99 #define BQ25630_VSYSMIN_MIN 2560000 100 #define BQ25630_VSYSMIN_MAX 4000000 101 #define BQ25630_VSYSMIN_STEP 80000 102 103 /* Pre-charge current limits. */ 104 #define BQ25630_IPRECHG_MIN_REGVAL 0x02 105 #define BQ25630_IPRECHG_MIN 40000 106 #define BQ25630_IPRECHG_MAX 1000000 107 #define BQ25630_IPRECHG_STEP 20000 108 109 /* Termination current limits. */ 110 #define BQ25630_ITERM_MIN_REGVAL 0x03 111 #define BQ25630_ITERM_MIN 30000 112 #define BQ25630_ITERM_MAX 1000000 113 #define BQ25630_ITERM_STEP 10000 114 115 /* Charge types. */ 116 #define BQ25630_CHG_STAT_NOT_CHARGING 0x00 117 #define BQ25630_CHG_STAT_TRICKLE_CHARGE 0x01 118 #define BQ25630_CHG_STAT_PRE_CHARGE 0x02 119 #define BQ25630_CHG_STAT_FAST_CHARGE 0x03 120 #define BQ25630_CHG_STAT_TAPER_CHARGE 0x04 121 #define BQ25630_CHG_STAT_TERMINATION 0x07 122 123 /* USB types (VBUS). */ 124 #define BQ25630_VBUS_STAT_NONE 0x00 125 #define BQ25630_VBUS_STAT_SDP 0x01 126 #define BQ25630_VBUS_STAT_CDP 0x02 127 #define BQ25630_VBUS_STAT_DCP 0x03 128 #define BQ25630_VBUS_STAT_HVDCP 0x06 129 #define BQ25630_VBUS_STAT_BOOST_OTG 0x07 130 #define BQ25630_VBUS_STAT_USB_C_DEFAULT 0x08 131 #define BQ25630_VBUS_STAT_USB_C_MEDIUM 0x09 132 #define BQ25630_VBUS_STAT_USB_C_HIGH 0x0a 133 134 /* Temperature status. */ 135 #define BQ25630_TS_STAT_NORMAL 0x00 136 #define BQ25630_TS_STAT_COLD 0x01 137 #define BQ25630_TS_STAT_HOT 0x02 138 #define BQ25630_TS_STAT_COOL 0x03 139 #define BQ25630_TS_STAT_WARM 0x04 140 #define BQ25630_TS_STAT_PRECOOL 0x05 141 #define BQ25630_TS_STAT_PREWARM 0x06 142 143 /* Register fields. */ 144 enum bq25630_regfield { 145 /* Charge current limit. */ 146 BQ25630_REGF_ICHG, 147 /* Charge voltage limit. */ 148 BQ25630_REGF_VREG, 149 /* Input current limit. */ 150 BQ25630_REGF_IINDPM, 151 /* Input voltage limit. */ 152 BQ25630_REGF_VINDPM, 153 /* Minimal system voltage. */ 154 BQ25630_REGF_VSYSMIN, 155 /* Pre-charge current limit. */ 156 BQ25630_REGF_IPRECHG, 157 /* Termination current threshold. */ 158 BQ25630_REGF_ITERM, 159 160 /* IBUS ADC reading. */ 161 BQ25630_REGF_IBUS_ADC, 162 /* VBUS ADC reading. */ 163 BQ25630_REGF_VBUS_ADC, 164 165 /* Watchdog timer. */ 166 BQ25630_REGF_WATCHDOG, 167 /* Enable charger. */ 168 BQ25630_REGF_EN_CHG, 169 /* Register reset. */ 170 BQ25630_REGF_REG_RST, 171 /* BATFET control. */ 172 BQ25630_REGF_BATFET_CTRL, 173 /* Power good indicator. */ 174 BQ25630_REGF_PG_STAT, 175 /* Charge status. */ 176 BQ25630_REGF_CHG_STAT, 177 /* VBUS status. */ 178 BQ25630_REGF_VBUS_STAT, 179 180 /* Temperature zone. */ 181 BQ25630_REGF_TS_STAT, 182 /* Temperature shutdwon. */ 183 BQ25630_REGF_TSHUT_STAT, 184 /* OTG fault. */ 185 BQ25630_REGF_OTG_FAULT_STAT, 186 /* System voltage fault. */ 187 BQ25630_REGF_VSYS_FAULT_STAT, 188 /* Battery fault. */ 189 BQ25630_REGF_BAT_FAULT_STAT, 190 /* VBUS fault. */ 191 BQ25630_REGF_VBUS_FAULT_STAT, 192 193 /* Sentinel value. */ 194 BQ25630_REGF_MAX 195 }; 196 197 static const struct reg_field bq25630_regfields[] = { 198 [BQ25630_REGF_ICHG] = 199 REG_FIELD(BQ25630_REG_CHARGE_CURRENT_LIMIT, 4, 11), 200 [BQ25630_REGF_VREG] = 201 REG_FIELD(BQ25630_REG_CHARGE_VOLTAGE_LIMIT, 3, 11), 202 [BQ25630_REGF_IINDPM] = 203 REG_FIELD(BQ25630_REG_INPUT_CURRENT_LIMIT, 3, 11), 204 [BQ25630_REGF_VINDPM] = 205 REG_FIELD(BQ25630_REG_INPUT_VOLTAGE_LIMIT, 5, 13), 206 207 [BQ25630_REGF_VSYSMIN] = 208 REG_FIELD(BQ25630_REG_MINIMAL_SYSTEM_VOLTAGE, 6, 11), 209 210 [BQ25630_REGF_IPRECHG] = 211 REG_FIELD(BQ25630_REG_PRECHARGE_CONTROL, 4, 9), 212 [BQ25630_REGF_ITERM] = 213 REG_FIELD(BQ25630_REG_TERMINATION_CONTROL, 3, 9), 214 215 [BQ25630_REGF_IBUS_ADC] = REG_FIELD(BQ25630_REG_IBUS_ADC, 1, 15), 216 [BQ25630_REGF_VBUS_ADC] = REG_FIELD(BQ25630_REG_VBUS_ADC, 2, 14), 217 218 [BQ25630_REGF_WATCHDOG] = 219 REG_FIELD(BQ25630_REG_CHARGER_CONTROL_1, 0, 1), 220 [BQ25630_REGF_EN_CHG] = 221 REG_FIELD(BQ25630_REG_CHARGER_CONTROL_1, 5, 5), 222 [BQ25630_REGF_REG_RST] = 223 REG_FIELD(BQ25630_REG_CHARGER_CONTROL_2, 7, 7), 224 [BQ25630_REGF_BATFET_CTRL] = 225 REG_FIELD(BQ25630_REG_CHARGER_CONTROL_3, 0, 1), 226 [BQ25630_REGF_PG_STAT] = 227 REG_FIELD(BQ25630_REG_CHARGER_STATUS_0, 7, 7), 228 [BQ25630_REGF_CHG_STAT] = 229 REG_FIELD(BQ25630_REG_CHARGER_STATUS_1, 3, 5), 230 [BQ25630_REGF_VBUS_STAT] = 231 REG_FIELD(BQ25630_REG_CHARGER_STATUS_2, 4, 7), 232 233 [BQ25630_REGF_TS_STAT] = 234 REG_FIELD(BQ25630_REG_FAULT_STATUS, 0, 2), 235 [BQ25630_REGF_TSHUT_STAT] = 236 REG_FIELD(BQ25630_REG_FAULT_STATUS, 3, 3), 237 [BQ25630_REGF_OTG_FAULT_STAT] = 238 REG_FIELD(BQ25630_REG_FAULT_STATUS, 4, 4), 239 [BQ25630_REGF_VSYS_FAULT_STAT] = 240 REG_FIELD(BQ25630_REG_FAULT_STATUS, 5, 5), 241 [BQ25630_REGF_BAT_FAULT_STAT] = 242 REG_FIELD(BQ25630_REG_FAULT_STATUS, 6, 6), 243 [BQ25630_REGF_VBUS_FAULT_STAT] = 244 REG_FIELD(BQ25630_REG_FAULT_STATUS, 7, 7), 245 }; 246 247 /* 8-bit value regmap. */ 248 static const struct regmap_range bq25630_read_reg_range8[] = { 249 regmap_reg_range(BQ25630_REG_CHARGE_TIMER_CONTROL, 250 BQ25630_REG_FAULT_MASK), 251 regmap_reg_range(BQ25630_REG_ADC_CONTROL, 252 BQ25630_REG_ADC_CHANNEL_DISABLE_1), 253 regmap_reg_range(BQ25630_REG_USB_C_CONTROL_0, 254 BQ25630_REG_PART_INFORMATION), 255 }; 256 257 static const struct regmap_range bq25630_write_reg_range8[] = { 258 regmap_reg_range(BQ25630_REG_CHARGE_TIMER_CONTROL, 259 BQ25630_REG_NTC_CONTROL_3), 260 regmap_reg_range(BQ25630_REG_CHARGER_MASK_0, 261 BQ25630_REG_FAULT_MASK), 262 regmap_reg_range(BQ25630_REG_ADC_CONTROL, 263 BQ25630_REG_ADC_CHANNEL_DISABLE_1), 264 regmap_reg_range(BQ25630_REG_USB_C_CONTROL_0, 265 BQ25630_REG_LIQUID_CONTROL_1), 266 regmap_reg_range(BQ25630_REG_USB_DAC_CONTROL_0, 267 BQ25630_REG_USB_DAC_CONTROL_1), 268 }; 269 270 static const struct regmap_access_table bq25630_read_reg_access_table8 = { 271 .yes_ranges = bq25630_read_reg_range8, 272 .n_yes_ranges = ARRAY_SIZE(bq25630_read_reg_range8), 273 }; 274 275 static const struct regmap_access_table bq25630_write_reg_access_table8 = { 276 .yes_ranges = bq25630_write_reg_range8, 277 .n_yes_ranges = ARRAY_SIZE(bq25630_write_reg_range8), 278 }; 279 280 static const struct regmap_config bq25630_regmap_config8 = { 281 .name = BQ25630_DRV_NAME "-8bit", 282 .reg_bits = 8, 283 .val_bits = 8, 284 .max_register = BQ25630_REG_PART_INFORMATION, 285 .rd_table = &bq25630_read_reg_access_table8, 286 .wr_table = &bq25630_write_reg_access_table8, 287 }; 288 289 /* 16-bit little-endian value regmap. */ 290 static const struct regmap_range bq25630_read_reg_range16le[] = { 291 regmap_reg_range(BQ25630_REG_CHARGE_CURRENT_LIMIT, 292 BQ25630_REG_TERMINATION_CONTROL), 293 regmap_reg_range(BQ25630_REG_ICO_CURRENT_LIMIT, 294 BQ25630_REG_ICO_CURRENT_LIMIT), 295 }; 296 297 static const struct regmap_range bq25630_write_reg_range16le[] = { 298 regmap_reg_range(BQ25630_REG_CHARGE_CURRENT_LIMIT, 299 BQ25630_REG_TERMINATION_CONTROL), 300 regmap_reg_range(BQ25630_REG_ICO_CURRENT_LIMIT, 301 BQ25630_REG_ICO_CURRENT_LIMIT), 302 }; 303 304 static const struct regmap_access_table bq25630_read_reg_access_table16le = { 305 .yes_ranges = bq25630_read_reg_range16le, 306 .n_yes_ranges = ARRAY_SIZE(bq25630_read_reg_range16le), 307 }; 308 309 static const struct regmap_access_table bq25630_write_reg_access_table16le = { 310 .yes_ranges = bq25630_write_reg_range16le, 311 .n_yes_ranges = ARRAY_SIZE(bq25630_write_reg_range16le), 312 }; 313 314 static const struct regmap_config bq25630_regmap_config16le = { 315 .name = BQ25630_DRV_NAME "-16bit-le", 316 .reg_bits = 8, 317 .val_bits = 16, 318 .reg_stride = 2, 319 .val_format_endian = REGMAP_ENDIAN_LITTLE, 320 /* 321 * Datasheet doesn't mention that this register is little-endian, but it 322 * looks like it? 323 */ 324 .max_register = BQ25630_REG_TERMINATION_CONTROL, 325 .rd_table = &bq25630_read_reg_access_table16le, 326 .wr_table = &bq25630_write_reg_access_table16le, 327 }; 328 329 /* 16-bit big-endian value regmap. */ 330 static const struct regmap_range bq25630_read_reg_range16be[] = { 331 regmap_reg_range(BQ25630_REG_IBUS_ADC, 332 BQ25630_REG_TDIE_ADC), 333 }; 334 335 static const struct regmap_access_table bq25630_read_reg_access_table16be = { 336 .yes_ranges = bq25630_read_reg_range16be, 337 .n_yes_ranges = ARRAY_SIZE(bq25630_read_reg_range16be), 338 }; 339 340 static const struct regmap_config bq25630_regmap_config16be = { 341 .name = BQ25630_DRV_NAME "-16bit-be", 342 .reg_bits = 8, 343 .val_bits = 16, 344 .reg_stride = 2, 345 .val_format_endian = REGMAP_ENDIAN_BIG, 346 .max_register = BQ25630_REG_TDIE_ADC, 347 .rd_table = &bq25630_read_reg_access_table16be, 348 .wr_table = NULL, 349 }; 350 351 struct bq25630_data { 352 struct device *dev; 353 struct regmap *regmap8; 354 struct regmap *regmap16le; 355 struct regmap *regmap16be; 356 struct regmap_field *regfields[BQ25630_REGF_MAX]; 357 358 struct power_supply *psy; 359 360 /* State status from IRQs. */ 361 u8 statregs[BQ25630_NR_STAT_REGS]; 362 }; 363 364 static int bq25630_alloc_regfield_range(struct bq25630_data *data, 365 const enum bq25630_regfield from, 366 const enum bq25630_regfield to, 367 struct regmap *regmap) 368 { 369 int i; 370 371 for (i = from; i <= to; ++i) { 372 data->regfields[i] = devm_regmap_field_alloc( 373 data->dev, regmap, bq25630_regfields[i]); 374 if (IS_ERR(data->regfields[i])) 375 return dev_err_probe( 376 data->dev, PTR_ERR(data->regfields[i]), 377 "Could not allocate register field %d\n", i); 378 } 379 380 return 0; 381 } 382 383 static irqreturn_t bq25630_irq_thread(int irq, void *dev_id) 384 { 385 struct bq25630_data *data = dev_id; 386 u8 regbuf[BQ25630_NR_STAT_REGS]; 387 int ret; 388 389 BUILD_BUG_ON(ARRAY_SIZE(regbuf) != ARRAY_SIZE(data->statregs)); 390 391 ret = regmap_bulk_read(data->regmap8, BQ25630_REG_CHARGER_STATUS_0, 392 regbuf, ARRAY_SIZE(regbuf)); 393 if (ret) { 394 dev_err(data->dev, "Could not bulk read IRQ registers (%d)\n", 395 ret); 396 goto out; 397 } 398 399 if (memcmp(data->statregs, regbuf, ARRAY_SIZE(data->statregs))) { 400 power_supply_changed(data->psy); 401 memcpy(data->statregs, regbuf, ARRAY_SIZE(data->statregs)); 402 } 403 404 out: 405 return IRQ_HANDLED; 406 } 407 408 static int bq25630_read_limit(struct bq25630_data *data, 409 const enum bq25630_regfield regfield, 410 const int minval, const int step, 411 const int minregval, int *val) 412 { 413 unsigned int regval; 414 int ret; 415 416 ret = regmap_field_read(data->regfields[regfield], ®val); 417 if (ret) { 418 dev_err(data->dev, "Could not read limit (%d)\n", ret); 419 return ret; 420 } 421 422 *val = minval + step * (regval - minregval); 423 424 return 0; 425 } 426 427 static int bq25630_write_limit(struct bq25630_data *data, 428 const enum bq25630_regfield regfield, 429 const int minval, const int maxval, 430 const int step, const int minregval, int val) 431 { 432 unsigned int regval; 433 int ret; 434 435 val = clamp(val, minval, maxval); 436 regval = minregval + ((val - minval) / step); 437 ret = regmap_field_write(data->regfields[regfield], regval); 438 if (ret) { 439 dev_err(data->dev, "Could not write limit (%d)\n", ret); 440 return ret; 441 } 442 443 return 0; 444 } 445 446 static int bq25630_read_charge_type(struct bq25630_data *data, int *val) 447 { 448 unsigned int regval; 449 int ret; 450 451 ret = regmap_field_read(data->regfields[BQ25630_REGF_CHG_STAT], 452 ®val); 453 if (ret) { 454 dev_err(data->dev, "Could not read charge type (%d)\n", ret); 455 return ret; 456 } 457 458 switch (regval) { 459 case BQ25630_CHG_STAT_NOT_CHARGING: 460 *val = POWER_SUPPLY_CHARGE_TYPE_NONE; 461 break; 462 case BQ25630_CHG_STAT_TRICKLE_CHARGE: 463 case BQ25630_CHG_STAT_PRE_CHARGE: 464 *val = POWER_SUPPLY_CHARGE_TYPE_TRICKLE; 465 break; 466 case BQ25630_CHG_STAT_FAST_CHARGE: 467 *val = POWER_SUPPLY_CHARGE_TYPE_FAST; 468 break; 469 case BQ25630_CHG_STAT_TAPER_CHARGE: 470 *val = POWER_SUPPLY_CHARGE_TYPE_LONGLIFE; 471 break; 472 case BQ25630_CHG_STAT_TERMINATION: 473 *val = POWER_SUPPLY_CHARGE_TYPE_BYPASS; 474 break; 475 default: 476 *val = POWER_SUPPLY_CHARGE_TYPE_UNKNOWN; 477 } 478 479 return 0; 480 } 481 482 static int bq25630_read_health(struct bq25630_data *data, int *val) 483 { 484 unsigned int regval; 485 int ret; 486 u8 temp; 487 488 ret = regmap_read(data->regmap8, BQ25630_REG_FAULT_STATUS, ®val); 489 if (ret) { 490 dev_err(data->dev, "Could not read fault status (%d)\n", ret); 491 return ret; 492 } 493 494 temp = regval & GENMASK(bq25630_regfields[BQ25630_REGF_TS_STAT].msb, 495 bq25630_regfields[BQ25630_REGF_TS_STAT].lsb); 496 if (regval & 497 GENMASK(bq25630_regfields[BQ25630_REGF_VBUS_FAULT_STAT].msb, 498 bq25630_regfields[BQ25630_REGF_VBUS_FAULT_STAT].lsb)) { 499 *val = POWER_SUPPLY_HEALTH_OVERVOLTAGE; 500 } else if (regval & 501 GENMASK(bq25630_regfields[BQ25630_REGF_BAT_FAULT_STAT].msb, 502 bq25630_regfields[BQ25630_REGF_BAT_FAULT_STAT].lsb)) { 503 /* 504 * We can't differentiate between dead, under voltage or over 505 * voltage. 506 */ 507 *val = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE; 508 } else if (regval & 509 GENMASK(bq25630_regfields[BQ25630_REGF_VSYS_FAULT_STAT].msb, 510 bq25630_regfields[BQ25630_REGF_VSYS_FAULT_STAT].lsb)) { 511 /* 512 * We can't differentiate between under voltage or over voltage. 513 */ 514 *val = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE; 515 } else if (regval & 516 GENMASK(bq25630_regfields[BQ25630_REGF_OTG_FAULT_STAT].msb, 517 bq25630_regfields[BQ25630_REGF_OTG_FAULT_STAT].lsb)) { 518 /* 519 * We can't differentiate between under voltage or over voltage. 520 */ 521 *val = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE; 522 } else if (regval & 523 GENMASK(bq25630_regfields[BQ25630_REGF_TSHUT_STAT].msb, 524 bq25630_regfields[BQ25630_REGF_TSHUT_STAT].lsb)) { 525 /* Temperature shutdown is always due to hot temperatures. */ 526 *val = POWER_SUPPLY_HEALTH_HOT; 527 } else if (temp) { 528 switch (temp) { 529 case BQ25630_TS_STAT_COLD: 530 *val = POWER_SUPPLY_HEALTH_COLD; 531 break; 532 case BQ25630_TS_STAT_COOL: 533 *val = POWER_SUPPLY_HEALTH_COOL; 534 break; 535 case BQ25630_TS_STAT_WARM: 536 *val = POWER_SUPPLY_HEALTH_WARM; 537 break; 538 case BQ25630_TS_STAT_HOT: 539 *val = POWER_SUPPLY_HEALTH_HOT; 540 break; 541 default: 542 /* Interpret PRECOOL and PREWARM as NORMAL. */ 543 *val = POWER_SUPPLY_HEALTH_GOOD; 544 } 545 } else { 546 *val = POWER_SUPPLY_HEALTH_GOOD; 547 } 548 549 return 0; 550 } 551 552 static int bq25630_read_vbus(struct bq25630_data *data, int *val) 553 { 554 unsigned int regval; 555 int ret; 556 557 ret = regmap_field_read(data->regfields[BQ25630_REGF_VBUS_STAT], 558 ®val); 559 if (ret) { 560 dev_err(data->dev, "Could not read VBUS (%d)\n", ret); 561 return ret; 562 } 563 564 switch (regval) { 565 case BQ25630_VBUS_STAT_NONE: 566 *val = -1; 567 break; 568 case BQ25630_VBUS_STAT_SDP: 569 *val = POWER_SUPPLY_USB_TYPE_SDP; 570 break; 571 case BQ25630_VBUS_STAT_CDP: 572 *val = POWER_SUPPLY_USB_TYPE_CDP; 573 break; 574 case BQ25630_VBUS_STAT_DCP: 575 case BQ25630_VBUS_STAT_HVDCP: 576 *val = POWER_SUPPLY_USB_TYPE_DCP; 577 break; 578 case BQ25630_VBUS_STAT_USB_C_DEFAULT: 579 case BQ25630_VBUS_STAT_USB_C_MEDIUM: 580 case BQ25630_VBUS_STAT_USB_C_HIGH: 581 *val = POWER_SUPPLY_USB_TYPE_C; 582 break; 583 default: 584 *val = POWER_SUPPLY_USB_TYPE_UNKNOWN; 585 } 586 587 return 0; 588 } 589 590 static int bq25630_get_status(struct bq25630_data *data, int *val) 591 { 592 unsigned int regval; 593 int ret; 594 595 ret = regmap_field_read(data->regfields[BQ25630_REGF_PG_STAT], ®val); 596 if (ret) { 597 dev_err(data->dev, "Could not read PG status (%d)", ret); 598 return ret; 599 } 600 601 if (!regval) { 602 /* There is not enough power, battery must be discharging. */ 603 *val = POWER_SUPPLY_STATUS_DISCHARGING; 604 return 0; 605 } 606 607 ret = regmap_field_read(data->regfields[BQ25630_REGF_EN_CHG], ®val); 608 if (ret) { 609 dev_err(data->dev, "Could not read charge status (%d)", ret); 610 return ret; 611 } 612 613 if (!regval) { 614 /* Charging is not enabled, battery must be discharging. */ 615 *val = POWER_SUPPLY_STATUS_DISCHARGING; 616 return 0; 617 } 618 619 ret = bq25630_read_charge_type(data, val); 620 if (ret) 621 return ret; 622 623 switch (*val) { 624 case POWER_SUPPLY_CHARGE_TYPE_NONE: 625 *val = POWER_SUPPLY_STATUS_NOT_CHARGING; 626 break; 627 case POWER_SUPPLY_CHARGE_TYPE_BYPASS: 628 /* Corresponds to BQ25630_CHG_STAT_TERMINATION. */ 629 *val = POWER_SUPPLY_STATUS_FULL; 630 break; 631 default: 632 *val = POWER_SUPPLY_STATUS_CHARGING; 633 } 634 635 return 0; 636 } 637 638 static int bq25630_reset(struct bq25630_data *data) 639 { 640 unsigned int regval = 1; 641 int ret; 642 643 ret = regmap_field_force_write(data->regfields[BQ25630_REGF_REG_RST], 644 regval); 645 if (ret) { 646 dev_err(data->dev, 647 "Could not force write reset register field (%d)\n", 648 ret); 649 return ret; 650 } 651 652 /* 653 * After a successful register reset, the device signals by resetting 654 * this register field to 0. Try reading it for some interrupt cycles. 655 */ 656 ret = regmap_field_read_poll_timeout( 657 data->regfields[BQ25630_REGF_REG_RST], regval, regval == 0, 256, 658 100000); 659 if (ret) { 660 dev_err(data->dev, "Could not read reset register field (%d)\n", 661 ret); 662 return ret; 663 } 664 665 return 0; 666 } 667 668 static int bq25630_setup(struct power_supply *psy) 669 { 670 struct bq25630_data *data = power_supply_get_drvdata(psy); 671 struct power_supply_battery_info *batinfo; 672 int ret; 673 674 ret = bq25630_reset(data); 675 if (ret) { 676 dev_err(data->dev, "Could not reset device (%d)\n", ret); 677 return ret; 678 } 679 680 /* Disable the watchdog. */ 681 ret = regmap_field_write(data->regfields[BQ25630_REGF_WATCHDOG], 0); 682 if (ret) { 683 dev_err(data->dev, "Could not write watchdog timer (%d)\n", 684 ret); 685 return ret; 686 } 687 688 ret = power_supply_get_battery_info(psy, &batinfo); 689 if (ret) { 690 dev_err(data->dev, "Could not get battery info (%d)\n", ret); 691 return ret; 692 } 693 694 /* 695 * Set values according to battery info. Warn on missing "dangerous" 696 * properties. 697 */ 698 if (batinfo->voltage_min_design_uv >= 0) { 699 ret = bq25630_write_limit(data, BQ25630_REGF_VSYSMIN, 700 BQ25630_VSYSMIN_MIN, 701 BQ25630_VSYSMIN_MAX, 702 BQ25630_VSYSMIN_STEP, 703 BQ25630_VSYSMIN_MIN_REGVAL, 704 batinfo->voltage_min_design_uv); 705 if (ret) 706 goto out_put_batinfo; 707 } else 708 dev_warn(data->dev, 709 "Using default value for minimum voltage\n"); 710 711 if (batinfo->constant_charge_voltage_max_uv >= 0) { 712 ret = bq25630_write_limit( 713 data, BQ25630_REGF_VREG, BQ25630_VREG_MIN, 714 BQ25630_VREG_MAX, BQ25630_VREG_STEP, 715 BQ25630_VREG_MIN_REGVAL, 716 batinfo->constant_charge_voltage_max_uv); 717 if (ret) 718 goto out_put_batinfo; 719 } else 720 dev_warn(data->dev, 721 "Using default value for maximum constant charge voltage\n"); 722 723 if (batinfo->constant_charge_current_max_ua >= 0) { 724 ret = bq25630_write_limit( 725 data, BQ25630_REGF_ICHG, BQ25630_ICHG_MIN, 726 BQ25630_ICHG_MAX, BQ25630_ICHG_STEP, 727 BQ25630_ICHG_MIN_REGVAL, 728 batinfo->constant_charge_current_max_ua); 729 if (ret) 730 goto out_put_batinfo; 731 } else 732 dev_warn(data->dev, 733 "Using default value for maximum constant charge current\n"); 734 735 if (batinfo->charge_term_current_ua >= 0) { 736 ret = bq25630_write_limit( 737 data, BQ25630_REGF_ITERM, BQ25630_ITERM_MIN, 738 BQ25630_ITERM_MAX, BQ25630_ITERM_STEP, 739 BQ25630_ITERM_MIN_REGVAL, 740 batinfo->charge_term_current_ua); 741 if (ret) 742 goto out_put_batinfo; 743 } 744 745 if (batinfo->precharge_current_ua >= 0) { 746 ret = bq25630_write_limit(data, BQ25630_REGF_IPRECHG, 747 BQ25630_IPRECHG_MIN, 748 BQ25630_IPRECHG_MAX, 749 BQ25630_IPRECHG_STEP, 750 BQ25630_IPRECHG_MIN_REGVAL, 751 batinfo->precharge_current_ua); 752 if (ret) 753 goto out_put_batinfo; 754 } 755 756 out_put_batinfo: 757 power_supply_put_battery_info(psy, batinfo); 758 759 return ret; 760 } 761 762 static int bq25630_charger_get_property(struct power_supply *psy, 763 enum power_supply_property psp, 764 union power_supply_propval *val) 765 { 766 struct bq25630_data *data = power_supply_get_drvdata(psy); 767 int ret = 0; 768 769 switch (psp) { 770 case POWER_SUPPLY_PROP_STATUS: 771 ret = bq25630_get_status(data, &val->intval); 772 break; 773 case POWER_SUPPLY_PROP_CHARGE_TYPE: 774 case POWER_SUPPLY_PROP_CHARGE_TYPES: 775 ret = bq25630_read_charge_type(data, &val->intval); 776 break; 777 case POWER_SUPPLY_PROP_HEALTH: 778 ret = bq25630_read_health(data, &val->intval); 779 break; 780 case POWER_SUPPLY_PROP_ONLINE: 781 ret = regmap_field_read(data->regfields[BQ25630_REGF_EN_CHG], 782 &val->intval); 783 if (ret || !val->intval) { 784 /* Charging is not even enabled. */ 785 break; 786 } 787 788 ret = bq25630_read_vbus(data, &val->intval); 789 val->intval = val->intval >= 0; 790 break; 791 case POWER_SUPPLY_PROP_VOLTAGE_MIN: 792 ret = bq25630_read_limit(data, BQ25630_REGF_VSYSMIN, 793 BQ25630_VSYSMIN_MIN, 794 BQ25630_VSYSMIN_STEP, 795 BQ25630_VSYSMIN_MIN_REGVAL, 796 &val->intval); 797 break; 798 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT: 799 ret = bq25630_read_limit(data, BQ25630_REGF_ICHG, 800 BQ25630_ICHG_MIN, BQ25630_ICHG_STEP, 801 BQ25630_ICHG_MIN_REGVAL, &val->intval); 802 break; 803 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX: 804 val->intval = BQ25630_ICHG_MAX; 805 break; 806 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE: 807 ret = bq25630_read_limit(data, BQ25630_REGF_VREG, 808 BQ25630_VREG_MIN, BQ25630_VREG_STEP, 809 BQ25630_VREG_MIN_REGVAL, &val->intval); 810 break; 811 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX: 812 val->intval = BQ25630_VREG_MAX; 813 break; 814 case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT: 815 ret = bq25630_read_limit(data, BQ25630_REGF_IINDPM, 816 BQ25630_IINDPM_MIN, 817 BQ25630_IINDPM_STEP, 818 BQ25630_IINDPM_MIN_REGVAL, 819 &val->intval); 820 break; 821 case POWER_SUPPLY_PROP_INPUT_VOLTAGE_LIMIT: 822 ret = bq25630_read_limit(data, BQ25630_REGF_VINDPM, 823 BQ25630_VINDPM_MIN, 824 BQ25630_VINDPM_STEP, 825 BQ25630_VINDPM_MIN_REGVAL, 826 &val->intval); 827 break; 828 case POWER_SUPPLY_PROP_USB_TYPE: 829 ret = bq25630_read_vbus(data, &val->intval); 830 if (!ret && val->intval < 0) { 831 /* Nothing connected. */ 832 val->intval = POWER_SUPPLY_USB_TYPE_UNKNOWN; 833 } 834 break; 835 case POWER_SUPPLY_PROP_PRECHARGE_CURRENT: 836 ret = bq25630_read_limit(data, BQ25630_REGF_IPRECHG, 837 BQ25630_IPRECHG_MIN, 838 BQ25630_IPRECHG_STEP, 839 BQ25630_IPRECHG_MIN_REGVAL, 840 &val->intval); 841 break; 842 case POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT: 843 ret = bq25630_read_limit(data, BQ25630_REGF_ITERM, 844 BQ25630_ITERM_MIN, BQ25630_ITERM_STEP, 845 BQ25630_ITERM_MIN_REGVAL, 846 &val->intval); 847 break; 848 case POWER_SUPPLY_PROP_MODEL_NAME: 849 val->strval = "BQ25630"; 850 break; 851 case POWER_SUPPLY_PROP_MANUFACTURER: 852 val->strval = "Texas Instruments"; 853 break; 854 default: 855 return -EINVAL; 856 } 857 858 return ret; 859 } 860 861 static int bq25630_charger_set_property(struct power_supply *psy, 862 enum power_supply_property psp, 863 const union power_supply_propval *val) 864 { 865 struct bq25630_data *data = power_supply_get_drvdata(psy); 866 int ret = 0; 867 868 switch (psp) { 869 case POWER_SUPPLY_PROP_ONLINE: 870 ret = regmap_field_write(data->regfields[BQ25630_REGF_EN_CHG], 871 !!val->intval); 872 break; 873 case POWER_SUPPLY_PROP_VOLTAGE_MIN: 874 ret = bq25630_write_limit( 875 data, BQ25630_REGF_VSYSMIN, BQ25630_VSYSMIN_MIN, 876 BQ25630_VSYSMIN_MAX, BQ25630_VSYSMIN_STEP, 877 BQ25630_VSYSMIN_MIN_REGVAL, val->intval); 878 break; 879 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT: 880 ret = bq25630_write_limit(data, BQ25630_REGF_ICHG, 881 BQ25630_ICHG_MIN, BQ25630_ICHG_MAX, 882 BQ25630_ICHG_STEP, 883 BQ25630_ICHG_MIN_REGVAL, val->intval); 884 break; 885 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE: 886 ret = bq25630_write_limit(data, BQ25630_REGF_VREG, 887 BQ25630_VREG_MIN, BQ25630_VREG_MAX, 888 BQ25630_VREG_STEP, 889 BQ25630_VREG_MIN_REGVAL, val->intval); 890 break; 891 case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT: 892 ret = bq25630_write_limit( 893 data, BQ25630_REGF_IINDPM, BQ25630_IINDPM_MIN, 894 BQ25630_IINDPM_MAX, BQ25630_IINDPM_STEP, 895 BQ25630_IINDPM_MIN_REGVAL, val->intval); 896 break; 897 case POWER_SUPPLY_PROP_INPUT_VOLTAGE_LIMIT: 898 ret = bq25630_write_limit( 899 data, BQ25630_REGF_VINDPM, BQ25630_VINDPM_MIN, 900 BQ25630_VINDPM_MAX, BQ25630_VINDPM_STEP, 901 BQ25630_VINDPM_MIN_REGVAL, val->intval); 902 break; 903 case POWER_SUPPLY_PROP_PRECHARGE_CURRENT: 904 ret = bq25630_write_limit( 905 data, BQ25630_REGF_IPRECHG, BQ25630_IPRECHG_MIN, 906 BQ25630_IPRECHG_MAX, BQ25630_IPRECHG_STEP, 907 BQ25630_IPRECHG_MIN_REGVAL, val->intval); 908 break; 909 case POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT: 910 ret = bq25630_write_limit(data, BQ25630_REGF_ITERM, 911 BQ25630_ITERM_MIN, BQ25630_ITERM_MAX, 912 BQ25630_ITERM_STEP, 913 BQ25630_ITERM_MIN_REGVAL, 914 val->intval); 915 break; 916 default: 917 return -EINVAL; 918 } 919 920 return ret; 921 } 922 923 static int bq25630_charger_property_is_writeable(struct power_supply *psy, 924 enum power_supply_property psp) 925 { 926 switch (psp) { 927 case POWER_SUPPLY_PROP_ONLINE: 928 case POWER_SUPPLY_PROP_VOLTAGE_MIN: 929 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT: 930 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE: 931 case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT: 932 case POWER_SUPPLY_PROP_INPUT_VOLTAGE_LIMIT: 933 case POWER_SUPPLY_PROP_PRECHARGE_CURRENT: 934 case POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT: 935 return true; 936 default: 937 return false; 938 } 939 } 940 941 static const enum power_supply_property bq25630_charger_properties[] = { 942 POWER_SUPPLY_PROP_STATUS, 943 POWER_SUPPLY_PROP_CHARGE_TYPE, 944 POWER_SUPPLY_PROP_CHARGE_TYPES, 945 POWER_SUPPLY_PROP_HEALTH, 946 POWER_SUPPLY_PROP_ONLINE, 947 POWER_SUPPLY_PROP_VOLTAGE_MIN, 948 POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT, 949 POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX, 950 POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE, 951 POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX, 952 POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT, 953 POWER_SUPPLY_PROP_INPUT_VOLTAGE_LIMIT, 954 POWER_SUPPLY_PROP_USB_TYPE, 955 POWER_SUPPLY_PROP_PRECHARGE_CURRENT, 956 POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT, 957 POWER_SUPPLY_PROP_MODEL_NAME, 958 POWER_SUPPLY_PROP_MANUFACTURER, 959 }; 960 961 static const struct power_supply_desc bq25630_charger_psy_desc = { 962 .name = BQ25630_DRV_NAME, 963 .type = POWER_SUPPLY_TYPE_USB, 964 .charge_types = BIT(POWER_SUPPLY_CHARGE_TYPE_NONE) | 965 BIT(POWER_SUPPLY_CHARGE_TYPE_TRICKLE) | 966 BIT(POWER_SUPPLY_CHARGE_TYPE_FAST) | 967 BIT(POWER_SUPPLY_CHARGE_TYPE_LONGLIFE) | 968 BIT(POWER_SUPPLY_CHARGE_TYPE_BYPASS) | 969 BIT(POWER_SUPPLY_CHARGE_TYPE_UNKNOWN), 970 .usb_types = BIT(POWER_SUPPLY_USB_TYPE_UNKNOWN) | 971 BIT(POWER_SUPPLY_USB_TYPE_SDP) | 972 BIT(POWER_SUPPLY_USB_TYPE_DCP) | 973 BIT(POWER_SUPPLY_USB_TYPE_CDP) | 974 BIT(POWER_SUPPLY_USB_TYPE_C), 975 .properties = bq25630_charger_properties, 976 .num_properties = ARRAY_SIZE(bq25630_charger_properties), 977 .get_property = bq25630_charger_get_property, 978 .set_property = bq25630_charger_set_property, 979 .property_is_writeable = bq25630_charger_property_is_writeable, 980 .init = bq25630_setup, 981 }; 982 983 static int bq25630_probe(struct i2c_client *client) 984 { 985 struct power_supply_config psy_cfg = {}; 986 struct bq25630_data *data; 987 int ret; 988 989 data = devm_kzalloc(&client->dev, sizeof(*data), GFP_KERNEL); 990 if (!data) 991 return -ENOMEM; 992 993 data->dev = &client->dev; 994 995 data->regmap8 = devm_regmap_init_i2c(client, &bq25630_regmap_config8); 996 if (IS_ERR(data->regmap8)) 997 return dev_err_probe(data->dev, PTR_ERR(data->regmap8), 998 "Could not initialize regmap8\n"); 999 1000 ret = bq25630_alloc_regfield_range(data, BQ25630_REGF_WATCHDOG, 1001 BQ25630_REGF_TS_STAT, 1002 data->regmap8); 1003 if (ret) 1004 return ret; 1005 1006 data->regmap16le = 1007 devm_regmap_init_i2c(client, &bq25630_regmap_config16le); 1008 if (IS_ERR(data->regmap16le)) 1009 return dev_err_probe(data->dev, PTR_ERR(data->regmap16le), 1010 "Could not initialize regmap16le\n"); 1011 1012 ret = bq25630_alloc_regfield_range(data, BQ25630_REGF_ICHG, 1013 BQ25630_REGF_ITERM, 1014 data->regmap16le); 1015 if (ret) 1016 return ret; 1017 1018 data->regmap16be = 1019 devm_regmap_init_i2c(client, &bq25630_regmap_config16be); 1020 if (IS_ERR(data->regmap16be)) 1021 return dev_err_probe(data->dev, PTR_ERR(data->regmap16be), 1022 "Could not initialize regmap16be\n"); 1023 1024 ret = bq25630_alloc_regfield_range(data, BQ25630_REGF_IBUS_ADC, 1025 BQ25630_REGF_VBUS_ADC, 1026 data->regmap16be); 1027 if (ret) 1028 return ret; 1029 1030 psy_cfg.drv_data = data; 1031 psy_cfg.fwnode = dev_fwnode(data->dev); 1032 data->psy = devm_power_supply_register( 1033 data->dev, &bq25630_charger_psy_desc, &psy_cfg); 1034 if (IS_ERR(data->psy)) 1035 return dev_err_probe(data->dev, PTR_ERR(data->psy), 1036 "Could not register power supply\n"); 1037 1038 /* 1039 * Device sends active low 256 µs pulse to report status and fault. 1040 * 1041 * Note that we need to request this *after* registering the power 1042 * supply so devm destructs it correctly in the reverse order. Otherwise 1043 * spurious interrupts could call power_supply_changed() wrongly with a 1044 * uninitialized/deallocated power supply. 1045 */ 1046 ret = devm_request_threaded_irq(data->dev, client->irq, NULL, 1047 bq25630_irq_thread, 1048 IRQF_TRIGGER_FALLING | IRQF_ONESHOT, 1049 NULL, data); 1050 if (ret) 1051 return dev_err_probe(data->dev, ret, "Could not request IRQ\n"); 1052 1053 return 0; 1054 } 1055 1056 static const struct of_device_id bq25630_of_match[] = { 1057 { 1058 .compatible = "ti,bq25630", 1059 }, 1060 {} 1061 }; 1062 MODULE_DEVICE_TABLE(of, bq25630_of_match); 1063 1064 static struct i2c_driver bq25630_driver = { 1065 .driver = { 1066 .name = BQ25630_DRV_NAME, 1067 .of_match_table = bq25630_of_match, 1068 }, 1069 .probe = bq25630_probe, 1070 }; 1071 module_i2c_driver(bq25630_driver); 1072 1073 MODULE_AUTHOR("Waqar Hameed <waqar.hameed@axis.com>"); 1074 MODULE_DESCRIPTION("TI BQ25630 charger driver"); 1075 MODULE_LICENSE("GPL"); 1076