1// SPDX-License-Identifier: GPL-2.0-only 2/* 3 * Copyright 2012 ST Ericsson. 4 * 5 * Power supply driver for ST Ericsson pm2xxx_charger charger 6 */ 7 8#include <linux/init.h> 9#include <linux/module.h> 10#include <linux/device.h> 11#include <linux/interrupt.h> 12#include <linux/delay.h> 13#include <linux/slab.h> 14#include <linux/platform_device.h> 15#include <linux/power_supply.h> 16#include <linux/regulator/consumer.h> 17#include <linux/err.h> 18#include <linux/i2c.h> 19#include <linux/workqueue.h> 20#include <linux/mfd/abx500/ab8500.h> 21#include <linux/mfd/abx500/ab8500-bm.h> 22#include <linux/mfd/abx500/ux500_chargalg.h> 23#include <linux/pm2301_charger.h> 24#include <linux/gpio.h> 25#include <linux/pm_runtime.h> 26#include <linux/pm.h> 27 28#include "pm2301_charger.h" 29 30#define to_pm2xxx_charger_ac_device_info(x) container_of((x), \ 31 struct pm2xxx_charger, ac_chg) 32#define SLEEP_MIN 50 33#define SLEEP_MAX 100 34#define PM2XXX_AUTOSUSPEND_DELAY 500 35 36static int pm2xxx_interrupt_registers[] = { 37 PM2XXX_REG_INT1, 38 PM2XXX_REG_INT2, 39 PM2XXX_REG_INT3, 40 PM2XXX_REG_INT4, 41 PM2XXX_REG_INT5, 42 PM2XXX_REG_INT6, 43}; 44 45static enum power_supply_property pm2xxx_charger_ac_props[] = { 46 POWER_SUPPLY_PROP_HEALTH, 47 POWER_SUPPLY_PROP_PRESENT, 48 POWER_SUPPLY_PROP_ONLINE, 49 POWER_SUPPLY_PROP_VOLTAGE_AVG, 50}; 51 52static int pm2xxx_charger_voltage_map[] = { 53 3500, 54 3525, 55 3550, 56 3575, 57 3600, 58 3625, 59 3650, 60 3675, 61 3700, 62 3725, 63 3750, 64 3775, 65 3800, 66 3825, 67 3850, 68 3875, 69 3900, 70 3925, 71 3950, 72 3975, 73 4000, 74 4025, 75 4050, 76 4075, 77 4100, 78 4125, 79 4150, 80 4175, 81 4200, 82 4225, 83 4250, 84 4275, 85 4300, 86}; 87 88static int pm2xxx_charger_current_map[] = { 89 200, 90 200, 91 400, 92 600, 93 800, 94 1000, 95 1200, 96 1400, 97 1600, 98 1800, 99 2000, 100 2200, 101 2400, 102 2600, 103 2800, 104 3000, 105}; 106 107static void set_lpn_pin(struct pm2xxx_charger *pm2) 108{ 109 if (!pm2->ac.charger_connected && gpio_is_valid(pm2->lpn_pin)) { 110 gpio_set_value(pm2->lpn_pin, 1); 111 usleep_range(SLEEP_MIN, SLEEP_MAX); 112 } 113} 114 115static void clear_lpn_pin(struct pm2xxx_charger *pm2) 116{ 117 if (!pm2->ac.charger_connected && gpio_is_valid(pm2->lpn_pin)) 118 gpio_set_value(pm2->lpn_pin, 0); 119} 120 121static int pm2xxx_reg_read(struct pm2xxx_charger *pm2, int reg, u8 *val) 122{ 123 int ret; 124 125 /* wake up the device */ 126 pm_runtime_get_sync(pm2->dev); 127 128 ret = i2c_smbus_read_i2c_block_data(pm2->config.pm2xxx_i2c, reg, 129 1, val); 130 if (ret < 0) 131 dev_err(pm2->dev, "Error reading register at 0x%x\n", reg); 132 else 133 ret = 0; 134 135 pm_runtime_put_sync(pm2->dev); 136 137 return ret; 138} 139 140static int pm2xxx_reg_write(struct pm2xxx_charger *pm2, int reg, u8 val) 141{ 142 int ret; 143 144 /* wake up the device */ 145 pm_runtime_get_sync(pm2->dev); 146 147 ret = i2c_smbus_write_i2c_block_data(pm2->config.pm2xxx_i2c, reg, 148 1, &val); 149 if (ret < 0) 150 dev_err(pm2->dev, "Error writing register at 0x%x\n", reg); 151 else 152 ret = 0; 153 154 pm_runtime_put_sync(pm2->dev); 155 156 return ret; 157} 158 159static int pm2xxx_charging_enable_mngt(struct pm2xxx_charger *pm2) 160{ 161 int ret; 162 163 /* Enable charging */ 164 ret = pm2xxx_reg_write(pm2, PM2XXX_BATT_CTRL_REG2, 165 (PM2XXX_CH_AUTO_RESUME_EN | PM2XXX_CHARGER_ENA)); 166 167 return ret; 168} 169 170static int pm2xxx_charging_disable_mngt(struct pm2xxx_charger *pm2) 171{ 172 int ret; 173 174 /* Disable SW EOC ctrl */ 175 ret = pm2xxx_reg_write(pm2, PM2XXX_SW_CTRL_REG, PM2XXX_SWCTRL_HW); 176 if (ret < 0) { 177 dev_err(pm2->dev, "%s pm2xxx write failed\n", __func__); 178 return ret; 179 } 180 181 /* Disable charging */ 182 ret = pm2xxx_reg_write(pm2, PM2XXX_BATT_CTRL_REG2, 183 (PM2XXX_CH_AUTO_RESUME_DIS | PM2XXX_CHARGER_DIS)); 184 if (ret < 0) { 185 dev_err(pm2->dev, "%s pm2xxx write failed\n", __func__); 186 return ret; 187 } 188 189 return 0; 190} 191 192static int pm2xxx_charger_batt_therm_mngt(struct pm2xxx_charger *pm2, int val) 193{ 194 queue_work(pm2->charger_wq, &pm2->check_main_thermal_prot_work); 195 196 return 0; 197} 198 199 200static int pm2xxx_charger_die_therm_mngt(struct pm2xxx_charger *pm2, int val) 201{ 202 queue_work(pm2->charger_wq, &pm2->check_main_thermal_prot_work); 203 204 return 0; 205} 206 207static int pm2xxx_charger_ovv_mngt(struct pm2xxx_charger *pm2, int val) 208{ 209 dev_err(pm2->dev, "Overvoltage detected\n"); 210 pm2->flags.ovv = true; 211 power_supply_changed(pm2->ac_chg.psy); 212 213 /* Schedule a new HW failure check */ 214 queue_delayed_work(pm2->charger_wq, &pm2->check_hw_failure_work, 0); 215 216 return 0; 217} 218 219static int pm2xxx_charger_wd_exp_mngt(struct pm2xxx_charger *pm2, int val) 220{ 221 dev_dbg(pm2->dev , "20 minutes watchdog expired\n"); 222 223 pm2->ac.wd_expired = true; 224 power_supply_changed(pm2->ac_chg.psy); 225 226 return 0; 227} 228 229static int pm2xxx_charger_vbat_lsig_mngt(struct pm2xxx_charger *pm2, int val) 230{ 231 int ret; 232 233 switch (val) { 234 case PM2XXX_INT1_ITVBATLOWR: 235 dev_dbg(pm2->dev, "VBAT grows above VBAT_LOW level\n"); 236 /* Enable SW EOC ctrl */ 237 ret = pm2xxx_reg_write(pm2, PM2XXX_SW_CTRL_REG, 238 PM2XXX_SWCTRL_SW); 239 if (ret < 0) { 240 dev_err(pm2->dev, "%s pm2xxx write failed\n", __func__); 241 return ret; 242 } 243 break; 244 245 case PM2XXX_INT1_ITVBATLOWF: 246 dev_dbg(pm2->dev, "VBAT drops below VBAT_LOW level\n"); 247 /* Disable SW EOC ctrl */ 248 ret = pm2xxx_reg_write(pm2, PM2XXX_SW_CTRL_REG, 249 PM2XXX_SWCTRL_HW); 250 if (ret < 0) { 251 dev_err(pm2->dev, "%s pm2xxx write failed\n", __func__); 252 return ret; 253 } 254 break; 255 256 default: 257 dev_err(pm2->dev, "Unknown VBAT level\n"); 258 } 259 260 return 0; 261} 262 263static int pm2xxx_charger_bat_disc_mngt(struct pm2xxx_charger *pm2, int val) 264{ 265 dev_dbg(pm2->dev, "battery disconnected\n"); 266 267 return 0; 268} 269 270static int pm2xxx_charger_detection(struct pm2xxx_charger *pm2, u8 *val) 271{ 272 int ret; 273 274 ret = pm2xxx_reg_read(pm2, PM2XXX_SRCE_REG_INT2, val); 275 276 if (ret < 0) { 277 dev_err(pm2->dev, "Charger detection failed\n"); 278 goto out; 279 } 280 281 *val &= (PM2XXX_INT2_S_ITVPWR1PLUG | PM2XXX_INT2_S_ITVPWR2PLUG); 282 283out: 284 return ret; 285} 286 287static int pm2xxx_charger_itv_pwr_plug_mngt(struct pm2xxx_charger *pm2, int val) 288{ 289 290 int ret; 291 u8 read_val; 292 293 /* 294 * Since we can't be sure that the events are received 295 * synchronously, we have the check if the main charger is 296 * connected by reading the interrupt source register. 297 */ 298 ret = pm2xxx_charger_detection(pm2, &read_val); 299 300 if ((ret == 0) && read_val) { 301 pm2->ac.charger_connected = 1; 302 pm2->ac_conn = true; 303 queue_work(pm2->charger_wq, &pm2->ac_work); 304 } 305 306 307 return ret; 308} 309 310static int pm2xxx_charger_itv_pwr_unplug_mngt(struct pm2xxx_charger *pm2, 311 int val) 312{ 313 pm2->ac.charger_connected = 0; 314 queue_work(pm2->charger_wq, &pm2->ac_work); 315 316 return 0; 317} 318 319static int pm2_int_reg0(void *pm2_data, int val) 320{ 321 struct pm2xxx_charger *pm2 = pm2_data; 322 int ret = 0; 323 324 if (val & PM2XXX_INT1_ITVBATLOWR) { 325 ret = pm2xxx_charger_vbat_lsig_mngt(pm2, 326 PM2XXX_INT1_ITVBATLOWR); 327 if (ret < 0) 328 goto out; 329 } 330 331 if (val & PM2XXX_INT1_ITVBATLOWF) { 332 ret = pm2xxx_charger_vbat_lsig_mngt(pm2, 333 PM2XXX_INT1_ITVBATLOWF); 334 if (ret < 0) 335 goto out; 336 } 337 338 if (val & PM2XXX_INT1_ITVBATDISCONNECT) { 339 ret = pm2xxx_charger_bat_disc_mngt(pm2, 340 PM2XXX_INT1_ITVBATDISCONNECT); 341 if (ret < 0) 342 goto out; 343 } 344out: 345 return ret; 346} 347 348static int pm2_int_reg1(void *pm2_data, int val) 349{ 350 struct pm2xxx_charger *pm2 = pm2_data; 351 int ret = 0; 352 353 if (val & (PM2XXX_INT2_ITVPWR1PLUG | PM2XXX_INT2_ITVPWR2PLUG)) { 354 dev_dbg(pm2->dev , "Main charger plugged\n"); 355 ret = pm2xxx_charger_itv_pwr_plug_mngt(pm2, val & 356 (PM2XXX_INT2_ITVPWR1PLUG | PM2XXX_INT2_ITVPWR2PLUG)); 357 } 358 359 if (val & 360 (PM2XXX_INT2_ITVPWR1UNPLUG | PM2XXX_INT2_ITVPWR2UNPLUG)) { 361 dev_dbg(pm2->dev , "Main charger unplugged\n"); 362 ret = pm2xxx_charger_itv_pwr_unplug_mngt(pm2, val & 363 (PM2XXX_INT2_ITVPWR1UNPLUG | 364 PM2XXX_INT2_ITVPWR2UNPLUG)); 365 } 366 367 return ret; 368} 369 370static int pm2_int_reg2(void *pm2_data, int val) 371{ 372 struct pm2xxx_charger *pm2 = pm2_data; 373 int ret = 0; 374 375 if (val & PM2XXX_INT3_ITAUTOTIMEOUTWD) 376 ret = pm2xxx_charger_wd_exp_mngt(pm2, val); 377 378 if (val & (PM2XXX_INT3_ITCHPRECHARGEWD | 379 PM2XXX_INT3_ITCHCCWD | PM2XXX_INT3_ITCHCVWD)) { 380 dev_dbg(pm2->dev, 381 "Watchdog occurred for precharge, CC and CV charge\n"); 382 } 383 384 return ret; 385} 386 387static int pm2_int_reg3(void *pm2_data, int val) 388{ 389 struct pm2xxx_charger *pm2 = pm2_data; 390 int ret = 0; 391 392 if (val & (PM2XXX_INT4_ITCHARGINGON)) { 393 dev_dbg(pm2->dev , 394 "charging operation has started\n"); 395 } 396 397 if (val & (PM2XXX_INT4_ITVRESUME)) { 398 dev_dbg(pm2->dev, 399 "battery discharged down to VResume threshold\n"); 400 } 401 402 if (val & (PM2XXX_INT4_ITBATTFULL)) { 403 dev_dbg(pm2->dev , "battery fully detected\n"); 404 } 405 406 if (val & (PM2XXX_INT4_ITCVPHASE)) { 407 dev_dbg(pm2->dev, "CV phase enter with 0.5C charging\n"); 408 } 409 410 if (val & (PM2XXX_INT4_ITVPWR2OVV | PM2XXX_INT4_ITVPWR1OVV)) { 411 pm2->failure_case = VPWR_OVV; 412 ret = pm2xxx_charger_ovv_mngt(pm2, val & 413 (PM2XXX_INT4_ITVPWR2OVV | PM2XXX_INT4_ITVPWR1OVV)); 414 dev_dbg(pm2->dev, "VPWR/VSYSTEM overvoltage detected\n"); 415 } 416 417 if (val & (PM2XXX_INT4_S_ITBATTEMPCOLD | 418 PM2XXX_INT4_S_ITBATTEMPHOT)) { 419 ret = pm2xxx_charger_batt_therm_mngt(pm2, val & 420 (PM2XXX_INT4_S_ITBATTEMPCOLD | 421 PM2XXX_INT4_S_ITBATTEMPHOT)); 422 dev_dbg(pm2->dev, "BTEMP is too Low/High\n"); 423 } 424 425 return ret; 426} 427 428static int pm2_int_reg4(void *pm2_data, int val) 429{ 430 struct pm2xxx_charger *pm2 = pm2_data; 431 int ret = 0; 432 433 if (val & PM2XXX_INT5_ITVSYSTEMOVV) { 434 pm2->failure_case = VSYSTEM_OVV; 435 ret = pm2xxx_charger_ovv_mngt(pm2, val & 436 PM2XXX_INT5_ITVSYSTEMOVV); 437 dev_dbg(pm2->dev, "VSYSTEM overvoltage detected\n"); 438 } 439 440 if (val & (PM2XXX_INT5_ITTHERMALWARNINGFALL | 441 PM2XXX_INT5_ITTHERMALWARNINGRISE | 442 PM2XXX_INT5_ITTHERMALSHUTDOWNFALL | 443 PM2XXX_INT5_ITTHERMALSHUTDOWNRISE)) { 444 dev_dbg(pm2->dev, "BTEMP die temperature is too Low/High\n"); 445 ret = pm2xxx_charger_die_therm_mngt(pm2, val & 446 (PM2XXX_INT5_ITTHERMALWARNINGFALL | 447 PM2XXX_INT5_ITTHERMALWARNINGRISE | 448 PM2XXX_INT5_ITTHERMALSHUTDOWNFALL | 449 PM2XXX_INT5_ITTHERMALSHUTDOWNRISE)); 450 } 451 452 return ret; 453} 454 455static int pm2_int_reg5(void *pm2_data, int val) 456{ 457 struct pm2xxx_charger *pm2 = pm2_data; 458 int ret = 0; 459 460 if (val & (PM2XXX_INT6_ITVPWR2DROP | PM2XXX_INT6_ITVPWR1DROP)) { 461 dev_dbg(pm2->dev, "VMPWR drop to VBAT level\n"); 462 } 463 464 if (val & (PM2XXX_INT6_ITVPWR2VALIDRISE | 465 PM2XXX_INT6_ITVPWR1VALIDRISE | 466 PM2XXX_INT6_ITVPWR2VALIDFALL | 467 PM2XXX_INT6_ITVPWR1VALIDFALL)) { 468 dev_dbg(pm2->dev, "Falling/Rising edge on WPWR1/2\n"); 469 } 470 471 return ret; 472} 473 474static irqreturn_t pm2xxx_irq_int(int irq, void *data) 475{ 476 struct pm2xxx_charger *pm2 = data; 477 struct pm2xxx_interrupts *interrupt = pm2->pm2_int; 478 int i; 479 480 /* wake up the device */ 481 pm_runtime_get_sync(pm2->dev); 482 483 do { 484 for (i = 0; i < PM2XXX_NUM_INT_REG; i++) { 485 pm2xxx_reg_read(pm2, 486 pm2xxx_interrupt_registers[i], 487 &(interrupt->reg[i])); 488 489 if (interrupt->reg[i] > 0) 490 interrupt->handler[i](pm2, interrupt->reg[i]); 491 } 492 } while (gpio_get_value(pm2->pdata->gpio_irq_number) == 0); 493 494 pm_runtime_mark_last_busy(pm2->dev); 495 pm_runtime_put_autosuspend(pm2->dev); 496 497 return IRQ_HANDLED; 498} 499 500static int pm2xxx_charger_get_ac_cv(struct pm2xxx_charger *pm2) 501{ 502 int ret = 0; 503 u8 val; 504 505 if (pm2->ac.charger_connected && pm2->ac.charger_online) { 506 507 ret = pm2xxx_reg_read(pm2, PM2XXX_SRCE_REG_INT4, &val); 508 if (ret < 0) { 509 dev_err(pm2->dev, "%s pm2xxx read failed\n", __func__); 510 goto out; 511 } 512 513 if (val & PM2XXX_INT4_S_ITCVPHASE) 514 ret = PM2XXX_CONST_VOLT; 515 else 516 ret = PM2XXX_CONST_CURR; 517 } 518out: 519 return ret; 520} 521 522static int pm2xxx_current_to_regval(int curr) 523{ 524 int i; 525 526 if (curr < pm2xxx_charger_current_map[0]) 527 return 0; 528 529 for (i = 1; i < ARRAY_SIZE(pm2xxx_charger_current_map); i++) { 530 if (curr < pm2xxx_charger_current_map[i]) 531 return (i - 1); 532 } 533 534 i = ARRAY_SIZE(pm2xxx_charger_current_map) - 1; 535 if (curr == pm2xxx_charger_current_map[i]) 536 return i; 537 else 538 return -EINVAL; 539} 540 541static int pm2xxx_voltage_to_regval(int curr) 542{ 543 int i; 544 545 if (curr < pm2xxx_charger_voltage_map[0]) 546 return 0; 547 548 for (i = 1; i < ARRAY_SIZE(pm2xxx_charger_voltage_map); i++) { 549 if (curr < pm2xxx_charger_voltage_map[i]) 550 return i - 1; 551 } 552 553 i = ARRAY_SIZE(pm2xxx_charger_voltage_map) - 1; 554 if (curr == pm2xxx_charger_voltage_map[i]) 555 return i; 556 else 557 return -EINVAL; 558} 559 560static int pm2xxx_charger_update_charger_current(struct ux500_charger *charger, 561 int ich_out) 562{ 563 int ret; 564 int curr_index; 565 struct pm2xxx_charger *pm2; 566 u8 val; 567 568 if (charger->psy->desc->type == POWER_SUPPLY_TYPE_MAINS) 569 pm2 = to_pm2xxx_charger_ac_device_info(charger); 570 else 571 return -ENXIO; 572 573 curr_index = pm2xxx_current_to_regval(ich_out); 574 if (curr_index < 0) { 575 dev_err(pm2->dev, 576 "Charger current too high, charging not started\n"); 577 return -ENXIO; 578 } 579 580 ret = pm2xxx_reg_read(pm2, PM2XXX_BATT_CTRL_REG6, &val); 581 if (ret >= 0) { 582 val &= ~PM2XXX_DIR_CH_CC_CURRENT_MASK; 583 val |= curr_index; 584 ret = pm2xxx_reg_write(pm2, PM2XXX_BATT_CTRL_REG6, val); 585 if (ret < 0) { 586 dev_err(pm2->dev, 587 "%s write failed\n", __func__); 588 } 589 } 590 else 591 dev_err(pm2->dev, "%s read failed\n", __func__); 592 593 return ret; 594} 595 596static int pm2xxx_charger_ac_get_property(struct power_supply *psy, 597 enum power_supply_property psp, 598 union power_supply_propval *val) 599{ 600 struct pm2xxx_charger *pm2; 601 602 pm2 = to_pm2xxx_charger_ac_device_info(psy_to_ux500_charger(psy)); 603 604 switch (psp) { 605 case POWER_SUPPLY_PROP_HEALTH: 606 if (pm2->flags.mainextchnotok) 607 val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE; 608 else if (pm2->ac.wd_expired) 609 val->intval = POWER_SUPPLY_HEALTH_DEAD; 610 else if (pm2->flags.main_thermal_prot) 611 val->intval = POWER_SUPPLY_HEALTH_OVERHEAT; 612 else if (pm2->flags.ovv) 613 val->intval = POWER_SUPPLY_HEALTH_OVERVOLTAGE; 614 else 615 val->intval = POWER_SUPPLY_HEALTH_GOOD; 616 break; 617 case POWER_SUPPLY_PROP_ONLINE: 618 val->intval = pm2->ac.charger_online; 619 break; 620 case POWER_SUPPLY_PROP_PRESENT: 621 val->intval = pm2->ac.charger_connected; 622 break; 623 case POWER_SUPPLY_PROP_VOLTAGE_AVG: 624 pm2->ac.cv_active = pm2xxx_charger_get_ac_cv(pm2); 625 val->intval = pm2->ac.cv_active; 626 break; 627 default: 628 return -EINVAL; 629 } 630 return 0; 631} 632 633static int pm2xxx_charging_init(struct pm2xxx_charger *pm2) 634{ 635 int ret = 0; 636 637 /* enable CC and CV watchdog */ 638 ret = pm2xxx_reg_write(pm2, PM2XXX_BATT_CTRL_REG3, 639 (PM2XXX_CH_WD_CV_PHASE_60MIN | PM2XXX_CH_WD_CC_PHASE_60MIN)); 640 if( ret < 0) 641 return ret; 642 643 /* enable precharge watchdog */ 644 ret = pm2xxx_reg_write(pm2, PM2XXX_BATT_CTRL_REG4, 645 PM2XXX_CH_WD_PRECH_PHASE_60MIN); 646 647 /* Disable auto timeout */ 648 ret = pm2xxx_reg_write(pm2, PM2XXX_BATT_CTRL_REG5, 649 PM2XXX_CH_WD_AUTO_TIMEOUT_20MIN); 650 651 /* 652 * EOC current level = 100mA 653 * Precharge current level = 100mA 654 * CC current level = 1000mA 655 */ 656 ret = pm2xxx_reg_write(pm2, PM2XXX_BATT_CTRL_REG6, 657 (PM2XXX_DIR_CH_CC_CURRENT_1000MA | 658 PM2XXX_CH_PRECH_CURRENT_100MA | 659 PM2XXX_CH_EOC_CURRENT_100MA)); 660 661 /* 662 * recharge threshold = 3.8V 663 * Precharge to CC threshold = 2.9V 664 */ 665 ret = pm2xxx_reg_write(pm2, PM2XXX_BATT_CTRL_REG7, 666 (PM2XXX_CH_PRECH_VOL_2_9 | PM2XXX_CH_VRESUME_VOL_3_8)); 667 668 /* float voltage charger level = 4.2V */ 669 ret = pm2xxx_reg_write(pm2, PM2XXX_BATT_CTRL_REG8, 670 PM2XXX_CH_VOLT_4_2); 671 672 /* Voltage drop between VBAT and VSYS in HW charging = 300mV */ 673 ret = pm2xxx_reg_write(pm2, PM2XXX_BATT_CTRL_REG9, 674 (PM2XXX_CH_150MV_DROP_300MV | PM2XXX_CHARCHING_INFO_DIS | 675 PM2XXX_CH_CC_REDUCED_CURRENT_IDENT | 676 PM2XXX_CH_CC_MODEDROP_DIS)); 677 678 /* Input charger level of over voltage = 10V */ 679 ret = pm2xxx_reg_write(pm2, PM2XXX_INP_VOLT_VPWR2, 680 PM2XXX_VPWR2_OVV_10); 681 ret = pm2xxx_reg_write(pm2, PM2XXX_INP_VOLT_VPWR1, 682 PM2XXX_VPWR1_OVV_10); 683 684 /* Input charger drop */ 685 ret = pm2xxx_reg_write(pm2, PM2XXX_INP_DROP_VPWR2, 686 (PM2XXX_VPWR2_HW_OPT_DIS | PM2XXX_VPWR2_VALID_DIS | 687 PM2XXX_VPWR2_DROP_DIS)); 688 ret = pm2xxx_reg_write(pm2, PM2XXX_INP_DROP_VPWR1, 689 (PM2XXX_VPWR1_HW_OPT_DIS | PM2XXX_VPWR1_VALID_DIS | 690 PM2XXX_VPWR1_DROP_DIS)); 691 692 /* Disable battery low monitoring */ 693 ret = pm2xxx_reg_write(pm2, PM2XXX_BATT_LOW_LEV_COMP_REG, 694 PM2XXX_VBAT_LOW_MONITORING_ENA); 695 696 return ret; 697} 698 699static int pm2xxx_charger_ac_en(struct ux500_charger *charger, 700 int enable, int vset, int iset) 701{ 702 int ret; 703 int volt_index; 704 int curr_index; 705 u8 val; 706 707 struct pm2xxx_charger *pm2 = to_pm2xxx_charger_ac_device_info(charger); 708 709 if (enable) { 710 if (!pm2->ac.charger_connected) { 711 dev_dbg(pm2->dev, "AC charger not connected\n"); 712 return -ENXIO; 713 } 714 715 dev_dbg(pm2->dev, "Enable AC: %dmV %dmA\n", vset, iset); 716 if (!pm2->vddadc_en_ac) { 717 ret = regulator_enable(pm2->regu); 718 if (ret) 719 dev_warn(pm2->dev, 720 "Failed to enable vddadc regulator\n"); 721 else 722 pm2->vddadc_en_ac = true; 723 } 724 725 ret = pm2xxx_charging_init(pm2); 726 if (ret < 0) { 727 dev_err(pm2->dev, "%s charging init failed\n", 728 __func__); 729 goto error_occured; 730 } 731 732 volt_index = pm2xxx_voltage_to_regval(vset); 733 curr_index = pm2xxx_current_to_regval(iset); 734 735 if (volt_index < 0 || curr_index < 0) { 736 dev_err(pm2->dev, 737 "Charger voltage or current too high, " 738 "charging not started\n"); 739 return -ENXIO; 740 } 741 742 ret = pm2xxx_reg_read(pm2, PM2XXX_BATT_CTRL_REG8, &val); 743 if (ret < 0) { 744 dev_err(pm2->dev, "%s pm2xxx read failed\n", __func__); 745 goto error_occured; 746 } 747 val &= ~PM2XXX_CH_VOLT_MASK; 748 val |= volt_index; 749 ret = pm2xxx_reg_write(pm2, PM2XXX_BATT_CTRL_REG8, val); 750 if (ret < 0) { 751 dev_err(pm2->dev, "%s pm2xxx write failed\n", __func__); 752 goto error_occured; 753 } 754 755 ret = pm2xxx_reg_read(pm2, PM2XXX_BATT_CTRL_REG6, &val); 756 if (ret < 0) { 757 dev_err(pm2->dev, "%s pm2xxx read failed\n", __func__); 758 goto error_occured; 759 } 760 val &= ~PM2XXX_DIR_CH_CC_CURRENT_MASK; 761 val |= curr_index; 762 ret = pm2xxx_reg_write(pm2, PM2XXX_BATT_CTRL_REG6, val); 763 if (ret < 0) { 764 dev_err(pm2->dev, "%s pm2xxx write failed\n", __func__); 765 goto error_occured; 766 } 767 768 if (!pm2->bat->enable_overshoot) { 769 ret = pm2xxx_reg_read(pm2, PM2XXX_LED_CTRL_REG, &val); 770 if (ret < 0) { 771 dev_err(pm2->dev, "%s pm2xxx read failed\n", 772 __func__); 773 goto error_occured; 774 } 775 val |= PM2XXX_ANTI_OVERSHOOT_EN; 776 ret = pm2xxx_reg_write(pm2, PM2XXX_LED_CTRL_REG, val); 777 if (ret < 0) { 778 dev_err(pm2->dev, "%s pm2xxx write failed\n", 779 __func__); 780 goto error_occured; 781 } 782 } 783 784 ret = pm2xxx_charging_enable_mngt(pm2); 785 if (ret < 0) { 786 dev_err(pm2->dev, "Failed to enable" 787 "pm2xxx ac charger\n"); 788 goto error_occured; 789 } 790 791 pm2->ac.charger_online = 1; 792 } else { 793 pm2->ac.charger_online = 0; 794 pm2->ac.wd_expired = false; 795 796 /* Disable regulator if enabled */ 797 if (pm2->vddadc_en_ac) { 798 regulator_disable(pm2->regu); 799 pm2->vddadc_en_ac = false; 800 } 801 802 ret = pm2xxx_charging_disable_mngt(pm2); 803 if (ret < 0) { 804 dev_err(pm2->dev, "failed to disable" 805 "pm2xxx ac charger\n"); 806 goto error_occured; 807 } 808 809 dev_dbg(pm2->dev, "PM2301: " "Disabled AC charging\n"); 810 } 811 power_supply_changed(pm2->ac_chg.psy); 812 813error_occured: 814 return ret; 815} 816 817static int pm2xxx_charger_watchdog_kick(struct ux500_charger *charger) 818{ 819 int ret; 820 struct pm2xxx_charger *pm2; 821 822 if (charger->psy->desc->type == POWER_SUPPLY_TYPE_MAINS) 823 pm2 = to_pm2xxx_charger_ac_device_info(charger); 824 else 825 return -ENXIO; 826 827 ret = pm2xxx_reg_write(pm2, PM2XXX_BATT_WD_KICK, WD_TIMER); 828 if (ret) 829 dev_err(pm2->dev, "Failed to kick WD!\n"); 830 831 return ret; 832} 833 834static void pm2xxx_charger_ac_work(struct work_struct *work) 835{ 836 struct pm2xxx_charger *pm2 = container_of(work, 837 struct pm2xxx_charger, ac_work); 838 839 840 power_supply_changed(pm2->ac_chg.psy); 841 sysfs_notify(&pm2->ac_chg.psy->dev.kobj, NULL, "present"); 842}; 843 844static void pm2xxx_charger_check_hw_failure_work(struct work_struct *work) 845{ 846 u8 reg_value; 847 848 struct pm2xxx_charger *pm2 = container_of(work, 849 struct pm2xxx_charger, check_hw_failure_work.work); 850 851 if (pm2->flags.ovv) { 852 pm2xxx_reg_read(pm2, PM2XXX_SRCE_REG_INT4, ®_value); 853 854 if (!(reg_value & (PM2XXX_INT4_S_ITVPWR1OVV | 855 PM2XXX_INT4_S_ITVPWR2OVV))) { 856 pm2->flags.ovv = false; 857 power_supply_changed(pm2->ac_chg.psy); 858 } 859 } 860 861 /* If we still have a failure, schedule a new check */ 862 if (pm2->flags.ovv) { 863 queue_delayed_work(pm2->charger_wq, 864 &pm2->check_hw_failure_work, round_jiffies(HZ)); 865 } 866} 867 868static void pm2xxx_charger_check_main_thermal_prot_work( 869 struct work_struct *work) 870{ 871 int ret; 872 u8 val; 873 874 struct pm2xxx_charger *pm2 = container_of(work, struct pm2xxx_charger, 875 check_main_thermal_prot_work); 876 877 /* Check if die temp warning is still active */ 878 ret = pm2xxx_reg_read(pm2, PM2XXX_SRCE_REG_INT5, &val); 879 if (ret < 0) { 880 dev_err(pm2->dev, "%s pm2xxx read failed\n", __func__); 881 return; 882 } 883 if (val & (PM2XXX_INT5_S_ITTHERMALWARNINGRISE 884 | PM2XXX_INT5_S_ITTHERMALSHUTDOWNRISE)) 885 pm2->flags.main_thermal_prot = true; 886 else if (val & (PM2XXX_INT5_S_ITTHERMALWARNINGFALL 887 | PM2XXX_INT5_S_ITTHERMALSHUTDOWNFALL)) 888 pm2->flags.main_thermal_prot = false; 889 890 power_supply_changed(pm2->ac_chg.psy); 891} 892 893static struct pm2xxx_interrupts pm2xxx_int = { 894 .handler[0] = pm2_int_reg0, 895 .handler[1] = pm2_int_reg1, 896 .handler[2] = pm2_int_reg2, 897 .handler[3] = pm2_int_reg3, 898 .handler[4] = pm2_int_reg4, 899 .handler[5] = pm2_int_reg5, 900}; 901 902static struct pm2xxx_irq pm2xxx_charger_irq[] = { 903 {"PM2XXX_IRQ_INT", pm2xxx_irq_int}, 904}; 905 906static int __maybe_unused pm2xxx_wall_charger_resume(struct device *dev) 907{ 908 struct i2c_client *i2c_client = to_i2c_client(dev); 909 struct pm2xxx_charger *pm2; 910 911 pm2 = (struct pm2xxx_charger *)i2c_get_clientdata(i2c_client); 912 set_lpn_pin(pm2); 913 914 /* If we still have a HW failure, schedule a new check */ 915 if (pm2->flags.ovv) 916 queue_delayed_work(pm2->charger_wq, 917 &pm2->check_hw_failure_work, 0); 918 919 return 0; 920} 921 922static int __maybe_unused pm2xxx_wall_charger_suspend(struct device *dev) 923{ 924 struct i2c_client *i2c_client = to_i2c_client(dev); 925 struct pm2xxx_charger *pm2; 926 927 pm2 = (struct pm2xxx_charger *)i2c_get_clientdata(i2c_client); 928 clear_lpn_pin(pm2); 929 930 /* Cancel any pending HW failure check */ 931 if (delayed_work_pending(&pm2->check_hw_failure_work)) 932 cancel_delayed_work(&pm2->check_hw_failure_work); 933 934 flush_work(&pm2->ac_work); 935 flush_work(&pm2->check_main_thermal_prot_work); 936 937 return 0; 938} 939 940static int __maybe_unused pm2xxx_runtime_suspend(struct device *dev) 941{ 942 struct i2c_client *pm2xxx_i2c_client = to_i2c_client(dev); 943 struct pm2xxx_charger *pm2; 944 945 pm2 = (struct pm2xxx_charger *)i2c_get_clientdata(pm2xxx_i2c_client); 946 clear_lpn_pin(pm2); 947 948 return 0; 949} 950 951static int __maybe_unused pm2xxx_runtime_resume(struct device *dev) 952{ 953 struct i2c_client *pm2xxx_i2c_client = to_i2c_client(dev); 954 struct pm2xxx_charger *pm2; 955 956 pm2 = (struct pm2xxx_charger *)i2c_get_clientdata(pm2xxx_i2c_client); 957 958 if (gpio_is_valid(pm2->lpn_pin) && gpio_get_value(pm2->lpn_pin) == 0) 959 set_lpn_pin(pm2); 960 961 return 0; 962} 963 964static const struct dev_pm_ops pm2xxx_pm_ops __maybe_unused = { 965 SET_SYSTEM_SLEEP_PM_OPS(pm2xxx_wall_charger_suspend, 966 pm2xxx_wall_charger_resume) 967 SET_RUNTIME_PM_OPS(pm2xxx_runtime_suspend, pm2xxx_runtime_resume, NULL) 968}; 969 970static int pm2xxx_wall_charger_probe(struct i2c_client *i2c_client, 971 const struct i2c_device_id *id) 972{ 973 struct pm2xxx_platform_data *pl_data = i2c_client->dev.platform_data; 974 struct power_supply_config psy_cfg = {}; 975 struct pm2xxx_charger *pm2; 976 int ret = 0; 977 u8 val; 978 int i; 979 980 if (!pl_data) { 981 dev_err(&i2c_client->dev, "No platform data supplied\n"); 982 return -EINVAL; 983 } 984 985 pm2 = kzalloc(sizeof(struct pm2xxx_charger), GFP_KERNEL); 986 if (!pm2) { 987 dev_err(&i2c_client->dev, "pm2xxx_charger allocation failed\n"); 988 return -ENOMEM; 989 } 990 991 /* get parent data */ 992 pm2->dev = &i2c_client->dev; 993 994 pm2->pm2_int = &pm2xxx_int; 995 996 /* get charger spcific platform data */ 997 if (!pl_data->wall_charger) { 998 dev_err(pm2->dev, "no charger platform data supplied\n"); 999 ret = -EINVAL; 1000 goto free_device_info; 1001 } 1002 1003 pm2->pdata = pl_data->wall_charger; 1004 1005 /* get battery specific platform data */ 1006 if (!pl_data->battery) { 1007 dev_err(pm2->dev, "no battery platform data supplied\n"); 1008 ret = -EINVAL; 1009 goto free_device_info; 1010 } 1011 1012 pm2->bat = pl_data->battery; 1013 1014 if (!i2c_check_functionality(i2c_client->adapter, 1015 I2C_FUNC_SMBUS_BYTE_DATA | 1016 I2C_FUNC_SMBUS_READ_WORD_DATA)) { 1017 ret = -ENODEV; 1018 dev_info(pm2->dev, "pm2301 i2c_check_functionality failed\n"); 1019 goto free_device_info; 1020 } 1021 1022 pm2->config.pm2xxx_i2c = i2c_client; 1023 pm2->config.pm2xxx_id = (struct i2c_device_id *) id; 1024 i2c_set_clientdata(i2c_client, pm2); 1025 1026 /* AC supply */ 1027 /* power_supply base class */ 1028 pm2->ac_chg_desc.name = pm2->pdata->label; 1029 pm2->ac_chg_desc.type = POWER_SUPPLY_TYPE_MAINS; 1030 pm2->ac_chg_desc.properties = pm2xxx_charger_ac_props; 1031 pm2->ac_chg_desc.num_properties = ARRAY_SIZE(pm2xxx_charger_ac_props); 1032 pm2->ac_chg_desc.get_property = pm2xxx_charger_ac_get_property; 1033 1034 psy_cfg.supplied_to = pm2->pdata->supplied_to; 1035 psy_cfg.num_supplicants = pm2->pdata->num_supplicants; 1036 /* pm2xxx_charger sub-class */ 1037 pm2->ac_chg.ops.enable = &pm2xxx_charger_ac_en; 1038 pm2->ac_chg.ops.kick_wd = &pm2xxx_charger_watchdog_kick; 1039 pm2->ac_chg.ops.update_curr = &pm2xxx_charger_update_charger_current; 1040 pm2->ac_chg.max_out_volt = pm2xxx_charger_voltage_map[ 1041 ARRAY_SIZE(pm2xxx_charger_voltage_map) - 1]; 1042 pm2->ac_chg.max_out_curr = pm2xxx_charger_current_map[ 1043 ARRAY_SIZE(pm2xxx_charger_current_map) - 1]; 1044 pm2->ac_chg.wdt_refresh = WD_KICK_INTERVAL; 1045 pm2->ac_chg.enabled = true; 1046 pm2->ac_chg.external = true; 1047 1048 /* Create a work queue for the charger */ 1049 pm2->charger_wq = alloc_ordered_workqueue("pm2xxx_charger_wq", 1050 WQ_MEM_RECLAIM); 1051 if (pm2->charger_wq == NULL) { 1052 ret = -ENOMEM; 1053 dev_err(pm2->dev, "failed to create work queue\n"); 1054 goto free_device_info; 1055 } 1056 1057 /* Init work for charger detection */ 1058 INIT_WORK(&pm2->ac_work, pm2xxx_charger_ac_work); 1059 1060 /* Init work for checking HW status */ 1061 INIT_WORK(&pm2->check_main_thermal_prot_work, 1062 pm2xxx_charger_check_main_thermal_prot_work); 1063 1064 /* Init work for HW failure check */ 1065 INIT_DEFERRABLE_WORK(&pm2->check_hw_failure_work, 1066 pm2xxx_charger_check_hw_failure_work); 1067 1068 /* 1069 * VDD ADC supply needs to be enabled from this driver when there 1070 * is a charger connected to avoid erroneous BTEMP_HIGH/LOW 1071 * interrupts during charging 1072 */ 1073 pm2->regu = regulator_get(pm2->dev, "vddadc"); 1074 if (IS_ERR(pm2->regu)) { 1075 ret = PTR_ERR(pm2->regu); 1076 dev_err(pm2->dev, "failed to get vddadc regulator\n"); 1077 goto free_charger_wq; 1078 } 1079 1080 /* Register AC charger class */ 1081 pm2->ac_chg.psy = power_supply_register(pm2->dev, &pm2->ac_chg_desc, 1082 &psy_cfg); 1083 if (IS_ERR(pm2->ac_chg.psy)) { 1084 dev_err(pm2->dev, "failed to register AC charger\n"); 1085 ret = PTR_ERR(pm2->ac_chg.psy); 1086 goto free_regulator; 1087 } 1088 1089 /* Register interrupts */ 1090 ret = request_threaded_irq(gpio_to_irq(pm2->pdata->gpio_irq_number), 1091 NULL, 1092 pm2xxx_charger_irq[0].isr, 1093 pm2->pdata->irq_type | IRQF_ONESHOT, 1094 pm2xxx_charger_irq[0].name, pm2); 1095 1096 if (ret != 0) { 1097 dev_err(pm2->dev, "failed to request %s IRQ %d: %d\n", 1098 pm2xxx_charger_irq[0].name, 1099 gpio_to_irq(pm2->pdata->gpio_irq_number), ret); 1100 goto unregister_pm2xxx_charger; 1101 } 1102 1103 ret = pm_runtime_set_active(pm2->dev); 1104 if (ret) 1105 dev_err(pm2->dev, "set active Error\n"); 1106 1107 pm_runtime_enable(pm2->dev); 1108 pm_runtime_set_autosuspend_delay(pm2->dev, PM2XXX_AUTOSUSPEND_DELAY); 1109 pm_runtime_use_autosuspend(pm2->dev); 1110 pm_runtime_resume(pm2->dev); 1111 1112 /* pm interrupt can wake up system */ 1113 ret = enable_irq_wake(gpio_to_irq(pm2->pdata->gpio_irq_number)); 1114 if (ret) { 1115 dev_err(pm2->dev, "failed to set irq wake\n"); 1116 goto unregister_pm2xxx_interrupt; 1117 } 1118 1119 mutex_init(&pm2->lock); 1120 1121 if (gpio_is_valid(pm2->pdata->lpn_gpio)) { 1122 /* get lpn GPIO from platform data */ 1123 pm2->lpn_pin = pm2->pdata->lpn_gpio; 1124 1125 /* 1126 * Charger detection mechanism requires pulling up the LPN pin 1127 * while i2c communication if Charger is not connected 1128 * LPN pin of PM2301 is GPIO60 of AB9540 1129 */ 1130 ret = gpio_request(pm2->lpn_pin, "pm2301_lpm_gpio"); 1131 1132 if (ret < 0) { 1133 dev_err(pm2->dev, "pm2301_lpm_gpio request failed\n"); 1134 goto disable_pm2_irq_wake; 1135 } 1136 ret = gpio_direction_output(pm2->lpn_pin, 0); 1137 if (ret < 0) { 1138 dev_err(pm2->dev, "pm2301_lpm_gpio direction failed\n"); 1139 goto free_gpio; 1140 } 1141 set_lpn_pin(pm2); 1142 } 1143 1144 /* read interrupt registers */ 1145 for (i = 0; i < PM2XXX_NUM_INT_REG; i++) 1146 pm2xxx_reg_read(pm2, 1147 pm2xxx_interrupt_registers[i], 1148 &val); 1149 1150 ret = pm2xxx_charger_detection(pm2, &val); 1151 1152 if ((ret == 0) && val) { 1153 pm2->ac.charger_connected = 1; 1154 ab8500_override_turn_on_stat(~AB8500_POW_KEY_1_ON, 1155 AB8500_MAIN_CH_DET); 1156 pm2->ac_conn = true; 1157 power_supply_changed(pm2->ac_chg.psy); 1158 sysfs_notify(&pm2->ac_chg.psy->dev.kobj, NULL, "present"); 1159 } 1160 1161 return 0; 1162 1163free_gpio: 1164 if (gpio_is_valid(pm2->lpn_pin)) 1165 gpio_free(pm2->lpn_pin); 1166disable_pm2_irq_wake: 1167 disable_irq_wake(gpio_to_irq(pm2->pdata->gpio_irq_number)); 1168unregister_pm2xxx_interrupt: 1169 /* disable interrupt */ 1170 free_irq(gpio_to_irq(pm2->pdata->gpio_irq_number), pm2); 1171unregister_pm2xxx_charger: 1172 /* unregister power supply */ 1173 power_supply_unregister(pm2->ac_chg.psy); 1174free_regulator: 1175 /* disable the regulator */ 1176 regulator_put(pm2->regu); 1177free_charger_wq: 1178 destroy_workqueue(pm2->charger_wq); 1179free_device_info: 1180 kfree(pm2); 1181 1182 return ret; 1183} 1184 1185static int pm2xxx_wall_charger_remove(struct i2c_client *i2c_client) 1186{ 1187 struct pm2xxx_charger *pm2 = i2c_get_clientdata(i2c_client); 1188 1189 /* Disable pm_runtime */ 1190 pm_runtime_disable(pm2->dev); 1191 /* Disable AC charging */ 1192 pm2xxx_charger_ac_en(&pm2->ac_chg, false, 0, 0); 1193 1194 /* Disable wake by pm interrupt */ 1195 disable_irq_wake(gpio_to_irq(pm2->pdata->gpio_irq_number)); 1196 1197 /* Disable interrupts */ 1198 free_irq(gpio_to_irq(pm2->pdata->gpio_irq_number), pm2); 1199 1200 /* Delete the work queue */ 1201 destroy_workqueue(pm2->charger_wq); 1202 1203 flush_scheduled_work(); 1204 1205 /* disable the regulator */ 1206 regulator_put(pm2->regu); 1207 1208 power_supply_unregister(pm2->ac_chg.psy); 1209 1210 if (gpio_is_valid(pm2->lpn_pin)) 1211 gpio_free(pm2->lpn_pin); 1212 1213 kfree(pm2); 1214 1215 return 0; 1216} 1217 1218static const struct i2c_device_id pm2xxx_id[] = { 1219 { "pm2301", 0 }, 1220 { } 1221}; 1222 1223MODULE_DEVICE_TABLE(i2c, pm2xxx_id); 1224 1225static struct i2c_driver pm2xxx_charger_driver = { 1226 .probe = pm2xxx_wall_charger_probe, 1227 .remove = pm2xxx_wall_charger_remove, 1228 .driver = { 1229 .name = "pm2xxx-wall_charger", 1230 .pm = IS_ENABLED(CONFIG_PM) ? &pm2xxx_pm_ops : NULL, 1231 }, 1232 .id_table = pm2xxx_id, 1233}; 1234 1235static int __init pm2xxx_charger_init(void) 1236{ 1237 return i2c_add_driver(&pm2xxx_charger_driver); 1238} 1239 1240static void __exit pm2xxx_charger_exit(void) 1241{ 1242 i2c_del_driver(&pm2xxx_charger_driver); 1243} 1244 1245device_initcall_sync(pm2xxx_charger_init); 1246module_exit(pm2xxx_charger_exit); 1247 1248MODULE_LICENSE("GPL v2"); 1249MODULE_AUTHOR("Rajkumar kasirajan, Olivier Launay"); 1250MODULE_DESCRIPTION("PM2xxx charger management driver"); 1251