[deliverable/linux.git] / drivers / hwmon / pmbus / ltc2978.c

/*
 * Hardware monitoring driver for LTC2974, LTC2977, LTC2978, LTC3880,
 * LTC3883, and LTM4676
 *
 * Copyright (c) 2011 Ericsson AB.
 * Copyright (c) 2013, 2014 Guenter Roeck
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/err.h>
#include <linux/slab.h>
#include <linux/i2c.h>
#include <linux/regulator/driver.h>
#include "pmbus.h"

enum chips { ltc2974, ltc2977, ltc2978, ltc3880, ltc3883, ltm4676 };

/* Common for all chips */
#define LTC2978_MFR_VOUT_PEAK		0xdd
#define LTC2978_MFR_VIN_PEAK		0xde
#define LTC2978_MFR_TEMPERATURE_PEAK	0xdf
#define LTC2978_MFR_SPECIAL_ID		0xe7

/* LTC2974, LCT2977, and LTC2978 */
#define LTC2978_MFR_VOUT_MIN		0xfb
#define LTC2978_MFR_VIN_MIN		0xfc
#define LTC2978_MFR_TEMPERATURE_MIN	0xfd

/* LTC2974 only */
#define LTC2974_MFR_IOUT_PEAK		0xd7
#define LTC2974_MFR_IOUT_MIN		0xd8

/* LTC3880, LTC3883, and LTM4676 */
#define LTC3880_MFR_IOUT_PEAK		0xd7
#define LTC3880_MFR_CLEAR_PEAKS		0xe3
#define LTC3880_MFR_TEMPERATURE2_PEAK	0xf4

/* LTC3883 only */
#define LTC3883_MFR_IIN_PEAK		0xe1

#define LTC2974_ID_REV1			0x0212
#define LTC2974_ID_REV2			0x0213
#define LTC2977_ID			0x0130
#define LTC2978_ID_REV1			0x0121
#define LTC2978_ID_REV2			0x0122
#define LTC2978A_ID			0x0124
#define LTC3880_ID			0x4000
#define LTC3880_ID_MASK			0xff00
#define LTC3883_ID			0x4300
#define LTC3883_ID_MASK			0xff00
#define LTM4676_ID			0x4480	/* datasheet claims 0x440X */
#define LTM4676_ID_MASK			0xfff0

#define LTC2974_NUM_PAGES		4
#define LTC2978_NUM_PAGES		8
#define LTC3880_NUM_PAGES		2
#define LTC3883_NUM_PAGES		1

/*
 * LTC2978 clears peak data whenever the CLEAR_FAULTS command is executed, which
 * happens pretty much each time chip data is updated. Raw peak data therefore
 * does not provide much value. To be able to provide useful peak data, keep an
 * internal cache of measured peak data, which is only cleared if an explicit
 * "clear peak" command is executed for the sensor in question.
 */

struct ltc2978_data {
	enum chips id;
	u16 vin_min, vin_max;
	u16 temp_min[LTC2974_NUM_PAGES], temp_max[LTC2974_NUM_PAGES];
	u16 vout_min[LTC2978_NUM_PAGES], vout_max[LTC2978_NUM_PAGES];
	u16 iout_min[LTC2974_NUM_PAGES], iout_max[LTC2974_NUM_PAGES];
	u16 iin_max;
	u16 temp2_max;
	struct pmbus_driver_info info;
};

#define to_ltc2978_data(x)  container_of(x, struct ltc2978_data, info)

static inline int lin11_to_val(int data)
{
	s16 e = ((s16)data) >> 11;
	s32 m = (((s16)(data << 5)) >> 5);

	/*
	 * mantissa is 10 bit + sign, exponent adds up to 15 bit.
	 * Add 6 bit to exponent for maximum accuracy (10 + 15 + 6 = 31).
	 */
	e += 6;
	return (e < 0 ? m >> -e : m << e);
}

static int ltc2978_read_word_data_common(struct i2c_client *client, int page,
					 int reg)
{
	const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
	struct ltc2978_data *data = to_ltc2978_data(info);
	int ret;

	switch (reg) {
	case PMBUS_VIRT_READ_VIN_MAX:
		ret = pmbus_read_word_data(client, page, LTC2978_MFR_VIN_PEAK);
		if (ret >= 0) {
			if (lin11_to_val(ret) > lin11_to_val(data->vin_max))
				data->vin_max = ret;
			ret = data->vin_max;
		}
		break;
	case PMBUS_VIRT_READ_VOUT_MAX:
		ret = pmbus_read_word_data(client, page, LTC2978_MFR_VOUT_PEAK);
		if (ret >= 0) {
			/*
			 * VOUT is 16 bit unsigned with fixed exponent,
			 * so we can compare it directly
			 */
			if (ret > data->vout_max[page])
				data->vout_max[page] = ret;
			ret = data->vout_max[page];
		}
		break;
	case PMBUS_VIRT_READ_TEMP_MAX:
		ret = pmbus_read_word_data(client, page,
					   LTC2978_MFR_TEMPERATURE_PEAK);
		if (ret >= 0) {
			if (lin11_to_val(ret)
			    > lin11_to_val(data->temp_max[page]))
				data->temp_max[page] = ret;
			ret = data->temp_max[page];
		}
		break;
	case PMBUS_VIRT_RESET_VOUT_HISTORY:
	case PMBUS_VIRT_RESET_VIN_HISTORY:
	case PMBUS_VIRT_RESET_TEMP_HISTORY:
		ret = 0;
		break;
	default:
		ret = -ENODATA;
		break;
	}
	return ret;
}

