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

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Copyright (C) 2017 IBM Corp.
 */

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

enum max31785_regs {
	MFR_REVISION		= 0x9b,
	MFR_FAN_CONFIG		= 0xf1,
};

#define MAX31785			0x3030
#define MAX31785A			0x3040
#define MAX31785B			0x3061

#define MFR_FAN_CONFIG_DUAL_TACH	BIT(12)

#define MAX31785_NR_PAGES		23
#define MAX31785_NR_FAN_PAGES		6

static int max31785_read_byte_data(struct i2c_client *client, int page,
				   int reg)
{
	if (page < MAX31785_NR_PAGES)
		return -ENODATA;

	switch (reg) {
	case PMBUS_VOUT_MODE:
		return -ENOTSUPP;
	case PMBUS_FAN_CONFIG_12:
		return pmbus_read_byte_data(client, page - MAX31785_NR_PAGES,
					    reg);
	}

	return -ENODATA;
}

static int max31785_write_byte(struct i2c_client *client, int page, u8 value)
{
	if (page < MAX31785_NR_PAGES)
		return -ENODATA;

	return -ENOTSUPP;
}

static int max31785_read_long_data(struct i2c_client *client, int page,
				   int reg, u32 *data)
{
	unsigned char cmdbuf[1];
	unsigned char rspbuf[4];
	int rc;

	struct i2c_msg msg[2] = {
		{
			.addr = client->addr,
			.flags = 0,
			.len = sizeof(cmdbuf),
			.buf = cmdbuf,
		},
		{
			.addr = client->addr,
			.flags = I2C_M_RD,
			.len = sizeof(rspbuf),
			.buf = rspbuf,
		},
	};

	cmdbuf[0] = reg;

	rc = pmbus_set_page(client, page, 0xff);
	if (rc < 0)
		return rc;

	rc = i2c_transfer(client->adapter, msg, ARRAY_SIZE(msg));
	if (rc < 0)
		return rc;

	*data = (rspbuf[0] << (0 * 8)) | (rspbuf[1] << (1 * 8)) |
		(rspbuf[2] << (2 * 8)) | (rspbuf[3] << (3 * 8));

	return rc;
}

static int max31785_get_pwm(struct i2c_client *client, int page)
{
	int rv;

	rv = pmbus_get_fan_rate_device(client, page, 0, percent);
	if (rv < 0)
		return rv;
	else if (rv >= 0x8000)
		return 0;
	else if (rv >= 0x2711)
		return 0x2710;

	return rv;
}

static int max31785_get_pwm_mode(struct i2c_client *client, int page)
{
	int config;
	int command;

	config = pmbus_read_byte_data(client, page, PMBUS_FAN_CONFIG_12);
	if (config < 0)
		return config;

	command = pmbus_read_word_data(client, page, 0xff, PMBUS_FAN_COMMAND_1);
	if (command < 0)
		return command;

	if (config & PB_FAN_1_RPM)
		return (command >= 0x8000) ? 3 : 2;

	if (command >= 0x8000)
		return 3;
	else if (command >= 0x2711)
		return 0;

	return 1;
}

static int max31785_read_word_data(struct i2c_client *client, int page,
				   int phase, int reg)
{
	u32 val;
	int rv;

	switch (reg) {
	case PMBUS_READ_FAN_SPEED_1:
		if (page < MAX31785_NR_PAGES)
			return -ENODATA;

		rv = max31785_read_long_data(client, page - MAX31785_NR_PAGES,
					     reg, &val);
		if (rv < 0)
			return rv;

		rv = (val >> 16) & 0xffff;
		break;
	case PMBUS_FAN_COMMAND_1:
		/*
		 * PMBUS_FAN_COMMAND_x is probed to judge whether or not to
		 * expose fan control registers.
		 *
		 * Don't expose fan_target attribute for virtual pages.
		 */
		rv = (page >= MAX31785_NR_PAGES) ? -ENOTSUPP : -ENODATA;
		break;
	case PMBUS_VIRT_PWM_1:
		rv = max31785_get_pwm(client, page);
		break;
	case PMBUS_VIRT_PWM_ENABLE_1:
		rv = max31785_get_pwm_mode(client, page);
		break;
	default:
		rv = -ENODATA;
		break;
	}

	return rv;
}

