[mirror_ubuntu-jammy-kernel.git] / drivers / hwmon / ltc4245.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Driver for Linear Technology LTC4245 I2C Multiple Supply Hot Swap Controller
 *
 * Copyright (C) 2008 Ira W. Snyder <iws@ovro.caltech.edu>
 *
 * This driver is based on the ds1621 and ina209 drivers.
 *
 * Datasheet:
 * http://www.linear.com/pc/downloadDocument.do?navId=H0,C1,C1003,C1006,C1140,P19392,D13517
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/bitops.h>
#include <linux/err.h>
#include <linux/slab.h>
#include <linux/i2c.h>
#include <linux/hwmon.h>
#include <linux/hwmon-sysfs.h>
#include <linux/jiffies.h>
#include <linux/platform_data/ltc4245.h>

/* Here are names of the chip's registers (a.k.a. commands) */
enum ltc4245_cmd {
	LTC4245_STATUS			= 0x00, /* readonly */
	LTC4245_ALERT			= 0x01,
	LTC4245_CONTROL			= 0x02,
	LTC4245_ON			= 0x03,
	LTC4245_FAULT1			= 0x04,
	LTC4245_FAULT2			= 0x05,
	LTC4245_GPIO			= 0x06,
	LTC4245_ADCADR			= 0x07,

	LTC4245_12VIN			= 0x10,
	LTC4245_12VSENSE		= 0x11,
	LTC4245_12VOUT			= 0x12,
	LTC4245_5VIN			= 0x13,
	LTC4245_5VSENSE			= 0x14,
	LTC4245_5VOUT			= 0x15,
	LTC4245_3VIN			= 0x16,
	LTC4245_3VSENSE			= 0x17,
	LTC4245_3VOUT			= 0x18,
	LTC4245_VEEIN			= 0x19,
	LTC4245_VEESENSE		= 0x1a,
	LTC4245_VEEOUT			= 0x1b,
	LTC4245_GPIOADC			= 0x1c,
};

struct ltc4245_data {
	struct i2c_client *client;

	struct mutex update_lock;
	bool valid;
	unsigned long last_updated; /* in jiffies */

	/* Control registers */
	u8 cregs[0x08];

	/* Voltage registers */
	u8 vregs[0x0d];

	/* GPIO ADC registers */
	bool use_extra_gpios;
	int gpios[3];
};

/*
 * Update the readings from the GPIO pins. If the driver has been configured to
 * sample all GPIO's as analog voltages, a round-robin sampling method is used.
 * Otherwise, only the configured GPIO pin is sampled.
 *
 * LOCKING: must hold data->update_lock
 */
static void ltc4245_update_gpios(struct device *dev)
{
	struct ltc4245_data *data = dev_get_drvdata(dev);
	struct i2c_client *client = data->client;
	u8 gpio_curr, gpio_next, gpio_reg;
	int i;

	/* no extra gpio support, we're basically done */
	if (!data->use_extra_gpios) {
		data->gpios[0] = data->vregs[LTC4245_GPIOADC - 0x10];
		return;
	}

	/*
	 * If the last reading was too long ago, then we mark all old GPIO
	 * readings as stale by setting them to -EAGAIN
	 */
	if (time_after(jiffies, data->last_updated + 5 * HZ)) {
		for (i = 0; i < ARRAY_SIZE(data->gpios); i++)
			data->gpios[i] = -EAGAIN;
	}

	/*
	 * Get the current GPIO pin
	 *
	 * The datasheet calls these GPIO[1-3], but we'll calculate the zero
	 * based array index instead, and call them GPIO[0-2]. This is much
	 * easier to think about.
	 */
	gpio_curr = (data->cregs[LTC4245_GPIO] & 0xc0) >> 6;
	if (gpio_curr > 0)
		gpio_curr -= 1;

	/* Read the GPIO voltage from the GPIOADC register */
	data->gpios[gpio_curr] = data->vregs[LTC4245_GPIOADC - 0x10];

	/* Find the next GPIO pin to read */
	gpio_next = (gpio_curr + 1) % ARRAY_SIZE(data->gpios);

	/*
	 * Calculate the correct setting for the GPIO register so it will
	 * sample the next GPIO pin
	 */
	gpio_reg = (data->cregs[LTC4245_GPIO] & 0x3f) | ((gpio_next + 1) << 6);

	/* Update the GPIO register */
	i2c_smbus_write_byte_data(client, LTC4245_GPIO, gpio_reg);

	/* Update saved data */
	data->cregs[LTC4245_GPIO] = gpio_reg;
}