static int ltc2978_read_word_data(struct i2c_client *client, int page, int reg)
{
	const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
	struct ltc2978_data *data = to_ltc2978_data(info);
	int ret;

	switch (reg) {
	case PMBUS_VIRT_READ_VIN_MIN:
		ret = pmbus_read_word_data(client, page, LTC2978_MFR_VIN_MIN);
		if (ret >= 0) {
			if (lin11_to_val(ret) < lin11_to_val(data->vin_min))
				data->vin_min = ret;
			ret = data->vin_min;
		}
		break;
	case PMBUS_VIRT_READ_VOUT_MIN:
		ret = pmbus_read_word_data(client, page, LTC2978_MFR_VOUT_MIN);
		if (ret >= 0) {
			/*
			 * VOUT_MIN is known to not be supported on some lots
			 * of LTC2978 revision 1, and will return the maximum
			 * possible voltage if read. If VOUT_MAX is valid and
			 * lower than the reading of VOUT_MIN, use it instead.
			 */
			if (data->vout_max[page] && ret > data->vout_max[page])
				ret = data->vout_max[page];
			if (ret < data->vout_min[page])
				data->vout_min[page] = ret;
			ret = data->vout_min[page];
		}
		break;
	case PMBUS_VIRT_READ_TEMP_MIN:
		ret = pmbus_read_word_data(client, page,
					   LTC2978_MFR_TEMPERATURE_MIN);
		if (ret >= 0) {
			if (lin11_to_val(ret)
			    < lin11_to_val(data->temp_min[page]))
				data->temp_min[page] = ret;
			ret = data->temp_min[page];
		}
		break;
	case PMBUS_VIRT_READ_IOUT_MAX:
	case PMBUS_VIRT_RESET_IOUT_HISTORY:
	case PMBUS_VIRT_READ_TEMP2_MAX:
	case PMBUS_VIRT_RESET_TEMP2_HISTORY:
		ret = -ENXIO;
		break;
	default:
		ret = ltc2978_read_word_data_common(client, page, reg);
		break;
	}
	return ret;
}

static int ltc2974_read_word_data(struct i2c_client *client, int page, int reg)
{
	const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
	struct ltc2978_data *data = to_ltc2978_data(info);
	int ret;

	switch (reg) {
	case PMBUS_VIRT_READ_IOUT_MAX:
		ret = pmbus_read_word_data(client, page, LTC2974_MFR_IOUT_PEAK);
		if (ret >= 0) {
			if (lin11_to_val(ret)
			    > lin11_to_val(data->iout_max[page]))
				data->iout_max[page] = ret;
			ret = data->iout_max[page];
		}
		break;
	case PMBUS_VIRT_READ_IOUT_MIN:
		ret = pmbus_read_word_data(client, page, LTC2974_MFR_IOUT_MIN);
		if (ret >= 0) {
			if (lin11_to_val(ret)
			    < lin11_to_val(data->iout_min[page]))
				data->iout_min[page] = ret;
			ret = data->iout_min[page];
		}
		break;
	case PMBUS_VIRT_RESET_IOUT_HISTORY:
		ret = 0;
		break;
	default:
		ret = ltc2978_read_word_data(client, page, reg);
		break;
	}
	return ret;
}

static int ltc3880_read_word_data(struct i2c_client *client, int page, int reg)
{
	const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
	struct ltc2978_data *data = to_ltc2978_data(info);
	int ret;

	switch (reg) {
	case PMBUS_VIRT_READ_IOUT_MAX:
		ret = pmbus_read_word_data(client, page, LTC3880_MFR_IOUT_PEAK);
		if (ret >= 0) {
			if (lin11_to_val(ret)
			    > lin11_to_val(data->iout_max[page]))
				data->iout_max[page] = ret;
			ret = data->iout_max[page];
		}
		break;
	case PMBUS_VIRT_READ_TEMP2_MAX:
		ret = pmbus_read_word_data(client, page,
					   LTC3880_MFR_TEMPERATURE2_PEAK);
		if (ret >= 0) {
			if (lin11_to_val(ret) > lin11_to_val(data->temp2_max))
				data->temp2_max = ret;
			ret = data->temp2_max;
		}
		break;
	case PMBUS_VIRT_READ_VIN_MIN:
	case PMBUS_VIRT_READ_VOUT_MIN:
	case PMBUS_VIRT_READ_TEMP_MIN:
		ret = -ENXIO;
		break;
	case PMBUS_VIRT_RESET_IOUT_HISTORY:
	case PMBUS_VIRT_RESET_TEMP2_HISTORY:
		ret = 0;
		break;
	default:
		ret = ltc2978_read_word_data_common(client, page, reg);
		break;
	}
	return ret;
}

static int ltc3883_read_word_data(struct i2c_client *client, int page, int reg)
{
	const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
	struct ltc2978_data *data = to_ltc2978_data(info);
	int ret;

	switch (reg) {
	case PMBUS_VIRT_READ_IIN_MAX:
		ret = pmbus_read_word_data(client, page, LTC3883_MFR_IIN_PEAK);
		if (ret >= 0) {
			if (lin11_to_val(ret)
			    > lin11_to_val(data->iin_max))
				data->iin_max = ret;
			ret = data->iin_max;
		}
		break;
	case PMBUS_VIRT_RESET_IIN_HISTORY:
		ret = 0;
		break;
	default:
		ret = ltc3880_read_word_data(client, page, reg);
		break;
	}
	return ret;
}

static int ltc2978_clear_peaks(struct i2c_client *client, int page,
			       enum chips id)
{
	int ret;

	if (id == ltc3880 || id == ltc3883)
		ret = pmbus_write_byte(client, 0, LTC3880_MFR_CLEAR_PEAKS);
	else
		ret = pmbus_write_byte(client, page, PMBUS_CLEAR_FAULTS);

	return ret;
}

