drivers/power/pm2301_charger.c

   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
  39 static 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
  48 static 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
  55 static 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
  91 static 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
 110 static const struct i2c_device_id pm2xxx_ident[] = {
 111         { "pm2301", 0 },
 112         { }
 113 };
 114
 115 static 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
 123 static 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
 129 static 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
 148 static 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
 167 static 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
 178 static 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
 200 static 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
 208 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
 215 static 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
 227 static 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
 237 static 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
 271 static 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
 278 static 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
 291 out:
 292         return ret;
 293 }
 294
 295 static 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
 318 static 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
 327 static 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         }
 352 out:
 353         return ret;
 354 }
 355
 356 static 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
 378 static 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 occured for precharge, CC and CV charge\n");
 390         }
 391
 392         return ret;
 393 }
 394
 395 static 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
 436 static 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
 463 static 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
 482 static 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
 508 static 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         }
 526 out:
 527         return ret;
 528 }
 529
 530 static 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
 549 static 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
 568 static 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.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
 604 static 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
 641 static 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
 707 static 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                         regulator_enable(pm2->regu);
 726                         pm2->vddadc_en_ac = true;
 727                 }
 728
 729                 ret = pm2xxx_charging_init(pm2);
 730                 if (ret < 0) {
 731                         dev_err(pm2->dev, "%s charging init failed\n",
 732                                         __func__);
 733                         goto error_occured;
 734                 }
 735
 736                 volt_index = pm2xxx_voltage_to_regval(vset);
 737                 curr_index = pm2xxx_current_to_regval(iset);
 738
 739                 if (volt_index < 0 || curr_index < 0) {
 740                         dev_err(pm2->dev,
 741                                 "Charger voltage or current too high, "
 742                                 "charging not started\n");
 743                         return -ENXIO;
 744                 }
 745
 746                 ret = pm2xxx_reg_read(pm2, PM2XXX_BATT_CTRL_REG8, &val);
 747                 if (ret < 0) {
 748                         dev_err(pm2->dev, "%s pm2xxx read failed\n", __func__);
 749                         goto error_occured;
 750                 }
 751                 val &= ~PM2XXX_CH_VOLT_MASK;
 752                 val |= volt_index;
 753                 ret = pm2xxx_reg_write(pm2, PM2XXX_BATT_CTRL_REG8, val);
 754                 if (ret < 0) {
 755                         dev_err(pm2->dev, "%s pm2xxx write failed\n", __func__);
 756                         goto error_occured;
 757                 }
 758
 759                 ret = pm2xxx_reg_read(pm2, PM2XXX_BATT_CTRL_REG6, &val);
 760                 if (ret < 0) {
 761                         dev_err(pm2->dev, "%s pm2xxx read failed\n", __func__);
 762                         goto error_occured;
 763                 }
 764                 val &= ~PM2XXX_DIR_CH_CC_CURRENT_MASK;
 765                 val |= curr_index;
 766                 ret = pm2xxx_reg_write(pm2, PM2XXX_BATT_CTRL_REG6, val);
 767                 if (ret < 0) {
 768                         dev_err(pm2->dev, "%s pm2xxx write failed\n", __func__);
 769                         goto error_occured;
 770                 }
 771
 772                 if (!pm2->bat->enable_overshoot) {
 773                         ret = pm2xxx_reg_read(pm2, PM2XXX_LED_CTRL_REG, &val);
 774                         if (ret < 0) {
 775                                 dev_err(pm2->dev, "%s pm2xxx read failed\n",
 776                                                                 __func__);
 777                                 goto error_occured;
 778                         }
 779                         val |= PM2XXX_ANTI_OVERSHOOT_EN;
 780                         ret = pm2xxx_reg_write(pm2, PM2XXX_LED_CTRL_REG, val);
 781                         if (ret < 0) {
 782                                 dev_err(pm2->dev, "%s pm2xxx write failed\n",
 783                                                                 __func__);
 784                                 goto error_occured;
 785                         }
 786                 }
 787
 788                 ret = pm2xxx_charging_enable_mngt(pm2);
 789                 if (ret < 0) {
 790                         dev_err(pm2->dev, "Failed to enable"
 791                                                 "pm2xxx ac charger\n");
 792                         goto error_occured;
 793                 }
 794
 795                 pm2->ac.charger_online = 1;
 796         } else {
 797                 pm2->ac.charger_online = 0;
 798                 pm2->ac.wd_expired = false;
 799
 800                 /* Disable regulator if enabled */
 801                 if (pm2->vddadc_en_ac) {
 802                         regulator_disable(pm2->regu);
 803                         pm2->vddadc_en_ac = false;
 804                 }
 805
 806                 ret = pm2xxx_charging_disable_mngt(pm2);
 807                 if (ret < 0) {
 808                         dev_err(pm2->dev, "failed to disable"
 809                                                 "pm2xxx ac charger\n");
 810                         goto error_occured;
 811                 }
 812
 813                 dev_dbg(pm2->dev, "PM2301: " "Disabled AC charging\n");
 814         }
 815         power_supply_changed(&pm2->ac_chg.psy);
 816
 817 error_occured:
 818         return ret;
 819 }
 820
 821 static int pm2xxx_charger_watchdog_kick(struct ux500_charger *charger)
 822 {
 823         int ret;
 824         struct pm2xxx_charger *pm2;
 825
 826         if (charger->psy.type == POWER_SUPPLY_TYPE_MAINS)
 827                 pm2 = to_pm2xxx_charger_ac_device_info(charger);
 828         else
 829                 return -ENXIO;
 830
 831         ret = pm2xxx_reg_write(pm2, PM2XXX_BATT_WD_KICK, WD_TIMER);
 832         if (ret)
 833                 dev_err(pm2->dev, "Failed to kick WD!\n");
 834
 835         return ret;
 836 }
 837
 838 static void pm2xxx_charger_ac_work(struct work_struct *work)
 839 {
 840         struct pm2xxx_charger *pm2 = container_of(work,
 841                 struct pm2xxx_charger, ac_work);
 842
 843
 844         power_supply_changed(&pm2->ac_chg.psy);
 845         sysfs_notify(&pm2->ac_chg.psy.dev->kobj, NULL, "present");
 846 };
 847
 848 static void pm2xxx_charger_check_hw_failure_work(struct work_struct *work)
 849 {
 850         u8 reg_value;
 851
 852         struct pm2xxx_charger *pm2 = container_of(work,
 853                 struct pm2xxx_charger, check_hw_failure_work.work);
 854
 855         if (pm2->flags.ovv) {
 856                 pm2xxx_reg_read(pm2, PM2XXX_SRCE_REG_INT4, &reg_value);
 857
 858                 if (!(reg_value & (PM2XXX_INT4_S_ITVPWR1OVV |
 859                                         PM2XXX_INT4_S_ITVPWR2OVV))) {
 860                         pm2->flags.ovv = false;
 861                         power_supply_changed(&pm2->ac_chg.psy);
 862                 }
 863         }
 864
 865         /* If we still have a failure, schedule a new check */
 866         if (pm2->flags.ovv) {
 867                 queue_delayed_work(pm2->charger_wq,
 868                         &pm2->check_hw_failure_work, round_jiffies(HZ));
 869         }
 870 }
 871
 872 static void pm2xxx_charger_check_main_thermal_prot_work(
 873         struct work_struct *work)
 874 {
 875         int ret;
 876         u8 val;
 877
 878         struct pm2xxx_charger *pm2 = container_of(work, struct pm2xxx_charger,
 879                                         check_main_thermal_prot_work);
 880
 881         /* Check if die temp warning is still active */
 882         ret = pm2xxx_reg_read(pm2, PM2XXX_SRCE_REG_INT5, &val);
 883         if (ret < 0) {
 884                 dev_err(pm2->dev, "%s pm2xxx read failed\n", __func__);
 885                 return;
 886         }
 887         if (val & (PM2XXX_INT5_S_ITTHERMALWARNINGRISE
 888                         | PM2XXX_INT5_S_ITTHERMALSHUTDOWNRISE))
 889                 pm2->flags.main_thermal_prot = true;
 890         else if (val & (PM2XXX_INT5_S_ITTHERMALWARNINGFALL
 891                                 | PM2XXX_INT5_S_ITTHERMALSHUTDOWNFALL))
 892                 pm2->flags.main_thermal_prot = false;
 893
 894         power_supply_changed(&pm2->ac_chg.psy);
 895 }
 896
 897 static struct pm2xxx_interrupts pm2xxx_int = {
 898         .handler[0] = pm2_int_reg0,
 899         .handler[1] = pm2_int_reg1,
 900         .handler[2] = pm2_int_reg2,
 901         .handler[3] = pm2_int_reg3,
 902         .handler[4] = pm2_int_reg4,
 903         .handler[5] = pm2_int_reg5,
 904 };
 905
 906 static struct pm2xxx_irq pm2xxx_charger_irq[] = {
 907         {"PM2XXX_IRQ_INT", pm2xxx_irq_int},
 908 };
 909
 910 #ifdef CONFIG_PM
 911
 912 #ifdef CONFIG_PM_SLEEP
 913
 914 static int pm2xxx_wall_charger_resume(struct device *dev)
 915 {
 916         struct i2c_client *i2c_client = to_i2c_client(dev);
 917         struct pm2xxx_charger *pm2;
 918
 919         pm2 =  (struct pm2xxx_charger *)i2c_get_clientdata(i2c_client);
 920         set_lpn_pin(pm2);
 921
 922         /* If we still have a HW failure, schedule a new check */
 923         if (pm2->flags.ovv)
 924                 queue_delayed_work(pm2->charger_wq,
 925                                 &pm2->check_hw_failure_work, 0);
 926
 927         return 0;
 928 }
 929
 930 static int pm2xxx_wall_charger_suspend(struct device *dev)
 931 {
 932         struct i2c_client *i2c_client = to_i2c_client(dev);
 933         struct pm2xxx_charger *pm2;
 934
 935         pm2 =  (struct pm2xxx_charger *)i2c_get_clientdata(i2c_client);
 936         clear_lpn_pin(pm2);
 937
 938         /* Cancel any pending HW failure check */
 939         if (delayed_work_pending(&pm2->check_hw_failure_work))
 940                 cancel_delayed_work(&pm2->check_hw_failure_work);
 941
 942         flush_work(&pm2->ac_work);
 943         flush_work(&pm2->check_main_thermal_prot_work);
 944
 945         return 0;
 946 }
 947
 948 #endif
 949
 950 #ifdef CONFIG_PM_RUNTIME
 951
 952 static int  pm2xxx_runtime_suspend(struct device *dev)
 953 {
 954         struct i2c_client *pm2xxx_i2c_client = to_i2c_client(dev);
 955         struct pm2xxx_charger *pm2;
 956         int ret = 0;
 957
 958         pm2 = (struct pm2xxx_charger *)i2c_get_clientdata(pm2xxx_i2c_client);
 959         if (!pm2) {
 960                 dev_err(pm2->dev, "no pm2xxx_charger data supplied\n");
 961                 ret = -EINVAL;
 962                 return ret;
 963         }
 964
 965         clear_lpn_pin(pm2);
 966
 967         return ret;
 968 }
 969
 970 static int  pm2xxx_runtime_resume(struct device *dev)
 971 {
 972         struct i2c_client *pm2xxx_i2c_client = to_i2c_client(dev);
 973         struct pm2xxx_charger *pm2;
 974         int ret = 0;
 975
 976         pm2 = (struct pm2xxx_charger *)i2c_get_clientdata(pm2xxx_i2c_client);
 977         if (!pm2) {
 978                 dev_err(pm2->dev, "no pm2xxx_charger data supplied\n");
 979                 ret = -EINVAL;
 980                 return ret;
 981         }
 982
 983         if (gpio_is_valid(pm2->lpn_pin) && gpio_get_value(pm2->lpn_pin) == 0)
 984                 set_lpn_pin(pm2);
 985
 986         return ret;
 987 }
 988
 989 #endif
 990
 991 static const struct dev_pm_ops pm2xxx_pm_ops = {
 992         SET_SYSTEM_SLEEP_PM_OPS(pm2xxx_wall_charger_suspend,
 993                 pm2xxx_wall_charger_resume)
 994         SET_RUNTIME_PM_OPS(pm2xxx_runtime_suspend, pm2xxx_runtime_resume, NULL)
 995 };
 996 #define  PM2XXX_PM_OPS (&pm2xxx_pm_ops)
 997 #else
 998 #define  PM2XXX_PM_OPS  NULL
 999 #endif