static struct ltc4245_data *ltc4245_update_device(struct device *dev)
{
	struct ltc4245_data *data = dev_get_drvdata(dev);
	struct i2c_client *client = data->client;
	s32 val;
	int i;

	mutex_lock(&data->update_lock);

	if (time_after(jiffies, data->last_updated + HZ) || !data->valid) {

		/* Read control registers -- 0x00 to 0x07 */
		for (i = 0; i < ARRAY_SIZE(data->cregs); i++) {
			val = i2c_smbus_read_byte_data(client, i);
			if (unlikely(val < 0))
				data->cregs[i] = 0;
			else
				data->cregs[i] = val;
		}

		/* Read voltage registers -- 0x10 to 0x1c */
		for (i = 0; i < ARRAY_SIZE(data->vregs); i++) {
			val = i2c_smbus_read_byte_data(client, i+0x10);
			if (unlikely(val < 0))
				data->vregs[i] = 0;
			else
				data->vregs[i] = val;
		}

		/* Update GPIO readings */
		ltc4245_update_gpios(dev);

		data->last_updated = jiffies;
		data->valid = true;
	}

	mutex_unlock(&data->update_lock);

	return data;
}

/* Return the voltage from the given register in millivolts */
static int ltc4245_get_voltage(struct device *dev, u8 reg)
{
	struct ltc4245_data *data = ltc4245_update_device(dev);
	const u8 regval = data->vregs[reg - 0x10];
	u32 voltage = 0;

	switch (reg) {
	case LTC4245_12VIN:
	case LTC4245_12VOUT:
		voltage = regval * 55;
		break;
	case LTC4245_5VIN:
	case LTC4245_5VOUT:
		voltage = regval * 22;
		break;
	case LTC4245_3VIN:
	case LTC4245_3VOUT:
		voltage = regval * 15;
		break;
	case LTC4245_VEEIN:
	case LTC4245_VEEOUT:
		voltage = regval * -55;
		break;
	case LTC4245_GPIOADC:
		voltage = regval * 10;
		break;
	default:
		/* If we get here, the developer messed up */
		WARN_ON_ONCE(1);
		break;
	}

	return voltage;
}

/* Return the current in the given sense register in milliAmperes */
static unsigned int ltc4245_get_current(struct device *dev, u8 reg)
{
	struct ltc4245_data *data = ltc4245_update_device(dev);
	const u8 regval = data->vregs[reg - 0x10];
	unsigned int voltage;
	unsigned int curr;

	/*
	 * The strange looking conversions that follow are fixed-point
	 * math, since we cannot do floating point in the kernel.
	 *
	 * Step 1: convert sense register to microVolts
	 * Step 2: convert voltage to milliAmperes
	 *
	 * If you play around with the V=IR equation, you come up with
	 * the following: X uV / Y mOhm == Z mA
	 *
	 * With the resistors that are fractions of a milliOhm, we multiply
	 * the voltage and resistance by 10, to shift the decimal point.
	 * Now we can use the normal division operator again.
	 */

	switch (reg) {
	case LTC4245_12VSENSE:
		voltage = regval * 250; /* voltage in uV */
		curr = voltage / 50; /* sense resistor 50 mOhm */
		break;
	case LTC4245_5VSENSE:
		voltage = regval * 125; /* voltage in uV */
		curr = (voltage * 10) / 35; /* sense resistor 3.5 mOhm */
		break;
	case LTC4245_3VSENSE:
		voltage = regval * 125; /* voltage in uV */
		curr = (voltage * 10) / 25; /* sense resistor 2.5 mOhm */
		break;
	case LTC4245_VEESENSE:
		voltage = regval * 250; /* voltage in uV */
		curr = voltage / 100; /* sense resistor 100 mOhm */
		break;
	default:
		/* If we get here, the developer messed up */
		WARN_ON_ONCE(1);
		curr = 0;
		break;
	}

	return curr;
}

/* Map from voltage channel index to voltage register */

static const s8 ltc4245_in_regs[] = {
	LTC4245_12VIN, LTC4245_5VIN, LTC4245_3VIN, LTC4245_VEEIN,
	LTC4245_12VOUT, LTC4245_5VOUT, LTC4245_3VOUT, LTC4245_VEEOUT,
};

/* Map from current channel index to current register */

static const s8 ltc4245_curr_regs[] = {
	LTC4245_12VSENSE, LTC4245_5VSENSE, LTC4245_3VSENSE, LTC4245_VEESENSE,
};