static int ltc2978_write_word_data(struct i2c_client *client, int page,
				    int reg, u16 word)
{
	const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
	struct ltc2978_data *data = to_ltc2978_data(info);
	int ret;

	switch (reg) {
	case PMBUS_VIRT_RESET_IIN_HISTORY:
		data->iin_max = 0x7c00;
		ret = ltc2978_clear_peaks(client, page, data->id);
		break;
	case PMBUS_VIRT_RESET_IOUT_HISTORY:
		data->iout_max[page] = 0x7c00;
		data->iout_min[page] = 0xfbff;
		ret = ltc2978_clear_peaks(client, page, data->id);
		break;
	case PMBUS_VIRT_RESET_TEMP2_HISTORY:
		data->temp2_max = 0x7c00;
		ret = ltc2978_clear_peaks(client, page, data->id);
		break;
	case PMBUS_VIRT_RESET_VOUT_HISTORY:
		data->vout_min[page] = 0xffff;
		data->vout_max[page] = 0;
		ret = ltc2978_clear_peaks(client, page, data->id);
		break;
	case PMBUS_VIRT_RESET_VIN_HISTORY:
		data->vin_min = 0x7bff;
		data->vin_max = 0x7c00;
		ret = ltc2978_clear_peaks(client, page, data->id);
		break;
	case PMBUS_VIRT_RESET_TEMP_HISTORY:
		data->temp_min[page] = 0x7bff;
		data->temp_max[page] = 0x7c00;
		ret = ltc2978_clear_peaks(client, page, data->id);
		break;
	default:
		ret = -ENODATA;
		break;
	}
	return ret;
}

static const struct i2c_device_id ltc2978_id[] = {
	{"ltc2974", ltc2974},
	{"ltc2977", ltc2977},
	{"ltc2978", ltc2978},
	{"ltc3880", ltc3880},
	{"ltc3883", ltc3883},
	{"ltm4676", ltm4676},
	{}
};
MODULE_DEVICE_TABLE(i2c, ltc2978_id);

#if IS_ENABLED(CONFIG_SENSORS_LTC2978_REGULATOR)
static const struct regulator_desc ltc2978_reg_desc[] = {
	PMBUS_REGULATOR("vout", 0),
	PMBUS_REGULATOR("vout", 1),
	PMBUS_REGULATOR("vout", 2),
	PMBUS_REGULATOR("vout", 3),
	PMBUS_REGULATOR("vout", 4),
	PMBUS_REGULATOR("vout", 5),
	PMBUS_REGULATOR("vout", 6),
	PMBUS_REGULATOR("vout", 7),
};
#endif /* CONFIG_SENSORS_LTC2978_REGULATOR */

static int ltc2978_probe(struct i2c_client *client,
			 const struct i2c_device_id *id)
{
	int chip_id, i;
	struct ltc2978_data *data;
	struct pmbus_driver_info *info;

	if (!i2c_check_functionality(client->adapter,
				     I2C_FUNC_SMBUS_READ_WORD_DATA))
		return -ENODEV;

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

	chip_id = i2c_smbus_read_word_data(client, LTC2978_MFR_SPECIAL_ID);
	if (chip_id < 0)
		return chip_id;

	if (chip_id == LTC2974_ID_REV1 || chip_id == LTC2974_ID_REV2) {
		data->id = ltc2974;
	} else if (chip_id == LTC2977_ID) {
		data->id = ltc2977;
	} else if (chip_id == LTC2978_ID_REV1 || chip_id == LTC2978_ID_REV2 ||
		   chip_id == LTC2978A_ID) {
		data->id = ltc2978;
	} else if ((chip_id & LTC3880_ID_MASK) == LTC3880_ID) {
		data->id = ltc3880;
	} else if ((chip_id & LTC3883_ID_MASK) == LTC3883_ID) {
		data->id = ltc3883;
	} else if ((chip_id & LTM4676_ID_MASK) == LTM4676_ID) {
		data->id = ltm4676;
	} else {
		dev_err(&client->dev, "Unsupported chip ID 0x%x\n", chip_id);
		return -ENODEV;
	}
	if (data->id != id->driver_data)
		dev_warn(&client->dev,
			 "Device mismatch: Configured %s, detected %s\n",
			 id->name,
			 ltc2978_id[data->id].name);

	info = &data->info;
	info->write_word_data = ltc2978_write_word_data;

	data->vin_min = 0x7bff;
	data->vin_max = 0x7c00;
	for (i = 0; i < ARRAY_SIZE(data->vout_min); i++)
		data->vout_min[i] = 0xffff;
	for (i = 0; i < ARRAY_SIZE(data->iout_min); i++)
		data->iout_min[i] = 0xfbff;
	for (i = 0; i < ARRAY_SIZE(data->iout_max); i++)
		data->iout_max[i] = 0x7c00;
	for (i = 0; i < ARRAY_SIZE(data->temp_min); i++)
		data->temp_min[i] = 0x7bff;
	for (i = 0; i < ARRAY_SIZE(data->temp_max); i++)
		data->temp_max[i] = 0x7c00;
	data->temp2_max = 0x7c00;

	switch (data->id) {
	case ltc2974:
		info->read_word_data = ltc2974_read_word_data;
		info->pages = LTC2974_NUM_PAGES;
		info->func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_STATUS_INPUT
		  | PMBUS_HAVE_TEMP2;
		for (i = 0; i < info->pages; i++) {
			info->func[i] |= PMBUS_HAVE_VOUT
			  | PMBUS_HAVE_STATUS_VOUT | PMBUS_HAVE_POUT
			  | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP
			  | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT;
		}
		break;
	case ltc2977:
	case ltc2978:
		info->read_word_data = ltc2978_read_word_data;
		info->pages = LTC2978_NUM_PAGES;
		info->func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_STATUS_INPUT
		  | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT
		  | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP;
		for (i = 1; i < LTC2978_NUM_PAGES; i++) {
			info->func[i] = PMBUS_HAVE_VOUT
			  | PMBUS_HAVE_STATUS_VOUT;
		}
		break;
	case ltc3880:
	case ltm4676:
		info->read_word_data = ltc3880_read_word_data;
		info->pages = LTC3880_NUM_PAGES;
		info->func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_IIN
		  | PMBUS_HAVE_STATUS_INPUT
		  | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT
		  | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT
		  | PMBUS_HAVE_POUT | PMBUS_HAVE_TEMP
		  | PMBUS_HAVE_TEMP2 | PMBUS_HAVE_STATUS_TEMP;
		info->func[1] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT
		  | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT
		  | PMBUS_HAVE_POUT
		  | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP;
		break;
	case ltc3883:
		info->read_word_data = ltc3883_read_word_data;
		info->pages = LTC3883_NUM_PAGES;
		info->func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_IIN
		  | PMBUS_HAVE_STATUS_INPUT
		  | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT
		  | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT
		  | PMBUS_HAVE_PIN | PMBUS_HAVE_POUT | PMBUS_HAVE_TEMP
		  | PMBUS_HAVE_TEMP2 | PMBUS_HAVE_STATUS_TEMP;
		break;
	default:
		return -ENODEV;
	}

#if IS_ENABLED(CONFIG_SENSORS_LTC2978_REGULATOR)
	info->num_regulators = info->pages;
	info->reg_desc = ltc2978_reg_desc;
	if (info->num_regulators > ARRAY_SIZE(ltc2978_reg_desc)) {
		dev_err(&client->dev, "num_regulators too large!");
		info->num_regulators = ARRAY_SIZE(ltc2978_reg_desc);
	}
#endif

	return pmbus_do_probe(client, id, info);
}

