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