2 * Fuel gauge driver for Maxim 17042 / 8966 / 8997
3 * Note that Maxim 8966 and 8997 are mfd and this is its subdevice.
5 * Copyright (C) 2011 Samsung Electronics
6 * MyungJoo Ham <myungjoo.ham@samsung.com>
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.
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.
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
22 * This driver is based on max17040_battery.c
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>
32 #include <linux/mod_devicetable.h>
33 #include <linux/power_supply.h>
34 #include <linux/power/max17042_battery.h>
36 #include <linux/regmap.h>
38 /* Status register bits */
39 #define STATUS_POR_BIT (1 << 1)
40 #define STATUS_BST_BIT (1 << 3)
41 #define STATUS_VMN_BIT (1 << 8)
42 #define STATUS_TMN_BIT (1 << 9)
43 #define STATUS_SMN_BIT (1 << 10)
44 #define STATUS_BI_BIT (1 << 11)
45 #define STATUS_VMX_BIT (1 << 12)
46 #define STATUS_TMX_BIT (1 << 13)
47 #define STATUS_SMX_BIT (1 << 14)
48 #define STATUS_BR_BIT (1 << 15)
50 /* Interrupt mask bits */
51 #define CONFIG_ALRT_BIT_ENBL (1 << 2)
52 #define STATUS_INTR_SOCMIN_BIT (1 << 10)
53 #define STATUS_INTR_SOCMAX_BIT (1 << 14)
55 #define VFSOC0_LOCK 0x0000
56 #define VFSOC0_UNLOCK 0x0080
57 #define MODEL_UNLOCK1 0X0059
58 #define MODEL_UNLOCK2 0X00C4
59 #define MODEL_LOCK1 0X0000
60 #define MODEL_LOCK2 0X0000
62 #define dQ_ACC_DIV 0x4
63 #define dP_ACC_100 0x1900
64 #define dP_ACC_200 0x3200
66 #define MAX17042_VMAX_TOLERANCE 50 /* 50 mV */
68 struct max17042_chip {
69 struct i2c_client *client;
70 struct regmap *regmap;
71 struct power_supply *battery;
72 enum max170xx_chip_type chip_type;
73 struct max17042_platform_data *pdata;
74 struct work_struct work;
78 static enum power_supply_property max17042_battery_props[] = {
79 POWER_SUPPLY_PROP_PRESENT,
80 POWER_SUPPLY_PROP_CYCLE_COUNT,
81 POWER_SUPPLY_PROP_VOLTAGE_MAX,
82 POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
83 POWER_SUPPLY_PROP_VOLTAGE_NOW,
84 POWER_SUPPLY_PROP_VOLTAGE_AVG,
85 POWER_SUPPLY_PROP_VOLTAGE_OCV,
86 POWER_SUPPLY_PROP_CAPACITY,
87 POWER_SUPPLY_PROP_CHARGE_FULL,
88 POWER_SUPPLY_PROP_CHARGE_COUNTER,
89 POWER_SUPPLY_PROP_TEMP,
90 POWER_SUPPLY_PROP_TEMP_ALERT_MIN,
91 POWER_SUPPLY_PROP_TEMP_ALERT_MAX,
92 POWER_SUPPLY_PROP_TEMP_MIN,
93 POWER_SUPPLY_PROP_TEMP_MAX,
94 POWER_SUPPLY_PROP_HEALTH,
95 POWER_SUPPLY_PROP_CURRENT_NOW,
96 POWER_SUPPLY_PROP_CURRENT_AVG,
99 static int max17042_get_temperature(struct max17042_chip *chip, int *temp)
103 struct regmap *map = chip->regmap;
105 ret = regmap_read(map, MAX17042_TEMP, &data);
110 /* The value is signed. */
111 if (*temp & 0x8000) {
112 *temp = (0x7fff & ~*temp) + 1;
116 /* The value is converted into deci-centigrade scale */
117 /* Units of LSB = 1 / 256 degree Celsius */
118 *temp = *temp * 10 / 256;
122 static int max17042_get_battery_health(struct max17042_chip *chip, int *health)
124 int temp, vavg, vbatt, ret;
127 ret = regmap_read(chip->regmap, MAX17042_AvgVCELL, &val);
131 /* bits [0-3] unused */
132 vavg = val * 625 / 8;
133 /* Convert to millivolts */
136 ret = regmap_read(chip->regmap, MAX17042_VCELL, &val);
140 /* bits [0-3] unused */
141 vbatt = val * 625 / 8;
142 /* Convert to millivolts */
145 if (vavg < chip->pdata->vmin) {
146 *health = POWER_SUPPLY_HEALTH_DEAD;
150 if (vbatt > chip->pdata->vmax + MAX17042_VMAX_TOLERANCE) {
151 *health = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
155 ret = max17042_get_temperature(chip, &temp);
159 if (temp <= chip->pdata->temp_min) {
160 *health = POWER_SUPPLY_HEALTH_COLD;
164 if (temp >= chip->pdata->temp_max) {
165 *health = POWER_SUPPLY_HEALTH_OVERHEAT;
169 *health = POWER_SUPPLY_HEALTH_GOOD;
178 static int max17042_get_property(struct power_supply *psy,
179 enum power_supply_property psp,
180 union power_supply_propval *val)
182 struct max17042_chip *chip = power_supply_get_drvdata(psy);
183 struct regmap *map = chip->regmap;
187 if (!chip->init_complete)
191 case POWER_SUPPLY_PROP_PRESENT:
192 ret = regmap_read(map, MAX17042_STATUS, &data);
196 if (data & MAX17042_STATUS_BattAbsent)
201 case POWER_SUPPLY_PROP_CYCLE_COUNT:
202 ret = regmap_read(map, MAX17042_Cycles, &data);
208 case POWER_SUPPLY_PROP_VOLTAGE_MAX:
209 ret = regmap_read(map, MAX17042_MinMaxVolt, &data);
213 val->intval = data >> 8;
214 val->intval *= 20000; /* Units of LSB = 20mV */
216 case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
217 if (chip->chip_type == MAXIM_DEVICE_TYPE_MAX17042)
218 ret = regmap_read(map, MAX17042_V_empty, &data);
220 ret = regmap_read(map, MAX17047_V_empty, &data);
224 val->intval = data >> 7;
225 val->intval *= 10000; /* Units of LSB = 10mV */
227 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
228 ret = regmap_read(map, MAX17042_VCELL, &data);
232 val->intval = data * 625 / 8;
234 case POWER_SUPPLY_PROP_VOLTAGE_AVG:
235 ret = regmap_read(map, MAX17042_AvgVCELL, &data);
239 val->intval = data * 625 / 8;
241 case POWER_SUPPLY_PROP_VOLTAGE_OCV:
242 ret = regmap_read(map, MAX17042_OCVInternal, &data);
246 val->intval = data * 625 / 8;
248 case POWER_SUPPLY_PROP_CAPACITY:
249 if (chip->pdata->enable_current_sense)
250 ret = regmap_read(map, MAX17042_RepSOC, &data);
252 ret = regmap_read(map, MAX17042_VFSOC, &data);
256 val->intval = data >> 8;
258 case POWER_SUPPLY_PROP_CHARGE_FULL:
259 ret = regmap_read(map, MAX17042_FullCAP, &data);
263 val->intval = data * 1000 / 2;
265 case POWER_SUPPLY_PROP_CHARGE_COUNTER:
266 ret = regmap_read(map, MAX17042_QH, &data);
270 val->intval = data * 1000 / 2;
272 case POWER_SUPPLY_PROP_TEMP:
273 ret = max17042_get_temperature(chip, &val->intval);
277 case POWER_SUPPLY_PROP_TEMP_ALERT_MIN:
278 ret = regmap_read(map, MAX17042_TALRT_Th, &data);
281 /* LSB is Alert Minimum. In deci-centigrade */
282 val->intval = (data & 0xff) * 10;
284 case POWER_SUPPLY_PROP_TEMP_ALERT_MAX:
285 ret = regmap_read(map, MAX17042_TALRT_Th, &data);
288 /* MSB is Alert Maximum. In deci-centigrade */
289 val->intval = (data >> 8) * 10;
291 case POWER_SUPPLY_PROP_TEMP_MIN:
292 val->intval = chip->pdata->temp_min;
294 case POWER_SUPPLY_PROP_TEMP_MAX:
295 val->intval = chip->pdata->temp_max;
297 case POWER_SUPPLY_PROP_HEALTH:
298 ret = max17042_get_battery_health(chip, &val->intval);
302 case POWER_SUPPLY_PROP_CURRENT_NOW:
303 if (chip->pdata->enable_current_sense) {
304 ret = regmap_read(map, MAX17042_Current, &data);
309 if (val->intval & 0x8000) {
311 val->intval = ~val->intval & 0x7fff;
315 val->intval *= 1562500 / chip->pdata->r_sns;
320 case POWER_SUPPLY_PROP_CURRENT_AVG:
321 if (chip->pdata->enable_current_sense) {
322 ret = regmap_read(map, MAX17042_AvgCurrent, &data);
327 if (val->intval & 0x8000) {
329 val->intval = ~val->intval & 0x7fff;
333 val->intval *= 1562500 / chip->pdata->r_sns;
344 static int max17042_set_property(struct power_supply *psy,
345 enum power_supply_property psp,
346 const union power_supply_propval *val)
348 struct max17042_chip *chip = power_supply_get_drvdata(psy);
349 struct regmap *map = chip->regmap;
355 case POWER_SUPPLY_PROP_TEMP_ALERT_MIN:
356 ret = regmap_read(map, MAX17042_TALRT_Th, &data);
360 /* Input in deci-centigrade, convert to centigrade */
361 temp = val->intval / 10;
362 /* force min < max */
363 if (temp >= (int8_t)(data >> 8))
364 temp = (int8_t)(data >> 8) - 1;
365 /* Write both MAX and MIN ALERT */
366 data = (data & 0xff00) + temp;
367 ret = regmap_write(map, MAX17042_TALRT_Th, data);
369 case POWER_SUPPLY_PROP_TEMP_ALERT_MAX:
370 ret = regmap_read(map, MAX17042_TALRT_Th, &data);
374 /* Input in Deci-Centigrade, convert to centigrade */
375 temp = val->intval / 10;
376 /* force max > min */
377 if (temp <= (int8_t)(data & 0xff))
378 temp = (int8_t)(data & 0xff) + 1;
379 /* Write both MAX and MIN ALERT */
380 data = (data & 0xff) + (temp << 8);
381 ret = regmap_write(map, MAX17042_TALRT_Th, data);
390 static int max17042_property_is_writeable(struct power_supply *psy,
391 enum power_supply_property psp)
396 case POWER_SUPPLY_PROP_TEMP_ALERT_MIN:
397 case POWER_SUPPLY_PROP_TEMP_ALERT_MAX:
407 static int max17042_write_verify_reg(struct regmap *map, u8 reg, u32 value)
414 ret = regmap_write(map, reg, value);
415 regmap_read(map, reg, &read_value);
416 if (read_value != value) {
420 } while (retries && read_value != value);
423 pr_err("%s: err %d\n", __func__, ret);
428 static inline void max17042_override_por(struct regmap *map,
432 regmap_write(map, reg, value);
435 static inline void max10742_unlock_model(struct max17042_chip *chip)
437 struct regmap *map = chip->regmap;
439 regmap_write(map, MAX17042_MLOCKReg1, MODEL_UNLOCK1);
440 regmap_write(map, MAX17042_MLOCKReg2, MODEL_UNLOCK2);
443 static inline void max10742_lock_model(struct max17042_chip *chip)
445 struct regmap *map = chip->regmap;
447 regmap_write(map, MAX17042_MLOCKReg1, MODEL_LOCK1);
448 regmap_write(map, MAX17042_MLOCKReg2, MODEL_LOCK2);
451 static inline void max17042_write_model_data(struct max17042_chip *chip,
454 struct regmap *map = chip->regmap;
457 for (i = 0; i < size; i++)
458 regmap_write(map, addr + i,
459 chip->pdata->config_data->cell_char_tbl[i]);
462 static inline void max17042_read_model_data(struct max17042_chip *chip,
463 u8 addr, u16 *data, int size)
465 struct regmap *map = chip->regmap;
469 for (i = 0; i < size; i++) {
470 regmap_read(map, addr + i, &tmp);
475 static inline int max17042_model_data_compare(struct max17042_chip *chip,
476 u16 *data1, u16 *data2, int size)
480 if (memcmp(data1, data2, size)) {
481 dev_err(&chip->client->dev, "%s compare failed\n", __func__);
482 for (i = 0; i < size; i++)
483 dev_info(&chip->client->dev, "0x%x, 0x%x",
485 dev_info(&chip->client->dev, "\n");
491 static int max17042_init_model(struct max17042_chip *chip)
494 int table_size = ARRAY_SIZE(chip->pdata->config_data->cell_char_tbl);
497 temp_data = kcalloc(table_size, sizeof(*temp_data), GFP_KERNEL);
501 max10742_unlock_model(chip);
502 max17042_write_model_data(chip, MAX17042_MODELChrTbl,
504 max17042_read_model_data(chip, MAX17042_MODELChrTbl, temp_data,
507 ret = max17042_model_data_compare(
509 chip->pdata->config_data->cell_char_tbl,
513 max10742_lock_model(chip);
519 static int max17042_verify_model_lock(struct max17042_chip *chip)
522 int table_size = ARRAY_SIZE(chip->pdata->config_data->cell_char_tbl);
526 temp_data = kcalloc(table_size, sizeof(*temp_data), GFP_KERNEL);
530 max17042_read_model_data(chip, MAX17042_MODELChrTbl, temp_data,
532 for (i = 0; i < table_size; i++)
540 static void max17042_write_config_regs(struct max17042_chip *chip)
542 struct max17042_config_data *config = chip->pdata->config_data;
543 struct regmap *map = chip->regmap;
545 regmap_write(map, MAX17042_CONFIG, config->config);
546 regmap_write(map, MAX17042_LearnCFG, config->learn_cfg);
547 regmap_write(map, MAX17042_FilterCFG,
549 regmap_write(map, MAX17042_RelaxCFG, config->relax_cfg);
550 if (chip->chip_type == MAXIM_DEVICE_TYPE_MAX17047 ||
551 chip->chip_type == MAXIM_DEVICE_TYPE_MAX17050)
552 regmap_write(map, MAX17047_FullSOCThr,
553 config->full_soc_thresh);
556 static void max17042_write_custom_regs(struct max17042_chip *chip)
558 struct max17042_config_data *config = chip->pdata->config_data;
559 struct regmap *map = chip->regmap;
561 max17042_write_verify_reg(map, MAX17042_RCOMP0, config->rcomp0);
562 max17042_write_verify_reg(map, MAX17042_TempCo, config->tcompc0);
563 max17042_write_verify_reg(map, MAX17042_ICHGTerm, config->ichgt_term);
564 if (chip->chip_type == MAXIM_DEVICE_TYPE_MAX17042) {
565 regmap_write(map, MAX17042_EmptyTempCo, config->empty_tempco);
566 max17042_write_verify_reg(map, MAX17042_K_empty0,
569 max17042_write_verify_reg(map, MAX17047_QRTbl00,
571 max17042_write_verify_reg(map, MAX17047_QRTbl10,
573 max17042_write_verify_reg(map, MAX17047_QRTbl20,
575 max17042_write_verify_reg(map, MAX17047_QRTbl30,
580 static void max17042_update_capacity_regs(struct max17042_chip *chip)
582 struct max17042_config_data *config = chip->pdata->config_data;
583 struct regmap *map = chip->regmap;
585 max17042_write_verify_reg(map, MAX17042_FullCAP,
587 regmap_write(map, MAX17042_DesignCap, config->design_cap);
588 max17042_write_verify_reg(map, MAX17042_FullCAPNom,
592 static void max17042_reset_vfsoc0_reg(struct max17042_chip *chip)
595 struct regmap *map = chip->regmap;
597 regmap_read(map, MAX17042_VFSOC, &vfSoc);
598 regmap_write(map, MAX17042_VFSOC0Enable, VFSOC0_UNLOCK);
599 max17042_write_verify_reg(map, MAX17042_VFSOC0, vfSoc);
600 regmap_write(map, MAX17042_VFSOC0Enable, VFSOC0_LOCK);
603 static void max17042_load_new_capacity_params(struct max17042_chip *chip)
605 u32 full_cap0, rep_cap, dq_acc, vfSoc;
608 struct max17042_config_data *config = chip->pdata->config_data;
609 struct regmap *map = chip->regmap;
611 regmap_read(map, MAX17042_FullCAP0, &full_cap0);
612 regmap_read(map, MAX17042_VFSOC, &vfSoc);
614 /* fg_vfSoc needs to shifted by 8 bits to get the
615 * perc in 1% accuracy, to get the right rem_cap multiply
616 * full_cap0, fg_vfSoc and devide by 100
618 rem_cap = ((vfSoc >> 8) * full_cap0) / 100;
619 max17042_write_verify_reg(map, MAX17042_RemCap, rem_cap);
622 max17042_write_verify_reg(map, MAX17042_RepCap, rep_cap);
624 /* Write dQ_acc to 200% of Capacity and dP_acc to 200% */
625 dq_acc = config->fullcap / dQ_ACC_DIV;
626 max17042_write_verify_reg(map, MAX17042_dQacc, dq_acc);
627 max17042_write_verify_reg(map, MAX17042_dPacc, dP_ACC_200);
629 max17042_write_verify_reg(map, MAX17042_FullCAP,
631 regmap_write(map, MAX17042_DesignCap,
633 max17042_write_verify_reg(map, MAX17042_FullCAPNom,
635 /* Update SOC register with new SOC */
636 regmap_write(map, MAX17042_RepSOC, vfSoc);
640 * Block write all the override values coming from platform data.
641 * This function MUST be called before the POR initialization proceedure
642 * specified by maxim.
644 static inline void max17042_override_por_values(struct max17042_chip *chip)
646 struct regmap *map = chip->regmap;
647 struct max17042_config_data *config = chip->pdata->config_data;
649 max17042_override_por(map, MAX17042_TGAIN, config->tgain);
650 max17042_override_por(map, MAX17042_TOFF, config->toff);
651 max17042_override_por(map, MAX17042_CGAIN, config->cgain);
652 max17042_override_por(map, MAX17042_COFF, config->coff);
654 max17042_override_por(map, MAX17042_VALRT_Th, config->valrt_thresh);
655 max17042_override_por(map, MAX17042_TALRT_Th, config->talrt_thresh);
656 max17042_override_por(map, MAX17042_SALRT_Th,
657 config->soc_alrt_thresh);
658 max17042_override_por(map, MAX17042_CONFIG, config->config);
659 max17042_override_por(map, MAX17042_SHDNTIMER, config->shdntimer);
661 max17042_override_por(map, MAX17042_DesignCap, config->design_cap);
662 max17042_override_por(map, MAX17042_ICHGTerm, config->ichgt_term);
664 max17042_override_por(map, MAX17042_AtRate, config->at_rate);
665 max17042_override_por(map, MAX17042_LearnCFG, config->learn_cfg);
666 max17042_override_por(map, MAX17042_FilterCFG, config->filter_cfg);
667 max17042_override_por(map, MAX17042_RelaxCFG, config->relax_cfg);
668 max17042_override_por(map, MAX17042_MiscCFG, config->misc_cfg);
669 max17042_override_por(map, MAX17042_MaskSOC, config->masksoc);
671 max17042_override_por(map, MAX17042_FullCAP, config->fullcap);
672 max17042_override_por(map, MAX17042_FullCAPNom, config->fullcapnom);
673 if (chip->chip_type == MAXIM_DEVICE_TYPE_MAX17042)
674 max17042_override_por(map, MAX17042_SOC_empty,
676 max17042_override_por(map, MAX17042_LAvg_empty, config->lavg_empty);
677 max17042_override_por(map, MAX17042_dQacc, config->dqacc);
678 max17042_override_por(map, MAX17042_dPacc, config->dpacc);
680 if (chip->chip_type == MAXIM_DEVICE_TYPE_MAX17042)
681 max17042_override_por(map, MAX17042_V_empty, config->vempty);
683 max17042_override_por(map, MAX17047_V_empty, config->vempty);
684 max17042_override_por(map, MAX17042_TempNom, config->temp_nom);
685 max17042_override_por(map, MAX17042_TempLim, config->temp_lim);
686 max17042_override_por(map, MAX17042_FCTC, config->fctc);
687 max17042_override_por(map, MAX17042_RCOMP0, config->rcomp0);
688 max17042_override_por(map, MAX17042_TempCo, config->tcompc0);
689 if (chip->chip_type) {
690 max17042_override_por(map, MAX17042_EmptyTempCo,
691 config->empty_tempco);
692 max17042_override_por(map, MAX17042_K_empty0,
697 static int max17042_init_chip(struct max17042_chip *chip)
699 struct regmap *map = chip->regmap;
702 max17042_override_por_values(chip);
703 /* After Power up, the MAX17042 requires 500mS in order
704 * to perform signal debouncing and initial SOC reporting
708 /* Initialize configaration */
709 max17042_write_config_regs(chip);
711 /* write cell characterization data */
712 ret = max17042_init_model(chip);
714 dev_err(&chip->client->dev, "%s init failed\n",
719 ret = max17042_verify_model_lock(chip);
721 dev_err(&chip->client->dev, "%s lock verify failed\n",
725 /* write custom parameters */
726 max17042_write_custom_regs(chip);
728 /* update capacity params */
729 max17042_update_capacity_regs(chip);
731 /* delay must be atleast 350mS to allow VFSOC
732 * to be calculated from the new configuration
736 /* reset vfsoc0 reg */
737 max17042_reset_vfsoc0_reg(chip);
739 /* load new capacity params */
740 max17042_load_new_capacity_params(chip);
742 /* Init complete, Clear the POR bit */
743 regmap_update_bits(map, MAX17042_STATUS, STATUS_POR_BIT, 0x0);
747 static void max17042_set_soc_threshold(struct max17042_chip *chip, u16 off)
749 struct regmap *map = chip->regmap;
752 /* program interrupt thesholds such that we should
753 * get interrupt for every 'off' perc change in the soc
755 regmap_read(map, MAX17042_RepSOC, &soc);
757 soc_tr = (soc + off) << 8;
760 regmap_write(map, MAX17042_SALRT_Th, soc_tr);
763 static irqreturn_t max17042_thread_handler(int id, void *dev)
765 struct max17042_chip *chip = dev;
769 ret = regmap_read(chip->regmap, MAX17042_STATUS, &val);
773 if ((val & STATUS_INTR_SOCMIN_BIT) ||
774 (val & STATUS_INTR_SOCMAX_BIT)) {
775 dev_info(&chip->client->dev, "SOC threshold INTR\n");
776 max17042_set_soc_threshold(chip, 1);
779 power_supply_changed(chip->battery);
783 static void max17042_init_worker(struct work_struct *work)
785 struct max17042_chip *chip = container_of(work,
786 struct max17042_chip, work);
789 /* Initialize registers according to values from the platform data */
790 if (chip->pdata->enable_por_init && chip->pdata->config_data) {
791 ret = max17042_init_chip(chip);
796 chip->init_complete = 1;
800 static struct max17042_platform_data *
801 max17042_get_pdata(struct device *dev)
803 struct device_node *np = dev->of_node;
805 struct max17042_platform_data *pdata;
808 return dev->platform_data;
810 pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
815 * Require current sense resistor value to be specified for
816 * current-sense functionality to be enabled at all.
818 if (of_property_read_u32(np, "maxim,rsns-microohm", &prop) == 0) {
820 pdata->enable_current_sense = true;
823 if (of_property_read_s32(np, "maxim,cold-temp", &pdata->temp_min))
824 pdata->temp_min = INT_MIN;
825 if (of_property_read_s32(np, "maxim,over-heat-temp", &pdata->temp_max))
826 pdata->temp_max = INT_MAX;
827 if (of_property_read_s32(np, "maxim,dead-volt", &pdata->vmin))
828 pdata->vmin = INT_MIN;
829 if (of_property_read_s32(np, "maxim,over-volt", &pdata->vmax))
830 pdata->vmax = INT_MAX;
835 static struct max17042_platform_data *
836 max17042_get_pdata(struct device *dev)
838 return dev->platform_data;
842 static const struct regmap_config max17042_regmap_config = {
845 .val_format_endian = REGMAP_ENDIAN_NATIVE,
848 static const struct power_supply_desc max17042_psy_desc = {
849 .name = "max170xx_battery",
850 .type = POWER_SUPPLY_TYPE_BATTERY,
851 .get_property = max17042_get_property,
852 .set_property = max17042_set_property,
853 .property_is_writeable = max17042_property_is_writeable,
854 .properties = max17042_battery_props,
855 .num_properties = ARRAY_SIZE(max17042_battery_props),
858 static const struct power_supply_desc max17042_no_current_sense_psy_desc = {
859 .name = "max170xx_battery",
860 .type = POWER_SUPPLY_TYPE_BATTERY,
861 .get_property = max17042_get_property,
862 .set_property = max17042_set_property,
863 .property_is_writeable = max17042_property_is_writeable,
864 .properties = max17042_battery_props,
865 .num_properties = ARRAY_SIZE(max17042_battery_props) - 2,
868 static int max17042_probe(struct i2c_client *client,
869 const struct i2c_device_id *id)
871 struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
872 const struct power_supply_desc *max17042_desc = &max17042_psy_desc;
873 struct power_supply_config psy_cfg = {};
874 struct max17042_chip *chip;
879 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_WORD_DATA))
882 chip = devm_kzalloc(&client->dev, sizeof(*chip), GFP_KERNEL);
886 chip->client = client;
887 chip->regmap = devm_regmap_init_i2c(client, &max17042_regmap_config);
888 if (IS_ERR(chip->regmap)) {
889 dev_err(&client->dev, "Failed to initialize regmap\n");
893 chip->pdata = max17042_get_pdata(&client->dev);
895 dev_err(&client->dev, "no platform data provided\n");
899 i2c_set_clientdata(client, chip);
900 chip->chip_type = id->driver_data;
901 psy_cfg.drv_data = chip;
903 /* When current is not measured,
904 * CURRENT_NOW and CURRENT_AVG properties should be invisible. */
905 if (!chip->pdata->enable_current_sense)
906 max17042_desc = &max17042_no_current_sense_psy_desc;
908 if (chip->pdata->r_sns == 0)
909 chip->pdata->r_sns = MAX17042_DEFAULT_SNS_RESISTOR;
911 if (chip->pdata->init_data)
912 for (i = 0; i < chip->pdata->num_init_data; i++)
913 regmap_write(chip->regmap,
914 chip->pdata->init_data[i].addr,
915 chip->pdata->init_data[i].data);
917 if (!chip->pdata->enable_current_sense) {
918 regmap_write(chip->regmap, MAX17042_CGAIN, 0x0000);
919 regmap_write(chip->regmap, MAX17042_MiscCFG, 0x0003);
920 regmap_write(chip->regmap, MAX17042_LearnCFG, 0x0007);
923 chip->battery = devm_power_supply_register(&client->dev, max17042_desc,
925 if (IS_ERR(chip->battery)) {
926 dev_err(&client->dev, "failed: power supply register\n");
927 return PTR_ERR(chip->battery);
931 ret = devm_request_threaded_irq(&client->dev, client->irq,
933 max17042_thread_handler,
934 IRQF_TRIGGER_FALLING |
936 chip->battery->desc->name,
939 regmap_update_bits(chip->regmap, MAX17042_CONFIG,
940 CONFIG_ALRT_BIT_ENBL,
941 CONFIG_ALRT_BIT_ENBL);
942 max17042_set_soc_threshold(chip, 1);
945 dev_err(&client->dev, "%s(): cannot get IRQ\n",
950 regmap_read(chip->regmap, MAX17042_STATUS, &val);
951 if (val & STATUS_POR_BIT) {
952 INIT_WORK(&chip->work, max17042_init_worker);
953 schedule_work(&chip->work);
955 chip->init_complete = 1;
961 #ifdef CONFIG_PM_SLEEP
962 static int max17042_suspend(struct device *dev)
964 struct max17042_chip *chip = dev_get_drvdata(dev);
967 * disable the irq and enable irq_wake
968 * capability to the interrupt line.
970 if (chip->client->irq) {
971 disable_irq(chip->client->irq);
972 enable_irq_wake(chip->client->irq);
978 static int max17042_resume(struct device *dev)
980 struct max17042_chip *chip = dev_get_drvdata(dev);
982 if (chip->client->irq) {
983 disable_irq_wake(chip->client->irq);
984 enable_irq(chip->client->irq);
985 /* re-program the SOC thresholds to 1% change */
986 max17042_set_soc_threshold(chip, 1);
993 static SIMPLE_DEV_PM_OPS(max17042_pm_ops, max17042_suspend,
997 static const struct of_device_id max17042_dt_match[] = {
998 { .compatible = "maxim,max17042" },
999 { .compatible = "maxim,max17047" },
1000 { .compatible = "maxim,max17050" },
1003 MODULE_DEVICE_TABLE(of, max17042_dt_match);
1006 static const struct i2c_device_id max17042_id[] = {
1007 { "max17042", MAXIM_DEVICE_TYPE_MAX17042 },
1008 { "max17047", MAXIM_DEVICE_TYPE_MAX17047 },
1009 { "max17050", MAXIM_DEVICE_TYPE_MAX17050 },
1012 MODULE_DEVICE_TABLE(i2c, max17042_id);
1014 static struct i2c_driver max17042_i2c_driver = {
1017 .of_match_table = of_match_ptr(max17042_dt_match),
1018 .pm = &max17042_pm_ops,
1020 .probe = max17042_probe,
1021 .id_table = max17042_id,
1023 module_i2c_driver(max17042_i2c_driver);
1025 MODULE_AUTHOR("MyungJoo Ham <myungjoo.ham@samsung.com>");
1026 MODULE_DESCRIPTION("MAX17042 Fuel Gauge");
1027 MODULE_LICENSE("GPL");