#ifdef CONFIG_OF
static const struct of_device_id ltc2978_of_match[] = {
	{ .compatible = "lltc,ltc2974" },
	{ .compatible = "lltc,ltc2977" },
	{ .compatible = "lltc,ltc2978" },
	{ .compatible = "lltc,ltc3880" },
	{ .compatible = "lltc,ltc3883" },
	{ .compatible = "lltc,ltm4676" },
	{ }
};
MODULE_DEVICE_TABLE(of, ltc2978_of_match);
#endif

static struct i2c_driver ltc2978_driver = {
	.driver = {
		   .name = "ltc2978",
		   .of_match_table = of_match_ptr(ltc2978_of_match),
		   },
	.probe = ltc2978_probe,
	.remove = pmbus_do_remove,
	.id_table = ltc2978_id,
};

module_i2c_driver(ltc2978_driver);

MODULE_AUTHOR("Guenter Roeck");
MODULE_DESCRIPTION("PMBus driver for LTC2974, LTC2978, LTC3880, LTC3883, and LTM4676");
MODULE_LICENSE("GPL");
Commit	Line	Data
c3ff9a67	1	/*
c24c407e	2	* Hardware monitoring driver for LTC2974, LTC2977, LTC2978, LTC3880,
f76992b0	3	* LTC3883, and LTM4676
c3ff9a67 GR	4	*
c3ff9a67 GR	5	* Copyright (c) 2011 Ericsson AB.
f76992b0	6	* Copyright (c) 2013, 2014 Guenter Roeck
c3ff9a67 GR	7	*
	8	* This program is free software; you can redistribute it and/or modify
	9	* it under the terms of the GNU General Public License as published by
	10	* the Free Software Foundation; either version 2 of the License, or
	11	* (at your option) any later version.
	12	*
	13	* This program is distributed in the hope that it will be useful,
	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	* GNU General Public License for more details.
c3ff9a67 GR	17	*/
	18
	19	#include <linux/kernel.h>
	20	#include <linux/module.h>
	21	#include <linux/init.h>
	22	#include <linux/err.h>
	23	#include <linux/slab.h>
	24	#include <linux/i2c.h>
77aa3585	25	#include <linux/regulator/driver.h>
c3ff9a67 GR	26	#include "pmbus.h"
c3ff9a67 GR	27
f76992b0	28	enum chips { ltc2974, ltc2977, ltc2978, ltc3880, ltc3883, ltm4676 };
c3ff9a67	29
fd9175d2	30	/* Common for all chips */
c3ff9a67 GR	31	#define LTC2978_MFR_VOUT_PEAK 0xdd
	32	#define LTC2978_MFR_VIN_PEAK 0xde
	33	#define LTC2978_MFR_TEMPERATURE_PEAK 0xdf
	34	#define LTC2978_MFR_SPECIAL_ID 0xe7
	35
c24c407e	36	/* LTC2974, LCT2977, and LTC2978 */
c3ff9a67 GR	37	#define LTC2978_MFR_VOUT_MIN 0xfb
	38	#define LTC2978_MFR_VIN_MIN 0xfc
	39	#define LTC2978_MFR_TEMPERATURE_MIN 0xfd
	40
fd9175d2 GR	41	/* LTC2974 only */
	42	#define LTC2974_MFR_IOUT_PEAK 0xd7
	43	#define LTC2974_MFR_IOUT_MIN 0xd8
	44
f76992b0	45	/* LTC3880, LTC3883, and LTM4676 */
ddfb41ca GR	46	#define LTC3880_MFR_IOUT_PEAK 0xd7
	47	#define LTC3880_MFR_CLEAR_PEAKS 0xe3
	48	#define LTC3880_MFR_TEMPERATURE2_PEAK 0xf4
	49
fd9175d2 GR	50	/* LTC3883 only */
	51	#define LTC3883_MFR_IIN_PEAK 0xe1
	52
a2e15107 GR	53	#define LTC2974_ID_REV1 0x0212
a2e15107 GR	54	#define LTC2974_ID_REV2 0x0213
c24c407e	55	#define LTC2977_ID 0x0130
c3ff9a67 GR	56	#define LTC2978_ID_REV1 0x0121
c3ff9a67 GR	57	#define LTC2978_ID_REV2 0x0122
3f08d7f4	58	#define LTC2978A_ID 0x0124
ddfb41ca GR	59	#define LTC3880_ID 0x4000
ddfb41ca GR	60	#define LTC3880_ID_MASK 0xff00
fd9175d2 GR	61	#define LTC3883_ID 0x4300
fd9175d2 GR	62	#define LTC3883_ID_MASK 0xff00
f76992b0 GR	63	#define LTM4676_ID 0x4480 /* datasheet claims 0x440X */
f76992b0 GR	64	#define LTM4676_ID_MASK 0xfff0
c3ff9a67	65
fd9175d2	66	#define LTC2974_NUM_PAGES 4
3d0d2839 GR	67	#define LTC2978_NUM_PAGES 8
3d0d2839 GR	68	#define LTC3880_NUM_PAGES 2
fd9175d2	69	#define LTC3883_NUM_PAGES 1
3d0d2839	70
c3ff9a67 GR	71	/*
	72	* LTC2978 clears peak data whenever the CLEAR_FAULTS command is executed, which
	73	* happens pretty much each time chip data is updated. Raw peak data therefore
	74	* does not provide much value. To be able to provide useful peak data, keep an
	75	* internal cache of measured peak data, which is only cleared if an explicit
	76	* "clear peak" command is executed for the sensor in question.
	77	*/
