drivers/power/supply/max17042

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
max17042_get_temperature
max17042_get_status
max17042_get_battery_health
max17042_get_property
max17042_set_property
max17042_property_is_writeable
max17042_external_power_changed
max17042_write_verify_reg
max17042_override_por
max17042_unlock_model
max17042_lock_model
max17042_write_model_data
max17042_read_model_data
max17042_model_data_compare
max17042_init_model
max17042_verify_model_lock
max17042_write_config_regs
max17042_write_custom_regs
max17042_update_capacity_regs
max17042_reset_vfsoc0_reg
max17042_load_new_capacity_params
max17042_override_por_values
max17042_init_chip
max17042_set_soc_threshold
max17042_thread_handler
max17042_init_worker
max17042_get_of_pdata
max17042_get_default_pdata
max17042_get_pdata
max17042_stop_work
max17042_probe
max17042_suspend
max17042_resume
   1 // SPDX-License-Identifier: GPL-2.0+
   2 //
   3 // Fuel gauge driver for Maxim 17042 / 8966 / 8997
   4 //  Note that Maxim 8966 and 8997 are mfd and this is its subdevice.
   5 //
   6 // Copyright (C) 2011 Samsung Electronics
   7 // MyungJoo Ham <myungjoo.ham@samsung.com>
   8 //
   9 // This driver is based on max17040_battery.c
  10 
  11 #include <linux/acpi.h>
  12 #include <linux/init.h>
  13 #include <linux/module.h>
  14 #include <linux/slab.h>
  15 #include <linux/i2c.h>
  16 #include <linux/delay.h>
  17 #include <linux/interrupt.h>
  18 #include <linux/pm.h>
  19 #include <linux/mod_devicetable.h>
  20 #include <linux/power_supply.h>
  21 #include <linux/power/max17042_battery.h>
  22 #include <linux/of.h>
  23 #include <linux/regmap.h>
  24 
  25 /* Status register bits */
  26 #define STATUS_POR_BIT         (1 << 1)
  27 #define STATUS_BST_BIT         (1 << 3)
  28 #define STATUS_VMN_BIT         (1 << 8)
  29 #define STATUS_TMN_BIT         (1 << 9)
  30 #define STATUS_SMN_BIT         (1 << 10)
  31 #define STATUS_BI_BIT          (1 << 11)
  32 #define STATUS_VMX_BIT         (1 << 12)
  33 #define STATUS_TMX_BIT         (1 << 13)
  34 #define STATUS_SMX_BIT         (1 << 14)
  35 #define STATUS_BR_BIT          (1 << 15)
  36 
  37 /* Interrupt mask bits */
  38 #define CONFIG_ALRT_BIT_ENBL    (1 << 2)
  39 #define STATUS_INTR_SOCMIN_BIT  (1 << 10)
  40 #define STATUS_INTR_SOCMAX_BIT  (1 << 14)
  41 
  42 #define VFSOC0_LOCK             0x0000
  43 #define VFSOC0_UNLOCK           0x0080
  44 #define MODEL_UNLOCK1   0X0059
  45 #define MODEL_UNLOCK2   0X00C4
  46 #define MODEL_LOCK1             0X0000
  47 #define MODEL_LOCK2             0X0000
  48 
  49 #define dQ_ACC_DIV      0x4
  50 #define dP_ACC_100      0x1900
  51 #define dP_ACC_200      0x3200
  52 
  53 #define MAX17042_VMAX_TOLERANCE         50 /* 50 mV */
  54 
  55 struct max17042_chip {
  56         struct i2c_client *client;
  57         struct regmap *regmap;
  58         struct power_supply *battery;
  59         enum max170xx_chip_type chip_type;
  60         struct max17042_platform_data *pdata;
  61         struct work_struct work;
  62         int    init_complete;
  63 };
  64 
  65 static enum power_supply_property max17042_battery_props[] = {
  66         POWER_SUPPLY_PROP_STATUS,
  67         POWER_SUPPLY_PROP_PRESENT,
  68         POWER_SUPPLY_PROP_TECHNOLOGY,
  69         POWER_SUPPLY_PROP_CYCLE_COUNT,
  70         POWER_SUPPLY_PROP_VOLTAGE_MAX,
  71         POWER_SUPPLY_PROP_VOLTAGE_MIN,
  72         POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
  73         POWER_SUPPLY_PROP_VOLTAGE_NOW,
  74         POWER_SUPPLY_PROP_VOLTAGE_AVG,
  75         POWER_SUPPLY_PROP_VOLTAGE_OCV,
  76         POWER_SUPPLY_PROP_CAPACITY,
  77         POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
  78         POWER_SUPPLY_PROP_CHARGE_FULL,
  79         POWER_SUPPLY_PROP_CHARGE_NOW,
  80         POWER_SUPPLY_PROP_CHARGE_COUNTER,
  81         POWER_SUPPLY_PROP_TEMP,
  82         POWER_SUPPLY_PROP_TEMP_ALERT_MIN,
  83         POWER_SUPPLY_PROP_TEMP_ALERT_MAX,
  84         POWER_SUPPLY_PROP_TEMP_MIN,
  85         POWER_SUPPLY_PROP_TEMP_MAX,
  86         POWER_SUPPLY_PROP_HEALTH,
  87         POWER_SUPPLY_PROP_SCOPE,
  88         POWER_SUPPLY_PROP_CURRENT_NOW,
  89         POWER_SUPPLY_PROP_CURRENT_AVG,
  90 };
  91 
  92 static int max17042_get_temperature(struct max17042_chip *chip, int *temp)
  93 {
  94         int ret;
  95         u32 data;
  96         struct regmap *map = chip->regmap;
  97 
  98         ret = regmap_read(map, MAX17042_TEMP, &data);
  99         if (ret < 0)
 100                 return ret;
 101 
 102         *temp = sign_extend32(data, 15);
 103         /* The value is converted into deci-centigrade scale */
 104         /* Units of LSB = 1 / 256 degree Celsius */
 105         *temp = *temp * 10 / 256;
 106         return 0;
 107 }
 108 
 109 static int max17042_get_status(struct max17042_chip *chip, int *status)
 110 {
 111         int ret, charge_full, charge_now;
 112         int avg_current;
 113         u32 data;
 114 
 115         ret = power_supply_am_i_supplied(chip->battery);
 116         if (ret < 0) {
 117                 *status = POWER_SUPPLY_STATUS_UNKNOWN;
 118                 return 0;
 119         }
 120         if (ret == 0) {
 121                 *status = POWER_SUPPLY_STATUS_DISCHARGING;
 122                 return 0;
 123         }
 124 
 125         /*
 126          * The MAX170xx has builtin end-of-charge detection and will update
 127          * FullCAP to match RepCap when it detects end of charging.
 128          *
 129          * When this cycle the battery gets charged to a higher (calculated)
 130          * capacity then the previous cycle then FullCAP will get updated
 131          * contineously once end-of-charge detection kicks in, so allow the
 132          * 2 to differ a bit.
 133          */
 134 
 135         ret = regmap_read(chip->regmap, MAX17042_FullCAP, &charge_full);
 136         if (ret < 0)
 137                 return ret;
 138 
 139         ret = regmap_read(chip->regmap, MAX17042_RepCap, &charge_now);
 140         if (ret < 0)
 141                 return ret;
 142 
 143         if ((charge_full - charge_now) <= MAX17042_FULL_THRESHOLD) {
 144                 *status = POWER_SUPPLY_STATUS_FULL;
 145                 return 0;
 146         }
 147 
 148         /*
 149          * Even though we are supplied, we may still be discharging if the
 150          * supply is e.g. only delivering 5V 0.5A. Check current if available.
 151          */
 152         if (!chip->pdata->enable_current_sense) {
 153                 *status = POWER_SUPPLY_STATUS_CHARGING;
 154                 return 0;
 155         }
 156 
 157         ret = regmap_read(chip->regmap, MAX17042_AvgCurrent, &data);
 158         if (ret < 0)
 159                 return ret;
 160 
 161         avg_current = sign_extend32(data, 15);
 162         avg_current *= 1562500 / chip->pdata->r_sns;
 163 
 164         if (avg_current > 0)
 165                 *status = POWER_SUPPLY_STATUS_CHARGING;
 166         else
 167                 *status = POWER_SUPPLY_STATUS_DISCHARGING;
 168 
 169         return 0;
 170 }
 171 
 172 static int max17042_get_battery_health(struct max17042_chip *chip, int *health)
 173 {
 174         int temp, vavg, vbatt, ret;
 175         u32 val;
 176 
 177         ret = regmap_read(chip->regmap, MAX17042_AvgVCELL, &val);
 178         if (ret < 0)
 179                 goto health_error;
 180 
 181         /* bits [0-3] unused */
 182         vavg = val * 625 / 8;
 183         /* Convert to millivolts */
 184         vavg /= 1000;
 185 
 186         ret = regmap_read(chip->regmap, MAX17042_VCELL, &val);
 187         if (ret < 0)
 188                 goto health_error;
 189 
 190         /* bits [0-3] unused */
 191         vbatt = val * 625 / 8;
 192         /* Convert to millivolts */
 193         vbatt /= 1000;
 194 
 195         if (vavg < chip->pdata->vmin) {
 196                 *health = POWER_SUPPLY_HEALTH_DEAD;
 197                 goto out;
 198         }
 199 
 200         if (vbatt > chip->pdata->vmax + MAX17042_VMAX_TOLERANCE) {
 201                 *health = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
 202                 goto out;
 203         }
 204 
 205         ret = max17042_get_temperature(chip, &temp);
 206         if (ret < 0)
 207                 goto health_error;
 208 
 209         if (temp < chip->pdata->temp_min) {
 210                 *health = POWER_SUPPLY_HEALTH_COLD;
 211                 goto out;
 212         }
 213 
 214         if (temp > chip->pdata->temp_max) {
 215                 *health = POWER_SUPPLY_HEALTH_OVERHEAT;
 216                 goto out;
 217         }
 218 
 219         *health = POWER_SUPPLY_HEALTH_GOOD;
 220 
 221 out:
 222         return 0;
 223 
 224 health_error:
 225         return ret;
 226 }
 227 
 228 static int max17042_get_property(struct power_supply *psy,
 229                             enum power_supply_property psp,
 230                             union power_supply_propval *val)
 231 {
 232         struct max17042_chip *chip = power_supply_get_drvdata(psy);
 233         struct regmap *map = chip->regmap;
 234         int ret;
 235         u32 data;
 236         u64 data64;
 237 
 238         if (!chip->init_complete)
 239                 return -EAGAIN;
 240 
 241         switch (psp) {
 242         case POWER_SUPPLY_PROP_STATUS:
 243                 ret = max17042_get_status(chip, &val->intval);
 244                 if (ret < 0)
 245                         return ret;
 246                 break;
 247         case POWER_SUPPLY_PROP_PRESENT:
 248                 ret = regmap_read(map, MAX17042_STATUS, &data);
 249                 if (ret < 0)
 250                         return ret;
 251 
 252                 if (data & MAX17042_STATUS_BattAbsent)
 253                         val->intval = 0;
 254                 else
 255                         val->intval = 1;
 256                 break;
 257         case POWER_SUPPLY_PROP_TECHNOLOGY:
 258                 val->intval = POWER_SUPPLY_TECHNOLOGY_LION;
 259                 break;
 260         case POWER_SUPPLY_PROP_CYCLE_COUNT:
 261                 ret = regmap_read(map, MAX17042_Cycles, &data);
 262                 if (ret < 0)
 263                         return ret;
 264 
 265                 val->intval = data;
 266                 break;
 267         case POWER_SUPPLY_PROP_VOLTAGE_MAX:
 268                 ret = regmap_read(map, MAX17042_MinMaxVolt, &data);
 269                 if (ret < 0)
 270                         return ret;
 271 
 272                 val->intval = data >> 8;
 273                 val->intval *= 20000; /* Units of LSB = 20mV */
 274                 break;
 275         case POWER_SUPPLY_PROP_VOLTAGE_MIN:
 276                 ret = regmap_read(map, MAX17042_MinMaxVolt, &data);
 277                 if (ret < 0)
 278                         return ret;
 279 
 280                 val->intval = (data & 0xff) * 20000; /* Units of 20mV */
 281                 break;
 282         case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
 283                 if (chip->chip_type == MAXIM_DEVICE_TYPE_MAX17042)
 284                         ret = regmap_read(map, MAX17042_V_empty, &data);
 285                 else
 286                         ret = regmap_read(map, MAX17047_V_empty, &data);
 287                 if (ret < 0)
 288                         return ret;
 289 
 290                 val->intval = data >> 7;
 291                 val->intval *= 10000; /* Units of LSB = 10mV */
 292                 break;
 293         case POWER_SUPPLY_PROP_VOLTAGE_NOW:
 294                 ret = regmap_read(map, MAX17042_VCELL, &data);
 295                 if (ret < 0)
 296                         return ret;
 297 
 298                 val->intval = data * 625 / 8;
 299                 break;
 300         case POWER_SUPPLY_PROP_VOLTAGE_AVG:
 301                 ret = regmap_read(map, MAX17042_AvgVCELL, &data);
 302                 if (ret < 0)
 303                         return ret;
 304 
 305                 val->intval = data * 625 / 8;
 306                 break;
 307         case POWER_SUPPLY_PROP_VOLTAGE_OCV:
 308                 ret = regmap_read(map, MAX17042_OCVInternal, &data);
 309                 if (ret < 0)
 310                         return ret;
 311 
 312                 val->intval = data * 625 / 8;
 313                 break;
 314         case POWER_SUPPLY_PROP_CAPACITY:
 315                 ret = regmap_read(map, MAX17042_RepSOC, &data);
 316                 if (ret < 0)
 317                         return ret;
 318 
 319                 val->intval = data >> 8;
 320                 break;
 321         case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
 322                 ret = regmap_read(map, MAX17042_DesignCap, &data);
 323                 if (ret < 0)
 324                         return ret;
 325 
 326                 data64 = data * 5000000ll;
 327                 do_div(data64, chip->pdata->r_sns);
 328                 val->intval = data64;
 329                 break;
 330         case POWER_SUPPLY_PROP_CHARGE_FULL:
 331                 ret = regmap_read(map, MAX17042_FullCAP, &data);
 332                 if (ret < 0)
 333                         return ret;
 334 
 335                 data64 = data * 5000000ll;
 336                 do_div(data64, chip->pdata->r_sns);
 337                 val->intval = data64;
 338                 break;
 339         case POWER_SUPPLY_PROP_CHARGE_NOW:
 340                 ret = regmap_read(map, MAX17042_RepCap, &data);
 341                 if (ret < 0)
 342                         return ret;
 343 
 344                 data64 = data * 5000000ll;
 345                 do_div(data64, chip->pdata->r_sns);
 346                 val->intval = data64;
 347                 break;
 348         case POWER_SUPPLY_PROP_CHARGE_COUNTER:
 349                 ret = regmap_read(map, MAX17042_QH, &data);
 350                 if (ret < 0)
 351                         return ret;
 352 
 353                 val->intval = data * 1000 / 2;
 354                 break;
 355         case POWER_SUPPLY_PROP_TEMP:
 356                 ret = max17042_get_temperature(chip, &val->intval);
 357                 if (ret < 0)
 358                         return ret;
 359                 break;
 360         case POWER_SUPPLY_PROP_TEMP_ALERT_MIN:
 361                 ret = regmap_read(map, MAX17042_TALRT_Th, &data);
 362                 if (ret < 0)
 363                         return ret;
 364                 /* LSB is Alert Minimum. In deci-centigrade */
 365                 val->intval = sign_extend32(data & 0xff, 7) * 10;
 366                 break;
 367         case POWER_SUPPLY_PROP_TEMP_ALERT_MAX:
 368                 ret = regmap_read(map, MAX17042_TALRT_Th, &data);
 369                 if (ret < 0)
 370                         return ret;
 371                 /* MSB is Alert Maximum. In deci-centigrade */
 372                 val->intval = sign_extend32(data >> 8, 7) * 10;
 373                 break;
 374         case POWER_SUPPLY_PROP_TEMP_MIN:
 375                 val->intval = chip->pdata->temp_min;
 376                 break;
 377         case POWER_SUPPLY_PROP_TEMP_MAX:
 378                 val->intval = chip->pdata->temp_max;
 379                 break;
 380         case POWER_SUPPLY_PROP_HEALTH:
 381                 ret = max17042_get_battery_health(chip, &val->intval);
 382                 if (ret < 0)
 383                         return ret;
 384                 break;
 385         case POWER_SUPPLY_PROP_SCOPE:
 386                 val->intval = POWER_SUPPLY_SCOPE_SYSTEM;
 387                 break;
 388         case POWER_SUPPLY_PROP_CURRENT_NOW:
 389                 if (chip->pdata->enable_current_sense) {
 390                         ret = regmap_read(map, MAX17042_Current, &data);
 391                         if (ret < 0)
 392                                 return ret;
 393 
 394                         val->intval = sign_extend32(data, 15);
 395                         val->intval *= 1562500 / chip->pdata->r_sns;
 396                 } else {
 397                         return -EINVAL;
 398                 }
 399                 break;
 400         case POWER_SUPPLY_PROP_CURRENT_AVG:
 401                 if (chip->pdata->enable_current_sense) {
 402                         ret = regmap_read(map, MAX17042_AvgCurrent, &data);
 403                         if (ret < 0)
 404                                 return ret;
 405 
 406                         val->intval = sign_extend32(data, 15);
 407                         val->intval *= 1562500 / chip->pdata->r_sns;
 408                 } else {
 409                         return -EINVAL;
 410                 }
 411                 break;
 412         default:
 413                 return -EINVAL;
 414         }
 415         return 0;
 416 }
 417 
 418 static int max17042_set_property(struct power_supply *psy,
 419                             enum power_supply_property psp,
 420                             const union power_supply_propval *val)
 421 {
 422         struct max17042_chip *chip = power_supply_get_drvdata(psy);
 423         struct regmap *map = chip->regmap;
 424         int ret = 0;
 425         u32 data;
 426         int8_t temp;
 427 
 428         switch (psp) {
 429         case POWER_SUPPLY_PROP_TEMP_ALERT_MIN:
 430                 ret = regmap_read(map, MAX17042_TALRT_Th, &data);
 431                 if (ret < 0)
 432                         return ret;
 433 
 434                 /* Input in deci-centigrade, convert to centigrade */
 435                 temp = val->intval / 10;
 436                 /* force min < max */
 437                 if (temp >= (int8_t)(data >> 8))
 438                         temp = (int8_t)(data >> 8) - 1;
 439                 /* Write both MAX and MIN ALERT */
 440                 data = (data & 0xff00) + temp;
 441                 ret = regmap_write(map, MAX17042_TALRT_Th, data);
 442                 break;
 443         case POWER_SUPPLY_PROP_TEMP_ALERT_MAX:
 444                 ret = regmap_read(map, MAX17042_TALRT_Th, &data);
 445                 if (ret < 0)
 446                         return ret;
 447 
 448                 /* Input in Deci-Centigrade, convert to centigrade */
 449                 temp = val->intval / 10;
 450                 /* force max > min */
 451                 if (temp <= (int8_t)(data & 0xff))
 452                         temp = (int8_t)(data & 0xff) + 1;
 453                 /* Write both MAX and MIN ALERT */
 454                 data = (data & 0xff) + (temp << 8);
 455                 ret = regmap_write(map, MAX17042_TALRT_Th, data);
 456                 break;
 457         default:
 458                 ret = -EINVAL;
 459         }
 460 
 461         return ret;
 462 }
 463 
 464 static int max17042_property_is_writeable(struct power_supply *psy,
 465                 enum power_supply_property psp)
 466 {
 467         int ret;
 468 
 469         switch (psp) {
 470         case POWER_SUPPLY_PROP_TEMP_ALERT_MIN:
 471         case POWER_SUPPLY_PROP_TEMP_ALERT_MAX:
 472                 ret = 1;
 473                 break;
 474         default:
 475                 ret = 0;
 476         }
 477 
 478         return ret;
 479 }
 480 
 481 static void max17042_external_power_changed(struct power_supply *psy)
 482 {
 483         power_supply_changed(psy);
 484 }
 485 
 486 static int max17042_write_verify_reg(struct regmap *map, u8 reg, u32 value)
 487 {
 488         int retries = 8;
 489         int ret;
 490         u32 read_value;
 491 
 492         do {
 493                 ret = regmap_write(map, reg, value);
 494                 regmap_read(map, reg, &read_value);
 495                 if (read_value != value) {
 496                         ret = -EIO;
 497                         retries--;
 498                 }
 499         } while (retries && read_value != value);
 500 
 501         if (ret < 0)
 502                 pr_err("%s: err %d\n", __func__, ret);
 503 
 504         return ret;
 505 }
 506 
 507 static inline void max17042_override_por(struct regmap *map,
 508                                          u8 reg, u16 value)
 509 {
 510         if (value)
 511                 regmap_write(map, reg, value);
 512 }
 513 
 514 static inline void max17042_unlock_model(struct max17042_chip *chip)
 515 {
 516         struct regmap *map = chip->regmap;
 517 
 518         regmap_write(map, MAX17042_MLOCKReg1, MODEL_UNLOCK1);
 519         regmap_write(map, MAX17042_MLOCKReg2, MODEL_UNLOCK2);
 520 }
 521 
 522 static inline void max17042_lock_model(struct max17042_chip *chip)
 523 {
 524         struct regmap *map = chip->regmap;
 525 
 526         regmap_write(map, MAX17042_MLOCKReg1, MODEL_LOCK1);
 527         regmap_write(map, MAX17042_MLOCKReg2, MODEL_LOCK2);
 528 }
 529 
 530 static inline void max17042_write_model_data(struct max17042_chip *chip,
 531                                         u8 addr, int size)
 532 {
 533         struct regmap *map = chip->regmap;
 534         int i;
 535 
 536         for (i = 0; i < size; i++)
 537                 regmap_write(map, addr + i,
 538                         chip->pdata->config_data->cell_char_tbl[i]);
 539 }
 540 
 541 static inline void max17042_read_model_data(struct max17042_chip *chip,
 542                                         u8 addr, u16 *data, int size)
 543 {
 544         struct regmap *map = chip->regmap;
 545         int i;
 546         u32 tmp;
 547 
 548         for (i = 0; i < size; i++) {
 549                 regmap_read(map, addr + i, &tmp);
 550                 data[i] = (u16)tmp;
 551         }
 552 }
 553 
 554 static inline int max17042_model_data_compare(struct max17042_chip *chip,
 555                                         u16 *data1, u16 *data2, int size)
 556 {
 557         int i;
 558 
 559         if (memcmp(data1, data2, size)) {
 560                 dev_err(&chip->client->dev, "%s compare failed\n", __func__);
 561                 for (i = 0; i < size; i++)
 562                         dev_info(&chip->client->dev, "0x%x, 0x%x",
 563                                 data1[i], data2[i]);
 564                 dev_info(&chip->client->dev, "\n");
 565                 return -EINVAL;
 566         }
 567         return 0;
 568 }
 569 
 570 static int max17042_init_model(struct max17042_chip *chip)
 571 {
 572         int ret;
 573         int table_size = ARRAY_SIZE(chip->pdata->config_data->cell_char_tbl);
 574         u16 *temp_data;
 575 
 576         temp_data = kcalloc(table_size, sizeof(*temp_data), GFP_KERNEL);
 577         if (!temp_data)
 578                 return -ENOMEM;
 579 
 580         max17042_unlock_model(chip);
 581         max17042_write_model_data(chip, MAX17042_MODELChrTbl,
 582                                 table_size);
 583         max17042_read_model_data(chip, MAX17042_MODELChrTbl, temp_data,
 584                                 table_size);
 585 
 586         ret = max17042_model_data_compare(
 587                 chip,
 588                 chip->pdata->config_data->cell_char_tbl,
 589                 temp_data,
 590                 table_size);
 591 
 592         max17042_lock_model(chip);
 593         kfree(temp_data);
 594 
 595         return ret;
 596 }
 597 
 598 static int max17042_verify_model_lock(struct max17042_chip *chip)
 599 {
 600         int i;
 601         int table_size = ARRAY_SIZE(chip->pdata->config_data->cell_char_tbl);
 602         u16 *temp_data;
 603         int ret = 0;
 604 
 605         temp_data = kcalloc(table_size, sizeof(*temp_data), GFP_KERNEL);
 606         if (!temp_data)
 607                 return -ENOMEM;
 608 
 609         max17042_read_model_data(chip, MAX17042_MODELChrTbl, temp_data,
 610                                 table_size);
 611         for (i = 0; i < table_size; i++)
 612                 if (temp_data[i])
 613                         ret = -EINVAL;
 614 
 615         kfree(temp_data);
 616         return ret;
 617 }
 618 
 619 static void max17042_write_config_regs(struct max17042_chip *chip)
 620 {
 621         struct max17042_config_data *config = chip->pdata->config_data;
 622         struct regmap *map = chip->regmap;
 623 
 624         regmap_write(map, MAX17042_CONFIG, config->config);
 625         regmap_write(map, MAX17042_LearnCFG, config->learn_cfg);
 626         regmap_write(map, MAX17042_FilterCFG,
 627                         config->filter_cfg);
 628         regmap_write(map, MAX17042_RelaxCFG, config->relax_cfg);
 629         if (chip->chip_type == MAXIM_DEVICE_TYPE_MAX17047 ||
 630                         chip->chip_type == MAXIM_DEVICE_TYPE_MAX17050)
 631                 regmap_write(map, MAX17047_FullSOCThr,
 632                                                 config->full_soc_thresh);
 633 }
 634 
 635 static void  max17042_write_custom_regs(struct max17042_chip *chip)
 636 {
 637         struct max17042_config_data *config = chip->pdata->config_data;
 638         struct regmap *map = chip->regmap;
 639 
 640         max17042_write_verify_reg(map, MAX17042_RCOMP0, config->rcomp0);
 641         max17042_write_verify_reg(map, MAX17042_TempCo, config->tcompc0);
 642         max17042_write_verify_reg(map, MAX17042_ICHGTerm, config->ichgt_term);
 643         if (chip->chip_type == MAXIM_DEVICE_TYPE_MAX17042) {
 644                 regmap_write(map, MAX17042_EmptyTempCo, config->empty_tempco);
 645                 max17042_write_verify_reg(map, MAX17042_K_empty0,
 646                                         config->kempty0);
 647         } else {
 648                 max17042_write_verify_reg(map, MAX17047_QRTbl00,
 649                                                 config->qrtbl00);
 650                 max17042_write_verify_reg(map, MAX17047_QRTbl10,
 651                                                 config->qrtbl10);
 652                 max17042_write_verify_reg(map, MAX17047_QRTbl20,
 653                                                 config->qrtbl20);
 654                 max17042_write_verify_reg(map, MAX17047_QRTbl30,
 655                                                 config->qrtbl30);
 656         }
 657 }
 658 
 659 static void max17042_update_capacity_regs(struct max17042_chip *chip)
 660 {
 661         struct max17042_config_data *config = chip->pdata->config_data;
 662         struct regmap *map = chip->regmap;
 663 
 664         max17042_write_verify_reg(map, MAX17042_FullCAP,
 665                                 config->fullcap);
 666         regmap_write(map, MAX17042_DesignCap, config->design_cap);
 667         max17042_write_verify_reg(map, MAX17042_FullCAPNom,
 668                                 config->fullcapnom);
 669 }
 670 
 671 static void max17042_reset_vfsoc0_reg(struct max17042_chip *chip)
 672 {
 673         unsigned int vfSoc;
 674         struct regmap *map = chip->regmap;
 675 
 676         regmap_read(map, MAX17042_VFSOC, &vfSoc);
 677         regmap_write(map, MAX17042_VFSOC0Enable, VFSOC0_UNLOCK);
 678         max17042_write_verify_reg(map, MAX17042_VFSOC0, vfSoc);
 679         regmap_write(map, MAX17042_VFSOC0Enable, VFSOC0_LOCK);
 680 }
 681 
 682 static void max17042_load_new_capacity_params(struct max17042_chip *chip)
 683 {
 684         u32 full_cap0, rep_cap, dq_acc, vfSoc;
 685         u32 rem_cap;
 686 
 687         struct max17042_config_data *config = chip->pdata->config_data;
 688         struct regmap *map = chip->regmap;
 689 
 690         regmap_read(map, MAX17042_FullCAP0, &full_cap0);
 691         regmap_read(map, MAX17042_VFSOC, &vfSoc);
 692 
 693         /* fg_vfSoc needs to shifted by 8 bits to get the
 694          * perc in 1% accuracy, to get the right rem_cap multiply
 695          * full_cap0, fg_vfSoc and devide by 100
 696          */
 697         rem_cap = ((vfSoc >> 8) * full_cap0) / 100;
 698         max17042_write_verify_reg(map, MAX17042_RemCap, rem_cap);
 699 
 700         rep_cap = rem_cap;
 701         max17042_write_verify_reg(map, MAX17042_RepCap, rep_cap);
 702 
 703         /* Write dQ_acc to 200% of Capacity and dP_acc to 200% */
 704         dq_acc = config->fullcap / dQ_ACC_DIV;
 705         max17042_write_verify_reg(map, MAX17042_dQacc, dq_acc);
 706         max17042_write_verify_reg(map, MAX17042_dPacc, dP_ACC_200);
 707 
 708         max17042_write_verify_reg(map, MAX17042_FullCAP,
 709                         config->fullcap);
 710         regmap_write(map, MAX17042_DesignCap,
 711                         config->design_cap);
 712         max17042_write_verify_reg(map, MAX17042_FullCAPNom,
 713                         config->fullcapnom);
 714         /* Update SOC register with new SOC */
 715         regmap_write(map, MAX17042_RepSOC, vfSoc);
 716 }
 717 
 718 /*
 719  * Block write all the override values coming from platform data.
 720  * This function MUST be called before the POR initialization proceedure
 721  * specified by maxim.
 722  */
 723 static inline void max17042_override_por_values(struct max17042_chip *chip)
 724 {
 725         struct regmap *map = chip->regmap;
 726         struct max17042_config_data *config = chip->pdata->config_data;
 727 
 728         max17042_override_por(map, MAX17042_TGAIN, config->tgain);
 729         max17042_override_por(map, MAx17042_TOFF, config->toff);
 730         max17042_override_por(map, MAX17042_CGAIN, config->cgain);
 731         max17042_override_por(map, MAX17042_COFF, config->coff);
 732 
 733         max17042_override_por(map, MAX17042_VALRT_Th, config->valrt_thresh);
 734         max17042_override_por(map, MAX17042_TALRT_Th, config->talrt_thresh);
 735         max17042_override_por(map, MAX17042_SALRT_Th,
 736                                                 config->soc_alrt_thresh);
 737         max17042_override_por(map, MAX17042_CONFIG, config->config);
 738         max17042_override_por(map, MAX17042_SHDNTIMER, config->shdntimer);
 739 
 740         max17042_override_por(map, MAX17042_DesignCap, config->design_cap);
 741         max17042_override_por(map, MAX17042_ICHGTerm, config->ichgt_term);
 742 
 743         max17042_override_por(map, MAX17042_AtRate, config->at_rate);
 744         max17042_override_por(map, MAX17042_LearnCFG, config->learn_cfg);
 745         max17042_override_por(map, MAX17042_FilterCFG, config->filter_cfg);
 746         max17042_override_por(map, MAX17042_RelaxCFG, config->relax_cfg);
 747         max17042_override_por(map, MAX17042_MiscCFG, config->misc_cfg);
 748         max17042_override_por(map, MAX17042_MaskSOC, config->masksoc);
 749 
 750         max17042_override_por(map, MAX17042_FullCAP, config->fullcap);
 751         max17042_override_por(map, MAX17042_FullCAPNom, config->fullcapnom);
 752         if (chip->chip_type == MAXIM_DEVICE_TYPE_MAX17042)
 753                 max17042_override_por(map, MAX17042_SOC_empty,
 754                                                 config->socempty);
 755         max17042_override_por(map, MAX17042_LAvg_empty, config->lavg_empty);
 756         max17042_override_por(map, MAX17042_dQacc, config->dqacc);
 757         max17042_override_por(map, MAX17042_dPacc, config->dpacc);
 758 
 759         if (chip->chip_type == MAXIM_DEVICE_TYPE_MAX17042)
 760                 max17042_override_por(map, MAX17042_V_empty, config->vempty);
 761         else
 762                 max17042_override_por(map, MAX17047_V_empty, config->vempty);
 763         max17042_override_por(map, MAX17042_TempNom, config->temp_nom);
 764         max17042_override_por(map, MAX17042_TempLim, config->temp_lim);
 765         max17042_override_por(map, MAX17042_FCTC, config->fctc);
 766         max17042_override_por(map, MAX17042_RCOMP0, config->rcomp0);
 767         max17042_override_por(map, MAX17042_TempCo, config->tcompc0);
 768         if (chip->chip_type) {
 769                 max17042_override_por(map, MAX17042_EmptyTempCo,
 770                                                 config->empty_tempco);
 771                 max17042_override_por(map, MAX17042_K_empty0,
 772                                                 config->kempty0);
 773         }
 774 }
 775 
 776 static int max17042_init_chip(struct max17042_chip *chip)
 777 {
 778         struct regmap *map = chip->regmap;
 779         int ret;
 780 
 781         max17042_override_por_values(chip);
 782         /* After Power up, the MAX17042 requires 500mS in order
 783          * to perform signal debouncing and initial SOC reporting
 784          */
 785         msleep(500);
 786 
 787         /* Initialize configaration */
 788         max17042_write_config_regs(chip);
 789 
 790         /* write cell characterization data */
 791         ret = max17042_init_model(chip);
 792         if (ret) {
 793                 dev_err(&chip->client->dev, "%s init failed\n",
 794                         __func__);
 795                 return -EIO;
 796         }
 797 
 798         ret = max17042_verify_model_lock(chip);
 799         if (ret) {
 800                 dev_err(&chip->client->dev, "%s lock verify failed\n",
 801                         __func__);
 802                 return -EIO;
 803         }
 804         /* write custom parameters */
 805         max17042_write_custom_regs(chip);
 806 
 807         /* update capacity params */
 808         max17042_update_capacity_regs(chip);
 809 
 810         /* delay must be atleast 350mS to allow VFSOC
 811          * to be calculated from the new configuration
 812          */
 813         msleep(350);
 814 
 815         /* reset vfsoc0 reg */
 816         max17042_reset_vfsoc0_reg(chip);
 817 
 818         /* load new capacity params */
 819         max17042_load_new_capacity_params(chip);
 820 
 821         /* Init complete, Clear the POR bit */
 822         regmap_update_bits(map, MAX17042_STATUS, STATUS_POR_BIT, 0x0);
 823         return 0;
 824 }
 825 
 826 static void max17042_set_soc_threshold(struct max17042_chip *chip, u16 off)
 827 {
 828         struct regmap *map = chip->regmap;
 829         u32 soc, soc_tr;
 830 
 831         /* program interrupt thesholds such that we should
 832          * get interrupt for every 'off' perc change in the soc
 833          */
 834         regmap_read(map, MAX17042_RepSOC, &soc);
 835         soc >>= 8;
 836         soc_tr = (soc + off) << 8;
 837         soc_tr |= (soc - off);
 838         regmap_write(map, MAX17042_SALRT_Th, soc_tr);
 839 }
 840 
 841 static irqreturn_t max17042_thread_handler(int id, void *dev)
 842 {
 843         struct max17042_chip *chip = dev;
 844         u32 val;
 845 
 846         regmap_read(chip->regmap, MAX17042_STATUS, &val);
 847         if ((val & STATUS_INTR_SOCMIN_BIT) ||
 848                 (val & STATUS_INTR_SOCMAX_BIT)) {
 849                 dev_info(&chip->client->dev, "SOC threshold INTR\n");
 850                 max17042_set_soc_threshold(chip, 1);
 851         }
 852 
 853         power_supply_changed(chip->battery);
 854         return IRQ_HANDLED;
 855 }
 856 
 857 static void max17042_init_worker(struct work_struct *work)
 858 {
 859         struct max17042_chip *chip = container_of(work,
 860                                 struct max17042_chip, work);
 861         int ret;
 862 
 863         /* Initialize registers according to values from the platform data */
 864         if (chip->pdata->enable_por_init && chip->pdata->config_data) {
 865                 ret = max17042_init_chip(chip);
 866                 if (ret)
 867                         return;
 868         }
 869 
 870         chip->init_complete = 1;
 871 }
 872 
 873 #ifdef CONFIG_OF
 874 static struct max17042_platform_data *
 875 max17042_get_of_pdata(struct max17042_chip *chip)
 876 {
 877         struct device *dev = &chip->client->dev;
 878         struct device_node *np = dev->of_node;
 879         u32 prop;
 880         struct max17042_platform_data *pdata;
 881 
 882         pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
 883         if (!pdata)
 884                 return NULL;
 885 
 886         /*
 887          * Require current sense resistor value to be specified for
 888          * current-sense functionality to be enabled at all.
 889          */
 890         if (of_property_read_u32(np, "maxim,rsns-microohm", &prop) == 0) {
 891                 pdata->r_sns = prop;
 892                 pdata->enable_current_sense = true;
 893         }
 894 
 895         if (of_property_read_s32(np, "maxim,cold-temp", &pdata->temp_min))
 896                 pdata->temp_min = INT_MIN;
 897         if (of_property_read_s32(np, "maxim,over-heat-temp", &pdata->temp_max))
 898                 pdata->temp_max = INT_MAX;
 899         if (of_property_read_s32(np, "maxim,dead-volt", &pdata->vmin))
 900                 pdata->vmin = INT_MIN;
 901         if (of_property_read_s32(np, "maxim,over-volt", &pdata->vmax))
 902                 pdata->vmax = INT_MAX;
 903 
 904         return pdata;
 905 }
 906 #endif
 907 
 908 static struct max17042_reg_data max17047_default_pdata_init_regs[] = {
 909         /*
 910          * Some firmwares do not set FullSOCThr, Enable End-of-Charge Detection
 911          * when the voltage FG reports 95%, as recommended in the datasheet.
 912          */
 913         { MAX17047_FullSOCThr, MAX17042_BATTERY_FULL << 8 },
 914 };
 915 
 916 static struct max17042_platform_data *
 917 max17042_get_default_pdata(struct max17042_chip *chip)
 918 {
 919         struct device *dev = &chip->client->dev;
 920         struct max17042_platform_data *pdata;
 921         int ret, misc_cfg;
 922 
 923         /*
 924          * The MAX17047 gets used on x86 where we might not have pdata, assume
 925          * the firmware will already have initialized the fuel-gauge and provide
 926          * default values for the non init bits to make things work.
 927          */
 928         pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
 929         if (!pdata)
 930                 return pdata;
 931 
 932         if (chip->chip_type != MAXIM_DEVICE_TYPE_MAX17042) {
 933                 pdata->init_data = max17047_default_pdata_init_regs;
 934                 pdata->num_init_data =
 935                         ARRAY_SIZE(max17047_default_pdata_init_regs);
 936         }
 937 
 938         ret = regmap_read(chip->regmap, MAX17042_MiscCFG, &misc_cfg);
 939         if (ret < 0)
 940                 return NULL;
 941 
 942         /* If bits 0-1 are set to 3 then only Voltage readings are used */
 943         if ((misc_cfg & 0x3) == 0x3)
 944                 pdata->enable_current_sense = false;
 945         else
 946                 pdata->enable_current_sense = true;
 947 
 948         pdata->vmin = MAX17042_DEFAULT_VMIN;
 949         pdata->vmax = MAX17042_DEFAULT_VMAX;
 950         pdata->temp_min = MAX17042_DEFAULT_TEMP_MIN;
 951         pdata->temp_max = MAX17042_DEFAULT_TEMP_MAX;
 952 
 953         return pdata;
 954 }
 955 
 956 static struct max17042_platform_data *
 957 max17042_get_pdata(struct max17042_chip *chip)
 958 {
 959         struct device *dev = &chip->client->dev;
 960 
 961 #ifdef CONFIG_OF
 962         if (dev->of_node)
 963                 return max17042_get_of_pdata(chip);
 964 #endif
 965         if (dev->platform_data)
 966                 return dev->platform_data;
 967 
 968         return max17042_get_default_pdata(chip);
 969 }
 970 
 971 static const struct regmap_config max17042_regmap_config = {
 972         .reg_bits = 8,
 973         .val_bits = 16,
 974         .val_format_endian = REGMAP_ENDIAN_NATIVE,
 975 };
 976 
 977 static const struct power_supply_desc max17042_psy_desc = {
 978         .name           = "max170xx_battery",
 979         .type           = POWER_SUPPLY_TYPE_BATTERY,
 980         .get_property   = max17042_get_property,
 981         .set_property   = max17042_set_property,
 982         .property_is_writeable  = max17042_property_is_writeable,
 983         .external_power_changed = max17042_external_power_changed,
 984         .properties     = max17042_battery_props,
 985         .num_properties = ARRAY_SIZE(max17042_battery_props),
 986 };
 987 
 988 static const struct power_supply_desc max17042_no_current_sense_psy_desc = {
 989         .name           = "max170xx_battery",
 990         .type           = POWER_SUPPLY_TYPE_BATTERY,
 991         .get_property   = max17042_get_property,
 992         .set_property   = max17042_set_property,
 993         .property_is_writeable  = max17042_property_is_writeable,
 994         .properties     = max17042_battery_props,
 995         .num_properties = ARRAY_SIZE(max17042_battery_props) - 2,
 996 };
 997 
 998 static void max17042_stop_work(void *data)
 999 {
1000         struct max17042_chip *chip = data;
1001 
1002         cancel_work_sync(&chip->work);
1003 }
1004 
1005 static int max17042_probe(struct i2c_client *client,
1006                         const struct i2c_device_id *id)
1007 {
1008         struct i2c_adapter *adapter = client->adapter;
1009         const struct power_supply_desc *max17042_desc = &max17042_psy_desc;
1010         struct power_supply_config psy_cfg = {};
1011         const struct acpi_device_id *acpi_id = NULL;
1012         struct device *dev = &client->dev;
1013         struct max17042_chip *chip;
1014         int ret;
1015         int i;
1016         u32 val;
1017 
1018         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_WORD_DATA))
1019                 return -EIO;
1020 
1021         chip = devm_kzalloc(&client->dev, sizeof(*chip), GFP_KERNEL);
1022         if (!chip)
1023                 return -ENOMEM;
1024 
1025         chip->client = client;
1026         if (id) {
1027                 chip->chip_type = id->driver_data;
1028         } else {
1029                 acpi_id = acpi_match_device(dev->driver->acpi_match_table, dev);
1030                 if (!acpi_id)
1031                         return -ENODEV;
1032 
1033                 chip->chip_type = acpi_id->driver_data;
1034         }
1035         chip->regmap = devm_regmap_init_i2c(client, &max17042_regmap_config);
1036         if (IS_ERR(chip->regmap)) {
1037                 dev_err(&client->dev, "Failed to initialize regmap\n");
1038                 return -EINVAL;
1039         }
1040 
1041         chip->pdata = max17042_get_pdata(chip);
1042         if (!chip->pdata) {
1043                 dev_err(&client->dev, "no platform data provided\n");
1044                 return -EINVAL;
1045         }
1046 
1047         i2c_set_clientdata(client, chip);
1048         psy_cfg.drv_data = chip;
1049         psy_cfg.of_node = dev->of_node;
1050 
1051         /* When current is not measured,
1052          * CURRENT_NOW and CURRENT_AVG properties should be invisible. */
1053         if (!chip->pdata->enable_current_sense)
1054                 max17042_desc = &max17042_no_current_sense_psy_desc;
1055 
1056         if (chip->pdata->r_sns == 0)
1057                 chip->pdata->r_sns = MAX17042_DEFAULT_SNS_RESISTOR;
1058 
1059         if (chip->pdata->init_data)
1060                 for (i = 0; i < chip->pdata->num_init_data; i++)
1061                         regmap_write(chip->regmap,
1062                                         chip->pdata->init_data[i].addr,
1063                                         chip->pdata->init_data[i].data);
1064 
1065         if (!chip->pdata->enable_current_sense) {
1066                 regmap_write(chip->regmap, MAX17042_CGAIN, 0x0000);
1067                 regmap_write(chip->regmap, MAX17042_MiscCFG, 0x0003);
1068                 regmap_write(chip->regmap, MAX17042_LearnCFG, 0x0007);
1069         }
1070 
1071         chip->battery = devm_power_supply_register(&client->dev, max17042_desc,
1072                                                    &psy_cfg);
1073         if (IS_ERR(chip->battery)) {
1074                 dev_err(&client->dev, "failed: power supply register\n");
1075                 return PTR_ERR(chip->battery);
1076         }
1077 
1078         if (client->irq) {
1079                 unsigned int flags = IRQF_TRIGGER_FALLING | IRQF_ONESHOT;
1080 
1081                 /*
1082                  * On ACPI systems the IRQ may be handled by ACPI-event code,
1083                  * so we need to share (if the ACPI code is willing to share).
1084                  */
1085                 if (acpi_id)
1086                         flags |= IRQF_SHARED | IRQF_PROBE_SHARED;
1087 
1088                 ret = devm_request_threaded_irq(&client->dev, client->irq,
1089                                                 NULL,
1090                                                 max17042_thread_handler, flags,
1091                                                 chip->battery->desc->name,
1092                                                 chip);
1093                 if (!ret) {
1094                         regmap_update_bits(chip->regmap, MAX17042_CONFIG,
1095                                         CONFIG_ALRT_BIT_ENBL,
1096                                         CONFIG_ALRT_BIT_ENBL);
1097                         max17042_set_soc_threshold(chip, 1);
1098                 } else {
1099                         client->irq = 0;
1100                         if (ret != -EBUSY)
1101                                 dev_err(&client->dev, "Failed to get IRQ\n");
1102                 }
1103         }
1104         /* Not able to update the charge threshold when exceeded? -> disable */
1105         if (!client->irq)
1106                 regmap_write(chip->regmap, MAX17042_SALRT_Th, 0xff00);
1107 
1108         regmap_read(chip->regmap, MAX17042_STATUS, &val);
1109         if (val & STATUS_POR_BIT) {
1110                 INIT_WORK(&chip->work, max17042_init_worker);
1111                 ret = devm_add_action(&client->dev, max17042_stop_work, chip);
1112                 if (ret)
1113                         return ret;
1114                 schedule_work(&chip->work);
1115         } else {
1116                 chip->init_complete = 1;
1117         }
1118 
1119         return 0;
1120 }
1121 
1122 #ifdef CONFIG_PM_SLEEP
1123 static int max17042_suspend(struct device *dev)
1124 {
1125         struct max17042_chip *chip = dev_get_drvdata(dev);
1126 
1127         /*
1128          * disable the irq and enable irq_wake
1129          * capability to the interrupt line.
1130          */
1131         if (chip->client->irq) {
1132                 disable_irq(chip->client->irq);
1133                 enable_irq_wake(chip->client->irq);
1134         }
1135 
1136         return 0;
1137 }
1138 
1139 static int max17042_resume(struct device *dev)
1140 {
1141         struct max17042_chip *chip = dev_get_drvdata(dev);
1142 
1143         if (chip->client->irq) {
1144                 disable_irq_wake(chip->client->irq);
1145                 enable_irq(chip->client->irq);
1146                 /* re-program the SOC thresholds to 1% change */
1147                 max17042_set_soc_threshold(chip, 1);
1148         }
1149 
1150         return 0;
1151 }
1152 #endif
1153 
1154 static SIMPLE_DEV_PM_OPS(max17042_pm_ops, max17042_suspend,
1155                         max17042_resume);
1156 
1157 #ifdef CONFIG_ACPI
1158 static const struct acpi_device_id max17042_acpi_match[] = {
1159         { "MAX17047", MAXIM_DEVICE_TYPE_MAX17047 },
1160         { }
1161 };
1162 MODULE_DEVICE_TABLE(acpi, max17042_acpi_match);
1163 #endif
1164 
1165 #ifdef CONFIG_OF
1166 static const struct of_device_id max17042_dt_match[] = {
1167         { .compatible = "maxim,max17042" },
1168         { .compatible = "maxim,max17047" },
1169         { .compatible = "maxim,max17050" },
1170         { },
1171 };
1172 MODULE_DEVICE_TABLE(of, max17042_dt_match);
1173 #endif
1174 
1175 static const struct i2c_device_id max17042_id[] = {
1176         { "max17042", MAXIM_DEVICE_TYPE_MAX17042 },
1177         { "max17047", MAXIM_DEVICE_TYPE_MAX17047 },
1178         { "max17050", MAXIM_DEVICE_TYPE_MAX17050 },
1179         { }
1180 };
1181 MODULE_DEVICE_TABLE(i2c, max17042_id);
1182 
1183 static struct i2c_driver max17042_i2c_driver = {
1184         .driver = {
1185                 .name   = "max17042",
1186                 .acpi_match_table = ACPI_PTR(max17042_acpi_match),
1187                 .of_match_table = of_match_ptr(max17042_dt_match),
1188                 .pm     = &max17042_pm_ops,
1189         },
1190         .probe          = max17042_probe,
1191         .id_table       = max17042_id,
1192 };
1193 module_i2c_driver(max17042_i2c_driver);
1194 
1195 MODULE_AUTHOR("MyungJoo Ham <myungjoo.ham@samsung.com>");
1196 MODULE_DESCRIPTION("MAX17042 Fuel Gauge");
1197 MODULE_LICENSE("GPL");
/* [<][>][^][v][top][bottom][index][help] */
root/drivers/power/supply/max17042_battery.c

DEFINITIONS
