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