3d0d2839	78
c3ff9a67 GR	79	struct ltc2978_data {
c3ff9a67 GR	80	enum chips id;
3d0d2839	81	u16 vin_min, vin_max;
fd9175d2	82	u16 temp_min[LTC2974_NUM_PAGES], temp_max[LTC2974_NUM_PAGES];
3d0d2839	83	u16 vout_min[LTC2978_NUM_PAGES], vout_max[LTC2978_NUM_PAGES];
fd9175d2 GR	84	u16 iout_min[LTC2974_NUM_PAGES], iout_max[LTC2974_NUM_PAGES];
fd9175d2 GR	85	u16 iin_max;
3d0d2839	86	u16 temp2_max;
c3ff9a67 GR	87	struct pmbus_driver_info info;
	88	};
	89
	90	#define to_ltc2978_data(x) container_of(x, struct ltc2978_data, info)
	91
	92	static inline int lin11_to_val(int data)
	93	{
	94	s16 e = ((s16)data) >> 11;
	95	s32 m = (((s16)(data << 5)) >> 5);
	96
	97	/*
	98	* mantissa is 10 bit + sign, exponent adds up to 15 bit.
	99	* Add 6 bit to exponent for maximum accuracy (10 + 15 + 6 = 31).
	100	*/
	101	e += 6;
	102	return (e < 0 ? m >> -e : m << e);
	103	}
	104
ddfb41ca GR	105	static int ltc2978_read_word_data_common(struct i2c_client *client, int page,
ddfb41ca GR	106	int reg)
c3ff9a67 GR	107	{
	108	const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
	109	struct ltc2978_data *data = to_ltc2978_data(info);
	110	int ret;
	111
	112	switch (reg) {
	113	case PMBUS_VIRT_READ_VIN_MAX:
	114	ret = pmbus_read_word_data(client, page, LTC2978_MFR_VIN_PEAK);
	115	if (ret >= 0) {
	116	if (lin11_to_val(ret) > lin11_to_val(data->vin_max))
	117	data->vin_max = ret;
	118	ret = data->vin_max;
	119	}
	120	break;
	121	case PMBUS_VIRT_READ_VOUT_MAX:
	122	ret = pmbus_read_word_data(client, page, LTC2978_MFR_VOUT_PEAK);
	123	if (ret >= 0) {
	124	/*
	125	* VOUT is 16 bit unsigned with fixed exponent,
	126	* so we can compare it directly
	127	*/
	128	if (ret > data->vout_max[page])
	129	data->vout_max[page] = ret;
	130	ret = data->vout_max[page];
	131	}
	132	break;
	133	case PMBUS_VIRT_READ_TEMP_MAX:
	134	ret = pmbus_read_word_data(client, page,
	135	LTC2978_MFR_TEMPERATURE_PEAK);
	136	if (ret >= 0) {
8c958c70 GR	137	if (lin11_to_val(ret)
	138	> lin11_to_val(data->temp_max[page]))
	139	data->temp_max[page] = ret;
	140	ret = data->temp_max[page];
c3ff9a67 GR	141	}
c3ff9a67 GR	142	break;
ddfb41ca GR	143	case PMBUS_VIRT_RESET_VOUT_HISTORY:
	144	case PMBUS_VIRT_RESET_VIN_HISTORY:
	145	case PMBUS_VIRT_RESET_TEMP_HISTORY:
	146	ret = 0;
	147	break;
	148	default:
	149	ret = -ENODATA;
	150	break;
	151	}
	152	return ret;
	153	}
	154
	155	static int ltc2978_read_word_data(struct i2c_client *client, int page, int reg)
	156	{
	157	const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
	158	struct ltc2978_data *data = to_ltc2978_data(info);
	159	int ret;
	160
	161	switch (reg) {
c3ff9a67 GR	162	case PMBUS_VIRT_READ_VIN_MIN:
	163	ret = pmbus_read_word_data(client, page, LTC2978_MFR_VIN_MIN);
	164	if (ret >= 0) {
	165	if (lin11_to_val(ret) < lin11_to_val(data->vin_min))
	166	data->vin_min = ret;
	167	ret = data->vin_min;
	168	}
	169	break;
	170	case PMBUS_VIRT_READ_VOUT_MIN:
	171	ret = pmbus_read_word_data(client, page, LTC2978_MFR_VOUT_MIN);
	172	if (ret >= 0) {
	173	/*
	174	* VOUT_MIN is known to not be supported on some lots
	175	* of LTC2978 revision 1, and will return the maximum
	176	* possible voltage if read. If VOUT_MAX is valid and
	177	* lower than the reading of VOUT_MIN, use it instead.
	178	*/
	179	if (data->vout_max[page] && ret > data->vout_max[page])
	180	ret = data->vout_max[page];
	181	if (ret < data->vout_min[page])
	182	data->vout_min[page] = ret;
	183	ret = data->vout_min[page];
	184	}
	185	break;
	186	case PMBUS_VIRT_READ_TEMP_MIN:
	187	ret = pmbus_read_word_data(client, page,
	188	LTC2978_MFR_TEMPERATURE_MIN);
	189	if (ret >= 0) {
	190	if (lin11_to_val(ret)
fd9175d2 GR	191	< lin11_to_val(data->temp_min[page]))
	192	data->temp_min[page] = ret;
	193	ret = data->temp_min[page];
c3ff9a67 GR	194	}
c3ff9a67 GR	195	break;
ddfb41ca GR	196	case PMBUS_VIRT_READ_IOUT_MAX:
	197	case PMBUS_VIRT_RESET_IOUT_HISTORY:
	198	case PMBUS_VIRT_READ_TEMP2_MAX:
	199	case PMBUS_VIRT_RESET_TEMP2_HISTORY:
	200	ret = -ENXIO;
	201	break;
	202	default:
	203	ret = ltc2978_read_word_data_common(client, page, reg);
	204	break;
	205	}
	206	return ret;
	207	}
	208
