1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (C) 2022 Richtek Technology Corp. 4 * 5 * Author: ChiYuan Huang <cy_huang@richtek.com> 6 * ChiaEn Wu <chiaen_wu@richtek.com> 7 */ 8 9 #include <linux/bits.h> 10 #include <linux/bitfield.h> 11 #include <linux/completion.h> 12 #include <linux/delay.h> 13 #include <linux/gpio/consumer.h> 14 #include <linux/i2c.h> 15 #include <linux/interrupt.h> 16 #include <linux/kernel.h> 17 #include <linux/kstrtox.h> 18 #include <linux/linear_range.h> 19 #include <linux/module.h> 20 #include <linux/mod_devicetable.h> 21 #include <linux/mutex.h> 22 #include <linux/of.h> 23 #include <linux/power_supply.h> 24 #include <linux/regmap.h> 25 #include <linux/regulator/driver.h> 26 #include <linux/units.h> 27 #include <linux/sysfs.h> 28 29 #define RT9467_REG_CORE_CTRL0 0x00 30 #define RT9467_REG_CHG_CTRL1 0x01 31 #define RT9467_REG_CHG_CTRL2 0x02 32 #define RT9467_REG_CHG_CTRL3 0x03 33 #define RT9467_REG_CHG_CTRL4 0x04 34 #define RT9467_REG_CHG_CTRL5 0x05 35 #define RT9467_REG_CHG_CTRL6 0x06 36 #define RT9467_REG_CHG_CTRL7 0x07 37 #define RT9467_REG_CHG_CTRL8 0x08 38 #define RT9467_REG_CHG_CTRL9 0x09 39 #define RT9467_REG_CHG_CTRL10 0x0A 40 #define RT9467_REG_CHG_CTRL12 0x0C 41 #define RT9467_REG_CHG_CTRL13 0x0D 42 #define RT9467_REG_CHG_CTRL14 0x0E 43 #define RT9467_REG_CHG_ADC 0x11 44 #define RT9467_REG_CHG_DPDM1 0x12 45 #define RT9467_REG_CHG_DPDM2 0x13 46 #define RT9467_REG_DEVICE_ID 0x40 47 #define RT9467_REG_CHG_STAT 0x42 48 #define RT9467_REG_ADC_DATA_H 0x44 49 #define RT9467_REG_CHG_STATC 0x50 50 #define RT9467_REG_CHG_IRQ1 0x53 51 #define RT9467_REG_CHG_STATC_CTRL 0x60 52 #define RT9467_REG_CHG_IRQ1_CTRL 0x63 53 54 #define RT9467_MASK_PWR_RDY BIT(7) 55 #define RT9467_MASK_MIVR_STAT BIT(6) 56 #define RT9467_MASK_OTG_CSEL GENMASK(2, 0) 57 #define RT9467_MASK_OTG_VSEL GENMASK(7, 2) 58 #define RT9467_MASK_OTG_EN BIT(0) 59 #define RT9467_MASK_ADC_IN_SEL GENMASK(7, 4) 60 #define RT9467_MASK_ADC_START BIT(0) 61 62 #define RT9467_NUM_IRQ_REGS 4 63 #define RT9467_ICHG_MIN_uA 100000 64 #define RT9467_ICHG_MAX_uA 5000000 65 #define RT9467_CV_MAX_uV 4710000 66 #define RT9467_OTG_MIN_uV 4425000 67 #define RT9467_OTG_MAX_uV 5825000 68 #define RT9467_OTG_STEP_uV 25000 69 #define RT9467_NUM_VOTG (RT9467_OTG_MAX_uV - RT9467_OTG_MIN_uV + 1) 70 #define RT9467_AICLVTH_GAP_uV 200000 71 #define RT9467_ADCCONV_TIME_MS 35 72 73 #define RT9466_VID 0x8 74 #define RT9467_VID 0x9 75 76 /* IRQ number */ 77 #define RT9467_IRQ_TS_STATC 0 78 #define RT9467_IRQ_CHG_FAULT 1 79 #define RT9467_IRQ_CHG_STATC 2 80 #define RT9467_IRQ_CHG_TMR 3 81 #define RT9467_IRQ_CHG_BATABS 4 82 #define RT9467_IRQ_CHG_ADPBAD 5 83 #define RT9467_IRQ_CHG_RVP 6 84 #define RT9467_IRQ_OTP 7 85 86 #define RT9467_IRQ_CHG_AICLM 8 87 #define RT9467_IRQ_CHG_ICHGM 9 88 #define RT9467_IRQ_WDTMR 11 89 #define RT9467_IRQ_SSFINISH 12 90 #define RT9467_IRQ_CHG_RECHG 13 91 #define RT9467_IRQ_CHG_TERM 14 92 #define RT9467_IRQ_CHG_IEOC 15 93 94 #define RT9467_IRQ_ADC_DONE 16 95 #define RT9467_IRQ_PUMPX_DONE 17 96 #define RT9467_IRQ_BST_BATUV 21 97 #define RT9467_IRQ_BST_MIDOV 22 98 #define RT9467_IRQ_BST_OLP 23 99 100 #define RT9467_IRQ_ATTACH 24 101 #define RT9467_IRQ_DETACH 25 102 #define RT9467_IRQ_HVDCP_DET 29 103 #define RT9467_IRQ_CHGDET 30 104 #define RT9467_IRQ_DCDT 31 105 106 enum rt9467_fields { 107 /* RT9467_REG_CORE_CTRL0 */ 108 F_RST = 0, 109 /* RT9467_REG_CHG_CTRL1 */ 110 F_HZ, F_OTG_PIN_EN, F_OPA_MODE, 111 /* RT9467_REG_CHG_CTRL2 */ 112 F_SHIP_MODE, F_TE, F_IINLMTSEL, F_CFO_EN, F_CHG_EN, 113 /* RT9467_REG_CHG_CTRL3 */ 114 F_IAICR, F_ILIM_EN, 115 /* RT9467_REG_CHG_CTRL4 */ 116 F_VOREG, 117 /* RT9467_REG_CHG_CTRL6 */ 118 F_VMIVR, 119 /* RT9467_REG_CHG_CTRL7 */ 120 F_ICHG, 121 /* RT9467_REG_CHG_CTRL8 */ 122 F_IPREC, 123 /* RT9467_REG_CHG_CTRL9 */ 124 F_IEOC, 125 /* RT9467_REG_CHG_CTRL12 */ 126 F_WT_FC, 127 /* RT9467_REG_CHG_CTRL13 */ 128 F_OCP, 129 /* RT9467_REG_CHG_CTRL14 */ 130 F_AICL_MEAS, F_AICL_VTH, 131 /* RT9467_REG_CHG_DPDM1 */ 132 F_USBCHGEN, 133 /* RT9467_REG_CHG_DPDM2 */ 134 F_USB_STATUS, 135 /* RT9467_REG_DEVICE_ID */ 136 F_VENDOR, 137 /* RT9467_REG_CHG_STAT */ 138 F_CHG_STAT, 139 /* RT9467_REG_CHG_STATC */ 140 F_PWR_RDY, F_CHG_MIVR, 141 F_MAX_FIELDS 142 }; 143 144 static const struct regmap_irq rt9467_irqs[] = { 145 REGMAP_IRQ_REG_LINE(RT9467_IRQ_TS_STATC, 8), 146 REGMAP_IRQ_REG_LINE(RT9467_IRQ_CHG_FAULT, 8), 147 REGMAP_IRQ_REG_LINE(RT9467_IRQ_CHG_STATC, 8), 148 REGMAP_IRQ_REG_LINE(RT9467_IRQ_CHG_TMR, 8), 149 REGMAP_IRQ_REG_LINE(RT9467_IRQ_CHG_BATABS, 8), 150 REGMAP_IRQ_REG_LINE(RT9467_IRQ_CHG_ADPBAD, 8), 151 REGMAP_IRQ_REG_LINE(RT9467_IRQ_CHG_RVP, 8), 152 REGMAP_IRQ_REG_LINE(RT9467_IRQ_OTP, 8), 153 REGMAP_IRQ_REG_LINE(RT9467_IRQ_CHG_AICLM, 8), 154 REGMAP_IRQ_REG_LINE(RT9467_IRQ_CHG_ICHGM, 8), 155 REGMAP_IRQ_REG_LINE(RT9467_IRQ_WDTMR, 8), 156 REGMAP_IRQ_REG_LINE(RT9467_IRQ_SSFINISH, 8), 157 REGMAP_IRQ_REG_LINE(RT9467_IRQ_CHG_RECHG, 8), 158 REGMAP_IRQ_REG_LINE(RT9467_IRQ_CHG_TERM, 8), 159 REGMAP_IRQ_REG_LINE(RT9467_IRQ_CHG_IEOC, 8), 160 REGMAP_IRQ_REG_LINE(RT9467_IRQ_ADC_DONE, 8), 161 REGMAP_IRQ_REG_LINE(RT9467_IRQ_PUMPX_DONE, 8), 162 REGMAP_IRQ_REG_LINE(RT9467_IRQ_BST_BATUV, 8), 163 REGMAP_IRQ_REG_LINE(RT9467_IRQ_BST_MIDOV, 8), 164 REGMAP_IRQ_REG_LINE(RT9467_IRQ_BST_OLP, 8), 165 REGMAP_IRQ_REG_LINE(RT9467_IRQ_ATTACH, 8), 166 REGMAP_IRQ_REG_LINE(RT9467_IRQ_DETACH, 8), 167 REGMAP_IRQ_REG_LINE(RT9467_IRQ_HVDCP_DET, 8), 168 REGMAP_IRQ_REG_LINE(RT9467_IRQ_CHGDET, 8), 169 REGMAP_IRQ_REG_LINE(RT9467_IRQ_DCDT, 8) 170 }; 171 172 static const struct regmap_irq_chip rt9467_irq_chip = { 173 .name = "rt9467-irqs", 174 .status_base = RT9467_REG_CHG_IRQ1, 175 .mask_base = RT9467_REG_CHG_IRQ1_CTRL, 176 .num_regs = RT9467_NUM_IRQ_REGS, 177 .irqs = rt9467_irqs, 178 .num_irqs = ARRAY_SIZE(rt9467_irqs), 179 }; 180 181 enum rt9467_ranges { 182 RT9467_RANGE_IAICR = 0, 183 RT9467_RANGE_VOREG, 184 RT9467_RANGE_VMIVR, 185 RT9467_RANGE_ICHG, 186 RT9467_RANGE_IPREC, 187 RT9467_RANGE_IEOC, 188 RT9467_RANGE_AICL_VTH, 189 RT9467_RANGES_MAX 190 }; 191 192 static const struct linear_range rt9467_ranges[RT9467_RANGES_MAX] = { 193 LINEAR_RANGE_IDX(RT9467_RANGE_IAICR, 100000, 0x0, 0x3F, 50000), 194 LINEAR_RANGE_IDX(RT9467_RANGE_VOREG, 3900000, 0x0, 0x51, 10000), 195 LINEAR_RANGE_IDX(RT9467_RANGE_VMIVR, 3900000, 0x0, 0x5F, 100000), 196 LINEAR_RANGE_IDX(RT9467_RANGE_ICHG, 900000, 0x08, 0x31, 100000), 197 LINEAR_RANGE_IDX(RT9467_RANGE_IPREC, 100000, 0x0, 0x0F, 50000), 198 LINEAR_RANGE_IDX(RT9467_RANGE_IEOC, 100000, 0x0, 0x0F, 50000), 199 LINEAR_RANGE_IDX(RT9467_RANGE_AICL_VTH, 4100000, 0x0, 0x7, 100000), 200 }; 201 202 static const struct reg_field rt9467_chg_fields[] = { 203 [F_RST] = REG_FIELD(RT9467_REG_CORE_CTRL0, 7, 7), 204 [F_HZ] = REG_FIELD(RT9467_REG_CHG_CTRL1, 2, 2), 205 [F_OTG_PIN_EN] = REG_FIELD(RT9467_REG_CHG_CTRL1, 1, 1), 206 [F_OPA_MODE] = REG_FIELD(RT9467_REG_CHG_CTRL1, 0, 0), 207 [F_SHIP_MODE] = REG_FIELD(RT9467_REG_CHG_CTRL2, 7, 7), 208 [F_TE] = REG_FIELD(RT9467_REG_CHG_CTRL2, 4, 4), 209 [F_IINLMTSEL] = REG_FIELD(RT9467_REG_CHG_CTRL2, 2, 3), 210 [F_CFO_EN] = REG_FIELD(RT9467_REG_CHG_CTRL2, 1, 1), 211 [F_CHG_EN] = REG_FIELD(RT9467_REG_CHG_CTRL2, 0, 0), 212 [F_IAICR] = REG_FIELD(RT9467_REG_CHG_CTRL3, 2, 7), 213 [F_ILIM_EN] = REG_FIELD(RT9467_REG_CHG_CTRL3, 0, 0), 214 [F_VOREG] = REG_FIELD(RT9467_REG_CHG_CTRL4, 1, 7), 215 [F_VMIVR] = REG_FIELD(RT9467_REG_CHG_CTRL6, 1, 7), 216 [F_ICHG] = REG_FIELD(RT9467_REG_CHG_CTRL7, 2, 7), 217 [F_IPREC] = REG_FIELD(RT9467_REG_CHG_CTRL8, 0, 3), 218 [F_IEOC] = REG_FIELD(RT9467_REG_CHG_CTRL9, 4, 7), 219 [F_WT_FC] = REG_FIELD(RT9467_REG_CHG_CTRL12, 5, 7), 220 [F_OCP] = REG_FIELD(RT9467_REG_CHG_CTRL13, 2, 2), 221 [F_AICL_MEAS] = REG_FIELD(RT9467_REG_CHG_CTRL14, 7, 7), 222 [F_AICL_VTH] = REG_FIELD(RT9467_REG_CHG_CTRL14, 0, 2), 223 [F_USBCHGEN] = REG_FIELD(RT9467_REG_CHG_DPDM1, 7, 7), 224 [F_USB_STATUS] = REG_FIELD(RT9467_REG_CHG_DPDM2, 0, 2), 225 [F_VENDOR] = REG_FIELD(RT9467_REG_DEVICE_ID, 4, 7), 226 [F_CHG_STAT] = REG_FIELD(RT9467_REG_CHG_STAT, 6, 7), 227 [F_PWR_RDY] = REG_FIELD(RT9467_REG_CHG_STATC, 7, 7), 228 [F_CHG_MIVR] = REG_FIELD(RT9467_REG_CHG_STATC, 6, 6), 229 }; 230 231 enum { 232 RT9467_STAT_READY = 0, 233 RT9467_STAT_PROGRESS, 234 RT9467_STAT_CHARGE_DONE, 235 RT9467_STAT_FAULT 236 }; 237 238 enum rt9467_adc_chan { 239 RT9467_ADC_VBUS_DIV5 = 0, 240 RT9467_ADC_VBUS_DIV2, 241 RT9467_ADC_VSYS, 242 RT9467_ADC_VBAT, 243 RT9467_ADC_TS_BAT, 244 RT9467_ADC_IBUS, 245 RT9467_ADC_IBAT, 246 RT9467_ADC_REGN, 247 RT9467_ADC_TEMP_JC 248 }; 249 250 enum rt9467_chg_type { 251 RT9467_CHG_TYPE_NOVBUS = 0, 252 RT9467_CHG_TYPE_UNDER_GOING, 253 RT9467_CHG_TYPE_SDP, 254 RT9467_CHG_TYPE_SDPNSTD, 255 RT9467_CHG_TYPE_DCP, 256 RT9467_CHG_TYPE_CDP, 257 RT9467_CHG_TYPE_MAX 258 }; 259 260 enum rt9467_iin_limit_sel { 261 RT9467_IINLMTSEL_3_2A = 0, 262 RT9467_IINLMTSEL_CHG_TYP, 263 RT9467_IINLMTSEL_AICR, 264 RT9467_IINLMTSEL_LOWER_LEVEL, /* lower of above three */ 265 }; 266 267 struct rt9467_chg_data { 268 struct device *dev; 269 struct regmap *regmap; 270 struct regmap_field *rm_field[F_MAX_FIELDS]; 271 struct regmap_irq_chip_data *irq_chip_data; 272 struct power_supply *psy; 273 struct mutex adc_lock; 274 struct mutex attach_lock; 275 struct mutex ichg_ieoc_lock; 276 struct regulator_dev *rdev; 277 struct completion aicl_done; 278 enum power_supply_usb_type psy_usb_type; 279 unsigned int old_stat; 280 unsigned int vid; 281 int ichg_ua; 282 int ieoc_ua; 283 }; 284 285 static int rt9467_otg_of_parse_cb(struct device_node *of, 286 const struct regulator_desc *desc, 287 struct regulator_config *cfg) 288 { 289 struct rt9467_chg_data *data = cfg->driver_data; 290 291 cfg->ena_gpiod = fwnode_gpiod_get_index(of_fwnode_handle(of), 292 "enable", 0, GPIOD_OUT_LOW | 293 GPIOD_FLAGS_BIT_NONEXCLUSIVE, 294 desc->name); 295 if (IS_ERR(cfg->ena_gpiod)) { 296 cfg->ena_gpiod = NULL; 297 return 0; 298 } 299 300 return regmap_field_write(data->rm_field[F_OTG_PIN_EN], 1); 301 } 302 303 static const struct regulator_ops rt9467_otg_regulator_ops = { 304 .enable = regulator_enable_regmap, 305 .disable = regulator_disable_regmap, 306 .is_enabled = regulator_is_enabled_regmap, 307 .list_voltage = regulator_list_voltage_linear, 308 .set_voltage_sel = regulator_set_voltage_sel_regmap, 309 .get_voltage_sel = regulator_get_voltage_sel_regmap, 310 .set_current_limit = regulator_set_current_limit_regmap, 311 .get_current_limit = regulator_get_current_limit_regmap, 312 }; 313 314 static const u32 rt9467_otg_microamp[] = { 315 500000, 700000, 1100000, 1300000, 1800000, 2100000, 2400000, 3000000 316 }; 317 318 static const struct regulator_desc rt9467_otg_desc = { 319 .name = "rt9476-usb-otg-vbus", 320 .of_match = "usb-otg-vbus-regulator", 321 .of_parse_cb = rt9467_otg_of_parse_cb, 322 .type = REGULATOR_VOLTAGE, 323 .owner = THIS_MODULE, 324 .min_uV = RT9467_OTG_MIN_uV, 325 .uV_step = RT9467_OTG_STEP_uV, 326 .n_voltages = RT9467_NUM_VOTG, 327 .curr_table = rt9467_otg_microamp, 328 .n_current_limits = ARRAY_SIZE(rt9467_otg_microamp), 329 .csel_reg = RT9467_REG_CHG_CTRL10, 330 .csel_mask = RT9467_MASK_OTG_CSEL, 331 .vsel_reg = RT9467_REG_CHG_CTRL5, 332 .vsel_mask = RT9467_MASK_OTG_VSEL, 333 .enable_reg = RT9467_REG_CHG_CTRL1, 334 .enable_mask = RT9467_MASK_OTG_EN, 335 .ops = &rt9467_otg_regulator_ops, 336 }; 337 338 static int rt9467_register_otg_regulator(struct rt9467_chg_data *data) 339 { 340 struct regulator_config cfg = { 341 .dev = data->dev, 342 .regmap = data->regmap, 343 .driver_data = data, 344 }; 345 346 data->rdev = devm_regulator_register(data->dev, &rt9467_otg_desc, &cfg); 347 return PTR_ERR_OR_ZERO(data->rdev); 348 } 349 350 static int rt9467_get_value_from_ranges(struct rt9467_chg_data *data, 351 enum rt9467_fields field, 352 enum rt9467_ranges rsel, 353 int *value) 354 { 355 const struct linear_range *range = rt9467_ranges + rsel; 356 unsigned int sel; 357 int ret; 358 359 ret = regmap_field_read(data->rm_field[field], &sel); 360 if (ret) 361 return ret; 362 363 return linear_range_get_value(range, sel, value); 364 } 365 366 static int rt9467_set_value_from_ranges(struct rt9467_chg_data *data, 367 enum rt9467_fields field, 368 enum rt9467_ranges rsel, 369 int value) 370 { 371 const struct linear_range *range = rt9467_ranges + rsel; 372 unsigned int sel; 373 bool found; 374 int ret; 375 376 if (rsel == RT9467_RANGE_VMIVR) { 377 ret = linear_range_get_selector_high(range, value, &sel, &found); 378 if (ret) 379 sel = range->max_sel; 380 } else { 381 linear_range_get_selector_within(range, value, &sel); 382 } 383 384 return regmap_field_write(data->rm_field[field], sel); 385 } 386 387 static int rt9467_get_adc_sel(enum rt9467_adc_chan chan, int *sel) 388 { 389 switch (chan) { 390 case RT9467_ADC_VBUS_DIV5: 391 case RT9467_ADC_VBUS_DIV2: 392 case RT9467_ADC_VSYS: 393 case RT9467_ADC_VBAT: 394 *sel = chan + 1; 395 return 0; 396 case RT9467_ADC_TS_BAT: 397 *sel = chan + 2; 398 return 0; 399 case RT9467_ADC_IBUS: 400 case RT9467_ADC_IBAT: 401 *sel = chan + 3; 402 return 0; 403 case RT9467_ADC_REGN: 404 case RT9467_ADC_TEMP_JC: 405 *sel = chan + 4; 406 return 0; 407 default: 408 return -EINVAL; 409 } 410 } 411 412 static int rt9467_get_adc_raw_data(struct rt9467_chg_data *data, 413 enum rt9467_adc_chan chan, int *val) 414 { 415 unsigned int adc_stat, reg_val, adc_sel; 416 __be16 chan_raw_data; 417 int ret; 418 419 mutex_lock(&data->adc_lock); 420 421 ret = rt9467_get_adc_sel(chan, &adc_sel); 422 if (ret) 423 goto adc_unlock; 424 425 ret = regmap_write(data->regmap, RT9467_REG_CHG_ADC, 0); 426 if (ret) { 427 dev_err(data->dev, "Failed to clear ADC enable\n"); 428 goto adc_unlock; 429 } 430 431 reg_val = RT9467_MASK_ADC_START | FIELD_PREP(RT9467_MASK_ADC_IN_SEL, adc_sel); 432 ret = regmap_write(data->regmap, RT9467_REG_CHG_ADC, reg_val); 433 if (ret) 434 goto adc_unlock; 435 436 /* Minimum wait time for one channel processing */ 437 msleep(RT9467_ADCCONV_TIME_MS); 438 439 ret = regmap_read_poll_timeout(data->regmap, RT9467_REG_CHG_ADC, 440 adc_stat, 441 !(adc_stat & RT9467_MASK_ADC_START), 442 MILLI, RT9467_ADCCONV_TIME_MS * MILLI); 443 if (ret) { 444 dev_err(data->dev, "Failed to wait ADC conversion, chan = %d\n", chan); 445 goto adc_unlock; 446 } 447 448 ret = regmap_raw_read(data->regmap, RT9467_REG_ADC_DATA_H, 449 &chan_raw_data, sizeof(chan_raw_data)); 450 if (ret) 451 goto adc_unlock; 452 453 *val = be16_to_cpu(chan_raw_data); 454 455 adc_unlock: 456 mutex_unlock(&data->adc_lock); 457 return ret; 458 } 459 460 static int rt9467_get_adc(struct rt9467_chg_data *data, 461 enum rt9467_adc_chan chan, int *val) 462 { 463 unsigned int aicr_ua, ichg_ua; 464 int ret; 465 466 ret = rt9467_get_adc_raw_data(data, chan, val); 467 if (ret) 468 return ret; 469 470 switch (chan) { 471 case RT9467_ADC_VBUS_DIV5: 472 *val *= 25000; 473 return 0; 474 case RT9467_ADC_VBUS_DIV2: 475 *val *= 10000; 476 return 0; 477 case RT9467_ADC_VBAT: 478 case RT9467_ADC_VSYS: 479 case RT9467_ADC_REGN: 480 *val *= 5000; 481 return 0; 482 case RT9467_ADC_TS_BAT: 483 *val /= 400; 484 return 0; 485 case RT9467_ADC_IBUS: 486 /* UUG MOS turn-on ratio will affect the IBUS adc scale */ 487 ret = rt9467_get_value_from_ranges(data, F_IAICR, 488 RT9467_RANGE_IAICR, &aicr_ua); 489 if (ret) 490 return ret; 491 492 *val *= aicr_ua < 400000 ? 29480 : 50000; 493 return 0; 494 case RT9467_ADC_IBAT: 495 /* PP MOS turn-on ratio will affect the ICHG adc scale */ 496 ret = rt9467_get_value_from_ranges(data, F_ICHG, 497 RT9467_RANGE_ICHG, &ichg_ua); 498 if (ret) 499 return ret; 500 501 *val *= ichg_ua <= 400000 ? 28500 : 502 ichg_ua <= 800000 ? 31500 : 500000; 503 return 0; 504 case RT9467_ADC_TEMP_JC: 505 *val = ((*val * 2) - 40) * 10; 506 return 0; 507 default: 508 return -EINVAL; 509 } 510 } 511 512 static int rt9467_psy_get_status(struct rt9467_chg_data *data, int *state) 513 { 514 unsigned int status; 515 int ret; 516 517 ret = regmap_field_read(data->rm_field[F_CHG_STAT], &status); 518 if (ret) 519 return ret; 520 521 switch (status) { 522 case RT9467_STAT_READY: 523 *state = POWER_SUPPLY_STATUS_NOT_CHARGING; 524 return 0; 525 case RT9467_STAT_PROGRESS: 526 *state = POWER_SUPPLY_STATUS_CHARGING; 527 return 0; 528 case RT9467_STAT_CHARGE_DONE: 529 *state = POWER_SUPPLY_STATUS_FULL; 530 return 0; 531 default: 532 *state = POWER_SUPPLY_STATUS_UNKNOWN; 533 return 0; 534 } 535 } 536 537 static int rt9467_psy_set_ichg(struct rt9467_chg_data *data, int microamp) 538 { 539 int ret; 540 541 mutex_lock(&data->ichg_ieoc_lock); 542 543 if (microamp < 500000) { 544 dev_err(data->dev, "Minimum value must be 500mA\n"); 545 microamp = 500000; 546 } 547 548 ret = rt9467_set_value_from_ranges(data, F_ICHG, RT9467_RANGE_ICHG, microamp); 549 if (ret) 550 goto out; 551 552 ret = rt9467_get_value_from_ranges(data, F_ICHG, RT9467_RANGE_ICHG, 553 &data->ichg_ua); 554 if (ret) 555 goto out; 556 557 out: 558 mutex_unlock(&data->ichg_ieoc_lock); 559 return ret; 560 } 561 562 static int rt9467_run_aicl(struct rt9467_chg_data *data) 563 { 564 unsigned int statc, aicl_vth; 565 int mivr_vth, aicr_get; 566 int ret = 0; 567 568 569 ret = regmap_read(data->regmap, RT9467_REG_CHG_STATC, &statc); 570 if (ret) { 571 dev_err(data->dev, "Failed to read status\n"); 572 return ret; 573 } 574 575 if (!(statc & RT9467_MASK_PWR_RDY) || !(statc & RT9467_MASK_MIVR_STAT)) { 576 dev_info(data->dev, "Condition not matched %d\n", statc); 577 return 0; 578 } 579 580 ret = rt9467_get_value_from_ranges(data, F_VMIVR, RT9467_RANGE_VMIVR, 581 &mivr_vth); 582 if (ret) { 583 dev_err(data->dev, "Failed to get mivr\n"); 584 return ret; 585 } 586 587 /* AICL_VTH = MIVR_VTH + 200mV */ 588 aicl_vth = mivr_vth + RT9467_AICLVTH_GAP_uV; 589 ret = rt9467_set_value_from_ranges(data, F_AICL_VTH, 590 RT9467_RANGE_AICL_VTH, aicl_vth); 591 if (ret) { 592 dev_err(data->dev, "Failed to set AICL VTH\n"); 593 return ret; 594 } 595 596 /* Trigger AICL function */ 597 ret = regmap_field_write(data->rm_field[F_AICL_MEAS], 1); 598 if (ret) { 599 dev_err(data->dev, "Failed to set aicl measurement\n"); 600 return ret; 601 } 602 603 reinit_completion(&data->aicl_done); 604 ret = wait_for_completion_timeout(&data->aicl_done, msecs_to_jiffies(3500)); 605 if (ret == 0) 606 return -ETIMEDOUT; 607 608 ret = rt9467_get_value_from_ranges(data, F_IAICR, RT9467_RANGE_IAICR, &aicr_get); 609 if (ret) { 610 dev_err(data->dev, "Failed to get aicr\n"); 611 return ret; 612 } 613 614 dev_info(data->dev, "aicr get = %d uA\n", aicr_get); 615 return 0; 616 } 617 618 static int rt9467_psy_set_ieoc(struct rt9467_chg_data *data, int microamp) 619 { 620 int ret; 621 622 mutex_lock(&data->ichg_ieoc_lock); 623 624 ret = rt9467_set_value_from_ranges(data, F_IEOC, RT9467_RANGE_IEOC, microamp); 625 if (ret) 626 goto out; 627 628 ret = rt9467_get_value_from_ranges(data, F_IEOC, RT9467_RANGE_IEOC, &data->ieoc_ua); 629 if (ret) 630 goto out; 631 632 out: 633 mutex_unlock(&data->ichg_ieoc_lock); 634 return ret; 635 } 636 637 static const enum power_supply_property rt9467_chg_properties[] = { 638 POWER_SUPPLY_PROP_STATUS, 639 POWER_SUPPLY_PROP_ONLINE, 640 POWER_SUPPLY_PROP_VOLTAGE_NOW, 641 POWER_SUPPLY_PROP_CURRENT_MAX, 642 POWER_SUPPLY_PROP_CURRENT_NOW, 643 POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT, 644 POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX, 645 POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE, 646 POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX, 647 POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT, 648 POWER_SUPPLY_PROP_INPUT_VOLTAGE_LIMIT, 649 POWER_SUPPLY_PROP_USB_TYPE, 650 POWER_SUPPLY_PROP_PRECHARGE_CURRENT, 651 POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT, 652 }; 653 654 static int rt9467_psy_get_property(struct power_supply *psy, 655 enum power_supply_property psp, 656 union power_supply_propval *val) 657 { 658 struct rt9467_chg_data *data = power_supply_get_drvdata(psy); 659 660 switch (psp) { 661 case POWER_SUPPLY_PROP_STATUS: 662 return rt9467_psy_get_status(data, &val->intval); 663 case POWER_SUPPLY_PROP_ONLINE: 664 return regmap_field_read(data->rm_field[F_PWR_RDY], &val->intval); 665 case POWER_SUPPLY_PROP_VOLTAGE_NOW: 666 return rt9467_get_adc(data, RT9467_ADC_VBUS_DIV5, &val->intval); 667 case POWER_SUPPLY_PROP_CURRENT_MAX: 668 mutex_lock(&data->attach_lock); 669 if (data->psy_usb_type == POWER_SUPPLY_USB_TYPE_UNKNOWN || 670 data->psy_usb_type == POWER_SUPPLY_USB_TYPE_SDP) 671 val->intval = 500000; 672 else 673 val->intval = 1500000; 674 mutex_unlock(&data->attach_lock); 675 return 0; 676 case POWER_SUPPLY_PROP_CURRENT_NOW: 677 return rt9467_get_adc(data, RT9467_ADC_IBUS, &val->intval); 678 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT: 679 mutex_lock(&data->ichg_ieoc_lock); 680 val->intval = data->ichg_ua; 681 mutex_unlock(&data->ichg_ieoc_lock); 682 return 0; 683 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX: 684 val->intval = RT9467_ICHG_MAX_uA; 685 return 0; 686 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE: 687 return rt9467_get_value_from_ranges(data, F_VOREG, 688 RT9467_RANGE_VOREG, 689 &val->intval); 690 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX: 691 val->intval = RT9467_CV_MAX_uV; 692 return 0; 693 case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT: 694 return rt9467_get_value_from_ranges(data, F_IAICR, 695 RT9467_RANGE_IAICR, 696 &val->intval); 697 case POWER_SUPPLY_PROP_INPUT_VOLTAGE_LIMIT: 698 return rt9467_get_value_from_ranges(data, F_VMIVR, 699 RT9467_RANGE_VMIVR, 700 &val->intval); 701 case POWER_SUPPLY_PROP_USB_TYPE: 702 mutex_lock(&data->attach_lock); 703 val->intval = data->psy_usb_type; 704 mutex_unlock(&data->attach_lock); 705 return 0; 706 case POWER_SUPPLY_PROP_PRECHARGE_CURRENT: 707 return rt9467_get_value_from_ranges(data, F_IPREC, 708 RT9467_RANGE_IPREC, 709 &val->intval); 710 case POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT: 711 mutex_lock(&data->ichg_ieoc_lock); 712 val->intval = data->ieoc_ua; 713 mutex_unlock(&data->ichg_ieoc_lock); 714 return 0; 715 default: 716 return -ENODATA; 717 } 718 } 719 720 static int rt9467_psy_set_property(struct power_supply *psy, 721 enum power_supply_property psp, 722 const union power_supply_propval *val) 723 { 724 struct rt9467_chg_data *data = power_supply_get_drvdata(psy); 725 726 switch (psp) { 727 case POWER_SUPPLY_PROP_STATUS: 728 return regmap_field_write(data->rm_field[F_CHG_EN], val->intval); 729 case POWER_SUPPLY_PROP_ONLINE: 730 return regmap_field_write(data->rm_field[F_HZ], val->intval); 731 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT: 732 return rt9467_psy_set_ichg(data, val->intval); 733 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE: 734 return rt9467_set_value_from_ranges(data, F_VOREG, 735 RT9467_RANGE_VOREG, val->intval); 736 case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT: 737 if (val->intval == -1) 738 return rt9467_run_aicl(data); 739 else 740 return rt9467_set_value_from_ranges(data, F_IAICR, 741 RT9467_RANGE_IAICR, 742 val->intval); 743 case POWER_SUPPLY_PROP_INPUT_VOLTAGE_LIMIT: 744 return rt9467_set_value_from_ranges(data, F_VMIVR, 745 RT9467_RANGE_VMIVR, val->intval); 746 case POWER_SUPPLY_PROP_PRECHARGE_CURRENT: 747 return rt9467_set_value_from_ranges(data, F_IPREC, 748 RT9467_RANGE_IPREC, val->intval); 749 case POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT: 750 return rt9467_psy_set_ieoc(data, val->intval); 751 default: 752 return -EINVAL; 753 } 754 } 755 756 static int rt9467_chg_prop_is_writeable(struct power_supply *psy, 757 enum power_supply_property psp) 758 { 759 switch (psp) { 760 case POWER_SUPPLY_PROP_STATUS: 761 case POWER_SUPPLY_PROP_ONLINE: 762 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT: 763 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE: 764 case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT: 765 case POWER_SUPPLY_PROP_INPUT_VOLTAGE_LIMIT: 766 case POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT: 767 case POWER_SUPPLY_PROP_PRECHARGE_CURRENT: 768 return 1; 769 default: 770 return 0; 771 } 772 } 773 774 static const struct power_supply_desc rt9467_chg_psy_desc = { 775 .name = "rt9467-charger", 776 .type = POWER_SUPPLY_TYPE_USB, 777 .usb_types = BIT(POWER_SUPPLY_USB_TYPE_SDP) | 778 BIT(POWER_SUPPLY_USB_TYPE_CDP) | 779 BIT(POWER_SUPPLY_USB_TYPE_DCP) | 780 BIT(POWER_SUPPLY_USB_TYPE_UNKNOWN), 781 .properties = rt9467_chg_properties, 782 .num_properties = ARRAY_SIZE(rt9467_chg_properties), 783 .property_is_writeable = rt9467_chg_prop_is_writeable, 784 .get_property = rt9467_psy_get_property, 785 .set_property = rt9467_psy_set_property, 786 }; 787 788 static inline struct rt9467_chg_data *psy_device_to_chip(struct device *dev) 789 { 790 return power_supply_get_drvdata(to_power_supply(dev)); 791 } 792 793 static ssize_t sysoff_enable_show(struct device *dev, 794 struct device_attribute *attr, char *buf) 795 { 796 struct rt9467_chg_data *data = psy_device_to_chip(dev); 797 unsigned int sysoff_enable; 798 int ret; 799 800 ret = regmap_field_read(data->rm_field[F_SHIP_MODE], &sysoff_enable); 801 if (ret) 802 return ret; 803 804 return sysfs_emit(buf, "%d\n", sysoff_enable); 805 } 806 807 static ssize_t sysoff_enable_store(struct device *dev, 808 struct device_attribute *attr, 809 const char *buf, size_t count) 810 { 811 struct rt9467_chg_data *data = psy_device_to_chip(dev); 812 unsigned int tmp; 813 int ret; 814 815 ret = kstrtouint(buf, 10, &tmp); 816 if (ret) 817 return ret; 818 819 ret = regmap_field_write(data->rm_field[F_SHIP_MODE], !!tmp); 820 if (ret) 821 return ret; 822 823 return count; 824 } 825 826 static DEVICE_ATTR_RW(sysoff_enable); 827 828 static struct attribute *rt9467_sysfs_attrs[] = { 829 &dev_attr_sysoff_enable.attr, 830 NULL 831 }; 832 833 ATTRIBUTE_GROUPS(rt9467_sysfs); 834 835 static int rt9467_register_psy(struct rt9467_chg_data *data) 836 { 837 struct power_supply_config cfg = { 838 .drv_data = data, 839 .fwnode = dev_fwnode(data->dev), 840 .attr_grp = rt9467_sysfs_groups, 841 }; 842 843 data->psy = devm_power_supply_register(data->dev, &rt9467_chg_psy_desc, 844 &cfg); 845 return PTR_ERR_OR_ZERO(data->psy); 846 } 847 848 static int rt9467_mivr_handler(struct rt9467_chg_data *data) 849 { 850 unsigned int mivr_act; 851 int ret, ibus_ma; 852 853 /* 854 * back-boost workaround 855 * If (mivr_active & ibus < 100mA), toggle cfo bit 856 */ 857 ret = regmap_field_read(data->rm_field[F_CHG_MIVR], &mivr_act); 858 if (ret) { 859 dev_err(data->dev, "Failed to read MIVR stat\n"); 860 return ret; 861 } 862 863 if (!mivr_act) 864 return 0; 865 866 ret = rt9467_get_adc(data, RT9467_ADC_IBUS, &ibus_ma); 867 if (ret) { 868 dev_err(data->dev, "Failed to get IBUS\n"); 869 return ret; 870 } 871 872 if (ibus_ma < 100000) { 873 ret = regmap_field_write(data->rm_field[F_CFO_EN], 0); 874 ret |= regmap_field_write(data->rm_field[F_CFO_EN], 1); 875 if (ret) 876 dev_err(data->dev, "Failed to toggle cfo\n"); 877 } 878 879 return ret; 880 } 881 882 static irqreturn_t rt9467_statc_handler(int irq, void *priv) 883 { 884 struct rt9467_chg_data *data = priv; 885 unsigned int new_stat, evts = 0; 886 int ret; 887 888 ret = regmap_read(data->regmap, RT9467_REG_CHG_STATC, &new_stat); 889 if (ret) { 890 dev_err(data->dev, "Failed to read chg_statc\n"); 891 return IRQ_NONE; 892 } 893 894 evts = data->old_stat ^ new_stat; 895 data->old_stat = new_stat; 896 897 if ((evts & new_stat) & RT9467_MASK_MIVR_STAT) { 898 ret = rt9467_mivr_handler(data); 899 if (ret) 900 dev_err(data->dev, "Failed to handle mivr stat\n"); 901 } 902 903 return IRQ_HANDLED; 904 } 905 906 static irqreturn_t rt9467_wdt_handler(int irq, void *priv) 907 { 908 struct rt9467_chg_data *data = priv; 909 unsigned int dev_id; 910 int ret; 911 912 /* Any i2c communication can kick watchdog timer */ 913 ret = regmap_read(data->regmap, RT9467_REG_DEVICE_ID, &dev_id); 914 if (ret) { 915 dev_err(data->dev, "Failed to kick wdt (%d)\n", ret); 916 return IRQ_NONE; 917 } 918 919 return IRQ_HANDLED; 920 } 921 922 static int rt9467_report_usb_state(struct rt9467_chg_data *data) 923 { 924 unsigned int usb_stat, power_ready; 925 bool psy_changed = true; 926 int ret; 927 928 ret = regmap_field_read(data->rm_field[F_USB_STATUS], &usb_stat); 929 ret |= regmap_field_read(data->rm_field[F_PWR_RDY], &power_ready); 930 if (ret) 931 return ret; 932 933 if (!power_ready) 934 usb_stat = RT9467_CHG_TYPE_NOVBUS; 935 936 mutex_lock(&data->attach_lock); 937 938 switch (usb_stat) { 939 case RT9467_CHG_TYPE_NOVBUS: 940 data->psy_usb_type = POWER_SUPPLY_USB_TYPE_UNKNOWN; 941 break; 942 case RT9467_CHG_TYPE_SDP: 943 data->psy_usb_type = POWER_SUPPLY_USB_TYPE_SDP; 944 break; 945 case RT9467_CHG_TYPE_SDPNSTD: 946 data->psy_usb_type = POWER_SUPPLY_USB_TYPE_DCP; 947 break; 948 case RT9467_CHG_TYPE_DCP: 949 data->psy_usb_type = POWER_SUPPLY_USB_TYPE_DCP; 950 break; 951 case RT9467_CHG_TYPE_CDP: 952 data->psy_usb_type = POWER_SUPPLY_USB_TYPE_CDP; 953 break; 954 case RT9467_CHG_TYPE_UNDER_GOING: 955 default: 956 psy_changed = false; 957 break; 958 } 959 960 mutex_unlock(&data->attach_lock); 961 962 if (psy_changed) 963 power_supply_changed(data->psy); 964 965 return 0; 966 } 967 968 static irqreturn_t rt9467_usb_state_handler(int irq, void *priv) 969 { 970 struct rt9467_chg_data *data = priv; 971 int ret; 972 973 ret = rt9467_report_usb_state(data); 974 if (ret) { 975 dev_err(data->dev, "Failed to report attach type (%d)\n", ret); 976 return IRQ_NONE; 977 } 978 979 return IRQ_HANDLED; 980 } 981 982 static irqreturn_t rt9467_aiclmeas_handler(int irq, void *priv) 983 { 984 struct rt9467_chg_data *data = priv; 985 986 complete(&data->aicl_done); 987 return IRQ_HANDLED; 988 } 989 990 #define RT9467_IRQ_DESC(_name, _handler_func, _hwirq) \ 991 { \ 992 .name = #_name, \ 993 .handler = rt9467_##_handler_func##_handler, \ 994 .hwirq = _hwirq, \ 995 } 996 997 static int rt9467_request_interrupt(struct rt9467_chg_data *data) 998 { 999 struct device *dev = data->dev; 1000 static const struct { 1001 const char *name; 1002 int hwirq; 1003 irq_handler_t handler; 1004 } rt9467_exclusive_irqs[] = { 1005 RT9467_IRQ_DESC(statc, statc, RT9467_IRQ_TS_STATC), 1006 RT9467_IRQ_DESC(wdt, wdt, RT9467_IRQ_WDTMR), 1007 RT9467_IRQ_DESC(attach, usb_state, RT9467_IRQ_ATTACH), 1008 RT9467_IRQ_DESC(detach, usb_state, RT9467_IRQ_DETACH), 1009 RT9467_IRQ_DESC(aiclmeas, aiclmeas, RT9467_IRQ_CHG_AICLM), 1010 }, rt9466_exclusive_irqs[] = { 1011 RT9467_IRQ_DESC(statc, statc, RT9467_IRQ_TS_STATC), 1012 RT9467_IRQ_DESC(wdt, wdt, RT9467_IRQ_WDTMR), 1013 RT9467_IRQ_DESC(aiclmeas, aiclmeas, RT9467_IRQ_CHG_AICLM), 1014 }, *chg_irqs; 1015 int num_chg_irqs, i, virq, ret; 1016 1017 if (data->vid == RT9466_VID) { 1018 chg_irqs = rt9466_exclusive_irqs; 1019 num_chg_irqs = ARRAY_SIZE(rt9466_exclusive_irqs); 1020 } else { 1021 chg_irqs = rt9467_exclusive_irqs; 1022 num_chg_irqs = ARRAY_SIZE(rt9467_exclusive_irqs); 1023 } 1024 1025 for (i = 0; i < num_chg_irqs; i++) { 1026 virq = regmap_irq_get_virq(data->irq_chip_data, chg_irqs[i].hwirq); 1027 if (virq <= 0) 1028 return dev_err_probe(dev, -EINVAL, "Failed to get (%s) irq\n", 1029 chg_irqs[i].name); 1030 1031 ret = devm_request_threaded_irq(dev, virq, NULL, chg_irqs[i].handler, 1032 IRQF_ONESHOT, chg_irqs[i].name, data); 1033 if (ret) 1034 return dev_err_probe(dev, ret, "Failed to request (%s) irq\n", 1035 chg_irqs[i].name); 1036 } 1037 1038 return 0; 1039 } 1040 1041 static int rt9467_do_charger_init(struct rt9467_chg_data *data) 1042 { 1043 struct device *dev = data->dev; 1044 int ret; 1045 1046 ret = regmap_write(data->regmap, RT9467_REG_CHG_ADC, 0); 1047 if (ret) 1048 return dev_err_probe(dev, ret, "Failed to reset ADC\n"); 1049 1050 ret = rt9467_get_value_from_ranges(data, F_ICHG, RT9467_RANGE_ICHG, 1051 &data->ichg_ua); 1052 ret |= rt9467_get_value_from_ranges(data, F_IEOC, RT9467_RANGE_IEOC, 1053 &data->ieoc_ua); 1054 if (ret) 1055 return dev_err_probe(dev, ret, "Failed to init ichg/ieoc value\n"); 1056 1057 ret = regmap_update_bits(data->regmap, RT9467_REG_CHG_STATC_CTRL, 1058 RT9467_MASK_PWR_RDY | RT9467_MASK_MIVR_STAT, 0); 1059 if (ret) 1060 return dev_err_probe(dev, ret, "Failed to make statc unmask\n"); 1061 1062 /* Select IINLMTSEL to use AICR */ 1063 ret = regmap_field_write(data->rm_field[F_IINLMTSEL], 1064 RT9467_IINLMTSEL_AICR); 1065 if (ret) 1066 return dev_err_probe(dev, ret, "Failed to set iinlmtsel to AICR\n"); 1067 1068 /* Wait for AICR Rampping */ 1069 msleep(150); 1070 1071 /* Disable hardware ILIM */ 1072 ret = regmap_field_write(data->rm_field[F_ILIM_EN], 0); 1073 if (ret) 1074 return dev_err_probe(dev, ret, "Failed to disable hardware ILIM\n"); 1075 1076 /* Set inductor OCP to high level */ 1077 ret = regmap_field_write(data->rm_field[F_OCP], 1); 1078 if (ret) 1079 return dev_err_probe(dev, ret, "Failed to set higher inductor OCP level\n"); 1080 1081 /* Set charge termination default enable */ 1082 ret = regmap_field_write(data->rm_field[F_TE], 1); 1083 if (ret) 1084 return dev_err_probe(dev, ret, "Failed to set TE=1\n"); 1085 1086 /* Set 12hrs fast charger timer */ 1087 ret = regmap_field_write(data->rm_field[F_WT_FC], 4); 1088 if (ret) 1089 return dev_err_probe(dev, ret, "Failed to set WT_FC\n"); 1090 1091 /* Toggle BC12 function */ 1092 ret = regmap_field_write(data->rm_field[F_USBCHGEN], 0); 1093 if (ret) 1094 return dev_err_probe(dev, ret, "Failed to disable BC12\n"); 1095 1096 return regmap_field_write(data->rm_field[F_USBCHGEN], 1); 1097 } 1098 1099 static bool rt9467_is_accessible_reg(struct device *dev, unsigned int reg) 1100 { 1101 switch (reg) { 1102 case 0x00 ... 0x1A: 1103 case 0x20 ... 0x38: 1104 case 0x40 ... 0x49: 1105 case 0x50 ... 0x57: 1106 case 0x60 ... 0x67: 1107 case 0x70 ... 0x79: 1108 case 0x82 ... 0x85: 1109 return true; 1110 default: 1111 return false; 1112 } 1113 } 1114 1115 static const struct regmap_config rt9467_regmap_config = { 1116 .reg_bits = 8, 1117 .val_bits = 8, 1118 .max_register = 0x85, 1119 .writeable_reg = rt9467_is_accessible_reg, 1120 .readable_reg = rt9467_is_accessible_reg, 1121 }; 1122 1123 static int rt9467_check_vendor_info(struct rt9467_chg_data *data) 1124 { 1125 unsigned int vid; 1126 int ret; 1127 1128 ret = regmap_field_read(data->rm_field[F_VENDOR], &vid); 1129 if (ret) { 1130 dev_err(data->dev, "Failed to get vid\n"); 1131 return ret; 1132 } 1133 1134 if ((vid != RT9466_VID) && (vid != RT9467_VID)) 1135 return dev_err_probe(data->dev, -ENODEV, 1136 "VID not correct [0x%02X]\n", vid); 1137 1138 data->vid = vid; 1139 return 0; 1140 } 1141 1142 static int rt9467_reset_chip(struct rt9467_chg_data *data) 1143 { 1144 int ret; 1145 1146 /* Disable HZ before reset chip */ 1147 ret = regmap_field_write(data->rm_field[F_HZ], 0); 1148 if (ret) 1149 return ret; 1150 1151 return regmap_field_write(data->rm_field[F_RST], 1); 1152 } 1153 1154 static void rt9467_chg_complete_aicl_done(void *data) 1155 { 1156 struct completion *aicl_done = data; 1157 1158 complete(aicl_done); 1159 } 1160 1161 static int rt9467_charger_probe(struct i2c_client *i2c) 1162 { 1163 struct device *dev = &i2c->dev; 1164 struct rt9467_chg_data *data; 1165 struct gpio_desc *ceb_gpio; 1166 int ret; 1167 1168 data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL); 1169 if (!data) 1170 return -ENOMEM; 1171 1172 data->dev = &i2c->dev; 1173 i2c_set_clientdata(i2c, data); 1174 1175 /* Default pull charge enable gpio to make 'CHG_EN' by SW control only */ 1176 ceb_gpio = devm_gpiod_get_optional(dev, "charge-enable", GPIOD_OUT_HIGH); 1177 if (IS_ERR(ceb_gpio)) 1178 return dev_err_probe(dev, PTR_ERR(ceb_gpio), 1179 "Failed to config charge enable gpio\n"); 1180 1181 data->regmap = devm_regmap_init_i2c(i2c, &rt9467_regmap_config); 1182 if (IS_ERR(data->regmap)) 1183 return dev_err_probe(dev, PTR_ERR(data->regmap), 1184 "Failed to init regmap\n"); 1185 1186 ret = devm_regmap_field_bulk_alloc(dev, data->regmap, 1187 data->rm_field, rt9467_chg_fields, 1188 ARRAY_SIZE(rt9467_chg_fields)); 1189 if (ret) 1190 return dev_err_probe(dev, ret, "Failed to alloc regmap fields\n"); 1191 1192 ret = rt9467_check_vendor_info(data); 1193 if (ret) 1194 return dev_err_probe(dev, ret, "Failed to check vendor info"); 1195 1196 ret = rt9467_reset_chip(data); 1197 if (ret) 1198 return dev_err_probe(dev, ret, "Failed to reset chip\n"); 1199 1200 ret = devm_regmap_add_irq_chip(dev, data->regmap, i2c->irq, 1201 IRQF_TRIGGER_LOW | IRQF_ONESHOT, 0, 1202 &rt9467_irq_chip, &data->irq_chip_data); 1203 if (ret) 1204 return dev_err_probe(dev, ret, "Failed to add irq chip\n"); 1205 1206 ret = devm_mutex_init(dev, &data->adc_lock); 1207 if (ret) 1208 return ret; 1209 1210 ret = devm_mutex_init(dev, &data->attach_lock); 1211 if (ret) 1212 return ret; 1213 1214 ret = devm_mutex_init(dev, &data->ichg_ieoc_lock); 1215 if (ret) 1216 return ret; 1217 1218 init_completion(&data->aicl_done); 1219 ret = devm_add_action_or_reset(dev, rt9467_chg_complete_aicl_done, 1220 &data->aicl_done); 1221 if (ret) 1222 return ret; 1223 1224 ret = rt9467_do_charger_init(data); 1225 if (ret) 1226 return ret; 1227 1228 ret = rt9467_register_otg_regulator(data); 1229 if (ret) 1230 return ret; 1231 1232 ret = rt9467_register_psy(data); 1233 if (ret) 1234 return ret; 1235 1236 return rt9467_request_interrupt(data); 1237 } 1238 1239 static const struct of_device_id rt9467_charger_of_match_table[] = { 1240 { .compatible = "richtek,rt9467", }, 1241 {} 1242 }; 1243 MODULE_DEVICE_TABLE(of, rt9467_charger_of_match_table); 1244 1245 static struct i2c_driver rt9467_charger_driver = { 1246 .driver = { 1247 .name = "rt9467-charger", 1248 .of_match_table = rt9467_charger_of_match_table, 1249 }, 1250 .probe = rt9467_charger_probe, 1251 }; 1252 module_i2c_driver(rt9467_charger_driver); 1253 1254 MODULE_DESCRIPTION("Richtek RT9467 Charger Driver"); 1255 MODULE_AUTHOR("ChiYuan Huang <cy_huang@richtek.com>"); 1256 MODULE_AUTHOR("ChiaEn Wu <chiaen_wu@richtek.com>"); 1257 MODULE_LICENSE("GPL"); 1258