1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Driver for Richtek RT9455WSC battery charger. 4 * 5 * Copyright (C) 2015 Intel Corporation 6 */ 7 8 #include <linux/module.h> 9 #include <linux/interrupt.h> 10 #include <linux/delay.h> 11 #include <linux/of.h> 12 #include <linux/pm_runtime.h> 13 #include <linux/power_supply.h> 14 #include <linux/i2c.h> 15 #include <linux/acpi.h> 16 #include <linux/usb/phy.h> 17 #include <linux/regmap.h> 18 19 #define RT9455_MANUFACTURER "Richtek" 20 #define RT9455_MODEL_NAME "RT9455" 21 #define RT9455_DRIVER_NAME "rt9455-charger" 22 23 #define RT9455_IRQ_NAME "interrupt" 24 25 #define RT9455_PWR_RDY_DELAY 1 /* 1 second */ 26 #define RT9455_MAX_CHARGING_TIME 21600 /* 6 hrs */ 27 #define RT9455_BATT_PRESENCE_DELAY 60 /* 60 seconds */ 28 29 #define RT9455_CHARGE_MODE 0x00 30 #define RT9455_BOOST_MODE 0x01 31 32 #define RT9455_FAULT 0x03 33 34 #define RT9455_IAICR_100MA 0x00 35 #define RT9455_IAICR_500MA 0x01 36 #define RT9455_IAICR_NO_LIMIT 0x03 37 38 #define RT9455_CHARGE_DISABLE 0x00 39 #define RT9455_CHARGE_ENABLE 0x01 40 41 #define RT9455_PWR_FAULT 0x00 42 #define RT9455_PWR_GOOD 0x01 43 44 #define RT9455_REG_CTRL1 0x00 /* CTRL1 reg address */ 45 #define RT9455_REG_CTRL2 0x01 /* CTRL2 reg address */ 46 #define RT9455_REG_CTRL3 0x02 /* CTRL3 reg address */ 47 #define RT9455_REG_DEV_ID 0x03 /* DEV_ID reg address */ 48 #define RT9455_REG_CTRL4 0x04 /* CTRL4 reg address */ 49 #define RT9455_REG_CTRL5 0x05 /* CTRL5 reg address */ 50 #define RT9455_REG_CTRL6 0x06 /* CTRL6 reg address */ 51 #define RT9455_REG_CTRL7 0x07 /* CTRL7 reg address */ 52 #define RT9455_REG_IRQ1 0x08 /* IRQ1 reg address */ 53 #define RT9455_REG_IRQ2 0x09 /* IRQ2 reg address */ 54 #define RT9455_REG_IRQ3 0x0A /* IRQ3 reg address */ 55 #define RT9455_REG_MASK1 0x0B /* MASK1 reg address */ 56 #define RT9455_REG_MASK2 0x0C /* MASK2 reg address */ 57 #define RT9455_REG_MASK3 0x0D /* MASK3 reg address */ 58 59 enum rt9455_fields { 60 F_STAT, F_BOOST, F_PWR_RDY, F_OTG_PIN_POLARITY, /* CTRL1 reg fields */ 61 62 F_IAICR, F_TE_SHDN_EN, F_HIGHER_OCP, F_TE, F_IAICR_INT, F_HIZ, 63 F_OPA_MODE, /* CTRL2 reg fields */ 64 65 F_VOREG, F_OTG_PL, F_OTG_EN, /* CTRL3 reg fields */ 66 67 F_VENDOR_ID, F_CHIP_REV, /* DEV_ID reg fields */ 68 69 F_RST, /* CTRL4 reg fields */ 70 71 F_TMR_EN, F_MIVR, F_IPREC, F_IEOC_PERCENTAGE, /* CTRL5 reg fields*/ 72 73 F_IAICR_SEL, F_ICHRG, F_VPREC, /* CTRL6 reg fields */ 74 75 F_BATD_EN, F_CHG_EN, F_VMREG, /* CTRL7 reg fields */ 76 77 F_TSDI, F_VINOVPI, F_BATAB, /* IRQ1 reg fields */ 78 79 F_CHRVPI, F_CHBATOVI, F_CHTERMI, F_CHRCHGI, F_CH32MI, F_CHTREGI, 80 F_CHMIVRI, /* IRQ2 reg fields */ 81 82 F_BSTBUSOVI, F_BSTOLI, F_BSTLOWVI, F_BST32SI, /* IRQ3 reg fields */ 83 84 F_TSDM, F_VINOVPIM, F_BATABM, /* MASK1 reg fields */ 85 86 F_CHRVPIM, F_CHBATOVIM, F_CHTERMIM, F_CHRCHGIM, F_CH32MIM, F_CHTREGIM, 87 F_CHMIVRIM, /* MASK2 reg fields */ 88 89 F_BSTVINOVIM, F_BSTOLIM, F_BSTLOWVIM, F_BST32SIM, /* MASK3 reg fields */ 90 91 F_MAX_FIELDS 92 }; 93 94 static const struct reg_field rt9455_reg_fields[] = { 95 [F_STAT] = REG_FIELD(RT9455_REG_CTRL1, 4, 5), 96 [F_BOOST] = REG_FIELD(RT9455_REG_CTRL1, 3, 3), 97 [F_PWR_RDY] = REG_FIELD(RT9455_REG_CTRL1, 2, 2), 98 [F_OTG_PIN_POLARITY] = REG_FIELD(RT9455_REG_CTRL1, 1, 1), 99 100 [F_IAICR] = REG_FIELD(RT9455_REG_CTRL2, 6, 7), 101 [F_TE_SHDN_EN] = REG_FIELD(RT9455_REG_CTRL2, 5, 5), 102 [F_HIGHER_OCP] = REG_FIELD(RT9455_REG_CTRL2, 4, 4), 103 [F_TE] = REG_FIELD(RT9455_REG_CTRL2, 3, 3), 104 [F_IAICR_INT] = REG_FIELD(RT9455_REG_CTRL2, 2, 2), 105 [F_HIZ] = REG_FIELD(RT9455_REG_CTRL2, 1, 1), 106 [F_OPA_MODE] = REG_FIELD(RT9455_REG_CTRL2, 0, 0), 107 108 [F_VOREG] = REG_FIELD(RT9455_REG_CTRL3, 2, 7), 109 [F_OTG_PL] = REG_FIELD(RT9455_REG_CTRL3, 1, 1), 110 [F_OTG_EN] = REG_FIELD(RT9455_REG_CTRL3, 0, 0), 111 112 [F_VENDOR_ID] = REG_FIELD(RT9455_REG_DEV_ID, 4, 7), 113 [F_CHIP_REV] = REG_FIELD(RT9455_REG_DEV_ID, 0, 3), 114 115 [F_RST] = REG_FIELD(RT9455_REG_CTRL4, 7, 7), 116 117 [F_TMR_EN] = REG_FIELD(RT9455_REG_CTRL5, 7, 7), 118 [F_MIVR] = REG_FIELD(RT9455_REG_CTRL5, 4, 5), 119 [F_IPREC] = REG_FIELD(RT9455_REG_CTRL5, 2, 3), 120 [F_IEOC_PERCENTAGE] = REG_FIELD(RT9455_REG_CTRL5, 0, 1), 121 122 [F_IAICR_SEL] = REG_FIELD(RT9455_REG_CTRL6, 7, 7), 123 [F_ICHRG] = REG_FIELD(RT9455_REG_CTRL6, 4, 6), 124 [F_VPREC] = REG_FIELD(RT9455_REG_CTRL6, 0, 2), 125 126 [F_BATD_EN] = REG_FIELD(RT9455_REG_CTRL7, 6, 6), 127 [F_CHG_EN] = REG_FIELD(RT9455_REG_CTRL7, 4, 4), 128 [F_VMREG] = REG_FIELD(RT9455_REG_CTRL7, 0, 3), 129 130 [F_TSDI] = REG_FIELD(RT9455_REG_IRQ1, 7, 7), 131 [F_VINOVPI] = REG_FIELD(RT9455_REG_IRQ1, 6, 6), 132 [F_BATAB] = REG_FIELD(RT9455_REG_IRQ1, 0, 0), 133 134 [F_CHRVPI] = REG_FIELD(RT9455_REG_IRQ2, 7, 7), 135 [F_CHBATOVI] = REG_FIELD(RT9455_REG_IRQ2, 5, 5), 136 [F_CHTERMI] = REG_FIELD(RT9455_REG_IRQ2, 4, 4), 137 [F_CHRCHGI] = REG_FIELD(RT9455_REG_IRQ2, 3, 3), 138 [F_CH32MI] = REG_FIELD(RT9455_REG_IRQ2, 2, 2), 139 [F_CHTREGI] = REG_FIELD(RT9455_REG_IRQ2, 1, 1), 140 [F_CHMIVRI] = REG_FIELD(RT9455_REG_IRQ2, 0, 0), 141 142 [F_BSTBUSOVI] = REG_FIELD(RT9455_REG_IRQ3, 7, 7), 143 [F_BSTOLI] = REG_FIELD(RT9455_REG_IRQ3, 6, 6), 144 [F_BSTLOWVI] = REG_FIELD(RT9455_REG_IRQ3, 5, 5), 145 [F_BST32SI] = REG_FIELD(RT9455_REG_IRQ3, 3, 3), 146 147 [F_TSDM] = REG_FIELD(RT9455_REG_MASK1, 7, 7), 148 [F_VINOVPIM] = REG_FIELD(RT9455_REG_MASK1, 6, 6), 149 [F_BATABM] = REG_FIELD(RT9455_REG_MASK1, 0, 0), 150 151 [F_CHRVPIM] = REG_FIELD(RT9455_REG_MASK2, 7, 7), 152 [F_CHBATOVIM] = REG_FIELD(RT9455_REG_MASK2, 5, 5), 153 [F_CHTERMIM] = REG_FIELD(RT9455_REG_MASK2, 4, 4), 154 [F_CHRCHGIM] = REG_FIELD(RT9455_REG_MASK2, 3, 3), 155 [F_CH32MIM] = REG_FIELD(RT9455_REG_MASK2, 2, 2), 156 [F_CHTREGIM] = REG_FIELD(RT9455_REG_MASK2, 1, 1), 157 [F_CHMIVRIM] = REG_FIELD(RT9455_REG_MASK2, 0, 0), 158 159 [F_BSTVINOVIM] = REG_FIELD(RT9455_REG_MASK3, 7, 7), 160 [F_BSTOLIM] = REG_FIELD(RT9455_REG_MASK3, 6, 6), 161 [F_BSTLOWVIM] = REG_FIELD(RT9455_REG_MASK3, 5, 5), 162 [F_BST32SIM] = REG_FIELD(RT9455_REG_MASK3, 3, 3), 163 }; 164 165 #define GET_MASK(fid) (BIT(rt9455_reg_fields[fid].msb + 1) - \ 166 BIT(rt9455_reg_fields[fid].lsb)) 167 168 /* 169 * Each array initialised below shows the possible real-world values for a 170 * group of bits belonging to RT9455 registers. The arrays are sorted in 171 * ascending order. The index of each real-world value represents the value 172 * that is encoded in the group of bits belonging to RT9455 registers. 173 */ 174 /* REG06[6:4] (ICHRG) in uAh */ 175 static const int rt9455_ichrg_values[] = { 176 500000, 650000, 800000, 950000, 1100000, 1250000, 1400000, 1550000 177 }; 178 179 /* 180 * When the charger is in charge mode, REG02[7:2] represent battery regulation 181 * voltage. 182 */ 183 /* REG02[7:2] (VOREG) in uV */ 184 static const int rt9455_voreg_values[] = { 185 3500000, 3520000, 3540000, 3560000, 3580000, 3600000, 3620000, 3640000, 186 3660000, 3680000, 3700000, 3720000, 3740000, 3760000, 3780000, 3800000, 187 3820000, 3840000, 3860000, 3880000, 3900000, 3920000, 3940000, 3960000, 188 3980000, 4000000, 4020000, 4040000, 4060000, 4080000, 4100000, 4120000, 189 4140000, 4160000, 4180000, 4200000, 4220000, 4240000, 4260000, 4280000, 190 4300000, 4330000, 4350000, 4370000, 4390000, 4410000, 4430000, 4450000, 191 4450000, 4450000, 4450000, 4450000, 4450000, 4450000, 4450000, 4450000, 192 4450000, 4450000, 4450000, 4450000, 4450000, 4450000, 4450000, 4450000 193 }; 194 195 #if IS_ENABLED(CONFIG_USB_PHY) 196 /* 197 * When the charger is in boost mode, REG02[7:2] represent boost output 198 * voltage. 199 */ 200 /* REG02[7:2] (Boost output voltage) in uV */ 201 static const int rt9455_boost_voltage_values[] = { 202 4425000, 4450000, 4475000, 4500000, 4525000, 4550000, 4575000, 4600000, 203 4625000, 4650000, 4675000, 4700000, 4725000, 4750000, 4775000, 4800000, 204 4825000, 4850000, 4875000, 4900000, 4925000, 4950000, 4975000, 5000000, 205 5025000, 5050000, 5075000, 5100000, 5125000, 5150000, 5175000, 5200000, 206 5225000, 5250000, 5275000, 5300000, 5325000, 5350000, 5375000, 5400000, 207 5425000, 5450000, 5475000, 5500000, 5525000, 5550000, 5575000, 5600000, 208 5600000, 5600000, 5600000, 5600000, 5600000, 5600000, 5600000, 5600000, 209 5600000, 5600000, 5600000, 5600000, 5600000, 5600000, 5600000, 5600000, 210 }; 211 #endif 212 213 /* REG07[3:0] (VMREG) in uV */ 214 static const int rt9455_vmreg_values[] = { 215 4200000, 4220000, 4240000, 4260000, 4280000, 4300000, 4320000, 4340000, 216 4360000, 4380000, 4400000, 4430000, 4450000, 4450000, 4450000, 4450000 217 }; 218 219 /* REG05[5:4] (IEOC_PERCENTAGE) */ 220 static const int rt9455_ieoc_percentage_values[] = { 221 10, 30, 20, 30 222 }; 223 224 /* REG05[1:0] (MIVR) in uV */ 225 static const int rt9455_mivr_values[] = { 226 4000000, 4250000, 4500000, 5000000 227 }; 228 229 /* REG05[1:0] (IAICR) in uA */ 230 static const int rt9455_iaicr_values[] = { 231 100000, 500000, 1000000, 2000000 232 }; 233 234 struct rt9455_info { 235 struct i2c_client *client; 236 struct regmap *regmap; 237 struct regmap_field *regmap_fields[F_MAX_FIELDS]; 238 struct power_supply *charger; 239 #if IS_ENABLED(CONFIG_USB_PHY) 240 struct usb_phy *usb_phy; 241 struct notifier_block nb; 242 #endif 243 struct delayed_work pwr_rdy_work; 244 struct delayed_work max_charging_time_work; 245 struct delayed_work batt_presence_work; 246 u32 voreg; 247 u32 boost_voltage; 248 }; 249 250 /* 251 * Iterate through each element of the 'tbl' array until an element whose value 252 * is greater than v is found. Return the index of the respective element, 253 * or the index of the last element in the array, if no such element is found. 254 */ 255 static unsigned int rt9455_find_idx(const int tbl[], int tbl_size, int v) 256 { 257 int i; 258 259 /* 260 * No need to iterate until the last index in the table because 261 * if no element greater than v is found in the table, 262 * or if only the last element is greater than v, 263 * function returns the index of the last element. 264 */ 265 for (i = 0; i < tbl_size - 1; i++) 266 if (v <= tbl[i]) 267 return i; 268 269 return (tbl_size - 1); 270 } 271 272 static int rt9455_get_field_val(struct rt9455_info *info, 273 enum rt9455_fields field, 274 const int tbl[], int tbl_size, int *val) 275 { 276 unsigned int v; 277 int ret; 278 279 ret = regmap_field_read(info->regmap_fields[field], &v); 280 if (ret) 281 return ret; 282 283 v = (v >= tbl_size) ? (tbl_size - 1) : v; 284 *val = tbl[v]; 285 286 return 0; 287 } 288 289 static int rt9455_set_field_val(struct rt9455_info *info, 290 enum rt9455_fields field, 291 const int tbl[], int tbl_size, int val) 292 { 293 unsigned int idx = rt9455_find_idx(tbl, tbl_size, val); 294 295 return regmap_field_write(info->regmap_fields[field], idx); 296 } 297 298 static int rt9455_register_reset(struct rt9455_info *info) 299 { 300 struct device *dev = &info->client->dev; 301 unsigned int v; 302 int ret, limit = 100; 303 304 ret = regmap_field_write(info->regmap_fields[F_RST], 0x01); 305 if (ret) { 306 dev_err(dev, "Failed to set RST bit\n"); 307 return ret; 308 } 309 310 /* 311 * To make sure that reset operation has finished, loop until RST bit 312 * is set to 0. 313 */ 314 do { 315 ret = regmap_field_read(info->regmap_fields[F_RST], &v); 316 if (ret) { 317 dev_err(dev, "Failed to read RST bit\n"); 318 return ret; 319 } 320 321 if (!v) 322 break; 323 324 usleep_range(10, 100); 325 } while (--limit); 326 327 if (!limit) 328 return -EIO; 329 330 return 0; 331 } 332 333 /* Charger power supply property routines */ 334 static enum power_supply_property rt9455_charger_properties[] = { 335 POWER_SUPPLY_PROP_STATUS, 336 POWER_SUPPLY_PROP_HEALTH, 337 POWER_SUPPLY_PROP_PRESENT, 338 POWER_SUPPLY_PROP_ONLINE, 339 POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT, 340 POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX, 341 POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE, 342 POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX, 343 POWER_SUPPLY_PROP_SCOPE, 344 POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT, 345 POWER_SUPPLY_PROP_MODEL_NAME, 346 POWER_SUPPLY_PROP_MANUFACTURER, 347 }; 348 349 static char *rt9455_charger_supplied_to[] = { 350 "main-battery", 351 }; 352 353 static int rt9455_charger_get_status(struct rt9455_info *info, 354 union power_supply_propval *val) 355 { 356 unsigned int v, pwr_rdy; 357 int ret; 358 359 ret = regmap_field_read(info->regmap_fields[F_PWR_RDY], 360 &pwr_rdy); 361 if (ret) { 362 dev_err(&info->client->dev, "Failed to read PWR_RDY bit\n"); 363 return ret; 364 } 365 366 /* 367 * If PWR_RDY bit is unset, the battery is discharging. Otherwise, 368 * STAT bits value must be checked. 369 */ 370 if (!pwr_rdy) { 371 val->intval = POWER_SUPPLY_STATUS_DISCHARGING; 372 return 0; 373 } 374 375 ret = regmap_field_read(info->regmap_fields[F_STAT], &v); 376 if (ret) { 377 dev_err(&info->client->dev, "Failed to read STAT bits\n"); 378 return ret; 379 } 380 381 switch (v) { 382 case 0: 383 /* 384 * If PWR_RDY bit is set, but STAT bits value is 0, the charger 385 * may be in one of the following cases: 386 * 1. CHG_EN bit is 0. 387 * 2. CHG_EN bit is 1 but the battery is not connected. 388 * In any of these cases, POWER_SUPPLY_STATUS_NOT_CHARGING is 389 * returned. 390 */ 391 val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING; 392 return 0; 393 case 1: 394 val->intval = POWER_SUPPLY_STATUS_CHARGING; 395 return 0; 396 case 2: 397 val->intval = POWER_SUPPLY_STATUS_FULL; 398 return 0; 399 default: 400 val->intval = POWER_SUPPLY_STATUS_UNKNOWN; 401 return 0; 402 } 403 } 404 405 static int rt9455_charger_get_health(struct rt9455_info *info, 406 union power_supply_propval *val) 407 { 408 struct device *dev = &info->client->dev; 409 unsigned int v; 410 int ret; 411 412 val->intval = POWER_SUPPLY_HEALTH_GOOD; 413 414 ret = regmap_read(info->regmap, RT9455_REG_IRQ1, &v); 415 if (ret) { 416 dev_err(dev, "Failed to read IRQ1 register\n"); 417 return ret; 418 } 419 420 if (v & GET_MASK(F_TSDI)) { 421 val->intval = POWER_SUPPLY_HEALTH_OVERHEAT; 422 return 0; 423 } 424 if (v & GET_MASK(F_VINOVPI)) { 425 val->intval = POWER_SUPPLY_HEALTH_OVERVOLTAGE; 426 return 0; 427 } 428 if (v & GET_MASK(F_BATAB)) { 429 val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE; 430 return 0; 431 } 432 433 ret = regmap_read(info->regmap, RT9455_REG_IRQ2, &v); 434 if (ret) { 435 dev_err(dev, "Failed to read IRQ2 register\n"); 436 return ret; 437 } 438 439 if (v & GET_MASK(F_CHBATOVI)) { 440 val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE; 441 return 0; 442 } 443 if (v & GET_MASK(F_CH32MI)) { 444 val->intval = POWER_SUPPLY_HEALTH_SAFETY_TIMER_EXPIRE; 445 return 0; 446 } 447 448 ret = regmap_read(info->regmap, RT9455_REG_IRQ3, &v); 449 if (ret) { 450 dev_err(dev, "Failed to read IRQ3 register\n"); 451 return ret; 452 } 453 454 if (v & GET_MASK(F_BSTBUSOVI)) { 455 val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE; 456 return 0; 457 } 458 if (v & GET_MASK(F_BSTOLI)) { 459 val->intval = POWER_SUPPLY_HEALTH_OVERVOLTAGE; 460 return 0; 461 } 462 if (v & GET_MASK(F_BSTLOWVI)) { 463 val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE; 464 return 0; 465 } 466 if (v & GET_MASK(F_BST32SI)) { 467 val->intval = POWER_SUPPLY_HEALTH_SAFETY_TIMER_EXPIRE; 468 return 0; 469 } 470 471 ret = regmap_field_read(info->regmap_fields[F_STAT], &v); 472 if (ret) { 473 dev_err(dev, "Failed to read STAT bits\n"); 474 return ret; 475 } 476 477 if (v == RT9455_FAULT) { 478 val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE; 479 return 0; 480 } 481 482 return 0; 483 } 484 485 static int rt9455_charger_get_battery_presence(struct rt9455_info *info, 486 union power_supply_propval *val) 487 { 488 unsigned int v; 489 int ret; 490 491 ret = regmap_field_read(info->regmap_fields[F_BATAB], &v); 492 if (ret) { 493 dev_err(&info->client->dev, "Failed to read BATAB bit\n"); 494 return ret; 495 } 496 497 /* 498 * Since BATAB is 1 when battery is NOT present and 0 otherwise, 499 * !BATAB is returned. 500 */ 501 val->intval = !v; 502 503 return 0; 504 } 505 506 static int rt9455_charger_get_online(struct rt9455_info *info, 507 union power_supply_propval *val) 508 { 509 unsigned int v; 510 int ret; 511 512 ret = regmap_field_read(info->regmap_fields[F_PWR_RDY], &v); 513 if (ret) { 514 dev_err(&info->client->dev, "Failed to read PWR_RDY bit\n"); 515 return ret; 516 } 517 518 val->intval = (int)v; 519 520 return 0; 521 } 522 523 static int rt9455_charger_get_current(struct rt9455_info *info, 524 union power_supply_propval *val) 525 { 526 int curr; 527 int ret; 528 529 ret = rt9455_get_field_val(info, F_ICHRG, 530 rt9455_ichrg_values, 531 ARRAY_SIZE(rt9455_ichrg_values), 532 &curr); 533 if (ret) { 534 dev_err(&info->client->dev, "Failed to read ICHRG value\n"); 535 return ret; 536 } 537 538 val->intval = curr; 539 540 return 0; 541 } 542 543 static int rt9455_charger_get_current_max(struct rt9455_info *info, 544 union power_supply_propval *val) 545 { 546 int idx = ARRAY_SIZE(rt9455_ichrg_values) - 1; 547 548 val->intval = rt9455_ichrg_values[idx]; 549 550 return 0; 551 } 552 553 static int rt9455_charger_get_voltage(struct rt9455_info *info, 554 union power_supply_propval *val) 555 { 556 int voltage; 557 int ret; 558 559 ret = rt9455_get_field_val(info, F_VOREG, 560 rt9455_voreg_values, 561 ARRAY_SIZE(rt9455_voreg_values), 562 &voltage); 563 if (ret) { 564 dev_err(&info->client->dev, "Failed to read VOREG value\n"); 565 return ret; 566 } 567 568 val->intval = voltage; 569 570 return 0; 571 } 572 573 static int rt9455_charger_get_voltage_max(struct rt9455_info *info, 574 union power_supply_propval *val) 575 { 576 int idx = ARRAY_SIZE(rt9455_vmreg_values) - 1; 577 578 val->intval = rt9455_vmreg_values[idx]; 579 580 return 0; 581 } 582 583 static int rt9455_charger_get_term_current(struct rt9455_info *info, 584 union power_supply_propval *val) 585 { 586 struct device *dev = &info->client->dev; 587 int ichrg, ieoc_percentage, ret; 588 589 ret = rt9455_get_field_val(info, F_ICHRG, 590 rt9455_ichrg_values, 591 ARRAY_SIZE(rt9455_ichrg_values), 592 &ichrg); 593 if (ret) { 594 dev_err(dev, "Failed to read ICHRG value\n"); 595 return ret; 596 } 597 598 ret = rt9455_get_field_val(info, F_IEOC_PERCENTAGE, 599 rt9455_ieoc_percentage_values, 600 ARRAY_SIZE(rt9455_ieoc_percentage_values), 601 &ieoc_percentage); 602 if (ret) { 603 dev_err(dev, "Failed to read IEOC value\n"); 604 return ret; 605 } 606 607 val->intval = ichrg * ieoc_percentage / 100; 608 609 return 0; 610 } 611 612 static int rt9455_charger_get_property(struct power_supply *psy, 613 enum power_supply_property psp, 614 union power_supply_propval *val) 615 { 616 struct rt9455_info *info = power_supply_get_drvdata(psy); 617 618 switch (psp) { 619 case POWER_SUPPLY_PROP_STATUS: 620 return rt9455_charger_get_status(info, val); 621 case POWER_SUPPLY_PROP_HEALTH: 622 return rt9455_charger_get_health(info, val); 623 case POWER_SUPPLY_PROP_PRESENT: 624 return rt9455_charger_get_battery_presence(info, val); 625 case POWER_SUPPLY_PROP_ONLINE: 626 return rt9455_charger_get_online(info, val); 627 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT: 628 return rt9455_charger_get_current(info, val); 629 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX: 630 return rt9455_charger_get_current_max(info, val); 631 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE: 632 return rt9455_charger_get_voltage(info, val); 633 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX: 634 return rt9455_charger_get_voltage_max(info, val); 635 case POWER_SUPPLY_PROP_SCOPE: 636 val->intval = POWER_SUPPLY_SCOPE_SYSTEM; 637 return 0; 638 case POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT: 639 return rt9455_charger_get_term_current(info, val); 640 case POWER_SUPPLY_PROP_MODEL_NAME: 641 val->strval = RT9455_MODEL_NAME; 642 return 0; 643 case POWER_SUPPLY_PROP_MANUFACTURER: 644 val->strval = RT9455_MANUFACTURER; 645 return 0; 646 default: 647 return -ENODATA; 648 } 649 } 650 651 static int rt9455_hw_init(struct rt9455_info *info, u32 ichrg, 652 u32 ieoc_percentage, 653 u32 mivr, u32 iaicr) 654 { 655 struct device *dev = &info->client->dev; 656 int idx, ret; 657 658 ret = rt9455_register_reset(info); 659 if (ret) { 660 dev_err(dev, "Power On Reset failed\n"); 661 return ret; 662 } 663 664 /* Set TE bit in order to enable end of charge detection */ 665 ret = regmap_field_write(info->regmap_fields[F_TE], 1); 666 if (ret) { 667 dev_err(dev, "Failed to set TE bit\n"); 668 return ret; 669 } 670 671 /* Set TE_SHDN_EN bit in order to enable end of charge detection */ 672 ret = regmap_field_write(info->regmap_fields[F_TE_SHDN_EN], 1); 673 if (ret) { 674 dev_err(dev, "Failed to set TE_SHDN_EN bit\n"); 675 return ret; 676 } 677 678 /* 679 * Set BATD_EN bit in order to enable battery detection 680 * when charging is done 681 */ 682 ret = regmap_field_write(info->regmap_fields[F_BATD_EN], 1); 683 if (ret) { 684 dev_err(dev, "Failed to set BATD_EN bit\n"); 685 return ret; 686 } 687 688 /* 689 * Disable Safety Timer. In charge mode, this timer terminates charging 690 * if no read or write via I2C is done within 32 minutes. This timer 691 * avoids overcharging the baterry when the OS is not loaded and the 692 * charger is connected to a power source. 693 * In boost mode, this timer triggers BST32SI interrupt if no read or 694 * write via I2C is done within 32 seconds. 695 * When the OS is loaded and the charger driver is inserted, it is used 696 * delayed_work, named max_charging_time_work, to avoid overcharging 697 * the battery. 698 */ 699 ret = regmap_field_write(info->regmap_fields[F_TMR_EN], 0x00); 700 if (ret) { 701 dev_err(dev, "Failed to disable Safety Timer\n"); 702 return ret; 703 } 704 705 /* Set ICHRG to value retrieved from device-specific data */ 706 ret = rt9455_set_field_val(info, F_ICHRG, 707 rt9455_ichrg_values, 708 ARRAY_SIZE(rt9455_ichrg_values), ichrg); 709 if (ret) { 710 dev_err(dev, "Failed to set ICHRG value\n"); 711 return ret; 712 } 713 714 /* Set IEOC Percentage to value retrieved from device-specific data */ 715 ret = rt9455_set_field_val(info, F_IEOC_PERCENTAGE, 716 rt9455_ieoc_percentage_values, 717 ARRAY_SIZE(rt9455_ieoc_percentage_values), 718 ieoc_percentage); 719 if (ret) { 720 dev_err(dev, "Failed to set IEOC Percentage value\n"); 721 return ret; 722 } 723 724 /* Set VOREG to value retrieved from device-specific data */ 725 ret = rt9455_set_field_val(info, F_VOREG, 726 rt9455_voreg_values, 727 ARRAY_SIZE(rt9455_voreg_values), 728 info->voreg); 729 if (ret) { 730 dev_err(dev, "Failed to set VOREG value\n"); 731 return ret; 732 } 733 734 /* Set VMREG value to maximum (4.45V). */ 735 idx = ARRAY_SIZE(rt9455_vmreg_values) - 1; 736 ret = rt9455_set_field_val(info, F_VMREG, 737 rt9455_vmreg_values, 738 ARRAY_SIZE(rt9455_vmreg_values), 739 rt9455_vmreg_values[idx]); 740 if (ret) { 741 dev_err(dev, "Failed to set VMREG value\n"); 742 return ret; 743 } 744 745 /* 746 * Set MIVR to value retrieved from device-specific data. 747 * If no value is specified, default value for MIVR is 4.5V. 748 */ 749 if (mivr == -1) 750 mivr = 4500000; 751 752 ret = rt9455_set_field_val(info, F_MIVR, 753 rt9455_mivr_values, 754 ARRAY_SIZE(rt9455_mivr_values), mivr); 755 if (ret) { 756 dev_err(dev, "Failed to set MIVR value\n"); 757 return ret; 758 } 759 760 /* 761 * Set IAICR to value retrieved from device-specific data. 762 * If no value is specified, default value for IAICR is 500 mA. 763 */ 764 if (iaicr == -1) 765 iaicr = 500000; 766 767 ret = rt9455_set_field_val(info, F_IAICR, 768 rt9455_iaicr_values, 769 ARRAY_SIZE(rt9455_iaicr_values), iaicr); 770 if (ret) { 771 dev_err(dev, "Failed to set IAICR value\n"); 772 return ret; 773 } 774 775 /* 776 * Set IAICR_INT bit so that IAICR value is determined by IAICR bits 777 * and not by OTG pin. 778 */ 779 ret = regmap_field_write(info->regmap_fields[F_IAICR_INT], 0x01); 780 if (ret) { 781 dev_err(dev, "Failed to set IAICR_INT bit\n"); 782 return ret; 783 } 784 785 /* 786 * Disable CHMIVRI interrupt. Because the driver sets MIVR value, 787 * CHMIVRI is triggered, but there is no action to be taken by the 788 * driver when CHMIVRI is triggered. 789 */ 790 ret = regmap_field_write(info->regmap_fields[F_CHMIVRIM], 0x01); 791 if (ret) { 792 dev_err(dev, "Failed to mask CHMIVRI interrupt\n"); 793 return ret; 794 } 795 796 return 0; 797 } 798 799 #if IS_ENABLED(CONFIG_USB_PHY) 800 /* 801 * Before setting the charger into boost mode, boost output voltage is 802 * set. This is needed because boost output voltage may differ from battery 803 * regulation voltage. F_VOREG bits represent either battery regulation voltage 804 * or boost output voltage, depending on the mode the charger is. Both battery 805 * regulation voltage and boost output voltage are read from DT/ACPI during 806 * probe. 807 */ 808 static int rt9455_set_boost_voltage_before_boost_mode(struct rt9455_info *info) 809 { 810 struct device *dev = &info->client->dev; 811 int ret; 812 813 ret = rt9455_set_field_val(info, F_VOREG, 814 rt9455_boost_voltage_values, 815 ARRAY_SIZE(rt9455_boost_voltage_values), 816 info->boost_voltage); 817 if (ret) { 818 dev_err(dev, "Failed to set boost output voltage value\n"); 819 return ret; 820 } 821 822 return 0; 823 } 824 #endif 825 826 /* 827 * Before setting the charger into charge mode, battery regulation voltage is 828 * set. This is needed because boost output voltage may differ from battery 829 * regulation voltage. F_VOREG bits represent either battery regulation voltage 830 * or boost output voltage, depending on the mode the charger is. Both battery 831 * regulation voltage and boost output voltage are read from DT/ACPI during 832 * probe. 833 */ 834 static int rt9455_set_voreg_before_charge_mode(struct rt9455_info *info) 835 { 836 struct device *dev = &info->client->dev; 837 int ret; 838 839 ret = rt9455_set_field_val(info, F_VOREG, 840 rt9455_voreg_values, 841 ARRAY_SIZE(rt9455_voreg_values), 842 info->voreg); 843 if (ret) { 844 dev_err(dev, "Failed to set VOREG value\n"); 845 return ret; 846 } 847 848 return 0; 849 } 850 851 static int rt9455_irq_handler_check_irq1_register(struct rt9455_info *info, 852 bool *_is_battery_absent, 853 bool *_alert_userspace) 854 { 855 unsigned int irq1, mask1, mask2; 856 struct device *dev = &info->client->dev; 857 bool is_battery_absent = false; 858 bool alert_userspace = false; 859 int ret; 860 861 ret = regmap_read(info->regmap, RT9455_REG_IRQ1, &irq1); 862 if (ret) { 863 dev_err(dev, "Failed to read IRQ1 register\n"); 864 return ret; 865 } 866 867 ret = regmap_read(info->regmap, RT9455_REG_MASK1, &mask1); 868 if (ret) { 869 dev_err(dev, "Failed to read MASK1 register\n"); 870 return ret; 871 } 872 873 if (irq1 & GET_MASK(F_TSDI)) { 874 dev_err(dev, "Thermal shutdown fault occurred\n"); 875 alert_userspace = true; 876 } 877 878 if (irq1 & GET_MASK(F_VINOVPI)) { 879 dev_err(dev, "Overvoltage input occurred\n"); 880 alert_userspace = true; 881 } 882 883 if (irq1 & GET_MASK(F_BATAB)) { 884 dev_err(dev, "Battery absence occurred\n"); 885 is_battery_absent = true; 886 alert_userspace = true; 887 888 if ((mask1 & GET_MASK(F_BATABM)) == 0) { 889 ret = regmap_field_write(info->regmap_fields[F_BATABM], 890 0x01); 891 if (ret) { 892 dev_err(dev, "Failed to mask BATAB interrupt\n"); 893 return ret; 894 } 895 } 896 897 ret = regmap_read(info->regmap, RT9455_REG_MASK2, &mask2); 898 if (ret) { 899 dev_err(dev, "Failed to read MASK2 register\n"); 900 return ret; 901 } 902 903 if (mask2 & GET_MASK(F_CHTERMIM)) { 904 ret = regmap_field_write( 905 info->regmap_fields[F_CHTERMIM], 0x00); 906 if (ret) { 907 dev_err(dev, "Failed to unmask CHTERMI interrupt\n"); 908 return ret; 909 } 910 } 911 912 if (mask2 & GET_MASK(F_CHRCHGIM)) { 913 ret = regmap_field_write( 914 info->regmap_fields[F_CHRCHGIM], 0x00); 915 if (ret) { 916 dev_err(dev, "Failed to unmask CHRCHGI interrupt\n"); 917 return ret; 918 } 919 } 920 921 /* 922 * When the battery is absent, max_charging_time_work is 923 * cancelled, since no charging is done. 924 */ 925 cancel_delayed_work_sync(&info->max_charging_time_work); 926 /* 927 * Since no interrupt is triggered when the battery is 928 * reconnected, max_charging_time_work is not rescheduled. 929 * Therefore, batt_presence_work is scheduled to check whether 930 * the battery is still absent or not. 931 */ 932 queue_delayed_work(system_power_efficient_wq, 933 &info->batt_presence_work, 934 RT9455_BATT_PRESENCE_DELAY * HZ); 935 } 936 937 *_is_battery_absent = is_battery_absent; 938 939 if (alert_userspace) 940 *_alert_userspace = alert_userspace; 941 942 return 0; 943 } 944 945 static int rt9455_irq_handler_check_irq2_register(struct rt9455_info *info, 946 bool is_battery_absent, 947 bool *_alert_userspace) 948 { 949 unsigned int irq2, mask2; 950 struct device *dev = &info->client->dev; 951 bool alert_userspace = false; 952 int ret; 953 954 ret = regmap_read(info->regmap, RT9455_REG_IRQ2, &irq2); 955 if (ret) { 956 dev_err(dev, "Failed to read IRQ2 register\n"); 957 return ret; 958 } 959 960 ret = regmap_read(info->regmap, RT9455_REG_MASK2, &mask2); 961 if (ret) { 962 dev_err(dev, "Failed to read MASK2 register\n"); 963 return ret; 964 } 965 966 if (irq2 & GET_MASK(F_CHRVPI)) { 967 dev_dbg(dev, "Charger fault occurred\n"); 968 /* 969 * CHRVPI bit is set in 2 cases: 970 * 1. when the power source is connected to the charger. 971 * 2. when the power source is disconnected from the charger. 972 * To identify the case, PWR_RDY bit is checked. Because 973 * PWR_RDY bit is set / cleared after CHRVPI interrupt is 974 * triggered, it is used delayed_work to later read PWR_RDY bit. 975 * Also, do not set to true alert_userspace, because there is no 976 * need to notify userspace when CHRVPI interrupt has occurred. 977 * Userspace will be notified after PWR_RDY bit is read. 978 */ 979 queue_delayed_work(system_power_efficient_wq, 980 &info->pwr_rdy_work, 981 RT9455_PWR_RDY_DELAY * HZ); 982 } 983 if (irq2 & GET_MASK(F_CHBATOVI)) { 984 dev_err(dev, "Battery OVP occurred\n"); 985 alert_userspace = true; 986 } 987 if (irq2 & GET_MASK(F_CHTERMI)) { 988 dev_dbg(dev, "Charge terminated\n"); 989 if (!is_battery_absent) { 990 if ((mask2 & GET_MASK(F_CHTERMIM)) == 0) { 991 ret = regmap_field_write( 992 info->regmap_fields[F_CHTERMIM], 0x01); 993 if (ret) { 994 dev_err(dev, "Failed to mask CHTERMI interrupt\n"); 995 return ret; 996 } 997 /* 998 * Update MASK2 value, since CHTERMIM bit is 999 * set. 1000 */ 1001 mask2 = mask2 | GET_MASK(F_CHTERMIM); 1002 } 1003 cancel_delayed_work_sync(&info->max_charging_time_work); 1004 alert_userspace = true; 1005 } 1006 } 1007 if (irq2 & GET_MASK(F_CHRCHGI)) { 1008 dev_dbg(dev, "Recharge request\n"); 1009 ret = regmap_field_write(info->regmap_fields[F_CHG_EN], 1010 RT9455_CHARGE_ENABLE); 1011 if (ret) { 1012 dev_err(dev, "Failed to enable charging\n"); 1013 return ret; 1014 } 1015 if (mask2 & GET_MASK(F_CHTERMIM)) { 1016 ret = regmap_field_write( 1017 info->regmap_fields[F_CHTERMIM], 0x00); 1018 if (ret) { 1019 dev_err(dev, "Failed to unmask CHTERMI interrupt\n"); 1020 return ret; 1021 } 1022 /* Update MASK2 value, since CHTERMIM bit is cleared. */ 1023 mask2 = mask2 & ~GET_MASK(F_CHTERMIM); 1024 } 1025 if (!is_battery_absent) { 1026 /* 1027 * No need to check whether the charger is connected to 1028 * power source when CHRCHGI is received, since CHRCHGI 1029 * is not triggered if the charger is not connected to 1030 * the power source. 1031 */ 1032 queue_delayed_work(system_power_efficient_wq, 1033 &info->max_charging_time_work, 1034 RT9455_MAX_CHARGING_TIME * HZ); 1035 alert_userspace = true; 1036 } 1037 } 1038 if (irq2 & GET_MASK(F_CH32MI)) { 1039 dev_err(dev, "Charger fault. 32 mins timeout occurred\n"); 1040 alert_userspace = true; 1041 } 1042 if (irq2 & GET_MASK(F_CHTREGI)) { 1043 dev_warn(dev, 1044 "Charger warning. Thermal regulation loop active\n"); 1045 alert_userspace = true; 1046 } 1047 if (irq2 & GET_MASK(F_CHMIVRI)) { 1048 dev_dbg(dev, 1049 "Charger warning. Input voltage MIVR loop active\n"); 1050 } 1051 1052 if (alert_userspace) 1053 *_alert_userspace = alert_userspace; 1054 1055 return 0; 1056 } 1057 1058 static int rt9455_irq_handler_check_irq3_register(struct rt9455_info *info, 1059 bool *_alert_userspace) 1060 { 1061 unsigned int irq3, mask3; 1062 struct device *dev = &info->client->dev; 1063 bool alert_userspace = false; 1064 int ret; 1065 1066 ret = regmap_read(info->regmap, RT9455_REG_IRQ3, &irq3); 1067 if (ret) { 1068 dev_err(dev, "Failed to read IRQ3 register\n"); 1069 return ret; 1070 } 1071 1072 ret = regmap_read(info->regmap, RT9455_REG_MASK3, &mask3); 1073 if (ret) { 1074 dev_err(dev, "Failed to read MASK3 register\n"); 1075 return ret; 1076 } 1077 1078 if (irq3 & GET_MASK(F_BSTBUSOVI)) { 1079 dev_err(dev, "Boost fault. Overvoltage input occurred\n"); 1080 alert_userspace = true; 1081 } 1082 if (irq3 & GET_MASK(F_BSTOLI)) { 1083 dev_err(dev, "Boost fault. Overload\n"); 1084 alert_userspace = true; 1085 } 1086 if (irq3 & GET_MASK(F_BSTLOWVI)) { 1087 dev_err(dev, "Boost fault. Battery voltage too low\n"); 1088 alert_userspace = true; 1089 } 1090 if (irq3 & GET_MASK(F_BST32SI)) { 1091 dev_err(dev, "Boost fault. 32 seconds timeout occurred.\n"); 1092 alert_userspace = true; 1093 } 1094 1095 if (alert_userspace) { 1096 dev_info(dev, "Boost fault occurred, therefore the charger goes into charge mode\n"); 1097 ret = rt9455_set_voreg_before_charge_mode(info); 1098 if (ret) { 1099 dev_err(dev, "Failed to set VOREG before entering charge mode\n"); 1100 return ret; 1101 } 1102 ret = regmap_field_write(info->regmap_fields[F_OPA_MODE], 1103 RT9455_CHARGE_MODE); 1104 if (ret) { 1105 dev_err(dev, "Failed to set charger in charge mode\n"); 1106 return ret; 1107 } 1108 *_alert_userspace = alert_userspace; 1109 } 1110 1111 return 0; 1112 } 1113 1114 static irqreturn_t rt9455_irq_handler_thread(int irq, void *data) 1115 { 1116 struct rt9455_info *info = data; 1117 struct device *dev; 1118 bool alert_userspace = false; 1119 bool is_battery_absent = false; 1120 unsigned int status; 1121 int ret; 1122 1123 if (!info) 1124 return IRQ_NONE; 1125 1126 dev = &info->client->dev; 1127 1128 if (irq != info->client->irq) { 1129 dev_err(dev, "Interrupt is not for RT9455 charger\n"); 1130 return IRQ_NONE; 1131 } 1132 1133 ret = regmap_field_read(info->regmap_fields[F_STAT], &status); 1134 if (ret) { 1135 dev_err(dev, "Failed to read STAT bits\n"); 1136 return IRQ_HANDLED; 1137 } 1138 dev_dbg(dev, "Charger status is %d\n", status); 1139 1140 /* 1141 * Each function that processes an IRQ register receives as output 1142 * parameter alert_userspace pointer. alert_userspace is set to true 1143 * in such a function only if an interrupt has occurred in the 1144 * respective interrupt register. This way, it is avoided the following 1145 * case: interrupt occurs only in IRQ1 register, 1146 * rt9455_irq_handler_check_irq1_register() function sets to true 1147 * alert_userspace, but rt9455_irq_handler_check_irq2_register() 1148 * and rt9455_irq_handler_check_irq3_register() functions set to false 1149 * alert_userspace and power_supply_changed() is never called. 1150 */ 1151 ret = rt9455_irq_handler_check_irq1_register(info, &is_battery_absent, 1152 &alert_userspace); 1153 if (ret) { 1154 dev_err(dev, "Failed to handle IRQ1 register\n"); 1155 return IRQ_HANDLED; 1156 } 1157 1158 ret = rt9455_irq_handler_check_irq2_register(info, is_battery_absent, 1159 &alert_userspace); 1160 if (ret) { 1161 dev_err(dev, "Failed to handle IRQ2 register\n"); 1162 return IRQ_HANDLED; 1163 } 1164 1165 ret = rt9455_irq_handler_check_irq3_register(info, &alert_userspace); 1166 if (ret) { 1167 dev_err(dev, "Failed to handle IRQ3 register\n"); 1168 return IRQ_HANDLED; 1169 } 1170 1171 if (alert_userspace) { 1172 /* 1173 * Sometimes, an interrupt occurs while rt9455_probe() function 1174 * is executing and power_supply_register() is not yet called. 1175 * Do not call power_supply_changed() in this case. 1176 */ 1177 if (info->charger) 1178 power_supply_changed(info->charger); 1179 } 1180 1181 return IRQ_HANDLED; 1182 } 1183 1184 static int rt9455_discover_charger(struct rt9455_info *info, u32 *ichrg, 1185 u32 *ieoc_percentage, 1186 u32 *mivr, u32 *iaicr) 1187 { 1188 struct device *dev = &info->client->dev; 1189 int ret; 1190 1191 if (!dev->of_node && !ACPI_HANDLE(dev)) { 1192 dev_err(dev, "No support for either device tree or ACPI\n"); 1193 return -EINVAL; 1194 } 1195 /* 1196 * ICHRG, IEOC_PERCENTAGE, VOREG and boost output voltage are mandatory 1197 * parameters. 1198 */ 1199 ret = device_property_read_u32(dev, "richtek,output-charge-current", 1200 ichrg); 1201 if (ret) { 1202 dev_err(dev, "Error: missing \"output-charge-current\" property\n"); 1203 return ret; 1204 } 1205 1206 ret = device_property_read_u32(dev, "richtek,end-of-charge-percentage", 1207 ieoc_percentage); 1208 if (ret) { 1209 dev_err(dev, "Error: missing \"end-of-charge-percentage\" property\n"); 1210 return ret; 1211 } 1212 1213 ret = device_property_read_u32(dev, 1214 "richtek,battery-regulation-voltage", 1215 &info->voreg); 1216 if (ret) { 1217 dev_err(dev, "Error: missing \"battery-regulation-voltage\" property\n"); 1218 return ret; 1219 } 1220 1221 ret = device_property_read_u32(dev, "richtek,boost-output-voltage", 1222 &info->boost_voltage); 1223 if (ret) { 1224 dev_err(dev, "Error: missing \"boost-output-voltage\" property\n"); 1225 return ret; 1226 } 1227 1228 /* 1229 * MIVR and IAICR are optional parameters. Do not return error if one of 1230 * them is not present in ACPI table or device tree specification. 1231 */ 1232 device_property_read_u32(dev, "richtek,min-input-voltage-regulation", 1233 mivr); 1234 device_property_read_u32(dev, "richtek,avg-input-current-regulation", 1235 iaicr); 1236 1237 return 0; 1238 } 1239 1240 #if IS_ENABLED(CONFIG_USB_PHY) 1241 static int rt9455_usb_event_none(struct rt9455_info *info, 1242 u8 opa_mode, u8 iaicr) 1243 { 1244 struct device *dev = &info->client->dev; 1245 int ret; 1246 1247 if (opa_mode == RT9455_BOOST_MODE) { 1248 ret = rt9455_set_voreg_before_charge_mode(info); 1249 if (ret) { 1250 dev_err(dev, "Failed to set VOREG before entering charge mode\n"); 1251 return ret; 1252 } 1253 /* 1254 * If the charger is in boost mode, and it has received 1255 * USB_EVENT_NONE, this means the consumer device powered by the 1256 * charger is not connected anymore. 1257 * In this case, the charger goes into charge mode. 1258 */ 1259 dev_dbg(dev, "USB_EVENT_NONE received, therefore the charger goes into charge mode\n"); 1260 ret = regmap_field_write(info->regmap_fields[F_OPA_MODE], 1261 RT9455_CHARGE_MODE); 1262 if (ret) { 1263 dev_err(dev, "Failed to set charger in charge mode\n"); 1264 return NOTIFY_DONE; 1265 } 1266 } 1267 1268 dev_dbg(dev, "USB_EVENT_NONE received, therefore IAICR is set to its minimum value\n"); 1269 if (iaicr != RT9455_IAICR_100MA) { 1270 ret = regmap_field_write(info->regmap_fields[F_IAICR], 1271 RT9455_IAICR_100MA); 1272 if (ret) { 1273 dev_err(dev, "Failed to set IAICR value\n"); 1274 return NOTIFY_DONE; 1275 } 1276 } 1277 1278 return NOTIFY_OK; 1279 } 1280 1281 static int rt9455_usb_event_vbus(struct rt9455_info *info, 1282 u8 opa_mode, u8 iaicr) 1283 { 1284 struct device *dev = &info->client->dev; 1285 int ret; 1286 1287 if (opa_mode == RT9455_BOOST_MODE) { 1288 ret = rt9455_set_voreg_before_charge_mode(info); 1289 if (ret) { 1290 dev_err(dev, "Failed to set VOREG before entering charge mode\n"); 1291 return ret; 1292 } 1293 /* 1294 * If the charger is in boost mode, and it has received 1295 * USB_EVENT_VBUS, this means the consumer device powered by the 1296 * charger is not connected anymore. 1297 * In this case, the charger goes into charge mode. 1298 */ 1299 dev_dbg(dev, "USB_EVENT_VBUS received, therefore the charger goes into charge mode\n"); 1300 ret = regmap_field_write(info->regmap_fields[F_OPA_MODE], 1301 RT9455_CHARGE_MODE); 1302 if (ret) { 1303 dev_err(dev, "Failed to set charger in charge mode\n"); 1304 return NOTIFY_DONE; 1305 } 1306 } 1307 1308 dev_dbg(dev, "USB_EVENT_VBUS received, therefore IAICR is set to 500 mA\n"); 1309 if (iaicr != RT9455_IAICR_500MA) { 1310 ret = regmap_field_write(info->regmap_fields[F_IAICR], 1311 RT9455_IAICR_500MA); 1312 if (ret) { 1313 dev_err(dev, "Failed to set IAICR value\n"); 1314 return NOTIFY_DONE; 1315 } 1316 } 1317 1318 return NOTIFY_OK; 1319 } 1320 1321 static int rt9455_usb_event_id(struct rt9455_info *info, 1322 u8 opa_mode, u8 iaicr) 1323 { 1324 struct device *dev = &info->client->dev; 1325 int ret; 1326 1327 if (opa_mode == RT9455_CHARGE_MODE) { 1328 ret = rt9455_set_boost_voltage_before_boost_mode(info); 1329 if (ret) { 1330 dev_err(dev, "Failed to set boost output voltage before entering boost mode\n"); 1331 return ret; 1332 } 1333 /* 1334 * If the charger is in charge mode, and it has received 1335 * USB_EVENT_ID, this means a consumer device is connected and 1336 * it should be powered by the charger. 1337 * In this case, the charger goes into boost mode. 1338 */ 1339 dev_dbg(dev, "USB_EVENT_ID received, therefore the charger goes into boost mode\n"); 1340 ret = regmap_field_write(info->regmap_fields[F_OPA_MODE], 1341 RT9455_BOOST_MODE); 1342 if (ret) { 1343 dev_err(dev, "Failed to set charger in boost mode\n"); 1344 return NOTIFY_DONE; 1345 } 1346 } 1347 1348 dev_dbg(dev, "USB_EVENT_ID received, therefore IAICR is set to its minimum value\n"); 1349 if (iaicr != RT9455_IAICR_100MA) { 1350 ret = regmap_field_write(info->regmap_fields[F_IAICR], 1351 RT9455_IAICR_100MA); 1352 if (ret) { 1353 dev_err(dev, "Failed to set IAICR value\n"); 1354 return NOTIFY_DONE; 1355 } 1356 } 1357 1358 return NOTIFY_OK; 1359 } 1360 1361 static int rt9455_usb_event_charger(struct rt9455_info *info, 1362 u8 opa_mode, u8 iaicr) 1363 { 1364 struct device *dev = &info->client->dev; 1365 int ret; 1366 1367 if (opa_mode == RT9455_BOOST_MODE) { 1368 ret = rt9455_set_voreg_before_charge_mode(info); 1369 if (ret) { 1370 dev_err(dev, "Failed to set VOREG before entering charge mode\n"); 1371 return ret; 1372 } 1373 /* 1374 * If the charger is in boost mode, and it has received 1375 * USB_EVENT_CHARGER, this means the consumer device powered by 1376 * the charger is not connected anymore. 1377 * In this case, the charger goes into charge mode. 1378 */ 1379 dev_dbg(dev, "USB_EVENT_CHARGER received, therefore the charger goes into charge mode\n"); 1380 ret = regmap_field_write(info->regmap_fields[F_OPA_MODE], 1381 RT9455_CHARGE_MODE); 1382 if (ret) { 1383 dev_err(dev, "Failed to set charger in charge mode\n"); 1384 return NOTIFY_DONE; 1385 } 1386 } 1387 1388 dev_dbg(dev, "USB_EVENT_CHARGER received, therefore IAICR is set to no current limit\n"); 1389 if (iaicr != RT9455_IAICR_NO_LIMIT) { 1390 ret = regmap_field_write(info->regmap_fields[F_IAICR], 1391 RT9455_IAICR_NO_LIMIT); 1392 if (ret) { 1393 dev_err(dev, "Failed to set IAICR value\n"); 1394 return NOTIFY_DONE; 1395 } 1396 } 1397 1398 return NOTIFY_OK; 1399 } 1400 1401 static int rt9455_usb_event(struct notifier_block *nb, 1402 unsigned long event, void *power) 1403 { 1404 struct rt9455_info *info = container_of(nb, struct rt9455_info, nb); 1405 struct device *dev = &info->client->dev; 1406 unsigned int opa_mode, iaicr; 1407 int ret; 1408 1409 /* 1410 * Determine whether the charger is in charge mode 1411 * or in boost mode. 1412 */ 1413 ret = regmap_field_read(info->regmap_fields[F_OPA_MODE], 1414 &opa_mode); 1415 if (ret) { 1416 dev_err(dev, "Failed to read OPA_MODE value\n"); 1417 return NOTIFY_DONE; 1418 } 1419 1420 ret = regmap_field_read(info->regmap_fields[F_IAICR], 1421 &iaicr); 1422 if (ret) { 1423 dev_err(dev, "Failed to read IAICR value\n"); 1424 return NOTIFY_DONE; 1425 } 1426 1427 dev_dbg(dev, "Received USB event %lu\n", event); 1428 switch (event) { 1429 case USB_EVENT_NONE: 1430 return rt9455_usb_event_none(info, opa_mode, iaicr); 1431 case USB_EVENT_VBUS: 1432 return rt9455_usb_event_vbus(info, opa_mode, iaicr); 1433 case USB_EVENT_ID: 1434 return rt9455_usb_event_id(info, opa_mode, iaicr); 1435 case USB_EVENT_CHARGER: 1436 return rt9455_usb_event_charger(info, opa_mode, iaicr); 1437 default: 1438 dev_err(dev, "Unknown USB event\n"); 1439 } 1440 return NOTIFY_DONE; 1441 } 1442 #endif 1443 1444 static void rt9455_pwr_rdy_work_callback(struct work_struct *work) 1445 { 1446 struct rt9455_info *info = container_of(work, struct rt9455_info, 1447 pwr_rdy_work.work); 1448 struct device *dev = &info->client->dev; 1449 unsigned int pwr_rdy; 1450 int ret; 1451 1452 ret = regmap_field_read(info->regmap_fields[F_PWR_RDY], &pwr_rdy); 1453 if (ret) { 1454 dev_err(dev, "Failed to read PWR_RDY bit\n"); 1455 return; 1456 } 1457 switch (pwr_rdy) { 1458 case RT9455_PWR_FAULT: 1459 dev_dbg(dev, "Charger disconnected from power source\n"); 1460 cancel_delayed_work_sync(&info->max_charging_time_work); 1461 break; 1462 case RT9455_PWR_GOOD: 1463 dev_dbg(dev, "Charger connected to power source\n"); 1464 ret = regmap_field_write(info->regmap_fields[F_CHG_EN], 1465 RT9455_CHARGE_ENABLE); 1466 if (ret) { 1467 dev_err(dev, "Failed to enable charging\n"); 1468 return; 1469 } 1470 queue_delayed_work(system_power_efficient_wq, 1471 &info->max_charging_time_work, 1472 RT9455_MAX_CHARGING_TIME * HZ); 1473 break; 1474 } 1475 /* 1476 * Notify userspace that the charger has been either connected to or 1477 * disconnected from the power source. 1478 */ 1479 power_supply_changed(info->charger); 1480 } 1481 1482 static void rt9455_max_charging_time_work_callback(struct work_struct *work) 1483 { 1484 struct rt9455_info *info = container_of(work, struct rt9455_info, 1485 max_charging_time_work.work); 1486 struct device *dev = &info->client->dev; 1487 int ret; 1488 1489 dev_err(dev, "Battery has been charging for at least 6 hours and is not yet fully charged. Battery is dead, therefore charging is disabled.\n"); 1490 ret = regmap_field_write(info->regmap_fields[F_CHG_EN], 1491 RT9455_CHARGE_DISABLE); 1492 if (ret) 1493 dev_err(dev, "Failed to disable charging\n"); 1494 } 1495 1496 static void rt9455_batt_presence_work_callback(struct work_struct *work) 1497 { 1498 struct rt9455_info *info = container_of(work, struct rt9455_info, 1499 batt_presence_work.work); 1500 struct device *dev = &info->client->dev; 1501 unsigned int irq1, mask1; 1502 int ret; 1503 1504 ret = regmap_read(info->regmap, RT9455_REG_IRQ1, &irq1); 1505 if (ret) { 1506 dev_err(dev, "Failed to read IRQ1 register\n"); 1507 return; 1508 } 1509 1510 /* 1511 * If the battery is still absent, batt_presence_work is rescheduled. 1512 * Otherwise, max_charging_time is scheduled. 1513 */ 1514 if (irq1 & GET_MASK(F_BATAB)) { 1515 queue_delayed_work(system_power_efficient_wq, 1516 &info->batt_presence_work, 1517 RT9455_BATT_PRESENCE_DELAY * HZ); 1518 } else { 1519 queue_delayed_work(system_power_efficient_wq, 1520 &info->max_charging_time_work, 1521 RT9455_MAX_CHARGING_TIME * HZ); 1522 1523 ret = regmap_read(info->regmap, RT9455_REG_MASK1, &mask1); 1524 if (ret) { 1525 dev_err(dev, "Failed to read MASK1 register\n"); 1526 return; 1527 } 1528 1529 if (mask1 & GET_MASK(F_BATABM)) { 1530 ret = regmap_field_write(info->regmap_fields[F_BATABM], 1531 0x00); 1532 if (ret) 1533 dev_err(dev, "Failed to unmask BATAB interrupt\n"); 1534 } 1535 /* 1536 * Notify userspace that the battery is now connected to the 1537 * charger. 1538 */ 1539 power_supply_changed(info->charger); 1540 } 1541 } 1542 1543 static const struct power_supply_desc rt9455_charger_desc = { 1544 .name = RT9455_DRIVER_NAME, 1545 .type = POWER_SUPPLY_TYPE_USB, 1546 .properties = rt9455_charger_properties, 1547 .num_properties = ARRAY_SIZE(rt9455_charger_properties), 1548 .get_property = rt9455_charger_get_property, 1549 }; 1550 1551 static bool rt9455_is_writeable_reg(struct device *dev, unsigned int reg) 1552 { 1553 switch (reg) { 1554 case RT9455_REG_DEV_ID: 1555 case RT9455_REG_IRQ1: 1556 case RT9455_REG_IRQ2: 1557 case RT9455_REG_IRQ3: 1558 return false; 1559 default: 1560 return true; 1561 } 1562 } 1563 1564 static bool rt9455_is_volatile_reg(struct device *dev, unsigned int reg) 1565 { 1566 switch (reg) { 1567 case RT9455_REG_DEV_ID: 1568 case RT9455_REG_CTRL5: 1569 case RT9455_REG_CTRL6: 1570 return false; 1571 default: 1572 return true; 1573 } 1574 } 1575 1576 static const struct regmap_config rt9455_regmap_config = { 1577 .reg_bits = 8, 1578 .val_bits = 8, 1579 .writeable_reg = rt9455_is_writeable_reg, 1580 .volatile_reg = rt9455_is_volatile_reg, 1581 .max_register = RT9455_REG_MASK3, 1582 .cache_type = REGCACHE_RBTREE, 1583 }; 1584 1585 static int rt9455_probe(struct i2c_client *client) 1586 { 1587 struct i2c_adapter *adapter = client->adapter; 1588 struct device *dev = &client->dev; 1589 struct rt9455_info *info; 1590 struct power_supply_config rt9455_charger_config = {}; 1591 /* 1592 * Mandatory device-specific data values. Also, VOREG and boost output 1593 * voltage are mandatory values, but they are stored in rt9455_info 1594 * structure. 1595 */ 1596 u32 ichrg, ieoc_percentage; 1597 /* Optional device-specific data values. */ 1598 u32 mivr = -1, iaicr = -1; 1599 int i, ret; 1600 1601 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) { 1602 dev_err(dev, "No support for SMBUS_BYTE_DATA\n"); 1603 return -ENODEV; 1604 } 1605 info = devm_kzalloc(dev, sizeof(*info), GFP_KERNEL); 1606 if (!info) 1607 return -ENOMEM; 1608 1609 info->client = client; 1610 i2c_set_clientdata(client, info); 1611 1612 info->regmap = devm_regmap_init_i2c(client, 1613 &rt9455_regmap_config); 1614 if (IS_ERR(info->regmap)) { 1615 dev_err(dev, "Failed to initialize register map\n"); 1616 return -EINVAL; 1617 } 1618 1619 for (i = 0; i < F_MAX_FIELDS; i++) { 1620 info->regmap_fields[i] = 1621 devm_regmap_field_alloc(dev, info->regmap, 1622 rt9455_reg_fields[i]); 1623 if (IS_ERR(info->regmap_fields[i])) { 1624 dev_err(dev, 1625 "Failed to allocate regmap field = %d\n", i); 1626 return PTR_ERR(info->regmap_fields[i]); 1627 } 1628 } 1629 1630 ret = rt9455_discover_charger(info, &ichrg, &ieoc_percentage, 1631 &mivr, &iaicr); 1632 if (ret) { 1633 dev_err(dev, "Failed to discover charger\n"); 1634 return ret; 1635 } 1636 1637 #if IS_ENABLED(CONFIG_USB_PHY) 1638 info->usb_phy = devm_usb_get_phy(dev, USB_PHY_TYPE_USB2); 1639 if (IS_ERR(info->usb_phy)) { 1640 dev_err(dev, "Failed to get USB transceiver\n"); 1641 } else { 1642 info->nb.notifier_call = rt9455_usb_event; 1643 ret = usb_register_notifier(info->usb_phy, &info->nb); 1644 if (ret) { 1645 dev_err(dev, "Failed to register USB notifier\n"); 1646 /* 1647 * If usb_register_notifier() fails, set notifier_call 1648 * to NULL, to avoid calling usb_unregister_notifier(). 1649 */ 1650 info->nb.notifier_call = NULL; 1651 } 1652 } 1653 #endif 1654 1655 INIT_DEFERRABLE_WORK(&info->pwr_rdy_work, rt9455_pwr_rdy_work_callback); 1656 INIT_DEFERRABLE_WORK(&info->max_charging_time_work, 1657 rt9455_max_charging_time_work_callback); 1658 INIT_DEFERRABLE_WORK(&info->batt_presence_work, 1659 rt9455_batt_presence_work_callback); 1660 1661 rt9455_charger_config.of_node = dev->of_node; 1662 rt9455_charger_config.drv_data = info; 1663 rt9455_charger_config.supplied_to = rt9455_charger_supplied_to; 1664 rt9455_charger_config.num_supplicants = 1665 ARRAY_SIZE(rt9455_charger_supplied_to); 1666 ret = devm_request_threaded_irq(dev, client->irq, NULL, 1667 rt9455_irq_handler_thread, 1668 IRQF_TRIGGER_LOW | IRQF_ONESHOT, 1669 RT9455_DRIVER_NAME, info); 1670 if (ret) { 1671 dev_err(dev, "Failed to register IRQ handler\n"); 1672 goto put_usb_notifier; 1673 } 1674 1675 ret = rt9455_hw_init(info, ichrg, ieoc_percentage, mivr, iaicr); 1676 if (ret) { 1677 dev_err(dev, "Failed to set charger to its default values\n"); 1678 goto put_usb_notifier; 1679 } 1680 1681 info->charger = devm_power_supply_register(dev, &rt9455_charger_desc, 1682 &rt9455_charger_config); 1683 if (IS_ERR(info->charger)) { 1684 dev_err(dev, "Failed to register charger\n"); 1685 ret = PTR_ERR(info->charger); 1686 goto put_usb_notifier; 1687 } 1688 1689 return 0; 1690 1691 put_usb_notifier: 1692 #if IS_ENABLED(CONFIG_USB_PHY) 1693 if (info->nb.notifier_call) { 1694 usb_unregister_notifier(info->usb_phy, &info->nb); 1695 info->nb.notifier_call = NULL; 1696 } 1697 #endif 1698 return ret; 1699 } 1700 1701 static void rt9455_remove(struct i2c_client *client) 1702 { 1703 int ret; 1704 struct rt9455_info *info = i2c_get_clientdata(client); 1705 1706 ret = rt9455_register_reset(info); 1707 if (ret) 1708 dev_err(&info->client->dev, "Failed to set charger to its default values\n"); 1709 1710 #if IS_ENABLED(CONFIG_USB_PHY) 1711 if (info->nb.notifier_call) 1712 usb_unregister_notifier(info->usb_phy, &info->nb); 1713 #endif 1714 1715 cancel_delayed_work_sync(&info->pwr_rdy_work); 1716 cancel_delayed_work_sync(&info->max_charging_time_work); 1717 cancel_delayed_work_sync(&info->batt_presence_work); 1718 } 1719 1720 static const struct i2c_device_id rt9455_i2c_id_table[] = { 1721 { RT9455_DRIVER_NAME }, 1722 { } 1723 }; 1724 MODULE_DEVICE_TABLE(i2c, rt9455_i2c_id_table); 1725 1726 static const struct of_device_id rt9455_of_match[] __maybe_unused = { 1727 { .compatible = "richtek,rt9455", }, 1728 { }, 1729 }; 1730 MODULE_DEVICE_TABLE(of, rt9455_of_match); 1731 1732 #ifdef CONFIG_ACPI 1733 static const struct acpi_device_id rt9455_i2c_acpi_match[] = { 1734 { "RT945500", 0 }, 1735 { } 1736 }; 1737 MODULE_DEVICE_TABLE(acpi, rt9455_i2c_acpi_match); 1738 #endif 1739 1740 static struct i2c_driver rt9455_driver = { 1741 .probe = rt9455_probe, 1742 .remove = rt9455_remove, 1743 .id_table = rt9455_i2c_id_table, 1744 .driver = { 1745 .name = RT9455_DRIVER_NAME, 1746 .of_match_table = of_match_ptr(rt9455_of_match), 1747 .acpi_match_table = ACPI_PTR(rt9455_i2c_acpi_match), 1748 }, 1749 }; 1750 module_i2c_driver(rt9455_driver); 1751 1752 MODULE_LICENSE("GPL"); 1753 MODULE_AUTHOR("Anda-Maria Nicolae <anda-maria.nicolae@intel.com>"); 1754 MODULE_DESCRIPTION("Richtek RT9455 Charger Driver"); 1755