fd9175d2 GR	209	static int ltc2974_read_word_data(struct i2c_client *client, int page, int reg)
	210	{
	211	const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
	212	struct ltc2978_data *data = to_ltc2978_data(info);
	213	int ret;
	214
	215	switch (reg) {
	216	case PMBUS_VIRT_READ_IOUT_MAX:
	217	ret = pmbus_read_word_data(client, page, LTC2974_MFR_IOUT_PEAK);
	218	if (ret >= 0) {
	219	if (lin11_to_val(ret)
	220	> lin11_to_val(data->iout_max[page]))
	221	data->iout_max[page] = ret;
	222	ret = data->iout_max[page];
	223	}
	224	break;
	225	case PMBUS_VIRT_READ_IOUT_MIN:
	226	ret = pmbus_read_word_data(client, page, LTC2974_MFR_IOUT_MIN);
	227	if (ret >= 0) {
	228	if (lin11_to_val(ret)
	229	< lin11_to_val(data->iout_min[page]))
	230	data->iout_min[page] = ret;
	231	ret = data->iout_min[page];
	232	}
	233	break;
	234	case PMBUS_VIRT_RESET_IOUT_HISTORY:
	235	ret = 0;
	236	break;
	237	default:
	238	ret = ltc2978_read_word_data(client, page, reg);
	239	break;
	240	}
	241	return ret;
	242	}
	243
ddfb41ca GR	244	static int ltc3880_read_word_data(struct i2c_client *client, int page, int reg)
	245	{
	246	const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
	247	struct ltc2978_data *data = to_ltc2978_data(info);
	248	int ret;
	249
	250	switch (reg) {
	251	case PMBUS_VIRT_READ_IOUT_MAX:
	252	ret = pmbus_read_word_data(client, page, LTC3880_MFR_IOUT_PEAK);
	253	if (ret >= 0) {
	254	if (lin11_to_val(ret)
	255	> lin11_to_val(data->iout_max[page]))
	256	data->iout_max[page] = ret;
	257	ret = data->iout_max[page];
	258	}
	259	break;
	260	case PMBUS_VIRT_READ_TEMP2_MAX:
	261	ret = pmbus_read_word_data(client, page,
	262	LTC3880_MFR_TEMPERATURE2_PEAK);
	263	if (ret >= 0) {
dbd712c2 GR	264	if (lin11_to_val(ret) > lin11_to_val(data->temp2_max))
	265	data->temp2_max = ret;
	266	ret = data->temp2_max;
ddfb41ca GR	267	}
	268	break;
	269	case PMBUS_VIRT_READ_VIN_MIN:
	270	case PMBUS_VIRT_READ_VOUT_MIN:
	271	case PMBUS_VIRT_READ_TEMP_MIN:
	272	ret = -ENXIO;
	273	break;
	274	case PMBUS_VIRT_RESET_IOUT_HISTORY:
	275	case PMBUS_VIRT_RESET_TEMP2_HISTORY:
c3ff9a67 GR	276	ret = 0;
	277	break;
	278	default:
ddfb41ca	279	ret = ltc2978_read_word_data_common(client, page, reg);
c3ff9a67 GR	280	break;
	281	}
	282	return ret;
	283	}
	284
fd9175d2 GR	285	static int ltc3883_read_word_data(struct i2c_client *client, int page, int reg)
	286	{
	287	const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
	288	struct ltc2978_data *data = to_ltc2978_data(info);
	289	int ret;
	290
	291	switch (reg) {
	292	case PMBUS_VIRT_READ_IIN_MAX:
	293	ret = pmbus_read_word_data(client, page, LTC3883_MFR_IIN_PEAK);
	294	if (ret >= 0) {
	295	if (lin11_to_val(ret)
	296	> lin11_to_val(data->iin_max))
	297	data->iin_max = ret;
	298	ret = data->iin_max;
	299	}
	300	break;
	301	case PMBUS_VIRT_RESET_IIN_HISTORY:
	302	ret = 0;
	303	break;
	304	default:
	305	ret = ltc3880_read_word_data(client, page, reg);
	306	break;
	307	}
	308	return ret;
	309	}
	310
ddfb41ca GR	311	static int ltc2978_clear_peaks(struct i2c_client *client, int page,
	312	enum chips id)
	313	{
	314	int ret;
	315
fd9175d2	316	if (id == ltc3880 \|\| id == ltc3883)
ddfb41ca	317	ret = pmbus_write_byte(client, 0, LTC3880_MFR_CLEAR_PEAKS);
fd9175d2 GR	318	else
fd9175d2 GR	319	ret = pmbus_write_byte(client, page, PMBUS_CLEAR_FAULTS);
ddfb41ca GR	320
	321	return ret;
	322	}
	323