static inline u32 max31785_scale_pwm(u32 sensor_val)
{
	/*
	 * The datasheet describes the accepted value range for manual PWM as
	 * [0, 0x2710], while the hwmon pwmX sysfs interface accepts values in
	 * [0, 255]. The MAX31785 uses DIRECT mode to scale the FAN_COMMAND
	 * registers and in PWM mode the coefficients are m=1, b=0, R=2. The
	 * important observation here is that 0x2710 == 10000 == 100 * 100.
	 *
	 * R=2 (== 10^2 == 100) accounts for scaling the value provided at the
	 * sysfs interface into the required hardware resolution, but it does
	 * not yet yield a value that we can write to the device (this initial
	 * scaling is handled by pmbus_data2reg()). Multiplying by 100 below
	 * translates the parameter value into the percentage units required by
	 * PMBus, and then we scale back by 255 as required by the hwmon pwmX
	 * interface to yield the percentage value at the appropriate
	 * resolution for hardware.
	 */
	return (sensor_val * 100) / 255;
}

static int max31785_pwm_enable(struct i2c_client *client, int page,
				    u16 word)
{
	int config = 0;
	int rate;

	switch (word) {
	case 0:
		rate = 0x7fff;
		break;
	case 1:
		rate = pmbus_get_fan_rate_cached(client, page, 0, percent);
		if (rate < 0)
			return rate;
		rate = max31785_scale_pwm(rate);
		break;
	case 2:
		config = PB_FAN_1_RPM;
		rate = pmbus_get_fan_rate_cached(client, page, 0, rpm);
		if (rate < 0)
			return rate;
		break;
	case 3:
		rate = 0xffff;
		break;
	default:
		return -EINVAL;
	}

	return pmbus_update_fan(client, page, 0, config, PB_FAN_1_RPM, rate);
}

static int max31785_write_word_data(struct i2c_client *client, int page,
				    int reg, u16 word)
{
	switch (reg) {
	case PMBUS_VIRT_PWM_1:
		return pmbus_update_fan(client, page, 0, 0, PB_FAN_1_RPM,
					max31785_scale_pwm(word));
	case PMBUS_VIRT_PWM_ENABLE_1:
		return max31785_pwm_enable(client, page, word);
	default:
		break;
	}

	return -ENODATA;
}

#define MAX31785_FAN_FUNCS \
	(PMBUS_HAVE_FAN12 | PMBUS_HAVE_STATUS_FAN12 | PMBUS_HAVE_PWM12)

#define MAX31785_TEMP_FUNCS \
	(PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP)

#define MAX31785_VOUT_FUNCS \
	(PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT)

static const struct pmbus_driver_info max31785_info = {
	.pages = MAX31785_NR_PAGES,

	.write_word_data = max31785_write_word_data,
	.read_byte_data = max31785_read_byte_data,
	.read_word_data = max31785_read_word_data,
	.write_byte = max31785_write_byte,

	/* RPM */
	.format[PSC_FAN] = direct,
	.m[PSC_FAN] = 1,
	.b[PSC_FAN] = 0,
	.R[PSC_FAN] = 0,
	/* PWM */
	.format[PSC_PWM] = direct,
	.m[PSC_PWM] = 1,
	.b[PSC_PWM] = 0,
	.R[PSC_PWM] = 2,
	.func[0] = MAX31785_FAN_FUNCS,
	.func[1] = MAX31785_FAN_FUNCS,
	.func[2] = MAX31785_FAN_FUNCS,
	.func[3] = MAX31785_FAN_FUNCS,
	.func[4] = MAX31785_FAN_FUNCS,
	.func[5] = MAX31785_FAN_FUNCS,

	.format[PSC_TEMPERATURE] = direct,
	.m[PSC_TEMPERATURE] = 1,
	.b[PSC_TEMPERATURE] = 0,
	.R[PSC_TEMPERATURE] = 2,
	.func[6]  = MAX31785_TEMP_FUNCS,
	.func[7]  = MAX31785_TEMP_FUNCS,
	.func[8]  = MAX31785_TEMP_FUNCS,
	.func[9]  = MAX31785_TEMP_FUNCS,
	.func[10] = MAX31785_TEMP_FUNCS,
	.func[11] = MAX31785_TEMP_FUNCS,
	.func[12] = MAX31785_TEMP_FUNCS,
	.func[13] = MAX31785_TEMP_FUNCS,
	.func[14] = MAX31785_TEMP_FUNCS,
	.func[15] = MAX31785_TEMP_FUNCS,
	.func[16] = MAX31785_TEMP_FUNCS,

	.format[PSC_VOLTAGE_OUT] = direct,
	.m[PSC_VOLTAGE_OUT] = 1,
	.b[PSC_VOLTAGE_OUT] = 0,
	.R[PSC_VOLTAGE_OUT] = 0,
	.func[17] = MAX31785_VOUT_FUNCS,
	.func[18] = MAX31785_VOUT_FUNCS,
	.func[19] = MAX31785_VOUT_FUNCS,
	.func[20] = MAX31785_VOUT_FUNCS,
	.func[21] = MAX31785_VOUT_FUNCS,
	.func[22] = MAX31785_VOUT_FUNCS,
};