static int ltc4245_read_curr(struct device *dev, u32 attr, int channel,
			     long *val)
{
	struct ltc4245_data *data = ltc4245_update_device(dev);

	switch (attr) {
	case hwmon_curr_input:
		*val = ltc4245_get_current(dev, ltc4245_curr_regs[channel]);
		return 0;
	case hwmon_curr_max_alarm:
		*val = !!(data->cregs[LTC4245_FAULT1] & BIT(channel + 4));
		return 0;
	default:
		return -EOPNOTSUPP;
	}
}

static int ltc4245_read_in(struct device *dev, u32 attr, int channel, long *val)
{
	struct ltc4245_data *data = ltc4245_update_device(dev);

	switch (attr) {
	case hwmon_in_input:
		if (channel < 8) {
			*val = ltc4245_get_voltage(dev,
						ltc4245_in_regs[channel]);
		} else {
			int regval = data->gpios[channel - 8];

			if (regval < 0)
				return regval;
			*val = regval * 10;
		}
		return 0;
	case hwmon_in_min_alarm:
		if (channel < 4)
			*val = !!(data->cregs[LTC4245_FAULT1] & BIT(channel));
		else
			*val = !!(data->cregs[LTC4245_FAULT2] &
				  BIT(channel - 4));
		return 0;
	default:
		return -EOPNOTSUPP;
	}
}

static int ltc4245_read_power(struct device *dev, u32 attr, int channel,
			      long *val)
{
	unsigned long curr;
	long voltage;

	switch (attr) {
	case hwmon_power_input:
		(void)ltc4245_update_device(dev);
		curr = ltc4245_get_current(dev, ltc4245_curr_regs[channel]);
		voltage = ltc4245_get_voltage(dev, ltc4245_in_regs[channel]);
		*val = abs(curr * voltage);
		return 0;
	default:
		return -EOPNOTSUPP;
	}
}

static int ltc4245_read(struct device *dev, enum hwmon_sensor_types type,
			u32 attr, int channel, long *val)
{

	switch (type) {
	case hwmon_curr:
		return ltc4245_read_curr(dev, attr, channel, val);
	case hwmon_power:
		return ltc4245_read_power(dev, attr, channel, val);
	case hwmon_in:
		return ltc4245_read_in(dev, attr, channel - 1, val);
	default:
		return -EOPNOTSUPP;
	}
}

static umode_t ltc4245_is_visible(const void *_data,
				  enum hwmon_sensor_types type,
				  u32 attr, int channel)
{
	const struct ltc4245_data *data = _data;

	switch (type) {
	case hwmon_in:
		if (channel == 0)
			return 0;
		switch (attr) {
		case hwmon_in_input:
			if (channel > 9 && !data->use_extra_gpios)
				return 0;
			return 0444;
		case hwmon_in_min_alarm:
			if (channel > 8)
				return 0;
			return 0444;
		default:
			return 0;
		}
	case hwmon_curr:
		switch (attr) {
		case hwmon_curr_input:
		case hwmon_curr_max_alarm:
			return 0444;
		default:
			return 0;
		}
	case hwmon_power:
		switch (attr) {
		case hwmon_power_input:
			return 0444;
		default:
			return 0;
		}
	default:
		return 0;
	}
}

static const struct hwmon_channel_info *ltc4245_info[] = {
	HWMON_CHANNEL_INFO(in,
			   HWMON_I_INPUT,
			   HWMON_I_INPUT | HWMON_I_MIN_ALARM,
			   HWMON_I_INPUT | HWMON_I_MIN_ALARM,
			   HWMON_I_INPUT | HWMON_I_MIN_ALARM,
			   HWMON_I_INPUT | HWMON_I_MIN_ALARM,
			   HWMON_I_INPUT | HWMON_I_MIN_ALARM,
			   HWMON_I_INPUT | HWMON_I_MIN_ALARM,
			   HWMON_I_INPUT | HWMON_I_MIN_ALARM,
			   HWMON_I_INPUT | HWMON_I_MIN_ALARM,
			   HWMON_I_INPUT,
			   HWMON_I_INPUT,
			   HWMON_I_INPUT),
	HWMON_CHANNEL_INFO(curr,
			   HWMON_C_INPUT | HWMON_C_MAX_ALARM,
			   HWMON_C_INPUT | HWMON_C_MAX_ALARM,
			   HWMON_C_INPUT | HWMON_C_MAX_ALARM,
			   HWMON_C_INPUT | HWMON_C_MAX_ALARM),
	HWMON_CHANNEL_INFO(power,
			   HWMON_P_INPUT,
			   HWMON_P_INPUT,
			   HWMON_P_INPUT,
			   HWMON_P_INPUT),
	NULL
};

static const struct hwmon_ops ltc4245_hwmon_ops = {
	.is_visible = ltc4245_is_visible,
	.read = ltc4245_read,
};

