1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Charger driver for SGM4154x 4 * 5 * Copyright (c) 2026 Rockchip Electronics Co., Ltd. 6 * 7 * Author: Xu Shengfei <xsf@rock-chips.com> 8 */ 9 10 #include <linux/bitfield.h> 11 #include <linux/delay.h> 12 #include <linux/devm-helpers.h> 13 #include <linux/i2c.h> 14 #include <linux/interrupt.h> 15 #include <linux/module.h> 16 #include <linux/mutex.h> 17 #include <linux/pm.h> 18 #include <linux/power_supply.h> 19 #include <linux/property.h> 20 #include <linux/regmap.h> 21 #include <linux/regulator/driver.h> 22 #include <linux/regulator/of_regulator.h> 23 #include <linux/types.h> 24 25 #define SGM4154X_MANUFACTURER "SGMICRO" 26 #define SGM4154X_NAME "sgm41542" 27 28 #define SGM4154X_CHRG_CTRL_0 0x00 29 #define SGM4154X_HIZ_EN BIT(7) 30 #define SGM4154X_IINDPM_I_MASK GENMASK(4, 0) 31 #define SGM4154X_IINDPM_I_MIN_UA 100000 32 #define SGM4154X_IINDPM_I_MAX_UA 3800000 33 #define SGM4154X_IINDPM_STEP_UA 100000 34 #define SGM4154X_IINDPM_DEF_UA 2400000 35 36 #define SGM4154X_CHRG_CTRL_1 0x01 37 #define SGM4154X_WDT_RST BIT(6) 38 #define SGM4154X_OTG_EN BIT(5) 39 #define SGM4154X_CHRG_EN BIT(4) 40 41 #define SGM4154X_CHRG_CTRL_2 0x02 42 #define SGM4154X_BOOST_LIM BIT(7) 43 #define SGM4154X_ICHRG_CUR_MASK GENMASK(5, 0) 44 #define SGM4154X_ICHRG_I_STEP_UA 60000 45 #define SGM4154X_ICHRG_I_MIN_UA 0 46 #define SGM4154X_ICHRG_I_MAX_UA 3780000 47 #define SGM4154X_ICHRG_I_DEF_UA 2040000 48 49 #define SGM4154X_CHRG_CTRL_3 0x03 50 #define SGM4154X_PRECHRG_CUR_MASK GENMASK(7, 4) 51 #define SGM4154X_PRECHRG_CURRENT_STEP_UA 60000 52 #define SGM4154X_PRECHRG_I_MIN_UA 60000 53 #define SGM4154X_PRECHRG_I_MAX_UA 780000 54 #define SGM4154X_PRECHRG_I_DEF_UA 180000 55 #define SGM4154X_TERMCHRG_CUR_MASK GENMASK(3, 0) 56 #define SGM4154X_TERMCHRG_CURRENT_STEP_UA 60000 57 #define SGM4154X_TERMCHRG_I_MIN_UA 60000 58 #define SGM4154X_TERMCHRG_I_MAX_UA 960000 59 #define SGM4154X_TERMCHRG_I_DEF_UA 180000 60 61 #define SGM4154X_CHRG_CTRL_4 0x04 62 #define SGM4154X_VREG_V_MASK GENMASK(7, 3) 63 #define SGM4154X_VREG_V_MAX_UV 4624000 64 #define SGM4154X_VREG_V_MIN_UV 3856000 65 #define SGM4154X_VREG_V_DEF_UV 4208000 66 #define SGM4154X_VREG_V_STEP_UV 32000 67 #define SGM4154X_VRECHARGE BIT(0) 68 #define SGM4154X_VRECHRG_STEP_UV 100000 69 #define SGM4154X_VRECHRG_OFFSET_UV 100000 70 71 #define SGM4154X_CHRG_CTRL_5 0x05 72 #define SGM4154X_TERM_EN BIT(7) 73 #define SGM4154X_WDT_TIMER_MASK GENMASK(5, 4) 74 75 #define SGM4154X_CHRG_CTRL_6 0x06 76 #define SGM4154X_VAC_OVP_MASK GENMASK(7, 6) 77 #define SGM4154X_OVP_14V (BIT(7) | BIT(6)) 78 #define SGM4154X_OVP_10_5V BIT(7) 79 #define SGM4154X_OVP_6_5V BIT(6) 80 #define SGM4154X_OVP_5_5V 0 81 #define SGM4154X_OVP_DEFAULT SGM4154X_OVP_14V 82 #define SGM4154X_BOOSTV GENMASK(5, 4) 83 #define SGM4154X_VINDPM_V_MASK GENMASK(3, 0) 84 #define SGM4154X_VINDPM_V_MIN_UV 3900000 85 #define SGM4154X_VINDPM_V_MAX_UV 12000000 86 #define SGM4154X_VINDPM_STEP_UV 100000 87 #define SGM4154X_VINDPM_DEF_UV 4500000 88 89 #define SGM4154X_CHRG_CTRL_7 0x07 90 91 #define SGM4154X_CHRG_STAT 0x08 92 #define SGM4154X_VBUS_STAT_MASK GENMASK(7, 5) 93 #define SGM4154X_OTG_MODE (BIT(7) | BIT(6) | BIT(5)) 94 #define SGM4154X_NON_STANDARD (BIT(7) | BIT(6)) 95 #define SGM4154X_UNKNOWN (BIT(7) | BIT(5)) 96 #define SGM4154X_USB_DCP (BIT(6) | BIT(5)) 97 #define SGM4154X_USB_CDP BIT(6) 98 #define SGM4154X_USB_SDP BIT(5) 99 #define SGM4154X_NOT_CHRGING 0 100 #define SGM4154X_CHG_STAT_MASK GENMASK(4, 3) 101 #define SGM4154X_TERM_CHRG (BIT(4) | BIT(3)) 102 #define SGM4154X_FAST_CHRG BIT(4) 103 #define SGM4154X_PRECHRG BIT(3) 104 #define SGM4154X_PG_STAT BIT(2) 105 #define SGM4154X_THERM_STAT BIT(1) 106 #define SGM4154X_VSYS_STAT BIT(0) 107 108 #define SGM4154X_CHRG_FAULT 0x09 109 #define SGM4154X_TEMP_MASK GENMASK(2, 0) 110 #define SGM4154X_TEMP_HOT (BIT(2) | BIT(1)) 111 #define SGM4154X_TEMP_COLD (BIT(2) | BIT(0)) 112 #define SGM4154X_TEMP_COOL (BIT(1) | BIT(0)) 113 #define SGM4154X_TEMP_WARM BIT(1) 114 #define SGM4154X_TEMP_NORMAL BIT(0) 115 116 #define SGM4154X_CHRG_CTRL_A 0x0a 117 #define SGM4154X_VBUS_GOOD BIT(7) 118 #define SGM4154X_VINDPM_INT_MASK BIT(1) 119 #define SGM4154X_IINDPM_INT_MASK BIT(0) 120 121 #define SGM4154X_CHRG_CTRL_B 0x0b 122 #define SGM4154X_PN_ID (BIT(6) | BIT(5) | BIT(3)) 123 #define SGM4154X_PN_MASK GENMASK(6, 3) 124 125 #define SGM4154X_CHRG_CTRL_C 0x0c 126 127 #define SGM4154X_CHRG_CTRL_D 0x0d 128 #define SGM4154X_JEITA_EN BIT(0) 129 130 #define SGM4154X_INPUT_DET 0x0e 131 #define SGM4154X_DPDM_ONGOING BIT(7) 132 133 #define SGM4154X_CHRG_CTRL_F 0x0f 134 #define SGM4154X_VINDPM_OS_MASK GENMASK(1, 0) 135 136 #define SGM4154X_DEFAULT_INPUT_CUR (500 * 1000) 137 138 struct sgm4154x_init_data { 139 int ilim; /* input current limit */ 140 int vlim; /* minimum system voltage limit */ 141 int iterm; /* termination current */ 142 int iprechg; /* precharge current */ 143 int max_ichg; /* maximum charge current */ 144 int max_vreg; /* maximum charge voltage */ 145 }; 146 147 struct sgm4154x_state { 148 bool vsys_stat; 149 bool therm_stat; 150 bool online; 151 u8 chrg_stat; 152 bool chrg_en; 153 bool vbus_gd; 154 u8 chrg_type; 155 u8 health; 156 u8 chrg_fault; 157 u8 ntc_fault; 158 }; 159 160 struct sgm4154x_device { 161 struct device *dev; 162 struct power_supply *charger; 163 struct regmap *regmap; 164 struct sgm4154x_init_data init_data; 165 struct sgm4154x_state state; 166 struct regulator_dev *otg_rdev; 167 struct mutex lock; 168 bool watchdog_enable; 169 struct workqueue_struct *sgm_monitor_wq; 170 struct delayed_work sgm_delay_work; 171 }; 172 173 enum SGM4154X_VINDPM_OS { 174 VINDPM_OS_3900MV, 175 VINDPM_OS_5900MV, 176 VINDPM_OS_7500MV, 177 VINDPM_OS_10500MV, 178 }; 179 180 enum sgm4154x_wdt_values { 181 SGM4154X_WDT_TIMER_DISABLE = 0, 182 SGM4154X_WDT_TIMER_40S = 1, 183 SGM4154X_WDT_TIMER_80S = 2, 184 SGM4154X_WDT_TIMER_160S = 3, 185 }; 186 187 static int sgm4154x_set_term_curr(struct sgm4154x_device *sgm, int cur_ua) 188 { 189 int reg_val; 190 int ret; 191 192 cur_ua = clamp(cur_ua, SGM4154X_TERMCHRG_I_MIN_UA, SGM4154X_TERMCHRG_I_MAX_UA); 193 reg_val = (cur_ua - SGM4154X_TERMCHRG_I_MIN_UA) / SGM4154X_TERMCHRG_CURRENT_STEP_UA; 194 195 ret = regmap_update_bits(sgm->regmap, 196 SGM4154X_CHRG_CTRL_3, 197 SGM4154X_TERMCHRG_CUR_MASK, 198 reg_val); 199 if (ret) 200 dev_err(sgm->dev, "set term current error!\n"); 201 202 return ret; 203 } 204 205 static int sgm4154x_set_prechrg_curr(struct sgm4154x_device *sgm, int cur_ua) 206 { 207 int reg_val; 208 int ret; 209 210 cur_ua = clamp(cur_ua, SGM4154X_PRECHRG_I_MIN_UA, SGM4154X_PRECHRG_I_MAX_UA); 211 reg_val = (cur_ua - SGM4154X_PRECHRG_I_MIN_UA) / SGM4154X_PRECHRG_CURRENT_STEP_UA; 212 213 reg_val = FIELD_PREP(SGM4154X_PRECHRG_CUR_MASK, reg_val); 214 ret = regmap_update_bits(sgm->regmap, 215 SGM4154X_CHRG_CTRL_3, 216 SGM4154X_PRECHRG_CUR_MASK, 217 reg_val); 218 if (ret) 219 dev_err(sgm->dev, "set precharge current error!\n"); 220 221 return ret; 222 } 223 224 static int sgm4154x_set_ichrg_curr(struct sgm4154x_device *sgm, int cur_ua) 225 { 226 int reg_val; 227 int ret; 228 229 cur_ua = clamp(cur_ua, SGM4154X_ICHRG_I_MIN_UA, sgm->init_data.max_ichg); 230 reg_val = cur_ua / SGM4154X_ICHRG_I_STEP_UA; 231 232 ret = regmap_update_bits(sgm->regmap, 233 SGM4154X_CHRG_CTRL_2, 234 SGM4154X_ICHRG_CUR_MASK, 235 reg_val); 236 if (ret) 237 dev_err(sgm->dev, "set icharge current error!\n"); 238 239 return ret; 240 } 241 242 static int sgm4154x_get_ichrg_curr(struct sgm4154x_device *sgm) 243 { 244 u32 reg; 245 int ret, val; 246 247 ret = regmap_read(sgm->regmap, SGM4154X_CHRG_CTRL_2, ®); 248 if (ret) { 249 dev_err(sgm->dev, "get charge current error!\n"); 250 return ret; 251 } 252 253 val = FIELD_GET(SGM4154X_ICHRG_CUR_MASK, reg); 254 255 return val * SGM4154X_ICHRG_I_STEP_UA; 256 } 257 258 static int sgm4154x_set_chrg_volt(struct sgm4154x_device *sgm, int chrg_volt) 259 { 260 int reg_val; 261 int ret; 262 263 /* 264 * Note that the value of 0x01111 represents a "special value" 265 * corresponding to 4352000uV instead of the expected 4336000uV, 266 * per the datasheet. All other values are as expected. So not 267 * only do we need to clamp between max and min values, but 268 * also clamp anything below 4352000uv to 4304000uv to prevent 269 * overcharging. 270 */ 271 chrg_volt = clamp(chrg_volt, SGM4154X_VREG_V_MIN_UV, sgm->init_data.max_vreg); 272 if (chrg_volt < 4352000) 273 chrg_volt = clamp(chrg_volt, SGM4154X_VREG_V_MIN_UV, 4304000); 274 reg_val = (chrg_volt - SGM4154X_VREG_V_MIN_UV) / SGM4154X_VREG_V_STEP_UV; 275 reg_val = FIELD_PREP(SGM4154X_VREG_V_MASK, reg_val); 276 ret = regmap_update_bits(sgm->regmap, 277 SGM4154X_CHRG_CTRL_4, 278 SGM4154X_VREG_V_MASK, 279 reg_val); 280 if (ret) 281 dev_err(sgm->dev, "set charge voltage error!\n"); 282 283 return ret; 284 } 285 286 static int sgm4154x_get_chrg_volt(struct sgm4154x_device *sgm) 287 { 288 u32 reg; 289 int ret, val; 290 291 ret = regmap_read(sgm->regmap, SGM4154X_CHRG_CTRL_4, ®); 292 if (ret) { 293 dev_err(sgm->dev, "get charge voltage error!\n"); 294 return ret; 295 } 296 297 val = FIELD_GET(SGM4154X_VREG_V_MASK, reg); 298 299 /* 300 * 0x01111 is a special value meaning 4352000uV, all other 301 * values are as expected based on the offset and step values. 302 */ 303 if (val == 0x0f) 304 return 4352000; 305 306 return val * SGM4154X_VREG_V_STEP_UV + SGM4154X_VREG_V_MIN_UV; 307 } 308 309 static int sgm4154x_set_input_volt_lim(struct sgm4154x_device *sgm, 310 unsigned int vindpm) 311 { 312 enum SGM4154X_VINDPM_OS os_val; 313 unsigned int offset; 314 u8 reg_val; 315 int ret; 316 317 318 if (vindpm < SGM4154X_VINDPM_V_MIN_UV || 319 vindpm > SGM4154X_VINDPM_V_MAX_UV) { 320 dev_err(sgm->dev, "input voltage limit %u outside range\n", vindpm); 321 return -EINVAL; 322 } 323 324 /* 325 * Supported ranges per the datasheet are as follows: 326 * 3.9v - 5.4v with a 3.9v offset 327 * 5.9v - 7.4v with a 5.9v offset 328 * 7.5v - 9.0v with a 7.5v offset 329 * 10.5v - 12.0v with a 10.5v offset 330 * Step size is a constant 100mv 331 */ 332 if (vindpm < 5900000) { 333 offset = 3900000; 334 vindpm = clamp(vindpm, offset, 5400000); 335 os_val = VINDPM_OS_3900MV; 336 } else if (vindpm < 7500000) { 337 offset = 5900000; 338 vindpm = clamp(vindpm, offset, 7400000); 339 os_val = VINDPM_OS_5900MV; 340 } else if (vindpm < 10500000) { 341 offset = 7500000; 342 vindpm = clamp(vindpm, offset, 9000000); 343 os_val = VINDPM_OS_7500MV; 344 } else { 345 offset = 10500000; 346 vindpm = clamp(vindpm, offset, 12000000); 347 os_val = VINDPM_OS_10500MV; 348 } 349 350 ret = regmap_update_bits(sgm->regmap, 351 SGM4154X_CHRG_CTRL_F, 352 SGM4154X_VINDPM_OS_MASK, 353 os_val); 354 if (ret) { 355 dev_err(sgm->dev, "set vin dpm error!\n"); 356 return ret; 357 } 358 359 reg_val = (vindpm - offset) / SGM4154X_VINDPM_STEP_UV; 360 361 ret = regmap_update_bits(sgm->regmap, SGM4154X_CHRG_CTRL_6, 362 SGM4154X_VINDPM_V_MASK, reg_val); 363 if (ret) 364 dev_err(sgm->dev, "input voltage error!\n"); 365 366 return ret; 367 } 368 369 static int sgm4154x_set_input_curr_lim(struct sgm4154x_device *sgm, int iindpm) 370 { 371 int reg_val; 372 int ret; 373 374 if (iindpm < SGM4154X_IINDPM_I_MIN_UA) 375 return -EINVAL; 376 377 /* 378 * Protect against a timing-issue edge case if a sysfs write occurs in the middle 379 * of a probe (very unlikely). 380 */ 381 if (sgm->init_data.ilim < SGM4154X_IINDPM_I_MIN_UA) 382 return -EINVAL; 383 384 /* 385 * Per the datasheet, values between 100000uA and 3100000uA work 386 * as expected with the register defined as having a step of 387 * 100000 and a min/max of 100000 (0x00) through 3100000 (0x1e). 388 * The register value of 0x1f however corresponds to 3800000uA not 389 * 3200000uA as one would expect. 390 */ 391 if ((iindpm > SGM4154X_IINDPM_I_MAX_UA) || (iindpm > sgm->init_data.ilim)) 392 iindpm = min(SGM4154X_IINDPM_I_MAX_UA, sgm->init_data.ilim); 393 394 if (iindpm > 3100000 && iindpm < SGM4154X_IINDPM_I_MAX_UA) 395 iindpm = 3100000; 396 397 if (iindpm == SGM4154X_IINDPM_I_MAX_UA) 398 reg_val = 0x1f; 399 else 400 reg_val = (iindpm - SGM4154X_IINDPM_I_MIN_UA) / SGM4154X_IINDPM_STEP_UA; 401 402 ret = regmap_update_bits(sgm->regmap, 403 SGM4154X_CHRG_CTRL_0, 404 SGM4154X_IINDPM_I_MASK, 405 reg_val); 406 if (ret) 407 dev_err(sgm->dev, "set input current limit error!\n"); 408 409 return ret; 410 } 411 412 static int sgm4154x_get_input_curr_lim(struct sgm4154x_device *sgm) 413 { 414 int ret; 415 int ilim; 416 417 ret = regmap_read(sgm->regmap, SGM4154X_CHRG_CTRL_0, &ilim); 418 if (ret) { 419 dev_err(sgm->dev, "get input current limit error!\n"); 420 return ret; 421 } 422 423 ilim &= SGM4154X_IINDPM_I_MASK; 424 425 /* Max value is not 3200000uA as expected but is 3800000uA */ 426 if (ilim == SGM4154X_IINDPM_I_MASK) 427 return SGM4154X_IINDPM_I_MAX_UA; 428 429 ilim = ilim * SGM4154X_IINDPM_STEP_UA + SGM4154X_IINDPM_I_MIN_UA; 430 431 return ilim; 432 } 433 434 static int sgm4154x_watchdog_timer_reset(struct sgm4154x_device *sgm) 435 { 436 int ret; 437 438 ret = regmap_update_bits(sgm->regmap, 439 SGM4154X_CHRG_CTRL_1, 440 SGM4154X_WDT_RST, 441 SGM4154X_WDT_RST); 442 443 if (ret) 444 dev_err(sgm->dev, "set watchdog timer error!\n"); 445 446 return ret; 447 } 448 449 static int sgm4154x_set_watchdog_timer(struct sgm4154x_device *sgm, u8 time) 450 { 451 int ret; 452 453 if (time > SGM4154X_WDT_TIMER_160S) 454 return -EINVAL; 455 456 time = FIELD_PREP(SGM4154X_WDT_TIMER_MASK, time); 457 ret = regmap_update_bits(sgm->regmap, 458 SGM4154X_CHRG_CTRL_5, 459 SGM4154X_WDT_TIMER_MASK, 460 time); 461 462 if (ret) { 463 dev_err(sgm->dev, "set watchdog timer error!\n"); 464 return ret; 465 } 466 467 if (time) { 468 if (!sgm->watchdog_enable) 469 queue_delayed_work(sgm->sgm_monitor_wq, 470 &sgm->sgm_delay_work, 471 msecs_to_jiffies(1000 * 5)); 472 sgm->watchdog_enable = true; 473 } else { 474 sgm->watchdog_enable = false; 475 sgm4154x_watchdog_timer_reset(sgm); 476 } 477 478 return ret; 479 } 480 481 static int sgm4154x_enable_charger(struct sgm4154x_device *sgm) 482 { 483 int ret; 484 485 ret = regmap_update_bits(sgm->regmap, 486 SGM4154X_CHRG_CTRL_1, 487 SGM4154X_CHRG_EN, 488 SGM4154X_CHRG_EN); 489 if (ret) 490 dev_err(sgm->dev, "enable charger error!\n"); 491 492 return ret; 493 } 494 495 static int sgm4154x_disable_charger(struct sgm4154x_device *sgm) 496 { 497 int ret; 498 499 ret = regmap_update_bits(sgm->regmap, 500 SGM4154X_CHRG_CTRL_1, 501 SGM4154X_CHRG_EN, 502 0); 503 if (ret) 504 dev_err(sgm->dev, "disable charger error!\n"); 505 506 return ret; 507 } 508 509 static int sgm4154x_set_vac_ovp(struct sgm4154x_device *sgm) 510 { 511 int reg_val; 512 int ret; 513 514 reg_val = SGM4154X_OVP_DEFAULT & SGM4154X_VAC_OVP_MASK; 515 516 ret = regmap_update_bits(sgm->regmap, 517 SGM4154X_CHRG_CTRL_6, 518 SGM4154X_VAC_OVP_MASK, 519 reg_val); 520 if (ret) 521 dev_err(sgm->dev, "set vac ovp error!\n"); 522 523 return ret; 524 } 525 526 static int sgm4154x_set_recharge_volt_ua(struct sgm4154x_device *sgm, int recharge_volt) 527 { 528 int reg_val; 529 int ret; 530 531 reg_val = (recharge_volt - SGM4154X_VRECHRG_OFFSET_UV) / SGM4154X_VRECHRG_STEP_UV; 532 533 ret = regmap_update_bits(sgm->regmap, 534 SGM4154X_CHRG_CTRL_4, 535 SGM4154X_VRECHARGE, 536 reg_val); 537 if (ret) 538 dev_err(sgm->dev, "set recharger error!\n"); 539 540 return ret; 541 } 542 543 static int sgm4154x_get_state(struct sgm4154x_device *sgm, 544 struct sgm4154x_state *state) 545 { 546 unsigned int reg; 547 int ret; 548 549 ret = regmap_read(sgm->regmap, SGM4154X_CHRG_STAT, ®); 550 if (ret) { 551 dev_err(sgm->dev, "read SGM4154X_CHRG_STAT fail\n"); 552 return ret; 553 } 554 state->chrg_type = reg & SGM4154X_VBUS_STAT_MASK; 555 state->chrg_stat = reg & SGM4154X_CHG_STAT_MASK; 556 state->online = !!(reg & SGM4154X_PG_STAT); 557 state->therm_stat = !!(reg & SGM4154X_THERM_STAT); 558 state->vsys_stat = !!(reg & SGM4154X_VSYS_STAT); 559 560 ret = regmap_read(sgm->regmap, SGM4154X_CHRG_FAULT, ®); 561 if (ret) { 562 dev_err(sgm->dev, "read SGM4154X_CHRG_FAULT fail\n"); 563 return ret; 564 } 565 state->chrg_fault = reg; 566 state->ntc_fault = reg & SGM4154X_TEMP_MASK; 567 state->health = state->ntc_fault; 568 569 ret = regmap_read(sgm->regmap, SGM4154X_CHRG_CTRL_A, ®); 570 if (ret) { 571 dev_err(sgm->dev, "read SGM4154X_CHRG_CTRL_A fail\n"); 572 return ret; 573 } 574 state->vbus_gd = !!(reg & SGM4154X_VBUS_GOOD); 575 576 return ret; 577 } 578 579 static int sgm4154x_property_is_writeable(struct power_supply *psy, 580 enum power_supply_property prop) 581 { 582 switch (prop) { 583 case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT: 584 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE: 585 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT: 586 case POWER_SUPPLY_PROP_ONLINE: 587 return true; 588 default: 589 return false; 590 } 591 } 592 593 static int sgm4154x_charger_set_property(struct power_supply *psy, 594 enum power_supply_property prop, 595 const union power_supply_propval *val) 596 { 597 struct sgm4154x_device *sgm = power_supply_get_drvdata(psy); 598 int ret = -EINVAL; 599 600 guard(mutex)(&sgm->lock); 601 602 switch (prop) { 603 case POWER_SUPPLY_PROP_ONLINE: 604 if (val->intval) { 605 ret = sgm4154x_enable_charger(sgm); 606 sgm4154x_set_watchdog_timer(sgm, SGM4154X_WDT_TIMER_40S); 607 } else { 608 sgm4154x_set_watchdog_timer(sgm, SGM4154X_WDT_TIMER_DISABLE); 609 ret = sgm4154x_disable_charger(sgm); 610 } 611 break; 612 613 case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT: 614 ret = sgm4154x_set_input_curr_lim(sgm, val->intval); 615 break; 616 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT: 617 ret = sgm4154x_set_ichrg_curr(sgm, val->intval); 618 break; 619 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE: 620 ret = sgm4154x_set_chrg_volt(sgm, val->intval); 621 break; 622 623 default: 624 return -EINVAL; 625 } 626 627 return ret; 628 } 629 630 static int sgm4154x_charger_get_property(struct power_supply *psy, 631 enum power_supply_property psp, 632 union power_supply_propval *val) 633 { 634 struct sgm4154x_device *sgm = power_supply_get_drvdata(psy); 635 struct sgm4154x_state state; 636 int ret; 637 638 scoped_guard(mutex, &sgm->lock) { 639 ret = sgm4154x_get_state(sgm, &state); 640 if (ret) { 641 dev_err(sgm->dev, "get state error!\n"); 642 return ret; 643 } 644 sgm->state = state; 645 } 646 647 switch (psp) { 648 case POWER_SUPPLY_PROP_STATUS: 649 if (!state.chrg_type || (state.chrg_type == SGM4154X_OTG_MODE)) 650 val->intval = POWER_SUPPLY_STATUS_DISCHARGING; 651 else if (!state.chrg_stat) 652 val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING; 653 else if (state.chrg_stat == SGM4154X_TERM_CHRG) 654 val->intval = POWER_SUPPLY_STATUS_FULL; 655 else 656 val->intval = POWER_SUPPLY_STATUS_CHARGING; 657 break; 658 case POWER_SUPPLY_PROP_CHARGE_TYPE: 659 switch (state.chrg_stat) { 660 case SGM4154X_PRECHRG: 661 val->intval = POWER_SUPPLY_CHARGE_TYPE_TRICKLE; 662 break; 663 case SGM4154X_FAST_CHRG: 664 val->intval = POWER_SUPPLY_CHARGE_TYPE_FAST; 665 break; 666 case SGM4154X_TERM_CHRG: 667 val->intval = POWER_SUPPLY_CHARGE_TYPE_TRICKLE; 668 break; 669 case SGM4154X_NOT_CHRGING: 670 val->intval = POWER_SUPPLY_CHARGE_TYPE_NONE; 671 break; 672 default: 673 val->intval = POWER_SUPPLY_CHARGE_TYPE_UNKNOWN; 674 } 675 break; 676 case POWER_SUPPLY_PROP_MANUFACTURER: 677 val->strval = SGM4154X_MANUFACTURER; 678 break; 679 680 case POWER_SUPPLY_PROP_MODEL_NAME: 681 val->strval = SGM4154X_NAME; 682 break; 683 684 case POWER_SUPPLY_PROP_ONLINE: 685 val->intval = state.online; 686 break; 687 case POWER_SUPPLY_PROP_PRESENT: 688 val->intval = state.vbus_gd; 689 break; 690 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE: 691 val->intval = sgm4154x_get_chrg_volt(sgm); 692 if (val->intval < 0) 693 return -EINVAL; 694 break; 695 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT: 696 val->intval = sgm4154x_get_ichrg_curr(sgm); 697 if (val->intval < 0) 698 return -EINVAL; 699 break; 700 case POWER_SUPPLY_PROP_INPUT_VOLTAGE_LIMIT: 701 val->intval = sgm->init_data.vlim; 702 break; 703 case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT: 704 val->intval = sgm4154x_get_input_curr_lim(sgm); 705 if (val->intval < 0) 706 return -EINVAL; 707 break; 708 default: 709 return -EINVAL; 710 } 711 712 return ret; 713 } 714 715 static irqreturn_t sgm4154x_irq_handler_thread(int irq, void *private) 716 { 717 struct sgm4154x_device *sgm = private; 718 struct sgm4154x_state oldstate, state; 719 int ret; 720 721 guard(mutex)(&sgm->lock); 722 723 oldstate = sgm->state; 724 725 ret = sgm4154x_get_state(sgm, &state); 726 if (ret) { 727 dev_err(sgm->dev, "get state error!\n"); 728 return IRQ_NONE; 729 } 730 731 sgm->state = state; 732 733 if (state.vbus_gd && !oldstate.vbus_gd) { 734 if (sgm->init_data.ilim >= SGM4154X_DEFAULT_INPUT_CUR) { 735 ret = sgm4154x_set_input_curr_lim(sgm, sgm->init_data.ilim); 736 if (ret) { 737 dev_err(sgm->dev, "set input current error!\n"); 738 /* 739 * Reading IRQ clears interrupt, so return handled 740 * even if error. 741 */ 742 } 743 } 744 } 745 746 power_supply_changed(sgm->charger); 747 748 return IRQ_HANDLED; 749 } 750 751 static int sgm4154x_hw_init(struct power_supply *psy) 752 { 753 struct sgm4154x_device *sgm = power_supply_get_drvdata(psy); 754 struct power_supply_battery_info *bat_info; 755 int ret; 756 u32 val; 757 758 /* 759 * If unable to read devicetree info, use default/reset 760 * values from hardware. If the devicetree info has data out 761 * of range for any of the values, use the default value. 762 */ 763 sgm->init_data.iprechg = SGM4154X_PRECHRG_I_DEF_UA; 764 sgm->init_data.iterm = SGM4154X_TERMCHRG_I_DEF_UA; 765 sgm->init_data.max_ichg = SGM4154X_ICHRG_I_DEF_UA; 766 sgm->init_data.max_vreg = SGM4154X_VREG_V_DEF_UV; 767 sgm->init_data.vlim = SGM4154X_VINDPM_DEF_UV; 768 sgm->init_data.ilim = SGM4154X_IINDPM_DEF_UA; 769 770 ret = power_supply_get_battery_info(psy, &bat_info); 771 if (ret) 772 dev_warn(sgm->dev, "sgm4154x: cannot read battery info\n"); 773 else { 774 if ((bat_info->constant_charge_current_max_ua >= SGM4154X_ICHRG_I_MIN_UA) && 775 (bat_info->constant_charge_current_max_ua <= SGM4154X_ICHRG_I_MAX_UA)) 776 sgm->init_data.max_ichg = bat_info->constant_charge_current_max_ua; 777 if ((bat_info->constant_charge_voltage_max_uv >= SGM4154X_VREG_V_MIN_UV) && 778 (bat_info->constant_charge_voltage_max_uv <= SGM4154X_VREG_V_MAX_UV)) 779 sgm->init_data.max_vreg = bat_info->constant_charge_voltage_max_uv; 780 if ((bat_info->charge_term_current_ua >= SGM4154X_TERMCHRG_I_MIN_UA) && 781 (bat_info->charge_term_current_ua <= SGM4154X_TERMCHRG_I_MAX_UA)) 782 sgm->init_data.iterm = bat_info->charge_term_current_ua; 783 if ((bat_info->precharge_current_ua >= SGM4154X_PRECHRG_I_MIN_UA) && 784 (bat_info->precharge_current_ua <= SGM4154X_PRECHRG_I_MAX_UA)) 785 sgm->init_data.iprechg = bat_info->precharge_current_ua; 786 787 power_supply_put_battery_info(psy, bat_info); 788 } 789 790 ret = device_property_read_u32(sgm->dev, 791 "input-voltage-limit-microvolt", 792 &val); 793 if (!ret) 794 sgm->init_data.vlim = clamp(val, SGM4154X_VINDPM_V_MIN_UV, 795 SGM4154X_VINDPM_V_MAX_UV); 796 797 ret = device_property_read_u32(sgm->dev, 798 "input-current-limit-microamp", 799 &val); 800 if (!ret) 801 sgm->init_data.ilim = clamp(val, SGM4154X_IINDPM_I_MIN_UA, 802 SGM4154X_IINDPM_I_MAX_UA); 803 804 ret = sgm4154x_set_watchdog_timer(sgm, SGM4154X_WDT_TIMER_DISABLE); 805 if (ret) 806 return ret; 807 808 ret = sgm4154x_set_prechrg_curr(sgm, sgm->init_data.iprechg); 809 if (ret) 810 return ret; 811 812 ret = sgm4154x_set_chrg_volt(sgm, sgm->init_data.max_vreg); 813 if (ret) 814 return ret; 815 816 ret = sgm4154x_set_term_curr(sgm, sgm->init_data.iterm); 817 if (ret) 818 return ret; 819 820 ret = sgm4154x_set_ichrg_curr(sgm, sgm->init_data.max_ichg); 821 if (ret) 822 return ret; 823 824 ret = sgm4154x_set_input_volt_lim(sgm, sgm->init_data.vlim); 825 if (ret) 826 return ret; 827 828 ret = sgm4154x_set_input_curr_lim(sgm, sgm->init_data.ilim); 829 if (ret) 830 return ret; 831 832 ret = sgm4154x_set_vac_ovp(sgm); 833 if (ret) 834 return ret; 835 836 ret = regmap_update_bits(sgm->regmap, 837 SGM4154X_CHRG_CTRL_D, 838 SGM4154X_JEITA_EN, 839 0); 840 if (ret) 841 return ret; 842 843 ret = regmap_update_bits(sgm->regmap, 844 SGM4154X_CHRG_CTRL_A, 845 SGM4154X_IINDPM_INT_MASK, 846 SGM4154X_IINDPM_INT_MASK); 847 if (ret) 848 return ret; 849 850 ret = regmap_update_bits(sgm->regmap, 851 SGM4154X_CHRG_CTRL_A, 852 SGM4154X_VINDPM_INT_MASK, 853 SGM4154X_VINDPM_INT_MASK); 854 if (ret) 855 return ret; 856 857 /* 858 * Recharge microvolt set to 200000 by BSP driver instead of hardware 859 * default value of 100000. 860 */ 861 ret = sgm4154x_set_recharge_volt_ua(sgm, 200000); 862 863 return ret; 864 } 865 866 static enum power_supply_property sgm4154x_power_supply_props[] = { 867 POWER_SUPPLY_PROP_MANUFACTURER, 868 POWER_SUPPLY_PROP_MODEL_NAME, 869 POWER_SUPPLY_PROP_STATUS, 870 POWER_SUPPLY_PROP_ONLINE, 871 POWER_SUPPLY_PROP_INPUT_VOLTAGE_LIMIT, 872 POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT, 873 POWER_SUPPLY_PROP_CHARGE_TYPE, 874 POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE, 875 POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT, 876 POWER_SUPPLY_PROP_PRESENT 877 }; 878 879 static struct power_supply_desc sgm4154x_power_supply_desc = { 880 .name = "sgm4154x-charger", 881 .type = POWER_SUPPLY_TYPE_USB, 882 .init = sgm4154x_hw_init, 883 .properties = sgm4154x_power_supply_props, 884 .num_properties = ARRAY_SIZE(sgm4154x_power_supply_props), 885 .get_property = sgm4154x_charger_get_property, 886 .set_property = sgm4154x_charger_set_property, 887 .property_is_writeable = sgm4154x_property_is_writeable, 888 }; 889 890 static const struct regmap_config sgm4154x_regmap_config = { 891 .reg_bits = 8, 892 .val_bits = 8, 893 .max_register = SGM4154X_CHRG_CTRL_F, 894 .cache_type = REGCACHE_NONE, 895 }; 896 897 static const u32 sgm4154x_chg_otg_cur_ua[] = { 898 1200000, 2000000, 899 }; 900 901 static const struct regulator_ops sgm4154x_vbus_ops = { 902 .list_voltage = regulator_list_voltage_linear, 903 .enable = regulator_enable_regmap, 904 .disable = regulator_disable_regmap, 905 .is_enabled = regulator_is_enabled_regmap, 906 .set_voltage_sel = regulator_set_voltage_sel_regmap, 907 .get_voltage_sel = regulator_get_voltage_sel_regmap, 908 .set_current_limit = regulator_set_current_limit_regmap, 909 .get_current_limit = regulator_get_current_limit_regmap, 910 }; 911 912 static const struct regulator_desc sgm4154x_otg_rdesc = { 913 .of_match = "otg-vbus", 914 .name = "otg-vbus", 915 .regulators_node = of_match_ptr("regulators"), 916 .ops = &sgm4154x_vbus_ops, 917 .owner = THIS_MODULE, 918 .type = REGULATOR_VOLTAGE, 919 .min_uV = 4850000, 920 .uV_step = 150000, 921 .n_voltages = 4, 922 .vsel_reg = SGM4154X_CHRG_CTRL_6, 923 .vsel_mask = SGM4154X_BOOSTV, 924 .enable_reg = SGM4154X_CHRG_CTRL_1, 925 .enable_mask = SGM4154X_OTG_EN, 926 .curr_table = sgm4154x_chg_otg_cur_ua, 927 .n_current_limits = ARRAY_SIZE(sgm4154x_chg_otg_cur_ua), 928 .csel_reg = SGM4154X_CHRG_CTRL_2, 929 .csel_mask = SGM4154X_BOOST_LIM, 930 }; 931 932 static int sgm4154x_vbus_regulator_register(struct sgm4154x_device *sgm) 933 { 934 struct regulator_config config = { 935 .dev = sgm->dev, 936 .regmap = sgm->regmap, 937 .driver_data = sgm, 938 }; 939 940 sgm->otg_rdev = devm_regulator_register(sgm->dev, 941 &sgm4154x_otg_rdesc, 942 &config); 943 944 return PTR_ERR_OR_ZERO(sgm->otg_rdev); 945 } 946 947 static int sgm4154x_hw_chipid_detect(struct sgm4154x_device *sgm) 948 { 949 int ret; 950 int val; 951 952 ret = regmap_read(sgm->regmap, SGM4154X_CHRG_CTRL_B, &val); 953 if (ret) 954 return ret; 955 956 if ((val & SGM4154X_PN_MASK) != SGM4154X_PN_ID) 957 dev_warn(sgm->dev, "sgm4154x device ID mismatch\n"); 958 959 return 0; 960 } 961 962 static void sgm_charger_work(struct work_struct *work) 963 { 964 struct sgm4154x_device *sgm = 965 container_of(work, 966 struct sgm4154x_device, 967 sgm_delay_work.work); 968 969 sgm4154x_watchdog_timer_reset(sgm); 970 if (sgm->watchdog_enable) 971 queue_delayed_work(sgm->sgm_monitor_wq, 972 &sgm->sgm_delay_work, 973 msecs_to_jiffies(1000 * 5)); 974 } 975 976 static void sgm4154x_disable_irq_wake(void *data) 977 { 978 struct sgm4154x_device *sgm = data; 979 struct i2c_client *client = to_i2c_client(sgm->dev); 980 981 disable_irq_wake(client->irq); 982 } 983 984 static int sgm4154x_probe(struct i2c_client *client) 985 { 986 struct power_supply_config psy_cfg = {}; 987 struct device *dev = &client->dev; 988 struct sgm4154x_device *sgm; 989 int ret; 990 991 sgm = devm_kzalloc(dev, sizeof(*sgm), GFP_KERNEL); 992 if (!sgm) 993 return -ENOMEM; 994 995 sgm->dev = dev; 996 997 sgm->regmap = devm_regmap_init_i2c(client, &sgm4154x_regmap_config); 998 if (IS_ERR(sgm->regmap)) 999 return dev_err_probe(dev, PTR_ERR(sgm->regmap), 1000 "Failed to allocate register map\n"); 1001 1002 i2c_set_clientdata(client, sgm); 1003 1004 ret = devm_mutex_init(dev, &sgm->lock); 1005 if (ret) 1006 return ret; 1007 1008 ret = sgm4154x_hw_chipid_detect(sgm); 1009 if (ret) 1010 return dev_err_probe(dev, ret, "Unable to read HW ID\n"); 1011 1012 devm_device_init_wakeup(dev); 1013 1014 sgm->sgm_monitor_wq = devm_alloc_ordered_workqueue(dev, "sgm-monitor-wq", 1015 WQ_MEM_RECLAIM | WQ_FREEZABLE); 1016 if (!sgm->sgm_monitor_wq) 1017 return -EINVAL; 1018 1019 ret = devm_delayed_work_autocancel(dev, &sgm->sgm_delay_work, 1020 sgm_charger_work); 1021 if (ret) 1022 return dev_err_probe(dev, ret, "Unable to register delayed work\n"); 1023 1024 psy_cfg.drv_data = sgm; 1025 psy_cfg.fwnode = dev_fwnode(dev); 1026 1027 sgm->charger = devm_power_supply_register(sgm->dev, 1028 &sgm4154x_power_supply_desc, 1029 &psy_cfg); 1030 if (IS_ERR(sgm->charger)) 1031 return dev_err_probe(dev, PTR_ERR(sgm->charger), 1032 "Failed to register power supply\n"); 1033 1034 if (client->irq) { 1035 ret = devm_request_threaded_irq(dev, client->irq, NULL, 1036 sgm4154x_irq_handler_thread, 1037 IRQF_TRIGGER_FALLING | 1038 IRQF_ONESHOT, 1039 "sgm41542-irq", sgm); 1040 if (ret) 1041 return ret; 1042 1043 ret = enable_irq_wake(client->irq); 1044 if (!ret) { 1045 ret = devm_add_action_or_reset(dev, sgm4154x_disable_irq_wake, sgm); 1046 if (ret) 1047 return ret; 1048 } 1049 } 1050 1051 ret = sgm4154x_vbus_regulator_register(sgm); 1052 if (ret) { 1053 return dev_err_probe(dev, ret, 1054 "Unable to register VBUS regulator\n"); 1055 } 1056 1057 return 0; 1058 } 1059 1060 static int __maybe_unused sgm4154x_suspend(struct device *dev) 1061 { 1062 struct i2c_client *client = to_i2c_client(dev); 1063 struct sgm4154x_device *sgm = i2c_get_clientdata(client); 1064 bool watchdog = sgm->watchdog_enable; 1065 int ret; 1066 1067 /* 1068 * Disable watchdog during suspend and stop delayed work. When 1069 * delayed work is restarted after resume watchdog will be 1070 * re-enabled if it was previously enabled. Retain the current 1071 * state of the watchdog timer though, so it can be re-enabled 1072 * if necessary by the work queue once resume is triggered. 1073 */ 1074 ret = sgm4154x_set_watchdog_timer(sgm, SGM4154X_WDT_TIMER_DISABLE); 1075 if (ret) 1076 return ret; 1077 cancel_delayed_work_sync(&sgm->sgm_delay_work); 1078 sgm->watchdog_enable = watchdog; 1079 return 0; 1080 } 1081 1082 static int __maybe_unused sgm4154x_resume(struct device *dev) 1083 { 1084 struct i2c_client *client = to_i2c_client(dev); 1085 struct sgm4154x_device *sgm = i2c_get_clientdata(client); 1086 int ret; 1087 1088 if (sgm->watchdog_enable) { 1089 ret = sgm4154x_set_watchdog_timer(sgm, SGM4154X_WDT_TIMER_40S); 1090 if (ret) 1091 return ret; 1092 } 1093 1094 queue_delayed_work(sgm->sgm_monitor_wq, 1095 &sgm->sgm_delay_work, 0); 1096 return 0; 1097 } 1098 1099 static SIMPLE_DEV_PM_OPS(sgm4154x_pm_ops, sgm4154x_suspend, sgm4154x_resume); 1100 1101 static const struct i2c_device_id sgm4154x_i2c_ids[] = { 1102 { "sgm41542" }, 1103 { }, 1104 }; 1105 MODULE_DEVICE_TABLE(i2c, sgm4154x_i2c_ids); 1106 1107 static const struct of_device_id sgm4154x_of_match[] = { 1108 { .compatible = "sgmicro,sgm41542", }, 1109 { }, 1110 }; 1111 MODULE_DEVICE_TABLE(of, sgm4154x_of_match); 1112 1113 static struct i2c_driver sgm4154x_driver = { 1114 .driver = { 1115 .name = "sgm4154x-charger", 1116 .of_match_table = sgm4154x_of_match, 1117 .pm = &sgm4154x_pm_ops, 1118 }, 1119 .probe = sgm4154x_probe, 1120 .id_table = sgm4154x_i2c_ids, 1121 }; 1122 1123 module_i2c_driver(sgm4154x_driver); 1124 1125 MODULE_AUTHOR("Xu Shengfei <xsf@rock-chips.com>"); 1126 MODULE_DESCRIPTION("sgm4154x charger driver"); 1127 MODULE_LICENSE("GPL"); 1128