static int max31785_configure_dual_tach(struct i2c_client *client,
					struct pmbus_driver_info *info)
{
	int ret;
	int i;

	for (i = 0; i < MAX31785_NR_FAN_PAGES; i++) {
		ret = i2c_smbus_write_byte_data(client, PMBUS_PAGE, i);
		if (ret < 0)
			return ret;

		ret = i2c_smbus_read_word_data(client, MFR_FAN_CONFIG);
		if (ret < 0)
			return ret;

		if (ret & MFR_FAN_CONFIG_DUAL_TACH) {
			int virtual = MAX31785_NR_PAGES + i;

			info->pages = virtual + 1;
			info->func[virtual] |= PMBUS_HAVE_FAN12;
			info->func[virtual] |= PMBUS_PAGE_VIRTUAL;
		}
	}

	return 0;
}

static int max31785_probe(struct i2c_client *client)
{
	struct device *dev = &client->dev;
	struct pmbus_driver_info *info;
	bool dual_tach = false;
	int ret;

	if (!i2c_check_functionality(client->adapter,
				     I2C_FUNC_SMBUS_BYTE_DATA |
				     I2C_FUNC_SMBUS_WORD_DATA))
		return -ENODEV;

	info = devm_kzalloc(dev, sizeof(struct pmbus_driver_info), GFP_KERNEL);
	if (!info)
		return -ENOMEM;

	*info = max31785_info;

	ret = i2c_smbus_write_byte_data(client, PMBUS_PAGE, 255);
	if (ret < 0)
		return ret;

	ret = i2c_smbus_read_word_data(client, MFR_REVISION);
	if (ret < 0)
		return ret;

	if (ret == MAX31785A || ret == MAX31785B) {
		dual_tach = true;
	} else if (ret == MAX31785) {
		if (!strcmp("max31785a", client->name) ||
		    !strcmp("max31785b", client->name))
			dev_warn(dev, "Expected max31785a/b, found max31785: cannot provide secondary tachometer readings\n");
	} else {
		dev_err(dev, "Unrecognized MAX31785 revision: %x\n", ret);
		return -ENODEV;
	}

	if (dual_tach) {
		ret = max31785_configure_dual_tach(client, info);
		if (ret < 0)
			return ret;
	}

	return pmbus_do_probe(client, info);
}

static const struct i2c_device_id max31785_id[] = {
	{ "max31785", 0 },
	{ "max31785a", 0 },
	{ "max31785b", 0 },
	{ },
};

MODULE_DEVICE_TABLE(i2c, max31785_id);

static const struct of_device_id max31785_of_match[] = {
	{ .compatible = "maxim,max31785" },
	{ .compatible = "maxim,max31785a" },
	{ .compatible = "maxim,max31785b" },
	{ },
};

MODULE_DEVICE_TABLE(of, max31785_of_match);

static struct i2c_driver max31785_driver = {
	.driver = {
		.name = "max31785",
		.of_match_table = max31785_of_match,
	},
	.probe_new = max31785_probe,
	.id_table = max31785_id,
};

module_i2c_driver(max31785_driver);

