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 | |
73 | static inline int max172xx_time_to_ps(unsigned int reg) |
74 | { |
75 | return reg * 5625 / 1000; /* in sec. */ |
76 | } |
77 | |
78 | static inline int max172xx_percent_to_ps(unsigned int reg) |
79 | { |
80 | return reg / 256; /* in percent from 0 to 100 */ |
81 | } |
82 | |
83 | static inline int max172xx_voltage_to_ps(unsigned int reg) |
84 | { |
85 | return reg * 1250; /* in uV */ |
86 | } |
87 | |
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 | |
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 | */ |
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 * |
122 | to_device_info(struct power_supply *psy) |
123 | { |
124 | return power_supply_get_drvdata(psy); |
125 | } |
126 | |
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(map: info->regmap, MAX172XX_REG_STATUS, |
144 | val: ®) ? 0 : !(reg & MAX172XX_BAT_PRESENT); |
145 | break; |
146 | case POWER_SUPPLY_PROP_CAPACITY: |
147 | ret = regmap_read(map: info->regmap, MAX172XX_REG_REPSOC, val: ®); |
148 | val->intval = max172xx_percent_to_ps(reg); |
149 | break; |
150 | case POWER_SUPPLY_PROP_VOLTAGE_NOW: |
151 | ret = regmap_read(map: info->regmap, MAX172XX_REG_BATT, val: ®); |
152 | val->intval = max172xx_voltage_to_ps(reg); |
153 | break; |
154 | case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN: |
155 | ret = regmap_read(map: info->regmap, MAX172XX_REG_DESIGNCAP, val: ®); |
156 | val->intval = max172xx_capacity_to_ps(reg); |
157 | break; |
158 | case POWER_SUPPLY_PROP_CHARGE_AVG: |
159 | ret = regmap_read(map: info->regmap, MAX172XX_REG_REPCAP, val: ®); |
160 | val->intval = max172xx_capacity_to_ps(reg); |
161 | break; |
162 | case POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG: |
163 | ret = regmap_read(map: info->regmap, MAX172XX_REG_TTE, val: ®); |
164 | val->intval = max172xx_time_to_ps(reg); |
165 | break; |
166 | case POWER_SUPPLY_PROP_TIME_TO_FULL_AVG: |
167 | ret = regmap_read(map: info->regmap, MAX172XX_REG_TTF, val: ®); |
168 | val->intval = max172xx_time_to_ps(reg); |
169 | break; |
170 | case POWER_SUPPLY_PROP_TEMP: |
171 | ret = regmap_read(map: info->regmap, MAX172XX_REG_TEMP, val: ®); |
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(map: info->regmap, MAX172XX_REG_CURRENT, val: ®); |
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(map: info->regmap, MAX172XX_REG_AVGCURRENT, val: ®); |
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(map: info->regmap, MAX1721X_REG_DEV_STR, val: ®); |
191 | val->strval = info->DeviceName; |
192 | break; |
193 | case POWER_SUPPLY_PROP_MANUFACTURER: |
194 | ret = regmap_read(map: info->regmap, MAX1721X_REG_MFG_STR, val: ®); |
195 | val->strval = info->ManufacturerName; |
196 | break; |
197 | case POWER_SUPPLY_PROP_SERIAL_NUMBER: |
198 | ret = regmap_read(map: info->regmap, MAX1721X_REG_SER_HEX, val: ®); |
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 | |
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(map: info->regmap, reg: reg++, val: &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 */ |
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(map: info->regmap, MAX1721X_REG_SER_HEX, val: &val[0])) |
253 | return -EFAULT; |
254 | if (regmap_read(map: info->regmap, MAX1721X_REG_SER_HEX + 1, val: &val[1])) |
255 | return -EFAULT; |
256 | if (regmap_read(map: info->regmap, MAX1721X_REG_SER_HEX + 2, val: &val[2])) |
257 | return -EFAULT; |
258 | |
259 | snprintf(buf: str, size: 13, fmt: "%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 | |
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(dev: &sl->dev, size: 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(buf: info->name, size: sizeof(info->name), |
342 | fmt: "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(ptr: info->regmap)) { |
360 | int err = PTR_ERR(ptr: 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(map: info->regmap, MAX1721X_REG_NRSENSE, val: &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, str: 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(p: info->ManufacturerName, DEF_MFG_NAME, |
388 | size: 2 * MAX1721X_REG_MFG_NUMB); |
389 | |
390 | if (get_string(info, MAX1721X_REG_DEV_STR, |
391 | MAX1721X_REG_DEV_NUMB, str: 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(map: info->regmap, |
399 | MAX172XX_REG_DEVNAME, val: &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(p: info->DeviceName, DEF_DEV_NAME_MAX17211, |
407 | size: 2 * MAX1721X_REG_DEV_NUMB); |
408 | break; |
409 | case MAX172X5_DEV: |
410 | strscpy(p: info->DeviceName, DEF_DEV_NAME_MAX17215, |
411 | size: 2 * MAX1721X_REG_DEV_NUMB); |
412 | break; |
413 | default: |
414 | strscpy(p: info->DeviceName, DEF_DEV_NAME_UNKNOWN, |
415 | size: 2 * MAX1721X_REG_DEV_NUMB); |
416 | } |
417 | } |
418 | |
419 | if (get_sn_string(info, str: 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(parent: &sl->dev, desc: &info->bat_desc, |
425 | cfg: &psy_cfg); |
426 | if (IS_ERR(ptr: info->bat)) { |
427 | dev_err(info->w1_dev, "failed to register battery\n" ); |
428 | return PTR_ERR(ptr: 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 | |