* Re: [PATCH v2 1/2] hwmon: Add support for ltc2947
[not found] <20191011114853.159327-1-nuno.sa@analog.com>
@ 2019-10-20 16:21 ` Guenter Roeck
0 siblings, 0 replies; only message in thread
From: Guenter Roeck @ 2019-10-20 16:21 UTC (permalink / raw)
To: Nuno Sá
Cc: linux-hwmon, devicetree, linux-doc, Rob Herring, Mark Rutland,
Jean Delvare, Jonathan Corbet
On Fri, Oct 11, 2019 at 01:48:52PM +0200, Nuno Sá wrote:
> The ltc2947 is a high precision power and energy monitor with an
> internal sense resistor supporting up to +/- 30A. Three internal no
> Latency ADCs ensure accurate measurement of voltage and current, while
> high-bandwidth analog multiplication of voltage and current provides
> accurate power measurement in a wide range of applications. Internal or
> external clocking options enable precise charge and energy measurements.
>
> Signed-off-by: Nuno Sá <nuno.sa@analog.com>
Almost perfect; just some if/else cleanup required.
Thanks,
Guenter
> ---
> Changes in v2:
> * Add #include <linux/bits.h>;
> * Aemove unneeded dev_err() messages;
> * Drop reset flag and calls to mutex_* in resume()/suspend() code;
> * Drop fault, overflow, energy max/min and energy alarms attributes;
> * Use standard attributes for power;
> * Remove unused macros;
> * Adjust min/max values per datasheet (on clamp_val() calls);
> * Set power max/min on setup().
>
> Documentation/hwmon/ltc2947.rst | 93 +++
> MAINTAINERS | 10 +
> drivers/hwmon/Kconfig | 27 +
> drivers/hwmon/Makefile | 3 +
> drivers/hwmon/ltc2947-core.c | 1191 +++++++++++++++++++++++++++++++
> drivers/hwmon/ltc2947-i2c.c | 49 ++
> drivers/hwmon/ltc2947-spi.c | 50 ++
> drivers/hwmon/ltc2947.h | 12 +
> 8 files changed, 1435 insertions(+)
> create mode 100644 Documentation/hwmon/ltc2947.rst
> create mode 100644 drivers/hwmon/ltc2947-core.c
> create mode 100644 drivers/hwmon/ltc2947-i2c.c
> create mode 100644 drivers/hwmon/ltc2947-spi.c
> create mode 100644 drivers/hwmon/ltc2947.h
>
> diff --git a/Documentation/hwmon/ltc2947.rst b/Documentation/hwmon/ltc2947.rst
> new file mode 100644
> index 000000000000..05df19775fb3
> --- /dev/null
> +++ b/Documentation/hwmon/ltc2947.rst
> @@ -0,0 +1,93 @@
> +Kernel drivers ltc2947-i2c and ltc2947-spi
> +=========================================
> +
> +Supported chips:
> + * Analog Devices LTC2947
> + Prefix: 'ltc2947'
> + Addresses scanned: -
> + Datasheet:
> + https://www.analog.com/media/en/technical-documentation/data-sheets/LTC2947.pdf
> +
> +Author: Nuno Sa <nuno.sa@analog.com>
> +
> +Description
> +___________
> +
> +The LTC2947 is a high precision power and energy monitor that measures current,
> +voltage, power, temperature, charge and energy. The device supports both SPI
> +and I2C depending on the chip configuration.
> +The device also measures accumulated quantities as energy. It has two banks of
> +register's to read/set energy related values. These banks can be configured
> +independently to have setups like: energy1 accumulates always and enrgy2 only
> +accumulates if current is positive (to check battery charging efficiency for
> +example). The device also supports a GPIO pin that can be configured as output
> +to control a fan as a function of measured temperature. Then, the GPIO becomes
> +active as soon as a temperature reading is higher than a defined threshold. The
> +temp2 channel is used to control this thresholds and to read the respective
> +alarms.
> +
> +Sysfs entries
> +_____________
> +
> +The following attributes are supported. Limits are read-write, reset_history
> +is write-only and all the other attributes are read-only.
> +
> +in0_input VP-VM voltage (mV).
> +in0_min Undervoltage threshold
> +in0_max Overvoltage threshold
> +in0_lowest Lowest measured voltage
> +in0_highest Highest measured voltage
> +in0_reset_history Write 1 to reset in1 history
> +in0_min_alarm Undervoltage alarm
> +in0_max_alarm Overvoltage alarm
> +in0_label Channel label (VP-VM)
> +
> +in1_input DVCC voltage (mV)
> +in1_min Undervoltage threshold
> +in1_max Overvoltage threshold
> +in1_lowest Lowest measured voltage
> +in1_highest Highest measured voltage
> +in1_reset_history Write 1 to reset in2 history
> +in1_min_alarm Undervoltage alarm
> +in1_max_alarm Overvoltage alarm
> +in1_label Channel label (DVCC)
> +
> +curr1_input IP-IM Sense current (mA)
> +curr1_min Undercurrent threshold
> +curr1_max Overcurrent threshold
> +curr1_lowest Lowest measured current
> +curr1_highest Highest measured current
> +curr1_reset_history Write 1 to reset curr1 history
> +curr1_min_alarm Undercurrent alarm
> +curr1_max_alarm Overcurrent alarm
> +curr1_label Channel label (IP-IM)
> +
> +power1_input Power (in uW)
> +power1_min Low power threshold
> +power1_max High power threshold
> +power1_input_lowest Historical minimum power use
> +power1_input_highest Historical maximum power use
> +power1_reset_history Write 1 to reset power1 history
> +power1_min_alarm Low power alarm
> +power1_max_alarm High power alarm
> +power1_label Channel label (Power)
> +
> +temp1_input Chip Temperature (in milliC)
> +temp1_min Low temperature threshold
> +temp1_max High temperature threshold
> +temp1_input_lowest Historical minimum temperature use
> +temp1_input_highest Historical maximum temperature use
> +temp1_reset_history Write 1 to reset temp1 history
> +temp1_min_alarm Low temperature alarm
> +temp1_max_alarm High temperature alarm
> +temp1_label Channel label (Ambient)
> +
> +temp2_min Low temperature threshold for fan control
> +temp2_max High temperature threshold for fan control
> +temp2_min_alarm Low temperature fan control alarm
> +temp2_max_alarm High temperature fan control alarm
> +temp2_label Channel label (TEMPFAN)
> +
> +energy1_input Measured energy over time (in microJoule)
> +
> +energy2_input Measured energy over time (in microJoule)
> diff --git a/MAINTAINERS b/MAINTAINERS
> index 296de2b51c83..aed3d0de26cf 100644
> --- a/MAINTAINERS
> +++ b/MAINTAINERS
> @@ -9628,6 +9628,16 @@ S: Maintained
> F: Documentation/hwmon/ltc4261.rst
> F: drivers/hwmon/ltc4261.c
>
> +LTC2947 HARDWARE MONITOR DRIVER
> +M: Nuno Sá <nuno.sa@analog.com>
> +W: http://ez.analog.com/community/linux-device-drivers
> +L: linux-hwmon@vger.kernel.org
> +S: Supported
> +F: drivers/hwmon/ltc2947-core.c
> +F: drivers/hwmon/ltc2947-spi.c
> +F: drivers/hwmon/ltc2947-i2c.c
> +F: drivers/hwmon/ltc2947.h
> +
> LTC4306 I2C MULTIPLEXER DRIVER
> M: Michael Hennerich <michael.hennerich@analog.com>
> W: http://ez.analog.com/community/linux-device-drivers
> diff --git a/drivers/hwmon/Kconfig b/drivers/hwmon/Kconfig
> index 7b6c4025b827..8c102ea2938b 100644
> --- a/drivers/hwmon/Kconfig
> +++ b/drivers/hwmon/Kconfig
> @@ -726,6 +726,33 @@ config SENSORS_LTC2945
> This driver can also be built as a module. If so, the module will
> be called ltc2945.
>
> +config SENSORS_LTC2947
> + tristate
> +
> +config SENSORS_LTC2947_I2C
> + tristate "Analog Devices LTC2947 High Precision Power and Energy Monitor over I2C"
> + depends on I2C
> + select REGMAP_I2C
> + select SENSORS_LTC2947
> + help
> + If you say yes here you get support for Linear Technology LTC2947
> + I2C High Precision Power and Energy Monitor
> +
> + This driver can also be built as a module. If so, the module will
> + be called ltc2947-i2c.
> +
> +config SENSORS_LTC2947_SPI
> + tristate "Analog Devices LTC2947 High Precision Power and Energy Monitor over SPI"
> + depends on SPI_MASTER
> + select REGMAP_SPI
> + select SENSORS_LTC2947
> + help
> + If you say yes here you get support for Linear Technology LTC2947
> + SPI High Precision Power and Energy Monitor
> +
> + This driver can also be built as a module. If so, the module will
> + be called ltc2947-spi.
> +
> config SENSORS_LTC2990
> tristate "Linear Technology LTC2990"
> depends on I2C
> diff --git a/drivers/hwmon/Makefile b/drivers/hwmon/Makefile
> index 40c036ea45e6..e416cfded0c4 100644
> --- a/drivers/hwmon/Makefile
> +++ b/drivers/hwmon/Makefile
> @@ -106,6 +106,9 @@ obj-$(CONFIG_SENSORS_LM95234) += lm95234.o
> obj-$(CONFIG_SENSORS_LM95241) += lm95241.o
> obj-$(CONFIG_SENSORS_LM95245) += lm95245.o
> obj-$(CONFIG_SENSORS_LTC2945) += ltc2945.o
> +obj-$(CONFIG_SENSORS_LTC2947) += ltc2947-core.o
> +obj-$(CONFIG_SENSORS_LTC2947_I2C) += ltc2947-i2c.o
> +obj-$(CONFIG_SENSORS_LTC2947_SPI) += ltc2947-spi.o
> obj-$(CONFIG_SENSORS_LTC2990) += ltc2990.o
> obj-$(CONFIG_SENSORS_LTC4151) += ltc4151.o
> obj-$(CONFIG_SENSORS_LTC4215) += ltc4215.o
> diff --git a/drivers/hwmon/ltc2947-core.c b/drivers/hwmon/ltc2947-core.c
> new file mode 100644
> index 000000000000..82f76d17a8be
> --- /dev/null
> +++ b/drivers/hwmon/ltc2947-core.c
> @@ -0,0 +1,1191 @@
> +// SPDX-License-Identifier: GPL-2.0
> +/*
> + * Analog Devices LTC2947 high precision power and energy monitor
> + *
> + * Copyright 2019 Analog Devices Inc.
> + */
> +#include <linux/bitfield.h>
> +#include <linux/bits.h>
> +#include <linux/clk.h>
> +#include <linux/device.h>
> +#include <linux/hwmon.h>
> +#include <linux/hwmon-sysfs.h>
> +#include <linux/module.h>
> +#include <linux/of.h>
> +#include <linux/regmap.h>
> +
> +#include "ltc2947.h"
> +
> +/* register's */
> +#define LTC2947_REG_PAGE_CTRL 0xFF
> +#define LTC2947_REG_CTRL 0xF0
> +#define LTC2947_REG_TBCTL 0xE9
> +#define LTC2947_CONT_MODE_MASK BIT(3)
> +#define LTC2947_CONT_MODE(x) FIELD_PREP(LTC2947_CONT_MODE_MASK, x)
> +#define LTC2947_PRE_MASK GENMASK(2, 0)
> +#define LTC2947_PRE(x) FIELD_PREP(LTC2947_PRE_MASK, x)
> +#define LTC2947_DIV_MASK GENMASK(7, 3)
> +#define LTC2947_DIV(x) FIELD_PREP(LTC2947_DIV_MASK, x)
> +#define LTC2947_SHUTDOWN_MASK BIT(0)
> +#define LTC2947_REG_ACCUM_POL 0xE1
> +#define LTC2947_ACCUM_POL_1_MASK GENMASK(1, 0)
> +#define LTC2947_ACCUM_POL_1(x) FIELD_PREP(LTC2947_ACCUM_POL_1_MASK, x)
> +#define LTC2947_ACCUM_POL_2_MASK GENMASK(3, 2)
> +#define LTC2947_ACCUM_POL_2(x) FIELD_PREP(LTC2947_ACCUM_POL_2_MASK, x)
> +#define LTC2947_REG_ACCUM_DEADBAND 0xE4
> +#define LTC2947_REG_GPIOSTATCTL 0x67
> +#define LTC2947_GPIO_EN_MASK BIT(0)
> +#define LTC2947_GPIO_EN(x) FIELD_PREP(LTC2947_GPIO_EN_MASK, x)
> +#define LTC2947_GPIO_FAN_EN_MASK BIT(6)
> +#define LTC2947_GPIO_FAN_EN(x) FIELD_PREP(LTC2947_GPIO_FAN_EN_MASK, x)
> +#define LTC2947_GPIO_FAN_POL_MASK BIT(7)
> +#define LTC2947_GPIO_FAN_POL(x) FIELD_PREP(LTC2947_GPIO_FAN_POL_MASK, x)
> +#define LTC2947_REG_GPIO_ACCUM 0xE3
> +/* 200Khz */
> +#define LTC2947_CLK_MIN 200000
> +/* 25Mhz */
> +#define LTC2947_CLK_MAX 25000000
> +#define PAGE0 0
> +#define PAGE1 1
> +/* Voltage registers */
> +#define LTC2947_REG_VOLTAGE 0xA0
> +#define LTC2947_REG_VOLTAGE_MAX 0x50
> +#define LTC2947_REG_VOLTAGE_MIN 0x52
> +#define LTC2947_REG_VOLTAGE_THRE_H 0x90
> +#define LTC2947_REG_VOLTAGE_THRE_L 0x92
> +#define LTC2947_REG_DVCC 0xA4
> +#define LTC2947_REG_DVCC_MAX 0x58
> +#define LTC2947_REG_DVCC_MIN 0x5A
> +#define LTC2947_REG_DVCC_THRE_H 0x98
> +#define LTC2947_REG_DVCC_THRE_L 0x9A
> +#define LTC2947_VOLTAGE_GEN_CHAN 0
> +#define LTC2947_VOLTAGE_DVCC_CHAN 1
> +/* in mV */
> +#define VOLTAGE_MAX 15500
> +#define VOLTAGE_MIN -300
> +#define VDVCC_MAX 15000
> +#define VDVCC_MIN 4750
> +/* Current registers */
> +#define LTC2947_REG_CURRENT 0x90
> +#define LTC2947_REG_CURRENT_MAX 0x40
> +#define LTC2947_REG_CURRENT_MIN 0x42
> +#define LTC2947_REG_CURRENT_THRE_H 0x80
> +#define LTC2947_REG_CURRENT_THRE_L 0x82
> +/* in mA */
> +#define CURRENT_MAX 30000
> +#define CURRENT_MIN -30000
> +/* Power registers */
> +#define LTC2947_REG_POWER 0x93
> +#define LTC2947_REG_POWER_MAX 0x44
> +#define LTC2947_REG_POWER_MIN 0x46
> +#define LTC2947_REG_POWER_THRE_H 0x84
> +#define LTC2947_REG_POWER_THRE_L 0x86
> +/* in uW */
> +#define POWER_MAX 450000000
> +#define POWER_MIN -450000000
> +/* Temperature registers */
> +#define LTC2947_REG_TEMP 0xA2
> +#define LTC2947_REG_TEMP_MAX 0x54
> +#define LTC2947_REG_TEMP_MIN 0x56
> +#define LTC2947_REG_TEMP_THRE_H 0x94
> +#define LTC2947_REG_TEMP_THRE_L 0x96
> +#define LTC2947_REG_TEMP_FAN_THRE_H 0x9C
> +#define LTC2947_REG_TEMP_FAN_THRE_L 0x9E
> +#define LTC2947_TEMP_FAN_CHAN 1
> +/* in millidegress Celsius */
> +#define TEMP_MAX 85000
> +#define TEMP_MIN -40000
> +/* Energy registers */
> +#define LTC2947_REG_ENERGY1 0x06
> +#define LTC2947_REG_ENERGY2 0x16
> +/* Status/Alarm/Overflow registers */
> +#define LTC2947_REG_STATUS 0x80
> +#define LTC2947_REG_STATVT 0x81
> +#define LTC2947_REG_STATIP 0x82
> +#define LTC2947_REG_STATVDVCC 0x87
> +
> +#define LTC2947_ALERTS_SIZE (LTC2947_REG_STATVDVCC - LTC2947_REG_STATUS)
> +#define LTC2947_MAX_VOLTAGE_MASK BIT(0)
> +#define LTC2947_MIN_VOLTAGE_MASK BIT(1)
> +#define LTC2947_MAX_CURRENT_MASK BIT(0)
> +#define LTC2947_MIN_CURRENT_MASK BIT(1)
> +#define LTC2947_MAX_POWER_MASK BIT(2)
> +#define LTC2947_MIN_POWER_MASK BIT(3)
> +#define LTC2947_MAX_TEMP_MASK BIT(2)
> +#define LTC2947_MIN_TEMP_MASK BIT(3)
> +#define LTC2947_MAX_TEMP_FAN_MASK BIT(4)
> +#define LTC2947_MIN_TEMP_FAN_MASK BIT(5)
> +
> +struct ltc2947_data {
> + struct regmap *map;
> + struct device *dev;
> + /*
> + * The mutex is needed because the device has 2 memory pages. When
> + * reading/writing the correct page needs to be set so that, the
> + * complete sequence select_page->read/write needs to be protected.
> + */
> + struct mutex lock;
> + u32 lsb_energy;
> + bool gpio_out;
> +};
> +
> +static int __ltc2947_val_read16(const struct ltc2947_data *st, const u8 reg,
> + u64 *val)
> +{
> + __be16 __val = 0;
> + int ret;
> +
> + ret = regmap_bulk_read(st->map, reg, &__val, 2);
> + if (ret)
> + return ret;
> +
> + *val = be16_to_cpu(__val);
> +
> + return 0;
> +}
> +
> +static int __ltc2947_val_read24(const struct ltc2947_data *st, const u8 reg,
> + u64 *val)
> +{
> + __be32 __val = 0;
> + int ret;
> +
> + ret = regmap_bulk_read(st->map, reg, &__val, 3);
> + if (ret)
> + return ret;
> +
> + *val = be32_to_cpu(__val) >> 8;
> +
> + return 0;
> +}
> +
> +static int __ltc2947_val_read64(const struct ltc2947_data *st, const u8 reg,
> + u64 *val)
> +{
> + __be64 __val = 0;
> + int ret;
> +
> + ret = regmap_bulk_read(st->map, reg, &__val, 6);
> + if (ret)
> + return ret;
> +
> + *val = be64_to_cpu(__val) >> 16;
> +
> + return 0;
> +}
> +
> +static int ltc2947_val_read(struct ltc2947_data *st, const u8 reg,
> + const u8 page, const size_t size, s64 *val)
> +{
> + int ret;
> + u64 __val = 0;
> +
> + mutex_lock(&st->lock);
> +
> + ret = regmap_write(st->map, LTC2947_REG_PAGE_CTRL, page);
> + if (ret) {
> + mutex_unlock(&st->lock);
> + return ret;
> + }
> +
> + dev_dbg(st->dev, "Read val, reg:%02X, p:%d sz:%zu\n", reg, page,
> + size);
> +
> + switch (size) {
> + case 2:
> + ret = __ltc2947_val_read16(st, reg, &__val);
> + break;
> + case 3:
> + ret = __ltc2947_val_read24(st, reg, &__val);
> + break;
> + case 6:
> + ret = __ltc2947_val_read64(st, reg, &__val);
> + break;
> + default:
> + ret = -EINVAL;
> + break;
> + }
> +
> + mutex_unlock(&st->lock);
> +
> + if (ret)
> + return ret;
> +
> + *val = sign_extend64(__val, (8 * size) - 1);
> +
> + dev_dbg(st->dev, "Got s:%lld, u:%016llX\n", *val, __val);
> +
> + return 0;
> +}
> +
> +static int __ltc2947_val_write64(const struct ltc2947_data *st, const u8 reg,
> + const u64 val)
> +{
> + __be64 __val;
> +
> + __val = cpu_to_be64(val << 16);
> + return regmap_bulk_write(st->map, reg, &__val, 6);
> +}
> +
> +static int __ltc2947_val_write16(const struct ltc2947_data *st, const u8 reg,
> + const u16 val)
> +{
> + __be16 __val;
> +
> + __val = cpu_to_be16(val);
> + return regmap_bulk_write(st->map, reg, &__val, 2);
> +}
> +
> +static int ltc2947_val_write(struct ltc2947_data *st, const u8 reg,
> + const u8 page, const size_t size, const u64 val)
> +{
> + int ret;
> +
> + mutex_lock(&st->lock);
> + /* set device on correct page */
> + ret = regmap_write(st->map, LTC2947_REG_PAGE_CTRL, page);
> + if (ret) {
> + mutex_unlock(&st->lock);
> + return ret;
> + }
> +
> + dev_dbg(st->dev, "Write val, r:%02X, p:%d, sz:%zu, val:%016llX\n",
> + reg, page, size, val);
> +
> + switch (size) {
> + case 2:
> + ret = __ltc2947_val_write16(st, reg, val);
> + break;
> + case 6:
> + ret = __ltc2947_val_write64(st, reg, val);
> + break;
> + default:
> + ret = -EINVAL;
> + break;
> + }
> +
> + mutex_unlock(&st->lock);
> +
> + return ret;
> +}
> +
> +static int ltc2947_reset_history(struct ltc2947_data *st, const u8 reg_h,
> + const u8 reg_l)
> +{
> + int ret;
> + /*
> + * let's reset the tracking register's. Tracking register's have all
> + * 2 bytes size
> + */
> + ret = ltc2947_val_write(st, reg_h, PAGE0, 2, 0x8000U);
> + if (ret)
> + return ret;
> +
> + return ltc2947_val_write(st, reg_l, PAGE0, 2, 0x7FFFU);
> +}
> +
> +static int ltc2947_alarm_read(struct ltc2947_data *st, const u8 reg,
> + const u32 mask, long *val)
> +{
> + u8 offset = reg - LTC2947_REG_STATUS;
> + /* +1 to include status reg */
> + char alarms[LTC2947_ALERTS_SIZE + 1];
> + int ret = 0;
> +
> + memset(alarms, 0, sizeof(alarms));
> +
> + mutex_lock(&st->lock);
> +
> + ret = regmap_write(st->map, LTC2947_REG_PAGE_CTRL, PAGE0);
> + if (ret)
> + goto unlock;
> +
> + dev_dbg(st->dev, "Read alarm, reg:%02X, mask:%02X\n", reg, mask);
> + /*
> + * As stated in the datasheet, when Threshold and Overflow registers
> + * are used, the status and all alert registers must be read in one
> + * multi-byte transaction.
> + */
> + ret = regmap_bulk_read(st->map, LTC2947_REG_STATUS, alarms,
> + sizeof(alarms));
> + if (ret)
> + goto unlock;
> +
> + /* get the alarm */
> + *val = !!(alarms[offset] & mask);
> +unlock:
> + mutex_unlock(&st->lock);
> + return ret;
> +}
> +
> +static ssize_t ltc2947_show_value(struct device *dev,
> + struct device_attribute *da, char *buf)
> +{
> + struct ltc2947_data *st = dev_get_drvdata(dev);
> + struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
> + int ret;
> + s64 val = 0;
> +
> + switch (attr->index) {
> + case LTC2947_REG_ENERGY1:
> + case LTC2947_REG_ENERGY2:
> + ret = ltc2947_val_read(st, attr->index, PAGE0, 6, &val);
> + break;
> + default:
> + return -EINVAL;
> + }
> +
> + if (ret)
> + return ret;
> +
> + /* value in microJoule. st->lsb_energy was multiplied by 10E9 */
> + val = div_s64(val * st->lsb_energy, 1000);
> +
> + return sprintf(buf, "%lld\n", val);
> +}
> +
> +static int ltc2947_read_temp(struct device *dev, const u32 attr, long *val,
> + const int channel)
> +{
> + int ret;
> + struct ltc2947_data *st = dev_get_drvdata(dev);
> + s64 __val = 0;
> +
> + if (channel < 0 || channel > LTC2947_TEMP_FAN_CHAN) {
> + dev_err(st->dev, "Invalid chan%d for temperature", channel);
> + return -EINVAL;
> + }
> +
> + switch (attr) {
> + case hwmon_temp_input:
> + ret = ltc2947_val_read(st, LTC2947_REG_TEMP, PAGE0, 2, &__val);
> + break;
> + case hwmon_temp_highest:
> + ret = ltc2947_val_read(st, LTC2947_REG_TEMP_MAX, PAGE0, 2,
> + &__val);
> + break;
> + case hwmon_temp_lowest:
> + ret = ltc2947_val_read(st, LTC2947_REG_TEMP_MIN, PAGE0, 2,
> + &__val);
> + break;
> + case hwmon_temp_max_alarm:
> + if (channel == LTC2947_TEMP_FAN_CHAN)
> + return ltc2947_alarm_read(st, LTC2947_REG_STATVT,
> + LTC2947_MAX_TEMP_FAN_MASK,
> + val);
> + else
> + return ltc2947_alarm_read(st, LTC2947_REG_STATVT,
> + LTC2947_MAX_TEMP_MASK, val);
> + case hwmon_temp_min_alarm:
> + if (channel == LTC2947_TEMP_FAN_CHAN)
> + return ltc2947_alarm_read(st, LTC2947_REG_STATVT,
> + LTC2947_MIN_TEMP_FAN_MASK,
> + val);
> + else
> + return ltc2947_alarm_read(st, LTC2947_REG_STATVT,
> + LTC2947_MIN_TEMP_MASK, val);
> + case hwmon_temp_max:
> + if (channel == LTC2947_TEMP_FAN_CHAN)
> + ret = ltc2947_val_read(st, LTC2947_REG_TEMP_FAN_THRE_H,
> + PAGE1, 2, &__val);
> + else
> + ret = ltc2947_val_read(st, LTC2947_REG_TEMP_THRE_H,
> + PAGE1, 2, &__val);
> + break;
> + case hwmon_temp_min:
> + if (channel == LTC2947_TEMP_FAN_CHAN)
> + ret = ltc2947_val_read(st, LTC2947_REG_TEMP_FAN_THRE_L,
> + PAGE1, 2, &__val);
> + else
> + ret = ltc2947_val_read(st, LTC2947_REG_TEMP_THRE_L,
> + PAGE1, 2, &__val);
> + break;
> + default:
> + return -ENOTSUPP;
> + }
> +
> + if (ret)
> + return ret;
> +
> + /* in milidegrees celcius, temp is given by: */
> + *val = (__val * 204) + 550;
> +
> + return 0;
> +}
> +
> +static int ltc2947_read_power(struct device *dev, const u32 attr, long *val)
> +{
> + struct ltc2947_data *st = dev_get_drvdata(dev);
> + int ret;
> + u32 lsb = 200000; /* in uW */
> + s64 __val = 0;
> +
> + switch (attr) {
> + case hwmon_power_input:
> + ret = ltc2947_val_read(st, LTC2947_REG_POWER, PAGE0, 3, &__val);
> + lsb = 50000;
> + break;
> + case hwmon_power_input_highest:
> + ret = ltc2947_val_read(st, LTC2947_REG_POWER_MAX, PAGE0, 2,
> + &__val);
> + break;
> + case hwmon_power_input_lowest:
> + ret = ltc2947_val_read(st, LTC2947_REG_POWER_MIN, PAGE0, 2,
> + &__val);
> + break;
> + case hwmon_power_max_alarm:
> + return ltc2947_alarm_read(st, LTC2947_REG_STATIP,
> + LTC2947_MAX_POWER_MASK, val);
> + case hwmon_power_min_alarm:
> + return ltc2947_alarm_read(st, LTC2947_REG_STATIP,
> + LTC2947_MIN_POWER_MASK, val);
> + case hwmon_power_max:
> + ret = ltc2947_val_read(st, LTC2947_REG_POWER_THRE_H, PAGE1, 2,
> + &__val);
> + break;
> + case hwmon_power_min:
> + ret = ltc2947_val_read(st, LTC2947_REG_POWER_THRE_L, PAGE1, 2,
> + &__val);
> + break;
> + default:
> + return -ENOTSUPP;
> + }
> +
> + if (ret)
> + return ret;
> +
> + *val = __val * lsb;
> +
> + return 0;
> +}
> +
> +static int ltc2947_read_curr(struct device *dev, const u32 attr, long *val)
> +{
> + struct ltc2947_data *st = dev_get_drvdata(dev);
> + int ret;
> + u8 lsb = 12; /* in mA */
> + s64 __val = 0;
> +
> + switch (attr) {
> + case hwmon_curr_input:
> + ret = ltc2947_val_read(st, LTC2947_REG_CURRENT, PAGE0, 3,
> + &__val);
> + lsb = 3;
> + break;
> + case hwmon_curr_highest:
> + ret = ltc2947_val_read(st, LTC2947_REG_CURRENT_MAX, PAGE0, 2,
> + &__val);
> + break;
> + case hwmon_curr_lowest:
> + ret = ltc2947_val_read(st, LTC2947_REG_CURRENT_MIN, PAGE0, 2,
> + &__val);
> + break;
> + case hwmon_curr_max_alarm:
> + return ltc2947_alarm_read(st, LTC2947_REG_STATIP,
> + LTC2947_MAX_CURRENT_MASK, val);
> + case hwmon_curr_min_alarm:
> + return ltc2947_alarm_read(st, LTC2947_REG_STATIP,
> + LTC2947_MIN_CURRENT_MASK, val);
> + case hwmon_curr_max:
> + ret = ltc2947_val_read(st, LTC2947_REG_CURRENT_THRE_H, PAGE1, 2,
> + &__val);
> + break;
> + case hwmon_curr_min:
> + ret = ltc2947_val_read(st, LTC2947_REG_CURRENT_THRE_L, PAGE1, 2,
> + &__val);
> + break;
> + default:
> + return -ENOTSUPP;
> + }
> +
> + if (ret)
> + return ret;
> +
> + *val = __val * lsb;
> +
> + return 0;
> +}
> +
> +static int ltc2947_read_in(struct device *dev, const u32 attr, long *val,
> + const int channel)
> +{
> + struct ltc2947_data *st = dev_get_drvdata(dev);
> + int ret;
> + u8 lsb = 2; /* in mV */
> + s64 __val = 0;
> +
> + if (channel < 0 || channel > LTC2947_VOLTAGE_DVCC_CHAN) {
> + dev_err(st->dev, "Invalid chan%d for voltage", channel);
> + return -EINVAL;
> + }
> +
> + switch (attr) {
> + case hwmon_in_input:
> + if (channel == LTC2947_VOLTAGE_DVCC_CHAN) {
> + ret = ltc2947_val_read(st, LTC2947_REG_DVCC, PAGE0, 2,
> + &__val);
> + lsb = 145;
> + } else {
> + ret = ltc2947_val_read(st, LTC2947_REG_VOLTAGE, PAGE0,
> + 2, &__val);
> + }
> + break;
> + case hwmon_in_highest:
> + if (channel == LTC2947_VOLTAGE_DVCC_CHAN) {
> + ret = ltc2947_val_read(st, LTC2947_REG_DVCC_MAX, PAGE0,
> + 2, &__val);
> + lsb = 145;
> + } else {
> + ret = ltc2947_val_read(st, LTC2947_REG_VOLTAGE_MAX,
> + PAGE0, 2, &__val);
> + }
> + break;
> + case hwmon_in_lowest:
> + if (channel == LTC2947_VOLTAGE_DVCC_CHAN) {
> + ret = ltc2947_val_read(st, LTC2947_REG_DVCC_MIN, PAGE0,
> + 2, &__val);
> + lsb = 145;
> + } else {
> + ret = ltc2947_val_read(st, LTC2947_REG_VOLTAGE_MIN,
> + PAGE0, 2, &__val);
> + }
> + break;
> + case hwmon_in_max_alarm:
> + if (channel == LTC2947_VOLTAGE_DVCC_CHAN)
> + return ltc2947_alarm_read(st, LTC2947_REG_STATVDVCC,
> + LTC2947_MAX_VOLTAGE_MASK,
> + val);
> + else
> + return ltc2947_alarm_read(st, LTC2947_REG_STATVT,
> + LTC2947_MAX_VOLTAGE_MASK,
> + val);
> + case hwmon_in_min_alarm:
> + if (channel == LTC2947_VOLTAGE_DVCC_CHAN)
> + return ltc2947_alarm_read(st, LTC2947_REG_STATVDVCC,
> + LTC2947_MIN_VOLTAGE_MASK,
> + val);
> + else
> + return ltc2947_alarm_read(st, LTC2947_REG_STATVT,
> + LTC2947_MIN_VOLTAGE_MASK,
> + val);
> + case hwmon_in_max:
> + if (channel == LTC2947_VOLTAGE_DVCC_CHAN) {
> + ret = ltc2947_val_read(st, LTC2947_REG_DVCC_THRE_H,
> + PAGE1, 2, &__val);
> + lsb = 145;
> + } else {
> + ret = ltc2947_val_read(st, LTC2947_REG_VOLTAGE_THRE_H,
> + PAGE1, 2, &__val);
> + }
> + break;
> + case hwmon_in_min:
> + if (channel == LTC2947_VOLTAGE_DVCC_CHAN) {
> + ret = ltc2947_val_read(st, LTC2947_REG_DVCC_THRE_L,
> + PAGE1, 2, &__val);
> + lsb = 145;
> + } else {
> + ret = ltc2947_val_read(st, LTC2947_REG_VOLTAGE_THRE_L,
> + PAGE1, 2, &__val);
> + }
> + break;
> + default:
> + return -ENOTSUPP;
> + }
> +
> + if (ret)
> + return ret;
> +
> + *val = __val * lsb;
> +
> + return 0;
> +}
> +
> +static int ltc2947_read(struct device *dev, enum hwmon_sensor_types type,
> + u32 attr, int channel, long *val)
> +{
> + switch (type) {
> + case hwmon_in:
> + return ltc2947_read_in(dev, attr, val, channel);
> + case hwmon_curr:
> + return ltc2947_read_curr(dev, attr, val);
> + case hwmon_power:
> + return ltc2947_read_power(dev, attr, val);
> + case hwmon_temp:
> + return ltc2947_read_temp(dev, attr, val, channel);
> + default:
> + return -ENOTSUPP;
> + }
> +}
> +
> +static int ltc2947_write_temp(struct device *dev, const u32 attr,
> + long val, const int channel)
> +{
> + struct ltc2947_data *st = dev_get_drvdata(dev);
> +
> + if (channel < 0 || channel > LTC2947_TEMP_FAN_CHAN) {
> + dev_err(st->dev, "Invalid chan%d for temperature", channel);
> + return -EINVAL;
> + }
> +
> + switch (attr) {
> + case hwmon_temp_reset_history:
> + if (val != 1)
> + return -EINVAL;
> + return ltc2947_reset_history(st, LTC2947_REG_TEMP_MAX,
> + LTC2947_REG_TEMP_MIN);
> + case hwmon_temp_max:
> + val = clamp_val(val, TEMP_MIN, TEMP_MAX);
> + if (channel == LTC2947_TEMP_FAN_CHAN) {
> + if (!st->gpio_out)
> + return -ENOTSUPP;
> +
> + return ltc2947_val_write(st,
> + LTC2947_REG_TEMP_FAN_THRE_H, PAGE1, 2,
> + DIV_ROUND_CLOSEST(val - 550, 204));
> + } else {
Unnecessary else after return. This confuses checkpatch (and will result
in static analyzer warnings).
> + return ltc2947_val_write(st, LTC2947_REG_TEMP_THRE_H,
> + PAGE1, 2,
> + DIV_ROUND_CLOSEST(val - 550, 204));
> + }
> + case hwmon_temp_min:
> + val = clamp_val(val, TEMP_MIN, TEMP_MAX);
> + if (channel == LTC2947_TEMP_FAN_CHAN) {
> + if (!st->gpio_out)
> + return -ENOTSUPP;
> +
> + return ltc2947_val_write(st,
> + LTC2947_REG_TEMP_FAN_THRE_L, PAGE1, 2,
> + DIV_ROUND_CLOSEST(val - 550, 204));
> + } else {
Same as above. I would suggest to run checkpatch --strict on the patch;
there are a few more of those.
> + return ltc2947_val_write(st, LTC2947_REG_TEMP_THRE_L,
> + PAGE1, 2,
> + DIV_ROUND_CLOSEST(val - 550, 204));
> + }
> + default:
> + return -ENOTSUPP;
> + }
> +}
> +
> +static int ltc2947_write_power(struct device *dev, const u32 attr,
> + long val)
> +{
> + struct ltc2947_data *st = dev_get_drvdata(dev);
> +
> + switch (attr) {
> + case hwmon_power_reset_history:
> + if (val != 1)
> + return -EINVAL;
> + return ltc2947_reset_history(st, LTC2947_REG_POWER_MAX,
> + LTC2947_REG_POWER_MIN);
> + case hwmon_power_max:
> + val = clamp_val(val, POWER_MIN, POWER_MAX);
> + return ltc2947_val_write(st, LTC2947_REG_POWER_THRE_H, PAGE1, 2,
> + DIV_ROUND_CLOSEST(val, 200000));
> + case hwmon_power_min:
> + val = clamp_val(val, POWER_MIN, POWER_MAX);
> + return ltc2947_val_write(st, LTC2947_REG_POWER_THRE_L, PAGE1, 2,
> + DIV_ROUND_CLOSEST(val, 200000));
> + default:
> + return -ENOTSUPP;
> + }
> +}
> +
> +static int ltc2947_write_curr(struct device *dev, const u32 attr,
> + long val)
> +{
> + struct ltc2947_data *st = dev_get_drvdata(dev);
> +
> + switch (attr) {
> + case hwmon_curr_reset_history:
> + if (val != 1)
> + return -EINVAL;
> + return ltc2947_reset_history(st, LTC2947_REG_CURRENT_MAX,
> + LTC2947_REG_CURRENT_MIN);
> + case hwmon_curr_max:
> + val = clamp_val(val, CURRENT_MIN, CURRENT_MAX);
> + return ltc2947_val_write(st, LTC2947_REG_CURRENT_THRE_H, PAGE1,
> + 2, DIV_ROUND_CLOSEST(val, 12));
> + case hwmon_curr_min:
> + val = clamp_val(val, CURRENT_MIN, CURRENT_MAX);
> + return ltc2947_val_write(st, LTC2947_REG_CURRENT_THRE_L, PAGE1,
> + 2, DIV_ROUND_CLOSEST(val, 12));
> + default:
> + return -ENOTSUPP;
> + }
> +}
> +
> +static int ltc2947_write_in(struct device *dev, const u32 attr, long val,
> + const int channel)
> +{
> + struct ltc2947_data *st = dev_get_drvdata(dev);
> +
> + if (channel > LTC2947_VOLTAGE_DVCC_CHAN) {
> + dev_err(st->dev, "Invalid chan%d for voltage", channel);
> + return -EINVAL;
> + }
> +
> + switch (attr) {
> + case hwmon_in_reset_history:
> + if (val != 1)
> + return -EINVAL;
> +
> + if (channel == LTC2947_VOLTAGE_DVCC_CHAN)
> + return ltc2947_reset_history(st, LTC2947_REG_DVCC_MAX,
> + LTC2947_REG_DVCC_MIN);
> + else
> + return ltc2947_reset_history(st,
> + LTC2947_REG_VOLTAGE_MAX,
> + LTC2947_REG_VOLTAGE_MIN);
> + case hwmon_in_max:
> + if (channel == LTC2947_VOLTAGE_DVCC_CHAN) {
> + val = clamp_val(val, VDVCC_MIN, VDVCC_MAX);
> + return ltc2947_val_write(st, LTC2947_REG_DVCC_THRE_H,
> + PAGE1, 2,
> + DIV_ROUND_CLOSEST(val, 145));
> + } else {
> + val = clamp_val(val, VOLTAGE_MIN, VOLTAGE_MAX);
> + return ltc2947_val_write(st, LTC2947_REG_VOLTAGE_THRE_H,
> + PAGE1, 2,
> + DIV_ROUND_CLOSEST(val, 2));
> + }
> + case hwmon_in_min:
> + if (channel == LTC2947_VOLTAGE_DVCC_CHAN) {
> + val = clamp_val(val, VDVCC_MIN, VDVCC_MAX);
> + return ltc2947_val_write(st, LTC2947_REG_DVCC_THRE_L,
> + PAGE1, 2,
> + DIV_ROUND_CLOSEST(val, 145));
> + } else {
> + val = clamp_val(val, VOLTAGE_MIN, VOLTAGE_MAX);
> + return ltc2947_val_write(st, LTC2947_REG_VOLTAGE_THRE_L,
> + PAGE1, 2,
> + DIV_ROUND_CLOSEST(val, 2));
> + }
> + default:
> + return -ENOTSUPP;
> + }
> +}
> +
> +static int ltc2947_write(struct device *dev,
> + enum hwmon_sensor_types type,
> + u32 attr, int channel, long val)
> +{
> + switch (type) {
> + case hwmon_in:
> + return ltc2947_write_in(dev, attr, val, channel);
> + case hwmon_curr:
> + return ltc2947_write_curr(dev, attr, val);
> + case hwmon_power:
> + return ltc2947_write_power(dev, attr, val);
> + case hwmon_temp:
> + return ltc2947_write_temp(dev, attr, val, channel);
> + default:
> + return -ENOTSUPP;
> + }
> +}
> +
> +static int ltc2947_read_labels(struct device *dev,
> + enum hwmon_sensor_types type,
> + u32 attr, int channel, const char **str)
> +{
> + switch (type) {
> + case hwmon_in:
> + if (channel == LTC2947_VOLTAGE_DVCC_CHAN)
> + *str = "DVCC";
> + else
> + *str = "VP-VM";
> + return 0;
> + case hwmon_curr:
> + *str = "IP-IM";
> + return 0;
> + case hwmon_temp:
> + if (channel == LTC2947_TEMP_FAN_CHAN)
> + *str = "TEMPFAN";
> + else
> + *str = "Ambient";
> + return 0;
> + case hwmon_power:
> + *str = "Power";
> + return 0;
> + default:
> + return -ENOTSUPP;
> + }
> +}
> +
> +static int ltc2947_in_is_visible(const u32 attr)
> +{
> + switch (attr) {
> + case hwmon_in_input:
> + case hwmon_in_highest:
> + case hwmon_in_lowest:
> + case hwmon_in_max_alarm:
> + case hwmon_in_min_alarm:
> + case hwmon_in_label:
> + return 0444;
> + case hwmon_in_reset_history:
> + return 0200;
> + case hwmon_in_max:
> + case hwmon_in_min:
> + return 0644;
> + default:
> + return 0;
> + }
> +}
> +
> +static int ltc2947_curr_is_visible(const u32 attr)
> +{
> + switch (attr) {
> + case hwmon_curr_input:
> + case hwmon_curr_highest:
> + case hwmon_curr_lowest:
> + case hwmon_curr_max_alarm:
> + case hwmon_curr_min_alarm:
> + case hwmon_curr_label:
> + return 0444;
> + case hwmon_curr_reset_history:
> + return 0200;
> + case hwmon_curr_max:
> + case hwmon_curr_min:
> + return 0644;
> + default:
> + return 0;
> + }
> +}
> +
> +static int ltc2947_power_is_visible(const u32 attr)
> +{
> + switch (attr) {
> + case hwmon_power_input:
> + case hwmon_power_input_highest:
> + case hwmon_power_input_lowest:
> + case hwmon_power_label:
> + case hwmon_power_max_alarm:
> + case hwmon_power_min_alarm:
> + return 0444;
> + case hwmon_power_reset_history:
> + return 0200;
> + case hwmon_power_max:
> + case hwmon_power_min:
> + return 0644;
> + default:
> + return 0;
> + }
> +}
> +
> +static int ltc2947_temp_is_visible(const u32 attr)
> +{
> + switch (attr) {
> + case hwmon_temp_input:
> + case hwmon_temp_highest:
> + case hwmon_temp_lowest:
> + case hwmon_temp_max_alarm:
> + case hwmon_temp_min_alarm:
> + case hwmon_temp_label:
> + return 0444;
> + case hwmon_temp_reset_history:
> + return 0200;
> + case hwmon_temp_max:
> + case hwmon_temp_min:
> + return 0644;
> + default:
> + return 0;
> + }
> +}
> +
> +static umode_t ltc2947_is_visible(const void *data,
> + enum hwmon_sensor_types type,
> + u32 attr, int channel)
> +{
> + switch (type) {
> + case hwmon_in:
> + return ltc2947_in_is_visible(attr);
> + case hwmon_curr:
> + return ltc2947_curr_is_visible(attr);
> + case hwmon_power:
> + return ltc2947_power_is_visible(attr);
> + case hwmon_temp:
> + return ltc2947_temp_is_visible(attr);
> + default:
> + return 0;
> + }
> +}
> +
> +static const struct hwmon_channel_info *ltc2947_info[] = {
> + HWMON_CHANNEL_INFO(in,
> + HWMON_I_INPUT | HWMON_I_LOWEST | HWMON_I_HIGHEST |
> + HWMON_I_MAX | HWMON_I_MIN | HWMON_I_RESET_HISTORY |
> + HWMON_I_MIN_ALARM | HWMON_I_MAX_ALARM |
> + HWMON_I_LABEL,
> + HWMON_I_INPUT | HWMON_I_LOWEST | HWMON_I_HIGHEST |
> + HWMON_I_MAX | HWMON_I_MIN | HWMON_I_RESET_HISTORY |
> + HWMON_I_MIN_ALARM | HWMON_I_MAX_ALARM |
> + HWMON_I_LABEL),
> + HWMON_CHANNEL_INFO(curr,
> + HWMON_C_INPUT | HWMON_C_LOWEST | HWMON_C_HIGHEST |
> + HWMON_C_MAX | HWMON_C_MIN | HWMON_C_RESET_HISTORY |
> + HWMON_C_MIN_ALARM | HWMON_C_MAX_ALARM |
> + HWMON_C_LABEL),
> + HWMON_CHANNEL_INFO(power,
> + HWMON_P_INPUT | HWMON_P_INPUT_LOWEST |
> + HWMON_P_INPUT_HIGHEST | HWMON_P_MAX | HWMON_P_MIN |
> + HWMON_P_RESET_HISTORY | HWMON_P_MAX_ALARM |
> + HWMON_P_MIN_ALARM | HWMON_P_LABEL),
> + HWMON_CHANNEL_INFO(temp,
> + HWMON_T_INPUT | HWMON_T_LOWEST | HWMON_T_HIGHEST |
> + HWMON_T_MAX | HWMON_T_MIN | HWMON_T_RESET_HISTORY |
> + HWMON_T_MIN_ALARM | HWMON_T_MAX_ALARM |
> + HWMON_T_LABEL,
> + HWMON_T_MAX_ALARM | HWMON_T_MIN_ALARM | HWMON_T_MAX |
> + HWMON_T_MIN | HWMON_T_LABEL),
> + NULL
> +};
> +
> +static const struct hwmon_ops ltc2947_hwmon_ops = {
> + .is_visible = ltc2947_is_visible,
> + .read = ltc2947_read,
> + .write = ltc2947_write,
> + .read_string = ltc2947_read_labels,
> +};
> +
> +static const struct hwmon_chip_info ltc2947_chip_info = {
> + .ops = <c2947_hwmon_ops,
> + .info = ltc2947_info,
> +};
> +
> +/* energy attributes are 6bytes wide so we need u64 */
> +static SENSOR_DEVICE_ATTR(energy1_input, 0444, ltc2947_show_value, NULL,
> + LTC2947_REG_ENERGY1);
> +static SENSOR_DEVICE_ATTR(energy2_input, 0444, ltc2947_show_value, NULL,
> + LTC2947_REG_ENERGY2);
> +
> +static struct attribute *ltc2947_attrs[] = {
> + &sensor_dev_attr_energy1_input.dev_attr.attr,
> + &sensor_dev_attr_energy2_input.dev_attr.attr,
> + NULL,
> +};
> +ATTRIBUTE_GROUPS(ltc2947);
> +
> +static void ltc2947_clk_disable(void *data)
> +{
> + struct clk *extclk = data;
> +
> + clk_disable_unprepare(extclk);
> +}
> +
> +static int ltc2947_setup(struct ltc2947_data *st)
> +{
> + int ret;
> + struct clk *extclk;
> + u32 dummy, deadband, pol;
> + u32 accum[2];
> +
> + /* clear status register by reading it */
> + ret = regmap_read(st->map, LTC2947_REG_STATUS, &dummy);
> + if (ret)
> + return ret;
> + /*
> + * Set max/min for power here since the default values x scale
> + * would overflow on 32bit arch
> + */
> + ret = ltc2947_val_write(st, LTC2947_REG_POWER_THRE_H, PAGE1, 2,
> + POWER_MAX / 200000);
> + if (ret)
> + return ret;
> +
> + ret = ltc2947_val_write(st, LTC2947_REG_POWER_THRE_L, PAGE1, 2,
> + POWER_MIN / 200000);
> + if (ret)
> + return ret;
> +
> + /* check external clock presence */
> + extclk = devm_clk_get(st->dev, NULL);
> + if (!IS_ERR(extclk)) {
> + unsigned long rate_hz;
> + u8 pre = 0, div, tbctl;
> + u64 aux;
> +
> + /* let's calculate and set the right valus in TBCTL */
> + rate_hz = clk_get_rate(extclk);
> + if (rate_hz < LTC2947_CLK_MIN || rate_hz > LTC2947_CLK_MAX) {
> + dev_err(st->dev, "Invalid rate:%lu for external clock",
> + rate_hz);
> + return -EINVAL;
> + }
> +
> + ret = clk_prepare_enable(extclk);
> + if (ret)
> + return ret;
> +
> + ret = devm_add_action_or_reset(st->dev, ltc2947_clk_disable,
> + extclk);
> + if (ret)
> + return ret;
> + /* as in table 1 of the datasheet */
> + if (rate_hz >= LTC2947_CLK_MIN && rate_hz <= 1000000)
> + pre = 0;
> + else if (rate_hz > 1000000 && rate_hz <= 2000000)
> + pre = 1;
> + else if (rate_hz > 2000000 && rate_hz <= 4000000)
> + pre = 2;
> + else if (rate_hz > 4000000 && rate_hz <= 8000000)
> + pre = 3;
> + else if (rate_hz > 8000000 && rate_hz <= 16000000)
> + pre = 4;
> + else if (rate_hz > 16000000 && rate_hz <= LTC2947_CLK_MAX)
> + pre = 5;
> + /*
> + * Div is given by:
> + * floor(fref / (2^PRE * 32768))
> + */
> + div = rate_hz / ((1 << pre) * 32768);
> + tbctl = LTC2947_PRE(pre) | LTC2947_DIV(div);
> +
> + ret = regmap_write(st->map, LTC2947_REG_TBCTL, tbctl);
> + if (ret)
> + return ret;
> + /*
> + * The energy lsb is given by (in W*s):
> + * 06416 * (1/fref) * 2^PRE * (DIV + 1)
> + * The value is multiplied by 10E9
> + */
> + aux = (div + 1) * ((1 << pre) * 641600000ULL);
> + st->lsb_energy = DIV_ROUND_CLOSEST_ULL(aux, rate_hz);
> + } else {
> + /* 19.89E-6 * 10E9 */
> + st->lsb_energy = 19890;
> + }
> + ret = of_property_read_u32_array(st->dev->of_node,
> + "adi,accumulator-ctl-pol", accum,
> + ARRAY_SIZE(accum));
> + if (!ret) {
> + u32 accum_reg = LTC2947_ACCUM_POL_1(accum[0]) |
> + LTC2947_ACCUM_POL_2(accum[1]);
> +
> + ret = regmap_write(st->map, LTC2947_REG_ACCUM_POL, accum_reg);
> + if (ret)
> + return ret;
> + }
> + ret = of_property_read_u32(st->dev->of_node,
> + "adi,accumulation-deadband-microamp",
> + &deadband);
> + if (!ret) {
> + /* the LSB is the same as the current, so 3mA */
> + ret = regmap_write(st->map, LTC2947_REG_ACCUM_DEADBAND,
> + deadband / (1000 * 3));
> + if (ret)
> + return ret;
> + }
> + /* check gpio cfg */
> + ret = of_property_read_u32(st->dev->of_node, "adi,gpio-out-pol", &pol);
> + if (!ret) {
> + /* setup GPIO as output */
> + u32 gpio_ctl = LTC2947_GPIO_EN(1) | LTC2947_GPIO_FAN_EN(1) |
> + LTC2947_GPIO_FAN_POL(pol);
> +
> + st->gpio_out = true;
> + ret = regmap_write(st->map, LTC2947_REG_GPIOSTATCTL, gpio_ctl);
> + if (ret)
> + return ret;
> + }
> + ret = of_property_read_u32_array(st->dev->of_node, "adi,gpio-in-accum",
> + accum, ARRAY_SIZE(accum));
> + if (!ret) {
> + /*
> + * Setup the accum options. The gpioctl is already defined as
> + * input by default.
> + */
> + u32 accum_val = LTC2947_ACCUM_POL_1(accum[0]) |
> + LTC2947_ACCUM_POL_2(accum[1]);
> +
> + if (st->gpio_out) {
> + dev_err(st->dev,
> + "Cannot have input gpio config if already configured as output");
> + return -EINVAL;
> + }
> +
> + ret = regmap_write(st->map, LTC2947_REG_GPIO_ACCUM, accum_val);
> + if (ret)
> + return ret;
> + }
> +
> + /* set continuos mode */
> + return regmap_update_bits(st->map, LTC2947_REG_CTRL,
> + LTC2947_CONT_MODE_MASK, LTC2947_CONT_MODE(1));
> +}
> +
> +int ltc2947_core_probe(struct regmap *map, const char *name)
> +{
> + struct ltc2947_data *st;
> + struct device *dev = regmap_get_device(map);
> + struct device *hwmon;
> + int ret;
> +
> + st = devm_kzalloc(dev, sizeof(*st), GFP_KERNEL);
> + if (!st)
> + return -ENOMEM;
> +
> + st->map = map;
> + st->dev = dev;
> + dev_set_drvdata(dev, st);
> + mutex_init(&st->lock);
> +
> + ret = ltc2947_setup(st);
> + if (ret)
> + return ret;
> +
> + hwmon = devm_hwmon_device_register_with_info(dev, name, st,
> + <c2947_chip_info,
> + ltc2947_groups);
> + return PTR_ERR_OR_ZERO(hwmon);
> +}
> +EXPORT_SYMBOL_GPL(ltc2947_core_probe);
> +
> +static int __maybe_unused ltc2947_resume(struct device *dev)
> +{
> + struct ltc2947_data *st = dev_get_drvdata(dev);
> + u32 ctrl = 0;
> + int ret;
> +
> + /* dummy read to wake the device */
> + ret = regmap_read(st->map, LTC2947_REG_CTRL, &ctrl);
> + if (ret)
> + return ret;
> + /*
> + * Wait for the device. It takes 100ms to wake up so, 10ms extra
> + * should be enough.
> + */
> + msleep(110);
> + ret = regmap_read(st->map, LTC2947_REG_CTRL, &ctrl);
> + if (ret)
> + return ret;
> + /* ctrl should be 0 */
> + if (ctrl != 0) {
> + dev_err(st->dev, "Device failed to wake up, ctl:%02X\n", ctrl);
> + return -ETIMEDOUT;
> + }
> +
> + /* set continuous mode */
> + return regmap_update_bits(st->map, LTC2947_REG_CTRL,
> + LTC2947_CONT_MODE_MASK, LTC2947_CONT_MODE(1));
> +}
> +
> +static int __maybe_unused ltc2947_suspend(struct device *dev)
> +{
> + struct ltc2947_data *st = dev_get_drvdata(dev);
> +
> + return regmap_update_bits(st->map, LTC2947_REG_CTRL,
> + LTC2947_SHUTDOWN_MASK, 1);
> +}
> +
> +SIMPLE_DEV_PM_OPS(ltc2947_pm_ops, ltc2947_suspend, ltc2947_resume);
> +EXPORT_SYMBOL_GPL(ltc2947_pm_ops);
> +
> +const struct of_device_id ltc2947_of_match[] = {
> + { .compatible = "adi,ltc2947" },
> + {}
> +};
> +EXPORT_SYMBOL_GPL(ltc2947_of_match);
> +MODULE_DEVICE_TABLE(of, ltc2947_of_match);
> +
> +MODULE_AUTHOR("Nuno Sa <nuno.sa@analog.com>");
> +MODULE_DESCRIPTION("LTC2947 power and energy monitor core driver");
> +MODULE_LICENSE("GPL");
> diff --git a/drivers/hwmon/ltc2947-i2c.c b/drivers/hwmon/ltc2947-i2c.c
> new file mode 100644
> index 000000000000..cf6074b110ae
> --- /dev/null
> +++ b/drivers/hwmon/ltc2947-i2c.c
> @@ -0,0 +1,49 @@
> +// SPDX-License-Identifier: GPL-2.0
> +/*
> + * Analog Devices LTC2947 high precision power and energy monitor over I2C
> + *
> + * Copyright 2019 Analog Devices Inc.
> + */
> +#include <linux/i2c.h>
> +#include <linux/module.h>
> +#include <linux/regmap.h>
> +
> +#include "ltc2947.h"
> +
> +static const struct regmap_config ltc2947_regmap_config = {
> + .reg_bits = 8,
> + .val_bits = 8,
> +};
> +
> +static int ltc2947_probe(struct i2c_client *i2c,
> + const struct i2c_device_id *id)
> +{
> + struct regmap *map;
> +
> + map = devm_regmap_init_i2c(i2c, <c2947_regmap_config);
> + if (IS_ERR(map))
> + return PTR_ERR(map);
> +
> + return ltc2947_core_probe(map, i2c->name);
> +}
> +
> +static const struct i2c_device_id ltc2947_id[] = {
> + {"ltc2947", 0},
> + {}
> +};
> +MODULE_DEVICE_TABLE(i2c, ltc2947_id);
> +
> +static struct i2c_driver ltc2947_driver = {
> + .driver = {
> + .name = "ltc2947",
> + .of_match_table = ltc2947_of_match,
> + .pm = <c2947_pm_ops,
> + },
> + .probe = ltc2947_probe,
> + .id_table = ltc2947_id,
> +};
> +module_i2c_driver(ltc2947_driver);
> +
> +MODULE_AUTHOR("Nuno Sa <nuno.sa@analog.com>");
> +MODULE_DESCRIPTION("LTC2947 I2C power and energy monitor driver");
> +MODULE_LICENSE("GPL");
> diff --git a/drivers/hwmon/ltc2947-spi.c b/drivers/hwmon/ltc2947-spi.c
> new file mode 100644
> index 000000000000..c24ca569db1b
> --- /dev/null
> +++ b/drivers/hwmon/ltc2947-spi.c
> @@ -0,0 +1,50 @@
> +// SPDX-License-Identifier: GPL-2.0
> +/*
> + * Analog Devices LTC2947 high precision power and energy monitor over SPI
> + *
> + * Copyright 2019 Analog Devices Inc.
> + */
> +#include <linux/module.h>
> +#include <linux/of.h>
> +#include <linux/regmap.h>
> +#include <linux/spi/spi.h>
> +
> +#include "ltc2947.h"
> +
> +static const struct regmap_config ltc2947_regmap_config = {
> + .reg_bits = 16,
> + .val_bits = 8,
> + .read_flag_mask = BIT(0),
> +};
> +
> +static int ltc2947_probe(struct spi_device *spi)
> +{
> + struct regmap *map;
> +
> + map = devm_regmap_init_spi(spi, <c2947_regmap_config);
> + if (IS_ERR(map))
> + return PTR_ERR(map);
> +
> + return ltc2947_core_probe(map, spi_get_device_id(spi)->name);
> +}
> +
> +static const struct spi_device_id ltc2947_id[] = {
> + {"ltc2947", 0},
> + {}
> +};
> +MODULE_DEVICE_TABLE(spi, ltc2947_id);
> +
> +static struct spi_driver ltc2947_driver = {
> + .driver = {
> + .name = "ltc2947",
> + .of_match_table = ltc2947_of_match,
> + .pm = <c2947_pm_ops,
> + },
> + .probe = ltc2947_probe,
> + .id_table = ltc2947_id,
> +};
> +module_spi_driver(ltc2947_driver);
> +
> +MODULE_AUTHOR("Nuno Sa <nuno.sa@analog.com>");
> +MODULE_DESCRIPTION("LTC2947 SPI power and energy monitor driver");
> +MODULE_LICENSE("GPL");
> diff --git a/drivers/hwmon/ltc2947.h b/drivers/hwmon/ltc2947.h
> new file mode 100644
> index 000000000000..5b8ff81a3dba
> --- /dev/null
> +++ b/drivers/hwmon/ltc2947.h
> @@ -0,0 +1,12 @@
> +/* SPDX-License-Identifier: GPL-2.0 */
> +#ifndef _LINUX_LTC2947_H
> +#define _LINUX_LTC2947_H
> +
> +struct regmap;
> +
> +extern const struct of_device_id ltc2947_of_match[];
> +extern const struct dev_pm_ops ltc2947_pm_ops;
> +
> +int ltc2947_core_probe(struct regmap *map, const char *name);
> +
> +#endif
^ permalink raw reply [flat|nested] only message in thread