MODULE_AUTHOR("Andrew Jeffery <andrew@aj.id.au>");
MODULE_DESCRIPTION("PMBus driver for the Maxim MAX31785");
MODULE_LICENSE("GPL");
MODULE_IMPORT_NS(PMBUS);
Commit	Line	Data
2874c5fd	1	// SPDX-License-Identifier: GPL-2.0-or-later
4d420a6a AJ	2	/*
4d420a6a AJ	3	* Copyright (C) 2017 IBM Corp.
4d420a6a AJ	4	*/
	5
	6	#include <linux/kernel.h>
	7	#include <linux/module.h>
	8	#include <linux/init.h>
	9	#include <linux/err.h>
	10	#include <linux/i2c.h>
	11	#include "pmbus.h"
	12
	13	enum max31785_regs {
	14	MFR_REVISION = 0x9b,
cf583b42	15	MFR_FAN_CONFIG = 0xf1,
4d420a6a AJ	16	};
4d420a6a AJ	17
cf583b42 AJ	18	#define MAX31785 0x3030
cf583b42 AJ	19	#define MAX31785A 0x3040
996dc09c	20	#define MAX31785B 0x3061
cf583b42 AJ	21
	22	#define MFR_FAN_CONFIG_DUAL_TACH BIT(12)
	23
4d420a6a	24	#define MAX31785_NR_PAGES 23
cf583b42 AJ	25	#define MAX31785_NR_FAN_PAGES 6
	26
	27	static int max31785_read_byte_data(struct i2c_client *client, int page,
	28	int reg)
	29	{
	30	if (page < MAX31785_NR_PAGES)
	31	return -ENODATA;
	32
	33	switch (reg) {
	34	case PMBUS_VOUT_MODE:
	35	return -ENOTSUPP;
	36	case PMBUS_FAN_CONFIG_12:
	37	return pmbus_read_byte_data(client, page - MAX31785_NR_PAGES,
	38	reg);
	39	}
	40
	41	return -ENODATA;
	42	}
	43
	44	static int max31785_write_byte(struct i2c_client *client, int page, u8 value)
	45	{
	46	if (page < MAX31785_NR_PAGES)
	47	return -ENODATA;
	48
	49	return -ENOTSUPP;
	50	}
	51
	52	static int max31785_read_long_data(struct i2c_client *client, int page,
	53	int reg, u32 *data)
	54	{
	55	unsigned char cmdbuf[1];
	56	unsigned char rspbuf[4];
	57	int rc;
	58
	59	struct i2c_msg msg[2] = {
	60	{
	61	.addr = client->addr,
	62	.flags = 0,
	63	.len = sizeof(cmdbuf),
	64	.buf = cmdbuf,
	65	},
	66	{
	67	.addr = client->addr,
	68	.flags = I2C_M_RD,
	69	.len = sizeof(rspbuf),
	70	.buf = rspbuf,
	71	},
	72	};
	73
	74	cmdbuf[0] = reg;
	75
43f33b6e	76	rc = pmbus_set_page(client, page, 0xff);
cf583b42 AJ	77	if (rc < 0)
	78	return rc;
	79
	80	rc = i2c_transfer(client->adapter, msg, ARRAY_SIZE(msg));
	81	if (rc < 0)
	82	return rc;
	83
	84	data = (rspbuf[0] << (0 8)) \| (rspbuf[1] << (1 * 8)) \|
	85	(rspbuf[2] << (2 * 8)) \| (rspbuf[3] << (3 * 8));
	86
	87	return rc;
	88	}