c3ff9a67 GR	324	static int ltc2978_write_word_data(struct i2c_client *client, int page,
	325	int reg, u16 word)
	326	{
	327	const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
	328	struct ltc2978_data *data = to_ltc2978_data(info);
	329	int ret;
	330
	331	switch (reg) {
fd9175d2 GR	332	case PMBUS_VIRT_RESET_IIN_HISTORY:
	333	data->iin_max = 0x7c00;
	334	ret = ltc2978_clear_peaks(client, page, data->id);
	335	break;
ddfb41ca	336	case PMBUS_VIRT_RESET_IOUT_HISTORY:
dbd712c2	337	data->iout_max[page] = 0x7c00;
fd9175d2	338	data->iout_min[page] = 0xfbff;
ddfb41ca GR	339	ret = ltc2978_clear_peaks(client, page, data->id);
	340	break;
	341	case PMBUS_VIRT_RESET_TEMP2_HISTORY:
dbd712c2	342	data->temp2_max = 0x7c00;
ddfb41ca GR	343	ret = ltc2978_clear_peaks(client, page, data->id);
ddfb41ca GR	344	break;
c3ff9a67 GR	345	case PMBUS_VIRT_RESET_VOUT_HISTORY:
	346	data->vout_min[page] = 0xffff;
	347	data->vout_max[page] = 0;
ddfb41ca	348	ret = ltc2978_clear_peaks(client, page, data->id);
c3ff9a67 GR	349	break;
	350	case PMBUS_VIRT_RESET_VIN_HISTORY:
	351	data->vin_min = 0x7bff;
dbd712c2	352	data->vin_max = 0x7c00;
ddfb41ca	353	ret = ltc2978_clear_peaks(client, page, data->id);
c3ff9a67 GR	354	break;
c3ff9a67 GR	355	case PMBUS_VIRT_RESET_TEMP_HISTORY:
fd9175d2	356	data->temp_min[page] = 0x7bff;
8c958c70	357	data->temp_max[page] = 0x7c00;
ddfb41ca	358	ret = ltc2978_clear_peaks(client, page, data->id);
c3ff9a67 GR	359	break;
	360	default:
	361	ret = -ENODATA;
	362	break;
	363	}
	364	return ret;
	365	}
	366
	367	static const struct i2c_device_id ltc2978_id[] = {
fd9175d2	368	{"ltc2974", ltc2974},
c24c407e	369	{"ltc2977", ltc2977},
c3ff9a67	370	{"ltc2978", ltc2978},
ddfb41ca	371	{"ltc3880", ltc3880},
fd9175d2	372	{"ltc3883", ltc3883},
f76992b0	373	{"ltm4676", ltm4676},
c3ff9a67 GR	374	{}
	375	};
	376	MODULE_DEVICE_TABLE(i2c, ltc2978_id);
	377
77aa3585 AT	378	#if IS_ENABLED(CONFIG_SENSORS_LTC2978_REGULATOR)
	379	static const struct regulator_desc ltc2978_reg_desc[] = {
	380	PMBUS_REGULATOR("vout", 0),
	381	PMBUS_REGULATOR("vout", 1),
	382	PMBUS_REGULATOR("vout", 2),
	383	PMBUS_REGULATOR("vout", 3),
	384	PMBUS_REGULATOR("vout", 4),
	385	PMBUS_REGULATOR("vout", 5),
	386	PMBUS_REGULATOR("vout", 6),
	387	PMBUS_REGULATOR("vout", 7),
	388	};
	389	#endif /* CONFIG_SENSORS_LTC2978_REGULATOR */
	390
