| 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 <[email protected]> |
| 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(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 |
|
| 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 */ |
| 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 |
|
| 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 <[email protected]>"); |
| 447 |
MODULE_DESCRIPTION("Maxim MAX17211/MAX17215 Fuel Gauge IC driver"); |
| 448 |
MODULE_ALIAS("w1-family-" __stringify(W1_MAX1721X_FAMILY_ID)); |