1 // SPDX-License-Identifier: GPL-2.0-only 2 // 3 // Copyright (C) 2025 Richtek Technology Corp. 4 // 5 // Authors: ChiYuan Huang <cy_huang@richtek.com> 6 7 #include <linux/atomic.h> 8 #include <linux/cleanup.h> 9 #include <linux/i2c.h> 10 #include <linux/kernel.h> 11 #include <linux/linear_range.h> 12 #include <linux/interrupt.h> 13 #include <linux/mod_devicetable.h> 14 #include <linux/module.h> 15 #include <linux/mutex.h> 16 #include <linux/power_supply.h> 17 #include <linux/property.h> 18 #include <linux/regmap.h> 19 #include <linux/sysfs.h> 20 #include <linux/util_macros.h> 21 22 #define RT9756_REG_INTFLAG1 0x0B 23 #define RT9756_REG_INTFLAG2 0x0D 24 #define RT9756_REG_INTFLAG3 0x0F 25 #define RT9756_REG_ADCCTL 0x11 26 #define RT9756_REG_VBUSADC 0x12 27 #define RT9756_REG_BC12FLAG 0x45 28 #define RT9756_REG_INTFLAG4 0x49 29 30 /* Flag1 */ 31 #define RT9756_EVT_BUSOVP BIT(3) 32 #define RT9756_EVT_BUSOCP BIT(2) 33 #define RT9756_EVT_BUSUCP BIT(0) 34 /* Flag2 */ 35 #define RT9756_EVT_BATOVP BIT(7) 36 #define RT9756_EVT_BATOCP BIT(6) 37 #define RT9756_EVT_TDIEOTP BIT(3) 38 #define RT9756_EVT_VBUSLOW_ERR BIT(2) 39 #define RT9756_EVT_VAC_INSERT BIT(0) 40 /* Flag3 */ 41 #define RT9756_EVT_WDT BIT(5) 42 #define RT9756_EVT_VAC_UVLO BIT(4) 43 /* ADCCTL */ 44 #define RT9756_ADCEN_MASK BIT(7) 45 #define RT9756_ADCONCE_MASK BIT(6) 46 /* Bc12_flag */ 47 #define RT9756_EVT_BC12_DONE BIT(3) 48 /* Flag4 */ 49 #define RT9756_EVT_OUTOVP BIT(0) 50 51 #define RICHTEK_DEVID 7 52 #define RT9756_REVID 0 53 #define RT9756A_REVID 1 54 #define RT9757_REVID 2 55 #define RT9757A_REVID 3 56 #define RT9756_ADC_CONVTIME 1200 57 #define RT9756_ADC_MAXWAIT 16000 58 59 enum rt9756_model { 60 MODEL_RT9756 = 0, 61 MODEL_RT9757, 62 MODEL_RT9770, 63 MODEL_MAX 64 }; 65 66 enum rt9756_adc_chan { 67 ADC_VBUS = 0, 68 ADC_IBUS, 69 ADC_VBAT, 70 ADC_IBAT, 71 ADC_TDIE, 72 ADC_MAX_CHANNEL 73 }; 74 75 enum rt9756_usb_type { 76 USB_NO_VBUS = 0, 77 USB_SDP = 2, 78 USB_NSTD, 79 USB_DCP, 80 USB_CDP, 81 MAX_USB_TYPE 82 }; 83 84 enum rt9756_fields { 85 F_VBATOVP = 0, 86 F_VBATOVP_EN, 87 F_IBATOCP, 88 F_IBATOCP_EN, 89 F_VBUSOVP, 90 F_VBUSOVP_EN, 91 F_IBUSOCP, 92 F_IBUSOCP_EN, 93 F_SWITCHING, 94 F_REG_RST, 95 F_CHG_EN, 96 F_OP_MODE, 97 F_WDT_DIS, 98 F_WDT_TMR, 99 F_DEV_ID, 100 F_BC12_EN, 101 F_USB_STATE, 102 F_VBUS_STATE, 103 F_IBAT_RSEN, 104 F_REVISION, 105 F_MAX_FIELD 106 }; 107 108 enum rt9756_ranges { 109 R_VBATOVP = 0, 110 R_IBATOCP, 111 R_VBUSOVP, 112 R_IBUSOCP, 113 R_MAX_RANGE 114 }; 115 116 static const struct reg_field rt9756_chg_fields[F_MAX_FIELD] = { 117 [F_VBATOVP] = REG_FIELD(0x08, 0, 4), 118 [F_VBATOVP_EN] = REG_FIELD(0x08, 7, 7), 119 [F_IBATOCP] = REG_FIELD(0x09, 0, 5), 120 [F_IBATOCP_EN] = REG_FIELD(0x09, 7, 7), 121 [F_VBUSOVP] = REG_FIELD(0x06, 0, 5), 122 [F_VBUSOVP_EN] = REG_FIELD(0x06, 7, 7), 123 [F_IBUSOCP] = REG_FIELD(0x07, 0, 4), 124 [F_IBUSOCP_EN] = REG_FIELD(0x07, 5, 5), 125 [F_SWITCHING] = REG_FIELD(0x5c, 7, 7), 126 [F_REG_RST] = REG_FIELD(0x00, 7, 7), 127 [F_CHG_EN] = REG_FIELD(0x00, 6, 6), 128 [F_OP_MODE] = REG_FIELD(0x00, 5, 5), 129 [F_WDT_DIS] = REG_FIELD(0x00, 3, 3), 130 [F_WDT_TMR] = REG_FIELD(0x00, 0, 2), 131 [F_DEV_ID] = REG_FIELD(0x03, 0, 3), 132 [F_BC12_EN] = REG_FIELD(0x44, 7, 7), 133 [F_USB_STATE] = REG_FIELD(0x46, 5, 7), 134 [F_VBUS_STATE] = REG_FIELD(0x4c, 0, 0), 135 [F_IBAT_RSEN] = REG_FIELD(0x5e, 0, 1), 136 [F_REVISION] = REG_FIELD(0x62, 0, 1), 137 }; 138 139 static const struct reg_field rt9770_chg_fields[F_MAX_FIELD] = { 140 [F_VBATOVP] = REG_FIELD(0x08, 0, 4), 141 [F_VBATOVP_EN] = REG_FIELD(0x08, 7, 7), 142 [F_IBATOCP] = REG_FIELD(0x09, 0, 5), 143 [F_IBATOCP_EN] = REG_FIELD(0x09, 7, 7), 144 [F_VBUSOVP] = REG_FIELD(0x06, 0, 5), 145 [F_VBUSOVP_EN] = REG_FIELD(0x06, 7, 7), 146 [F_IBUSOCP] = REG_FIELD(0x07, 0, 4), 147 [F_IBUSOCP_EN] = REG_FIELD(0x07, 5, 5), 148 [F_SWITCHING] = REG_FIELD(0x5c, 7, 7), 149 [F_REG_RST] = REG_FIELD(0x00, 7, 7), 150 [F_CHG_EN] = REG_FIELD(0x00, 6, 6), 151 [F_OP_MODE] = REG_FIELD(0x00, 5, 5), 152 [F_WDT_DIS] = REG_FIELD(0x00, 3, 3), 153 [F_WDT_TMR] = REG_FIELD(0x00, 0, 2), 154 [F_DEV_ID] = REG_FIELD(0x60, 0, 3), 155 [F_BC12_EN] = REG_FIELD(0x03, 7, 7), 156 [F_USB_STATE] = REG_FIELD(0x02, 5, 7), 157 [F_VBUS_STATE] = REG_FIELD(0x4c, 0, 0), 158 [F_IBAT_RSEN] = REG_FIELD(0x5e, 0, 1), 159 [F_REVISION] = REG_FIELD(0x62, 3, 7), 160 }; 161 162 /* All converted to microvolt or microamp */ 163 static const struct linear_range rt9756_chg_ranges[R_MAX_RANGE] = { 164 LINEAR_RANGE_IDX(R_VBATOVP, 4200000, 0, 31, 25000), 165 LINEAR_RANGE_IDX(R_IBATOCP, 2000000, 0, 63, 100000), 166 LINEAR_RANGE_IDX(R_VBUSOVP, 3000000, 0, 63, 50000), 167 LINEAR_RANGE_IDX(R_IBUSOCP, 1000000, 0, 31, 250000), 168 }; 169 170 struct charger_event { 171 unsigned int flag1; 172 unsigned int flag2; 173 unsigned int flag3; 174 unsigned int flag4; 175 }; 176 177 struct rt9756_data { 178 struct device *dev; 179 struct regmap *regmap; 180 struct regmap_field *rm_fields[F_MAX_FIELD]; 181 struct power_supply *psy; 182 struct power_supply *bat_psy; 183 struct mutex adc_lock; 184 struct power_supply_desc psy_desc; 185 struct power_supply_desc bat_psy_desc; 186 struct charger_event chg_evt; 187 unsigned int rg_resistor; 188 unsigned int real_resistor; 189 enum rt9756_model model; 190 atomic_t usb_type; 191 }; 192 193 struct rt975x_dev_data { 194 const struct regmap_config *regmap_config; 195 const struct reg_field *reg_fields; 196 const struct reg_sequence *init_regs; 197 size_t num_init_regs; 198 int (*check_device_model)(struct rt9756_data *data); 199 }; 200 201 static int rt9756_get_value_field_range(struct rt9756_data *data, enum rt9756_fields en_field, 202 enum rt9756_fields field, enum rt9756_ranges rsel, int *val) 203 { 204 const struct linear_range *range = rt9756_chg_ranges + rsel; 205 unsigned int enable, selector, value; 206 int ret; 207 208 ret = regmap_field_read(data->rm_fields[en_field], &enable); 209 if (ret) 210 return ret; 211 212 if (!enable) { 213 *val = 0; 214 return 0; 215 } 216 217 ret = regmap_field_read(data->rm_fields[field], &selector); 218 if (ret) 219 return ret; 220 221 ret = linear_range_get_value(range, selector, &value); 222 if (ret) 223 return ret; 224 225 *val = (int)value; 226 227 return 0; 228 } 229 230 static int rt9756_set_value_field_range(struct rt9756_data *data, enum rt9756_fields en_field, 231 enum rt9756_fields field, enum rt9756_ranges rsel, int val) 232 { 233 const struct linear_range *range = rt9756_chg_ranges + rsel; 234 unsigned int selector, value; 235 int ret; 236 237 if (!val) 238 return regmap_field_write(data->rm_fields[en_field], 0); 239 240 value = (unsigned int)val; 241 linear_range_get_selector_within(range, value, &selector); 242 ret = regmap_field_write(data->rm_fields[field], selector); 243 if (ret) 244 return ret; 245 246 return regmap_field_write(data->rm_fields[en_field], 1); 247 } 248 249 static int rt9756_get_adc(struct rt9756_data *data, enum rt9756_adc_chan chan, 250 int *val) 251 { 252 struct regmap *regmap = data->regmap; 253 unsigned int reg_addr = RT9756_REG_VBUSADC + chan * 2; 254 unsigned int mask = RT9756_ADCEN_MASK | RT9756_ADCONCE_MASK; 255 unsigned int shift = 0, adc_cntl; 256 __be16 raws; 257 int scale, offset = 0, ret; 258 259 guard(mutex)(&data->adc_lock); 260 261 ret = regmap_update_bits(regmap, RT9756_REG_ADCCTL, mask, mask); 262 if (ret) 263 return ret; 264 265 ret = regmap_read_poll_timeout(regmap, RT9756_REG_ADCCTL, adc_cntl, 266 !(adc_cntl & RT9756_ADCEN_MASK), 267 RT9756_ADC_CONVTIME, RT9756_ADC_MAXWAIT); 268 if (ret && ret != -ETIMEDOUT) 269 return ret; 270 271 ret = regmap_raw_read(regmap, reg_addr, &raws, sizeof(raws)); 272 if (ret) 273 return ret; 274 275 /* 276 * TDIE LSB 1'c, others LSB 1000uV or 1000uA. 277 * Rsense ratio is needed for IBAT channel 278 */ 279 if (chan == ADC_TDIE) { 280 scale = 10; 281 shift = 8; 282 offset = -40; 283 } else if (chan == ADC_IBAT) 284 scale = 1000 * data->rg_resistor / data->real_resistor; 285 else 286 scale = 1000; 287 288 *val = ((be16_to_cpu(raws) >> shift) + offset) * scale; 289 290 return regmap_update_bits(regmap, RT9756_REG_ADCCTL, mask, 0); 291 } 292 293 static int rt9756_get_switching_state(struct rt9756_data *data, int *status) 294 { 295 unsigned int switching_state; 296 int ret; 297 298 ret = regmap_field_read(data->rm_fields[F_SWITCHING], &switching_state); 299 if (ret) 300 return ret; 301 302 if (switching_state) 303 *status = POWER_SUPPLY_STATUS_CHARGING; 304 else 305 *status = POWER_SUPPLY_STATUS_NOT_CHARGING; 306 307 return 0; 308 } 309 310 static int rt9756_get_charger_health(struct rt9756_data *data) 311 { 312 struct charger_event *evt = &data->chg_evt; 313 314 if (evt->flag2 & RT9756_EVT_VBUSLOW_ERR) 315 return POWER_SUPPLY_HEALTH_UNDERVOLTAGE; 316 317 if (evt->flag1 & RT9756_EVT_BUSOVP || evt->flag2 & RT9756_EVT_BATOVP || 318 evt->flag4 & RT9756_EVT_OUTOVP) 319 return POWER_SUPPLY_HEALTH_OVERVOLTAGE; 320 321 if (evt->flag1 & RT9756_EVT_BUSOCP || evt->flag2 & RT9756_EVT_BATOCP) 322 return POWER_SUPPLY_HEALTH_OVERCURRENT; 323 324 if (evt->flag1 & RT9756_EVT_BUSUCP) 325 return POWER_SUPPLY_HEALTH_UNSPEC_FAILURE; 326 327 if (evt->flag2 & RT9756_EVT_TDIEOTP) 328 return POWER_SUPPLY_HEALTH_OVERHEAT; 329 330 if (evt->flag3 & RT9756_EVT_WDT) 331 return POWER_SUPPLY_HEALTH_WATCHDOG_TIMER_EXPIRE; 332 333 return POWER_SUPPLY_HEALTH_GOOD; 334 } 335 336 static int rt9756_get_charger_online(struct rt9756_data *data, int *val) 337 { 338 unsigned int online; 339 int ret; 340 341 ret = regmap_field_read(data->rm_fields[F_VBUS_STATE], &online); 342 if (ret) 343 return ret; 344 345 *val = !!online; 346 return 0; 347 } 348 349 static int rt9756_get_vbus_ovp(struct rt9756_data *data, int *val) 350 { 351 unsigned int opmode; 352 int ovpval, ret; 353 354 /* operating mode -> 0 bypass, 1 div2 */ 355 ret = regmap_field_read(data->rm_fields[F_OP_MODE], &opmode); 356 if (ret) 357 return ret; 358 359 ret = rt9756_get_value_field_range(data, F_VBUSOVP_EN, F_VBUSOVP, R_VBUSOVP, &ovpval); 360 if (ret) 361 return ret; 362 363 *val = opmode ? ovpval * 2 : ovpval; 364 return 0; 365 } 366 367 static int rt9756_set_vbus_ovp(struct rt9756_data *data, int val) 368 { 369 unsigned int opmode; 370 int ret; 371 372 /* operating mode -> 0 bypass, 1 div2 */ 373 ret = regmap_field_read(data->rm_fields[F_OP_MODE], &opmode); 374 if (ret) 375 return ret; 376 377 return rt9756_set_value_field_range(data, F_VBUSOVP_EN, F_VBUSOVP, R_VBUSOVP, 378 opmode ? val / 2 : val); 379 } 380 381 static const char * const rt9756_manufacturer = "Richtek Technology Corp."; 382 static const char * const rt9756_model[MODEL_MAX] = { "RT9756", "RT9757", "RT9770" }; 383 384 static int rt9756_psy_get_property(struct power_supply *psy, 385 enum power_supply_property psp, 386 union power_supply_propval *val) 387 { 388 struct rt9756_data *data = power_supply_get_drvdata(psy); 389 int *pval = &val->intval; 390 391 switch (psp) { 392 case POWER_SUPPLY_PROP_STATUS: 393 return rt9756_get_switching_state(data, pval); 394 case POWER_SUPPLY_PROP_HEALTH: 395 *pval = rt9756_get_charger_health(data); 396 return 0; 397 case POWER_SUPPLY_PROP_ONLINE: 398 return rt9756_get_charger_online(data, pval); 399 case POWER_SUPPLY_PROP_VOLTAGE_MAX: 400 return rt9756_get_vbus_ovp(data, pval); 401 case POWER_SUPPLY_PROP_VOLTAGE_NOW: 402 return rt9756_get_adc(data, ADC_VBUS, pval); 403 case POWER_SUPPLY_PROP_CURRENT_MAX: 404 return rt9756_get_value_field_range(data, F_IBUSOCP_EN, F_IBUSOCP, R_IBUSOCP, pval); 405 case POWER_SUPPLY_PROP_CURRENT_NOW: 406 return rt9756_get_adc(data, ADC_IBUS, pval); 407 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX: 408 return rt9756_get_value_field_range(data, F_VBATOVP_EN, F_VBATOVP, R_VBATOVP, pval); 409 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX: 410 return rt9756_get_value_field_range(data, F_IBATOCP_EN, F_IBATOCP, R_IBATOCP, pval); 411 case POWER_SUPPLY_PROP_TEMP: 412 return rt9756_get_adc(data, ADC_TDIE, pval); 413 case POWER_SUPPLY_PROP_USB_TYPE: 414 *pval = atomic_read(&data->usb_type); 415 return 0; 416 case POWER_SUPPLY_PROP_MODEL_NAME: 417 val->strval = rt9756_model[data->model]; 418 return 0; 419 case POWER_SUPPLY_PROP_MANUFACTURER: 420 val->strval = rt9756_manufacturer; 421 return 0; 422 default: 423 return -ENODATA; 424 } 425 } 426 427 static int rt9756_psy_set_property(struct power_supply *psy, 428 enum power_supply_property psp, 429 const union power_supply_propval *val) 430 { 431 struct rt9756_data *data = power_supply_get_drvdata(psy); 432 int intval = val->intval; 433 434 switch (psp) { 435 case POWER_SUPPLY_PROP_STATUS: 436 memset(&data->chg_evt, 0, sizeof(data->chg_evt)); 437 return regmap_field_write(data->rm_fields[F_CHG_EN], !!intval); 438 case POWER_SUPPLY_PROP_VOLTAGE_MAX: 439 return rt9756_set_vbus_ovp(data, intval); 440 case POWER_SUPPLY_PROP_CURRENT_MAX: 441 return rt9756_set_value_field_range(data, F_IBUSOCP_EN, F_IBUSOCP, R_IBUSOCP, 442 intval); 443 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX: 444 return rt9756_set_value_field_range(data, F_VBATOVP_EN, F_VBATOVP, R_VBATOVP, 445 intval); 446 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX: 447 return rt9756_set_value_field_range(data, F_IBATOCP_EN, F_IBATOCP, R_IBATOCP, 448 intval); 449 case POWER_SUPPLY_PROP_USB_TYPE: 450 return regmap_field_write(data->rm_fields[F_BC12_EN], !!intval); 451 default: 452 return -EINVAL; 453 } 454 } 455 456 static const enum power_supply_property rt9756_psy_properties[] = { 457 POWER_SUPPLY_PROP_STATUS, 458 POWER_SUPPLY_PROP_ONLINE, 459 POWER_SUPPLY_PROP_HEALTH, 460 POWER_SUPPLY_PROP_ONLINE, 461 POWER_SUPPLY_PROP_VOLTAGE_MAX, 462 POWER_SUPPLY_PROP_VOLTAGE_NOW, 463 POWER_SUPPLY_PROP_CURRENT_MAX, 464 POWER_SUPPLY_PROP_CURRENT_NOW, 465 POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX, 466 POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX, 467 POWER_SUPPLY_PROP_TEMP, 468 POWER_SUPPLY_PROP_USB_TYPE, 469 POWER_SUPPLY_PROP_MODEL_NAME, 470 POWER_SUPPLY_PROP_MANUFACTURER, 471 }; 472 473 static int rt9756_bat_psy_get_property(struct power_supply *psy, 474 enum power_supply_property psp, 475 union power_supply_propval *val) 476 { 477 struct rt9756_data *data = power_supply_get_drvdata(psy); 478 int *pval = &val->intval; 479 480 switch (psp) { 481 case POWER_SUPPLY_PROP_TECHNOLOGY: 482 *pval = POWER_SUPPLY_TECHNOLOGY_LION; 483 return 0; 484 case POWER_SUPPLY_PROP_VOLTAGE_NOW: 485 return rt9756_get_adc(data, ADC_VBAT, pval); 486 case POWER_SUPPLY_PROP_CURRENT_NOW: 487 return rt9756_get_adc(data, ADC_IBAT, pval); 488 default: 489 return -ENODATA; 490 } 491 } 492 493 static const enum power_supply_property rt9756_bat_psy_properties[] = { 494 POWER_SUPPLY_PROP_TECHNOLOGY, 495 POWER_SUPPLY_PROP_VOLTAGE_NOW, 496 POWER_SUPPLY_PROP_CURRENT_NOW, 497 }; 498 499 static int rt9756_psy_property_is_writeable(struct power_supply *psy, 500 enum power_supply_property psp) 501 { 502 switch (psp) { 503 case POWER_SUPPLY_PROP_STATUS: 504 case POWER_SUPPLY_PROP_ONLINE: 505 case POWER_SUPPLY_PROP_VOLTAGE_MAX: 506 case POWER_SUPPLY_PROP_CURRENT_MAX: 507 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX: 508 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX: 509 case POWER_SUPPLY_PROP_USB_TYPE: 510 return 1; 511 default: 512 return 0; 513 } 514 } 515 516 static const unsigned int rt9756_wdt_millisecond[] = { 517 500, 1000, 5000, 30000, 40000, 80000, 128000, 255000 518 }; 519 520 static ssize_t watchdog_timer_show(struct device *dev, 521 struct device_attribute *attr, char *buf) 522 { 523 struct power_supply *psy = to_power_supply(dev); 524 struct rt9756_data *data = power_supply_get_drvdata(psy); 525 unsigned int wdt_tmr_now = 0, wdt_sel, wdt_dis; 526 int ret; 527 528 ret = regmap_field_read(data->rm_fields[F_WDT_DIS], &wdt_dis); 529 if (ret) 530 return ret; 531 532 if (!wdt_dis) { 533 ret = regmap_field_read(data->rm_fields[F_WDT_TMR], &wdt_sel); 534 if (ret) 535 return ret; 536 537 wdt_tmr_now = rt9756_wdt_millisecond[wdt_sel]; 538 } 539 540 return sysfs_emit(buf, "%d\n", wdt_tmr_now); 541 } 542 543 static ssize_t watchdog_timer_store(struct device *dev, 544 struct device_attribute *attr, 545 const char *buf, size_t count) 546 { 547 struct power_supply *psy = to_power_supply(dev); 548 struct rt9756_data *data = power_supply_get_drvdata(psy); 549 unsigned int wdt_set, wdt_sel; 550 int ret; 551 552 ret = kstrtouint(buf, 10, &wdt_set); 553 if (ret) 554 return ret; 555 556 ret = regmap_field_write(data->rm_fields[F_WDT_DIS], 1); 557 if (ret) 558 return ret; 559 560 wdt_sel = find_closest(wdt_set, rt9756_wdt_millisecond, 561 ARRAY_SIZE(rt9756_wdt_millisecond)); 562 563 ret = regmap_field_write(data->rm_fields[F_WDT_TMR], wdt_sel); 564 if (ret) 565 return ret; 566 567 if (wdt_set) { 568 ret = regmap_field_write(data->rm_fields[F_WDT_DIS], 0); 569 if (ret) 570 return ret; 571 } 572 573 return count; 574 } 575 576 static const char * const rt9756_opmode_str[] = { "bypass", "div2" }; 577 578 static ssize_t operation_mode_show(struct device *dev, 579 struct device_attribute *attr, char *buf) 580 { 581 struct power_supply *psy = to_power_supply(dev); 582 struct rt9756_data *data = power_supply_get_drvdata(psy); 583 unsigned int opmode; 584 int ret; 585 586 ret = regmap_field_read(data->rm_fields[F_OP_MODE], &opmode); 587 if (ret) 588 return ret; 589 590 return sysfs_emit(buf, "%s\n", rt9756_opmode_str[opmode]); 591 } 592 593 static ssize_t operation_mode_store(struct device *dev, 594 struct device_attribute *attr, 595 const char *buf, size_t count) 596 { 597 struct power_supply *psy = to_power_supply(dev); 598 struct rt9756_data *data = power_supply_get_drvdata(psy); 599 int index, ret; 600 601 index = sysfs_match_string(rt9756_opmode_str, buf); 602 if (index < 0) 603 return index; 604 605 ret = regmap_field_write(data->rm_fields[F_OP_MODE], index); 606 607 return ret ?: count; 608 } 609 610 static DEVICE_ATTR_RW(watchdog_timer); 611 static DEVICE_ATTR_RW(operation_mode); 612 613 static struct attribute *rt9756_sysfs_attrs[] = { 614 &dev_attr_watchdog_timer.attr, 615 &dev_attr_operation_mode.attr, 616 NULL 617 }; 618 ATTRIBUTE_GROUPS(rt9756_sysfs); 619 620 static int rt9756_register_psy(struct rt9756_data *data) 621 { 622 struct power_supply_desc *desc = &data->psy_desc; 623 struct power_supply_desc *bat_desc = &data->bat_psy_desc; 624 struct power_supply_config cfg = {}, bat_cfg = {}; 625 struct device *dev = data->dev; 626 char *psy_name, *bat_psy_name, **supplied_to; 627 628 bat_cfg.drv_data = data; 629 bat_cfg.fwnode = dev_fwnode(dev); 630 631 bat_psy_name = devm_kasprintf(dev, GFP_KERNEL, "rt9756-%s-battery", dev_name(dev)); 632 if (!bat_psy_name) 633 return -ENOMEM; 634 635 bat_desc->name = bat_psy_name; 636 bat_desc->type = POWER_SUPPLY_TYPE_BATTERY; 637 bat_desc->properties = rt9756_bat_psy_properties; 638 bat_desc->num_properties = ARRAY_SIZE(rt9756_bat_psy_properties); 639 bat_desc->get_property = rt9756_bat_psy_get_property; 640 641 data->bat_psy = devm_power_supply_register(dev, bat_desc, &bat_cfg); 642 if (IS_ERR(data->bat_psy)) 643 return dev_err_probe(dev, PTR_ERR(data->bat_psy), "Failed to register battery\n"); 644 645 supplied_to = devm_kzalloc(dev, sizeof(*supplied_to), GFP_KERNEL); 646 if (!supplied_to) 647 return -ENOMEM; 648 649 /* Link charger psy to battery psy */ 650 supplied_to[0] = bat_psy_name; 651 652 cfg.drv_data = data; 653 cfg.fwnode = dev_fwnode(dev); 654 cfg.attr_grp = rt9756_sysfs_groups; 655 cfg.supplied_to = supplied_to; 656 cfg.num_supplicants = 1; 657 658 psy_name = devm_kasprintf(dev, GFP_KERNEL, "rt9756-%s", dev_name(dev)); 659 if (!psy_name) 660 return -ENOMEM; 661 662 desc->name = psy_name; 663 desc->type = POWER_SUPPLY_TYPE_USB; 664 desc->usb_types = BIT(POWER_SUPPLY_USB_TYPE_UNKNOWN) | BIT(POWER_SUPPLY_USB_TYPE_SDP) | 665 BIT(POWER_SUPPLY_USB_TYPE_DCP) | BIT(POWER_SUPPLY_USB_TYPE_CDP); 666 desc->properties = rt9756_psy_properties; 667 desc->num_properties = ARRAY_SIZE(rt9756_psy_properties); 668 desc->property_is_writeable = rt9756_psy_property_is_writeable; 669 desc->get_property = rt9756_psy_get_property; 670 desc->set_property = rt9756_psy_set_property; 671 672 data->psy = devm_power_supply_register(dev, desc, &cfg); 673 674 return PTR_ERR_OR_ZERO(data->psy); 675 } 676 677 static int rt9756_get_usb_type(struct rt9756_data *data) 678 { 679 unsigned int type; 680 int report_type, ret; 681 682 ret = regmap_field_read(data->rm_fields[F_USB_STATE], &type); 683 if (ret) 684 return ret; 685 686 switch (type) { 687 case USB_SDP: 688 case USB_NSTD: 689 report_type = POWER_SUPPLY_USB_TYPE_SDP; 690 break; 691 case USB_DCP: 692 report_type = POWER_SUPPLY_USB_TYPE_DCP; 693 break; 694 case USB_CDP: 695 report_type = POWER_SUPPLY_USB_TYPE_CDP; 696 break; 697 case USB_NO_VBUS: 698 default: 699 report_type = POWER_SUPPLY_USB_TYPE_UNKNOWN; 700 break; 701 } 702 703 atomic_set(&data->usb_type, report_type); 704 return 0; 705 } 706 707 static irqreturn_t rt9756_irq_handler(int irq, void *devid) 708 { 709 struct rt9756_data *data = devid; 710 struct regmap *regmap = data->regmap; 711 struct charger_event *evt = &data->chg_evt; 712 unsigned int bc12_flag = 0; 713 int ret; 714 715 ret = regmap_read(regmap, RT9756_REG_INTFLAG1, &evt->flag1); 716 if (ret) 717 return IRQ_NONE; 718 719 ret = regmap_read(regmap, RT9756_REG_INTFLAG2, &evt->flag2); 720 if (ret) 721 return IRQ_NONE; 722 723 ret = regmap_read(regmap, RT9756_REG_INTFLAG3, &evt->flag3); 724 if (ret) 725 return IRQ_NONE; 726 727 if (data->model != MODEL_RT9770) { 728 ret = regmap_read(regmap, RT9756_REG_INTFLAG4, &evt->flag4); 729 if (ret) 730 return IRQ_NONE; 731 732 ret = regmap_read(regmap, RT9756_REG_BC12FLAG, &bc12_flag); 733 if (ret) 734 return IRQ_NONE; 735 } 736 737 dev_dbg(data->dev, "events: 0x%02x,%02x,%02x,%02x,%02x\n", evt->flag1, evt->flag2, 738 evt->flag3, evt->flag4, bc12_flag); 739 740 if (evt->flag2 & RT9756_EVT_VAC_INSERT) { 741 ret = regmap_field_write(data->rm_fields[F_BC12_EN], 1); 742 if (ret) 743 return IRQ_NONE; 744 } 745 746 if (evt->flag3 & RT9756_EVT_VAC_UVLO) 747 atomic_set(&data->usb_type, POWER_SUPPLY_USB_TYPE_UNKNOWN); 748 749 if (bc12_flag & RT9756_EVT_BC12_DONE) { 750 ret = rt9756_get_usb_type(data); 751 if (ret) 752 return IRQ_NONE; 753 } 754 755 power_supply_changed(data->psy); 756 757 return IRQ_HANDLED; 758 } 759 760 static int rt9756_config_batsense_resistor(struct rt9756_data *data) 761 { 762 unsigned int shunt_resistor_uohms = 2000, rsense_sel; 763 764 device_property_read_u32(data->dev, "shunt-resistor-micro-ohms", &shunt_resistor_uohms); 765 766 if (!shunt_resistor_uohms || shunt_resistor_uohms > 5000) 767 return -EINVAL; 768 769 data->real_resistor = shunt_resistor_uohms; 770 771 /* Always choose the larger or equal one to prevent false ocp alarm */ 772 if (shunt_resistor_uohms <= 1000) { 773 rsense_sel = 0; 774 data->rg_resistor = 1000; 775 } else if (shunt_resistor_uohms <= 2000) { 776 rsense_sel = 1; 777 data->rg_resistor = 2000; 778 } else { 779 rsense_sel = 2; 780 data->rg_resistor = 5000; 781 } 782 783 return regmap_field_write(data->rm_fields[F_IBAT_RSEN], rsense_sel); 784 } 785 786 static const struct reg_sequence rt9756_init_regs[] = { 787 REG_SEQ(0x00, 0x80, 1000), /* REG_RESET */ 788 REG_SEQ0(0x04, 0x13), /* VACOVP/OVPGATE 12V */ 789 REG_SEQ0(0x00, 0x28), /* WDT_DIS = 1 */ 790 REG_SEQ0(0x0c, 0x02), /* MASK FLAG1 */ 791 REG_SEQ0(0x0e, 0x06), /* MASK FLAG2 */ 792 REG_SEQ0(0x10, 0xca), /* MASK FLAG3 */ 793 REG_SEQ0(0x44, 0xa0), /* BC12_EN */ 794 REG_SEQ0(0x47, 0x07), /* MASK BC12FLAG */ 795 REG_SEQ0(0x4a, 0xfe), /* MASK FLAG4 */ 796 REG_SEQ0(0x5c, 0x40), /* MASK CON_SWITCHING */ 797 REG_SEQ0(0x63, 0x01), /* MASK VDDA_UVLO */ 798 }; 799 800 static const struct reg_sequence rt9770_init_regs[] = { 801 REG_SEQ(0x00, 0x80, 1000), /* REG_RESET */ 802 REG_SEQ0(0x04, 0x13), /* VACOVP/OVPGATE 12V */ 803 REG_SEQ0(0x00, 0x28), /* WDT_DIS = 1 */ 804 REG_SEQ0(0x0c, 0x02), /* MASK FLAG1 */ 805 REG_SEQ0(0x0e, 0x06), /* MASK FLAG2 */ 806 REG_SEQ0(0x10, 0xca), /* MASK FLAG3 */ 807 REG_SEQ0(0x5c, 0x40), /* MASK CON_SWITCHING */ 808 REG_SEQ0(0x63, 0x01), /* MASK VDDA_UVLO */ 809 }; 810 811 static const struct regmap_config rt9756_regmap_config = { 812 .name = "rt9756", 813 .reg_bits = 16, 814 .val_bits = 8, 815 .max_register = 0x1ff, 816 }; 817 818 static const struct regmap_config rt9770_regmap_config = { 819 .name = "rt9770", 820 .reg_bits = 8, 821 .val_bits = 8, 822 .max_register = 0xff, 823 }; 824 825 static int rt9756_check_device_model(struct rt9756_data *data) 826 { 827 struct device *dev = data->dev; 828 unsigned int revid; 829 int ret; 830 831 ret = regmap_field_read(data->rm_fields[F_REVISION], &revid); 832 if (ret) 833 return dev_err_probe(dev, ret, "Failed to read revid\n"); 834 835 if (revid == RT9757_REVID || revid == RT9757A_REVID) 836 data->model = MODEL_RT9757; 837 else if (revid == RT9756_REVID || revid == RT9756A_REVID) 838 data->model = MODEL_RT9756; 839 else 840 return dev_err_probe(dev, -EINVAL, "Unknown revision %d\n", revid); 841 842 return 0; 843 } 844 845 static int rt9770_check_device_model(struct rt9756_data *data) 846 { 847 data->model = MODEL_RT9770; 848 return 0; 849 } 850 851 static int rt9756_probe(struct i2c_client *i2c) 852 { 853 const struct rt975x_dev_data *dev_data; 854 struct device *dev = &i2c->dev; 855 struct rt9756_data *data; 856 struct regmap *regmap; 857 unsigned int devid; 858 int ret; 859 860 dev_data = device_get_match_data(dev); 861 if (!dev_data) 862 return dev_err_probe(dev, -EINVAL, "No device data found\n"); 863 864 data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL); 865 if (!data) 866 return -ENOMEM; 867 868 data->dev = dev; 869 mutex_init(&data->adc_lock); 870 atomic_set(&data->usb_type, POWER_SUPPLY_USB_TYPE_UNKNOWN); 871 i2c_set_clientdata(i2c, data); 872 873 regmap = devm_regmap_init_i2c(i2c, dev_data->regmap_config); 874 if (IS_ERR(regmap)) 875 return dev_err_probe(dev, PTR_ERR(regmap), "Failed to init regmap\n"); 876 877 data->regmap = regmap; 878 879 ret = devm_regmap_field_bulk_alloc(dev, regmap, data->rm_fields, dev_data->reg_fields, 880 F_MAX_FIELD); 881 if (ret) 882 return dev_err_probe(dev, ret, "Failed to alloc regmap fields\n"); 883 884 /* Richtek Device ID check */ 885 ret = regmap_field_read(data->rm_fields[F_DEV_ID], &devid); 886 if (ret) 887 return dev_err_probe(dev, ret, "Failed to read devid\n"); 888 889 if (devid != RICHTEK_DEVID) 890 return dev_err_probe(dev, -ENODEV, "Incorrect VID 0x%02x\n", devid); 891 892 /* Get specific model */ 893 ret = dev_data->check_device_model(data); 894 if (ret) 895 return ret; 896 897 ret = regmap_register_patch(regmap, dev_data->init_regs, dev_data->num_init_regs); 898 if (ret) 899 return dev_err_probe(dev, ret, "Failed to init registers\n"); 900 901 ret = rt9756_config_batsense_resistor(data); 902 if (ret) 903 return dev_err_probe(dev, ret, "Failed to config batsense resistor\n"); 904 905 ret = rt9756_register_psy(data); 906 if (ret) 907 return dev_err_probe(dev, ret, "Failed to init power supply\n"); 908 909 return devm_request_threaded_irq(dev, i2c->irq, NULL, rt9756_irq_handler, IRQF_ONESHOT, 910 dev_name(dev), data); 911 } 912 913 static void rt9756_shutdown(struct i2c_client *i2c) 914 { 915 struct rt9756_data *data = i2c_get_clientdata(i2c); 916 917 regmap_field_write(data->rm_fields[F_REG_RST], 1); 918 } 919 920 static const struct rt975x_dev_data rt9756_dev_data = { 921 .regmap_config = &rt9756_regmap_config, 922 .reg_fields = rt9756_chg_fields, 923 .init_regs = rt9756_init_regs, 924 .num_init_regs = ARRAY_SIZE(rt9756_init_regs), 925 .check_device_model = rt9756_check_device_model, 926 }; 927 928 static const struct rt975x_dev_data rt9770_dev_data = { 929 .regmap_config = &rt9770_regmap_config, 930 .reg_fields = rt9770_chg_fields, 931 .init_regs = rt9770_init_regs, 932 .num_init_regs = ARRAY_SIZE(rt9770_init_regs), 933 .check_device_model = rt9770_check_device_model, 934 }; 935 936 static const struct of_device_id rt9756_device_match_table[] = { 937 { .compatible = "richtek,rt9756", .data = &rt9756_dev_data }, 938 { .compatible = "richtek,rt9770", .data = &rt9770_dev_data }, 939 {} 940 }; 941 MODULE_DEVICE_TABLE(of, rt9756_device_match_table); 942 943 static struct i2c_driver rt9756_charger_driver = { 944 .driver = { 945 .name = "rt9756", 946 .of_match_table = rt9756_device_match_table, 947 }, 948 .probe = rt9756_probe, 949 .shutdown = rt9756_shutdown, 950 }; 951 module_i2c_driver(rt9756_charger_driver); 952 953 MODULE_DESCRIPTION("Richtek RT9756 charger driver"); 954 MODULE_AUTHOR("ChiYuan Huang <cy_huang@richtek.com>"); 955 MODULE_LICENSE("GPL"); 956