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