1 // SPDX-License-Identifier: GPL-2.0 2 // 3 // Copyright (C) 2021 Samuel Holland <samuel@sholland.org> 4 5 #include <linux/i2c.h> 6 #include <linux/module.h> 7 #include <linux/power_supply.h> 8 #include <linux/regmap.h> 9 10 #define IP5XXX_SYS_CTL0 0x01 11 #define IP5XXX_SYS_CTL0_WLED_DET_EN BIT(4) 12 #define IP5XXX_SYS_CTL0_WLED_EN BIT(3) 13 #define IP5XXX_SYS_CTL0_BOOST_EN BIT(2) 14 #define IP5XXX_SYS_CTL0_CHARGER_EN BIT(1) 15 #define IP5XXX_SYS_CTL1 0x02 16 #define IP5XXX_SYS_CTL1_LIGHT_SHDN_EN BIT(1) 17 #define IP5XXX_SYS_CTL1_LOAD_PWRUP_EN BIT(0) 18 #define IP5XXX_SYS_CTL2 0x0c 19 #define IP5XXX_SYS_CTL2_LIGHT_SHDN_TH GENMASK(7, 3) 20 #define IP5XXX_SYS_CTL3 0x03 21 #define IP5XXX_SYS_CTL3_LONG_PRESS_TIME_SEL GENMASK(7, 6) 22 #define IP5XXX_SYS_CTL3_BTN_SHDN_EN BIT(5) 23 #define IP5XXX_SYS_CTL4 0x04 24 #define IP5XXX_SYS_CTL4_SHDN_TIME_SEL GENMASK(7, 6) 25 #define IP5XXX_SYS_CTL4_VIN_PULLOUT_BOOST_EN BIT(5) 26 #define IP5XXX_SYS_CTL5 0x07 27 #define IP5XXX_SYS_CTL5_NTC_DIS BIT(6) 28 #define IP5XXX_SYS_CTL5_WLED_MODE_SEL BIT(1) 29 #define IP5XXX_SYS_CTL5_BTN_SHDN_SEL BIT(0) 30 #define IP5XXX_CHG_CTL1 0x22 31 #define IP5XXX_CHG_CTL1_BOOST_UVP_SEL GENMASK(3, 2) 32 #define IP5XXX_CHG_CTL2 0x24 33 #define IP5XXX_CHG_CTL2_BAT_TYPE_SEL GENMASK(6, 5) 34 #define IP5XXX_CHG_CTL2_BAT_TYPE_SEL_4_2V (0x0 << 5) 35 #define IP5XXX_CHG_CTL2_BAT_TYPE_SEL_4_3V (0x1 << 5) 36 #define IP5XXX_CHG_CTL2_BAT_TYPE_SEL_4_35V (0x2 << 5) 37 #define IP5XXX_CHG_CTL2_CONST_VOLT_SEL GENMASK(2, 1) 38 #define IP5XXX_CHG_CTL4 0x26 39 #define IP5XXX_CHG_CTL4_BAT_TYPE_SEL_EN BIT(6) 40 #define IP5XXX_CHG_CTL4A 0x25 41 #define IP5XXX_CHG_CTL4A_CONST_CUR_SEL GENMASK(4, 0) 42 #define IP5XXX_MFP_CTL0 0x51 43 #define IP5XXX_MFP_CTL1 0x52 44 #define IP5XXX_GPIO_CTL2 0x53 45 #define IP5XXX_GPIO_CTL2A 0x54 46 #define IP5XXX_GPIO_CTL3 0x55 47 #define IP5XXX_READ0 0x71 48 #define IP5XXX_READ0_CHG_STAT GENMASK(7, 5) 49 #define IP5XXX_READ0_CHG_STAT_IDLE (0x0 << 5) 50 #define IP5XXX_READ0_CHG_STAT_TRICKLE (0x1 << 5) 51 #define IP5XXX_READ0_CHG_STAT_CONST_VOLT (0x2 << 5) 52 #define IP5XXX_READ0_CHG_STAT_CONST_CUR (0x3 << 5) 53 #define IP5XXX_READ0_CHG_STAT_CONST_VOLT_STOP (0x4 << 5) 54 #define IP5XXX_READ0_CHG_STAT_FULL (0x5 << 5) 55 #define IP5XXX_READ0_CHG_STAT_TIMEOUT (0x6 << 5) 56 #define IP5XXX_READ0_CHG_OP BIT(4) 57 #define IP5XXX_READ0_CHG_END BIT(3) 58 #define IP5XXX_READ0_CONST_VOLT_TIMEOUT BIT(2) 59 #define IP5XXX_READ0_CHG_TIMEOUT BIT(1) 60 #define IP5XXX_READ0_TRICKLE_TIMEOUT BIT(0) 61 #define IP5XXX_READ0_TIMEOUT GENMASK(2, 0) 62 #define IP5XXX_READ1 0x72 63 #define IP5XXX_READ1_WLED_PRESENT BIT(7) 64 #define IP5XXX_READ1_LIGHT_LOAD BIT(6) 65 #define IP5XXX_READ1_VIN_OVERVOLT BIT(5) 66 #define IP5XXX_READ2 0x77 67 #define IP5XXX_READ2_BTN_PRESS BIT(3) 68 #define IP5XXX_READ2_BTN_LONG_PRESS BIT(1) 69 #define IP5XXX_READ2_BTN_SHORT_PRESS BIT(0) 70 #define IP5XXX_BATVADC_DAT0 0xa2 71 #define IP5XXX_BATVADC_DAT1 0xa3 72 #define IP5XXX_BATIADC_DAT0 0xa4 73 #define IP5XXX_BATIADC_DAT1 0xa5 74 #define IP5XXX_BATOCV_DAT0 0xa8 75 #define IP5XXX_BATOCV_DAT1 0xa9 76 77 struct ip5xxx { 78 struct regmap *regmap; 79 bool initialized; 80 }; 81 82 /* 83 * The IP5xxx charger only responds on I2C when it is "awake". The charger is 84 * generally only awake when VIN is powered or when its boost converter is 85 * enabled. Going into shutdown resets all register values. To handle this: 86 * 1) When any bus error occurs, assume the charger has gone into shutdown. 87 * 2) Attempt the initialization sequence on each subsequent register access 88 * until it succeeds. 89 */ 90 static int ip5xxx_read(struct ip5xxx *ip5xxx, unsigned int reg, 91 unsigned int *val) 92 { 93 int ret; 94 95 ret = regmap_read(ip5xxx->regmap, reg, val); 96 if (ret) 97 ip5xxx->initialized = false; 98 99 return ret; 100 } 101 102 static int ip5xxx_update_bits(struct ip5xxx *ip5xxx, unsigned int reg, 103 unsigned int mask, unsigned int val) 104 { 105 int ret; 106 107 ret = regmap_update_bits(ip5xxx->regmap, reg, mask, val); 108 if (ret) 109 ip5xxx->initialized = false; 110 111 return ret; 112 } 113 114 static int ip5xxx_initialize(struct power_supply *psy) 115 { 116 struct ip5xxx *ip5xxx = power_supply_get_drvdata(psy); 117 int ret; 118 119 if (ip5xxx->initialized) 120 return 0; 121 122 /* 123 * Disable shutdown under light load. 124 * Enable power on when under load. 125 */ 126 ret = ip5xxx_update_bits(ip5xxx, IP5XXX_SYS_CTL1, 127 IP5XXX_SYS_CTL1_LIGHT_SHDN_EN | 128 IP5XXX_SYS_CTL1_LOAD_PWRUP_EN, 129 IP5XXX_SYS_CTL1_LOAD_PWRUP_EN); 130 if (ret) 131 return ret; 132 133 /* 134 * Enable shutdown after a long button press (as configured below). 135 */ 136 ret = ip5xxx_update_bits(ip5xxx, IP5XXX_SYS_CTL3, 137 IP5XXX_SYS_CTL3_BTN_SHDN_EN, 138 IP5XXX_SYS_CTL3_BTN_SHDN_EN); 139 if (ret) 140 return ret; 141 142 /* 143 * Power on automatically when VIN is removed. 144 */ 145 ret = ip5xxx_update_bits(ip5xxx, IP5XXX_SYS_CTL4, 146 IP5XXX_SYS_CTL4_VIN_PULLOUT_BOOST_EN, 147 IP5XXX_SYS_CTL4_VIN_PULLOUT_BOOST_EN); 148 if (ret) 149 return ret; 150 151 /* 152 * Enable the NTC. 153 * Configure the button for two presses => LED, long press => shutdown. 154 */ 155 ret = ip5xxx_update_bits(ip5xxx, IP5XXX_SYS_CTL5, 156 IP5XXX_SYS_CTL5_NTC_DIS | 157 IP5XXX_SYS_CTL5_WLED_MODE_SEL | 158 IP5XXX_SYS_CTL5_BTN_SHDN_SEL, 159 IP5XXX_SYS_CTL5_WLED_MODE_SEL | 160 IP5XXX_SYS_CTL5_BTN_SHDN_SEL); 161 if (ret) 162 return ret; 163 164 ip5xxx->initialized = true; 165 dev_dbg(psy->dev.parent, "Initialized after power on\n"); 166 167 return 0; 168 } 169 170 static const enum power_supply_property ip5xxx_battery_properties[] = { 171 POWER_SUPPLY_PROP_STATUS, 172 POWER_SUPPLY_PROP_CHARGE_TYPE, 173 POWER_SUPPLY_PROP_HEALTH, 174 POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN, 175 POWER_SUPPLY_PROP_VOLTAGE_NOW, 176 POWER_SUPPLY_PROP_VOLTAGE_OCV, 177 POWER_SUPPLY_PROP_CURRENT_NOW, 178 POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT, 179 POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX, 180 POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE, 181 POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX, 182 }; 183 184 static int ip5xxx_battery_get_status(struct ip5xxx *ip5xxx, int *val) 185 { 186 unsigned int rval; 187 int ret; 188 189 ret = ip5xxx_read(ip5xxx, IP5XXX_READ0, &rval); 190 if (ret) 191 return ret; 192 193 switch (rval & IP5XXX_READ0_CHG_STAT) { 194 case IP5XXX_READ0_CHG_STAT_IDLE: 195 *val = POWER_SUPPLY_STATUS_DISCHARGING; 196 break; 197 case IP5XXX_READ0_CHG_STAT_TRICKLE: 198 case IP5XXX_READ0_CHG_STAT_CONST_CUR: 199 case IP5XXX_READ0_CHG_STAT_CONST_VOLT: 200 *val = POWER_SUPPLY_STATUS_CHARGING; 201 break; 202 case IP5XXX_READ0_CHG_STAT_CONST_VOLT_STOP: 203 case IP5XXX_READ0_CHG_STAT_FULL: 204 *val = POWER_SUPPLY_STATUS_FULL; 205 break; 206 case IP5XXX_READ0_CHG_STAT_TIMEOUT: 207 *val = POWER_SUPPLY_STATUS_NOT_CHARGING; 208 break; 209 default: 210 return -EINVAL; 211 } 212 213 return 0; 214 } 215 216 static int ip5xxx_battery_get_charge_type(struct ip5xxx *ip5xxx, int *val) 217 { 218 unsigned int rval; 219 int ret; 220 221 ret = ip5xxx_read(ip5xxx, IP5XXX_READ0, &rval); 222 if (ret) 223 return ret; 224 225 switch (rval & IP5XXX_READ0_CHG_STAT) { 226 case IP5XXX_READ0_CHG_STAT_IDLE: 227 case IP5XXX_READ0_CHG_STAT_CONST_VOLT_STOP: 228 case IP5XXX_READ0_CHG_STAT_FULL: 229 case IP5XXX_READ0_CHG_STAT_TIMEOUT: 230 *val = POWER_SUPPLY_CHARGE_TYPE_NONE; 231 break; 232 case IP5XXX_READ0_CHG_STAT_TRICKLE: 233 *val = POWER_SUPPLY_CHARGE_TYPE_TRICKLE; 234 break; 235 case IP5XXX_READ0_CHG_STAT_CONST_CUR: 236 case IP5XXX_READ0_CHG_STAT_CONST_VOLT: 237 *val = POWER_SUPPLY_CHARGE_TYPE_STANDARD; 238 break; 239 default: 240 return -EINVAL; 241 } 242 243 return 0; 244 } 245 246 static int ip5xxx_battery_get_health(struct ip5xxx *ip5xxx, int *val) 247 { 248 unsigned int rval; 249 int ret; 250 251 ret = ip5xxx_read(ip5xxx, IP5XXX_READ0, &rval); 252 if (ret) 253 return ret; 254 255 if (rval & IP5XXX_READ0_TIMEOUT) 256 *val = POWER_SUPPLY_HEALTH_SAFETY_TIMER_EXPIRE; 257 else 258 *val = POWER_SUPPLY_HEALTH_GOOD; 259 260 return 0; 261 } 262 263 static int ip5xxx_battery_get_voltage_max(struct ip5xxx *ip5xxx, int *val) 264 { 265 unsigned int rval; 266 int ret; 267 268 ret = ip5xxx_read(ip5xxx, IP5XXX_CHG_CTL2, &rval); 269 if (ret) 270 return ret; 271 272 /* 273 * It is not clear what this will return if 274 * IP5XXX_CHG_CTL4_BAT_TYPE_SEL_EN is not set... 275 */ 276 switch (rval & IP5XXX_CHG_CTL2_BAT_TYPE_SEL) { 277 case IP5XXX_CHG_CTL2_BAT_TYPE_SEL_4_2V: 278 *val = 4200000; 279 break; 280 case IP5XXX_CHG_CTL2_BAT_TYPE_SEL_4_3V: 281 *val = 4300000; 282 break; 283 case IP5XXX_CHG_CTL2_BAT_TYPE_SEL_4_35V: 284 *val = 4350000; 285 break; 286 default: 287 return -EINVAL; 288 } 289 290 return 0; 291 } 292 293 static int ip5xxx_battery_read_adc(struct ip5xxx *ip5xxx, 294 u8 lo_reg, u8 hi_reg, int *val) 295 { 296 unsigned int hi, lo; 297 int ret; 298 299 ret = ip5xxx_read(ip5xxx, lo_reg, &lo); 300 if (ret) 301 return ret; 302 303 ret = ip5xxx_read(ip5xxx, hi_reg, &hi); 304 if (ret) 305 return ret; 306 307 *val = sign_extend32(hi << 8 | lo, 13); 308 309 return 0; 310 } 311 312 static int ip5xxx_battery_get_property(struct power_supply *psy, 313 enum power_supply_property psp, 314 union power_supply_propval *val) 315 { 316 struct ip5xxx *ip5xxx = power_supply_get_drvdata(psy); 317 int raw, ret, vmax; 318 unsigned int rval; 319 320 ret = ip5xxx_initialize(psy); 321 if (ret) 322 return ret; 323 324 switch (psp) { 325 case POWER_SUPPLY_PROP_STATUS: 326 return ip5xxx_battery_get_status(ip5xxx, &val->intval); 327 328 case POWER_SUPPLY_PROP_CHARGE_TYPE: 329 return ip5xxx_battery_get_charge_type(ip5xxx, &val->intval); 330 331 case POWER_SUPPLY_PROP_HEALTH: 332 return ip5xxx_battery_get_health(ip5xxx, &val->intval); 333 334 case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN: 335 return ip5xxx_battery_get_voltage_max(ip5xxx, &val->intval); 336 337 case POWER_SUPPLY_PROP_VOLTAGE_NOW: 338 ret = ip5xxx_battery_read_adc(ip5xxx, IP5XXX_BATVADC_DAT0, 339 IP5XXX_BATVADC_DAT1, &raw); 340 341 val->intval = 2600000 + DIV_ROUND_CLOSEST(raw * 26855, 100); 342 return 0; 343 344 case POWER_SUPPLY_PROP_VOLTAGE_OCV: 345 ret = ip5xxx_battery_read_adc(ip5xxx, IP5XXX_BATOCV_DAT0, 346 IP5XXX_BATOCV_DAT1, &raw); 347 348 val->intval = 2600000 + DIV_ROUND_CLOSEST(raw * 26855, 100); 349 return 0; 350 351 case POWER_SUPPLY_PROP_CURRENT_NOW: 352 ret = ip5xxx_battery_read_adc(ip5xxx, IP5XXX_BATIADC_DAT0, 353 IP5XXX_BATIADC_DAT1, &raw); 354 355 val->intval = DIV_ROUND_CLOSEST(raw * 149197, 200); 356 return 0; 357 358 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT: 359 ret = ip5xxx_read(ip5xxx, IP5XXX_CHG_CTL4A, &rval); 360 if (ret) 361 return ret; 362 363 rval &= IP5XXX_CHG_CTL4A_CONST_CUR_SEL; 364 val->intval = 100000 * rval; 365 return 0; 366 367 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX: 368 val->intval = 100000 * 0x1f; 369 return 0; 370 371 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE: 372 ret = ip5xxx_battery_get_voltage_max(ip5xxx, &vmax); 373 if (ret) 374 return ret; 375 376 ret = ip5xxx_read(ip5xxx, IP5XXX_CHG_CTL2, &rval); 377 if (ret) 378 return ret; 379 380 rval &= IP5XXX_CHG_CTL2_CONST_VOLT_SEL; 381 val->intval = vmax + 14000 * (rval >> 1); 382 return 0; 383 384 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX: 385 ret = ip5xxx_battery_get_voltage_max(ip5xxx, &vmax); 386 if (ret) 387 return ret; 388 389 val->intval = vmax + 14000 * 3; 390 return 0; 391 392 default: 393 return -EINVAL; 394 } 395 } 396 397 static int ip5xxx_battery_set_voltage_max(struct ip5xxx *ip5xxx, int val) 398 { 399 unsigned int rval; 400 int ret; 401 402 switch (val) { 403 case 4200000: 404 rval = IP5XXX_CHG_CTL2_BAT_TYPE_SEL_4_2V; 405 break; 406 case 4300000: 407 rval = IP5XXX_CHG_CTL2_BAT_TYPE_SEL_4_3V; 408 break; 409 case 4350000: 410 rval = IP5XXX_CHG_CTL2_BAT_TYPE_SEL_4_35V; 411 break; 412 default: 413 return -EINVAL; 414 } 415 416 ret = ip5xxx_update_bits(ip5xxx, IP5XXX_CHG_CTL2, 417 IP5XXX_CHG_CTL2_BAT_TYPE_SEL, rval); 418 if (ret) 419 return ret; 420 421 ret = ip5xxx_update_bits(ip5xxx, IP5XXX_CHG_CTL4, 422 IP5XXX_CHG_CTL4_BAT_TYPE_SEL_EN, 423 IP5XXX_CHG_CTL4_BAT_TYPE_SEL_EN); 424 if (ret) 425 return ret; 426 427 return 0; 428 } 429 430 static int ip5xxx_battery_set_property(struct power_supply *psy, 431 enum power_supply_property psp, 432 const union power_supply_propval *val) 433 { 434 struct ip5xxx *ip5xxx = power_supply_get_drvdata(psy); 435 unsigned int rval; 436 int ret, vmax; 437 438 ret = ip5xxx_initialize(psy); 439 if (ret) 440 return ret; 441 442 switch (psp) { 443 case POWER_SUPPLY_PROP_STATUS: 444 switch (val->intval) { 445 case POWER_SUPPLY_STATUS_CHARGING: 446 rval = IP5XXX_SYS_CTL0_CHARGER_EN; 447 break; 448 case POWER_SUPPLY_STATUS_DISCHARGING: 449 case POWER_SUPPLY_STATUS_NOT_CHARGING: 450 rval = 0; 451 break; 452 default: 453 return -EINVAL; 454 } 455 return ip5xxx_update_bits(ip5xxx, IP5XXX_SYS_CTL0, 456 IP5XXX_SYS_CTL0_CHARGER_EN, rval); 457 458 case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN: 459 return ip5xxx_battery_set_voltage_max(ip5xxx, val->intval); 460 461 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT: 462 rval = val->intval / 100000; 463 return ip5xxx_update_bits(ip5xxx, IP5XXX_CHG_CTL4A, 464 IP5XXX_CHG_CTL4A_CONST_CUR_SEL, rval); 465 466 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE: 467 ret = ip5xxx_battery_get_voltage_max(ip5xxx, &vmax); 468 if (ret) 469 return ret; 470 471 rval = ((val->intval - vmax) / 14000) << 1; 472 return ip5xxx_update_bits(ip5xxx, IP5XXX_CHG_CTL2, 473 IP5XXX_CHG_CTL2_CONST_VOLT_SEL, rval); 474 475 default: 476 return -EINVAL; 477 } 478 } 479 480 static int ip5xxx_battery_property_is_writeable(struct power_supply *psy, 481 enum power_supply_property psp) 482 { 483 return psp == POWER_SUPPLY_PROP_STATUS || 484 psp == POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN || 485 psp == POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT || 486 psp == POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE; 487 } 488 489 static const struct power_supply_desc ip5xxx_battery_desc = { 490 .name = "ip5xxx-battery", 491 .type = POWER_SUPPLY_TYPE_BATTERY, 492 .properties = ip5xxx_battery_properties, 493 .num_properties = ARRAY_SIZE(ip5xxx_battery_properties), 494 .get_property = ip5xxx_battery_get_property, 495 .set_property = ip5xxx_battery_set_property, 496 .property_is_writeable = ip5xxx_battery_property_is_writeable, 497 }; 498 499 static const enum power_supply_property ip5xxx_boost_properties[] = { 500 POWER_SUPPLY_PROP_ONLINE, 501 POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN, 502 }; 503 504 static int ip5xxx_boost_get_property(struct power_supply *psy, 505 enum power_supply_property psp, 506 union power_supply_propval *val) 507 { 508 struct ip5xxx *ip5xxx = power_supply_get_drvdata(psy); 509 unsigned int rval; 510 int ret; 511 512 ret = ip5xxx_initialize(psy); 513 if (ret) 514 return ret; 515 516 switch (psp) { 517 case POWER_SUPPLY_PROP_ONLINE: 518 ret = ip5xxx_read(ip5xxx, IP5XXX_SYS_CTL0, &rval); 519 if (ret) 520 return ret; 521 522 val->intval = !!(rval & IP5XXX_SYS_CTL0_BOOST_EN); 523 return 0; 524 525 case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN: 526 ret = ip5xxx_read(ip5xxx, IP5XXX_CHG_CTL1, &rval); 527 if (ret) 528 return ret; 529 530 rval &= IP5XXX_CHG_CTL1_BOOST_UVP_SEL; 531 val->intval = 4530000 + 100000 * (rval >> 2); 532 return 0; 533 534 default: 535 return -EINVAL; 536 } 537 } 538 539 static int ip5xxx_boost_set_property(struct power_supply *psy, 540 enum power_supply_property psp, 541 const union power_supply_propval *val) 542 { 543 struct ip5xxx *ip5xxx = power_supply_get_drvdata(psy); 544 unsigned int rval; 545 int ret; 546 547 ret = ip5xxx_initialize(psy); 548 if (ret) 549 return ret; 550 551 switch (psp) { 552 case POWER_SUPPLY_PROP_ONLINE: 553 rval = val->intval ? IP5XXX_SYS_CTL0_BOOST_EN : 0; 554 return ip5xxx_update_bits(ip5xxx, IP5XXX_SYS_CTL0, 555 IP5XXX_SYS_CTL0_BOOST_EN, rval); 556 557 case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN: 558 rval = ((val->intval - 4530000) / 100000) << 2; 559 return ip5xxx_update_bits(ip5xxx, IP5XXX_CHG_CTL1, 560 IP5XXX_CHG_CTL1_BOOST_UVP_SEL, rval); 561 562 default: 563 return -EINVAL; 564 } 565 } 566 567 static int ip5xxx_boost_property_is_writeable(struct power_supply *psy, 568 enum power_supply_property psp) 569 { 570 return true; 571 } 572 573 static const struct power_supply_desc ip5xxx_boost_desc = { 574 .name = "ip5xxx-boost", 575 .type = POWER_SUPPLY_TYPE_USB, 576 .properties = ip5xxx_boost_properties, 577 .num_properties = ARRAY_SIZE(ip5xxx_boost_properties), 578 .get_property = ip5xxx_boost_get_property, 579 .set_property = ip5xxx_boost_set_property, 580 .property_is_writeable = ip5xxx_boost_property_is_writeable, 581 }; 582 583 static const struct regmap_config ip5xxx_regmap_config = { 584 .reg_bits = 8, 585 .val_bits = 8, 586 .max_register = IP5XXX_BATOCV_DAT1, 587 }; 588 589 static int ip5xxx_power_probe(struct i2c_client *client) 590 { 591 struct power_supply_config psy_cfg = {}; 592 struct device *dev = &client->dev; 593 struct power_supply *psy; 594 struct ip5xxx *ip5xxx; 595 596 ip5xxx = devm_kzalloc(dev, sizeof(*ip5xxx), GFP_KERNEL); 597 if (!ip5xxx) 598 return -ENOMEM; 599 600 ip5xxx->regmap = devm_regmap_init_i2c(client, &ip5xxx_regmap_config); 601 if (IS_ERR(ip5xxx->regmap)) 602 return PTR_ERR(ip5xxx->regmap); 603 604 psy_cfg.of_node = dev->of_node; 605 psy_cfg.drv_data = ip5xxx; 606 607 psy = devm_power_supply_register(dev, &ip5xxx_battery_desc, &psy_cfg); 608 if (IS_ERR(psy)) 609 return PTR_ERR(psy); 610 611 psy = devm_power_supply_register(dev, &ip5xxx_boost_desc, &psy_cfg); 612 if (IS_ERR(psy)) 613 return PTR_ERR(psy); 614 615 return 0; 616 } 617 618 static const struct of_device_id ip5xxx_power_of_match[] = { 619 { .compatible = "injoinic,ip5108" }, 620 { .compatible = "injoinic,ip5109" }, 621 { .compatible = "injoinic,ip5207" }, 622 { .compatible = "injoinic,ip5209" }, 623 { } 624 }; 625 MODULE_DEVICE_TABLE(of, ip5xxx_power_of_match); 626 627 static struct i2c_driver ip5xxx_power_driver = { 628 .probe_new = ip5xxx_power_probe, 629 .driver = { 630 .name = "ip5xxx-power", 631 .of_match_table = ip5xxx_power_of_match, 632 } 633 }; 634 module_i2c_driver(ip5xxx_power_driver); 635 636 MODULE_AUTHOR("Samuel Holland <samuel@sholland.org>"); 637 MODULE_DESCRIPTION("Injoinic IP5xxx power bank IC driver"); 638 MODULE_LICENSE("GPL"); 639