static const struct hwmon_chip_info ltc4245_chip_info = {
	.ops = &ltc4245_hwmon_ops,
	.info = ltc4245_info,
};

static bool ltc4245_use_extra_gpios(struct i2c_client *client)
{
	struct ltc4245_platform_data *pdata = dev_get_platdata(&client->dev);
	struct device_node *np = client->dev.of_node;

	/* prefer platform data */
	if (pdata)
		return pdata->use_extra_gpios;

	/* fallback on OF */
	if (of_find_property(np, "ltc4245,use-extra-gpios", NULL))
		return true;

	return false;
}

static int ltc4245_probe(struct i2c_client *client)
{
	struct i2c_adapter *adapter = client->adapter;
	struct ltc4245_data *data;
	struct device *hwmon_dev;

	if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
		return -ENODEV;

	data = devm_kzalloc(&client->dev, sizeof(*data), GFP_KERNEL);
	if (!data)
		return -ENOMEM;

	data->client = client;
	mutex_init(&data->update_lock);
	data->use_extra_gpios = ltc4245_use_extra_gpios(client);

	/* Initialize the LTC4245 chip */
	i2c_smbus_write_byte_data(client, LTC4245_FAULT1, 0x00);
	i2c_smbus_write_byte_data(client, LTC4245_FAULT2, 0x00);

	hwmon_dev = devm_hwmon_device_register_with_info(&client->dev,
							 client->name, data,
							 &ltc4245_chip_info,
							 NULL);
	return PTR_ERR_OR_ZERO(hwmon_dev);
}

static const struct i2c_device_id ltc4245_id[] = {
	{ "ltc4245", 0 },
	{ }
};
MODULE_DEVICE_TABLE(i2c, ltc4245_id);

/* This is the driver that will be inserted */
static struct i2c_driver ltc4245_driver = {
	.driver = {
		.name	= "ltc4245",
	},
	.probe_new	= ltc4245_probe,
	.id_table	= ltc4245_id,
};

module_i2c_driver(ltc4245_driver);

MODULE_AUTHOR("Ira W. Snyder <iws@ovro.caltech.edu>");
MODULE_DESCRIPTION("LTC4245 driver");
MODULE_LICENSE("GPL");
Commit	Line	Data
b886d83c	1	// SPDX-License-Identifier: GPL-2.0-only
6e34b187 IS	2	/*
	3	* Driver for Linear Technology LTC4245 I2C Multiple Supply Hot Swap Controller
	4	*
	5	* Copyright (C) 2008 Ira W. Snyder <iws@ovro.caltech.edu>
	6	*
6e34b187 IS	7	* This driver is based on the ds1621 and ina209 drivers.
	8	*
	9	* Datasheet:
	10	* http://www.linear.com/pc/downloadDocument.do?navId=H0,C1,C1003,C1006,C1140,P19392,D13517
	11	*/
	12
	13	#include <linux/kernel.h>
	14	#include <linux/module.h>
	15	#include <linux/init.h>
a584287c	16	#include <linux/bitops.h>
6e34b187 IS	17	#include <linux/err.h>
	18	#include <linux/slab.h>
	19	#include <linux/i2c.h>
	20	#include <linux/hwmon.h>
	21	#include <linux/hwmon-sysfs.h>