1000
1001 static int pm2xxx_wall_charger_probe(struct i2c_client *i2c_client,
1002                 const struct i2c_device_id *id)
1003 {
1004         struct pm2xxx_platform_data *pl_data = i2c_client->dev.platform_data;
1005         struct pm2xxx_charger *pm2;
1006         int ret = 0;
1007         u8 val;
1008         int i;
1009
1010         pm2 = kzalloc(sizeof(struct pm2xxx_charger), GFP_KERNEL);
1011         if (!pm2) {
1012                 dev_err(pm2->dev, "pm2xxx_charger allocation failed\n");
1013                 return -ENOMEM;
1014         }
1015
1016         /* get parent data */
1017         pm2->dev = &i2c_client->dev;
1018
1019         pm2->pm2_int = &pm2xxx_int;
1020
1021         /* get charger spcific platform data */
1022         if (!pl_data->wall_charger) {
1023                 dev_err(pm2->dev, "no charger platform data supplied\n");
1024                 ret = -EINVAL;
1025                 goto free_device_info;
1026         }
1027
1028         pm2->pdata = pl_data->wall_charger;
1029
1030         /* get battery specific platform data */
1031         if (!pl_data->battery) {
1032                 dev_err(pm2->dev, "no battery platform data supplied\n");
1033                 ret = -EINVAL;
1034                 goto free_device_info;
1035         }
1036
1037         pm2->bat = pl_data->battery;
1038
1039         if (!i2c_check_functionality(i2c_client->adapter,
1040                         I2C_FUNC_SMBUS_BYTE_DATA |
1041                         I2C_FUNC_SMBUS_READ_WORD_DATA)) {
1042                 ret = -ENODEV;
1043                 dev_info(pm2->dev, "pm2301 i2c_check_functionality failed\n");
1044                 goto free_device_info;
1045         }
1046
1047         pm2->config.pm2xxx_i2c = i2c_client;
1048         pm2->config.pm2xxx_id = (struct i2c_device_id *) id;
1049         i2c_set_clientdata(i2c_client, pm2);
1050
1051         /* AC supply */
1052         /* power_supply base class */
1053         pm2->ac_chg.psy.name = pm2->pdata->label;
1054         pm2->ac_chg.psy.type = POWER_SUPPLY_TYPE_MAINS;
1055         pm2->ac_chg.psy.properties = pm2xxx_charger_ac_props;
1056         pm2->ac_chg.psy.num_properties = ARRAY_SIZE(pm2xxx_charger_ac_props);
1057         pm2->ac_chg.psy.get_property = pm2xxx_charger_ac_get_property;
1058         pm2->ac_chg.psy.supplied_to = pm2->pdata->supplied_to;
1059         pm2->ac_chg.psy.num_supplicants = pm2->pdata->num_supplicants;
1060         /* pm2xxx_charger sub-class */
1061         pm2->ac_chg.ops.enable = &pm2xxx_charger_ac_en;
1062         pm2->ac_chg.ops.kick_wd = &pm2xxx_charger_watchdog_kick;
1063         pm2->ac_chg.ops.update_curr = &pm2xxx_charger_update_charger_current;
1064         pm2->ac_chg.max_out_volt = pm2xxx_charger_voltage_map[
1065                 ARRAY_SIZE(pm2xxx_charger_voltage_map) - 1];
1066         pm2->ac_chg.max_out_curr = pm2xxx_charger_current_map[
1067                 ARRAY_SIZE(pm2xxx_charger_current_map) - 1];
1068         pm2->ac_chg.wdt_refresh = WD_KICK_INTERVAL;
1069         pm2->ac_chg.enabled = true;
1070         pm2->ac_chg.external = true;
1071
1072         /* Create a work queue for the charger */
1073         pm2->charger_wq =
1074                 create_singlethread_workqueue("pm2xxx_charger_wq");
1075         if (pm2->charger_wq == NULL) {
1076                 dev_err(pm2->dev, "failed to create work queue\n");
1077                 goto free_device_info;
1078         }
1079
1080         /* Init work for charger detection */
1081         INIT_WORK(&pm2->ac_work, pm2xxx_charger_ac_work);
1082
1083         /* Init work for checking HW status */
1084         INIT_WORK(&pm2->check_main_thermal_prot_work,
1085                 pm2xxx_charger_check_main_thermal_prot_work);
1086
1087         /* Init work for HW failure check */
1088         INIT_DEFERRABLE_WORK(&pm2->check_hw_failure_work,
1089                 pm2xxx_charger_check_hw_failure_work);
1090
1091         /*
1092          * VDD ADC supply needs to be enabled from this driver when there
1093          * is a charger connected to avoid erroneous BTEMP_HIGH/LOW
1094          * interrupts during charging
1095          */
1096         pm2->regu = regulator_get(pm2->dev, "vddadc");
1097         if (IS_ERR(pm2->regu)) {
1098                 ret = PTR_ERR(pm2->regu);
1099                 dev_err(pm2->dev, "failed to get vddadc regulator\n");
1100                 goto free_charger_wq;
1101         }
1102
1103         /* Register AC charger class */
1104         ret = power_supply_register(pm2->dev, &pm2->ac_chg.psy);
1105         if (ret) {
1106                 dev_err(pm2->dev, "failed to register AC charger\n");
1107                 goto free_regulator;
1108         }
1109
1110         /* Register interrupts */
1111         ret = request_threaded_irq(gpio_to_irq(pm2->pdata->gpio_irq_number),
1112                                 NULL,
1113                                 pm2xxx_charger_irq[0].isr,
1114                                 pm2->pdata->irq_type,
1115                                 pm2xxx_charger_irq[0].name, pm2);
1116
1117         if (ret != 0) {
1118                 dev_err(pm2->dev, "failed to request %s IRQ %d: %d\n",
1119                 pm2xxx_charger_irq[0].name,
1120                         gpio_to_irq(pm2->pdata->gpio_irq_number), ret);
1121                 goto unregister_pm2xxx_charger;
1122         }
1123
1124         ret = pm_runtime_set_active(pm2->dev);
1125         if (ret)
1126                 dev_err(pm2->dev, "set active Error\n");
1127
1128         pm_runtime_enable(pm2->dev);
1129         pm_runtime_set_autosuspend_delay(pm2->dev, PM2XXX_AUTOSUSPEND_DELAY);
1130         pm_runtime_use_autosuspend(pm2->dev);
1131         pm_runtime_resume(pm2->dev);
1132
1133         /* pm interrupt can wake up system */
1134         ret = enable_irq_wake(gpio_to_irq(pm2->pdata->gpio_irq_number));
1135         if (ret) {
1136                 dev_err(pm2->dev, "failed to set irq wake\n");
1137                 goto unregister_pm2xxx_interrupt;
1138         }
1139
1140         mutex_init(&pm2->lock);
1141
1142         if (gpio_is_valid(pm2->pdata->lpn_gpio)) {
1143                 /* get lpn GPIO from platform data */
1144                 pm2->lpn_pin = pm2->pdata->lpn_gpio;
1145
1146                 /*
1147                  * Charger detection mechanism requires pulling up the LPN pin
1148                  * while i2c communication if Charger is not connected
1149                  * LPN pin of PM2301 is GPIO60 of AB9540
1150                  */
1151                 ret = gpio_request(pm2->lpn_pin, "pm2301_lpm_gpio");
1152
1153                 if (ret < 0) {
1154                         dev_err(pm2->dev, "pm2301_lpm_gpio request failed\n");
1155                         goto disable_pm2_irq_wake;
1156                 }
1157                 ret = gpio_direction_output(pm2->lpn_pin, 0);
1158                 if (ret < 0) {
1159                         dev_err(pm2->dev, "pm2301_lpm_gpio direction failed\n");
1160                         goto free_gpio;
1161                 }
1162                 set_lpn_pin(pm2);
1163         }
1164
1165         /* read  interrupt registers */
1166         for (i = 0; i < PM2XXX_NUM_INT_REG; i++)
1167                 pm2xxx_reg_read(pm2,
1168                         pm2xxx_interrupt_registers[i],
1169                         &val);
1170
1171         ret = pm2xxx_charger_detection(pm2, &val);
1172
1173         if ((ret == 0) && val) {
1174                 pm2->ac.charger_connected = 1;
1175                 ab8500_override_turn_on_stat(~AB8500_POW_KEY_1_ON,
1176                                              AB8500_MAIN_CH_DET);
1177                 pm2->ac_conn = true;
1178                 power_supply_changed(&pm2->ac_chg.psy);
1179                 sysfs_notify(&pm2->ac_chg.psy.dev->kobj, NULL, "present");
1180         }
1181
1182         return 0;
1183
1184 free_gpio:
1185         if (gpio_is_valid(pm2->lpn_pin))
1186                 gpio_free(pm2->lpn_pin);
1187 disable_pm2_irq_wake:
1188         disable_irq_wake(gpio_to_irq(pm2->pdata->gpio_irq_number));
1189 unregister_pm2xxx_interrupt:
1190         /* disable interrupt */
1191         free_irq(gpio_to_irq(pm2->pdata->gpio_irq_number), pm2);
1192 unregister_pm2xxx_charger:
1193         /* unregister power supply */
1194         power_supply_unregister(&pm2->ac_chg.psy);
1195 free_regulator:
1196         /* disable the regulator */
1197         regulator_put(pm2->regu);
1198 free_charger_wq:
1199         destroy_workqueue(pm2->charger_wq);
1200 free_device_info:
1201         kfree(pm2);
1202
1203         return ret;
1204 }
1205
1206 static int pm2xxx_wall_charger_remove(struct i2c_client *i2c_client)
1207 {
1208         struct pm2xxx_charger *pm2 = i2c_get_clientdata(i2c_client);
1209
1210         /* Disable pm_runtime */
1211         pm_runtime_disable(pm2->dev);
1212         /* Disable AC charging */
1213         pm2xxx_charger_ac_en(&pm2->ac_chg, false, 0, 0);
1214
1215         /* Disable wake by pm interrupt */
1216         disable_irq_wake(gpio_to_irq(pm2->pdata->gpio_irq_number));
1217
1218         /* Disable interrupts */
1219         free_irq(gpio_to_irq(pm2->pdata->gpio_irq_number), pm2);
1220
1221         /* Delete the work queue */
1222         destroy_workqueue(pm2->charger_wq);
1223
1224         flush_scheduled_work();
1225
1226         /* disable the regulator */
1227         regulator_put(pm2->regu);
1228
1229         power_supply_unregister(&pm2->ac_chg.psy);
1230
1231         if (gpio_is_valid(pm2->lpn_pin))
1232                 gpio_free(pm2->lpn_pin);
1233
1234         kfree(pm2);
1235
1236         return 0;
1237 }
1238
1239 static const struct i2c_device_id pm2xxx_id[] = {
1240         { "pm2301", 0 },
1241         { }
1242 };
1243
1244 MODULE_DEVICE_TABLE(i2c, pm2xxx_id);
1245
1246 static struct i2c_driver pm2xxx_charger_driver = {
1247         .probe = pm2xxx_wall_charger_probe,
1248         .remove = pm2xxx_wall_charger_remove,
1249         .driver = {
1250                 .name = "pm2xxx-wall_charger",
1251                 .owner = THIS_MODULE,
1252                 .pm = PM2XXX_PM_OPS,
1253         },
1254         .id_table = pm2xxx_id,
1255 };
1256
1257 static int __init pm2xxx_charger_init(void)
1258 {
1259         return i2c_add_driver(&pm2xxx_charger_driver);
1260 }
1261
1262 static void __exit pm2xxx_charger_exit(void)
1263 {
1264         i2c_del_driver(&pm2xxx_charger_driver);
1265 }
1266
1267 device_initcall_sync(pm2xxx_charger_init);
1268 module_exit(pm2xxx_charger_exit);
1269
1270 MODULE_LICENSE("GPL v2");
1271 MODULE_AUTHOR("Rajkumar kasirajan, Olivier Launay");
1272 MODULE_ALIAS("i2c:pm2xxx-charger");
1273 MODULE_DESCRIPTION("PM2xxx charger management driver");