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