linux/drivers/power/pm2301_charger.c
<<
>>
Prefs
   1/*
   2 * Copyright 2012 ST Ericsson.
   3 *
   4 * Power supply driver for ST Ericsson pm2xxx_charger charger
   5 *
   6 * This program is free software; you can redistribute it and/or modify
   7 * it under the terms of the GNU General Public License version 2 as
   8 * published by the Free Software Foundation.
   9 */
  10
  11#include <linux/init.h>
  12#include <linux/module.h>
  13#include <linux/device.h>
  14#include <linux/interrupt.h>
  15#include <linux/delay.h>
  16#include <linux/slab.h>
  17#include <linux/platform_device.h>
  18#include <linux/power_supply.h>
  19#include <linux/regulator/consumer.h>
  20#include <linux/err.h>
  21#include <linux/i2c.h>
  22#include <linux/workqueue.h>
  23#include <linux/mfd/abx500/ab8500.h>
  24#include <linux/mfd/abx500/ab8500-bm.h>
  25#include <linux/mfd/abx500/ux500_chargalg.h>
  26#include <linux/pm2301_charger.h>
  27#include <linux/gpio.h>
  28#include <linux/pm_runtime.h>
  29#include <linux/pm.h>
  30
  31#include "pm2301_charger.h"
  32
  33#define to_pm2xxx_charger_ac_device_info(x) container_of((x), \
  34                struct pm2xxx_charger, ac_chg)
  35#define SLEEP_MIN               50
  36#define SLEEP_MAX               100
  37#define PM2XXX_AUTOSUSPEND_DELAY 500
  38
  39static int pm2xxx_interrupt_registers[] = {
  40        PM2XXX_REG_INT1,
  41        PM2XXX_REG_INT2,
  42        PM2XXX_REG_INT3,
  43        PM2XXX_REG_INT4,
  44        PM2XXX_REG_INT5,
  45        PM2XXX_REG_INT6,
  46};
  47
  48static enum power_supply_property pm2xxx_charger_ac_props[] = {
  49        POWER_SUPPLY_PROP_HEALTH,
  50        POWER_SUPPLY_PROP_PRESENT,
  51        POWER_SUPPLY_PROP_ONLINE,
  52        POWER_SUPPLY_PROP_VOLTAGE_AVG,
  53};
  54
  55static int pm2xxx_charger_voltage_map[] = {
  56        3500,
  57        3525,
  58        3550,
  59        3575,
  60        3600,
  61        3625,
  62        3650,
  63        3675,
  64        3700,
  65        3725,
  66        3750,
  67        3775,
  68        3800,
  69        3825,
  70        3850,
  71        3875,
  72        3900,
  73        3925,
  74        3950,
  75        3975,
  76        4000,
  77        4025,
  78        4050,
  79        4075,
  80        4100,
  81        4125,
  82        4150,
  83        4175,
  84        4200,
  85        4225,
  86        4250,
  87        4275,
  88        4300,
  89};
  90
  91static int pm2xxx_charger_current_map[] = {
  92        200,
  93        200,
  94        400,
  95        600,
  96        800,
  97        1000,
  98        1200,
  99        1400,
 100        1600,
 101        1800,
 102        2000,
 103        2200,
 104        2400,
 105        2600,
 106        2800,
 107        3000,
 108};
 109
 110static const struct i2c_device_id pm2xxx_ident[] = {
 111        { "pm2301", 0 },
 112        { }
 113};
 114
 115static void set_lpn_pin(struct pm2xxx_charger *pm2)
 116{
 117        if (!pm2->ac.charger_connected && gpio_is_valid(pm2->lpn_pin)) {
 118                gpio_set_value(pm2->lpn_pin, 1);
 119                usleep_range(SLEEP_MIN, SLEEP_MAX);
 120        }
 121}
 122
 123static void clear_lpn_pin(struct pm2xxx_charger *pm2)
 124{
 125        if (!pm2->ac.charger_connected && gpio_is_valid(pm2->lpn_pin))
 126                gpio_set_value(pm2->lpn_pin, 0);
 127}
 128
 129static int pm2xxx_reg_read(struct pm2xxx_charger *pm2, int reg, u8 *val)
 130{
 131        int ret;
 132
 133        /* wake up the device */
 134        pm_runtime_get_sync(pm2->dev);
 135
 136        ret = i2c_smbus_read_i2c_block_data(pm2->config.pm2xxx_i2c, reg,
 137                                1, val);
 138        if (ret < 0)
 139                dev_err(pm2->dev, "Error reading register at 0x%x\n", reg);
 140        else
 141                ret = 0;
 142
 143        pm_runtime_put_sync(pm2->dev);
 144
 145        return ret;
 146}
 147
 148static int pm2xxx_reg_write(struct pm2xxx_charger *pm2, int reg, u8 val)
 149{
 150        int ret;
 151
 152        /* wake up the device */
 153        pm_runtime_get_sync(pm2->dev);
 154
 155        ret = i2c_smbus_write_i2c_block_data(pm2->config.pm2xxx_i2c, reg,
 156                                1, &val);
 157        if (ret < 0)
 158                dev_err(pm2->dev, "Error writing register at 0x%x\n", reg);
 159        else
 160                ret = 0;
 161
 162        pm_runtime_put_sync(pm2->dev);
 163
 164        return ret;
 165}
 166
 167static int pm2xxx_charging_enable_mngt(struct pm2xxx_charger *pm2)
 168{
 169        int ret;
 170
 171        /* Enable charging */
 172        ret = pm2xxx_reg_write(pm2, PM2XXX_BATT_CTRL_REG2,
 173                        (PM2XXX_CH_AUTO_RESUME_EN | PM2XXX_CHARGER_ENA));
 174
 175        return ret;
 176}
 177
 178static int pm2xxx_charging_disable_mngt(struct pm2xxx_charger *pm2)
 179{
 180        int ret;
 181
 182        /* Disable SW EOC ctrl */
 183        ret = pm2xxx_reg_write(pm2, PM2XXX_SW_CTRL_REG, PM2XXX_SWCTRL_HW);
 184        if (ret < 0) {
 185                dev_err(pm2->dev, "%s pm2xxx write failed\n", __func__);
 186                return ret;
 187        }
 188
 189        /* Disable charging */
 190        ret = pm2xxx_reg_write(pm2, PM2XXX_BATT_CTRL_REG2,
 191                        (PM2XXX_CH_AUTO_RESUME_DIS | PM2XXX_CHARGER_DIS));
 192        if (ret < 0) {
 193                dev_err(pm2->dev, "%s pm2xxx write failed\n", __func__);
 194                return ret;
 195        }
 196
 197        return 0;
 198}
 199
 200static int pm2xxx_charger_batt_therm_mngt(struct pm2xxx_charger *pm2, int val)
 201{
 202        queue_work(pm2->charger_wq, &pm2->check_main_thermal_prot_work);
 203
 204        return 0;
 205}
 206
 207
 208int pm2xxx_charger_die_therm_mngt(struct pm2xxx_charger *pm2, int val)
 209{
 210        queue_work(pm2->charger_wq, &pm2->check_main_thermal_prot_work);
 211
 212        return 0;
 213}
 214
 215static int pm2xxx_charger_ovv_mngt(struct pm2xxx_charger *pm2, int val)
 216{
 217        dev_err(pm2->dev, "Overvoltage detected\n");
 218        pm2->flags.ovv = true;
 219        power_supply_changed(&pm2->ac_chg.psy);
 220
 221        /* Schedule a new HW failure check */
 222        queue_delayed_work(pm2->charger_wq, &pm2->check_hw_failure_work, 0);
 223
 224        return 0;
 225}
 226
 227static int pm2xxx_charger_wd_exp_mngt(struct pm2xxx_charger *pm2, int val)
 228{
 229        dev_dbg(pm2->dev , "20 minutes watchdog expired\n");
 230
 231        pm2->ac.wd_expired = true;
 232        power_supply_changed(&pm2->ac_chg.psy);
 233
 234        return 0;
 235}
 236
 237static int pm2xxx_charger_vbat_lsig_mngt(struct pm2xxx_charger *pm2, int val)
 238{
 239        int ret;
 240
 241        switch (val) {
 242        case PM2XXX_INT1_ITVBATLOWR:
 243                dev_dbg(pm2->dev, "VBAT grows above VBAT_LOW level\n");
 244                /* Enable SW EOC ctrl */
 245                ret = pm2xxx_reg_write(pm2, PM2XXX_SW_CTRL_REG,
 246                                                        PM2XXX_SWCTRL_SW);
 247                if (ret < 0) {
 248                        dev_err(pm2->dev, "%s pm2xxx write failed\n", __func__);
 249                        return ret;
 250                }
 251                break;
 252
 253        case PM2XXX_INT1_ITVBATLOWF:
 254                dev_dbg(pm2->dev, "VBAT drops below VBAT_LOW level\n");
 255                /* Disable SW EOC ctrl */
 256                ret = pm2xxx_reg_write(pm2, PM2XXX_SW_CTRL_REG,
 257                                                        PM2XXX_SWCTRL_HW);
 258                if (ret < 0) {
 259                        dev_err(pm2->dev, "%s pm2xxx write failed\n", __func__);
 260                        return ret;
 261                }
 262                break;
 263
 264        default:
 265                dev_err(pm2->dev, "Unknown VBAT level\n");
 266        }
 267
 268        return 0;
 269}
 270
 271static int pm2xxx_charger_bat_disc_mngt(struct pm2xxx_charger *pm2, int val)
 272{
 273        dev_dbg(pm2->dev, "battery disconnected\n");
 274
 275        return 0;
 276}
 277
 278static int pm2xxx_charger_detection(struct pm2xxx_charger *pm2, u8 *val)
 279{
 280        int ret;
 281
 282        ret = pm2xxx_reg_read(pm2, PM2XXX_SRCE_REG_INT2, val);
 283
 284        if (ret < 0) {
 285                dev_err(pm2->dev, "Charger detection failed\n");
 286                goto out;
 287        }
 288
 289        *val &= (PM2XXX_INT2_S_ITVPWR1PLUG | PM2XXX_INT2_S_ITVPWR2PLUG);
 290
 291out:
 292        return ret;
 293}
 294
 295static int pm2xxx_charger_itv_pwr_plug_mngt(struct pm2xxx_charger *pm2, int val)
 296{
 297
 298        int ret;
 299        u8 read_val;
 300
 301        /*
 302         * Since we can't be sure that the events are received
 303         * synchronously, we have the check if the main charger is
 304         * connected by reading the interrupt source register.
 305         */
 306        ret = pm2xxx_charger_detection(pm2, &read_val);
 307
 308        if ((ret == 0) && read_val) {
 309                pm2->ac.charger_connected = 1;
 310                pm2->ac_conn = true;
 311                queue_work(pm2->charger_wq, &pm2->ac_work);
 312        }
 313
 314
 315        return ret;
 316}
 317
 318static int pm2xxx_charger_itv_pwr_unplug_mngt(struct pm2xxx_charger *pm2,
 319                                                                int val)
 320{
 321        pm2->ac.charger_connected = 0;
 322        queue_work(pm2->charger_wq, &pm2->ac_work);
 323
 324        return 0;
 325}
 326
 327static int pm2_int_reg0(void *pm2_data, int val)
 328{
 329        struct pm2xxx_charger *pm2 = pm2_data;
 330        int ret = 0;
 331
 332        if (val & PM2XXX_INT1_ITVBATLOWR) {
 333                ret = pm2xxx_charger_vbat_lsig_mngt(pm2,
 334                                                PM2XXX_INT1_ITVBATLOWR);
 335                if (ret < 0)
 336                        goto out;
 337        }
 338
 339        if (val & PM2XXX_INT1_ITVBATLOWF) {
 340                ret = pm2xxx_charger_vbat_lsig_mngt(pm2,
 341                                                PM2XXX_INT1_ITVBATLOWF);
 342                if (ret < 0)
 343                        goto out;
 344        }
 345
 346        if (val & PM2XXX_INT1_ITVBATDISCONNECT) {
 347                ret = pm2xxx_charger_bat_disc_mngt(pm2,
 348                                PM2XXX_INT1_ITVBATDISCONNECT);
 349                if (ret < 0)
 350                        goto out;
 351        }
 352out:
 353        return ret;
 354}
 355
 356static int pm2_int_reg1(void *pm2_data, int val)
 357{
 358        struct pm2xxx_charger *pm2 = pm2_data;
 359        int ret = 0;
 360
 361        if (val & (PM2XXX_INT2_ITVPWR1PLUG | PM2XXX_INT2_ITVPWR2PLUG)) {
 362                dev_dbg(pm2->dev , "Main charger plugged\n");
 363                ret = pm2xxx_charger_itv_pwr_plug_mngt(pm2, val &
 364                        (PM2XXX_INT2_ITVPWR1PLUG | PM2XXX_INT2_ITVPWR2PLUG));
 365        }
 366
 367        if (val &
 368                (PM2XXX_INT2_ITVPWR1UNPLUG | PM2XXX_INT2_ITVPWR2UNPLUG)) {
 369                dev_dbg(pm2->dev , "Main charger unplugged\n");
 370                ret = pm2xxx_charger_itv_pwr_unplug_mngt(pm2, val &
 371                                                (PM2XXX_INT2_ITVPWR1UNPLUG |
 372                                                PM2XXX_INT2_ITVPWR2UNPLUG));
 373        }
 374
 375        return ret;
 376}
 377
 378static int pm2_int_reg2(void *pm2_data, int val)
 379{
 380        struct pm2xxx_charger *pm2 = pm2_data;
 381        int ret = 0;
 382
 383        if (val & PM2XXX_INT3_ITAUTOTIMEOUTWD)
 384                ret = pm2xxx_charger_wd_exp_mngt(pm2, val);
 385
 386        if (val & (PM2XXX_INT3_ITCHPRECHARGEWD |
 387                                PM2XXX_INT3_ITCHCCWD | PM2XXX_INT3_ITCHCVWD)) {
 388                dev_dbg(pm2->dev,
 389                        "Watchdog occured for precharge, CC and CV charge\n");
 390        }
 391
 392        return ret;
 393}
 394
 395static int pm2_int_reg3(void *pm2_data, int val)
 396{
 397        struct pm2xxx_charger *pm2 = pm2_data;
 398        int ret = 0;
 399
 400        if (val & (PM2XXX_INT4_ITCHARGINGON)) {
 401                dev_dbg(pm2->dev ,
 402                        "chargind operation has started\n");
 403        }
 404
 405        if (val & (PM2XXX_INT4_ITVRESUME)) {
 406                dev_dbg(pm2->dev,
 407                        "battery discharged down to VResume threshold\n");
 408        }
 409
 410        if (val & (PM2XXX_INT4_ITBATTFULL)) {
 411                dev_dbg(pm2->dev , "battery fully detected\n");
 412        }
 413
 414        if (val & (PM2XXX_INT4_ITCVPHASE)) {
 415                dev_dbg(pm2->dev, "CV phase enter with 0.5C charging\n");
 416        }
 417
 418        if (val & (PM2XXX_INT4_ITVPWR2OVV | PM2XXX_INT4_ITVPWR1OVV)) {
 419                pm2->failure_case = VPWR_OVV;
 420                ret = pm2xxx_charger_ovv_mngt(pm2, val &
 421                        (PM2XXX_INT4_ITVPWR2OVV | PM2XXX_INT4_ITVPWR1OVV));
 422                dev_dbg(pm2->dev, "VPWR/VSYSTEM overvoltage detected\n");
 423        }
 424
 425        if (val & (PM2XXX_INT4_S_ITBATTEMPCOLD |
 426                                PM2XXX_INT4_S_ITBATTEMPHOT)) {
 427                ret = pm2xxx_charger_batt_therm_mngt(pm2, val &
 428                        (PM2XXX_INT4_S_ITBATTEMPCOLD |
 429                        PM2XXX_INT4_S_ITBATTEMPHOT));
 430                dev_dbg(pm2->dev, "BTEMP is too Low/High\n");
 431        }
 432
 433        return ret;
 434}
 435
 436static int pm2_int_reg4(void *pm2_data, int val)
 437{
 438        struct pm2xxx_charger *pm2 = pm2_data;
 439        int ret = 0;
 440
 441        if (val & PM2XXX_INT5_ITVSYSTEMOVV) {
 442                pm2->failure_case = VSYSTEM_OVV;
 443                ret = pm2xxx_charger_ovv_mngt(pm2, val &
 444                                                PM2XXX_INT5_ITVSYSTEMOVV);
 445                dev_dbg(pm2->dev, "VSYSTEM overvoltage detected\n");
 446        }
 447
 448        if (val & (PM2XXX_INT5_ITTHERMALWARNINGFALL |
 449                                PM2XXX_INT5_ITTHERMALWARNINGRISE |
 450                                PM2XXX_INT5_ITTHERMALSHUTDOWNFALL |
 451                                PM2XXX_INT5_ITTHERMALSHUTDOWNRISE)) {
 452                dev_dbg(pm2->dev, "BTEMP die temperature is too Low/High\n");
 453                ret = pm2xxx_charger_die_therm_mngt(pm2, val &
 454                        (PM2XXX_INT5_ITTHERMALWARNINGFALL |
 455                        PM2XXX_INT5_ITTHERMALWARNINGRISE |
 456                        PM2XXX_INT5_ITTHERMALSHUTDOWNFALL |
 457                        PM2XXX_INT5_ITTHERMALSHUTDOWNRISE));
 458        }
 459
 460        return ret;
 461}
 462
 463static int pm2_int_reg5(void *pm2_data, int val)
 464{
 465        struct pm2xxx_charger *pm2 = pm2_data;
 466        int ret = 0;
 467
 468        if (val & (PM2XXX_INT6_ITVPWR2DROP | PM2XXX_INT6_ITVPWR1DROP)) {
 469                dev_dbg(pm2->dev, "VMPWR drop to VBAT level\n");
 470        }
 471
 472        if (val & (PM2XXX_INT6_ITVPWR2VALIDRISE |
 473                        PM2XXX_INT6_ITVPWR1VALIDRISE |
 474                        PM2XXX_INT6_ITVPWR2VALIDFALL |
 475                        PM2XXX_INT6_ITVPWR1VALIDFALL)) {
 476                dev_dbg(pm2->dev, "Falling/Rising edge on WPWR1/2\n");
 477        }
 478
 479        return ret;
 480}
 481
 482static irqreturn_t  pm2xxx_irq_int(int irq, void *data)
 483{
 484        struct pm2xxx_charger *pm2 = data;
 485        struct pm2xxx_interrupts *interrupt = pm2->pm2_int;
 486        int i;
 487
 488        /* wake up the device */
 489        pm_runtime_get_sync(pm2->dev);
 490
 491        do {
 492                for (i = 0; i < PM2XXX_NUM_INT_REG; i++) {
 493                        pm2xxx_reg_read(pm2,
 494                                pm2xxx_interrupt_registers[i],
 495                                &(interrupt->reg[i]));
 496
 497                        if (interrupt->reg[i] > 0)
 498                                interrupt->handler[i](pm2, interrupt->reg[i]);
 499                }
 500        } while (gpio_get_value(pm2->pdata->gpio_irq_number) == 0);
 501
 502        pm_runtime_mark_last_busy(pm2->dev);
 503        pm_runtime_put_autosuspend(pm2->dev);
 504
 505        return IRQ_HANDLED;
 506}
 507
 508static int pm2xxx_charger_get_ac_cv(struct pm2xxx_charger *pm2)
 509{
 510        int ret = 0;
 511        u8 val;
 512
 513        if (pm2->ac.charger_connected && pm2->ac.charger_online) {
 514
 515                ret = pm2xxx_reg_read(pm2, PM2XXX_SRCE_REG_INT4, &val);
 516                if (ret < 0) {
 517                        dev_err(pm2->dev, "%s pm2xxx read failed\n", __func__);
 518                        goto out;
 519                }
 520
 521                if (val & PM2XXX_INT4_S_ITCVPHASE)
 522                        ret = PM2XXX_CONST_VOLT;
 523                else
 524                        ret = PM2XXX_CONST_CURR;
 525        }
 526out:
 527        return ret;
 528}
 529
 530static int pm2xxx_current_to_regval(int curr)
 531{
 532        int i;
 533
 534        if (curr < pm2xxx_charger_current_map[0])
 535                return 0;
 536
 537        for (i = 1; i < ARRAY_SIZE(pm2xxx_charger_current_map); i++) {
 538                if (curr < pm2xxx_charger_current_map[i])
 539                        return (i - 1);
 540        }
 541
 542        i = ARRAY_SIZE(pm2xxx_charger_current_map) - 1;
 543        if (curr == pm2xxx_charger_current_map[i])
 544                return i;
 545        else
 546                return -EINVAL;
 547}
 548
 549static int pm2xxx_voltage_to_regval(int curr)
 550{
 551        int i;
 552
 553        if (curr < pm2xxx_charger_voltage_map[0])
 554                return 0;
 555
 556        for (i = 1; i < ARRAY_SIZE(pm2xxx_charger_voltage_map); i++) {
 557                if (curr < pm2xxx_charger_voltage_map[i])
 558                        return i - 1;
 559        }
 560
 561        i = ARRAY_SIZE(pm2xxx_charger_voltage_map) - 1;
 562        if (curr == pm2xxx_charger_voltage_map[i])
 563                return i;
 564        else
 565                return -EINVAL;
 566}
 567
 568static int pm2xxx_charger_update_charger_current(struct ux500_charger *charger,
 569                int ich_out)
 570{
 571        int ret;
 572        int curr_index;
 573        struct pm2xxx_charger *pm2;
 574        u8 val;
 575
 576        if (charger->psy.type == POWER_SUPPLY_TYPE_MAINS)
 577                pm2 = to_pm2xxx_charger_ac_device_info(charger);
 578        else
 579                return -ENXIO;
 580
 581        curr_index = pm2xxx_current_to_regval(ich_out);
 582        if (curr_index < 0) {
 583                dev_err(pm2->dev,
 584                        "Charger current too high, charging not started\n");
 585                return -ENXIO;
 586        }
 587
 588        ret = pm2xxx_reg_read(pm2, PM2XXX_BATT_CTRL_REG6, &val);
 589        if (ret >= 0) {
 590                val &= ~PM2XXX_DIR_CH_CC_CURRENT_MASK;
 591                val |= curr_index;
 592                ret = pm2xxx_reg_write(pm2, PM2XXX_BATT_CTRL_REG6, val);
 593                if (ret < 0) {
 594                        dev_err(pm2->dev,
 595                                "%s write failed\n", __func__);
 596                }
 597        }
 598        else
 599                dev_err(pm2->dev, "%s read failed\n", __func__);
 600
 601        return ret;
 602}
 603
 604static int pm2xxx_charger_ac_get_property(struct power_supply *psy,
 605        enum power_supply_property psp,
 606        union power_supply_propval *val)
 607{
 608        struct pm2xxx_charger *pm2;
 609
 610        pm2 = to_pm2xxx_charger_ac_device_info(psy_to_ux500_charger(psy));
 611
 612        switch (psp) {
 613        case POWER_SUPPLY_PROP_HEALTH:
 614                if (pm2->flags.mainextchnotok)
 615                        val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
 616                else if (pm2->ac.wd_expired)
 617                        val->intval = POWER_SUPPLY_HEALTH_DEAD;
 618                else if (pm2->flags.main_thermal_prot)
 619                        val->intval = POWER_SUPPLY_HEALTH_OVERHEAT;
 620                else if (pm2->flags.ovv)
 621                        val->intval = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
 622                else
 623                        val->intval = POWER_SUPPLY_HEALTH_GOOD;
 624                break;
 625        case POWER_SUPPLY_PROP_ONLINE:
 626                val->intval = pm2->ac.charger_online;
 627                break;
 628        case POWER_SUPPLY_PROP_PRESENT:
 629                val->intval = pm2->ac.charger_connected;
 630                break;
 631        case POWER_SUPPLY_PROP_VOLTAGE_AVG:
 632                pm2->ac.cv_active = pm2xxx_charger_get_ac_cv(pm2);
 633                val->intval = pm2->ac.cv_active;
 634                break;
 635        default:
 636                return -EINVAL;
 637        }
 638        return 0;
 639}
 640
 641static int pm2xxx_charging_init(struct pm2xxx_charger *pm2)
 642{
 643        int ret = 0;
 644
 645        /* enable CC and CV watchdog */
 646        ret = pm2xxx_reg_write(pm2, PM2XXX_BATT_CTRL_REG3,
 647                (PM2XXX_CH_WD_CV_PHASE_60MIN | PM2XXX_CH_WD_CC_PHASE_60MIN));
 648        if( ret < 0)
 649                return ret;
 650
 651        /* enable precharge watchdog */
 652        ret = pm2xxx_reg_write(pm2, PM2XXX_BATT_CTRL_REG4,
 653                                        PM2XXX_CH_WD_PRECH_PHASE_60MIN);
 654
 655        /* Disable auto timeout */
 656        ret = pm2xxx_reg_write(pm2, PM2XXX_BATT_CTRL_REG5,
 657                                        PM2XXX_CH_WD_AUTO_TIMEOUT_20MIN);
 658
 659        /*
 660     * EOC current level = 100mA
 661         * Precharge current level = 100mA
 662         * CC current level = 1000mA
 663         */
 664        ret = pm2xxx_reg_write(pm2, PM2XXX_BATT_CTRL_REG6,
 665                (PM2XXX_DIR_CH_CC_CURRENT_1000MA |
 666                PM2XXX_CH_PRECH_CURRENT_100MA |
 667                PM2XXX_CH_EOC_CURRENT_100MA));
 668
 669        /*
 670     * recharge threshold = 3.8V
 671         * Precharge to CC threshold = 2.9V
 672         */
 673        ret = pm2xxx_reg_write(pm2, PM2XXX_BATT_CTRL_REG7,
 674                (PM2XXX_CH_PRECH_VOL_2_9 | PM2XXX_CH_VRESUME_VOL_3_8));
 675
 676        /* float voltage charger level = 4.2V */
 677        ret = pm2xxx_reg_write(pm2, PM2XXX_BATT_CTRL_REG8,
 678                PM2XXX_CH_VOLT_4_2);
 679
 680        /* Voltage drop between VBAT and VSYS in HW charging = 300mV */
 681        ret = pm2xxx_reg_write(pm2, PM2XXX_BATT_CTRL_REG9,
 682                (PM2XXX_CH_150MV_DROP_300MV | PM2XXX_CHARCHING_INFO_DIS |
 683                PM2XXX_CH_CC_REDUCED_CURRENT_IDENT |
 684                PM2XXX_CH_CC_MODEDROP_DIS));
 685
 686        /* Input charger level of over voltage = 10V */
 687        ret = pm2xxx_reg_write(pm2, PM2XXX_INP_VOLT_VPWR2,
 688                                        PM2XXX_VPWR2_OVV_10);
 689        ret = pm2xxx_reg_write(pm2, PM2XXX_INP_VOLT_VPWR1,
 690                                        PM2XXX_VPWR1_OVV_10);
 691
 692        /* Input charger drop */
 693        ret = pm2xxx_reg_write(pm2, PM2XXX_INP_DROP_VPWR2,
 694                (PM2XXX_VPWR2_HW_OPT_DIS | PM2XXX_VPWR2_VALID_DIS |
 695                PM2XXX_VPWR2_DROP_DIS));
 696        ret = pm2xxx_reg_write(pm2, PM2XXX_INP_DROP_VPWR1,
 697                (PM2XXX_VPWR1_HW_OPT_DIS | PM2XXX_VPWR1_VALID_DIS |
 698                PM2XXX_VPWR1_DROP_DIS));
 699
 700        /* Disable battery low monitoring */
 701        ret = pm2xxx_reg_write(pm2, PM2XXX_BATT_LOW_LEV_COMP_REG,
 702                PM2XXX_VBAT_LOW_MONITORING_ENA);
 703
 704        return ret;
 705}
 706
 707static int pm2xxx_charger_ac_en(struct ux500_charger *charger,
 708        int enable, int vset, int iset)
 709{
 710        int ret;
 711        int volt_index;
 712        int curr_index;
 713        u8 val;
 714
 715        struct pm2xxx_charger *pm2 = to_pm2xxx_charger_ac_device_info(charger);
 716
 717        if (enable) {
 718                if (!pm2->ac.charger_connected) {
 719                        dev_dbg(pm2->dev, "AC charger not connected\n");
 720                        return -ENXIO;
 721                }
 722
 723                dev_dbg(pm2->dev, "Enable AC: %dmV %dmA\n", vset, iset);
 724                if (!pm2->vddadc_en_ac) {
 725                        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
 817error_occured:
 818        return ret;
 819}
 820
 821static 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
 838static 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
 848static 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
 872static 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
 897static 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
 906static 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
 914static 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
 930static 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
 952static 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
 970static 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
 991static 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
1001static 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
1184free_gpio:
1185        if (gpio_is_valid(pm2->lpn_pin))
1186                gpio_free(pm2->lpn_pin);
1187disable_pm2_irq_wake:
1188        disable_irq_wake(gpio_to_irq(pm2->pdata->gpio_irq_number));
1189unregister_pm2xxx_interrupt:
1190        /* disable interrupt */
1191        free_irq(gpio_to_irq(pm2->pdata->gpio_irq_number), pm2);
1192unregister_pm2xxx_charger:
1193        /* unregister power supply */
1194        power_supply_unregister(&pm2->ac_chg.psy);
1195free_regulator:
1196        /* disable the regulator */
1197        regulator_put(pm2->regu);
1198free_charger_wq:
1199        destroy_workqueue(pm2->charger_wq);
1200free_device_info:
1201        kfree(pm2);
1202
1203        return ret;
1204}
1205
1206static 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
1239static const struct i2c_device_id pm2xxx_id[] = {
1240        { "pm2301", 0 },
1241        { }
1242};
1243
1244MODULE_DEVICE_TABLE(i2c, pm2xxx_id);
1245
1246static 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
1257static int __init pm2xxx_charger_init(void)
1258{
1259        return i2c_add_driver(&pm2xxx_charger_driver);
1260}
1261
1262static void __exit pm2xxx_charger_exit(void)
1263{
1264        i2c_del_driver(&pm2xxx_charger_driver);
1265}
1266
1267device_initcall_sync(pm2xxx_charger_init);
1268module_exit(pm2xxx_charger_exit);
1269
1270MODULE_LICENSE("GPL v2");
1271MODULE_AUTHOR("Rajkumar kasirajan, Olivier Launay");
1272MODULE_ALIAS("i2c:pm2xxx-charger");
1273MODULE_DESCRIPTION("PM2xxx charger management driver");
1274
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.