Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S376700AbdD2OfB (ORCPT ); Sat, 29 Apr 2017 10:35:01 -0400 Received: from huan1.mail.rambler.ru ([81.19.78.107]:57036 "EHLO huan1.mail.rambler.ru" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S376659AbdD2Oel (ORCPT ); Sat, 29 Apr 2017 10:34:41 -0400 From: "Alex A. Mihaylov" To: linux-kernel@vger.kernel.org Cc: zbr@ioremap.net, greg@kroah.com, "Alex A. Mihaylov" Subject: [PATCH 2/2] Add driver for MAX17211/MAX17215 fuel gauge Date: Sat, 29 Apr 2017 17:34:29 +0300 Message-Id: <20170429143429.5685-3-minimumlaw@rambler.ru> X-Mailer: git-send-email 2.8.4 (Apple Git-73) In-Reply-To: <20170429143429.5685-1-minimumlaw@rambler.ru> References: <20170429143429.5685-1-minimumlaw@rambler.ru> X-Rambler-User: minimumlaw@rambler.ru/178.70.112.37 Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Length: 10798 Lines: 354 Maxim Semiconductor MAX17211/MAX17215 single/multi-cell fuel gauge monitor with M5 Fuel Gauge algorithm This driver provide userspace access to MAX17211/MAX17215 data with power_supply class drivers. --- drivers/power/supply/Kconfig | 8 + drivers/power/supply/Makefile | 1 + drivers/power/supply/max1721x_battery.c | 303 ++++++++++++++++++++++++++++++++ 3 files changed, 312 insertions(+) create mode 100644 drivers/power/supply/max1721x_battery.c diff --git a/drivers/power/supply/Kconfig b/drivers/power/supply/Kconfig index 76806a0..25fe441 100644 --- a/drivers/power/supply/Kconfig +++ b/drivers/power/supply/Kconfig @@ -117,6 +117,14 @@ config BATTERY_DS2782 Say Y here to enable support for the DS2782/DS2786 standalone battery gas-gauge. +config BATTERY_MAX1721X + tristate "MAX17211/MAX17215 standalone gas-gauge" + depends on W1 + select W1_SLAVE_MAX1721X + help + Say Y here to enable support for the MAX17211/MAX17215 standalone + battery gas-gauge. + config BATTERY_PMU tristate "Apple PMU battery" depends on PPC32 && ADB_PMU diff --git a/drivers/power/supply/Makefile b/drivers/power/supply/Makefile index 36c599d..1e5546d 100644 --- a/drivers/power/supply/Makefile +++ b/drivers/power/supply/Makefile @@ -22,6 +22,7 @@ obj-$(CONFIG_BATTERY_DS2760) += ds2760_battery.o obj-$(CONFIG_BATTERY_DS2780) += ds2780_battery.o obj-$(CONFIG_BATTERY_DS2781) += ds2781_battery.o obj-$(CONFIG_BATTERY_DS2782) += ds2782_battery.o +obj-$(CONFIG_BATTERY_MAX1721X) += max1721x_battery.o obj-$(CONFIG_BATTERY_GAUGE_LTC2941) += ltc2941-battery-gauge.o obj-$(CONFIG_BATTERY_GOLDFISH) += goldfish_battery.o obj-$(CONFIG_BATTERY_PMU) += pmu_battery.o diff --git a/drivers/power/supply/max1721x_battery.c b/drivers/power/supply/max1721x_battery.c new file mode 100644 index 0000000..ff77d3f --- /dev/null +++ b/drivers/power/supply/max1721x_battery.c @@ -0,0 +1,303 @@ +/* + * 1-wire client/driver for the Maxim MAX17211/MAX17215 Fuel Gauge IC + * + * Author: Alex A. Mihaylov + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. + * + */ + +#include +#include +#include +#include +#include +#include +#include + +#include "../../w1/w1.h" +#include "../../w1/slaves/w1_max1721x.h" + +#define DEF_DEV_NAME_MAX17211 "MAX17211" +#define DEF_DEV_NAME_MAX17215 "MAX17215" +#define DEF_DEV_NAME_UNKNOWN "UNKNOWN" +#define DEF_MFG_NAME "MAXIM" + +struct max17211_device_info { + struct device *dev; + struct power_supply *bat; + struct power_supply_desc bat_desc; + struct device *w1_dev; + /* battery design format */ + uint16_t rsense; /* in tenths uOhm */ + char DeviceName[2 * MAX1721X_REG_DEV_NUMB + 1]; + char ManufacturerName[2 * MAX1721X_REG_MFG_NUMB + 1]; + char SerialNumber[13]; /* see get_sn_str() later for comment */ +}; + +static inline struct max17211_device_info * +to_device_info(struct power_supply *psy) +{ + return power_supply_get_drvdata(psy); +} + +static int max1721x_battery_get_property(struct power_supply *psy, + enum power_supply_property psp, + union power_supply_propval *val) +{ + struct max17211_device_info *info = to_device_info(psy); + uint16_t reg; + int ret = 0; + + switch (psp) { + case POWER_SUPPLY_PROP_PRESENT: + /* + * POWER_SUPPLY_PROP_PRESENT will always readable via + * sysfs interface. Value return 0 if battery not + * present or unaccesable via W1. + */ + val->intval = + w1_max1721x_reg_get(info->w1_dev, MAX172XX_REG_STATUS, + ®) ? 0 : !(reg & MAX172XX_BAT_PRESENT); + break; + case POWER_SUPPLY_PROP_CAPACITY: + ret = w1_max1721x_reg_get(info->w1_dev, + MAX172XX_REG_REPSOC, ®); + val->intval = max172xx_percent_to_ps(reg); + break; + case POWER_SUPPLY_PROP_VOLTAGE_NOW: + ret = w1_max1721x_reg_get(info->w1_dev, + MAX172XX_REG_BATT, ®); + val->intval = max172xx_voltage_to_ps(reg); + break; + case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN: + ret = w1_max1721x_reg_get(info->w1_dev, + MAX172XX_REG_DESIGNCAP, ®); + val->intval = max172xx_capacity_to_ps(reg); + break; + case POWER_SUPPLY_PROP_CHARGE_AVG: + ret = w1_max1721x_reg_get(info->w1_dev, + MAX172XX_REG_REPCAP, ®); + val->intval = max172xx_capacity_to_ps(reg); + break; + case POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG: + ret = w1_max1721x_reg_get(info->w1_dev, + MAX172XX_REG_TTE, ®); + val->intval = max172xx_time_to_ps(reg); + break; + case POWER_SUPPLY_PROP_TIME_TO_FULL_AVG: + ret = w1_max1721x_reg_get(info->w1_dev, + MAX172XX_REG_TTF, ®); + val->intval = max172xx_time_to_ps(reg); + break; + case POWER_SUPPLY_PROP_TEMP: + ret = w1_max1721x_reg_get(info->w1_dev, + MAX172XX_REG_TEMP, ®); + val->intval = max172xx_temperature_to_ps(reg); + break; + case POWER_SUPPLY_PROP_CURRENT_NOW: + ret = w1_max1721x_reg_get(info->w1_dev, + MAX172XX_REG_CURRENT, ®); + val->intval = max172xx_current_to_voltage(reg) / info->rsense; + break; + case POWER_SUPPLY_PROP_CURRENT_AVG: + ret = w1_max1721x_reg_get(info->w1_dev, + MAX172XX_REG_AVGCURRENT, ®); + val->intval = max172xx_current_to_voltage(reg) / info->rsense; + break; + /* + * Strings already received and inited by probe. + * We do dummy read for check battery still available. + */ + case POWER_SUPPLY_PROP_MODEL_NAME: + ret = w1_max1721x_reg_get(info->w1_dev, + MAX1721X_REG_DEV_STR, ®); + val->strval = info->DeviceName; + break; + case POWER_SUPPLY_PROP_MANUFACTURER: + ret = w1_max1721x_reg_get(info->w1_dev, + MAX1721X_REG_MFG_STR, ®); + val->strval = info->ManufacturerName; + break; + case POWER_SUPPLY_PROP_SERIAL_NUMBER: + ret = w1_max1721x_reg_get(info->w1_dev, + MAX1721X_REG_SER_HEX, ®); + val->strval = info->SerialNumber; + break; + default: + ret = -EINVAL; + } + + return ret; +} + +static enum power_supply_property max1721x_battery_props[] = { + /* int */ + POWER_SUPPLY_PROP_PRESENT, + POWER_SUPPLY_PROP_CAPACITY, + POWER_SUPPLY_PROP_VOLTAGE_NOW, + POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN, + POWER_SUPPLY_PROP_CHARGE_AVG, + POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG, + POWER_SUPPLY_PROP_TIME_TO_FULL_AVG, + POWER_SUPPLY_PROP_TEMP, + POWER_SUPPLY_PROP_CURRENT_NOW, + POWER_SUPPLY_PROP_CURRENT_AVG, + /* strings */ + POWER_SUPPLY_PROP_MODEL_NAME, + POWER_SUPPLY_PROP_MANUFACTURER, + POWER_SUPPLY_PROP_SERIAL_NUMBER, +}; + +static int get_string(struct device *dev, uint16_t reg, uint8_t nr, char *str) +{ + uint16_t val; + + if (!str || !(reg == MAX1721X_REG_MFG_STR || + reg == MAX1721X_REG_DEV_STR)) + return -EFAULT; + + while (nr--) { + if (w1_max1721x_reg_get(dev, reg++, &val)) + return -EFAULT; + *str++ = val>>8 & 0x00FF; + *str++ = val & 0x00FF; + } + return 0; +} + +/* Maxim say: Serial number is a hex string up to 12 hex characters */ +static int get_sn_string(struct device *dev, char *str) +{ + uint16_t val[3]; + + if (!str) + return -EFAULT; + + if (w1_max1721x_reg_get(dev, MAX1721X_REG_SER_HEX, &val[0])) + return -EFAULT; + if (w1_max1721x_reg_get(dev, MAX1721X_REG_SER_HEX + 1, &val[1])) + return -EFAULT; + if (w1_max1721x_reg_get(dev, MAX1721X_REG_SER_HEX + 2, &val[2])) + return -EFAULT; + + snprintf(str, 13, "%04X%04X%04X", val[0], val[1], val[2]); + return 0; +} + +static int max1721x_battery_probe(struct platform_device *pdev) +{ + struct power_supply_config psy_cfg = {}; + struct max17211_device_info *info; + + info = devm_kzalloc(&pdev->dev, sizeof(*info), GFP_KERNEL); + if (!info) + return -ENOMEM; + + platform_set_drvdata(pdev, info); + + info->dev = &pdev->dev; + info->w1_dev = pdev->dev.parent; + info->bat_desc.name = dev_name(&pdev->dev); + info->bat_desc.type = POWER_SUPPLY_TYPE_BATTERY; + info->bat_desc.properties = max1721x_battery_props; + info->bat_desc.num_properties = ARRAY_SIZE(max1721x_battery_props); + info->bat_desc.get_property = max1721x_battery_get_property; + /* + * FixMe: + * Device without no_thermal = true not register (err -22) + * Len of platform device name "max17211-battery.X.auto" + * more than 20 chars limit in THERMAL_NAME_LENGTH from + * include/uapi/linux/thermal.h + */ + info->bat_desc.no_thermal = true; + psy_cfg.drv_data = info; + + if (w1_max1721x_reg_get(info->w1_dev, + MAX1721X_REG_NRSENSE, &info->rsense)) + return -ENODEV; + + if (!info->rsense) { + dev_warn(info->dev, "RSenese not calibrated, set 10 mOhms!\n"); + info->rsense = 1000; /* in regs in 10^-5 */ + } + dev_dbg(info->dev, "RSense: %d mOhms.\n", info->rsense / 100); + + if (get_string(info->w1_dev, MAX1721X_REG_MFG_STR, + MAX1721X_REG_MFG_NUMB, info->ManufacturerName)) { + dev_err(info->dev, "Can't read manufacturer. Hardware error.\n"); + return -ENODEV; + } + + if (!info->ManufacturerName[0]) + strncpy(info->ManufacturerName, DEF_MFG_NAME, + 2 * MAX1721X_REG_MFG_NUMB); + + if (get_string(info->w1_dev, MAX1721X_REG_DEV_STR, + MAX1721X_REG_DEV_NUMB, info->DeviceName)) { + dev_err(info->dev, "Can't read device. Hardware error.\n"); + return -ENODEV; + } + if (!info->DeviceName[0]) { + uint16_t dev_name; + + if (w1_max1721x_reg_get(info->w1_dev, + MAX172XX_REG_DEVNAME, &dev_name)) { + dev_err(info->w1_dev, "Can't read device name reg.\n"); + return -ENODEV; + } + + switch (dev_name & MAX172XX_DEV_MASK) { + case MAX172X1_DEV: + strncpy(info->DeviceName, DEF_DEV_NAME_MAX17211, + 2 * MAX1721X_REG_DEV_NUMB); + break; + case MAX172X5_DEV: + strncpy(info->DeviceName, DEF_DEV_NAME_MAX17215, + 2 * MAX1721X_REG_DEV_NUMB); + break; + default: + strncpy(info->DeviceName, DEF_DEV_NAME_UNKNOWN, + 2 * MAX1721X_REG_DEV_NUMB); + } + } + + if (get_sn_string(info->w1_dev, info->SerialNumber)) { + dev_err(info->dev, "Can't read serial. Hardware error.\n"); + return -ENODEV; + } + + info->bat = power_supply_register(&pdev->dev, &info->bat_desc, + &psy_cfg); + if (IS_ERR(info->bat)) { + dev_err(info->dev, "failed to register battery\n"); + return PTR_ERR(info->bat); + } + + return 0; +} + +static int max1721x_battery_remove(struct platform_device *pdev) +{ + struct max17211_device_info *info = platform_get_drvdata(pdev); + + power_supply_unregister(info->bat); + + return 0; +} + +static struct platform_driver max1721x_battery_driver = { + .driver = { + .name = "max1721x-battery", + }, + .probe = max1721x_battery_probe, + .remove = max1721x_battery_remove, +}; +module_platform_driver(max1721x_battery_driver); + +MODULE_LICENSE("GPL"); +MODULE_AUTHOR("Alex A. Mihaylov "); +MODULE_DESCRIPTION("Maxim MAX17211/MAX17215 Fuel Gauage IC driver"); +MODULE_ALIAS("platform:max1721x-battery"); -- 2.8.4 (Apple Git-73)