drivers/power/max17042_battery.c

   1 /*
   2  * Fuel gauge driver for Maxim 17042 / 8966 / 8997
   3  *  Note that Maxim 8966 and 8997 are mfd and this is its subdevice.
   4  *
   5  * Copyright (C) 2011 Samsung Electronics
   6  * MyungJoo Ham <myungjoo.ham@samsung.com>
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21  *
  22  * This driver is based on max17040_battery.c
  23  */
  24
  25 #include <linux/init.h>
  26 #include <linux/module.h>
  27 #include <linux/slab.h>
  28 #include <linux/i2c.h>
  29 #include <linux/delay.h>
  30 #include <linux/interrupt.h>
  31 #include <linux/mod_devicetable.h>
  32 #include <linux/power_supply.h>
  33 #include <linux/power/max17042_battery.h>
  34 #include <linux/of.h>
  35
  36 /* Status register bits */
  37 #define STATUS_POR_BIT         (1 << 1)
  38 #define STATUS_BST_BIT         (1 << 3)
  39 #define STATUS_VMN_BIT         (1 << 8)
  40 #define STATUS_TMN_BIT         (1 << 9)
  41 #define STATUS_SMN_BIT         (1 << 10)
  42 #define STATUS_BI_BIT          (1 << 11)
  43 #define STATUS_VMX_BIT         (1 << 12)
  44 #define STATUS_TMX_BIT         (1 << 13)
  45 #define STATUS_SMX_BIT         (1 << 14)
  46 #define STATUS_BR_BIT          (1 << 15)
  47
  48 /* Interrupt mask bits */
  49 #define CONFIG_ALRT_BIT_ENBL    (1 << 2)
  50 #define STATUS_INTR_SOC_BIT     (1 << 14)
  51 #define STATUS_INTR_LOW_SOC_BIT (1 << 10)
  52
  53 #define VFSOC0_LOCK             0x0000
  54 #define VFSOC0_UNLOCK           0x0080
  55 #define MODEL_UNLOCK1   0X0059
  56 #define MODEL_UNLOCK2   0X00C4
  57 #define MODEL_LOCK1             0X0000
  58 #define MODEL_LOCK2             0X0000
  59
  60 #define dQ_ACC_DIV      0x4
  61 #define dP_ACC_100      0x1900
  62 #define dP_ACC_200      0x3200
  63
  64 struct max17042_chip {
  65         struct i2c_client *client;
  66         struct power_supply battery;
  67         struct max17042_platform_data *pdata;
  68         struct work_struct work;
  69         int    init_complete;
  70 };
  71
  72 static int max17042_write_reg(struct i2c_client *client, u8 reg, u16 value)
  73 {
  74         int ret = i2c_smbus_write_word_data(client, reg, value);
  75
  76         if (ret < 0)
  77                 dev_err(&client->dev, "%s: err %d\n", __func__, ret);
  78
  79         return ret;
  80 }
  81
  82 static int max17042_read_reg(struct i2c_client *client, u8 reg)
  83 {
  84         int ret = i2c_smbus_read_word_data(client, reg);
  85
  86         if (ret < 0)
  87                 dev_err(&client->dev, "%s: err %d\n", __func__, ret);
  88
  89         return ret;
  90 }
  91
  92 static void max17042_set_reg(struct i2c_client *client,
  93                              struct max17042_reg_data *data, int size)
  94 {
  95         int i;
  96
  97         for (i = 0; i < size; i++)
  98                 max17042_write_reg(client, data[i].addr, data[i].data);
  99 }
 100
 101 static enum power_supply_property max17042_battery_props[] = {
 102         POWER_SUPPLY_PROP_PRESENT,
 103         POWER_SUPPLY_PROP_CYCLE_COUNT,
 104         POWER_SUPPLY_PROP_VOLTAGE_MAX,
 105         POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
 106         POWER_SUPPLY_PROP_VOLTAGE_NOW,
 107         POWER_SUPPLY_PROP_VOLTAGE_AVG,
 108         POWER_SUPPLY_PROP_CAPACITY,
 109         POWER_SUPPLY_PROP_CHARGE_FULL,
 110         POWER_SUPPLY_PROP_TEMP,
 111         POWER_SUPPLY_PROP_CURRENT_NOW,
 112         POWER_SUPPLY_PROP_CURRENT_AVG,
 113 };
 114
 115 static int max17042_get_property(struct power_supply *psy,
 116                             enum power_supply_property psp,
 117                             union power_supply_propval *val)
 118 {
 119         struct max17042_chip *chip = container_of(psy,
 120                                 struct max17042_chip, battery);
 121         int ret;
 122
 123         if (!chip->init_complete)
 124                 return -EAGAIN;
 125
 126         switch (psp) {
 127         case POWER_SUPPLY_PROP_PRESENT:
 128                 ret = max17042_read_reg(chip->client, MAX17042_STATUS);
 129                 if (ret < 0)
 130                         return ret;
 131
 132                 if (ret & MAX17042_STATUS_BattAbsent)
 133                         val->intval = 0;
 134                 else
 135                         val->intval = 1;
 136                 break;
 137         case POWER_SUPPLY_PROP_CYCLE_COUNT:
 138                 ret = max17042_read_reg(chip->client, MAX17042_Cycles);
 139                 if (ret < 0)
 140                         return ret;
 141
 142                 val->intval = ret;
 143                 break;
 144         case POWER_SUPPLY_PROP_VOLTAGE_MAX:
 145                 ret = max17042_read_reg(chip->client, MAX17042_MinMaxVolt);
 146                 if (ret < 0)
 147                         return ret;
 148
 149                 val->intval = ret >> 8;
 150                 val->intval *= 20000; /* Units of LSB = 20mV */
 151                 break;
 152         case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
 153                 ret = max17042_read_reg(chip->client, MAX17042_V_empty);
 154                 if (ret < 0)
 155                         return ret;
 156
 157                 val->intval = ret >> 7;
 158                 val->intval *= 10000; /* Units of LSB = 10mV */
 159                 break;
 160         case POWER_SUPPLY_PROP_VOLTAGE_NOW:
 161                 ret = max17042_read_reg(chip->client, MAX17042_VCELL);
 162                 if (ret < 0)
 163                         return ret;
 164
 165                 val->intval = ret * 625 / 8;
 166                 break;
 167         case POWER_SUPPLY_PROP_VOLTAGE_AVG:
 168                 ret = max17042_read_reg(chip->client, MAX17042_AvgVCELL);
 169                 if (ret < 0)
 170                         return ret;
 171
 172                 val->intval = ret * 625 / 8;
 173                 break;
 174         case POWER_SUPPLY_PROP_CAPACITY:
 175                 ret = max17042_read_reg(chip->client, MAX17042_RepSOC);
 176                 if (ret < 0)
 177                         return ret;
 178
 179                 val->intval = ret >> 8;
 180                 break;
 181         case POWER_SUPPLY_PROP_CHARGE_FULL:
 182                 ret = max17042_read_reg(chip->client, MAX17042_RepSOC);
 183                 if (ret < 0)
 184                         return ret;
 185
 186                 if ((ret >> 8) >= MAX17042_BATTERY_FULL)
 187                         val->intval = 1;
 188                 else if (ret >= 0)
 189                         val->intval = 0;
 190                 break;
 191         case POWER_SUPPLY_PROP_TEMP:
 192                 ret = max17042_read_reg(chip->client, MAX17042_TEMP);
 193                 if (ret < 0)
 194                         return ret;
 195
 196                 val->intval = ret;
 197                 /* The value is signed. */
 198                 if (val->intval & 0x8000) {
 199                         val->intval = (0x7fff & ~val->intval) + 1;
 200                         val->intval *= -1;
 201                 }
 202                 /* The value is converted into deci-centigrade scale */
 203                 /* Units of LSB = 1 / 256 degree Celsius */
 204                 val->intval = val->intval * 10 / 256;
 205                 break;
 206         case POWER_SUPPLY_PROP_CURRENT_NOW:
 207                 if (chip->pdata->enable_current_sense) {
 208                         ret = max17042_read_reg(chip->client, MAX17042_Current);
 209                         if (ret < 0)
 210                                 return ret;
 211
 212                         val->intval = ret;
 213                         if (val->intval & 0x8000) {
 214                                 /* Negative */
 215                                 val->intval = ~val->intval & 0x7fff;
 216                                 val->intval++;
 217                                 val->intval *= -1;
 218                         }
 219                         val->intval *= 1562500 / chip->pdata->r_sns;
 220                 } else {
 221                         return -EINVAL;
 222                 }
 223                 break;
 224         case POWER_SUPPLY_PROP_CURRENT_AVG:
 225                 if (chip->pdata->enable_current_sense) {
 226                         ret = max17042_read_reg(chip->client,
 227                                                 MAX17042_AvgCurrent);
 228                         if (ret < 0)
 229                                 return ret;
 230
 231                         val->intval = ret;
 232                         if (val->intval & 0x8000) {
 233                                 /* Negative */
 234                                 val->intval = ~val->intval & 0x7fff;
 235                                 val->intval++;
 236                                 val->intval *= -1;
 237                         }
 238                         val->intval *= 1562500 / chip->pdata->r_sns;
 239                 } else {
 240                         return -EINVAL;
 241                 }
 242                 break;
 243         default:
 244                 return -EINVAL;
 245         }
 246         return 0;
 247 }
 248
 249 static int max17042_write_verify_reg(struct i2c_client *client,
 250                                 u8 reg, u16 value)
 251 {
 252         int retries = 8;
 253         int ret;
 254         u16 read_value;
 255
 256         do {
 257                 ret = i2c_smbus_write_word_data(client, reg, value);
 258                 read_value =  max17042_read_reg(client, reg);
 259                 if (read_value != value) {
 260                         ret = -EIO;
 261                         retries--;
 262                 }
 263         } while (retries && read_value != value);
 264
 265         if (ret < 0)
 266                 dev_err(&client->dev, "%s: err %d\n", __func__, ret);
 267
 268         return ret;
 269 }
 270
 271 static inline void max17042_override_por(
 272         struct i2c_client *client, u8 reg, u16 value)
 273 {
 274         if (value)
 275                 max17042_write_reg(client, reg, value);
 276 }
 277
 278 static inline void max10742_unlock_model(struct max17042_chip *chip)
 279 {
 280         struct i2c_client *client = chip->client;
 281         max17042_write_reg(client, MAX17042_MLOCKReg1, MODEL_UNLOCK1);
 282         max17042_write_reg(client, MAX17042_MLOCKReg2, MODEL_UNLOCK2);
 283 }
 284
 285 static inline void max10742_lock_model(struct max17042_chip *chip)
 286 {
 287         struct i2c_client *client = chip->client;
 288         max17042_write_reg(client, MAX17042_MLOCKReg1, MODEL_LOCK1);
 289         max17042_write_reg(client, MAX17042_MLOCKReg2, MODEL_LOCK2);
 290 }
 291
 292 static inline void max17042_write_model_data(struct max17042_chip *chip,
 293                                         u8 addr, int size)
 294 {
 295         struct i2c_client *client = chip->client;
 296         int i;
 297         for (i = 0; i < size; i++)
 298                 max17042_write_reg(client, addr + i,
 299                                 chip->pdata->config_data->cell_char_tbl[i]);
 300 }
 301
 302 static inline void max17042_read_model_data(struct max17042_chip *chip,
 303                                         u8 addr, u16 *data, int size)
 304 {
 305         struct i2c_client *client = chip->client;
 306         int i;
 307
 308         for (i = 0; i < size; i++)
 309                 data[i] = max17042_read_reg(client, addr + i);
 310 }
 311
 312 static inline int max17042_model_data_compare(struct max17042_chip *chip,
 313                                         u16 *data1, u16 *data2, int size)
 314 {
 315         int i;
 316
 317         if (memcmp(data1, data2, size)) {
 318                 dev_err(&chip->client->dev, "%s compare failed\n", __func__);
 319                 for (i = 0; i < size; i++)
 320                         dev_info(&chip->client->dev, "0x%x, 0x%x",
 321                                 data1[i], data2[i]);
 322                 dev_info(&chip->client->dev, "\n");
 323                 return -EINVAL;
 324         }
 325         return 0;
 326 }
 327
 328 static int max17042_init_model(struct max17042_chip *chip)
 329 {
 330         int ret;
 331         int table_size =
 332                 sizeof(chip->pdata->config_data->cell_char_tbl)/sizeof(u16);
 333         u16 *temp_data;
 334
 335         temp_data = kzalloc(table_size, GFP_KERNEL);
 336         if (!temp_data)
 337                 return -ENOMEM;
 338
 339         max10742_unlock_model(chip);
 340         max17042_write_model_data(chip, MAX17042_MODELChrTbl,
 341                                 table_size);
 342         max17042_read_model_data(chip, MAX17042_MODELChrTbl, temp_data,
 343                                 table_size);
 344
 345         ret = max17042_model_data_compare(
 346                 chip,
 347                 chip->pdata->config_data->cell_char_tbl,
 348                 temp_data,
 349                 table_size);
 350
 351         max10742_lock_model(chip);
 352         kfree(temp_data);
 353
 354         return ret;
 355 }
 356
 357 static int max17042_verify_model_lock(struct max17042_chip *chip)
 358 {
 359         int i;
 360         int table_size =
 361                 sizeof(chip->pdata->config_data->cell_char_tbl);
 362         u16 *temp_data;
 363         int ret = 0;
 364
 365         temp_data = kzalloc(table_size, GFP_KERNEL);
 366         if (!temp_data)
 367                 return -ENOMEM;
 368
 369         max17042_read_model_data(chip, MAX17042_MODELChrTbl, temp_data,
 370                                 table_size);
 371         for (i = 0; i < table_size; i++)
 372                 if (temp_data[i])
 373                         ret = -EINVAL;
 374
 375         kfree(temp_data);
 376         return ret;
 377 }
 378
 379 static void max17042_write_config_regs(struct max17042_chip *chip)
 380 {
 381         struct max17042_config_data *config = chip->pdata->config_data;
 382
 383         max17042_write_reg(chip->client, MAX17042_CONFIG, config->config);
 384         max17042_write_reg(chip->client, MAX17042_LearnCFG, config->learn_cfg);
 385         max17042_write_reg(chip->client, MAX17042_FilterCFG,
 386                         config->filter_cfg);
 387         max17042_write_reg(chip->client, MAX17042_RelaxCFG, config->relax_cfg);
 388 }
 389
 390 static void  max17042_write_custom_regs(struct max17042_chip *chip)
 391 {
 392         struct max17042_config_data *config = chip->pdata->config_data;
 393
 394         max17042_write_verify_reg(chip->client, MAX17042_RCOMP0,
 395                                 config->rcomp0);
 396         max17042_write_verify_reg(chip->client, MAX17042_TempCo,
 397                                 config->tcompc0);
 398         max17042_write_reg(chip->client, MAX17042_EmptyTempCo,
 399                         config->empty_tempco);
 400         max17042_write_verify_reg(chip->client, MAX17042_K_empty0,
 401                                 config->kempty0);
 402         max17042_write_verify_reg(chip->client, MAX17042_ICHGTerm,
 403                                 config->ichgt_term);
 404 }
 405
 406 static void max17042_update_capacity_regs(struct max17042_chip *chip)
 407 {
 408         struct max17042_config_data *config = chip->pdata->config_data;
 409
 410         max17042_write_verify_reg(chip->client, MAX17042_FullCAP,
 411                                 config->fullcap);
 412         max17042_write_reg(chip->client, MAX17042_DesignCap,
 413                         config->design_cap);
 414         max17042_write_verify_reg(chip->client, MAX17042_FullCAPNom,
 415                                 config->fullcapnom);
 416 }
 417
 418 static void max17042_reset_vfsoc0_reg(struct max17042_chip *chip)
 419 {
 420         u16 vfSoc;
 421
 422         vfSoc = max17042_read_reg(chip->client, MAX17042_VFSOC);
 423         max17042_write_reg(chip->client, MAX17042_VFSOC0Enable, VFSOC0_UNLOCK);
 424         max17042_write_verify_reg(chip->client, MAX17042_VFSOC0, vfSoc);
 425         max17042_write_reg(chip->client, MAX17042_VFSOC0Enable, VFSOC0_LOCK);
 426 }
 427
 428 static void max17042_load_new_capacity_params(struct max17042_chip *chip)
 429 {
 430         u16 full_cap0, rep_cap, dq_acc, vfSoc;
 431         u32 rem_cap;
 432
 433         struct max17042_config_data *config = chip->pdata->config_data;
 434
 435         full_cap0 = max17042_read_reg(chip->client, MAX17042_FullCAP0);
 436         vfSoc = max17042_read_reg(chip->client, MAX17042_VFSOC);
 437
 438         /* fg_vfSoc needs to shifted by 8 bits to get the
 439          * perc in 1% accuracy, to get the right rem_cap multiply
 440          * full_cap0, fg_vfSoc and devide by 100
 441          */
 442         rem_cap = ((vfSoc >> 8) * full_cap0) / 100;
 443         max17042_write_verify_reg(chip->client, MAX17042_RemCap, (u16)rem_cap);
 444
 445         rep_cap = (u16)rem_cap;
 446         max17042_write_verify_reg(chip->client, MAX17042_RepCap, rep_cap);
 447
 448         /* Write dQ_acc to 200% of Capacity and dP_acc to 200% */
 449         dq_acc = config->fullcap / dQ_ACC_DIV;
 450         max17042_write_verify_reg(chip->client, MAX17042_dQacc, dq_acc);
 451         max17042_write_verify_reg(chip->client, MAX17042_dPacc, dP_ACC_200);
 452
 453         max17042_write_verify_reg(chip->client, MAX17042_FullCAP,
 454                         config->fullcap);
 455         max17042_write_reg(chip->client, MAX17042_DesignCap,
 456                         config->design_cap);
 457         max17042_write_verify_reg(chip->client, MAX17042_FullCAPNom,
 458                         config->fullcapnom);
 459 }
 460
 461 /*
 462  * Block write all the override values coming from platform data.
 463  * This function MUST be called before the POR initialization proceedure
 464  * specified by maxim.
 465  */
 466 static inline void max17042_override_por_values(struct max17042_chip *chip)
 467 {
 468         struct i2c_client *client = chip->client;
 469         struct max17042_config_data *config = chip->pdata->config_data;
 470
 471         max17042_override_por(client, MAX17042_TGAIN, config->tgain);
 472         max17042_override_por(client, MAx17042_TOFF, config->toff);
 473         max17042_override_por(client, MAX17042_CGAIN, config->cgain);
 474         max17042_override_por(client, MAX17042_COFF, config->coff);
 475
 476         max17042_override_por(client, MAX17042_VALRT_Th, config->valrt_thresh);
 477         max17042_override_por(client, MAX17042_TALRT_Th, config->talrt_thresh);
 478         max17042_override_por(client, MAX17042_SALRT_Th,
 479                         config->soc_alrt_thresh);
 480         max17042_override_por(client, MAX17042_CONFIG, config->config);
 481         max17042_override_por(client, MAX17042_SHDNTIMER, config->shdntimer);
 482
 483         max17042_override_por(client, MAX17042_DesignCap, config->design_cap);
 484         max17042_override_por(client, MAX17042_ICHGTerm, config->ichgt_term);
 485
 486         max17042_override_por(client, MAX17042_AtRate, config->at_rate);
 487         max17042_override_por(client, MAX17042_LearnCFG, config->learn_cfg);
 488         max17042_override_por(client, MAX17042_FilterCFG, config->filter_cfg);
 489         max17042_override_por(client, MAX17042_RelaxCFG, config->relax_cfg);
 490         max17042_override_por(client, MAX17042_MiscCFG, config->misc_cfg);
 491         max17042_override_por(client, MAX17042_MaskSOC, config->masksoc);
 492
 493         max17042_override_por(client, MAX17042_FullCAP, config->fullcap);
 494         max17042_override_por(client, MAX17042_FullCAPNom, config->fullcapnom);
 495         max17042_override_por(client, MAX17042_SOC_empty, config->socempty);
 496         max17042_override_por(client, MAX17042_LAvg_empty, config->lavg_empty);
 497         max17042_override_por(client, MAX17042_dQacc, config->dqacc);
 498         max17042_override_por(client, MAX17042_dPacc, config->dpacc);
 499
 500         max17042_override_por(client, MAX17042_V_empty, config->vempty);
 501         max17042_override_por(client, MAX17042_TempNom, config->temp_nom);
 502         max17042_override_por(client, MAX17042_TempLim, config->temp_lim);
 503         max17042_override_por(client, MAX17042_FCTC, config->fctc);
 504         max17042_override_por(client, MAX17042_RCOMP0, config->rcomp0);
 505         max17042_override_por(client, MAX17042_TempCo, config->tcompc0);
 506         max17042_override_por(client, MAX17042_EmptyTempCo,
 507                         config->empty_tempco);
 508         max17042_override_por(client, MAX17042_K_empty0, config->kempty0);
 509 }
 510
 511 static int max17042_init_chip(struct max17042_chip *chip)
 512 {
 513         int ret;
 514         int val;
 515
 516         max17042_override_por_values(chip);
 517         /* After Power up, the MAX17042 requires 500mS in order
 518          * to perform signal debouncing and initial SOC reporting
 519          */
 520         msleep(500);
 521
 522         /* Initialize configaration */
 523         max17042_write_config_regs(chip);
 524
 525         /* write cell characterization data */
 526         ret = max17042_init_model(chip);
 527         if (ret) {
 528                 dev_err(&chip->client->dev, "%s init failed\n",
 529                         __func__);
 530                 return -EIO;
 531         }
 532         max17042_verify_model_lock(chip);
 533         if (ret) {
 534                 dev_err(&chip->client->dev, "%s lock verify failed\n",
 535                         __func__);
 536                 return -EIO;
 537         }
 538         /* write custom parameters */
 539         max17042_write_custom_regs(chip);
 540
 541         /* update capacity params */
 542         max17042_update_capacity_regs(chip);
 543
 544         /* delay must be atleast 350mS to allow VFSOC
 545          * to be calculated from the new configuration
 546          */
 547         msleep(350);
 548
 549         /* reset vfsoc0 reg */
 550         max17042_reset_vfsoc0_reg(chip);
 551
 552         /* load new capacity params */
 553         max17042_load_new_capacity_params(chip);
 554
 555         /* Init complete, Clear the POR bit */
 556         val = max17042_read_reg(chip->client, MAX17042_STATUS);
 557         max17042_write_reg(chip->client, MAX17042_STATUS,
 558                         val & (~STATUS_POR_BIT));
 559         return 0;
 560 }
 561
 562 static void max17042_set_soc_threshold(struct max17042_chip *chip, u16 off)
 563 {
 564         u16 soc, soc_tr;
 565
 566         /* program interrupt thesholds such that we should
 567          * get interrupt for every 'off' perc change in the soc
 568          */
 569         soc = max17042_read_reg(chip->client, MAX17042_RepSOC) >> 8;
 570         soc_tr = (soc + off) << 8;
 571         soc_tr |= (soc - off);
 572         max17042_write_reg(chip->client, MAX17042_SALRT_Th, soc_tr);
 573 }
 574
 575 static irqreturn_t max17042_intr_handler(int id, void *dev)
 576 {
 577         return IRQ_WAKE_THREAD;
 578 }
 579
 580 static irqreturn_t max17042_thread_handler(int id, void *dev)
 581 {
 582         struct max17042_chip *chip = dev;
 583         u16 val;
 584
 585         val = max17042_read_reg(chip->client, MAX17042_STATUS);
 586         if ((val & STATUS_INTR_SOC_BIT) ||
 587                 (val & STATUS_INTR_LOW_SOC_BIT)) {
 588                 dev_info(&chip->client->dev, "SOC threshold INTR\n");
 589                 max17042_set_soc_threshold(chip, 1);
 590         }
 591
 592         power_supply_changed(&chip->battery);
 593         return IRQ_HANDLED;
 594 }
 595
 596 static void max17042_init_worker(struct work_struct *work)
 597 {
 598         struct max17042_chip *chip = container_of(work,
 599                                 struct max17042_chip, work);
 600         int ret;
 601
 602         /* Initialize registers according to values from the platform data */
 603         if (chip->pdata->enable_por_init && chip->pdata->config_data) {
 604                 ret = max17042_init_chip(chip);
 605                 if (ret)
 606                         return;
 607         }
 608
 609         chip->init_complete = 1;
 610 }
 611
 612 #ifdef CONFIG_OF
 613 static struct max17042_platform_data *
 614 max17042_get_pdata(struct device *dev)
 615 {
 616         struct device_node *np = dev->of_node;
 617         u32 prop;
 618         struct max17042_platform_data *pdata;
 619
 620         if (!np)
 621                 return dev->platform_data;
 622
 623         pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
 624         if (!pdata)
 625                 return NULL;
 626
 627         /*
 628          * Require current sense resistor value to be specified for
 629          * current-sense functionality to be enabled at all.
 630          */
 631         if (of_property_read_u32(np, "maxim,rsns-microohm", &prop) == 0) {
 632                 pdata->r_sns = prop;
 633                 pdata->enable_current_sense = true;
 634         }
 635
 636         return pdata;
 637 }
 638 #else
 639 static struct max17042_platform_data *
 640 max17042_get_pdata(struct device *dev)
 641 {
 642         return dev->platform_data;
 643 }
 644 #endif
 645
 646 static int __devinit max17042_probe(struct i2c_client *client,
 647                         const struct i2c_device_id *id)
 648 {
 649         struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
 650         struct max17042_chip *chip;
 651         int ret;
 652         int reg;
 653
 654         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_WORD_DATA))
 655                 return -EIO;
 656
 657         chip = devm_kzalloc(&client->dev, sizeof(*chip), GFP_KERNEL);
 658         if (!chip)
 659                 return -ENOMEM;
 660
 661         chip->client = client;
 662         chip->pdata = max17042_get_pdata(&client->dev);
 663         if (!chip->pdata) {
 664                 dev_err(&client->dev, "no platform data provided\n");
 665                 return -EINVAL;
 666         }
 667
 668         i2c_set_clientdata(client, chip);
 669
 670         chip->battery.name              = "max17042_battery";
 671         chip->battery.type              = POWER_SUPPLY_TYPE_BATTERY;
 672         chip->battery.get_property      = max17042_get_property;
 673         chip->battery.properties        = max17042_battery_props;
 674         chip->battery.num_properties    = ARRAY_SIZE(max17042_battery_props);
 675
 676         /* When current is not measured,
 677          * CURRENT_NOW and CURRENT_AVG properties should be invisible. */
 678         if (!chip->pdata->enable_current_sense)
 679                 chip->battery.num_properties -= 2;
 680
 681         if (chip->pdata->r_sns == 0)
 682                 chip->pdata->r_sns = MAX17042_DEFAULT_SNS_RESISTOR;
 683
 684         if (chip->pdata->init_data)
 685                 max17042_set_reg(client, chip->pdata->init_data,
 686                                 chip->pdata->num_init_data);
 687
 688         if (!chip->pdata->enable_current_sense) {
 689                 max17042_write_reg(client, MAX17042_CGAIN, 0x0000);
 690                 max17042_write_reg(client, MAX17042_MiscCFG, 0x0003);
 691                 max17042_write_reg(client, MAX17042_LearnCFG, 0x0007);
 692         }
 693
 694         if (client->irq) {
 695                 ret = request_threaded_irq(client->irq, max17042_intr_handler,
 696                                                 max17042_thread_handler,
 697                                                 0, chip->battery.name, chip);
 698                 if (!ret) {
 699                         reg =  max17042_read_reg(client, MAX17042_CONFIG);
 700                         reg |= CONFIG_ALRT_BIT_ENBL;
 701                         max17042_write_reg(client, MAX17042_CONFIG, reg);
 702                         max17042_set_soc_threshold(chip, 1);
 703                 } else
 704                         dev_err(&client->dev, "%s(): cannot get IRQ\n",
 705                                 __func__);
 706         }
 707
 708         reg = max17042_read_reg(chip->client, MAX17042_STATUS);
 709
 710         if (reg & STATUS_POR_BIT) {
 711                 INIT_WORK(&chip->work, max17042_init_worker);
 712                 schedule_work(&chip->work);
 713         } else {
 714                 chip->init_complete = 1;
 715         }
 716
 717         ret = power_supply_register(&client->dev, &chip->battery);
 718         if (ret)
 719                 dev_err(&client->dev, "failed: power supply register\n");
 720         return ret;
 721 }
 722
 723 static int __devexit max17042_remove(struct i2c_client *client)
 724 {
 725         struct max17042_chip *chip = i2c_get_clientdata(client);
 726
 727         power_supply_unregister(&chip->battery);
 728         return 0;
 729 }
 730
 731 #ifdef CONFIG_OF
 732 static const struct of_device_id max17042_dt_match[] = {
 733         { .compatible = "maxim,max17042" },
 734         { },
 735 };
 736 MODULE_DEVICE_TABLE(of, max17042_dt_match);
 737 #endif
 738
 739 static const struct i2c_device_id max17042_id[] = {
 740         { "max17042", 0 },
 741         { }
 742 };
 743 MODULE_DEVICE_TABLE(i2c, max17042_id);
 744
 745 static struct i2c_driver max17042_i2c_driver = {
 746         .driver = {
 747                 .name   = "max17042",
 748                 .of_match_table = of_match_ptr(max17042_dt_match),
 749         },
 750         .probe          = max17042_probe,
 751         .remove         = __devexit_p(max17042_remove),
 752         .id_table       = max17042_id,
 753 };
 754
 755 static int __init max17042_init(void)
 756 {
 757         return i2c_add_driver(&max17042_i2c_driver);
 758 }
 759 module_init(max17042_init);
 760
 761 static void __exit max17042_exit(void)
 762 {
 763         i2c_del_driver(&max17042_i2c_driver);
 764 }
 765 module_exit(max17042_exit);
 766
 767 MODULE_AUTHOR("MyungJoo Ham <myungjoo.ham@samsung.com>");
 768 MODULE_DESCRIPTION("MAX17042 Fuel Gauge");
 769 MODULE_LICENSE("GPL");