1 /* 2 * Power supply driver for the Active-semi ACT8945A PMIC 3 * 4 * Copyright (C) 2015 Atmel Corporation 5 * 6 * Author: Wenyou Yang <wenyou.yang@atmel.com> 7 * 8 * This program is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU General Public License version 2 as 10 * published by the Free Software Foundation. 11 * 12 */ 13 #include <linux/interrupt.h> 14 #include <linux/module.h> 15 #include <linux/of.h> 16 #include <linux/of_irq.h> 17 #include <linux/platform_device.h> 18 #include <linux/power_supply.h> 19 #include <linux/regmap.h> 20 #include <linux/gpio/consumer.h> 21 22 static const char *act8945a_charger_model = "ACT8945A"; 23 static const char *act8945a_charger_manufacturer = "Active-semi"; 24 25 /** 26 * ACT8945A Charger Register Map 27 */ 28 29 /* 0x70: Reserved */ 30 #define ACT8945A_APCH_CFG 0x71 31 #define ACT8945A_APCH_STATUS 0x78 32 #define ACT8945A_APCH_CTRL 0x79 33 #define ACT8945A_APCH_STATE 0x7A 34 35 /* ACT8945A_APCH_CFG */ 36 #define APCH_CFG_OVPSET (0x3 << 0) 37 #define APCH_CFG_OVPSET_6V6 (0x0 << 0) 38 #define APCH_CFG_OVPSET_7V (0x1 << 0) 39 #define APCH_CFG_OVPSET_7V5 (0x2 << 0) 40 #define APCH_CFG_OVPSET_8V (0x3 << 0) 41 #define APCH_CFG_PRETIMO (0x3 << 2) 42 #define APCH_CFG_PRETIMO_40_MIN (0x0 << 2) 43 #define APCH_CFG_PRETIMO_60_MIN (0x1 << 2) 44 #define APCH_CFG_PRETIMO_80_MIN (0x2 << 2) 45 #define APCH_CFG_PRETIMO_DISABLED (0x3 << 2) 46 #define APCH_CFG_TOTTIMO (0x3 << 4) 47 #define APCH_CFG_TOTTIMO_3_HOUR (0x0 << 4) 48 #define APCH_CFG_TOTTIMO_4_HOUR (0x1 << 4) 49 #define APCH_CFG_TOTTIMO_5_HOUR (0x2 << 4) 50 #define APCH_CFG_TOTTIMO_DISABLED (0x3 << 4) 51 #define APCH_CFG_SUSCHG (0x1 << 7) 52 53 #define APCH_STATUS_CHGDAT BIT(0) 54 #define APCH_STATUS_INDAT BIT(1) 55 #define APCH_STATUS_TEMPDAT BIT(2) 56 #define APCH_STATUS_TIMRDAT BIT(3) 57 #define APCH_STATUS_CHGSTAT BIT(4) 58 #define APCH_STATUS_INSTAT BIT(5) 59 #define APCH_STATUS_TEMPSTAT BIT(6) 60 #define APCH_STATUS_TIMRSTAT BIT(7) 61 62 #define APCH_CTRL_CHGEOCOUT BIT(0) 63 #define APCH_CTRL_INDIS BIT(1) 64 #define APCH_CTRL_TEMPOUT BIT(2) 65 #define APCH_CTRL_TIMRPRE BIT(3) 66 #define APCH_CTRL_CHGEOCIN BIT(4) 67 #define APCH_CTRL_INCON BIT(5) 68 #define APCH_CTRL_TEMPIN BIT(6) 69 #define APCH_CTRL_TIMRTOT BIT(7) 70 71 #define APCH_STATE_ACINSTAT (0x1 << 1) 72 #define APCH_STATE_CSTATE (0x3 << 4) 73 #define APCH_STATE_CSTATE_SHIFT 4 74 #define APCH_STATE_CSTATE_DISABLED 0x00 75 #define APCH_STATE_CSTATE_EOC 0x01 76 #define APCH_STATE_CSTATE_FAST 0x02 77 #define APCH_STATE_CSTATE_PRE 0x03 78 79 struct act8945a_charger { 80 struct power_supply *psy; 81 struct power_supply_desc desc; 82 struct regmap *regmap; 83 struct work_struct work; 84 85 bool init_done; 86 struct gpio_desc *lbo_gpio; 87 struct gpio_desc *chglev_gpio; 88 }; 89 90 static int act8945a_get_charger_state(struct regmap *regmap, int *val) 91 { 92 int ret; 93 unsigned int status, state; 94 95 ret = regmap_read(regmap, ACT8945A_APCH_STATUS, &status); 96 if (ret < 0) 97 return ret; 98 99 ret = regmap_read(regmap, ACT8945A_APCH_STATE, &state); 100 if (ret < 0) 101 return ret; 102 103 state &= APCH_STATE_CSTATE; 104 state >>= APCH_STATE_CSTATE_SHIFT; 105 106 switch (state) { 107 case APCH_STATE_CSTATE_PRE: 108 case APCH_STATE_CSTATE_FAST: 109 *val = POWER_SUPPLY_STATUS_CHARGING; 110 break; 111 case APCH_STATE_CSTATE_EOC: 112 if (status & APCH_STATUS_CHGDAT) 113 *val = POWER_SUPPLY_STATUS_FULL; 114 else 115 *val = POWER_SUPPLY_STATUS_CHARGING; 116 break; 117 case APCH_STATE_CSTATE_DISABLED: 118 default: 119 if (!(status & APCH_STATUS_INDAT)) 120 *val = POWER_SUPPLY_STATUS_DISCHARGING; 121 else 122 *val = POWER_SUPPLY_STATUS_NOT_CHARGING; 123 break; 124 } 125 126 return 0; 127 } 128 129 static int act8945a_get_charge_type(struct regmap *regmap, int *val) 130 { 131 int ret; 132 unsigned int status, state; 133 134 ret = regmap_read(regmap, ACT8945A_APCH_STATUS, &status); 135 if (ret < 0) 136 return ret; 137 138 ret = regmap_read(regmap, ACT8945A_APCH_STATE, &state); 139 if (ret < 0) 140 return ret; 141 142 state &= APCH_STATE_CSTATE; 143 state >>= APCH_STATE_CSTATE_SHIFT; 144 145 switch (state) { 146 case APCH_STATE_CSTATE_PRE: 147 *val = POWER_SUPPLY_CHARGE_TYPE_TRICKLE; 148 break; 149 case APCH_STATE_CSTATE_FAST: 150 *val = POWER_SUPPLY_CHARGE_TYPE_FAST; 151 break; 152 case APCH_STATE_CSTATE_EOC: 153 *val = POWER_SUPPLY_CHARGE_TYPE_NONE; 154 break; 155 case APCH_STATE_CSTATE_DISABLED: 156 default: 157 if (!(status & APCH_STATUS_INDAT)) 158 *val = POWER_SUPPLY_CHARGE_TYPE_NONE; 159 else 160 *val = POWER_SUPPLY_CHARGE_TYPE_UNKNOWN; 161 break; 162 } 163 164 return 0; 165 } 166 167 static int act8945a_get_battery_health(struct regmap *regmap, int *val) 168 { 169 int ret; 170 unsigned int status, state, config; 171 172 ret = regmap_read(regmap, ACT8945A_APCH_STATUS, &status); 173 if (ret < 0) 174 return ret; 175 176 ret = regmap_read(regmap, ACT8945A_APCH_CFG, &config); 177 if (ret < 0) 178 return ret; 179 180 ret = regmap_read(regmap, ACT8945A_APCH_STATE, &state); 181 if (ret < 0) 182 return ret; 183 184 state &= APCH_STATE_CSTATE; 185 state >>= APCH_STATE_CSTATE_SHIFT; 186 187 switch (state) { 188 case APCH_STATE_CSTATE_DISABLED: 189 if (config & APCH_CFG_SUSCHG) { 190 *val = POWER_SUPPLY_HEALTH_UNKNOWN; 191 } else if (status & APCH_STATUS_INDAT) { 192 if (!(status & APCH_STATUS_TEMPDAT)) 193 *val = POWER_SUPPLY_HEALTH_OVERHEAT; 194 else if (status & APCH_STATUS_TIMRDAT) 195 *val = POWER_SUPPLY_HEALTH_SAFETY_TIMER_EXPIRE; 196 else 197 *val = POWER_SUPPLY_HEALTH_OVERVOLTAGE; 198 } else { 199 *val = POWER_SUPPLY_HEALTH_GOOD; 200 } 201 break; 202 case APCH_STATE_CSTATE_PRE: 203 case APCH_STATE_CSTATE_FAST: 204 case APCH_STATE_CSTATE_EOC: 205 default: 206 *val = POWER_SUPPLY_HEALTH_GOOD; 207 break; 208 } 209 210 return 0; 211 } 212 213 static int act8945a_get_capacity_level(struct act8945a_charger *charger, 214 struct regmap *regmap, int *val) 215 { 216 int ret; 217 unsigned int status, state, config; 218 int lbo_level = gpiod_get_value(charger->lbo_gpio); 219 220 ret = regmap_read(regmap, ACT8945A_APCH_STATUS, &status); 221 if (ret < 0) 222 return ret; 223 224 ret = regmap_read(regmap, ACT8945A_APCH_CFG, &config); 225 if (ret < 0) 226 return ret; 227 228 ret = regmap_read(regmap, ACT8945A_APCH_STATE, &state); 229 if (ret < 0) 230 return ret; 231 232 state &= APCH_STATE_CSTATE; 233 state >>= APCH_STATE_CSTATE_SHIFT; 234 235 switch (state) { 236 case APCH_STATE_CSTATE_PRE: 237 *val = POWER_SUPPLY_CAPACITY_LEVEL_LOW; 238 break; 239 case APCH_STATE_CSTATE_FAST: 240 if (lbo_level) 241 *val = POWER_SUPPLY_CAPACITY_LEVEL_HIGH; 242 else 243 *val = POWER_SUPPLY_CAPACITY_LEVEL_LOW; 244 break; 245 case APCH_STATE_CSTATE_EOC: 246 if (status & APCH_STATUS_CHGDAT) 247 *val = POWER_SUPPLY_CAPACITY_LEVEL_FULL; 248 else 249 *val = POWER_SUPPLY_CAPACITY_LEVEL_NORMAL; 250 break; 251 case APCH_STATE_CSTATE_DISABLED: 252 default: 253 if (config & APCH_CFG_SUSCHG) { 254 *val = POWER_SUPPLY_CAPACITY_LEVEL_UNKNOWN; 255 } else { 256 *val = POWER_SUPPLY_CAPACITY_LEVEL_NORMAL; 257 if (!(status & APCH_STATUS_INDAT)) { 258 if (!lbo_level) 259 *val = POWER_SUPPLY_CAPACITY_LEVEL_CRITICAL; 260 } 261 } 262 break; 263 } 264 265 return 0; 266 } 267 268 #define MAX_CURRENT_USB_HIGH 450000 269 #define MAX_CURRENT_USB_LOW 90000 270 #define MAX_CURRENT_USB_PRE 45000 271 /* 272 * Riset(K) = 2336 * (1V/Ichg(mA)) - 0.205 273 * Riset = 2.43K 274 */ 275 #define MAX_CURRENT_AC_HIGH 886527 276 #define MAX_CURRENT_AC_LOW 117305 277 #define MAX_CURRENT_AC_HIGH_PRE 88653 278 #define MAX_CURRENT_AC_LOW_PRE 11731 279 280 static int act8945a_get_current_max(struct act8945a_charger *charger, 281 struct regmap *regmap, int *val) 282 { 283 int ret; 284 unsigned int status, state; 285 unsigned int acin_state; 286 int chgin_level = gpiod_get_value(charger->chglev_gpio); 287 288 ret = regmap_read(regmap, ACT8945A_APCH_STATUS, &status); 289 if (ret < 0) 290 return ret; 291 292 ret = regmap_read(regmap, ACT8945A_APCH_STATE, &state); 293 if (ret < 0) 294 return ret; 295 296 acin_state = (state & APCH_STATE_ACINSTAT) >> 1; 297 298 state &= APCH_STATE_CSTATE; 299 state >>= APCH_STATE_CSTATE_SHIFT; 300 301 switch (state) { 302 case APCH_STATE_CSTATE_PRE: 303 if (acin_state) { 304 if (chgin_level) 305 *val = MAX_CURRENT_AC_HIGH_PRE; 306 else 307 *val = MAX_CURRENT_AC_LOW_PRE; 308 } else { 309 *val = MAX_CURRENT_USB_PRE; 310 } 311 break; 312 case APCH_STATE_CSTATE_FAST: 313 if (acin_state) { 314 if (chgin_level) 315 *val = MAX_CURRENT_AC_HIGH; 316 else 317 *val = MAX_CURRENT_AC_LOW; 318 } else { 319 if (chgin_level) 320 *val = MAX_CURRENT_USB_HIGH; 321 else 322 *val = MAX_CURRENT_USB_LOW; 323 } 324 break; 325 case APCH_STATE_CSTATE_EOC: 326 case APCH_STATE_CSTATE_DISABLED: 327 default: 328 *val = 0; 329 break; 330 } 331 332 return 0; 333 } 334 335 static enum power_supply_property act8945a_charger_props[] = { 336 POWER_SUPPLY_PROP_STATUS, 337 POWER_SUPPLY_PROP_CHARGE_TYPE, 338 POWER_SUPPLY_PROP_TECHNOLOGY, 339 POWER_SUPPLY_PROP_HEALTH, 340 POWER_SUPPLY_PROP_CAPACITY_LEVEL, 341 POWER_SUPPLY_PROP_CURRENT_MAX, 342 POWER_SUPPLY_PROP_MODEL_NAME, 343 POWER_SUPPLY_PROP_MANUFACTURER 344 }; 345 346 static int act8945a_charger_get_property(struct power_supply *psy, 347 enum power_supply_property prop, 348 union power_supply_propval *val) 349 { 350 struct act8945a_charger *charger = power_supply_get_drvdata(psy); 351 struct regmap *regmap = charger->regmap; 352 int ret = 0; 353 354 switch (prop) { 355 case POWER_SUPPLY_PROP_STATUS: 356 ret = act8945a_get_charger_state(regmap, &val->intval); 357 break; 358 case POWER_SUPPLY_PROP_CHARGE_TYPE: 359 ret = act8945a_get_charge_type(regmap, &val->intval); 360 break; 361 case POWER_SUPPLY_PROP_TECHNOLOGY: 362 val->intval = POWER_SUPPLY_TECHNOLOGY_LION; 363 break; 364 case POWER_SUPPLY_PROP_HEALTH: 365 ret = act8945a_get_battery_health(regmap, &val->intval); 366 break; 367 case POWER_SUPPLY_PROP_CAPACITY_LEVEL: 368 ret = act8945a_get_capacity_level(charger, 369 regmap, &val->intval); 370 break; 371 case POWER_SUPPLY_PROP_CURRENT_MAX: 372 ret = act8945a_get_current_max(charger, 373 regmap, &val->intval); 374 break; 375 case POWER_SUPPLY_PROP_MODEL_NAME: 376 val->strval = act8945a_charger_model; 377 break; 378 case POWER_SUPPLY_PROP_MANUFACTURER: 379 val->strval = act8945a_charger_manufacturer; 380 break; 381 default: 382 return -EINVAL; 383 } 384 385 return ret; 386 } 387 388 static int act8945a_enable_interrupt(struct act8945a_charger *charger) 389 { 390 struct regmap *regmap = charger->regmap; 391 unsigned char ctrl; 392 int ret; 393 394 ctrl = APCH_CTRL_CHGEOCOUT | APCH_CTRL_CHGEOCIN | 395 APCH_CTRL_INDIS | APCH_CTRL_INCON | 396 APCH_CTRL_TEMPOUT | APCH_CTRL_TEMPIN | 397 APCH_CTRL_TIMRPRE | APCH_CTRL_TIMRTOT; 398 ret = regmap_write(regmap, ACT8945A_APCH_CTRL, ctrl); 399 if (ret) 400 return ret; 401 402 ctrl = APCH_STATUS_CHGSTAT | APCH_STATUS_INSTAT | 403 APCH_STATUS_TEMPSTAT | APCH_STATUS_TIMRSTAT; 404 ret = regmap_write(regmap, ACT8945A_APCH_STATUS, ctrl); 405 if (ret) 406 return ret; 407 408 return 0; 409 } 410 411 static unsigned int act8945a_set_supply_type(struct act8945a_charger *charger, 412 unsigned int *type) 413 { 414 unsigned int status, state; 415 int ret; 416 417 ret = regmap_read(charger->regmap, ACT8945A_APCH_STATUS, &status); 418 if (ret < 0) 419 return ret; 420 421 ret = regmap_read(charger->regmap, ACT8945A_APCH_STATE, &state); 422 if (ret < 0) 423 return ret; 424 425 if (status & APCH_STATUS_INDAT) { 426 if (state & APCH_STATE_ACINSTAT) 427 *type = POWER_SUPPLY_TYPE_MAINS; 428 else 429 *type = POWER_SUPPLY_TYPE_USB; 430 } else { 431 *type = POWER_SUPPLY_TYPE_BATTERY; 432 } 433 434 return 0; 435 } 436 437 static void act8945a_work(struct work_struct *work) 438 { 439 struct act8945a_charger *charger = 440 container_of(work, struct act8945a_charger, work); 441 442 act8945a_set_supply_type(charger, &charger->desc.type); 443 444 power_supply_changed(charger->psy); 445 } 446 447 static irqreturn_t act8945a_status_changed(int irq, void *dev_id) 448 { 449 struct act8945a_charger *charger = dev_id; 450 451 if (charger->init_done) 452 schedule_work(&charger->work); 453 454 return IRQ_HANDLED; 455 } 456 457 #define DEFAULT_TOTAL_TIME_OUT 3 458 #define DEFAULT_PRE_TIME_OUT 40 459 #define DEFAULT_INPUT_OVP_THRESHOLD 6600 460 461 static int act8945a_charger_config(struct device *dev, 462 struct act8945a_charger *charger) 463 { 464 struct device_node *np = dev->of_node; 465 struct regmap *regmap = charger->regmap; 466 467 u32 total_time_out; 468 u32 pre_time_out; 469 u32 input_voltage_threshold; 470 int err, ret; 471 472 unsigned int tmp; 473 unsigned int value = 0; 474 475 if (!np) { 476 dev_err(dev, "no charger of node\n"); 477 return -EINVAL; 478 } 479 480 ret = regmap_read(regmap, ACT8945A_APCH_CFG, &tmp); 481 if (ret) 482 return ret; 483 484 if (tmp & APCH_CFG_SUSCHG) { 485 value |= APCH_CFG_SUSCHG; 486 dev_info(dev, "have been suspended\n"); 487 } 488 489 charger->lbo_gpio = devm_gpiod_get_optional(dev, "active-semi,lbo", 490 GPIOD_IN); 491 if (IS_ERR(charger->lbo_gpio)) { 492 err = PTR_ERR(charger->lbo_gpio); 493 dev_err(dev, "unable to claim gpio \"lbo\": %d\n", err); 494 return err; 495 } 496 497 ret = devm_request_irq(dev, gpiod_to_irq(charger->lbo_gpio), 498 act8945a_status_changed, 499 (IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING), 500 "act8945a_lbo_detect", charger); 501 if (ret) 502 dev_info(dev, "failed to request gpio \"lbo\" IRQ\n"); 503 504 charger->chglev_gpio = devm_gpiod_get_optional(dev, 505 "active-semi,chglev", 506 GPIOD_IN); 507 if (IS_ERR(charger->chglev_gpio)) { 508 err = PTR_ERR(charger->chglev_gpio); 509 dev_err(dev, "unable to claim gpio \"chglev\": %d\n", err); 510 return err; 511 } 512 513 if (of_property_read_u32(np, 514 "active-semi,input-voltage-threshold-microvolt", 515 &input_voltage_threshold)) 516 input_voltage_threshold = DEFAULT_INPUT_OVP_THRESHOLD; 517 518 if (of_property_read_u32(np, 519 "active-semi,precondition-timeout", 520 &pre_time_out)) 521 pre_time_out = DEFAULT_PRE_TIME_OUT; 522 523 if (of_property_read_u32(np, "active-semi,total-timeout", 524 &total_time_out)) 525 total_time_out = DEFAULT_TOTAL_TIME_OUT; 526 527 switch (input_voltage_threshold) { 528 case 8000: 529 value |= APCH_CFG_OVPSET_8V; 530 break; 531 case 7500: 532 value |= APCH_CFG_OVPSET_7V5; 533 break; 534 case 7000: 535 value |= APCH_CFG_OVPSET_7V; 536 break; 537 case 6600: 538 default: 539 value |= APCH_CFG_OVPSET_6V6; 540 break; 541 } 542 543 switch (pre_time_out) { 544 case 60: 545 value |= APCH_CFG_PRETIMO_60_MIN; 546 break; 547 case 80: 548 value |= APCH_CFG_PRETIMO_80_MIN; 549 break; 550 case 0: 551 value |= APCH_CFG_PRETIMO_DISABLED; 552 break; 553 case 40: 554 default: 555 value |= APCH_CFG_PRETIMO_40_MIN; 556 break; 557 } 558 559 switch (total_time_out) { 560 case 4: 561 value |= APCH_CFG_TOTTIMO_4_HOUR; 562 break; 563 case 5: 564 value |= APCH_CFG_TOTTIMO_5_HOUR; 565 break; 566 case 0: 567 value |= APCH_CFG_TOTTIMO_DISABLED; 568 break; 569 case 3: 570 default: 571 value |= APCH_CFG_TOTTIMO_3_HOUR; 572 break; 573 } 574 575 return regmap_write(regmap, ACT8945A_APCH_CFG, value); 576 } 577 578 static int act8945a_charger_probe(struct platform_device *pdev) 579 { 580 struct act8945a_charger *charger; 581 struct power_supply_config psy_cfg = {}; 582 int irq, ret; 583 584 charger = devm_kzalloc(&pdev->dev, sizeof(*charger), GFP_KERNEL); 585 if (!charger) 586 return -ENOMEM; 587 588 charger->regmap = dev_get_regmap(pdev->dev.parent, NULL); 589 if (!charger->regmap) { 590 dev_err(&pdev->dev, "Parent did not provide regmap\n"); 591 return -EINVAL; 592 } 593 594 ret = act8945a_charger_config(&pdev->dev, charger); 595 if (ret) 596 return ret; 597 598 irq = of_irq_get(pdev->dev.of_node, 0); 599 if (irq <= 0) { 600 dev_err(&pdev->dev, "failed to find IRQ number\n"); 601 return irq ?: -ENXIO; 602 } 603 604 ret = devm_request_irq(&pdev->dev, irq, act8945a_status_changed, 605 IRQF_TRIGGER_FALLING, "act8945a_interrupt", 606 charger); 607 if (ret) { 608 dev_err(&pdev->dev, "failed to request nIRQ pin IRQ\n"); 609 return ret; 610 } 611 612 charger->desc.name = "act8945a-charger"; 613 charger->desc.get_property = act8945a_charger_get_property; 614 charger->desc.properties = act8945a_charger_props; 615 charger->desc.num_properties = ARRAY_SIZE(act8945a_charger_props); 616 617 ret = act8945a_set_supply_type(charger, &charger->desc.type); 618 if (ret) 619 return -EINVAL; 620 621 psy_cfg.of_node = pdev->dev.of_node; 622 psy_cfg.drv_data = charger; 623 624 charger->psy = devm_power_supply_register(&pdev->dev, 625 &charger->desc, 626 &psy_cfg); 627 if (IS_ERR(charger->psy)) { 628 dev_err(&pdev->dev, "failed to register power supply\n"); 629 return PTR_ERR(charger->psy); 630 } 631 632 platform_set_drvdata(pdev, charger); 633 634 INIT_WORK(&charger->work, act8945a_work); 635 636 ret = act8945a_enable_interrupt(charger); 637 if (ret) 638 return -EIO; 639 640 charger->init_done = true; 641 642 return 0; 643 } 644 645 static int act8945a_charger_remove(struct platform_device *pdev) 646 { 647 struct act8945a_charger *charger = platform_get_drvdata(pdev); 648 649 charger->init_done = false; 650 cancel_work_sync(&charger->work); 651 652 return 0; 653 } 654 655 static struct platform_driver act8945a_charger_driver = { 656 .driver = { 657 .name = "act8945a-charger", 658 }, 659 .probe = act8945a_charger_probe, 660 .remove = act8945a_charger_remove, 661 }; 662 module_platform_driver(act8945a_charger_driver); 663 664 MODULE_DESCRIPTION("Active-semi ACT8945A ActivePath charger driver"); 665 MODULE_AUTHOR("Wenyou Yang <wenyou.yang@atmel.com>"); 666 MODULE_LICENSE("GPL"); 667