c3ff9a67 GR	391	static int ltc2978_probe(struct i2c_client *client,
	392	const struct i2c_device_id *id)
	393	{
8b313ca7	394	int chip_id, i;
c3ff9a67 GR	395	struct ltc2978_data *data;
	396	struct pmbus_driver_info *info;
	397
	398	if (!i2c_check_functionality(client->adapter,
	399	I2C_FUNC_SMBUS_READ_WORD_DATA))
	400	return -ENODEV;
	401
8b313ca7 GR	402	data = devm_kzalloc(&client->dev, sizeof(struct ltc2978_data),
8b313ca7 GR	403	GFP_KERNEL);
c3ff9a67 GR	404	if (!data)
	405	return -ENOMEM;
	406
	407	chip_id = i2c_smbus_read_word_data(client, LTC2978_MFR_SPECIAL_ID);
8b313ca7 GR	408	if (chip_id < 0)
8b313ca7 GR	409	return chip_id;
c3ff9a67	410
a2e15107	411	if (chip_id == LTC2974_ID_REV1 \|\| chip_id == LTC2974_ID_REV2) {
fd9175d2	412	data->id = ltc2974;
c24c407e GR	413	} else if (chip_id == LTC2977_ID) {
c24c407e GR	414	data->id = ltc2977;
3f08d7f4 GR	415	} else if (chip_id == LTC2978_ID_REV1 \|\| chip_id == LTC2978_ID_REV2 \|\|
3f08d7f4 GR	416	chip_id == LTC2978A_ID) {
c3ff9a67	417	data->id = ltc2978;
ddfb41ca GR	418	} else if ((chip_id & LTC3880_ID_MASK) == LTC3880_ID) {
ddfb41ca GR	419	data->id = ltc3880;
fd9175d2 GR	420	} else if ((chip_id & LTC3883_ID_MASK) == LTC3883_ID) {
fd9175d2 GR	421	data->id = ltc3883;
f76992b0 GR	422	} else if ((chip_id & LTM4676_ID_MASK) == LTM4676_ID) {
f76992b0 GR	423	data->id = ltm4676;
c3ff9a67 GR	424	} else {
c3ff9a67 GR	425	dev_err(&client->dev, "Unsupported chip ID 0x%x\n", chip_id);
8b313ca7	426	return -ENODEV;
c3ff9a67 GR	427	}
	428	if (data->id != id->driver_data)
	429	dev_warn(&client->dev,
	430	"Device mismatch: Configured %s, detected %s\n",
	431	id->name,
	432	ltc2978_id[data->id].name);
	433
	434	info = &data->info;
c3ff9a67 GR	435	info->write_word_data = ltc2978_write_word_data;
c3ff9a67 GR	436
c3ff9a67	437	data->vin_min = 0x7bff;
dbd712c2	438	data->vin_max = 0x7c00;
3d0d2839 GR	439	for (i = 0; i < ARRAY_SIZE(data->vout_min); i++)
3d0d2839 GR	440	data->vout_min[i] = 0xffff;
fd9175d2 GR	441	for (i = 0; i < ARRAY_SIZE(data->iout_min); i++)
	442	data->iout_min[i] = 0xfbff;
	443	for (i = 0; i < ARRAY_SIZE(data->iout_max); i++)
	444	data->iout_max[i] = 0x7c00;
	445	for (i = 0; i < ARRAY_SIZE(data->temp_min); i++)
	446	data->temp_min[i] = 0x7bff;
8c958c70 GR	447	for (i = 0; i < ARRAY_SIZE(data->temp_max); i++)
8c958c70 GR	448	data->temp_max[i] = 0x7c00;
dbd712c2	449	data->temp2_max = 0x7c00;
c3ff9a67	450
f366fccd	451	switch (data->id) {
fd9175d2 GR	452	case ltc2974:
	453	info->read_word_data = ltc2974_read_word_data;
	454	info->pages = LTC2974_NUM_PAGES;
	455	info->func[0] = PMBUS_HAVE_VIN \| PMBUS_HAVE_STATUS_INPUT
	456	\| PMBUS_HAVE_TEMP2;
	457	for (i = 0; i < info->pages; i++) {
	458	info->func[i] \|= PMBUS_HAVE_VOUT
	459	\| PMBUS_HAVE_STATUS_VOUT \| PMBUS_HAVE_POUT
	460	\| PMBUS_HAVE_TEMP \| PMBUS_HAVE_STATUS_TEMP
	461	\| PMBUS_HAVE_IOUT \| PMBUS_HAVE_STATUS_IOUT;
	462	}
	463	break;
c24c407e	464	case ltc2977:
c3ff9a67	465	case ltc2978:
ddfb41ca	466	info->read_word_data = ltc2978_read_word_data;
3d0d2839	467	info->pages = LTC2978_NUM_PAGES;
c3ff9a67 GR	468	info->func[0] = PMBUS_HAVE_VIN \| PMBUS_HAVE_STATUS_INPUT
	469	\| PMBUS_HAVE_VOUT \| PMBUS_HAVE_STATUS_VOUT
	470	\| PMBUS_HAVE_TEMP \| PMBUS_HAVE_STATUS_TEMP;
3d0d2839	471	for (i = 1; i < LTC2978_NUM_PAGES; i++) {
c3ff9a67 GR	472	info->func[i] = PMBUS_HAVE_VOUT
c3ff9a67 GR	473	\| PMBUS_HAVE_STATUS_VOUT;
c3ff9a67 GR	474	}
c3ff9a67 GR	475	break;
ddfb41ca	476	case ltc3880:
f76992b0	477	case ltm4676:
ddfb41ca	478	info->read_word_data = ltc3880_read_word_data;
3d0d2839	479	info->pages = LTC3880_NUM_PAGES;
ddfb41ca GR	480	info->func[0] = PMBUS_HAVE_VIN \| PMBUS_HAVE_IIN
	481	\| PMBUS_HAVE_STATUS_INPUT
	482	\| PMBUS_HAVE_VOUT \| PMBUS_HAVE_STATUS_VOUT
	483	\| PMBUS_HAVE_IOUT \| PMBUS_HAVE_STATUS_IOUT
	484	\| PMBUS_HAVE_POUT \| PMBUS_HAVE_TEMP
	485	\| PMBUS_HAVE_TEMP2 \| PMBUS_HAVE_STATUS_TEMP;
	486	info->func[1] = PMBUS_HAVE_VOUT \| PMBUS_HAVE_STATUS_VOUT
	487	\| PMBUS_HAVE_IOUT \| PMBUS_HAVE_STATUS_IOUT
	488	\| PMBUS_HAVE_POUT
	489	\| PMBUS_HAVE_TEMP \| PMBUS_HAVE_STATUS_TEMP;
fd9175d2 GR	490	break;
	491	case ltc3883:
	492	info->read_word_data = ltc3883_read_word_data;
	493	info->pages = LTC3883_NUM_PAGES;
	494	info->func[0] = PMBUS_HAVE_VIN \| PMBUS_HAVE_IIN
	495	\| PMBUS_HAVE_STATUS_INPUT
	496	\| PMBUS_HAVE_VOUT \| PMBUS_HAVE_STATUS_VOUT
	497	\| PMBUS_HAVE_IOUT \| PMBUS_HAVE_STATUS_IOUT
	498	\| PMBUS_HAVE_PIN \| PMBUS_HAVE_POUT \| PMBUS_HAVE_TEMP
	499	\| PMBUS_HAVE_TEMP2 \| PMBUS_HAVE_STATUS_TEMP;
ddfb41ca	500	break;
c3ff9a67	501	default:
8b313ca7	502	return -ENODEV;
c3ff9a67	503	}
77aa3585 AT	504
	505	#if IS_ENABLED(CONFIG_SENSORS_LTC2978_REGULATOR)
	506	info->num_regulators = info->pages;
	507	info->reg_desc = ltc2978_reg_desc;
	508	if (info->num_regulators > ARRAY_SIZE(ltc2978_reg_desc)) {
	509	dev_err(&client->dev, "num_regulators too large!");
	510	info->num_regulators = ARRAY_SIZE(ltc2978_reg_desc);
	511	}
	512	#endif
	513
8b313ca7	514	return pmbus_do_probe(client, id, info);
c3ff9a67 GR	515	}
c3ff9a67 GR	516
77aa3585 AT	517	#ifdef CONFIG_OF
	518	static const struct of_device_id ltc2978_of_match[] = {
	519	{ .compatible = "lltc,ltc2974" },
	520	{ .compatible = "lltc,ltc2977" },
	521	{ .compatible = "lltc,ltc2978" },
	522	{ .compatible = "lltc,ltc3880" },
	523	{ .compatible = "lltc,ltc3883" },
	524	{ .compatible = "lltc,ltm4676" },
	525	{ }
	526	};
	527	MODULE_DEVICE_TABLE(of, ltc2978_of_match);
	528	#endif
	529
c3ff9a67 GR	530	static struct i2c_driver ltc2978_driver = {
	531	.driver = {
	532	.name = "ltc2978",
77aa3585	533	.of_match_table = of_match_ptr(ltc2978_of_match),
c3ff9a67 GR	534	},
c3ff9a67 GR	535	.probe = ltc2978_probe,
dd285ad7	536	.remove = pmbus_do_remove,
c3ff9a67 GR	537	.id_table = ltc2978_id,
	538	};
	539
f0967eea	540	module_i2c_driver(ltc2978_driver);
c3ff9a67 GR	541
c3ff9a67 GR	542	MODULE_AUTHOR("Guenter Roeck");
f76992b0	543	MODULE_DESCRIPTION("PMBus driver for LTC2974, LTC2978, LTC3880, LTC3883, and LTM4676");
c3ff9a67	544	MODULE_LICENSE("GPL");