drivers/power/sabresd_battery.c

   1 /*
   2  * sabresd_battery.c - Maxim 8903 USB/Adapter Charger Driver
   3  *
   4  * Copyright (C) 2011 Samsung Electronics
   5  * Copyright (C) 2011-2013 Freescale Semiconductor, Inc.
   6  * Based on max8903_charger.c
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20  *
  21  */
  22
  23 #include <linux/delay.h>
  24 #include <linux/gpio.h>
  25 #include <linux/interrupt.h>
  26 #include <linux/module.h>
  27 #include <linux/of.h>
  28 #include <linux/of_device.h>
  29 #include <linux/of_gpio.h>
  30 #include <linux/power_supply.h>
  31 #include <linux/platform_device.h>
  32 #include <linux/power/sabresd_battery.h>
  33 #include <linux/slab.h>
  34
  35 #define BATTERY_UPDATE_INTERVAL 5 /*seconds*/
  36 #define LOW_VOLT_THRESHOLD      2800000
  37 #define HIGH_VOLT_THRESHOLD     4200000
  38 #define ADC_SAMPLE_COUNT        6
  39
  40 struct max8903_data {
  41         struct max8903_pdata *pdata;
  42         struct device *dev;
  43         struct power_supply psy;
  44         struct power_supply usb;
  45         bool fault;
  46         bool usb_in;
  47         bool ta_in;
  48         bool chg_state;
  49         struct delayed_work work;
  50         unsigned int interval;
  51         unsigned short thermal_raw;
  52         int voltage_uV;
  53         int current_uA;
  54         int battery_status;
  55         int charger_online;
  56         int charger_voltage_uV;
  57         int real_capacity;
  58         int percent;
  59         int old_percent;
  60         int usb_charger_online;
  61         int first_delay_count;
  62         struct power_supply bat;
  63         struct power_supply     detect_usb;
  64 };
  65
  66 typedef struct {
  67         u32 voltage;
  68         u32 percent;
  69 } battery_capacity , *pbattery_capacity;
  70
  71 static int offset_discharger;
  72 static int offset_charger;
  73 static int offset_usb_charger;
  74
  75 static battery_capacity chargingTable[] = {
  76         {4050,  99},
  77         {4040,  98},
  78         {4020,  97},
  79         {4010,  96},
  80         {3990,  95},
  81         {3980,  94},
  82         {3970,  93},
  83         {3960,  92},
  84         {3950,  91},
  85         {3940,  90},
  86         {3930,  85},
  87         {3920,  81},
  88         {3910,  77},
  89         {3900,  73},
  90         {3890,  70},
  91         {3860,  65},
  92         {3830,  60},
  93         {3780,  55},
  94         {3760,  50},
  95         {3740,  45},
  96         {3720,  40},
  97         {3700,  35},
  98         {3680,  30},
  99         {3660,  25},
 100         {3640,  20},
 101         {3620,  17},
 102         {3600,  14},
 103         {3580,  13},
 104         {3560,  12},
 105         {3540,  11},
 106         {3520,  10},
 107         {3500,  9},
 108         {3480,  8},
 109         {3460,  7},
 110         {3440,  6},
 111         {3430,  5},
 112         {3420,  4},
 113         {3020,  0},
 114 };
 115
 116 static battery_capacity dischargingTable[] = {
 117         {4050, 100},
 118         {4035,  99},
 119         {4020,  98},
 120         {4010,  97},
 121         {4000,  96},
 122         {3990,  96},
 123         {3980,  95},
 124         {3970,  92},
 125         {3960,  91},
 126         {3950,  90},
 127         {3940,  88},
 128         {3930,  86},
 129         {3920,  84},
 130         {3910,  82},
 131         {3900,  80},
 132         {3890,  74},
 133         {3860,  69},
 134         {3830,  64},
 135         {3780,  59},
 136         {3760,  54},
 137         {3740,  49},
 138         {3720,  44},
 139         {3700,  39},
 140         {3680,  34},
 141         {3660,  29},
 142         {3640,  24},
 143         {3620,  19},
 144         {3600,  14},
 145         {3580,  13},
 146         {3560,  12},
 147         {3540,  11},
 148         {3520,  10},
 149         {3500,  9},
 150         {3480,  8},
 151         {3460,  7},
 152         {3440,  6},
 153         {3430,  5},
 154         {3420,  4},
 155         {3020,  0},
 156 };
 157
 158 u32 calibrate_battery_capability_percent(struct max8903_data *data)
 159 {
 160         u8 i;
 161         pbattery_capacity pTable;
 162         u32 tableSize;
 163
 164         if (data->battery_status  == POWER_SUPPLY_STATUS_DISCHARGING) {
 165                 pTable = dischargingTable;
 166                 tableSize = sizeof(dischargingTable)/
 167                         sizeof(dischargingTable[0]);
 168         } else {
 169                 pTable = chargingTable;
 170                 tableSize = sizeof(chargingTable)/
 171                         sizeof(chargingTable[0]);
 172         }
 173         for (i = 0; i < tableSize; i++) {
 174                 if (data->voltage_uV >= pTable[i].voltage)
 175                         return  pTable[i].percent;
 176         }
 177
 178         return 0;
 179 }
 180
 181 static enum power_supply_property max8903_charger_props[] = {
 182         POWER_SUPPLY_PROP_ONLINE,
 183 };
 184
 185 static enum power_supply_property max8903_battery_props[] = {
 186         POWER_SUPPLY_PROP_VOLTAGE_NOW,
 187         POWER_SUPPLY_PROP_STATUS,
 188         POWER_SUPPLY_PROP_PRESENT,
 189         POWER_SUPPLY_PROP_CAPACITY,
 190         POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN,
 191         POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
 192         POWER_SUPPLY_PROP_HEALTH,
 193         POWER_SUPPLY_PROP_CAPACITY_LEVEL,
 194 };
 195
 196 extern u32 max11801_read_adc(void);
 197
 198 static void max8903_charger_update_status(struct max8903_data *data)
 199 {
 200         if (data->ta_in) {
 201                 data->charger_online = 1;
 202         } else if (data->usb_in) {
 203                 data->usb_charger_online = 1;
 204         } else {
 205                 data->charger_online = 0;
 206                 data->usb_charger_online = 0;
 207         }
 208
 209         if (!data->charger_online && !data->usb_charger_online) {
 210                 data->battery_status = POWER_SUPPLY_STATUS_DISCHARGING;
 211         } else if (gpio_get_value(data->pdata->chg) == 0) {
 212                 data->battery_status = POWER_SUPPLY_STATUS_CHARGING;
 213         } else if ((data->ta_in || data->usb_in) &&
 214                 gpio_get_value(data->pdata->chg) > 0) {
 215                 if (!data->pdata->feature_flag) {
 216                         if (data->percent >= 99)
 217                                 data->battery_status = POWER_SUPPLY_STATUS_FULL;
 218                         else
 219                                 data->battery_status =
 220                                 POWER_SUPPLY_STATUS_NOT_CHARGING;
 221                 } else {
 222                         data->battery_status = POWER_SUPPLY_STATUS_FULL;
 223                 }
 224         }
 225 }
 226
 227 u32 calibration_voltage(struct max8903_data *data)
 228 {
 229         u32 voltage_data = 0;
 230         int i;
 231         int offset;
 232
 233         if (!data->charger_online && !data->usb_charger_online)
 234                 offset = offset_discharger;
 235         else if (data->usb_charger_online)
 236                 offset = offset_usb_charger;
 237         else if (data->charger_online)
 238                 offset = offset_charger;
 239
 240         /* simple average */
 241         for (i = 0; i < ADC_SAMPLE_COUNT; i++)
 242                 voltage_data += max11801_read_adc()-offset;
 243         voltage_data = voltage_data / ADC_SAMPLE_COUNT;
 244         dev_dbg(data->dev, "volt: %d\n", voltage_data);
 245
 246         return voltage_data;
 247 }
 248
 249 static void max8903_battery_update_status(struct max8903_data *data)
 250 {
 251         if (!data->pdata->feature_flag) {
 252                 data->voltage_uV = calibration_voltage(data);
 253                 data->percent = calibrate_battery_capability_percent(data);
 254                 if (data->percent != data->old_percent) {
 255                         data->old_percent = data->percent;
 256                         power_supply_changed(&data->bat);
 257                 }
 258                  /*
 259                   * because boot time gap between led framwork and charger
 260                   * framwork,when system boots with charger attatched,
 261                   * charger led framwork loses the first charger online event,
 262                   * add once extra power_supply_changed can fix this issure
 263                   */
 264                 if (data->first_delay_count < 200) {
 265                         data->first_delay_count = data->first_delay_count + 1;
 266                         power_supply_changed(&data->bat);
 267                 }
 268         }
 269 }
 270
 271 static int max8903_battery_get_property(struct power_supply *bat,
 272                                        enum power_supply_property psp,
 273                                        union power_supply_propval *val)
 274 {
 275         struct max8903_data *di = container_of(bat, struct max8903_data, bat);
 276
 277         switch (psp) {
 278         case POWER_SUPPLY_PROP_STATUS:
 279                 val->intval = POWER_SUPPLY_STATUS_UNKNOWN;
 280                 if (gpio_get_value(di->pdata->chg) == 0) {
 281                         di->battery_status = POWER_SUPPLY_STATUS_CHARGING;
 282                 } else if ((di->ta_in || di->usb_in) &&
 283                         gpio_get_value(di->pdata->chg) > 0) {
 284                         if (!di->pdata->feature_flag) {
 285                                 if (di->percent >= 99)
 286                                         di->battery_status =
 287                                         POWER_SUPPLY_STATUS_FULL;
 288                                 else
 289                                         di->battery_status =
 290                                         POWER_SUPPLY_STATUS_NOT_CHARGING;
 291                         } else {
 292                                 di->battery_status = POWER_SUPPLY_STATUS_FULL;
 293                         }
 294                 }
 295                 val->intval = di->battery_status;
 296                 return 0;
 297         default:
 298                 break;
 299         }
 300
 301         switch (psp) {
 302         case POWER_SUPPLY_PROP_VOLTAGE_NOW:
 303                 val->intval = di->voltage_uV;
 304                 break;
 305         case POWER_SUPPLY_PROP_CHARGE_NOW:
 306                 val->intval = 0;
 307                 break;
 308         case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN:
 309                 val->intval = HIGH_VOLT_THRESHOLD;
 310                 break;
 311         case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
 312                 val->intval = LOW_VOLT_THRESHOLD;
 313                 break;
 314         case POWER_SUPPLY_PROP_PRESENT:
 315                 val->intval = 1;
 316                 break;
 317         case POWER_SUPPLY_PROP_CAPACITY:
 318                 val->intval = di->percent < 0 ? 0 :
 319                                 (di->percent > 100 ? 100 : di->percent);
 320                 break;
 321         case POWER_SUPPLY_PROP_HEALTH:
 322                 val->intval = POWER_SUPPLY_HEALTH_GOOD;
 323                 if (di->fault)
 324                         val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
 325                 break;
 326         case POWER_SUPPLY_PROP_CAPACITY_LEVEL:
 327                 if (di->battery_status == POWER_SUPPLY_STATUS_FULL)
 328                         val->intval = POWER_SUPPLY_CAPACITY_LEVEL_FULL;
 329                 else if (di->percent <= 15)
 330                         val->intval = POWER_SUPPLY_CAPACITY_LEVEL_LOW;
 331                 else
 332                         val->intval = POWER_SUPPLY_CAPACITY_LEVEL_NORMAL;
 333                 break;
 334         default:
 335                 return -EINVAL;
 336         }
 337
 338         return 0;
 339 }
 340
 341 static int max8903_get_property(struct power_supply *psy,
 342                 enum power_supply_property psp,
 343                 union power_supply_propval *val)
 344 {
 345         struct max8903_data *data = container_of(psy,
 346                         struct max8903_data, psy);
 347
 348         switch (psp) {
 349         case POWER_SUPPLY_PROP_ONLINE:
 350                 val->intval = 0;
 351                 if (data->ta_in)
 352                         val->intval = 1;
 353                 data->charger_online = val->intval;
 354                 break;
 355         default:
 356                 return -EINVAL;
 357         }
 358
 359         return 0;
 360 }
 361
 362 static int max8903_get_usb_property(struct power_supply *usb,
 363                 enum power_supply_property psp,
 364                 union power_supply_propval *val)
 365 {
 366         struct max8903_data *data = container_of(usb,
 367                         struct max8903_data, usb);
 368
 369         switch (psp) {
 370         case POWER_SUPPLY_PROP_ONLINE:
 371                 val->intval = 0;
 372                 if (data->usb_in)
 373                         val->intval = 1;
 374                 data->usb_charger_online = val->intval;
 375                 break;
 376         default:
 377                 return -EINVAL;
 378         }
 379
 380         return 0;
 381 }
 382
 383 static irqreturn_t max8903_dcin(int irq, void *_data)
 384 {
 385         struct max8903_data *data = _data;
 386         struct max8903_pdata *pdata = data->pdata;
 387         bool ta_in = false;
 388
 389         if (pdata->dok)
 390                 ta_in = gpio_get_value(pdata->dok) ? false : true;
 391
 392         if (ta_in == data->ta_in)
 393                 return IRQ_HANDLED;
 394
 395         data->ta_in = ta_in;
 396         dev_info(data->dev, "TA(DC-IN) Charger %s.\n", ta_in ?
 397                         "Connected" : "Disconnected");
 398         max8903_charger_update_status(data);
 399         power_supply_changed(&data->psy);
 400         power_supply_changed(&data->bat);
 401
 402         return IRQ_HANDLED;
 403 }
 404
 405 static irqreturn_t max8903_usbin(int irq, void *_data)
 406 {
 407         struct max8903_data *data = _data;
 408         struct max8903_pdata *pdata = data->pdata;
 409         bool usb_in = false;
 410
 411         if (pdata->uok)
 412                 usb_in = gpio_get_value(pdata->uok) ? false : true;
 413         if (usb_in == data->usb_in)
 414                 return IRQ_HANDLED;
 415         data->usb_in = usb_in;
 416         dev_info(data->dev, "USB Charger %s.\n", usb_in ?
 417                         "Connected" : "Disconnected");
 418         max8903_charger_update_status(data);
 419         power_supply_changed(&data->bat);
 420         power_supply_changed(&data->usb);
 421
 422         return IRQ_HANDLED;
 423 }
 424
 425 static irqreturn_t max8903_fault(int irq, void *_data)
 426 {
 427         struct max8903_data *data = _data;
 428         struct max8903_pdata *pdata = data->pdata;
 429         bool fault;
 430
 431         fault = gpio_get_value(pdata->flt) ? false : true;
 432
 433         if (fault == data->fault)
 434                 return IRQ_HANDLED;
 435         data->fault = fault;
 436
 437         if (fault)
 438                 dev_err(data->dev, "Charger suffers a fault and stops.\n");
 439         else
 440                 dev_err(data->dev, "Charger recovered from a fault.\n");
 441         max8903_charger_update_status(data);
 442         power_supply_changed(&data->psy);
 443         power_supply_changed(&data->bat);
 444         power_supply_changed(&data->usb);
 445
 446         return IRQ_HANDLED;
 447 }
 448
 449 static irqreturn_t max8903_chg(int irq, void *_data)
 450 {
 451         struct max8903_data *data = _data;
 452         struct max8903_pdata *pdata = data->pdata;
 453         int chg_state;
 454
 455         chg_state = gpio_get_value(pdata->chg) ? false : true;
 456
 457         if (chg_state == data->chg_state)
 458                 return IRQ_HANDLED;
 459         data->chg_state = chg_state;
 460         max8903_charger_update_status(data);
 461         power_supply_changed(&data->psy);
 462         power_supply_changed(&data->bat);
 463         power_supply_changed(&data->usb);
 464
 465         return IRQ_HANDLED;
 466 }
 467
 468 static void max8903_battery_work(struct work_struct *work)
 469 {
 470         struct max8903_data *data;
 471
 472         data = container_of(work, struct max8903_data, work.work);
 473         data->interval = HZ * BATTERY_UPDATE_INTERVAL;
 474
 475         max8903_charger_update_status(data);
 476         max8903_battery_update_status(data);
 477         dev_dbg(data->dev, "battery voltage: %4d mV\n", data->voltage_uV);
 478         dev_dbg(data->dev, "charger online status: %d\n",
 479                 data->charger_online);
 480         dev_dbg(data->dev, "battery status : %d\n" , data->battery_status);
 481         dev_dbg(data->dev, "battery capacity percent: %3d\n", data->percent);
 482         dev_dbg(data->dev, "data->usb_in: %x , data->ta_in: %x\n",
 483                 data->usb_in, data->ta_in);
 484         /* reschedule for the next time */
 485         schedule_delayed_work(&data->work, data->interval);
 486 }
 487
 488 static ssize_t max8903_voltage_offset_discharger_show(struct device *dev,
 489                             struct device_attribute *attr, char *buf)
 490 {
 491         return sprintf(buf, "read offset_discharger:%04d\n",
 492                 offset_discharger);
 493 }
 494
 495 static ssize_t max8903_voltage_offset_discharger_store(struct device *dev,
 496                              struct device_attribute *attr, const char *buf,
 497                              size_t count)
 498 {
 499         int ret;
 500         unsigned long data;
 501
 502         ret = strict_strtoul(buf, 10, &data);
 503         offset_discharger = (int)data;
 504         pr_info("read offset_discharger:%04d\n", offset_discharger);
 505
 506         return count;
 507 }
 508
 509 static ssize_t max8903_voltage_offset_charger_show(struct device *dev,
 510                             struct device_attribute *attr, char *buf)
 511 {
 512         return sprintf(buf, "read offset_charger:%04d\n",
 513                 offset_charger);
 514 }
 515
 516 static ssize_t max8903_voltage_offset_charger_store(struct device *dev,
 517                              struct device_attribute *attr, const char *buf,
 518                              size_t count)
 519 {
 520         int ret;
 521         unsigned long data;
 522
 523         ret = strict_strtoul(buf, 10, &data);
 524         offset_charger = (int)data;
 525         pr_info("read offset_charger:%04d\n", offset_charger);
 526         return count;
 527 }
 528
 529 static ssize_t max8903_voltage_offset_usb_charger_show(struct device *dev,
 530                             struct device_attribute *attr, char *buf)
 531 {
 532         return sprintf(buf, "read offset_usb_charger:%04d\n",
 533                 offset_usb_charger);
 534 }
 535
 536 static ssize_t max8903_voltage_offset_usb_charger_store(struct device *dev,
 537                              struct device_attribute *attr, const char *buf,
 538                              size_t count)
 539 {
 540         int ret;
 541         unsigned long data;
 542
 543         ret = strict_strtoul(buf, 10, &data);
 544         offset_usb_charger = (int)data;
 545         pr_info("read offset_charger:%04d\n", offset_usb_charger);
 546
 547         return count;
 548 }
 549
 550 static struct device_attribute max8903_discharger_dev_attr = {
 551         .attr = {
 552                  .name = "max8903_ctl_offset_discharger",
 553                  .mode = S_IRUSR | S_IWUSR,
 554                  },
 555         .show = max8903_voltage_offset_discharger_show,
 556         .store = max8903_voltage_offset_discharger_store,
 557 };
 558
 559 static struct device_attribute max8903_charger_dev_attr = {
 560         .attr = {
 561                  .name = "max8903_ctl_offset_charger",
 562                  .mode = S_IRUSR | S_IWUSR,
 563                  },
 564         .show = max8903_voltage_offset_charger_show,
 565         .store = max8903_voltage_offset_charger_store,
 566 };
 567
 568 static struct device_attribute max8903_usb_charger_dev_attr = {
 569         .attr = {
 570                  .name = "max8903_ctl_offset_usb_charger",
 571                  .mode = S_IRUSR | S_IWUSR,
 572                  },
 573         .show = max8903_voltage_offset_usb_charger_show,
 574         .store = max8903_voltage_offset_usb_charger_store,
 575 };
 576
 577 #if defined(CONFIG_OF)
 578 static const struct of_device_id max8903_dt_ids[] = {
 579         { .compatible = "fsl,max8903-charger", },
 580         { /* sentinel */ }
 581 };
 582 MODULE_DEVICE_TABLE(of, max8903_dt_ids);
 583
 584 static struct max8903_pdata *max8903_of_populate_pdata(
 585                 struct device *dev)
 586 {
 587         struct device_node *of_node = dev->of_node;
 588         struct max8903_pdata *pdata = dev->platform_data;
 589
 590         if (!of_node || pdata)
 591                 return pdata;
 592
 593         pdata = devm_kzalloc(dev, sizeof(struct max8903_pdata),
 594                                 GFP_KERNEL);
 595         if (!pdata)
 596                 return pdata;
 597
 598         if (of_get_property(of_node, "fsl,dcm_always_high", NULL))
 599                 pdata->dcm_always_high = true;
 600         if (of_get_property(of_node, "fsl,dc_valid", NULL))
 601                 pdata->dc_valid = true;
 602         if (of_get_property(of_node, "fsl,usb_valid", NULL))
 603                 pdata->usb_valid = true;
 604         if (of_get_property(of_node, "fsl,adc_disable", NULL))
 605                 pdata->feature_flag = true;
 606
 607         if (pdata->dc_valid) {
 608                 pdata->dok = of_get_named_gpio(of_node, "dok_input", 0);
 609                 if (!gpio_is_valid(pdata->dok)) {
 610                         dev_err(dev, "pin pdata->dok: invalid gpio %d\n", pdata->dok);
 611                         return NULL;
 612                 }
 613         }
 614         if (pdata->usb_valid) {
 615                 pdata->uok = of_get_named_gpio(of_node, "uok_input", 0);
 616                 if (!gpio_is_valid(pdata->uok)) {
 617                         dev_err(dev, "pin pdata->uok: invalid gpio %d\n", pdata->uok);
 618                         return NULL;
 619                 }
 620         }
 621         pdata->chg = of_get_named_gpio(of_node, "chg_input", 0);
 622         if (!gpio_is_valid(pdata->chg)) {
 623                 dev_err(dev, "pin pdata->chg: invalid gpio %d\n", pdata->chg);
 624                 return NULL;
 625         }
 626         pdata->flt = of_get_named_gpio(of_node, "flt_input", 0);
 627         if (!gpio_is_valid(pdata->flt)) {
 628                 dev_err(dev, "pin pdata->flt: invalid gpio %d\n", pdata->flt);
 629                 return NULL;
 630         }
 631         /* no need check offset without adc converter */
 632         if (!pdata->feature_flag) {
 633                 if (of_property_read_u32(of_node, "offset-charger",
 634                         &offset_charger))
 635                         dev_err(dev, "Not setting offset-charger in dts!\n");
 636
 637                 if (of_property_read_u32(of_node, "offset-discharger",
 638                         &offset_discharger))
 639                         dev_err(dev, "Not setting offset-discharger in dts!\n");
 640
 641                 if (of_property_read_u32(of_node, "offset-usb-charger",
 642                         &offset_usb_charger))
 643                         dev_err(dev, "Not setting offset-usb-charger in dts!\n");
 644         }
 645
 646         return pdata;
 647 }
 648 #endif
 649
 650 static int max8903_probe(struct platform_device *pdev)
 651 {
 652         struct max8903_data *data;
 653         struct device *dev = &pdev->dev;
 654         struct max8903_pdata *pdata = pdev->dev.platform_data;
 655         int ret = 0;
 656         int gpio = 0;
 657         int ta_in = 0;
 658         int usb_in = 0;
 659         int retval;
 660
 661         data = devm_kzalloc(dev, sizeof(struct max8903_data), GFP_KERNEL);
 662         if (!data)
 663                 return -ENOMEM;
 664
 665         pdata = pdev->dev.platform_data;
 666         if (!pdata) {
 667                 pdata = max8903_of_populate_pdata(&pdev->dev);
 668                 if (!pdata)
 669                         return -EINVAL;
 670         }
 671
 672         data->first_delay_count = 0;
 673         data->pdata = pdata;
 674         data->dev = dev;
 675         data->usb_in = 0;
 676         data->ta_in = 0;
 677         platform_set_drvdata(pdev, data);
 678
 679         if (pdata->dc_valid == false && pdata->usb_valid == false) {
 680                 dev_err(dev, "No valid power sources.\n");
 681                 ret = -EINVAL;
 682                 goto err;
 683         }
 684         if (pdata->dc_valid) {
 685                 if (pdata->dok && pdata->dcm_always_high) {
 686                         gpio = pdata->dok;
 687                         ret = gpio_request_one(gpio, GPIOF_IN, "max8903-DOK");
 688                         if (ret) {
 689                                 dev_err(dev, "request max8903-DOK error!!\n");
 690                                 goto err;
 691                         }
 692                         ta_in = gpio_get_value(gpio) ? 0 : 1;
 693                 } else {
 694                         dev_err(dev, "When DC is wired, DOK and DCM should be"
 695                                 " wired as well or set dcm always high!\n");
 696                         ret = -EINVAL;
 697                         goto err;
 698                 }
 699         }
 700
 701         if (pdata->usb_valid) {
 702                 if (pdata->uok) {
 703                         gpio = pdata->uok;
 704                         ret = gpio_request_one(gpio, GPIOF_IN, "max8903-UOK");
 705                         if (ret) {
 706                                 dev_err(dev, "request max8903-UOK error!!\n");
 707                                 goto err;
 708                         }
 709                         usb_in = gpio_get_value(gpio) ? 0 : 1;
 710                 } else {
 711                         dev_err(dev, "When USB is wired, UOK should be wired"
 712                                 " as well.\n");
 713                         ret = -EINVAL;
 714                         goto err;
 715                 }
 716         }
 717
 718         if (pdata->chg) {
 719                 ret = gpio_request_one(pdata->chg, GPIOF_IN, "max8903-CHG");
 720                 if (ret) {
 721                         dev_err(dev, "request max8903-CHG error!!\n");
 722                         goto err;
 723                 }
 724         }
 725
 726         if (pdata->flt) {
 727                 ret = gpio_request_one(pdata->flt, GPIOF_IN, "max8903-FLT");
 728                 if (ret) {
 729                         dev_err(dev, "request max8903-FLT error!!\n");
 730                         goto err;
 731                 }
 732         }
 733
 734         data->fault = false;
 735         data->ta_in = ta_in;
 736         data->usb_in = usb_in;
 737         data->psy.name = "max8903-ac";
 738         data->psy.type = POWER_SUPPLY_TYPE_MAINS;
 739         data->psy.get_property = max8903_get_property;
 740         data->psy.properties = max8903_charger_props;
 741         data->psy.num_properties = ARRAY_SIZE(max8903_charger_props);
 742         ret = power_supply_register(dev, &data->psy);
 743         if (ret) {
 744                 dev_err(dev, "failed: power supply register.\n");
 745                 goto err_psy;
 746         }
 747
 748         data->usb.name = "max8903-usb";
 749         data->usb.type = POWER_SUPPLY_TYPE_USB;
 750         data->usb.get_property = max8903_get_usb_property;
 751         data->usb.properties = max8903_charger_props;
 752         data->usb.num_properties = ARRAY_SIZE(max8903_charger_props);
 753         ret = power_supply_register(dev, &data->usb);
 754         if (ret) {
 755                 dev_err(dev, "failed: power supply register.\n");
 756                 goto err_psy;
 757         }
 758
 759         data->bat.name = "max8903-charger";
 760         data->bat.type = POWER_SUPPLY_TYPE_BATTERY;
 761         data->bat.properties = max8903_battery_props;
 762         data->bat.num_properties = ARRAY_SIZE(max8903_battery_props);
 763         data->bat.get_property = max8903_battery_get_property;
 764         data->bat.use_for_apm = 1;
 765         retval = power_supply_register(&pdev->dev, &data->bat);
 766         if (retval) {
 767                 dev_err(data->dev, "failed to register battery\n");
 768                 goto battery_failed;
 769         }
 770
 771         INIT_DELAYED_WORK(&data->work, max8903_battery_work);
 772         schedule_delayed_work(&data->work, data->interval);
 773
 774         if (pdata->dc_valid) {
 775                 ret = request_threaded_irq(gpio_to_irq(pdata->dok), NULL,
 776                         max8903_dcin, IRQF_TRIGGER_FALLING |
 777                         IRQF_TRIGGER_RISING | IRQF_ONESHOT, "MAX8903 DC IN",
 778                         data);
 779                 if (ret) {
 780                         dev_err(dev, "Cannot request irq %d for DC (%d)\n",
 781                                         gpio_to_irq(pdata->dok), ret);
 782                         goto err_dc_irq;
 783                 }
 784         }
 785
 786         if (pdata->usb_valid) {
 787                 ret = request_threaded_irq(gpio_to_irq(pdata->uok), NULL,
 788                         max8903_usbin, IRQF_TRIGGER_FALLING |
 789                         IRQF_TRIGGER_RISING | IRQF_ONESHOT, "MAX8903 USB IN",
 790                         data);
 791                 if (ret) {
 792                         dev_err(dev, "Cannot request irq %d for USB (%d)\n",
 793                                         gpio_to_irq(pdata->uok), ret);
 794                         goto err_usb_irq;
 795                 }
 796         }
 797
 798         if (pdata->flt) {
 799                 ret = request_threaded_irq(gpio_to_irq(pdata->flt), NULL,
 800                         max8903_fault, IRQF_TRIGGER_FALLING |
 801                         IRQF_TRIGGER_RISING | IRQF_ONESHOT, "MAX8903 Fault",
 802                         data);
 803                 if (ret) {
 804                         dev_err(dev, "Cannot request irq %d for Fault (%d)\n",
 805                                         gpio_to_irq(pdata->flt), ret);
 806                         goto err_flt_irq;
 807                 }
 808         }
 809
 810         if (pdata->chg) {
 811                 ret = request_threaded_irq(gpio_to_irq(pdata->chg), NULL,
 812                         max8903_chg, IRQF_TRIGGER_FALLING |
 813                         IRQF_TRIGGER_RISING | IRQF_ONESHOT, "MAX8903 Status",
 814                         data);
 815                 if (ret) {
 816                         dev_err(dev, "Cannot request irq %d for Status (%d)\n",
 817                                         gpio_to_irq(pdata->flt), ret);
 818                         goto err_chg_irq;
 819                 }
 820         }
 821
 822         ret = device_create_file(&pdev->dev, &max8903_discharger_dev_attr);
 823         if (ret)
 824                 dev_err(&pdev->dev, "create device file failed!\n");
 825         ret = device_create_file(&pdev->dev, &max8903_charger_dev_attr);
 826         if (ret)
 827                 dev_err(&pdev->dev, "create device file failed!\n");
 828         ret = device_create_file(&pdev->dev, &max8903_usb_charger_dev_attr);
 829         if (ret)
 830                 dev_err(&pdev->dev, "create device file failed!\n");
 831
 832         device_set_wakeup_capable(&pdev->dev, true);
 833
 834         max8903_charger_update_status(data);
 835         max8903_battery_update_status(data);
 836
 837         return 0;
 838 err_psy:
 839         power_supply_unregister(&data->psy);
 840 battery_failed:
 841         power_supply_unregister(&data->bat);
 842 err_usb_irq:
 843         if (pdata->usb_valid)
 844                 free_irq(gpio_to_irq(pdata->uok), data);
 845         cancel_delayed_work(&data->work);
 846 err_dc_irq:
 847         if (pdata->dc_valid)
 848                 free_irq(gpio_to_irq(pdata->dok), data);
 849         cancel_delayed_work(&data->work);
 850 err_flt_irq:
 851         if (pdata->usb_valid)
 852                 free_irq(gpio_to_irq(pdata->uok), data);
 853         cancel_delayed_work(&data->work);
 854 err_chg_irq:
 855         if (pdata->dc_valid)
 856                 free_irq(gpio_to_irq(pdata->dok), data);
 857         cancel_delayed_work(&data->work);
 858 err:
 859         if (pdata->uok)
 860                 gpio_free(pdata->uok);
 861         if (pdata->dok)
 862                 gpio_free(pdata->dok);
 863         if (pdata->flt)
 864                 gpio_free(pdata->flt);
 865         if (pdata->chg)
 866                 gpio_free(pdata->chg);
 867         return ret;
 868 }
 869
 870 static int max8903_remove(struct platform_device *pdev)
 871 {
 872         struct max8903_data *data = platform_get_drvdata(pdev);
 873         if (data) {
 874                 struct max8903_pdata *pdata = data->pdata;
 875
 876                 cancel_delayed_work_sync(&data->work);
 877                 power_supply_unregister(&data->psy);
 878                 power_supply_unregister(&data->usb);
 879                 power_supply_unregister(&data->bat);
 880
 881                 if (pdata->flt) {
 882                         free_irq(gpio_to_irq(pdata->flt), data);
 883                         gpio_free(pdata->flt);
 884                 }
 885                 if (pdata->usb_valid && pdata->uok) {
 886                         free_irq(gpio_to_irq(pdata->uok), data);
 887                         gpio_free(pdata->uok);
 888                 }
 889                 if (pdata->dc_valid) {
 890                         if (pdata->dok) {
 891                                 free_irq(gpio_to_irq(pdata->dok), data);
 892                                 gpio_free(pdata->dok);
 893                         } else if (pdata->chg) {
 894                                 free_irq(gpio_to_irq(pdata->chg), data);
 895                                 gpio_free(pdata->chg);
 896                         }
 897                 }
 898
 899                 device_remove_file(&pdev->dev, &max8903_discharger_dev_attr);
 900                 device_remove_file(&pdev->dev, &max8903_charger_dev_attr);
 901                 device_remove_file(&pdev->dev, &max8903_usb_charger_dev_attr);
 902
 903                 platform_set_drvdata(pdev, NULL);
 904                 kfree(data);
 905         }
 906
 907         return 0;
 908 }
 909
 910 static int max8903_suspend(struct platform_device *pdev,
 911                                   pm_message_t state)
 912 {
 913         struct max8903_data *data = platform_get_drvdata(pdev);
 914         int irq;
 915         if (data) {
 916                 struct max8903_pdata *pdata = data->pdata;
 917                 if (pdata) {
 918                         if (pdata->dc_valid && device_may_wakeup(&pdev->dev)) {
 919                                 irq = gpio_to_irq(pdata->dok);
 920                                 enable_irq_wake(irq);
 921                         }
 922
 923                         if (pdata->usb_valid && device_may_wakeup(&pdev->dev)) {
 924                                 irq = gpio_to_irq(pdata->uok);
 925                                 enable_irq_wake(irq);
 926                         }
 927                         cancel_delayed_work(&data->work);
 928                 }
 929         }
 930         return 0;
 931 }
 932
 933 static int max8903_resume(struct platform_device *pdev)
 934 {
 935         struct max8903_data *data = platform_get_drvdata(pdev);
 936         bool ta_in = false;
 937         bool usb_in = false;
 938         int irq;
 939
 940         if (data) {
 941                 struct max8903_pdata *pdata = data->pdata;
 942
 943                 if (pdata) {
 944                         if (pdata->dok)
 945                                 ta_in = gpio_get_value(pdata->dok) ? false : true;
 946                         if (pdata->uok)
 947                                 usb_in = gpio_get_value(pdata->uok) ? false : true;
 948
 949                         if (ta_in != data->ta_in) {
 950                                 data->ta_in = ta_in;
 951                                 dev_info(data->dev, "TA(DC-IN) Charger %s.\n", ta_in ?
 952                                 "Connected" : "Disconnected");
 953                                 max8903_charger_update_status(data);
 954                                 power_supply_changed(&data->psy);
 955                         }
 956
 957                         if (usb_in != data->usb_in) {
 958                                 data->usb_in = usb_in;
 959                                 dev_info(data->dev, "USB Charger %s.\n", usb_in ?
 960                                 "Connected" : "Disconnected");
 961                                 max8903_charger_update_status(data);
 962                                 power_supply_changed(&data->usb);
 963                         }
 964
 965                         if (pdata->dc_valid && device_may_wakeup(&pdev->dev)) {
 966                                 irq = gpio_to_irq(pdata->dok);
 967                                 disable_irq_wake(irq);
 968                         }
 969                         if (pdata->usb_valid && device_may_wakeup(&pdev->dev)) {
 970                                 irq = gpio_to_irq(pdata->uok);
 971                                 disable_irq_wake(irq);
 972                         }
 973
 974                         schedule_delayed_work(&data->work,
 975                         BATTERY_UPDATE_INTERVAL);
 976                 }
 977         }
 978
 979         return 0;
 980 }
 981
 982 static struct platform_driver max8903_driver = {
 983         .probe  = max8903_probe,
 984         .remove = max8903_remove,
 985         .suspend = max8903_suspend,
 986         .resume = max8903_resume,
 987         .driver = {
 988                 .name   = "max8903-charger",
 989                 .owner  = THIS_MODULE,
 990                 .of_match_table = max8903_dt_ids,
 991         },
 992 };
 993 module_platform_driver(max8903_driver);
 994
 995 MODULE_LICENSE("GPL v2");
 996 MODULE_AUTHOR("Freescale Semiconductor, Inc.");
 997 MODULE_DESCRIPTION("Sabresd Battery Driver");
 998 MODULE_ALIAS("sabresd_battery");