4d420a6a	89
56ad86b4 AJ	90	static int max31785_get_pwm(struct i2c_client *client, int page)
	91	{
	92	int rv;
	93
	94	rv = pmbus_get_fan_rate_device(client, page, 0, percent);
	95	if (rv < 0)
	96	return rv;
	97	else if (rv >= 0x8000)
	98	return 0;
	99	else if (rv >= 0x2711)
	100	return 0x2710;
	101
	102	return rv;
	103	}
	104
	105	static int max31785_get_pwm_mode(struct i2c_client *client, int page)
	106	{
	107	int config;
	108	int command;
	109
	110	config = pmbus_read_byte_data(client, page, PMBUS_FAN_CONFIG_12);
	111	if (config < 0)
	112	return config;
	113
43f33b6e	114	command = pmbus_read_word_data(client, page, 0xff, PMBUS_FAN_COMMAND_1);
56ad86b4 AJ	115	if (command < 0)
	116	return command;
	117
	118	if (config & PB_FAN_1_RPM)
	119	return (command >= 0x8000) ? 3 : 2;
	120
	121	if (command >= 0x8000)
	122	return 3;
	123	else if (command >= 0x2711)
	124	return 0;
	125
	126	return 1;
	127	}
	128
	129	static int max31785_read_word_data(struct i2c_client *client, int page,
43f33b6e	130	int phase, int reg)
56ad86b4	131	{
cf583b42	132	u32 val;
56ad86b4 AJ	133	int rv;
	134
	135	switch (reg) {
cf583b42 AJ	136	case PMBUS_READ_FAN_SPEED_1:
	137	if (page < MAX31785_NR_PAGES)
	138	return -ENODATA;
	139
	140	rv = max31785_read_long_data(client, page - MAX31785_NR_PAGES,
	141	reg, &val);
	142	if (rv < 0)
	143	return rv;
	144
	145	rv = (val >> 16) & 0xffff;
	146	break;
	147	case PMBUS_FAN_COMMAND_1:
	148	/*
	149	* PMBUS_FAN_COMMAND_x is probed to judge whether or not to
	150	* expose fan control registers.
	151	*
	152	* Don't expose fan_target attribute for virtual pages.
	153	*/
	154	rv = (page >= MAX31785_NR_PAGES) ? -ENOTSUPP : -ENODATA;
	155	break;
56ad86b4 AJ	156	case PMBUS_VIRT_PWM_1:
	157	rv = max31785_get_pwm(client, page);
	158	break;
	159	case PMBUS_VIRT_PWM_ENABLE_1:
	160	rv = max31785_get_pwm_mode(client, page);
	161	break;
	162	default:
	163	rv = -ENODATA;
	164	break;
	165	}
	166
	167	return rv;
	168	}
	169
	170	static inline u32 max31785_scale_pwm(u32 sensor_val)
	171	{
	172	/*
	173	* The datasheet describes the accepted value range for manual PWM as
	174	* [0, 0x2710], while the hwmon pwmX sysfs interface accepts values in
	175	* [0, 255]. The MAX31785 uses DIRECT mode to scale the FAN_COMMAND
	176	* registers and in PWM mode the coefficients are m=1, b=0, R=2. The
	177	* important observation here is that 0x2710 == 10000 == 100 * 100.
	178	*
	179	* R=2 (== 10^2 == 100) accounts for scaling the value provided at the
	180	* sysfs interface into the required hardware resolution, but it does
	181	* not yet yield a value that we can write to the device (this initial
	182	* scaling is handled by pmbus_data2reg()). Multiplying by 100 below
	183	* translates the parameter value into the percentage units required by
	184	* PMBus, and then we scale back by 255 as required by the hwmon pwmX
	185	* interface to yield the percentage value at the appropriate
	186	* resolution for hardware.
	187	*/
	188	return (sensor_val * 100) / 255;
	189	}
	190
	191	static int max31785_pwm_enable(struct i2c_client *client, int page,
	192	u16 word)
	193	{
	194	int config = 0;
	195	int rate;
	196
	197	switch (word) {
	198	case 0:
	199	rate = 0x7fff;
	200	break;
	201	case 1:
	202	rate = pmbus_get_fan_rate_cached(client, page, 0, percent);
	203	if (rate < 0)
	204	return rate;
	205	rate = max31785_scale_pwm(rate);
	206	break;
	207	case 2:
	208	config = PB_FAN_1_RPM;
	209	rate = pmbus_get_fan_rate_cached(client, page, 0, rpm);
	210	if (rate < 0)
	211	return rate;
	212	break;
	213	case 3:
	214	rate = 0xffff;
	215	break;
	216	default:
	217	return -EINVAL;
	218	}
	219
220	return pmbus_update_fan(client, page, 0, config, PB_FAN_1_RPM, rate);
221	}
222
223	static int max31785_write_word_data(struct i2c_client *client, int page,
224	int reg, u16 word)
225	{
226	switch (reg) {
227	case PMBUS_VIRT_PWM_1:
228	return pmbus_update_fan(client, page, 0, 0, PB_FAN_1_RPM,
229	max31785_scale_pwm(word));
230	case PMBUS_VIRT_PWM_ENABLE_1:
231	return max31785_pwm_enable(client, page, word);
232	default:
233	break;
234	}
235
236	return -ENODATA;
237	}
238
4d420a6a	239	#define MAX31785_FAN_FUNCS \
56ad86b4	240	(PMBUS_HAVE_FAN12 \| PMBUS_HAVE_STATUS_FAN12 \| PMBUS_HAVE_PWM12)
4d420a6a AJ	241
	242	#define MAX31785_TEMP_FUNCS \
	243	(PMBUS_HAVE_TEMP \| PMBUS_HAVE_STATUS_TEMP)
	244
	245	#define MAX31785_VOUT_FUNCS \
	246	(PMBUS_HAVE_VOUT \| PMBUS_HAVE_STATUS_VOUT)
	247
	248	static const struct pmbus_driver_info max31785_info = {
	249	.pages = MAX31785_NR_PAGES,
	250
56ad86b4	251	.write_word_data = max31785_write_word_data,
cf583b42	252	.read_byte_data = max31785_read_byte_data,
56ad86b4	253	.read_word_data = max31785_read_word_data,
cf583b42	254	.write_byte = max31785_write_byte,
56ad86b4	255
4d420a6a AJ	256	/* RPM */
	257	.format[PSC_FAN] = direct,
	258	.m[PSC_FAN] = 1,
	259	.b[PSC_FAN] = 0,
	260	.R[PSC_FAN] = 0,
56ad86b4 AJ	261	/* PWM */
	262	.format[PSC_PWM] = direct,
	263	.m[PSC_PWM] = 1,
	264	.b[PSC_PWM] = 0,
	265	.R[PSC_PWM] = 2,
4d420a6a AJ	266	.func[0] = MAX31785_FAN_FUNCS,
	267	.func[1] = MAX31785_FAN_FUNCS,
	268	.func[2] = MAX31785_FAN_FUNCS,
	269	.func[3] = MAX31785_FAN_FUNCS,
	270	.func[4] = MAX31785_FAN_FUNCS,
	271	.func[5] = MAX31785_FAN_FUNCS,
	272
	273	.format[PSC_TEMPERATURE] = direct,
	274	.m[PSC_TEMPERATURE] = 1,
	275	.b[PSC_TEMPERATURE] = 0,
	276	.R[PSC_TEMPERATURE] = 2,
	277	.func[6] = MAX31785_TEMP_FUNCS,
	278	.func[7] = MAX31785_TEMP_FUNCS,
	279	.func[8] = MAX31785_TEMP_FUNCS,
	280	.func[9] = MAX31785_TEMP_FUNCS,
	281	.func[10] = MAX31785_TEMP_FUNCS,
	282	.func[11] = MAX31785_TEMP_FUNCS,
	283	.func[12] = MAX31785_TEMP_FUNCS,
	284	.func[13] = MAX31785_TEMP_FUNCS,
	285	.func[14] = MAX31785_TEMP_FUNCS,
	286	.func[15] = MAX31785_TEMP_FUNCS,
	287	.func[16] = MAX31785_TEMP_FUNCS,
	288
	289	.format[PSC_VOLTAGE_OUT] = direct,
	290	.m[PSC_VOLTAGE_OUT] = 1,
	291	.b[PSC_VOLTAGE_OUT] = 0,
	292	.R[PSC_VOLTAGE_OUT] = 0,
	293	.func[17] = MAX31785_VOUT_FUNCS,
	294	.func[18] = MAX31785_VOUT_FUNCS,
	295	.func[19] = MAX31785_VOUT_FUNCS,
	296	.func[20] = MAX31785_VOUT_FUNCS,
	297	.func[21] = MAX31785_VOUT_FUNCS,
	298	.func[22] = MAX31785_VOUT_FUNCS,
	299	};
	300
