1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * Fuel gauge driver for Maxim 17201/17205
4 *
5 * based on max1721x_battery.c
6 *
7 * Copyright (C) 2024 Liebherr-Electronics and Drives GmbH
8 */
9
10 #include <linux/bitfield.h>
11 #include <linux/i2c.h>
12 #include <linux/module.h>
13 #include <linux/nvmem-provider.h>
14 #include <linux/power_supply.h>
15 #include <linux/regmap.h>
16
17 #include <linux/unaligned.h>
18
19 /* SBS compliant registers */
20 #define MAX172XX_TEMP1 0x34
21 #define MAX172XX_INT_TEMP 0x35
22 #define MAX172XX_TEMP2 0x3B
23
24 /* Nonvolatile registers */
25 #define MAX1720X_NXTABLE0 0x80
26 #define MAX1720X_NRSENSE 0xCF /* RSense in 10^-5 Ohm */
27 #define MAX1720X_NDEVICE_NAME4 0xDF
28
29 /* ModelGauge m5 */
30 #define MAX172XX_STATUS 0x00 /* Status */
31 #define MAX172XX_STATUS_BAT_ABSENT BIT(3) /* Battery absent */
32 #define MAX172XX_REPCAP 0x05 /* Average capacity */
33 #define MAX172XX_REPSOC 0x06 /* Percentage of charge */
34 #define MAX172XX_TEMP 0x08 /* Temperature */
35 #define MAX172XX_CURRENT 0x0A /* Actual current */
36 #define MAX172XX_AVG_CURRENT 0x0B /* Average current */
37 #define MAX172XX_FULL_CAP 0x10 /* Calculated full capacity */
38 #define MAX172XX_TTE 0x11 /* Time to empty */
39 #define MAX172XX_AVG_TA 0x16 /* Average temperature */
40 #define MAX172XX_CYCLES 0x17
41 #define MAX172XX_DESIGN_CAP 0x18 /* Design capacity */
42 #define MAX172XX_AVG_VCELL 0x19
43 #define MAX172XX_TTF 0x20 /* Time to full */
44 #define MAX172XX_DEV_NAME 0x21 /* Device name */
45 #define MAX172XX_DEV_NAME_TYPE_MASK GENMASK(3, 0)
46 #define MAX172XX_DEV_NAME_TYPE_MAX17201 BIT(0)
47 #define MAX172XX_DEV_NAME_TYPE_MAX17205 (BIT(0) | BIT(2))
48 #define MAX172XX_QR_TABLE10 0x22
49 #define MAX172XX_BATT 0xDA /* Battery voltage */
50 #define MAX172XX_ATAVCAP 0xDF
51
52 static const char *const max1720x_manufacturer = "Maxim Integrated";
53 static const char *const max17201_model = "MAX17201";
54 static const char *const max17205_model = "MAX17205";
55
56 struct max1720x_device_info {
57 struct regmap *regmap;
58 struct regmap *regmap_nv;
59 struct i2c_client *ancillary;
60 int rsense;
61 };
62
63 /*
64 * Model Gauge M5 Algorithm output register
65 * Volatile data (must not be cached)
66 */
67 static const struct regmap_range max1720x_volatile_allow[] = {
68 regmap_reg_range(MAX172XX_STATUS, MAX172XX_CYCLES),
69 regmap_reg_range(MAX172XX_AVG_VCELL, MAX172XX_TTF),
70 regmap_reg_range(MAX172XX_QR_TABLE10, MAX172XX_ATAVCAP),
71 };
72
73 static const struct regmap_range max1720x_readable_allow[] = {
74 regmap_reg_range(MAX172XX_STATUS, MAX172XX_ATAVCAP),
75 };
76
77 static const struct regmap_range max1720x_readable_deny[] = {
78 /* unused registers */
79 regmap_reg_range(0x24, 0x26),
80 regmap_reg_range(0x30, 0x31),
81 regmap_reg_range(0x33, 0x34),
82 regmap_reg_range(0x37, 0x37),
83 regmap_reg_range(0x3B, 0x3C),
84 regmap_reg_range(0x40, 0x41),
85 regmap_reg_range(0x43, 0x44),
86 regmap_reg_range(0x47, 0x49),
87 regmap_reg_range(0x4B, 0x4C),
88 regmap_reg_range(0x4E, 0xAF),
89 regmap_reg_range(0xB1, 0xB3),
90 regmap_reg_range(0xB5, 0xB7),
91 regmap_reg_range(0xBF, 0xD0),
92 regmap_reg_range(0xDB, 0xDB),
93 regmap_reg_range(0xE0, 0xFF),
94 };
95
96 static const struct regmap_access_table max1720x_readable_regs = {
97 .yes_ranges = max1720x_readable_allow,
98 .n_yes_ranges = ARRAY_SIZE(max1720x_readable_allow),
99 .no_ranges = max1720x_readable_deny,
100 .n_no_ranges = ARRAY_SIZE(max1720x_readable_deny),
101 };
102
103 static const struct regmap_access_table max1720x_volatile_regs = {
104 .yes_ranges = max1720x_volatile_allow,
105 .n_yes_ranges = ARRAY_SIZE(max1720x_volatile_allow),
106 .no_ranges = max1720x_readable_deny,
107 .n_no_ranges = ARRAY_SIZE(max1720x_readable_deny),
108 };
109
110 static const struct regmap_config max1720x_regmap_cfg = {
111 .reg_bits = 8,
112 .val_bits = 16,
113 .max_register = MAX172XX_ATAVCAP,
114 .val_format_endian = REGMAP_ENDIAN_LITTLE,
115 .rd_table = &max1720x_readable_regs,
116 .volatile_table = &max1720x_volatile_regs,
117 .cache_type = REGCACHE_RBTREE,
118 };
119
120 static const struct regmap_range max1720x_nvmem_allow[] = {
121 regmap_reg_range(MAX172XX_TEMP1, MAX172XX_INT_TEMP),
122 regmap_reg_range(MAX172XX_TEMP2, MAX172XX_TEMP2),
123 regmap_reg_range(MAX1720X_NXTABLE0, MAX1720X_NDEVICE_NAME4),
124 };
125
126 static const struct regmap_range max1720x_nvmem_deny[] = {
127 regmap_reg_range(0x00, 0x33),
128 regmap_reg_range(0x36, 0x3A),
129 regmap_reg_range(0x3C, 0x7F),
130 regmap_reg_range(0xE0, 0xFF),
131 };
132
133 static const struct regmap_access_table max1720x_nvmem_regs = {
134 .yes_ranges = max1720x_nvmem_allow,
135 .n_yes_ranges = ARRAY_SIZE(max1720x_nvmem_allow),
136 .no_ranges = max1720x_nvmem_deny,
137 .n_no_ranges = ARRAY_SIZE(max1720x_nvmem_deny),
138 };
139
140 static const struct regmap_config max1720x_nvmem_regmap_cfg = {
141 .reg_bits = 8,
142 .val_bits = 16,
143 .max_register = MAX1720X_NDEVICE_NAME4,
144 .val_format_endian = REGMAP_ENDIAN_LITTLE,
145 .rd_table = &max1720x_nvmem_regs,
146 };
147
148 static const struct nvmem_cell_info max1720x_nvmem_cells[] = {
149 { .name = "nXTable0", .offset = 0, .bytes = 2, },
150 { .name = "nXTable1", .offset = 2, .bytes = 2, },
151 { .name = "nXTable2", .offset = 4, .bytes = 2, },
152 { .name = "nXTable3", .offset = 6, .bytes = 2, },
153 { .name = "nXTable4", .offset = 8, .bytes = 2, },
154 { .name = "nXTable5", .offset = 10, .bytes = 2, },
155 { .name = "nXTable6", .offset = 12, .bytes = 2, },
156 { .name = "nXTable7", .offset = 14, .bytes = 2, },
157 { .name = "nXTable8", .offset = 16, .bytes = 2, },
158 { .name = "nXTable9", .offset = 18, .bytes = 2, },
159 { .name = "nXTable10", .offset = 20, .bytes = 2, },
160 { .name = "nXTable11", .offset = 22, .bytes = 2, },
161 { .name = "nUser18C", .offset = 24, .bytes = 2, },
162 { .name = "nUser18D", .offset = 26, .bytes = 2, },
163 { .name = "nODSCTh", .offset = 28, .bytes = 2, },
164 { .name = "nODSCCfg", .offset = 30, .bytes = 2, },
165
166 { .name = "nOCVTable0", .offset = 32, .bytes = 2, },
167 { .name = "nOCVTable1", .offset = 34, .bytes = 2, },
168 { .name = "nOCVTable2", .offset = 36, .bytes = 2, },
169 { .name = "nOCVTable3", .offset = 38, .bytes = 2, },
170 { .name = "nOCVTable4", .offset = 40, .bytes = 2, },
171 { .name = "nOCVTable5", .offset = 42, .bytes = 2, },
172 { .name = "nOCVTable6", .offset = 44, .bytes = 2, },
173 { .name = "nOCVTable7", .offset = 46, .bytes = 2, },
174 { .name = "nOCVTable8", .offset = 48, .bytes = 2, },
175 { .name = "nOCVTable9", .offset = 50, .bytes = 2, },
176 { .name = "nOCVTable10", .offset = 52, .bytes = 2, },
177 { .name = "nOCVTable11", .offset = 54, .bytes = 2, },
178 { .name = "nIChgTerm", .offset = 56, .bytes = 2, },
179 { .name = "nFilterCfg", .offset = 58, .bytes = 2, },
180 { .name = "nVEmpty", .offset = 60, .bytes = 2, },
181 { .name = "nLearnCfg", .offset = 62, .bytes = 2, },
182
183 { .name = "nQRTable00", .offset = 64, .bytes = 2, },
184 { .name = "nQRTable10", .offset = 66, .bytes = 2, },
185 { .name = "nQRTable20", .offset = 68, .bytes = 2, },
186 { .name = "nQRTable30", .offset = 70, .bytes = 2, },
187 { .name = "nCycles", .offset = 72, .bytes = 2, },
188 { .name = "nFullCapNom", .offset = 74, .bytes = 2, },
189 { .name = "nRComp0", .offset = 76, .bytes = 2, },
190 { .name = "nTempCo", .offset = 78, .bytes = 2, },
191 { .name = "nIAvgEmpty", .offset = 80, .bytes = 2, },
192 { .name = "nFullCapRep", .offset = 82, .bytes = 2, },
193 { .name = "nVoltTemp", .offset = 84, .bytes = 2, },
194 { .name = "nMaxMinCurr", .offset = 86, .bytes = 2, },
195 { .name = "nMaxMinVolt", .offset = 88, .bytes = 2, },
196 { .name = "nMaxMinTemp", .offset = 90, .bytes = 2, },
197 { .name = "nSOC", .offset = 92, .bytes = 2, },
198 { .name = "nTimerH", .offset = 94, .bytes = 2, },
199
200 { .name = "nConfig", .offset = 96, .bytes = 2, },
201 { .name = "nRippleCfg", .offset = 98, .bytes = 2, },
202 { .name = "nMiscCfg", .offset = 100, .bytes = 2, },
203 { .name = "nDesignCap", .offset = 102, .bytes = 2, },
204 { .name = "nHibCfg", .offset = 104, .bytes = 2, },
205 { .name = "nPackCfg", .offset = 106, .bytes = 2, },
206 { .name = "nRelaxCfg", .offset = 108, .bytes = 2, },
207 { .name = "nConvgCfg", .offset = 110, .bytes = 2, },
208 { .name = "nNVCfg0", .offset = 112, .bytes = 2, },
209 { .name = "nNVCfg1", .offset = 114, .bytes = 2, },
210 { .name = "nNVCfg2", .offset = 116, .bytes = 2, },
211 { .name = "nSBSCfg", .offset = 118, .bytes = 2, },
212 { .name = "nROMID0", .offset = 120, .bytes = 2, },
213 { .name = "nROMID1", .offset = 122, .bytes = 2, },
214 { .name = "nROMID2", .offset = 124, .bytes = 2, },
215 { .name = "nROMID3", .offset = 126, .bytes = 2, },
216
217 { .name = "nVAlrtTh", .offset = 128, .bytes = 2, },
218 { .name = "nTAlrtTh", .offset = 130, .bytes = 2, },
219 { .name = "nSAlrtTh", .offset = 132, .bytes = 2, },
220 { .name = "nIAlrtTh", .offset = 134, .bytes = 2, },
221 { .name = "nUser1C4", .offset = 136, .bytes = 2, },
222 { .name = "nUser1C5", .offset = 138, .bytes = 2, },
223 { .name = "nFullSOCThr", .offset = 140, .bytes = 2, },
224 { .name = "nTTFCfg", .offset = 142, .bytes = 2, },
225 { .name = "nCGain", .offset = 144, .bytes = 2, },
226 { .name = "nTCurve", .offset = 146, .bytes = 2, },
227 { .name = "nTGain", .offset = 148, .bytes = 2, },
228 { .name = "nTOff", .offset = 150, .bytes = 2, },
229 { .name = "nManfctrName0", .offset = 152, .bytes = 2, },
230 { .name = "nManfctrName1", .offset = 154, .bytes = 2, },
231 { .name = "nManfctrName2", .offset = 156, .bytes = 2, },
232 { .name = "nRSense", .offset = 158, .bytes = 2, },
233
234 { .name = "nUser1D0", .offset = 160, .bytes = 2, },
235 { .name = "nUser1D1", .offset = 162, .bytes = 2, },
236 { .name = "nAgeFcCfg", .offset = 164, .bytes = 2, },
237 { .name = "nDesignVoltage", .offset = 166, .bytes = 2, },
238 { .name = "nUser1D4", .offset = 168, .bytes = 2, },
239 { .name = "nRFastVShdn", .offset = 170, .bytes = 2, },
240 { .name = "nManfctrDate", .offset = 172, .bytes = 2, },
241 { .name = "nFirstUsed", .offset = 174, .bytes = 2, },
242 { .name = "nSerialNumber0", .offset = 176, .bytes = 2, },
243 { .name = "nSerialNumber1", .offset = 178, .bytes = 2, },
244 { .name = "nSerialNumber2", .offset = 180, .bytes = 2, },
245 { .name = "nDeviceName0", .offset = 182, .bytes = 2, },
246 { .name = "nDeviceName1", .offset = 184, .bytes = 2, },
247 { .name = "nDeviceName2", .offset = 186, .bytes = 2, },
248 { .name = "nDeviceName3", .offset = 188, .bytes = 2, },
249 { .name = "nDeviceName4", .offset = 190, .bytes = 2, },
250 };
251
252 static const enum power_supply_property max1720x_battery_props[] = {
253 POWER_SUPPLY_PROP_PRESENT,
254 POWER_SUPPLY_PROP_CAPACITY,
255 POWER_SUPPLY_PROP_VOLTAGE_NOW,
256 POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
257 POWER_SUPPLY_PROP_CHARGE_AVG,
258 POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG,
259 POWER_SUPPLY_PROP_TIME_TO_FULL_AVG,
260 POWER_SUPPLY_PROP_TEMP,
261 POWER_SUPPLY_PROP_CURRENT_NOW,
262 POWER_SUPPLY_PROP_CURRENT_AVG,
263 POWER_SUPPLY_PROP_CHARGE_FULL,
264 POWER_SUPPLY_PROP_MODEL_NAME,
265 POWER_SUPPLY_PROP_MANUFACTURER,
266 };
267
268 /* Convert regs value to power_supply units */
269
max172xx_time_to_ps(unsigned int reg)270 static int max172xx_time_to_ps(unsigned int reg)
271 {
272 return reg * 5625 / 1000; /* in sec. */
273 }
274
max172xx_percent_to_ps(unsigned int reg)275 static int max172xx_percent_to_ps(unsigned int reg)
276 {
277 return reg / 256; /* in percent from 0 to 100 */
278 }
279
max172xx_voltage_to_ps(unsigned int reg)280 static int max172xx_voltage_to_ps(unsigned int reg)
281 {
282 return reg * 1250; /* in uV */
283 }
284
max172xx_capacity_to_ps(unsigned int reg)285 static int max172xx_capacity_to_ps(unsigned int reg)
286 {
287 return reg * 500; /* in uAh */
288 }
289
290 /*
291 * Current and temperature is signed values, so unsigned regs
292 * value must be converted to signed type
293 */
294
max172xx_temperature_to_ps(unsigned int reg)295 static int max172xx_temperature_to_ps(unsigned int reg)
296 {
297 int val = (int16_t)reg;
298
299 return val * 10 / 256; /* in tenths of deg. C */
300 }
301
302 /*
303 * Calculating current registers resolution:
304 *
305 * RSense stored in 10^-5 Ohm, so mesaurment voltage must be
306 * in 10^-11 Volts for get current in uA.
307 * 16 bit current reg fullscale +/-51.2mV is 102400 uV.
308 * So: 102400 / 65535 * 10^5 = 156252
309 */
max172xx_current_to_voltage(unsigned int reg)310 static int max172xx_current_to_voltage(unsigned int reg)
311 {
312 int val = (int16_t)reg;
313
314 return val * 156252;
315 }
316
max1720x_battery_get_property(struct power_supply * psy,enum power_supply_property psp,union power_supply_propval * val)317 static int max1720x_battery_get_property(struct power_supply *psy,
318 enum power_supply_property psp,
319 union power_supply_propval *val)
320 {
321 struct max1720x_device_info *info = power_supply_get_drvdata(psy);
322 unsigned int reg_val;
323 int ret = 0;
324
325 switch (psp) {
326 case POWER_SUPPLY_PROP_PRESENT:
327 /*
328 * POWER_SUPPLY_PROP_PRESENT will always readable via
329 * sysfs interface. Value return 0 if battery not
330 * present or unaccesable via I2c.
331 */
332 ret = regmap_read(info->regmap, MAX172XX_STATUS, ®_val);
333 if (ret < 0) {
334 val->intval = 0;
335 return 0;
336 }
337
338 val->intval = !FIELD_GET(MAX172XX_STATUS_BAT_ABSENT, reg_val);
339 break;
340 case POWER_SUPPLY_PROP_CAPACITY:
341 ret = regmap_read(info->regmap, MAX172XX_REPSOC, ®_val);
342 val->intval = max172xx_percent_to_ps(reg_val);
343 break;
344 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
345 ret = regmap_read(info->regmap, MAX172XX_BATT, ®_val);
346 val->intval = max172xx_voltage_to_ps(reg_val);
347 break;
348 case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
349 ret = regmap_read(info->regmap, MAX172XX_DESIGN_CAP, ®_val);
350 val->intval = max172xx_capacity_to_ps(reg_val);
351 break;
352 case POWER_SUPPLY_PROP_CHARGE_AVG:
353 ret = regmap_read(info->regmap, MAX172XX_REPCAP, ®_val);
354 val->intval = max172xx_capacity_to_ps(reg_val);
355 break;
356 case POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG:
357 ret = regmap_read(info->regmap, MAX172XX_TTE, ®_val);
358 val->intval = max172xx_time_to_ps(reg_val);
359 break;
360 case POWER_SUPPLY_PROP_TIME_TO_FULL_AVG:
361 ret = regmap_read(info->regmap, MAX172XX_TTF, ®_val);
362 val->intval = max172xx_time_to_ps(reg_val);
363 break;
364 case POWER_SUPPLY_PROP_TEMP:
365 ret = regmap_read(info->regmap, MAX172XX_TEMP, ®_val);
366 val->intval = max172xx_temperature_to_ps(reg_val);
367 break;
368 case POWER_SUPPLY_PROP_CURRENT_NOW:
369 ret = regmap_read(info->regmap, MAX172XX_CURRENT, ®_val);
370 val->intval = max172xx_current_to_voltage(reg_val) / info->rsense;
371 break;
372 case POWER_SUPPLY_PROP_CURRENT_AVG:
373 ret = regmap_read(info->regmap, MAX172XX_AVG_CURRENT, ®_val);
374 val->intval = max172xx_current_to_voltage(reg_val) / info->rsense;
375 break;
376 case POWER_SUPPLY_PROP_CHARGE_FULL:
377 ret = regmap_read(info->regmap, MAX172XX_FULL_CAP, ®_val);
378 val->intval = max172xx_capacity_to_ps(reg_val);
379 break;
380 case POWER_SUPPLY_PROP_MODEL_NAME:
381 ret = regmap_read(info->regmap, MAX172XX_DEV_NAME, ®_val);
382 reg_val = FIELD_GET(MAX172XX_DEV_NAME_TYPE_MASK, reg_val);
383 if (reg_val == MAX172XX_DEV_NAME_TYPE_MAX17201)
384 val->strval = max17201_model;
385 else if (reg_val == MAX172XX_DEV_NAME_TYPE_MAX17205)
386 val->strval = max17205_model;
387 else
388 return -ENODEV;
389 break;
390 case POWER_SUPPLY_PROP_MANUFACTURER:
391 val->strval = max1720x_manufacturer;
392 break;
393 default:
394 return -EINVAL;
395 }
396
397 return ret;
398 }
399
max1720x_read_temp(struct device * dev,u8 reg,char * buf)400 static int max1720x_read_temp(struct device *dev, u8 reg, char *buf)
401 {
402 struct power_supply *psy = dev_get_drvdata(dev);
403 struct max1720x_device_info *info = power_supply_get_drvdata(psy);
404 unsigned int val;
405 int ret;
406
407 ret = regmap_read(info->regmap_nv, reg, &val);
408 if (ret < 0)
409 return ret;
410
411 /*
412 * Temperature in degrees Celsius starting at absolute zero, -273C or
413 * 0K with an LSb of 0.1C
414 */
415 return sysfs_emit(buf, "%d\n", val - 2730);
416 }
417
temp_ain1_show(struct device * dev,struct device_attribute * attr,char * buf)418 static ssize_t temp_ain1_show(struct device *dev, struct device_attribute *attr,
419 char *buf)
420 {
421 return max1720x_read_temp(dev, MAX172XX_TEMP1, buf);
422 }
423
temp_ain2_show(struct device * dev,struct device_attribute * attr,char * buf)424 static ssize_t temp_ain2_show(struct device *dev, struct device_attribute *attr,
425 char *buf)
426 {
427 return max1720x_read_temp(dev, MAX172XX_TEMP2, buf);
428 }
429
temp_int_show(struct device * dev,struct device_attribute * attr,char * buf)430 static ssize_t temp_int_show(struct device *dev, struct device_attribute *attr,
431 char *buf)
432 {
433 return max1720x_read_temp(dev, MAX172XX_INT_TEMP, buf);
434 }
435
436 static DEVICE_ATTR_RO(temp_ain1);
437 static DEVICE_ATTR_RO(temp_ain2);
438 static DEVICE_ATTR_RO(temp_int);
439
440 static struct attribute *max1720x_attrs[] = {
441 &dev_attr_temp_ain1.attr,
442 &dev_attr_temp_ain2.attr,
443 &dev_attr_temp_int.attr,
444 NULL
445 };
446 ATTRIBUTE_GROUPS(max1720x);
447
448 static
max1720x_nvmem_reg_read(void * priv,unsigned int off,void * val,size_t len)449 int max1720x_nvmem_reg_read(void *priv, unsigned int off, void *val, size_t len)
450 {
451 struct max1720x_device_info *info = priv;
452 unsigned int reg = MAX1720X_NXTABLE0 + (off / 2);
453
454 return regmap_bulk_read(info->regmap_nv, reg, val, len / 2);
455 }
456
max1720x_unregister_ancillary(void * data)457 static void max1720x_unregister_ancillary(void *data)
458 {
459 struct max1720x_device_info *info = data;
460
461 i2c_unregister_device(info->ancillary);
462 }
463
max1720x_probe_nvmem(struct i2c_client * client,struct max1720x_device_info * info)464 static int max1720x_probe_nvmem(struct i2c_client *client,
465 struct max1720x_device_info *info)
466 {
467 struct device *dev = &client->dev;
468 struct nvmem_config nvmem_config = {
469 .dev = dev,
470 .name = "max1720x_nvmem",
471 .cells = max1720x_nvmem_cells,
472 .ncells = ARRAY_SIZE(max1720x_nvmem_cells),
473 .read_only = true,
474 .root_only = true,
475 .reg_read = max1720x_nvmem_reg_read,
476 .size = ARRAY_SIZE(max1720x_nvmem_cells) * 2,
477 .word_size = 2,
478 .stride = 2,
479 .priv = info,
480 };
481 struct nvmem_device *nvmem;
482 unsigned int val;
483 int ret;
484
485 info->ancillary = i2c_new_ancillary_device(client, "nvmem", 0xb);
486 if (IS_ERR(info->ancillary)) {
487 dev_err(dev, "Failed to initialize ancillary i2c device\n");
488 return PTR_ERR(info->ancillary);
489 }
490
491 ret = devm_add_action_or_reset(dev, max1720x_unregister_ancillary, info);
492 if (ret) {
493 dev_err(dev, "Failed to add unregister callback\n");
494 return ret;
495 }
496
497 info->regmap_nv = devm_regmap_init_i2c(info->ancillary,
498 &max1720x_nvmem_regmap_cfg);
499 if (IS_ERR(info->regmap_nv)) {
500 dev_err(dev, "regmap initialization of nvmem failed\n");
501 return PTR_ERR(info->regmap_nv);
502 }
503
504 ret = regmap_read(info->regmap_nv, MAX1720X_NRSENSE, &val);
505 if (ret < 0) {
506 dev_err(dev, "Failed to read sense resistor value\n");
507 return ret;
508 }
509
510 info->rsense = val;
511 if (!info->rsense) {
512 dev_warn(dev, "RSense not calibrated, set 10 mOhms!\n");
513 info->rsense = 1000; /* in regs in 10^-5 */
514 }
515
516 nvmem = devm_nvmem_register(dev, &nvmem_config);
517 if (IS_ERR(nvmem)) {
518 dev_err(dev, "Could not register nvmem!");
519 return PTR_ERR(nvmem);
520 }
521
522 return 0;
523 }
524
525 static const struct power_supply_desc max1720x_bat_desc = {
526 .name = "max1720x",
527 .no_thermal = true,
528 .type = POWER_SUPPLY_TYPE_BATTERY,
529 .properties = max1720x_battery_props,
530 .num_properties = ARRAY_SIZE(max1720x_battery_props),
531 .get_property = max1720x_battery_get_property,
532 };
533
max1720x_probe(struct i2c_client * client)534 static int max1720x_probe(struct i2c_client *client)
535 {
536 struct power_supply_config psy_cfg = {};
537 struct device *dev = &client->dev;
538 struct max1720x_device_info *info;
539 struct power_supply *bat;
540 int ret;
541
542 info = devm_kzalloc(dev, sizeof(*info), GFP_KERNEL);
543 if (!info)
544 return -ENOMEM;
545
546 psy_cfg.drv_data = info;
547 psy_cfg.fwnode = dev_fwnode(dev);
548 psy_cfg.attr_grp = max1720x_groups;
549 i2c_set_clientdata(client, info);
550 info->regmap = devm_regmap_init_i2c(client, &max1720x_regmap_cfg);
551 if (IS_ERR(info->regmap))
552 return dev_err_probe(dev, PTR_ERR(info->regmap),
553 "regmap initialization failed\n");
554
555 ret = max1720x_probe_nvmem(client, info);
556 if (ret)
557 return dev_err_probe(dev, ret, "Failed to probe nvmem\n");
558
559 bat = devm_power_supply_register(dev, &max1720x_bat_desc, &psy_cfg);
560 if (IS_ERR(bat))
561 return dev_err_probe(dev, PTR_ERR(bat),
562 "Failed to register power supply\n");
563
564 return 0;
565 }
566
567 static const struct of_device_id max1720x_of_match[] = {
568 { .compatible = "maxim,max17201" },
569 {}
570 };
571 MODULE_DEVICE_TABLE(of, max1720x_of_match);
572
573 static struct i2c_driver max1720x_i2c_driver = {
574 .driver = {
575 .name = "max1720x",
576 .of_match_table = max1720x_of_match,
577 },
578 .probe = max1720x_probe,
579 };
580 module_i2c_driver(max1720x_i2c_driver);
581
582 MODULE_LICENSE("GPL");
583 MODULE_AUTHOR("Dimitri Fedrau <[email protected]>");
584 MODULE_DESCRIPTION("Maxim MAX17201/MAX17205 Fuel Gauge IC driver");
585