drivers/power/supply/pm2301_charger.c

   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
  36 static 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
  45 static 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
  52 static 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
  88 static 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
 107 static 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
 115 static 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
 121 static 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
 140 static 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
 159 static 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
 170 static 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
 192 static 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
 200 static 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
 207 static 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
 219 static 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
 229 static 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
 263 static 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
 270 static 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
 283 out:
 284         return ret;
 285 }
 286
 287 static 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
 310 static 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
 319 static 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         }
 344 out:
 345         return ret;
 346 }
 347
 348 static 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
 370 static 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
 387 static 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
 428 static 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
 455 static 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
 474 static 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
 500 static 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         }
 518 out:
 519         return ret;
 520 }
 521
 522 static 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
 541 static 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
 560 static 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
 596 static 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
 633 static 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
 699 static 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
 813 error_occured:
 814         return ret;
 815 }
 816
 817 static 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
 834 static 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
 844 static 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, &reg_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
 868 static 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
 893 static 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
 902 static struct pm2xxx_irq pm2xxx_charger_irq[] = {
 903         {"PM2XXX_IRQ_INT", pm2xxx_irq_int},
 904 };
 905
 906 static 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
 922 static 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
 940 static 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
 951 static 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
 964 static 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
 970 static 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
1163 free_gpio:
1164         if (gpio_is_valid(pm2->lpn_pin))
1165                 gpio_free(pm2->lpn_pin);
1166 disable_pm2_irq_wake:
1167         disable_irq_wake(gpio_to_irq(pm2->pdata->gpio_irq_number));
1168 unregister_pm2xxx_interrupt:
1169         /* disable interrupt */
1170         free_irq(gpio_to_irq(pm2->pdata->gpio_irq_number), pm2);
1171 unregister_pm2xxx_charger:
1172         /* unregister power supply */
1173         power_supply_unregister(pm2->ac_chg.psy);
1174 free_regulator:
1175         /* disable the regulator */
1176         regulator_put(pm2->regu);
1177 free_charger_wq:
1178         destroy_workqueue(pm2->charger_wq);
1179 free_device_info:
1180         kfree(pm2);
1181
1182         return ret;
1183 }
1184
1185 static 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
1218 static const struct i2c_device_id pm2xxx_id[] = {
1219         { "pm2301", 0 },
1220         { }
1221 };
1222
1223 MODULE_DEVICE_TABLE(i2c, pm2xxx_id);
1224
1225 static 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
1235 static int __init pm2xxx_charger_init(void)
1236 {
1237         return i2c_add_driver(&pm2xxx_charger_driver);
1238 }
1239
1240 static void __exit pm2xxx_charger_exit(void)
1241 {
1242         i2c_del_driver(&pm2xxx_charger_driver);
1243 }
1244
1245 device_initcall_sync(pm2xxx_charger_init);
1246 module_exit(pm2xxx_charger_exit);
1247
1248 MODULE_LICENSE("GPL v2");
1249 MODULE_AUTHOR("Rajkumar kasirajan, Olivier Launay");
1250 MODULE_DESCRIPTION("PM2xxx charger management driver");