cf583b42 AJ	301	static int max31785_configure_dual_tach(struct i2c_client *client,
	302	struct pmbus_driver_info *info)
	303	{
	304	int ret;
	305	int i;
	306
	307	for (i = 0; i < MAX31785_NR_FAN_PAGES; i++) {
	308	ret = i2c_smbus_write_byte_data(client, PMBUS_PAGE, i);
	309	if (ret < 0)
	310	return ret;
	311
	312	ret = i2c_smbus_read_word_data(client, MFR_FAN_CONFIG);
	313	if (ret < 0)
	314	return ret;
	315
	316	if (ret & MFR_FAN_CONFIG_DUAL_TACH) {
	317	int virtual = MAX31785_NR_PAGES + i;
	318
	319	info->pages = virtual + 1;
	320	info->func[virtual] \|= PMBUS_HAVE_FAN12;
	321	info->func[virtual] \|= PMBUS_PAGE_VIRTUAL;
	322	}
	323	}
	324
	325	return 0;
	326	}
	327
dd431939	328	static int max31785_probe(struct i2c_client *client)
4d420a6a AJ	329	{
	330	struct device *dev = &client->dev;
	331	struct pmbus_driver_info *info;
cf583b42	332	bool dual_tach = false;
996dc09c	333	int ret;
4d420a6a	334
cf583b42 AJ	335	if (!i2c_check_functionality(client->adapter,
	336	I2C_FUNC_SMBUS_BYTE_DATA \|
	337	I2C_FUNC_SMBUS_WORD_DATA))
	338	return -ENODEV;
	339
4d420a6a AJ	340	info = devm_kzalloc(dev, sizeof(struct pmbus_driver_info), GFP_KERNEL);
	341	if (!info)
	342	return -ENOMEM;
	343
	344	*info = max31785_info;
	345
	346	ret = i2c_smbus_write_byte_data(client, PMBUS_PAGE, 255);
	347	if (ret < 0)
	348	return ret;
	349
cf583b42 AJ	350	ret = i2c_smbus_read_word_data(client, MFR_REVISION);
	351	if (ret < 0)
	352	return ret;
	353
996dc09c	354	if (ret == MAX31785A \|\| ret == MAX31785B) {
cf583b42 AJ	355	dual_tach = true;
cf583b42 AJ	356	} else if (ret == MAX31785) {
996dc09c MB	357	if (!strcmp("max31785a", client->name) \|\|
	358	!strcmp("max31785b", client->name))
	359	dev_warn(dev, "Expected max31785a/b, found max31785: cannot provide secondary tachometer readings\n");
cf583b42	360	} else {
996dc09c	361	dev_err(dev, "Unrecognized MAX31785 revision: %x\n", ret);
cf583b42 AJ	362	return -ENODEV;
	363	}
	364
	365	if (dual_tach) {
	366	ret = max31785_configure_dual_tach(client, info);
	367	if (ret < 0)
	368	return ret;
	369	}
	370
dd431939	371	return pmbus_do_probe(client, info);
4d420a6a AJ	372	}
	373
	374	static const struct i2c_device_id max31785_id[] = {
	375	{ "max31785", 0 },
	376	{ "max31785a", 0 },
996dc09c	377	{ "max31785b", 0 },
4d420a6a AJ	378	{ },
	379	};
	380
	381	MODULE_DEVICE_TABLE(i2c, max31785_id);
	382
98b16a09 JMC	383	static const struct of_device_id max31785_of_match[] = {
	384	{ .compatible = "maxim,max31785" },
	385	{ .compatible = "maxim,max31785a" },
996dc09c	386	{ .compatible = "maxim,max31785b" },
98b16a09 JMC	387	{ },
	388	};
	389
	390	MODULE_DEVICE_TABLE(of, max31785_of_match);
	391
4d420a6a AJ	392	static struct i2c_driver max31785_driver = {
	393	.driver = {
	394	.name = "max31785",
98b16a09	395	.of_match_table = max31785_of_match,
4d420a6a	396	},
dd431939	397	.probe_new = max31785_probe,
4d420a6a AJ	398	.id_table = max31785_id,
	399	};
	400
	401	module_i2c_driver(max31785_driver);
	402
	403	MODULE_AUTHOR("Andrew Jeffery <andrew@aj.id.au>");
	404	MODULE_DESCRIPTION("PMBus driver for the Maxim MAX31785");
	405	MODULE_LICENSE("GPL");
b94ca77e	406	MODULE_IMPORT_NS(PMBUS);