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

source code of linux/drivers/power/supply/max17042_battery.c