dcd8f392	22	#include <linux/jiffies.h>
8116e8dd	23	#include <linux/platform_data/ltc4245.h>
6e34b187	24
6e34b187 IS	25	/* Here are names of the chip's registers (a.k.a. commands) */
	26	enum ltc4245_cmd {
	27	LTC4245_STATUS = 0x00, /* readonly */
	28	LTC4245_ALERT = 0x01,
	29	LTC4245_CONTROL = 0x02,
	30	LTC4245_ON = 0x03,
	31	LTC4245_FAULT1 = 0x04,
	32	LTC4245_FAULT2 = 0x05,
	33	LTC4245_GPIO = 0x06,
	34	LTC4245_ADCADR = 0x07,
	35
	36	LTC4245_12VIN = 0x10,
	37	LTC4245_12VSENSE = 0x11,
	38	LTC4245_12VOUT = 0x12,
	39	LTC4245_5VIN = 0x13,
	40	LTC4245_5VSENSE = 0x14,
	41	LTC4245_5VOUT = 0x15,
	42	LTC4245_3VIN = 0x16,
	43	LTC4245_3VSENSE = 0x17,
	44	LTC4245_3VOUT = 0x18,
	45	LTC4245_VEEIN = 0x19,
	46	LTC4245_VEESENSE = 0x1a,
	47	LTC4245_VEEOUT = 0x1b,
df16dd53	48	LTC4245_GPIOADC = 0x1c,
6e34b187 IS	49	};
	50
	51	struct ltc4245_data {
9a85d53c GR	52	struct i2c_client *client;
9a85d53c GR	53
6e34b187 IS	54	struct mutex update_lock;
	55	bool valid;
	56	unsigned long last_updated; /* in jiffies */
	57
	58	/* Control registers */
	59	u8 cregs[0x08];
	60
	61	/* Voltage registers */
df16dd53	62	u8 vregs[0x0d];
5950ec8d IS	63
	64	/* GPIO ADC registers */
	65	bool use_extra_gpios;
	66	int gpios[3];
6e34b187 IS	67	};
6e34b187 IS	68
5950ec8d IS	69	/*
	70	* Update the readings from the GPIO pins. If the driver has been configured to
	71	* sample all GPIO's as analog voltages, a round-robin sampling method is used.
	72	* Otherwise, only the configured GPIO pin is sampled.
	73	*
	74	* LOCKING: must hold data->update_lock
	75	*/
	76	static void ltc4245_update_gpios(struct device *dev)
	77	{
9a85d53c GR	78	struct ltc4245_data *data = dev_get_drvdata(dev);
9a85d53c GR	79	struct i2c_client *client = data->client;
5950ec8d IS	80	u8 gpio_curr, gpio_next, gpio_reg;
	81	int i;
	82
	83	/* no extra gpio support, we're basically done */
	84	if (!data->use_extra_gpios) {
	85	data->gpios[0] = data->vregs[LTC4245_GPIOADC - 0x10];
	86	return;
	87	}
	88
	89	/*
	90	* If the last reading was too long ago, then we mark all old GPIO
	91	* readings as stale by setting them to -EAGAIN
	92	*/
	93	if (time_after(jiffies, data->last_updated + 5 * HZ)) {
5950ec8d IS	94	for (i = 0; i < ARRAY_SIZE(data->gpios); i++)
	95	data->gpios[i] = -EAGAIN;
	96	}
	97
	98	/*
	99	* Get the current GPIO pin
	100	*
	101	* The datasheet calls these GPIO[1-3], but we'll calculate the zero
	102	* based array index instead, and call them GPIO[0-2]. This is much
	103	* easier to think about.
	104	*/
	105	gpio_curr = (data->cregs[LTC4245_GPIO] & 0xc0) >> 6;
	106	if (gpio_curr > 0)
	107	gpio_curr -= 1;
	108
	109	/* Read the GPIO voltage from the GPIOADC register */
	110	data->gpios[gpio_curr] = data->vregs[LTC4245_GPIOADC - 0x10];
	111
	112	/* Find the next GPIO pin to read */
	113	gpio_next = (gpio_curr + 1) % ARRAY_SIZE(data->gpios);
	114
	115	/*
	116	* Calculate the correct setting for the GPIO register so it will
	117	* sample the next GPIO pin
	118	*/
	119	gpio_reg = (data->cregs[LTC4245_GPIO] & 0x3f) \| ((gpio_next + 1) << 6);
	120
	121	/* Update the GPIO register */
	122	i2c_smbus_write_byte_data(client, LTC4245_GPIO, gpio_reg);
	123
	124	/* Update saved data */
	125	data->cregs[LTC4245_GPIO] = gpio_reg;
	126	}
	127
