1 // SPDX-License-Identifier: GPL-2.0-or-later 2 3 #include <linux/devm-helpers.h> 4 #include <linux/delay.h> 5 #include <linux/device.h> 6 #include <linux/err.h> 7 #include <linux/extcon.h> 8 #include <linux/i2c.h> 9 #include <linux/of_graph.h> 10 #include <linux/property.h> 11 #include <linux/interrupt.h> 12 #include <linux/module.h> 13 #include <linux/pm.h> 14 #include <linux/power_supply.h> 15 #include <linux/regmap.h> 16 #include <linux/sysfs.h> 17 #include <linux/types.h> 18 19 #define MAX8971_REG_CHGINT 0x0f 20 #define MAX8971_REG_CHG_RST BIT(0) 21 #define MAX8971_REG_CHGINT_MASK 0x01 22 #define MAX8971_AICL_MASK BIT(7) 23 #define MAX8971_REG_CHG_STAT 0x02 24 #define MAX8971_CHG_MASK BIT(3) 25 #define MAX8971_REG_DETAILS1 0x03 26 #define MAX8971_REG_DETAILS2 0x04 27 #define MAX8971_REG_CHGCNTL1 0x05 28 #define MAX8971_REG_FCHGCRNT 0x06 29 #define MAX8971_REG_DCCRNT 0x07 30 #define MAX8971_CHGRSTRT_MASK BIT(6) 31 #define MAX8971_REG_TOPOFF 0x08 32 #define MAX8971_REG_TEMPREG 0x09 33 #define MAX8971_REG_PROTCMD 0x0a 34 #define MAX8971_CHGPROT_LOCKED 0x00 35 #define MAX8971_CHGPROT_UNLOCKED 0x03 36 37 #define MAX8971_FCHGT_DEFAULT 2 38 #define MAX8971_TOPOFFT_DEFAULT 3 39 40 static const char *max8971_manufacturer = "Maxim Integrated"; 41 static const char *max8971_model = "MAX8971"; 42 43 enum max8971_charging_state { 44 MAX8971_CHARGING_DEAD_BATTERY, 45 MAX8971_CHARGING_PREQUALIFICATION, 46 MAX8971_CHARGING_FAST_CONST_CURRENT, 47 MAX8971_CHARGING_FAST_CONST_VOLTAGE, 48 MAX8971_CHARGING_TOP_OFF, 49 MAX8971_CHARGING_DONE, 50 MAX8971_CHARGING_TIMER_FAULT, 51 MAX8971_CHARGING_SUSPENDED_THERMAL, 52 MAX8971_CHARGING_OFF, 53 MAX8971_CHARGING_THERMAL_LOOP, 54 }; 55 56 enum max8971_health_state { 57 MAX8971_HEALTH_UNKNOWN, 58 MAX8971_HEALTH_COLD, 59 MAX8971_HEALTH_COOL, 60 MAX8971_HEALTH_WARM, 61 MAX8971_HEALTH_HOT, 62 MAX8971_HEALTH_OVERHEAT, 63 }; 64 65 /* Fast-Charge current limit, 250..1550 mA, 50 mA steps */ 66 #define MAX8971_CHG_CC_STEP 50000U 67 #define MAX8971_CHG_CC_MIN 250000U 68 #define MAX8971_CHG_CC_MAX 1550000U 69 70 /* Input current limit, 250..1500 mA, 25 mA steps */ 71 #define MAX8971_DCILMT_STEP 25000U 72 #define MAX8971_DCILMT_MIN 250000U 73 #define MAX8971_DCILMT_MAX 1500000U 74 75 enum max8971_field_idx { 76 THM_DTLS, /* DETAILS1 */ 77 BAT_DTLS, CHG_DTLS, /* DETAILS2 */ 78 CHG_CC, FCHG_T, /* FCHGCRNT */ 79 DCI_LMT, /* DCCRNT */ 80 TOPOFF_T, TOPOFF_S, /* TOPOFF */ 81 CPROT, /* PROTCMD */ 82 MAX8971_N_REGMAP_FIELDS 83 }; 84 85 static const struct reg_field max8971_reg_field[MAX8971_N_REGMAP_FIELDS] = { 86 [THM_DTLS] = REG_FIELD(MAX8971_REG_DETAILS1, 0, 2), 87 [BAT_DTLS] = REG_FIELD(MAX8971_REG_DETAILS2, 4, 5), 88 [CHG_DTLS] = REG_FIELD(MAX8971_REG_DETAILS2, 0, 3), 89 [CHG_CC] = REG_FIELD(MAX8971_REG_FCHGCRNT, 0, 4), 90 [FCHG_T] = REG_FIELD(MAX8971_REG_FCHGCRNT, 5, 7), 91 [DCI_LMT] = REG_FIELD(MAX8971_REG_DCCRNT, 0, 5), 92 [TOPOFF_T] = REG_FIELD(MAX8971_REG_TOPOFF, 5, 7), 93 [TOPOFF_S] = REG_FIELD(MAX8971_REG_TOPOFF, 2, 3), 94 [CPROT] = REG_FIELD(MAX8971_REG_PROTCMD, 2, 3), 95 }; 96 97 static const struct regmap_config max8971_regmap_config = { 98 .reg_bits = 8, 99 .val_bits = 8, 100 .max_register = MAX8971_REG_CHGINT, 101 }; 102 103 struct max8971_data { 104 struct device *dev; 105 struct power_supply *psy_mains; 106 107 struct extcon_dev *edev; 108 struct notifier_block extcon_nb; 109 struct delayed_work extcon_work; 110 111 struct regmap *regmap; 112 struct regmap_field *rfield[MAX8971_N_REGMAP_FIELDS]; 113 114 enum power_supply_usb_type usb_type; 115 116 u32 fchgt; 117 u32 tofft; 118 u32 toffs; 119 120 bool present; 121 }; 122 123 static int max8971_get_status(struct max8971_data *priv, int *val) 124 { 125 u32 regval; 126 int err; 127 128 err = regmap_field_read(priv->rfield[CHG_DTLS], ®val); 129 if (err) 130 return err; 131 132 switch (regval) { 133 case MAX8971_CHARGING_DEAD_BATTERY: 134 case MAX8971_CHARGING_PREQUALIFICATION: 135 case MAX8971_CHARGING_FAST_CONST_CURRENT: 136 case MAX8971_CHARGING_FAST_CONST_VOLTAGE: 137 case MAX8971_CHARGING_TOP_OFF: 138 case MAX8971_CHARGING_THERMAL_LOOP: 139 *val = POWER_SUPPLY_STATUS_CHARGING; 140 break; 141 case MAX8971_CHARGING_DONE: 142 *val = POWER_SUPPLY_STATUS_FULL; 143 break; 144 case MAX8971_CHARGING_TIMER_FAULT: 145 *val = POWER_SUPPLY_STATUS_NOT_CHARGING; 146 break; 147 case MAX8971_CHARGING_OFF: 148 case MAX8971_CHARGING_SUSPENDED_THERMAL: 149 *val = POWER_SUPPLY_STATUS_DISCHARGING; 150 break; 151 default: 152 *val = POWER_SUPPLY_STATUS_UNKNOWN; 153 } 154 155 return 0; 156 } 157 158 static int max8971_get_charge_type(struct max8971_data *priv, int *val) 159 { 160 u32 regval; 161 int err; 162 163 err = regmap_field_read(priv->rfield[CHG_DTLS], ®val); 164 if (err) 165 return err; 166 167 switch (regval) { 168 case MAX8971_CHARGING_DEAD_BATTERY: 169 case MAX8971_CHARGING_PREQUALIFICATION: 170 *val = POWER_SUPPLY_CHARGE_TYPE_TRICKLE; 171 break; 172 case MAX8971_CHARGING_FAST_CONST_CURRENT: 173 case MAX8971_CHARGING_FAST_CONST_VOLTAGE: 174 *val = POWER_SUPPLY_CHARGE_TYPE_FAST; 175 break; 176 case MAX8971_CHARGING_TOP_OFF: 177 case MAX8971_CHARGING_THERMAL_LOOP: 178 *val = POWER_SUPPLY_CHARGE_TYPE_STANDARD; 179 break; 180 case MAX8971_CHARGING_DONE: 181 case MAX8971_CHARGING_TIMER_FAULT: 182 case MAX8971_CHARGING_SUSPENDED_THERMAL: 183 case MAX8971_CHARGING_OFF: 184 *val = POWER_SUPPLY_CHARGE_TYPE_NONE; 185 break; 186 default: 187 *val = POWER_SUPPLY_CHARGE_TYPE_UNKNOWN; 188 } 189 190 return 0; 191 } 192 193 static int max8971_get_health(struct max8971_data *priv, int *val) 194 { 195 u32 regval; 196 int err; 197 198 err = regmap_field_read(priv->rfield[THM_DTLS], ®val); 199 if (err) 200 return err; 201 202 switch (regval) { 203 case MAX8971_HEALTH_COLD: 204 *val = POWER_SUPPLY_HEALTH_COLD; 205 break; 206 case MAX8971_HEALTH_COOL: 207 *val = POWER_SUPPLY_HEALTH_COOL; 208 break; 209 case MAX8971_HEALTH_WARM: 210 *val = POWER_SUPPLY_HEALTH_GOOD; 211 break; 212 case MAX8971_HEALTH_HOT: 213 *val = POWER_SUPPLY_HEALTH_HOT; 214 break; 215 case MAX8971_HEALTH_OVERHEAT: 216 *val = POWER_SUPPLY_HEALTH_OVERHEAT; 217 break; 218 case MAX8971_HEALTH_UNKNOWN: 219 default: 220 *val = POWER_SUPPLY_HEALTH_UNKNOWN; 221 } 222 223 return 0; 224 } 225 226 static int max8971_get_online(struct max8971_data *priv, int *val) 227 { 228 u32 regval; 229 int err; 230 231 err = regmap_read(priv->regmap, MAX8971_REG_CHG_STAT, ®val); 232 if (err) 233 return err; 234 235 if (priv->present) 236 /* CHG_OK bit is 0 when charger is online */ 237 *val = !(regval & MAX8971_CHG_MASK); 238 else 239 *val = priv->present; 240 241 return 0; 242 } 243 244 static int max8971_get_integer(struct max8971_data *priv, enum max8971_field_idx fidx, 245 u32 clamp_min, u32 clamp_max, u32 mult, int *val) 246 { 247 u32 regval; 248 int err; 249 250 err = regmap_field_read(priv->rfield[fidx], ®val); 251 if (err) 252 return err; 253 254 *val = clamp_val(regval * mult, clamp_min, clamp_max); 255 256 return 0; 257 } 258 259 static int max8971_set_integer(struct max8971_data *priv, enum max8971_field_idx fidx, 260 u32 clamp_min, u32 clamp_max, u32 div, int val) 261 { 262 u32 regval; 263 264 regval = clamp_val(val, clamp_min, clamp_max) / div; 265 266 return regmap_field_write(priv->rfield[fidx], regval); 267 } 268 269 static int max8971_get_property(struct power_supply *psy, enum power_supply_property psp, 270 union power_supply_propval *val) 271 { 272 struct max8971_data *priv = power_supply_get_drvdata(psy); 273 int err = 0; 274 275 switch (psp) { 276 case POWER_SUPPLY_PROP_STATUS: 277 err = max8971_get_status(priv, &val->intval); 278 break; 279 case POWER_SUPPLY_PROP_CHARGE_TYPE: 280 err = max8971_get_charge_type(priv, &val->intval); 281 break; 282 case POWER_SUPPLY_PROP_USB_TYPE: 283 val->intval = priv->usb_type; 284 break; 285 case POWER_SUPPLY_PROP_HEALTH: 286 err = max8971_get_health(priv, &val->intval); 287 break; 288 case POWER_SUPPLY_PROP_ONLINE: 289 err = max8971_get_online(priv, &val->intval); 290 break; 291 case POWER_SUPPLY_PROP_PRESENT: 292 val->intval = priv->present; 293 break; 294 case POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT_MAX: 295 val->intval = MAX8971_CHG_CC_MAX; 296 break; 297 case POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT: 298 err = max8971_get_integer(priv, CHG_CC, MAX8971_CHG_CC_MIN, MAX8971_CHG_CC_MAX, 299 MAX8971_CHG_CC_STEP, &val->intval); 300 break; 301 case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT: 302 err = max8971_get_integer(priv, DCI_LMT, MAX8971_DCILMT_MIN, MAX8971_DCILMT_MAX, 303 MAX8971_DCILMT_STEP, &val->intval); 304 break; 305 case POWER_SUPPLY_PROP_MODEL_NAME: 306 val->strval = max8971_model; 307 break; 308 case POWER_SUPPLY_PROP_MANUFACTURER: 309 val->strval = max8971_manufacturer; 310 break; 311 default: 312 err = -EINVAL; 313 } 314 315 return err; 316 } 317 318 static int max8971_set_property(struct power_supply *psy, enum power_supply_property psp, 319 const union power_supply_propval *val) 320 { 321 struct max8971_data *priv = power_supply_get_drvdata(psy); 322 int err = 0; 323 324 switch (psp) { 325 case POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT: 326 err = max8971_set_integer(priv, CHG_CC, MAX8971_CHG_CC_MIN, MAX8971_CHG_CC_MAX, 327 MAX8971_CHG_CC_STEP, val->intval); 328 break; 329 case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT: 330 err = max8971_set_integer(priv, DCI_LMT, MAX8971_DCILMT_MIN, MAX8971_DCILMT_MAX, 331 MAX8971_DCILMT_STEP, val->intval); 332 break; 333 default: 334 err = -EINVAL; 335 } 336 337 return err; 338 }; 339 340 static int max8971_property_is_writeable(struct power_supply *psy, 341 enum power_supply_property psp) 342 { 343 switch (psp) { 344 case POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT: 345 case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT: 346 return true; 347 default: 348 return false; 349 } 350 } 351 352 static enum power_supply_property max8971_properties[] = { 353 POWER_SUPPLY_PROP_STATUS, 354 POWER_SUPPLY_PROP_CHARGE_TYPE, 355 POWER_SUPPLY_PROP_USB_TYPE, 356 POWER_SUPPLY_PROP_HEALTH, 357 POWER_SUPPLY_PROP_ONLINE, 358 POWER_SUPPLY_PROP_PRESENT, 359 POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT, 360 POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT_MAX, 361 POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT, 362 POWER_SUPPLY_PROP_MODEL_NAME, 363 POWER_SUPPLY_PROP_MANUFACTURER, 364 }; 365 366 static const struct power_supply_desc max8971_charger_desc = { 367 .name = "max8971-charger", 368 .type = POWER_SUPPLY_TYPE_USB, 369 .usb_types = BIT(POWER_SUPPLY_USB_TYPE_UNKNOWN) | 370 BIT(POWER_SUPPLY_USB_TYPE_SDP) | 371 BIT(POWER_SUPPLY_USB_TYPE_DCP) | 372 BIT(POWER_SUPPLY_USB_TYPE_CDP) | 373 BIT(POWER_SUPPLY_USB_TYPE_ACA), 374 .properties = max8971_properties, 375 .num_properties = ARRAY_SIZE(max8971_properties), 376 .get_property = max8971_get_property, 377 .set_property = max8971_set_property, 378 .property_is_writeable = max8971_property_is_writeable, 379 }; 380 381 static void max8971_update_config(struct max8971_data *priv) 382 { 383 regmap_field_write(priv->rfield[CPROT], MAX8971_CHGPROT_UNLOCKED); 384 385 if (priv->fchgt != MAX8971_FCHGT_DEFAULT) 386 regmap_field_write(priv->rfield[FCHG_T], priv->fchgt); 387 388 regmap_write_bits(priv->regmap, MAX8971_REG_DCCRNT, MAX8971_CHGRSTRT_MASK, 389 MAX8971_CHGRSTRT_MASK); 390 391 if (priv->tofft != MAX8971_TOPOFFT_DEFAULT) 392 regmap_field_write(priv->rfield[TOPOFF_T], priv->tofft); 393 394 if (priv->toffs) 395 regmap_field_write(priv->rfield[TOPOFF_S], priv->toffs); 396 397 regmap_field_write(priv->rfield[CPROT], MAX8971_CHGPROT_LOCKED); 398 } 399 400 static ssize_t fast_charge_timer_show(struct device *dev, struct device_attribute *attr, 401 char *buf) 402 { 403 struct power_supply *psy = to_power_supply(dev); 404 struct max8971_data *priv = power_supply_get_drvdata(psy); 405 u32 regval; 406 int err; 407 408 err = regmap_field_read(priv->rfield[FCHG_T], ®val); 409 if (err) 410 return err; 411 412 switch (regval) { 413 case 0x1 ... 0x7: 414 /* Time is off by 3 hours comparing to value */ 415 regval += 3; 416 break; 417 case 0x0: 418 default: 419 regval = 0; 420 break; 421 } 422 423 return sysfs_emit(buf, "%u\n", regval); 424 } 425 426 static ssize_t fast_charge_timer_store(struct device *dev, struct device_attribute *attr, 427 const char *buf, size_t count) 428 { 429 struct power_supply *psy = to_power_supply(dev); 430 struct max8971_data *priv = power_supply_get_drvdata(psy); 431 unsigned long hours; 432 int val, err; 433 434 err = kstrtoul(buf, 10, &hours); 435 if (err) 436 return err; 437 438 val = hours - 3; 439 if (val <= 0 || val > 7) 440 priv->fchgt = 0; 441 else 442 priv->fchgt = val; 443 444 max8971_update_config(priv); 445 446 return count; 447 } 448 449 static ssize_t top_off_threshold_current_show(struct device *dev, 450 struct device_attribute *attr, 451 char *buf) 452 { 453 struct power_supply *psy = to_power_supply(dev); 454 struct max8971_data *priv = power_supply_get_drvdata(psy); 455 u32 regval, val; 456 int err; 457 458 err = regmap_field_read(priv->rfield[TOPOFF_S], ®val); 459 if (err) 460 return err; 461 462 /* 50uA start with 50uA step */ 463 val = regval * 50 + 50; 464 val *= 1000; 465 466 return sysfs_emit(buf, "%u\n", val); 467 } 468 469 static ssize_t top_off_threshold_current_store(struct device *dev, 470 struct device_attribute *attr, 471 const char *buf, size_t count) 472 { 473 struct power_supply *psy = to_power_supply(dev); 474 struct max8971_data *priv = power_supply_get_drvdata(psy); 475 unsigned long uamp; 476 int err; 477 478 err = kstrtoul(buf, 10, &uamp); 479 if (err) 480 return err; 481 482 if (uamp < 50000 || uamp > 200000) 483 return -EINVAL; 484 485 priv->toffs = uamp / 50000 - 1; 486 487 max8971_update_config(priv); 488 489 return count; 490 } 491 492 static ssize_t top_off_timer_show(struct device *dev, struct device_attribute *attr, 493 char *buf) 494 { 495 struct power_supply *psy = to_power_supply(dev); 496 struct max8971_data *priv = power_supply_get_drvdata(psy); 497 u32 regval; 498 int err; 499 500 err = regmap_field_read(priv->rfield[TOPOFF_T], ®val); 501 if (err) 502 return err; 503 504 /* 10 min intervals */ 505 regval *= 10; 506 507 return sysfs_emit(buf, "%u\n", regval); 508 } 509 510 static ssize_t top_off_timer_store(struct device *dev, struct device_attribute *attr, 511 const char *buf, size_t count) 512 { 513 struct power_supply *psy = to_power_supply(dev); 514 struct max8971_data *priv = power_supply_get_drvdata(psy); 515 unsigned long minutes; 516 int err; 517 518 err = kstrtoul(buf, 10, &minutes); 519 if (err) 520 return err; 521 522 if (minutes > 70) 523 return -EINVAL; 524 525 priv->tofft = minutes / 10; 526 527 max8971_update_config(priv); 528 529 return count; 530 } 531 532 static DEVICE_ATTR_RW(fast_charge_timer); 533 static DEVICE_ATTR_RW(top_off_threshold_current); 534 static DEVICE_ATTR_RW(top_off_timer); 535 536 static struct attribute *max8971_attrs[] = { 537 &dev_attr_fast_charge_timer.attr, 538 &dev_attr_top_off_threshold_current.attr, 539 &dev_attr_top_off_timer.attr, 540 NULL 541 }; 542 ATTRIBUTE_GROUPS(max8971); 543 544 static void max8971_extcon_evt_worker(struct work_struct *work) 545 { 546 struct max8971_data *priv = 547 container_of(work, struct max8971_data, extcon_work.work); 548 struct device *dev = priv->dev; 549 struct extcon_dev *edev = priv->edev; 550 u32 chgcc, dcilmt; 551 552 if (extcon_get_state(edev, EXTCON_CHG_USB_SDP) > 0) { 553 dev_dbg(dev, "USB SDP charger is connected\n"); 554 priv->usb_type = POWER_SUPPLY_USB_TYPE_SDP; 555 chgcc = 500000; 556 dcilmt = 500000; 557 } else if (extcon_get_state(edev, EXTCON_USB) > 0) { 558 dev_dbg(dev, "USB charger is connected\n"); 559 priv->usb_type = POWER_SUPPLY_USB_TYPE_SDP; 560 chgcc = 500000; 561 dcilmt = 500000; 562 } else if (extcon_get_state(edev, EXTCON_DISP_MHL) > 0) { 563 dev_dbg(dev, "MHL plug is connected\n"); 564 priv->usb_type = POWER_SUPPLY_USB_TYPE_SDP; 565 chgcc = 500000; 566 dcilmt = 500000; 567 } else if (extcon_get_state(edev, EXTCON_CHG_USB_DCP) > 0) { 568 dev_dbg(dev, "USB DCP charger is connected\n"); 569 priv->usb_type = POWER_SUPPLY_USB_TYPE_DCP; 570 chgcc = 900000; 571 dcilmt = 1200000; 572 } else if (extcon_get_state(edev, EXTCON_CHG_USB_FAST) > 0) { 573 dev_dbg(dev, "USB FAST charger is connected\n"); 574 priv->usb_type = POWER_SUPPLY_USB_TYPE_ACA; 575 chgcc = 900000; 576 dcilmt = 1200000; 577 } else if (extcon_get_state(edev, EXTCON_CHG_USB_SLOW) > 0) { 578 dev_dbg(dev, "USB SLOW charger is connected\n"); 579 priv->usb_type = POWER_SUPPLY_USB_TYPE_ACA; 580 chgcc = 900000; 581 dcilmt = 1200000; 582 } else if (extcon_get_state(edev, EXTCON_CHG_USB_CDP) > 0) { 583 dev_dbg(dev, "USB CDP charger is connected\n"); 584 priv->usb_type = POWER_SUPPLY_USB_TYPE_CDP; 585 chgcc = 900000; 586 dcilmt = 1200000; 587 } else { 588 dev_dbg(dev, "USB state is unknown\n"); 589 priv->usb_type = POWER_SUPPLY_USB_TYPE_UNKNOWN; 590 return; 591 } 592 593 regmap_field_write(priv->rfield[CPROT], MAX8971_CHGPROT_UNLOCKED); 594 595 max8971_set_integer(priv, CHG_CC, MAX8971_CHG_CC_MIN, MAX8971_CHG_CC_MAX, 596 MAX8971_CHG_CC_STEP, chgcc); 597 max8971_set_integer(priv, DCI_LMT, MAX8971_DCILMT_MIN, MAX8971_DCILMT_MAX, 598 MAX8971_DCILMT_STEP, dcilmt); 599 600 regmap_field_write(priv->rfield[CPROT], MAX8971_CHGPROT_LOCKED); 601 } 602 603 static int extcon_get_charger_type(struct notifier_block *nb, 604 unsigned long state, void *data) 605 { 606 struct max8971_data *priv = 607 container_of(nb, struct max8971_data, extcon_nb); 608 schedule_delayed_work(&priv->extcon_work, 0); 609 610 return NOTIFY_OK; 611 } 612 613 static irqreturn_t max8971_interrupt(int irq, void *dev_id) 614 { 615 struct max8971_data *priv = dev_id; 616 struct device *dev = priv->dev; 617 int err, state; 618 619 err = regmap_read(priv->regmap, MAX8971_REG_CHGINT, &state); 620 if (err) 621 dev_err(dev, "interrupt reg read failed %d\n", err); 622 623 err = regmap_write_bits(priv->regmap, MAX8971_REG_CHGINT_MASK, 624 MAX8971_AICL_MASK, MAX8971_AICL_MASK); 625 if (err) 626 dev_err(dev, "failed to mask IRQ\n"); 627 628 /* set presence prop */ 629 priv->present = state & MAX8971_REG_CHG_RST; 630 631 /* on every plug chip resets to default */ 632 if (priv->present) 633 max8971_update_config(priv); 634 635 /* update supply status */ 636 power_supply_changed(priv->psy_mains); 637 638 return IRQ_HANDLED; 639 } 640 641 static int max8971_probe(struct i2c_client *client) 642 { 643 struct device *dev = &client->dev; 644 struct max8971_data *priv; 645 struct device_node *extcon; 646 struct power_supply_config cfg = { }; 647 int err, i; 648 649 priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL); 650 if (!priv) 651 return -ENOMEM; 652 653 priv->dev = dev; 654 priv->usb_type = POWER_SUPPLY_USB_TYPE_UNKNOWN; 655 656 i2c_set_clientdata(client, priv); 657 658 priv->regmap = devm_regmap_init_i2c(client, &max8971_regmap_config); 659 if (IS_ERR(priv->regmap)) 660 return dev_err_probe(dev, PTR_ERR(priv->regmap), "cannot allocate regmap\n"); 661 662 for (i = 0; i < MAX8971_N_REGMAP_FIELDS; i++) { 663 priv->rfield[i] = devm_regmap_field_alloc(dev, priv->regmap, max8971_reg_field[i]); 664 if (IS_ERR(priv->rfield[i])) 665 return dev_err_probe(dev, PTR_ERR(priv->rfield[i]), 666 "cannot allocate regmap field\n"); 667 } 668 669 cfg.attr_grp = max8971_groups; 670 cfg.drv_data = priv; 671 cfg.fwnode = dev_fwnode(dev); 672 673 priv->psy_mains = devm_power_supply_register(dev, &max8971_charger_desc, &cfg); 674 if (IS_ERR(priv->psy_mains)) 675 return dev_err_probe(dev, PTR_ERR(priv->psy_mains), 676 "failed to register mains supply\n"); 677 678 err = regmap_write_bits(priv->regmap, MAX8971_REG_CHGINT_MASK, MAX8971_AICL_MASK, 679 MAX8971_AICL_MASK); 680 if (err) 681 return dev_err_probe(dev, err, "failed to mask IRQ\n"); 682 683 err = devm_request_threaded_irq(dev, client->irq, NULL, &max8971_interrupt, 684 IRQF_ONESHOT | IRQF_SHARED, client->name, priv); 685 if (err) 686 return err; 687 688 extcon = of_graph_get_remote_node(dev->of_node, -1, -1); 689 if (!extcon) 690 return 0; 691 692 priv->edev = extcon_find_edev_by_node(extcon); 693 of_node_put(extcon); 694 if (IS_ERR(priv->edev)) 695 return dev_err_probe(dev, PTR_ERR(priv->edev), "failed to find extcon\n"); 696 697 err = devm_delayed_work_autocancel(dev, &priv->extcon_work, 698 max8971_extcon_evt_worker); 699 if (err) 700 return dev_err_probe(dev, err, "failed to add extcon evt stop action\n"); 701 702 priv->extcon_nb.notifier_call = extcon_get_charger_type; 703 704 err = devm_extcon_register_notifier_all(dev, priv->edev, &priv->extcon_nb); 705 if (err) 706 return dev_err_probe(dev, err, "failed to register notifier\n"); 707 708 /* Initial configuration work with 1 sec delay */ 709 schedule_delayed_work(&priv->extcon_work, msecs_to_jiffies(1000)); 710 711 return 0; 712 } 713 714 static int __maybe_unused max8971_resume(struct device *dev) 715 { 716 struct i2c_client *client = to_i2c_client(dev); 717 struct max8971_data *priv = i2c_get_clientdata(client); 718 719 irq_wake_thread(client->irq, priv); 720 721 return 0; 722 } 723 724 static SIMPLE_DEV_PM_OPS(max8971_pm_ops, NULL, max8971_resume); 725 726 static const struct of_device_id max8971_match_ids[] = { 727 { .compatible = "maxim,max8971" }, 728 { /* sentinel */ } 729 }; 730 MODULE_DEVICE_TABLE(of, max8971_match_ids); 731 732 static const struct i2c_device_id max8971_i2c_id[] = { 733 { .name = "max8971" }, 734 { } 735 }; 736 MODULE_DEVICE_TABLE(i2c, max8971_i2c_id); 737 738 static struct i2c_driver max8971_driver = { 739 .driver = { 740 .name = "max8971-charger", 741 .of_match_table = max8971_match_ids, 742 .pm = &max8971_pm_ops, 743 }, 744 .probe = max8971_probe, 745 .id_table = max8971_i2c_id, 746 }; 747 module_i2c_driver(max8971_driver); 748 749 MODULE_AUTHOR("Svyatoslav Ryhel <clamor95@gmail.com>"); 750 MODULE_DESCRIPTION("MAX8971 Charger Driver"); 751 MODULE_LICENSE("GPL"); 752