1 /*
2 * 1-Wire implementation for Maxim Semiconductor
3 * MAX7211/MAX17215 standalone fuel gauge chip
4 *
5 * Copyright (C) 2017 Radioavionica Corporation
6 * Author: Alex A. Mihaylov <minimumlaw@rambler.ru>
7 *
8 * Use consistent with the GNU GPL is permitted,
9 * provided that this copyright notice is
10 * preserved in its entirety in all copies and derived works.
11 *
12 */
13
14 #include <linux/module.h>
15 #include <linux/slab.h>
16 #include <linux/w1.h>
17 #include <linux/regmap.h>
18 #include <linux/power_supply.h>
19
20 #define W1_MAX1721X_FAMILY_ID 0x26
21 #define DEF_DEV_NAME_MAX17211 "MAX17211"
22 #define DEF_DEV_NAME_MAX17215 "MAX17215"
23 #define DEF_DEV_NAME_UNKNOWN "UNKNOWN"
24 #define DEF_MFG_NAME "MAXIM"
25
26 #define PSY_MAX_NAME_LEN 32
27
28 /* Number of valid register addresses in W1 mode */
29 #define MAX1721X_MAX_REG_NR 0x1EF
30
31 /* Factory settings (nonvolatile registers) (W1 specific) */
32 #define MAX1721X_REG_NRSENSE 0x1CF /* RSense in 10^-5 Ohm */
33 /* Strings */
34 #define MAX1721X_REG_MFG_STR 0x1CC
35 #define MAX1721X_REG_MFG_NUMB 3
36 #define MAX1721X_REG_DEV_STR 0x1DB
37 #define MAX1721X_REG_DEV_NUMB 5
38 /* HEX Strings */
39 #define MAX1721X_REG_SER_HEX 0x1D8
40
41 /* MAX172XX Output Registers for W1 chips */
42 #define MAX172XX_REG_STATUS 0x000 /* status reg */
43 #define MAX172XX_BAT_PRESENT (1<<4) /* battery connected bit */
44 #define MAX172XX_REG_DEVNAME 0x021 /* chip config */
45 #define MAX172XX_DEV_MASK 0x000F /* chip type mask */
46 #define MAX172X1_DEV 0x0001
47 #define MAX172X5_DEV 0x0005
48 #define MAX172XX_REG_TEMP 0x008 /* Temperature */
49 #define MAX172XX_REG_BATT 0x0DA /* Battery voltage */
50 #define MAX172XX_REG_CURRENT 0x00A /* Actual current */
51 #define MAX172XX_REG_AVGCURRENT 0x00B /* Average current */
52 #define MAX172XX_REG_REPSOC 0x006 /* Percentage of charge */
53 #define MAX172XX_REG_DESIGNCAP 0x018 /* Design capacity */
54 #define MAX172XX_REG_REPCAP 0x005 /* Average capacity */
55 #define MAX172XX_REG_TTE 0x011 /* Time to empty */
56 #define MAX172XX_REG_TTF 0x020 /* Time to full */
57
58 struct max17211_device_info {
59 char name[PSY_MAX_NAME_LEN];
60 struct power_supply *bat;
61 struct power_supply_desc bat_desc;
62 struct device *w1_dev;
63 struct regmap *regmap;
64 /* battery design format */
65 unsigned int rsense; /* in tenths uOhm */
66 char DeviceName[2 * MAX1721X_REG_DEV_NUMB + 1];
67 char ManufacturerName[2 * MAX1721X_REG_MFG_NUMB + 1];
68 char SerialNumber[13]; /* see get_sn_str() later for comment */
69 };
70
71 /* Convert regs value to power_supply units */
72
max172xx_time_to_ps(unsigned int reg)73 static inline int max172xx_time_to_ps(unsigned int reg)
74 {
75 return reg * 5625 / 1000; /* in sec. */
76 }
77
max172xx_percent_to_ps(unsigned int reg)78 static inline int max172xx_percent_to_ps(unsigned int reg)
79 {
80 return reg / 256; /* in percent from 0 to 100 */
81 }
82
max172xx_voltage_to_ps(unsigned int reg)83 static inline int max172xx_voltage_to_ps(unsigned int reg)
84 {
85 return reg * 1250; /* in uV */
86 }
87
max172xx_capacity_to_ps(unsigned int reg)88 static inline int max172xx_capacity_to_ps(unsigned int reg)
89 {
90 return reg * 500; /* in uAh */
91 }
92
93 /*
94 * Current and temperature is signed values, so unsigned regs
95 * value must be converted to signed type
96 */
97
max172xx_temperature_to_ps(unsigned int reg)98 static inline int max172xx_temperature_to_ps(unsigned int reg)
99 {
100 int val = (int16_t)(reg);
101
102 return val * 10 / 256; /* in tenths of deg. C */
103 }
104
105 /*
106 * Calculating current registers resolution:
107 *
108 * RSense stored in 10^-5 Ohm, so measurement voltage must be
109 * in 10^-11 Volts for get current in uA.
110 * 16 bit current reg fullscale +/-51.2mV is 102400 uV.
111 * So: 102400 / 65535 * 10^5 = 156252
112 */
max172xx_current_to_voltage(unsigned int reg)113 static inline int max172xx_current_to_voltage(unsigned int reg)
114 {
115 int val = (int16_t)(reg);
116
117 return val * 156252;
118 }
119
120
121 static inline struct max17211_device_info *
to_device_info(struct power_supply * psy)122 to_device_info(struct power_supply *psy)
123 {
124 return power_supply_get_drvdata(psy);
125 }
126
max1721x_battery_get_property(struct power_supply * psy,enum power_supply_property psp,union power_supply_propval * val)127 static int max1721x_battery_get_property(struct power_supply *psy,
128 enum power_supply_property psp,
129 union power_supply_propval *val)
130 {
131 struct max17211_device_info *info = to_device_info(psy);
132 unsigned int reg = 0;
133 int ret = 0;
134
135 switch (psp) {
136 case POWER_SUPPLY_PROP_PRESENT:
137 /*
138 * POWER_SUPPLY_PROP_PRESENT will always readable via
139 * sysfs interface. Value return 0 if battery not
140 * present or unaccessible via W1.
141 */
142 val->intval =
143 regmap_read(info->regmap, MAX172XX_REG_STATUS,
144 ®) ? 0 : !(reg & MAX172XX_BAT_PRESENT);
145 break;
146 case POWER_SUPPLY_PROP_CAPACITY:
147 ret = regmap_read(info->regmap, MAX172XX_REG_REPSOC, ®);
148 val->intval = max172xx_percent_to_ps(reg);
149 break;
150 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
151 ret = regmap_read(info->regmap, MAX172XX_REG_BATT, ®);
152 val->intval = max172xx_voltage_to_ps(reg);
153 break;
154 case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
155 ret = regmap_read(info->regmap, MAX172XX_REG_DESIGNCAP, ®);
156 val->intval = max172xx_capacity_to_ps(reg);
157 break;
158 case POWER_SUPPLY_PROP_CHARGE_AVG:
159 ret = regmap_read(info->regmap, MAX172XX_REG_REPCAP, ®);
160 val->intval = max172xx_capacity_to_ps(reg);
161 break;
162 case POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG:
163 ret = regmap_read(info->regmap, MAX172XX_REG_TTE, ®);
164 val->intval = max172xx_time_to_ps(reg);
165 break;
166 case POWER_SUPPLY_PROP_TIME_TO_FULL_AVG:
167 ret = regmap_read(info->regmap, MAX172XX_REG_TTF, ®);
168 val->intval = max172xx_time_to_ps(reg);
169 break;
170 case POWER_SUPPLY_PROP_TEMP:
171 ret = regmap_read(info->regmap, MAX172XX_REG_TEMP, ®);
172 val->intval = max172xx_temperature_to_ps(reg);
173 break;
174 /* We need signed current, so must cast info->rsense to signed type */
175 case POWER_SUPPLY_PROP_CURRENT_NOW:
176 ret = regmap_read(info->regmap, MAX172XX_REG_CURRENT, ®);
177 val->intval =
178 max172xx_current_to_voltage(reg) / (int)info->rsense;
179 break;
180 case POWER_SUPPLY_PROP_CURRENT_AVG:
181 ret = regmap_read(info->regmap, MAX172XX_REG_AVGCURRENT, ®);
182 val->intval =
183 max172xx_current_to_voltage(reg) / (int)info->rsense;
184 break;
185 /*
186 * Strings already received and inited by probe.
187 * We do dummy read for check battery still available.
188 */
189 case POWER_SUPPLY_PROP_MODEL_NAME:
190 ret = regmap_read(info->regmap, MAX1721X_REG_DEV_STR, ®);
191 val->strval = info->DeviceName;
192 break;
193 case POWER_SUPPLY_PROP_MANUFACTURER:
194 ret = regmap_read(info->regmap, MAX1721X_REG_MFG_STR, ®);
195 val->strval = info->ManufacturerName;
196 break;
197 case POWER_SUPPLY_PROP_SERIAL_NUMBER:
198 ret = regmap_read(info->regmap, MAX1721X_REG_SER_HEX, ®);
199 val->strval = info->SerialNumber;
200 break;
201 default:
202 ret = -EINVAL;
203 }
204
205 return ret;
206 }
207
208 static enum power_supply_property max1721x_battery_props[] = {
209 /* int */
210 POWER_SUPPLY_PROP_PRESENT,
211 POWER_SUPPLY_PROP_CAPACITY,
212 POWER_SUPPLY_PROP_VOLTAGE_NOW,
213 POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
214 POWER_SUPPLY_PROP_CHARGE_AVG,
215 POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG,
216 POWER_SUPPLY_PROP_TIME_TO_FULL_AVG,
217 POWER_SUPPLY_PROP_TEMP,
218 POWER_SUPPLY_PROP_CURRENT_NOW,
219 POWER_SUPPLY_PROP_CURRENT_AVG,
220 /* strings */
221 POWER_SUPPLY_PROP_MODEL_NAME,
222 POWER_SUPPLY_PROP_MANUFACTURER,
223 POWER_SUPPLY_PROP_SERIAL_NUMBER,
224 };
225
get_string(struct max17211_device_info * info,uint16_t reg,uint8_t nr,char * str)226 static int get_string(struct max17211_device_info *info,
227 uint16_t reg, uint8_t nr, char *str)
228 {
229 unsigned int val;
230
231 if (!str || !(reg == MAX1721X_REG_MFG_STR ||
232 reg == MAX1721X_REG_DEV_STR))
233 return -EFAULT;
234
235 while (nr--) {
236 if (regmap_read(info->regmap, reg++, &val))
237 return -EFAULT;
238 *str++ = val>>8 & 0x00FF;
239 *str++ = val & 0x00FF;
240 }
241 return 0;
242 }
243
244 /* Maxim say: Serial number is a hex string up to 12 hex characters */
get_sn_string(struct max17211_device_info * info,char * str)245 static int get_sn_string(struct max17211_device_info *info, char *str)
246 {
247 unsigned int val[3];
248
249 if (!str)
250 return -EFAULT;
251
252 if (regmap_read(info->regmap, MAX1721X_REG_SER_HEX, &val[0]))
253 return -EFAULT;
254 if (regmap_read(info->regmap, MAX1721X_REG_SER_HEX + 1, &val[1]))
255 return -EFAULT;
256 if (regmap_read(info->regmap, MAX1721X_REG_SER_HEX + 2, &val[2]))
257 return -EFAULT;
258
259 snprintf(str, 13, "%04X%04X%04X", val[0], val[1], val[2]);
260 return 0;
261 }
262
263 /*
264 * MAX1721x registers description for w1-regmap
265 */
266 static const struct regmap_range max1721x_allow_range[] = {
267 regmap_reg_range(0, 0xDF), /* volatile data */
268 regmap_reg_range(0x180, 0x1DF), /* non-volatile memory */
269 regmap_reg_range(0x1E0, 0x1EF), /* non-volatile history (unused) */
270 };
271
272 static const struct regmap_range max1721x_deny_range[] = {
273 /* volatile data unused registers */
274 regmap_reg_range(0x24, 0x26),
275 regmap_reg_range(0x30, 0x31),
276 regmap_reg_range(0x33, 0x34),
277 regmap_reg_range(0x37, 0x37),
278 regmap_reg_range(0x3B, 0x3C),
279 regmap_reg_range(0x40, 0x41),
280 regmap_reg_range(0x43, 0x44),
281 regmap_reg_range(0x47, 0x49),
282 regmap_reg_range(0x4B, 0x4C),
283 regmap_reg_range(0x4E, 0xAF),
284 regmap_reg_range(0xB1, 0xB3),
285 regmap_reg_range(0xB5, 0xB7),
286 regmap_reg_range(0xBF, 0xD0),
287 regmap_reg_range(0xDB, 0xDB),
288 /* hole between volatile and non-volatile registers */
289 regmap_reg_range(0xE0, 0x17F),
290 };
291
292 static const struct regmap_access_table max1721x_regs = {
293 .yes_ranges = max1721x_allow_range,
294 .n_yes_ranges = ARRAY_SIZE(max1721x_allow_range),
295 .no_ranges = max1721x_deny_range,
296 .n_no_ranges = ARRAY_SIZE(max1721x_deny_range),
297 };
298
299 /*
300 * Model Gauge M5 Algorithm output register
301 * Volatile data (must not be cached)
302 */
303 static const struct regmap_range max1721x_volatile_allow[] = {
304 regmap_reg_range(0, 0xDF),
305 };
306
307 static const struct regmap_access_table max1721x_volatile_regs = {
308 .yes_ranges = max1721x_volatile_allow,
309 .n_yes_ranges = ARRAY_SIZE(max1721x_volatile_allow),
310 };
311
312 /*
313 * W1-regmap config
314 */
315 static const struct regmap_config max1721x_regmap_w1_config = {
316 .reg_bits = 16,
317 .val_bits = 16,
318 .rd_table = &max1721x_regs,
319 .volatile_table = &max1721x_volatile_regs,
320 .max_register = MAX1721X_MAX_REG_NR,
321 };
322
devm_w1_max1721x_add_device(struct w1_slave * sl)323 static int devm_w1_max1721x_add_device(struct w1_slave *sl)
324 {
325 struct power_supply_config psy_cfg = {};
326 struct max17211_device_info *info;
327
328 info = devm_kzalloc(&sl->dev, sizeof(*info), GFP_KERNEL);
329 if (!info)
330 return -ENOMEM;
331
332 sl->family_data = (void *)info;
333 info->w1_dev = &sl->dev;
334
335 /*
336 * power_supply class battery name translated from W1 slave device
337 * unique ID (look like 26-0123456789AB) to "max1721x-0123456789AB\0"
338 * so, 26 (device family) correspond to max1721x devices.
339 * Device name still unique for any number of connected devices.
340 */
341 snprintf(info->name, sizeof(info->name),
342 "max1721x-%012X", (unsigned int)sl->reg_num.id);
343 info->bat_desc.name = info->name;
344
345 /*
346 * FixMe: battery device name exceed max len for thermal_zone device
347 * name and translation to thermal_zone must be disabled.
348 */
349 info->bat_desc.no_thermal = true;
350 info->bat_desc.type = POWER_SUPPLY_TYPE_BATTERY;
351 info->bat_desc.properties = max1721x_battery_props;
352 info->bat_desc.num_properties = ARRAY_SIZE(max1721x_battery_props);
353 info->bat_desc.get_property = max1721x_battery_get_property;
354 psy_cfg.drv_data = info;
355
356 /* regmap init */
357 info->regmap = devm_regmap_init_w1(info->w1_dev,
358 &max1721x_regmap_w1_config);
359 if (IS_ERR(info->regmap)) {
360 int err = PTR_ERR(info->regmap);
361
362 dev_err(info->w1_dev, "Failed to allocate register map: %d\n",
363 err);
364 return err;
365 }
366
367 /* rsense init */
368 info->rsense = 0;
369 if (regmap_read(info->regmap, MAX1721X_REG_NRSENSE, &info->rsense)) {
370 dev_err(info->w1_dev, "Can't read RSense. Hardware error.\n");
371 return -ENODEV;
372 }
373
374 if (!info->rsense) {
375 dev_warn(info->w1_dev, "RSense not calibrated, set 10 mOhms!\n");
376 info->rsense = 1000; /* in regs in 10^-5 */
377 }
378 dev_info(info->w1_dev, "RSense: %d mOhms.\n", info->rsense / 100);
379
380 if (get_string(info, MAX1721X_REG_MFG_STR,
381 MAX1721X_REG_MFG_NUMB, info->ManufacturerName)) {
382 dev_err(info->w1_dev, "Can't read manufacturer. Hardware error.\n");
383 return -ENODEV;
384 }
385
386 if (!info->ManufacturerName[0])
387 strscpy(info->ManufacturerName, DEF_MFG_NAME,
388 2 * MAX1721X_REG_MFG_NUMB);
389
390 if (get_string(info, MAX1721X_REG_DEV_STR,
391 MAX1721X_REG_DEV_NUMB, info->DeviceName)) {
392 dev_err(info->w1_dev, "Can't read device. Hardware error.\n");
393 return -ENODEV;
394 }
395 if (!info->DeviceName[0]) {
396 unsigned int dev_name;
397
398 if (regmap_read(info->regmap,
399 MAX172XX_REG_DEVNAME, &dev_name)) {
400 dev_err(info->w1_dev, "Can't read device name reg.\n");
401 return -ENODEV;
402 }
403
404 switch (dev_name & MAX172XX_DEV_MASK) {
405 case MAX172X1_DEV:
406 strscpy(info->DeviceName, DEF_DEV_NAME_MAX17211,
407 2 * MAX1721X_REG_DEV_NUMB);
408 break;
409 case MAX172X5_DEV:
410 strscpy(info->DeviceName, DEF_DEV_NAME_MAX17215,
411 2 * MAX1721X_REG_DEV_NUMB);
412 break;
413 default:
414 strscpy(info->DeviceName, DEF_DEV_NAME_UNKNOWN,
415 2 * MAX1721X_REG_DEV_NUMB);
416 }
417 }
418
419 if (get_sn_string(info, info->SerialNumber)) {
420 dev_err(info->w1_dev, "Can't read serial. Hardware error.\n");
421 return -ENODEV;
422 }
423
424 info->bat = devm_power_supply_register(&sl->dev, &info->bat_desc,
425 &psy_cfg);
426 if (IS_ERR(info->bat)) {
427 dev_err(info->w1_dev, "failed to register battery\n");
428 return PTR_ERR(info->bat);
429 }
430
431 return 0;
432 }
433
434 static const struct w1_family_ops w1_max1721x_fops = {
435 .add_slave = devm_w1_max1721x_add_device,
436 };
437
438 static struct w1_family w1_max1721x_family = {
439 .fid = W1_MAX1721X_FAMILY_ID,
440 .fops = &w1_max1721x_fops,
441 };
442
443 module_w1_family(w1_max1721x_family);
444
445 MODULE_LICENSE("GPL");
446 MODULE_AUTHOR("Alex A. Mihaylov <minimumlaw@rambler.ru>");
447 MODULE_DESCRIPTION("Maxim MAX17211/MAX17215 Fuel Gauge IC driver");
448 MODULE_ALIAS("w1-family-" __stringify(W1_MAX1721X_FAMILY_ID));
449