6e34b187 IS	128	static struct ltc4245_data ltc4245_update_device(struct device dev)
6e34b187 IS	129	{
9a85d53c GR	130	struct ltc4245_data *data = dev_get_drvdata(dev);
9a85d53c GR	131	struct i2c_client *client = data->client;
6e34b187 IS	132	s32 val;
	133	int i;
	134
	135	mutex_lock(&data->update_lock);
	136
	137	if (time_after(jiffies, data->last_updated + HZ) \|\| !data->valid) {
	138
6e34b187 IS	139	/* Read control registers -- 0x00 to 0x07 */
	140	for (i = 0; i < ARRAY_SIZE(data->cregs); i++) {
	141	val = i2c_smbus_read_byte_data(client, i);
	142	if (unlikely(val < 0))
	143	data->cregs[i] = 0;
	144	else
	145	data->cregs[i] = val;
	146	}
	147
df16dd53	148	/* Read voltage registers -- 0x10 to 0x1c */
6e34b187 IS	149	for (i = 0; i < ARRAY_SIZE(data->vregs); i++) {
	150	val = i2c_smbus_read_byte_data(client, i+0x10);
	151	if (unlikely(val < 0))
	152	data->vregs[i] = 0;
	153	else
	154	data->vregs[i] = val;
	155	}
	156
5950ec8d IS	157	/* Update GPIO readings */
	158	ltc4245_update_gpios(dev);
	159
6e34b187	160	data->last_updated = jiffies;
a584287c	161	data->valid = true;
6e34b187 IS	162	}
	163
	164	mutex_unlock(&data->update_lock);
	165
	166	return data;
	167	}
	168
	169	/* Return the voltage from the given register in millivolts */
	170	static int ltc4245_get_voltage(struct device *dev, u8 reg)
	171	{
	172	struct ltc4245_data *data = ltc4245_update_device(dev);
	173	const u8 regval = data->vregs[reg - 0x10];
	174	u32 voltage = 0;
	175
	176	switch (reg) {
	177	case LTC4245_12VIN:
	178	case LTC4245_12VOUT:
	179	voltage = regval * 55;
	180	break;
	181	case LTC4245_5VIN:
	182	case LTC4245_5VOUT:
	183	voltage = regval * 22;
	184	break;
	185	case LTC4245_3VIN:
	186	case LTC4245_3VOUT:
	187	voltage = regval * 15;
	188	break;
	189	case LTC4245_VEEIN:
	190	case LTC4245_VEEOUT:
	191	voltage = regval * -55;
	192	break;
df16dd53	193	case LTC4245_GPIOADC:
6e34b187 IS	194	voltage = regval * 10;
	195	break;
	196	default:
	197	/* If we get here, the developer messed up */
	198	WARN_ON_ONCE(1);
	199	break;
	200	}
	201
	202	return voltage;
	203	}
	204
	205	/* Return the current in the given sense register in milliAmperes */
	206	static unsigned int ltc4245_get_current(struct device *dev, u8 reg)
	207	{
	208	struct ltc4245_data *data = ltc4245_update_device(dev);
	209	const u8 regval = data->vregs[reg - 0x10];
	210	unsigned int voltage;
	211	unsigned int curr;
	212
430b4fcd GR	213	/*
430b4fcd GR	214	* The strange looking conversions that follow are fixed-point
6e34b187 IS	215	* math, since we cannot do floating point in the kernel.
	216	*
	217	* Step 1: convert sense register to microVolts
	218	* Step 2: convert voltage to milliAmperes
	219	*
	220	* If you play around with the V=IR equation, you come up with
	221	* the following: X uV / Y mOhm == Z mA
	222	*
	223	* With the resistors that are fractions of a milliOhm, we multiply
	224	* the voltage and resistance by 10, to shift the decimal point.
	225	* Now we can use the normal division operator again.
	226	*/
	227
	228	switch (reg) {
	229	case LTC4245_12VSENSE:
	230	voltage = regval * 250; /* voltage in uV */
	231	curr = voltage / 50; /* sense resistor 50 mOhm */
	232	break;
	233	case LTC4245_5VSENSE:
	234	voltage = regval * 125; /* voltage in uV */
	235	curr = (voltage * 10) / 35; /* sense resistor 3.5 mOhm */
	236	break;
	237	case LTC4245_3VSENSE:
	238	voltage = regval * 125; /* voltage in uV */
	239	curr = (voltage * 10) / 25; /* sense resistor 2.5 mOhm */
	240	break;
	241	case LTC4245_VEESENSE:
	242	voltage = regval * 250; /* voltage in uV */
	243	curr = voltage / 100; /* sense resistor 100 mOhm */
	244	break;
	245	default:
	246	/* If we get here, the developer messed up */
	247	WARN_ON_ONCE(1);
	248	curr = 0;
	249	break;
	250	}
	251
	252	return curr;
	253	}
	254
a584287c	255	/* Map from voltage channel index to voltage register */
6e34b187	256
a584287c GR	257	static const s8 ltc4245_in_regs[] = {
	258	LTC4245_12VIN, LTC4245_5VIN, LTC4245_3VIN, LTC4245_VEEIN,
	259	LTC4245_12VOUT, LTC4245_5VOUT, LTC4245_3VOUT, LTC4245_VEEOUT,
	260	};
	261
	262	/* Map from current channel index to current register */
6e34b187	263
a584287c GR	264	static const s8 ltc4245_curr_regs[] = {
	265	LTC4245_12VSENSE, LTC4245_5VSENSE, LTC4245_3VSENSE, LTC4245_VEESENSE,
	266	};
	267
	268	static int ltc4245_read_curr(struct device *dev, u32 attr, int channel,
	269	long *val)
