1 // SPDX-License-Identifier: GPL-2.0 2 // BQ25980 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/delay.h> 16 #include <linux/device.h> 17 #include <linux/moduleparam.h> 18 #include <linux/slab.h> 19 20 #include "bq25980_charger.h" 21 22 struct bq25980_state { 23 bool dischg; 24 bool ovp; 25 bool ocp; 26 bool wdt; 27 bool tflt; 28 bool online; 29 bool ce; 30 bool hiz; 31 bool bypass; 32 33 u32 vbat_adc; 34 u32 vsys_adc; 35 u32 ibat_adc; 36 }; 37 38 enum bq25980_id { 39 BQ25980, 40 BQ25975, 41 BQ25960, 42 }; 43 44 struct bq25980_chip_info { 45 46 int model_id; 47 48 const struct regmap_config *regmap_config; 49 50 int busocp_def; 51 int busocp_sc_max; 52 int busocp_byp_max; 53 int busocp_sc_min; 54 int busocp_byp_min; 55 56 int busovp_sc_def; 57 int busovp_byp_def; 58 int busovp_sc_step; 59 60 int busovp_sc_offset; 61 int busovp_byp_step; 62 int busovp_byp_offset; 63 int busovp_sc_min; 64 int busovp_sc_max; 65 int busovp_byp_min; 66 int busovp_byp_max; 67 68 int batovp_def; 69 int batovp_max; 70 int batovp_min; 71 int batovp_step; 72 int batovp_offset; 73 74 int batocp_def; 75 int batocp_max; 76 }; 77 78 struct bq25980_init_data { 79 u32 ichg; 80 u32 bypass_ilim; 81 u32 sc_ilim; 82 u32 vreg; 83 u32 iterm; 84 u32 iprechg; 85 u32 bypass_vlim; 86 u32 sc_vlim; 87 u32 ichg_max; 88 u32 vreg_max; 89 }; 90 91 struct bq25980_device { 92 struct i2c_client *client; 93 struct device *dev; 94 struct power_supply *charger; 95 struct power_supply *battery; 96 struct mutex lock; 97 struct regmap *regmap; 98 99 char model_name[I2C_NAME_SIZE]; 100 101 struct bq25980_init_data init_data; 102 const struct bq25980_chip_info *chip_info; 103 struct bq25980_state state; 104 int watchdog_timer; 105 }; 106 107 static struct reg_default bq25980_reg_defs[] = { 108 {BQ25980_BATOVP, 0x5A}, 109 {BQ25980_BATOVP_ALM, 0x46}, 110 {BQ25980_BATOCP, 0x51}, 111 {BQ25980_BATOCP_ALM, 0x50}, 112 {BQ25980_BATUCP_ALM, 0x28}, 113 {BQ25980_CHRGR_CTRL_1, 0x0}, 114 {BQ25980_BUSOVP, 0x26}, 115 {BQ25980_BUSOVP_ALM, 0x22}, 116 {BQ25980_BUSOCP, 0xD}, 117 {BQ25980_BUSOCP_ALM, 0xC}, 118 {BQ25980_TEMP_CONTROL, 0x30}, 119 {BQ25980_TDIE_ALM, 0xC8}, 120 {BQ25980_TSBUS_FLT, 0x15}, 121 {BQ25980_TSBAT_FLG, 0x15}, 122 {BQ25980_VAC_CONTROL, 0x0}, 123 {BQ25980_CHRGR_CTRL_2, 0x0}, 124 {BQ25980_CHRGR_CTRL_3, 0x20}, 125 {BQ25980_CHRGR_CTRL_4, 0x1D}, 126 {BQ25980_CHRGR_CTRL_5, 0x18}, 127 {BQ25980_STAT1, 0x0}, 128 {BQ25980_STAT2, 0x0}, 129 {BQ25980_STAT3, 0x0}, 130 {BQ25980_STAT4, 0x0}, 131 {BQ25980_STAT5, 0x0}, 132 {BQ25980_FLAG1, 0x0}, 133 {BQ25980_FLAG2, 0x0}, 134 {BQ25980_FLAG3, 0x0}, 135 {BQ25980_FLAG4, 0x0}, 136 {BQ25980_FLAG5, 0x0}, 137 {BQ25980_MASK1, 0x0}, 138 {BQ25980_MASK2, 0x0}, 139 {BQ25980_MASK3, 0x0}, 140 {BQ25980_MASK4, 0x0}, 141 {BQ25980_MASK5, 0x0}, 142 {BQ25980_DEVICE_INFO, 0x8}, 143 {BQ25980_ADC_CONTROL1, 0x0}, 144 {BQ25980_ADC_CONTROL2, 0x0}, 145 {BQ25980_IBUS_ADC_LSB, 0x0}, 146 {BQ25980_IBUS_ADC_MSB, 0x0}, 147 {BQ25980_VBUS_ADC_LSB, 0x0}, 148 {BQ25980_VBUS_ADC_MSB, 0x0}, 149 {BQ25980_VAC1_ADC_LSB, 0x0}, 150 {BQ25980_VAC2_ADC_LSB, 0x0}, 151 {BQ25980_VOUT_ADC_LSB, 0x0}, 152 {BQ25980_VBAT_ADC_LSB, 0x0}, 153 {BQ25980_IBAT_ADC_MSB, 0x0}, 154 {BQ25980_IBAT_ADC_LSB, 0x0}, 155 {BQ25980_TSBUS_ADC_LSB, 0x0}, 156 {BQ25980_TSBAT_ADC_LSB, 0x0}, 157 {BQ25980_TDIE_ADC_LSB, 0x0}, 158 {BQ25980_DEGLITCH_TIME, 0x0}, 159 {BQ25980_CHRGR_CTRL_6, 0x0}, 160 }; 161 162 static struct reg_default bq25975_reg_defs[] = { 163 {BQ25980_BATOVP, 0x5A}, 164 {BQ25980_BATOVP_ALM, 0x46}, 165 {BQ25980_BATOCP, 0x51}, 166 {BQ25980_BATOCP_ALM, 0x50}, 167 {BQ25980_BATUCP_ALM, 0x28}, 168 {BQ25980_CHRGR_CTRL_1, 0x0}, 169 {BQ25980_BUSOVP, 0x26}, 170 {BQ25980_BUSOVP_ALM, 0x22}, 171 {BQ25980_BUSOCP, 0xD}, 172 {BQ25980_BUSOCP_ALM, 0xC}, 173 {BQ25980_TEMP_CONTROL, 0x30}, 174 {BQ25980_TDIE_ALM, 0xC8}, 175 {BQ25980_TSBUS_FLT, 0x15}, 176 {BQ25980_TSBAT_FLG, 0x15}, 177 {BQ25980_VAC_CONTROL, 0x0}, 178 {BQ25980_CHRGR_CTRL_2, 0x0}, 179 {BQ25980_CHRGR_CTRL_3, 0x20}, 180 {BQ25980_CHRGR_CTRL_4, 0x1D}, 181 {BQ25980_CHRGR_CTRL_5, 0x18}, 182 {BQ25980_STAT1, 0x0}, 183 {BQ25980_STAT2, 0x0}, 184 {BQ25980_STAT3, 0x0}, 185 {BQ25980_STAT4, 0x0}, 186 {BQ25980_STAT5, 0x0}, 187 {BQ25980_FLAG1, 0x0}, 188 {BQ25980_FLAG2, 0x0}, 189 {BQ25980_FLAG3, 0x0}, 190 {BQ25980_FLAG4, 0x0}, 191 {BQ25980_FLAG5, 0x0}, 192 {BQ25980_MASK1, 0x0}, 193 {BQ25980_MASK2, 0x0}, 194 {BQ25980_MASK3, 0x0}, 195 {BQ25980_MASK4, 0x0}, 196 {BQ25980_MASK5, 0x0}, 197 {BQ25980_DEVICE_INFO, 0x8}, 198 {BQ25980_ADC_CONTROL1, 0x0}, 199 {BQ25980_ADC_CONTROL2, 0x0}, 200 {BQ25980_IBUS_ADC_LSB, 0x0}, 201 {BQ25980_IBUS_ADC_MSB, 0x0}, 202 {BQ25980_VBUS_ADC_LSB, 0x0}, 203 {BQ25980_VBUS_ADC_MSB, 0x0}, 204 {BQ25980_VAC1_ADC_LSB, 0x0}, 205 {BQ25980_VAC2_ADC_LSB, 0x0}, 206 {BQ25980_VOUT_ADC_LSB, 0x0}, 207 {BQ25980_VBAT_ADC_LSB, 0x0}, 208 {BQ25980_IBAT_ADC_MSB, 0x0}, 209 {BQ25980_IBAT_ADC_LSB, 0x0}, 210 {BQ25980_TSBUS_ADC_LSB, 0x0}, 211 {BQ25980_TSBAT_ADC_LSB, 0x0}, 212 {BQ25980_TDIE_ADC_LSB, 0x0}, 213 {BQ25980_DEGLITCH_TIME, 0x0}, 214 {BQ25980_CHRGR_CTRL_6, 0x0}, 215 }; 216 217 static struct reg_default bq25960_reg_defs[] = { 218 {BQ25980_BATOVP, 0x5A}, 219 {BQ25980_BATOVP_ALM, 0x46}, 220 {BQ25980_BATOCP, 0x51}, 221 {BQ25980_BATOCP_ALM, 0x50}, 222 {BQ25980_BATUCP_ALM, 0x28}, 223 {BQ25980_CHRGR_CTRL_1, 0x0}, 224 {BQ25980_BUSOVP, 0x26}, 225 {BQ25980_BUSOVP_ALM, 0x22}, 226 {BQ25980_BUSOCP, 0xD}, 227 {BQ25980_BUSOCP_ALM, 0xC}, 228 {BQ25980_TEMP_CONTROL, 0x30}, 229 {BQ25980_TDIE_ALM, 0xC8}, 230 {BQ25980_TSBUS_FLT, 0x15}, 231 {BQ25980_TSBAT_FLG, 0x15}, 232 {BQ25980_VAC_CONTROL, 0x0}, 233 {BQ25980_CHRGR_CTRL_2, 0x0}, 234 {BQ25980_CHRGR_CTRL_3, 0x20}, 235 {BQ25980_CHRGR_CTRL_4, 0x1D}, 236 {BQ25980_CHRGR_CTRL_5, 0x18}, 237 {BQ25980_STAT1, 0x0}, 238 {BQ25980_STAT2, 0x0}, 239 {BQ25980_STAT3, 0x0}, 240 {BQ25980_STAT4, 0x0}, 241 {BQ25980_STAT5, 0x0}, 242 {BQ25980_FLAG1, 0x0}, 243 {BQ25980_FLAG2, 0x0}, 244 {BQ25980_FLAG3, 0x0}, 245 {BQ25980_FLAG4, 0x0}, 246 {BQ25980_FLAG5, 0x0}, 247 {BQ25980_MASK1, 0x0}, 248 {BQ25980_MASK2, 0x0}, 249 {BQ25980_MASK3, 0x0}, 250 {BQ25980_MASK4, 0x0}, 251 {BQ25980_MASK5, 0x0}, 252 {BQ25980_DEVICE_INFO, 0x8}, 253 {BQ25980_ADC_CONTROL1, 0x0}, 254 {BQ25980_ADC_CONTROL2, 0x0}, 255 {BQ25980_IBUS_ADC_LSB, 0x0}, 256 {BQ25980_IBUS_ADC_MSB, 0x0}, 257 {BQ25980_VBUS_ADC_LSB, 0x0}, 258 {BQ25980_VBUS_ADC_MSB, 0x0}, 259 {BQ25980_VAC1_ADC_LSB, 0x0}, 260 {BQ25980_VAC2_ADC_LSB, 0x0}, 261 {BQ25980_VOUT_ADC_LSB, 0x0}, 262 {BQ25980_VBAT_ADC_LSB, 0x0}, 263 {BQ25980_IBAT_ADC_MSB, 0x0}, 264 {BQ25980_IBAT_ADC_LSB, 0x0}, 265 {BQ25980_TSBUS_ADC_LSB, 0x0}, 266 {BQ25980_TSBAT_ADC_LSB, 0x0}, 267 {BQ25980_TDIE_ADC_LSB, 0x0}, 268 {BQ25980_DEGLITCH_TIME, 0x0}, 269 {BQ25980_CHRGR_CTRL_6, 0x0}, 270 }; 271 272 static int bq25980_watchdog_time[BQ25980_NUM_WD_VAL] = {5000, 10000, 50000, 273 300000}; 274 275 static int bq25980_get_input_curr_lim(struct bq25980_device *bq) 276 { 277 unsigned int busocp_reg_code; 278 int ret; 279 280 ret = regmap_read(bq->regmap, BQ25980_BUSOCP, &busocp_reg_code); 281 if (ret) 282 return ret; 283 284 return (busocp_reg_code * BQ25980_BUSOCP_STEP_uA) + BQ25980_BUSOCP_OFFSET_uA; 285 } 286 287 static int bq25980_set_hiz(struct bq25980_device *bq, int setting) 288 { 289 return regmap_update_bits(bq->regmap, BQ25980_CHRGR_CTRL_2, 290 BQ25980_EN_HIZ, setting); 291 } 292 293 static int bq25980_set_input_curr_lim(struct bq25980_device *bq, int busocp) 294 { 295 unsigned int busocp_reg_code; 296 int ret; 297 298 if (!busocp) 299 return bq25980_set_hiz(bq, BQ25980_ENABLE_HIZ); 300 301 bq25980_set_hiz(bq, BQ25980_DISABLE_HIZ); 302 303 if (busocp < BQ25980_BUSOCP_MIN_uA) 304 busocp = BQ25980_BUSOCP_MIN_uA; 305 306 if (bq->state.bypass) 307 busocp = min(busocp, bq->chip_info->busocp_sc_max); 308 else 309 busocp = min(busocp, bq->chip_info->busocp_byp_max); 310 311 busocp_reg_code = (busocp - BQ25980_BUSOCP_OFFSET_uA) 312 / BQ25980_BUSOCP_STEP_uA; 313 314 ret = regmap_write(bq->regmap, BQ25980_BUSOCP, busocp_reg_code); 315 if (ret) 316 return ret; 317 318 return regmap_write(bq->regmap, BQ25980_BUSOCP_ALM, busocp_reg_code); 319 } 320 321 static int bq25980_get_input_volt_lim(struct bq25980_device *bq) 322 { 323 unsigned int busovp_reg_code; 324 unsigned int busovp_offset; 325 unsigned int busovp_step; 326 int ret; 327 328 if (bq->state.bypass) { 329 busovp_step = bq->chip_info->busovp_byp_step; 330 busovp_offset = bq->chip_info->busovp_byp_offset; 331 } else { 332 busovp_step = bq->chip_info->busovp_sc_step; 333 busovp_offset = bq->chip_info->busovp_sc_offset; 334 } 335 336 ret = regmap_read(bq->regmap, BQ25980_BUSOVP, &busovp_reg_code); 337 if (ret) 338 return ret; 339 340 return (busovp_reg_code * busovp_step) + busovp_offset; 341 } 342 343 static int bq25980_set_input_volt_lim(struct bq25980_device *bq, int busovp) 344 { 345 unsigned int busovp_reg_code; 346 unsigned int busovp_step; 347 unsigned int busovp_offset; 348 int ret; 349 350 if (bq->state.bypass) { 351 busovp_step = bq->chip_info->busovp_byp_step; 352 busovp_offset = bq->chip_info->busovp_byp_offset; 353 if (busovp > bq->chip_info->busovp_byp_max) 354 busovp = bq->chip_info->busovp_byp_max; 355 else if (busovp < bq->chip_info->busovp_byp_min) 356 busovp = bq->chip_info->busovp_byp_min; 357 } else { 358 busovp_step = bq->chip_info->busovp_sc_step; 359 busovp_offset = bq->chip_info->busovp_sc_offset; 360 if (busovp > bq->chip_info->busovp_sc_max) 361 busovp = bq->chip_info->busovp_sc_max; 362 else if (busovp < bq->chip_info->busovp_sc_min) 363 busovp = bq->chip_info->busovp_sc_min; 364 } 365 366 busovp_reg_code = (busovp - busovp_offset) / busovp_step; 367 368 ret = regmap_write(bq->regmap, BQ25980_BUSOVP, busovp_reg_code); 369 if (ret) 370 return ret; 371 372 return regmap_write(bq->regmap, BQ25980_BUSOVP_ALM, busovp_reg_code); 373 } 374 375 static int bq25980_get_const_charge_curr(struct bq25980_device *bq) 376 { 377 unsigned int batocp_reg_code; 378 int ret; 379 380 ret = regmap_read(bq->regmap, BQ25980_BATOCP, &batocp_reg_code); 381 if (ret) 382 return ret; 383 384 return (batocp_reg_code & BQ25980_BATOCP_MASK) * 385 BQ25980_BATOCP_STEP_uA; 386 } 387 388 static int bq25980_set_const_charge_curr(struct bq25980_device *bq, int batocp) 389 { 390 unsigned int batocp_reg_code; 391 int ret; 392 393 batocp = max(batocp, BQ25980_BATOCP_MIN_uA); 394 batocp = min(batocp, bq->chip_info->batocp_max); 395 396 batocp_reg_code = batocp / BQ25980_BATOCP_STEP_uA; 397 398 ret = regmap_update_bits(bq->regmap, BQ25980_BATOCP, 399 BQ25980_BATOCP_MASK, batocp_reg_code); 400 if (ret) 401 return ret; 402 403 return regmap_update_bits(bq->regmap, BQ25980_BATOCP_ALM, 404 BQ25980_BATOCP_MASK, batocp_reg_code); 405 } 406 407 static int bq25980_get_const_charge_volt(struct bq25980_device *bq) 408 { 409 unsigned int batovp_reg_code; 410 int ret; 411 412 ret = regmap_read(bq->regmap, BQ25980_BATOVP, &batovp_reg_code); 413 if (ret) 414 return ret; 415 416 return ((batovp_reg_code * bq->chip_info->batovp_step) + 417 bq->chip_info->batovp_offset); 418 } 419 420 static int bq25980_set_const_charge_volt(struct bq25980_device *bq, int batovp) 421 { 422 unsigned int batovp_reg_code; 423 int ret; 424 425 if (batovp < bq->chip_info->batovp_min) 426 batovp = bq->chip_info->batovp_min; 427 428 if (batovp > bq->chip_info->batovp_max) 429 batovp = bq->chip_info->batovp_max; 430 431 batovp_reg_code = (batovp - bq->chip_info->batovp_offset) / 432 bq->chip_info->batovp_step; 433 434 ret = regmap_write(bq->regmap, BQ25980_BATOVP, batovp_reg_code); 435 if (ret) 436 return ret; 437 438 return regmap_write(bq->regmap, BQ25980_BATOVP_ALM, batovp_reg_code); 439 } 440 441 static int bq25980_set_bypass(struct bq25980_device *bq, bool en_bypass) 442 { 443 int ret; 444 445 if (en_bypass) 446 ret = regmap_update_bits(bq->regmap, BQ25980_CHRGR_CTRL_2, 447 BQ25980_EN_BYPASS, BQ25980_EN_BYPASS); 448 else 449 ret = regmap_update_bits(bq->regmap, BQ25980_CHRGR_CTRL_2, 450 BQ25980_EN_BYPASS, en_bypass); 451 if (ret) 452 return ret; 453 454 bq->state.bypass = en_bypass; 455 456 return bq->state.bypass; 457 } 458 459 static int bq25980_set_chg_en(struct bq25980_device *bq, bool en_chg) 460 { 461 int ret; 462 463 if (en_chg) 464 ret = regmap_update_bits(bq->regmap, BQ25980_CHRGR_CTRL_2, 465 BQ25980_CHG_EN, BQ25980_CHG_EN); 466 else 467 ret = regmap_update_bits(bq->regmap, BQ25980_CHRGR_CTRL_2, 468 BQ25980_CHG_EN, en_chg); 469 if (ret) 470 return ret; 471 472 bq->state.ce = en_chg; 473 474 return 0; 475 } 476 477 static int bq25980_get_adc_ibus(struct bq25980_device *bq) 478 { 479 int ibus_adc_lsb, ibus_adc_msb; 480 u16 ibus_adc; 481 int ret; 482 483 ret = regmap_read(bq->regmap, BQ25980_IBUS_ADC_MSB, &ibus_adc_msb); 484 if (ret) 485 return ret; 486 487 ret = regmap_read(bq->regmap, BQ25980_IBUS_ADC_LSB, &ibus_adc_lsb); 488 if (ret) 489 return ret; 490 491 ibus_adc = (ibus_adc_msb << 8) | ibus_adc_lsb; 492 493 if (ibus_adc_msb & BQ25980_ADC_POLARITY_BIT) 494 return ((ibus_adc ^ 0xffff) + 1) * BQ25980_ADC_CURR_STEP_uA; 495 496 return ibus_adc * BQ25980_ADC_CURR_STEP_uA; 497 } 498 499 static int bq25980_get_adc_vbus(struct bq25980_device *bq) 500 { 501 int vbus_adc_lsb, vbus_adc_msb; 502 u16 vbus_adc; 503 int ret; 504 505 ret = regmap_read(bq->regmap, BQ25980_VBUS_ADC_MSB, &vbus_adc_msb); 506 if (ret) 507 return ret; 508 509 ret = regmap_read(bq->regmap, BQ25980_VBUS_ADC_LSB, &vbus_adc_lsb); 510 if (ret) 511 return ret; 512 513 vbus_adc = (vbus_adc_msb << 8) | vbus_adc_lsb; 514 515 return vbus_adc * BQ25980_ADC_VOLT_STEP_uV; 516 } 517 518 static int bq25980_get_ibat_adc(struct bq25980_device *bq) 519 { 520 int ret; 521 int ibat_adc_lsb, ibat_adc_msb; 522 int ibat_adc; 523 524 ret = regmap_read(bq->regmap, BQ25980_IBAT_ADC_MSB, &ibat_adc_msb); 525 if (ret) 526 return ret; 527 528 ret = regmap_read(bq->regmap, BQ25980_IBAT_ADC_LSB, &ibat_adc_lsb); 529 if (ret) 530 return ret; 531 532 ibat_adc = (ibat_adc_msb << 8) | ibat_adc_lsb; 533 534 if (ibat_adc_msb & BQ25980_ADC_POLARITY_BIT) 535 return ((ibat_adc ^ 0xffff) + 1) * BQ25980_ADC_CURR_STEP_uA; 536 537 return ibat_adc * BQ25980_ADC_CURR_STEP_uA; 538 } 539 540 static int bq25980_get_adc_vbat(struct bq25980_device *bq) 541 { 542 int vsys_adc_lsb, vsys_adc_msb; 543 u16 vsys_adc; 544 int ret; 545 546 ret = regmap_read(bq->regmap, BQ25980_VBAT_ADC_MSB, &vsys_adc_msb); 547 if (ret) 548 return ret; 549 550 ret = regmap_read(bq->regmap, BQ25980_VBAT_ADC_LSB, &vsys_adc_lsb); 551 if (ret) 552 return ret; 553 554 vsys_adc = (vsys_adc_msb << 8) | vsys_adc_lsb; 555 556 return vsys_adc * BQ25980_ADC_VOLT_STEP_uV; 557 } 558 559 static int bq25980_get_state(struct bq25980_device *bq, 560 struct bq25980_state *state) 561 { 562 unsigned int chg_ctrl_2; 563 unsigned int stat1; 564 unsigned int stat2; 565 unsigned int stat3; 566 unsigned int stat4; 567 unsigned int ibat_adc_msb; 568 int ret; 569 570 ret = regmap_read(bq->regmap, BQ25980_STAT1, &stat1); 571 if (ret) 572 return ret; 573 574 ret = regmap_read(bq->regmap, BQ25980_STAT2, &stat2); 575 if (ret) 576 return ret; 577 578 ret = regmap_read(bq->regmap, BQ25980_STAT3, &stat3); 579 if (ret) 580 return ret; 581 582 ret = regmap_read(bq->regmap, BQ25980_STAT4, &stat4); 583 if (ret) 584 return ret; 585 586 ret = regmap_read(bq->regmap, BQ25980_CHRGR_CTRL_2, &chg_ctrl_2); 587 if (ret) 588 return ret; 589 590 ret = regmap_read(bq->regmap, BQ25980_IBAT_ADC_MSB, &ibat_adc_msb); 591 if (ret) 592 return ret; 593 594 state->dischg = ibat_adc_msb & BQ25980_ADC_POLARITY_BIT; 595 state->ovp = (stat1 & BQ25980_STAT1_OVP_MASK) | 596 (stat3 & BQ25980_STAT3_OVP_MASK); 597 state->ocp = (stat1 & BQ25980_STAT1_OCP_MASK) | 598 (stat2 & BQ25980_STAT2_OCP_MASK); 599 state->tflt = stat4 & BQ25980_STAT4_TFLT_MASK; 600 state->wdt = stat4 & BQ25980_WD_STAT; 601 state->online = stat3 & BQ25980_PRESENT_MASK; 602 state->ce = chg_ctrl_2 & BQ25980_CHG_EN; 603 state->hiz = chg_ctrl_2 & BQ25980_EN_HIZ; 604 state->bypass = chg_ctrl_2 & BQ25980_EN_BYPASS; 605 606 return 0; 607 } 608 609 static int bq25980_get_battery_property(struct power_supply *psy, 610 enum power_supply_property psp, 611 union power_supply_propval *val) 612 { 613 struct bq25980_device *bq = power_supply_get_drvdata(psy); 614 int ret = 0; 615 616 switch (psp) { 617 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX: 618 val->intval = bq->init_data.ichg_max; 619 break; 620 621 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX: 622 val->intval = bq->init_data.vreg_max; 623 break; 624 625 case POWER_SUPPLY_PROP_CURRENT_NOW: 626 ret = bq25980_get_ibat_adc(bq); 627 val->intval = ret; 628 break; 629 630 case POWER_SUPPLY_PROP_VOLTAGE_NOW: 631 ret = bq25980_get_adc_vbat(bq); 632 if (ret < 0) 633 return ret; 634 635 val->intval = ret; 636 break; 637 638 default: 639 return -EINVAL; 640 } 641 642 return ret; 643 } 644 645 static int bq25980_set_charger_property(struct power_supply *psy, 646 enum power_supply_property prop, 647 const union power_supply_propval *val) 648 { 649 struct bq25980_device *bq = power_supply_get_drvdata(psy); 650 int ret = -EINVAL; 651 652 switch (prop) { 653 case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT: 654 ret = bq25980_set_input_curr_lim(bq, val->intval); 655 if (ret) 656 return ret; 657 break; 658 659 case POWER_SUPPLY_PROP_INPUT_VOLTAGE_LIMIT: 660 ret = bq25980_set_input_volt_lim(bq, val->intval); 661 if (ret) 662 return ret; 663 break; 664 665 case POWER_SUPPLY_PROP_CHARGE_TYPE: 666 ret = bq25980_set_bypass(bq, val->intval); 667 if (ret) 668 return ret; 669 break; 670 671 case POWER_SUPPLY_PROP_STATUS: 672 ret = bq25980_set_chg_en(bq, val->intval); 673 if (ret) 674 return ret; 675 break; 676 677 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT: 678 ret = bq25980_set_const_charge_curr(bq, val->intval); 679 if (ret) 680 return ret; 681 break; 682 683 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE: 684 ret = bq25980_set_const_charge_volt(bq, val->intval); 685 if (ret) 686 return ret; 687 break; 688 689 default: 690 return -EINVAL; 691 } 692 693 return ret; 694 } 695 696 static int bq25980_get_charger_property(struct power_supply *psy, 697 enum power_supply_property psp, 698 union power_supply_propval *val) 699 { 700 struct bq25980_device *bq = power_supply_get_drvdata(psy); 701 struct bq25980_state state; 702 int ret = 0; 703 704 mutex_lock(&bq->lock); 705 ret = bq25980_get_state(bq, &state); 706 mutex_unlock(&bq->lock); 707 if (ret) 708 return ret; 709 710 switch (psp) { 711 case POWER_SUPPLY_PROP_MANUFACTURER: 712 val->strval = BQ25980_MANUFACTURER; 713 break; 714 case POWER_SUPPLY_PROP_MODEL_NAME: 715 val->strval = bq->model_name; 716 break; 717 case POWER_SUPPLY_PROP_ONLINE: 718 val->intval = state.online; 719 break; 720 721 case POWER_SUPPLY_PROP_INPUT_VOLTAGE_LIMIT: 722 ret = bq25980_get_input_volt_lim(bq); 723 if (ret < 0) 724 return ret; 725 val->intval = ret; 726 break; 727 728 case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT: 729 ret = bq25980_get_input_curr_lim(bq); 730 if (ret < 0) 731 return ret; 732 733 val->intval = ret; 734 break; 735 736 case POWER_SUPPLY_PROP_HEALTH: 737 val->intval = POWER_SUPPLY_HEALTH_GOOD; 738 739 if (state.tflt) 740 val->intval = POWER_SUPPLY_HEALTH_OVERHEAT; 741 else if (state.ovp) 742 val->intval = POWER_SUPPLY_HEALTH_OVERVOLTAGE; 743 else if (state.ocp) 744 val->intval = POWER_SUPPLY_HEALTH_OVERCURRENT; 745 else if (state.wdt) 746 val->intval = 747 POWER_SUPPLY_HEALTH_WATCHDOG_TIMER_EXPIRE; 748 break; 749 750 case POWER_SUPPLY_PROP_STATUS: 751 val->intval = POWER_SUPPLY_STATUS_UNKNOWN; 752 753 if ((state.ce) && (!state.hiz)) 754 val->intval = POWER_SUPPLY_STATUS_CHARGING; 755 else if (state.dischg) 756 val->intval = POWER_SUPPLY_STATUS_DISCHARGING; 757 else if (!state.ce) 758 val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING; 759 break; 760 761 case POWER_SUPPLY_PROP_CHARGE_TYPE: 762 val->intval = POWER_SUPPLY_CHARGE_TYPE_UNKNOWN; 763 764 if (!state.ce) 765 val->intval = POWER_SUPPLY_CHARGE_TYPE_NONE; 766 else if (state.bypass) 767 val->intval = POWER_SUPPLY_CHARGE_TYPE_BYPASS; 768 else if (!state.bypass) 769 val->intval = POWER_SUPPLY_CHARGE_TYPE_STANDARD; 770 break; 771 772 case POWER_SUPPLY_PROP_CURRENT_NOW: 773 ret = bq25980_get_adc_ibus(bq); 774 if (ret < 0) 775 return ret; 776 777 val->intval = ret; 778 break; 779 780 case POWER_SUPPLY_PROP_VOLTAGE_NOW: 781 ret = bq25980_get_adc_vbus(bq); 782 if (ret < 0) 783 return ret; 784 785 val->intval = ret; 786 break; 787 788 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT: 789 ret = bq25980_get_const_charge_curr(bq); 790 if (ret < 0) 791 return ret; 792 793 val->intval = ret; 794 break; 795 796 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE: 797 ret = bq25980_get_const_charge_volt(bq); 798 if (ret < 0) 799 return ret; 800 801 val->intval = ret; 802 break; 803 804 default: 805 return -EINVAL; 806 } 807 808 return ret; 809 } 810 811 static bool bq25980_state_changed(struct bq25980_device *bq, 812 struct bq25980_state *new_state) 813 { 814 struct bq25980_state old_state; 815 816 mutex_lock(&bq->lock); 817 old_state = bq->state; 818 mutex_unlock(&bq->lock); 819 820 return (old_state.dischg != new_state->dischg || 821 old_state.ovp != new_state->ovp || 822 old_state.ocp != new_state->ocp || 823 old_state.online != new_state->online || 824 old_state.wdt != new_state->wdt || 825 old_state.tflt != new_state->tflt || 826 old_state.ce != new_state->ce || 827 old_state.hiz != new_state->hiz || 828 old_state.bypass != new_state->bypass); 829 } 830 831 static irqreturn_t bq25980_irq_handler_thread(int irq, void *private) 832 { 833 struct bq25980_device *bq = private; 834 struct bq25980_state state; 835 int ret; 836 837 ret = bq25980_get_state(bq, &state); 838 if (ret < 0) 839 goto irq_out; 840 841 if (!bq25980_state_changed(bq, &state)) 842 goto irq_out; 843 844 mutex_lock(&bq->lock); 845 bq->state = state; 846 mutex_unlock(&bq->lock); 847 848 power_supply_changed(bq->charger); 849 850 irq_out: 851 return IRQ_HANDLED; 852 } 853 854 static enum power_supply_property bq25980_power_supply_props[] = { 855 POWER_SUPPLY_PROP_MANUFACTURER, 856 POWER_SUPPLY_PROP_MODEL_NAME, 857 POWER_SUPPLY_PROP_STATUS, 858 POWER_SUPPLY_PROP_ONLINE, 859 POWER_SUPPLY_PROP_HEALTH, 860 POWER_SUPPLY_PROP_INPUT_VOLTAGE_LIMIT, 861 POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT, 862 POWER_SUPPLY_PROP_CHARGE_TYPE, 863 POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT, 864 POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE, 865 POWER_SUPPLY_PROP_CURRENT_NOW, 866 POWER_SUPPLY_PROP_VOLTAGE_NOW, 867 }; 868 869 static enum power_supply_property bq25980_battery_props[] = { 870 POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX, 871 POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX, 872 POWER_SUPPLY_PROP_CURRENT_NOW, 873 POWER_SUPPLY_PROP_VOLTAGE_NOW, 874 }; 875 876 static char *bq25980_charger_supplied_to[] = { 877 "main-battery", 878 }; 879 880 static int bq25980_property_is_writeable(struct power_supply *psy, 881 enum power_supply_property prop) 882 { 883 switch (prop) { 884 case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT: 885 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE: 886 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT: 887 case POWER_SUPPLY_PROP_CHARGE_TYPE: 888 case POWER_SUPPLY_PROP_STATUS: 889 case POWER_SUPPLY_PROP_INPUT_VOLTAGE_LIMIT: 890 return true; 891 default: 892 return false; 893 } 894 } 895 896 static const struct power_supply_desc bq25980_power_supply_desc = { 897 .name = "bq25980-charger", 898 .type = POWER_SUPPLY_TYPE_MAINS, 899 .properties = bq25980_power_supply_props, 900 .num_properties = ARRAY_SIZE(bq25980_power_supply_props), 901 .get_property = bq25980_get_charger_property, 902 .set_property = bq25980_set_charger_property, 903 .property_is_writeable = bq25980_property_is_writeable, 904 }; 905 906 static struct power_supply_desc bq25980_battery_desc = { 907 .name = "bq25980-battery", 908 .type = POWER_SUPPLY_TYPE_BATTERY, 909 .get_property = bq25980_get_battery_property, 910 .properties = bq25980_battery_props, 911 .num_properties = ARRAY_SIZE(bq25980_battery_props), 912 .property_is_writeable = bq25980_property_is_writeable, 913 }; 914 915 916 static bool bq25980_is_volatile_reg(struct device *dev, unsigned int reg) 917 { 918 switch (reg) { 919 case BQ25980_CHRGR_CTRL_2: 920 case BQ25980_STAT1...BQ25980_FLAG5: 921 case BQ25980_ADC_CONTROL1...BQ25980_TDIE_ADC_LSB: 922 return true; 923 default: 924 return false; 925 } 926 } 927 928 static const struct regmap_config bq25980_regmap_config = { 929 .reg_bits = 8, 930 .val_bits = 8, 931 932 .max_register = BQ25980_CHRGR_CTRL_6, 933 .reg_defaults = bq25980_reg_defs, 934 .num_reg_defaults = ARRAY_SIZE(bq25980_reg_defs), 935 .cache_type = REGCACHE_RBTREE, 936 .volatile_reg = bq25980_is_volatile_reg, 937 }; 938 939 static const struct regmap_config bq25975_regmap_config = { 940 .reg_bits = 8, 941 .val_bits = 8, 942 943 .max_register = BQ25980_CHRGR_CTRL_6, 944 .reg_defaults = bq25975_reg_defs, 945 .num_reg_defaults = ARRAY_SIZE(bq25975_reg_defs), 946 .cache_type = REGCACHE_RBTREE, 947 .volatile_reg = bq25980_is_volatile_reg, 948 }; 949 950 static const struct regmap_config bq25960_regmap_config = { 951 .reg_bits = 8, 952 .val_bits = 8, 953 954 .max_register = BQ25980_CHRGR_CTRL_6, 955 .reg_defaults = bq25960_reg_defs, 956 .num_reg_defaults = ARRAY_SIZE(bq25960_reg_defs), 957 .cache_type = REGCACHE_RBTREE, 958 .volatile_reg = bq25980_is_volatile_reg, 959 }; 960 961 static const struct bq25980_chip_info bq25980_chip_info_tbl[] = { 962 [BQ25980] = { 963 .model_id = BQ25980, 964 .regmap_config = &bq25980_regmap_config, 965 966 .busocp_def = BQ25980_BUSOCP_DFLT_uA, 967 .busocp_sc_min = BQ25960_BUSOCP_SC_MAX_uA, 968 .busocp_sc_max = BQ25980_BUSOCP_SC_MAX_uA, 969 .busocp_byp_max = BQ25980_BUSOCP_BYP_MAX_uA, 970 .busocp_byp_min = BQ25980_BUSOCP_MIN_uA, 971 972 .busovp_sc_def = BQ25980_BUSOVP_DFLT_uV, 973 .busovp_byp_def = BQ25980_BUSOVP_BYPASS_DFLT_uV, 974 .busovp_sc_step = BQ25980_BUSOVP_SC_STEP_uV, 975 .busovp_sc_offset = BQ25980_BUSOVP_SC_OFFSET_uV, 976 .busovp_byp_step = BQ25980_BUSOVP_BYP_STEP_uV, 977 .busovp_byp_offset = BQ25980_BUSOVP_BYP_OFFSET_uV, 978 .busovp_sc_min = BQ25980_BUSOVP_SC_MIN_uV, 979 .busovp_sc_max = BQ25980_BUSOVP_SC_MAX_uV, 980 .busovp_byp_min = BQ25980_BUSOVP_BYP_MIN_uV, 981 .busovp_byp_max = BQ25980_BUSOVP_BYP_MAX_uV, 982 983 .batovp_def = BQ25980_BATOVP_DFLT_uV, 984 .batovp_max = BQ25980_BATOVP_MAX_uV, 985 .batovp_min = BQ25980_BATOVP_MIN_uV, 986 .batovp_step = BQ25980_BATOVP_STEP_uV, 987 .batovp_offset = BQ25980_BATOVP_OFFSET_uV, 988 989 .batocp_def = BQ25980_BATOCP_DFLT_uA, 990 .batocp_max = BQ25980_BATOCP_MAX_uA, 991 }, 992 993 [BQ25975] = { 994 .model_id = BQ25975, 995 .regmap_config = &bq25975_regmap_config, 996 997 .busocp_def = BQ25975_BUSOCP_DFLT_uA, 998 .busocp_sc_min = BQ25975_BUSOCP_SC_MAX_uA, 999 .busocp_sc_max = BQ25975_BUSOCP_SC_MAX_uA, 1000 .busocp_byp_min = BQ25980_BUSOCP_MIN_uA, 1001 .busocp_byp_max = BQ25975_BUSOCP_BYP_MAX_uA, 1002 1003 .busovp_sc_def = BQ25975_BUSOVP_DFLT_uV, 1004 .busovp_byp_def = BQ25975_BUSOVP_BYPASS_DFLT_uV, 1005 .busovp_sc_step = BQ25975_BUSOVP_SC_STEP_uV, 1006 .busovp_sc_offset = BQ25975_BUSOVP_SC_OFFSET_uV, 1007 .busovp_byp_step = BQ25975_BUSOVP_BYP_STEP_uV, 1008 .busovp_byp_offset = BQ25975_BUSOVP_BYP_OFFSET_uV, 1009 .busovp_sc_min = BQ25975_BUSOVP_SC_MIN_uV, 1010 .busovp_sc_max = BQ25975_BUSOVP_SC_MAX_uV, 1011 .busovp_byp_min = BQ25975_BUSOVP_BYP_MIN_uV, 1012 .busovp_byp_max = BQ25975_BUSOVP_BYP_MAX_uV, 1013 1014 .batovp_def = BQ25975_BATOVP_DFLT_uV, 1015 .batovp_max = BQ25975_BATOVP_MAX_uV, 1016 .batovp_min = BQ25975_BATOVP_MIN_uV, 1017 .batovp_step = BQ25975_BATOVP_STEP_uV, 1018 .batovp_offset = BQ25975_BATOVP_OFFSET_uV, 1019 1020 .batocp_def = BQ25980_BATOCP_DFLT_uA, 1021 .batocp_max = BQ25980_BATOCP_MAX_uA, 1022 }, 1023 1024 [BQ25960] = { 1025 .model_id = BQ25960, 1026 .regmap_config = &bq25960_regmap_config, 1027 1028 .busocp_def = BQ25960_BUSOCP_DFLT_uA, 1029 .busocp_sc_min = BQ25960_BUSOCP_SC_MAX_uA, 1030 .busocp_sc_max = BQ25960_BUSOCP_SC_MAX_uA, 1031 .busocp_byp_min = BQ25960_BUSOCP_SC_MAX_uA, 1032 .busocp_byp_max = BQ25960_BUSOCP_BYP_MAX_uA, 1033 1034 .busovp_sc_def = BQ25975_BUSOVP_DFLT_uV, 1035 .busovp_byp_def = BQ25975_BUSOVP_BYPASS_DFLT_uV, 1036 .busovp_sc_step = BQ25960_BUSOVP_SC_STEP_uV, 1037 .busovp_sc_offset = BQ25960_BUSOVP_SC_OFFSET_uV, 1038 .busovp_byp_step = BQ25960_BUSOVP_BYP_STEP_uV, 1039 .busovp_byp_offset = BQ25960_BUSOVP_BYP_OFFSET_uV, 1040 .busovp_sc_min = BQ25960_BUSOVP_SC_MIN_uV, 1041 .busovp_sc_max = BQ25960_BUSOVP_SC_MAX_uV, 1042 .busovp_byp_min = BQ25960_BUSOVP_BYP_MIN_uV, 1043 .busovp_byp_max = BQ25960_BUSOVP_BYP_MAX_uV, 1044 1045 .batovp_def = BQ25960_BATOVP_DFLT_uV, 1046 .batovp_max = BQ25960_BATOVP_MAX_uV, 1047 .batovp_min = BQ25960_BATOVP_MIN_uV, 1048 .batovp_step = BQ25960_BATOVP_STEP_uV, 1049 .batovp_offset = BQ25960_BATOVP_OFFSET_uV, 1050 1051 .batocp_def = BQ25960_BATOCP_DFLT_uA, 1052 .batocp_max = BQ25960_BATOCP_MAX_uA, 1053 }, 1054 }; 1055 1056 static int bq25980_power_supply_init(struct bq25980_device *bq, 1057 struct device *dev) 1058 { 1059 struct power_supply_config psy_cfg = { .drv_data = bq, 1060 .of_node = dev->of_node, }; 1061 1062 psy_cfg.supplied_to = bq25980_charger_supplied_to; 1063 psy_cfg.num_supplicants = ARRAY_SIZE(bq25980_charger_supplied_to); 1064 1065 bq->charger = devm_power_supply_register(bq->dev, 1066 &bq25980_power_supply_desc, 1067 &psy_cfg); 1068 if (IS_ERR(bq->charger)) 1069 return -EINVAL; 1070 1071 bq->battery = devm_power_supply_register(bq->dev, 1072 &bq25980_battery_desc, 1073 &psy_cfg); 1074 if (IS_ERR(bq->battery)) 1075 return -EINVAL; 1076 1077 return 0; 1078 } 1079 1080 static int bq25980_hw_init(struct bq25980_device *bq) 1081 { 1082 struct power_supply_battery_info *bat_info; 1083 int wd_reg_val = BQ25980_WATCHDOG_DIS; 1084 int wd_max_val = BQ25980_NUM_WD_VAL - 1; 1085 int ret = 0; 1086 int curr_val; 1087 int volt_val; 1088 int i; 1089 1090 if (bq->watchdog_timer) { 1091 if (bq->watchdog_timer >= bq25980_watchdog_time[wd_max_val]) 1092 wd_reg_val = wd_max_val; 1093 else { 1094 for (i = 0; i < wd_max_val; i++) { 1095 if (bq->watchdog_timer > bq25980_watchdog_time[i] && 1096 bq->watchdog_timer < bq25980_watchdog_time[i + 1]) { 1097 wd_reg_val = i; 1098 break; 1099 } 1100 } 1101 } 1102 } 1103 1104 ret = regmap_update_bits(bq->regmap, BQ25980_CHRGR_CTRL_3, 1105 BQ25980_WATCHDOG_MASK, wd_reg_val); 1106 if (ret) 1107 return ret; 1108 1109 ret = power_supply_get_battery_info(bq->charger, &bat_info); 1110 if (ret) { 1111 dev_warn(bq->dev, "battery info missing\n"); 1112 return -EINVAL; 1113 } 1114 1115 bq->init_data.ichg_max = bat_info->constant_charge_current_max_ua; 1116 bq->init_data.vreg_max = bat_info->constant_charge_voltage_max_uv; 1117 1118 if (bq->state.bypass) { 1119 ret = regmap_update_bits(bq->regmap, BQ25980_CHRGR_CTRL_2, 1120 BQ25980_EN_BYPASS, BQ25980_EN_BYPASS); 1121 if (ret) 1122 return ret; 1123 1124 curr_val = bq->init_data.bypass_ilim; 1125 volt_val = bq->init_data.bypass_vlim; 1126 } else { 1127 curr_val = bq->init_data.sc_ilim; 1128 volt_val = bq->init_data.sc_vlim; 1129 } 1130 1131 ret = bq25980_set_input_curr_lim(bq, curr_val); 1132 if (ret) 1133 return ret; 1134 1135 ret = bq25980_set_input_volt_lim(bq, volt_val); 1136 if (ret) 1137 return ret; 1138 1139 return regmap_update_bits(bq->regmap, BQ25980_ADC_CONTROL1, 1140 BQ25980_ADC_EN, BQ25980_ADC_EN); 1141 } 1142 1143 static int bq25980_parse_dt(struct bq25980_device *bq) 1144 { 1145 int ret; 1146 1147 ret = device_property_read_u32(bq->dev, "ti,watchdog-timeout-ms", 1148 &bq->watchdog_timer); 1149 if (ret) 1150 bq->watchdog_timer = BQ25980_WATCHDOG_MIN; 1151 1152 if (bq->watchdog_timer > BQ25980_WATCHDOG_MAX || 1153 bq->watchdog_timer < BQ25980_WATCHDOG_MIN) 1154 return -EINVAL; 1155 1156 ret = device_property_read_u32(bq->dev, 1157 "ti,sc-ovp-limit-microvolt", 1158 &bq->init_data.sc_vlim); 1159 if (ret) 1160 bq->init_data.sc_vlim = bq->chip_info->busovp_sc_def; 1161 1162 if (bq->init_data.sc_vlim > bq->chip_info->busovp_sc_max || 1163 bq->init_data.sc_vlim < bq->chip_info->busovp_sc_min) { 1164 dev_err(bq->dev, "SC ovp limit is out of range\n"); 1165 return -EINVAL; 1166 } 1167 1168 ret = device_property_read_u32(bq->dev, 1169 "ti,sc-ocp-limit-microamp", 1170 &bq->init_data.sc_ilim); 1171 if (ret) 1172 bq->init_data.sc_ilim = bq->chip_info->busocp_def; 1173 1174 if (bq->init_data.sc_ilim > bq->chip_info->busocp_sc_max || 1175 bq->init_data.sc_ilim < bq->chip_info->busocp_sc_min) { 1176 dev_err(bq->dev, "SC ocp limit is out of range\n"); 1177 return -EINVAL; 1178 } 1179 1180 ret = device_property_read_u32(bq->dev, 1181 "ti,bypass-ovp-limit-microvolt", 1182 &bq->init_data.bypass_vlim); 1183 if (ret) 1184 bq->init_data.bypass_vlim = bq->chip_info->busovp_byp_def; 1185 1186 if (bq->init_data.bypass_vlim > bq->chip_info->busovp_byp_max || 1187 bq->init_data.bypass_vlim < bq->chip_info->busovp_byp_min) { 1188 dev_err(bq->dev, "Bypass ovp limit is out of range\n"); 1189 return -EINVAL; 1190 } 1191 1192 ret = device_property_read_u32(bq->dev, 1193 "ti,bypass-ocp-limit-microamp", 1194 &bq->init_data.bypass_ilim); 1195 if (ret) 1196 bq->init_data.bypass_ilim = bq->chip_info->busocp_def; 1197 1198 if (bq->init_data.bypass_ilim > bq->chip_info->busocp_byp_max || 1199 bq->init_data.bypass_ilim < bq->chip_info->busocp_byp_min) { 1200 dev_err(bq->dev, "Bypass ocp limit is out of range\n"); 1201 return -EINVAL; 1202 } 1203 1204 1205 bq->state.bypass = device_property_read_bool(bq->dev, 1206 "ti,bypass-enable"); 1207 return 0; 1208 } 1209 1210 static int bq25980_probe(struct i2c_client *client) 1211 { 1212 const struct i2c_device_id *id = i2c_client_get_device_id(client); 1213 struct device *dev = &client->dev; 1214 struct bq25980_device *bq; 1215 int ret; 1216 1217 bq = devm_kzalloc(dev, sizeof(*bq), GFP_KERNEL); 1218 if (!bq) 1219 return -ENOMEM; 1220 1221 bq->client = client; 1222 bq->dev = dev; 1223 1224 mutex_init(&bq->lock); 1225 1226 strncpy(bq->model_name, id->name, I2C_NAME_SIZE); 1227 bq->chip_info = &bq25980_chip_info_tbl[id->driver_data]; 1228 1229 bq->regmap = devm_regmap_init_i2c(client, 1230 bq->chip_info->regmap_config); 1231 if (IS_ERR(bq->regmap)) { 1232 dev_err(dev, "Failed to allocate register map\n"); 1233 return PTR_ERR(bq->regmap); 1234 } 1235 1236 i2c_set_clientdata(client, bq); 1237 1238 ret = bq25980_parse_dt(bq); 1239 if (ret) { 1240 dev_err(dev, "Failed to read device tree properties%d\n", ret); 1241 return ret; 1242 } 1243 1244 if (client->irq) { 1245 ret = devm_request_threaded_irq(dev, client->irq, NULL, 1246 bq25980_irq_handler_thread, 1247 IRQF_TRIGGER_FALLING | 1248 IRQF_ONESHOT, 1249 dev_name(&client->dev), bq); 1250 if (ret) 1251 return ret; 1252 } 1253 1254 ret = bq25980_power_supply_init(bq, dev); 1255 if (ret) { 1256 dev_err(dev, "Failed to register power supply\n"); 1257 return ret; 1258 } 1259 1260 ret = bq25980_hw_init(bq); 1261 if (ret) { 1262 dev_err(dev, "Cannot initialize the chip.\n"); 1263 return ret; 1264 } 1265 1266 return 0; 1267 } 1268 1269 static const struct i2c_device_id bq25980_i2c_ids[] = { 1270 { "bq25980", BQ25980 }, 1271 { "bq25975", BQ25975 }, 1272 { "bq25960", BQ25960 }, 1273 {}, 1274 }; 1275 MODULE_DEVICE_TABLE(i2c, bq25980_i2c_ids); 1276 1277 static const struct of_device_id bq25980_of_match[] = { 1278 { .compatible = "ti,bq25980", .data = (void *)BQ25980 }, 1279 { .compatible = "ti,bq25975", .data = (void *)BQ25975 }, 1280 { .compatible = "ti,bq25960", .data = (void *)BQ25960 }, 1281 { }, 1282 }; 1283 MODULE_DEVICE_TABLE(of, bq25980_of_match); 1284 1285 static struct i2c_driver bq25980_driver = { 1286 .driver = { 1287 .name = "bq25980-charger", 1288 .of_match_table = bq25980_of_match, 1289 }, 1290 .probe = bq25980_probe, 1291 .id_table = bq25980_i2c_ids, 1292 }; 1293 module_i2c_driver(bq25980_driver); 1294 1295 MODULE_AUTHOR("Dan Murphy <dmurphy@ti.com>"); 1296 MODULE_AUTHOR("Ricardo Rivera-Matos <r-rivera-matos@ti.com>"); 1297 MODULE_DESCRIPTION("bq25980 charger driver"); 1298 MODULE_LICENSE("GPL v2"); 1299