6e34b187	270	{
a584287c	271	struct ltc4245_data *data = ltc4245_update_device(dev);
6e34b187	272
a584287c GR	273	switch (attr) {
	274	case hwmon_curr_input:
	275	*val = ltc4245_get_current(dev, ltc4245_curr_regs[channel]);
	276	return 0;
	277	case hwmon_curr_max_alarm:
	278	*val = !!(data->cregs[LTC4245_FAULT1] & BIT(channel + 4));
	279	return 0;
	280	default:
	281	return -EOPNOTSUPP;
	282	}
6e34b187 IS	283	}
6e34b187 IS	284
a584287c	285	static int ltc4245_read_in(struct device dev, u32 attr, int channel, long val)
6e34b187	286	{
a584287c	287	struct ltc4245_data *data = ltc4245_update_device(dev);
6e34b187	288
a584287c GR	289	switch (attr) {
	290	case hwmon_in_input:
	291	if (channel < 8) {
	292	*val = ltc4245_get_voltage(dev,
	293	ltc4245_in_regs[channel]);
	294	} else {
	295	int regval = data->gpios[channel - 8];
	296
	297	if (regval < 0)
	298	return regval;
	299	val = regval 10;
	300	}
	301	return 0;
	302	case hwmon_in_min_alarm:
	303	if (channel < 4)
	304	*val = !!(data->cregs[LTC4245_FAULT1] & BIT(channel));
	305	else
	306	*val = !!(data->cregs[LTC4245_FAULT2] &
	307	BIT(channel - 4));
	308	return 0;
	309	default:
	310	return -EOPNOTSUPP;
	311	}
	312	}
6e34b187	313
a584287c GR	314	static int ltc4245_read_power(struct device *dev, u32 attr, int channel,
	315	long *val)
	316	{
	317	unsigned long curr;
	318	long voltage;
	319
	320	switch (attr) {
	321	case hwmon_power_input:
	322	(void)ltc4245_update_device(dev);
	323	curr = ltc4245_get_current(dev, ltc4245_curr_regs[channel]);
	324	voltage = ltc4245_get_voltage(dev, ltc4245_in_regs[channel]);
	325	val = abs(curr voltage);
	326	return 0;
	327	default:
	328	return -EOPNOTSUPP;
	329	}
6e34b187 IS	330	}
6e34b187 IS	331
a584287c GR	332	static int ltc4245_read(struct device *dev, enum hwmon_sensor_types type,
a584287c GR	333	u32 attr, int channel, long *val)
6e34b187	334	{
6e34b187	335
a584287c GR	336	switch (type) {
	337	case hwmon_curr:
	338	return ltc4245_read_curr(dev, attr, channel, val);
	339	case hwmon_power:
	340	return ltc4245_read_power(dev, attr, channel, val);
	341	case hwmon_in:
	342	return ltc4245_read_in(dev, attr, channel - 1, val);
	343	default:
	344	return -EOPNOTSUPP;
	345	}
6e34b187 IS	346	}
6e34b187 IS	347
a584287c GR	348	static umode_t ltc4245_is_visible(const void *_data,
	349	enum hwmon_sensor_types type,
	350	u32 attr, int channel)
5950ec8d	351	{
a584287c GR	352	const struct ltc4245_data *data = _data;
	353
	354	switch (type) {
	355	case hwmon_in:
	356	if (channel == 0)
	357	return 0;
	358	switch (attr) {
	359	case hwmon_in_input:
	360	if (channel > 9 && !data->use_extra_gpios)
	361	return 0;
d703e7f1	362	return 0444;
a584287c GR	363	case hwmon_in_min_alarm:
	364	if (channel > 8)
	365	return 0;
d703e7f1	366	return 0444;
a584287c GR	367	default:
	368	return 0;
	369	}
	370	case hwmon_curr:
	371	switch (attr) {
	372	case hwmon_curr_input:
	373	case hwmon_curr_max_alarm:
d703e7f1	374	return 0444;
a584287c GR	375	default:
	376	return 0;
	377	}
	378	case hwmon_power:
	379	switch (attr) {
	380	case hwmon_power_input:
d703e7f1	381	return 0444;
a584287c GR	382	default:
	383	return 0;
	384	}
	385	default:
	386	return 0;
	387	}
	388	}
5950ec8d	389
a584287c	390	static const struct hwmon_channel_info *ltc4245_info[] = {
0ee508f0 GR	391	HWMON_CHANNEL_INFO(in,
	392	HWMON_I_INPUT,
	393	HWMON_I_INPUT \| HWMON_I_MIN_ALARM,
	394	HWMON_I_INPUT \| HWMON_I_MIN_ALARM,
	395	HWMON_I_INPUT \| HWMON_I_MIN_ALARM,
	396	HWMON_I_INPUT \| HWMON_I_MIN_ALARM,
	397	HWMON_I_INPUT \| HWMON_I_MIN_ALARM,
	398	HWMON_I_INPUT \| HWMON_I_MIN_ALARM,
	399	HWMON_I_INPUT \| HWMON_I_MIN_ALARM,
	400	HWMON_I_INPUT \| HWMON_I_MIN_ALARM,
	401	HWMON_I_INPUT,
	402	HWMON_I_INPUT,
	403	HWMON_I_INPUT),
	404	HWMON_CHANNEL_INFO(curr,
	405	HWMON_C_INPUT \| HWMON_C_MAX_ALARM,
	406	HWMON_C_INPUT \| HWMON_C_MAX_ALARM,
	407	HWMON_C_INPUT \| HWMON_C_MAX_ALARM,
	408	HWMON_C_INPUT \| HWMON_C_MAX_ALARM),
	409	HWMON_CHANNEL_INFO(power,
	410	HWMON_P_INPUT,
	411	HWMON_P_INPUT,
	412	HWMON_P_INPUT,
	413	HWMON_P_INPUT),
a584287c	414	NULL
6e34b187 IS	415	};
6e34b187 IS	416
a584287c GR	417	static const struct hwmon_ops ltc4245_hwmon_ops = {
	418	.is_visible = ltc4245_is_visible,
	419	.read = ltc4245_read,
	420	};
5950ec8d	421
a584287c GR	422	static const struct hwmon_chip_info ltc4245_chip_info = {
	423	.ops = &ltc4245_hwmon_ops,
	424	.info = ltc4245_info,
	425	};
5950ec8d IS	426
	427	static bool ltc4245_use_extra_gpios(struct i2c_client *client)
	428	{
	429	struct ltc4245_platform_data *pdata = dev_get_platdata(&client->dev);
5950ec8d	430	struct device_node *np = client->dev.of_node;
5950ec8d IS	431
	432	/* prefer platform data */
	433	if (pdata)
	434	return pdata->use_extra_gpios;
	435
5950ec8d IS	436	/* fallback on OF */
	437	if (of_find_property(np, "ltc4245,use-extra-gpios", NULL))
	438	return true;
5950ec8d IS	439
	440	return false;
	441	}
	442
67487038	443	static int ltc4245_probe(struct i2c_client *client)
6e34b187	444	{
2d2a7cff	445	struct i2c_adapter *adapter = client->adapter;
6e34b187	446	struct ltc4245_data *data;
9a85d53c	447	struct device *hwmon_dev;
6e34b187	448
2d2a7cff JD	449	if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
	450	return -ENODEV;
	451
effb8ab1 GR	452	data = devm_kzalloc(&client->dev, sizeof(*data), GFP_KERNEL);
	453	if (!data)
	454	return -ENOMEM;
6e34b187	455
9a85d53c	456	data->client = client;
6e34b187	457	mutex_init(&data->update_lock);
5950ec8d	458	data->use_extra_gpios = ltc4245_use_extra_gpios(client);
6e34b187 IS	459
6e34b187 IS	460	/* Initialize the LTC4245 chip */
58f055e5 IS	461	i2c_smbus_write_byte_data(client, LTC4245_FAULT1, 0x00);
58f055e5 IS	462	i2c_smbus_write_byte_data(client, LTC4245_FAULT2, 0x00);
6e34b187	463
a584287c GR	464	hwmon_dev = devm_hwmon_device_register_with_info(&client->dev,
	465	client->name, data,
	466	&ltc4245_chip_info,
	467	NULL);
94c42cf9	468	return PTR_ERR_OR_ZERO(hwmon_dev);
6e34b187 IS	469	}
6e34b187 IS	470
6e34b187	471	static const struct i2c_device_id ltc4245_id[] = {
2d2a7cff	472	{ "ltc4245", 0 },
6e34b187 IS	473	{ }
	474	};
	475	MODULE_DEVICE_TABLE(i2c, ltc4245_id);
	476
	477	/* This is the driver that will be inserted */
	478	static struct i2c_driver ltc4245_driver = {
6e34b187 IS	479	.driver = {
	480	.name = "ltc4245",
	481	},
67487038	482	.probe_new = ltc4245_probe,
6e34b187	483	.id_table = ltc4245_id,
6e34b187 IS	484	};
6e34b187 IS	485
f0967eea	486	module_i2c_driver(ltc4245_driver);
6e34b187 IS	487
	488	MODULE_AUTHOR("Ira W. Snyder <iws@ovro.caltech.edu>");
	489	MODULE_DESCRIPTION("LTC4245 driver");
	490	MODULE_LICENSE("GPL");