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

/*
 * Hardware monitoring driver for Analog Devices ADM1275 Hot-Swap Controller
 * and Digital Power Monitor
 *
 * Copyright (c) 2011 Ericsson AB.
 *
 * 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 "pmbus.h"

enum chips { adm1075, adm1275, adm1276 };

#define ADM1275_PEAK_IOUT		0xd0
#define ADM1275_PEAK_VIN		0xd1
#define ADM1275_PEAK_VOUT		0xd2
#define ADM1275_PMON_CONFIG		0xd4

#define ADM1275_VIN_VOUT_SELECT		(1 << 6)
#define ADM1275_VRANGE			(1 << 5)
#define ADM1075_IRANGE_50		(1 << 4)
#define ADM1075_IRANGE_25		(1 << 3)
#define ADM1075_IRANGE_MASK		((1 << 3) | (1 << 4))

#define ADM1275_IOUT_WARN2_LIMIT	0xd7
#define ADM1275_DEVICE_CONFIG		0xd8

#define ADM1275_IOUT_WARN2_SELECT	(1 << 4)

#define ADM1276_PEAK_PIN		0xda

#define ADM1275_MFR_STATUS_IOUT_WARN2	(1 << 0)

#define ADM1075_READ_VAUX		0xdd
#define ADM1075_VAUX_OV_WARN_LIMIT	0xde
#define ADM1075_VAUX_UV_WARN_LIMIT	0xdf
#define ADM1075_VAUX_STATUS		0xf6

#define ADM1075_VAUX_OV_WARN		(1<<7)
#define ADM1075_VAUX_UV_WARN		(1<<6)

struct adm1275_data {
	int id;
	bool have_oc_fault;
	struct pmbus_driver_info info;
};

#define to_adm1275_data(x)  container_of(x, struct adm1275_data, info)

static int adm1275_read_word_data(struct i2c_client *client, int page, int reg)
{
	const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
	const struct adm1275_data *data = to_adm1275_data(info);
	int ret = 0;

	if (page)
		return -ENXIO;

	switch (reg) {
	case PMBUS_IOUT_UC_FAULT_LIMIT:
		if (data->have_oc_fault) {
			ret = -ENXIO;
			break;
		}
		ret = pmbus_read_word_data(client, 0, ADM1275_IOUT_WARN2_LIMIT);
		break;
	case PMBUS_IOUT_OC_FAULT_LIMIT:
		if (!data->have_oc_fault) {
			ret = -ENXIO;
			break;
		}
		ret = pmbus_read_word_data(client, 0, ADM1275_IOUT_WARN2_LIMIT);
		break;
	case PMBUS_VOUT_OV_WARN_LIMIT:
		if (data->id != adm1075) {
			ret = -ENODATA;
			break;
		}
		ret = pmbus_read_word_data(client, 0,
					   ADM1075_VAUX_OV_WARN_LIMIT);
		break;
	case PMBUS_VOUT_UV_WARN_LIMIT:
		if (data->id != adm1075) {
			ret = -ENODATA;
			break;
		}
		ret = pmbus_read_word_data(client, 0,
					   ADM1075_VAUX_UV_WARN_LIMIT);
		break;
	case PMBUS_READ_VOUT:
		if (data->id != adm1075) {
			ret = -ENODATA;
			break;
		}
		ret = pmbus_read_word_data(client, 0, ADM1075_READ_VAUX);
		break;
	case PMBUS_VIRT_READ_IOUT_MAX:
		ret = pmbus_read_word_data(client, 0, ADM1275_PEAK_IOUT);
		break;
	case PMBUS_VIRT_READ_VOUT_MAX:
		ret = pmbus_read_word_data(client, 0, ADM1275_PEAK_VOUT);
		break;
	case PMBUS_VIRT_READ_VIN_MAX:
		ret = pmbus_read_word_data(client, 0, ADM1275_PEAK_VIN);
		break;
	case PMBUS_VIRT_READ_PIN_MAX:
		if (data->id == adm1275) {
			ret = -ENXIO;
			break;
		}
		ret = pmbus_read_word_data(client, 0, ADM1276_PEAK_PIN);
		break;
	case PMBUS_VIRT_RESET_IOUT_HISTORY:
	case PMBUS_VIRT_RESET_VOUT_HISTORY:
	case PMBUS_VIRT_RESET_VIN_HISTORY:
		break;
	case PMBUS_VIRT_RESET_PIN_HISTORY:
		if (data->id == adm1275)
			ret = -ENXIO;
		break;
	default:
		ret = -ENODATA;
		break;
	}
	return ret;
}

static int adm1275_write_word_data(struct i2c_client *client, int page, int reg,
				   u16 word)
{
	int ret;

	if (page)
		return -ENXIO;

	switch (reg) {
	case PMBUS_IOUT_UC_FAULT_LIMIT:
	case PMBUS_IOUT_OC_FAULT_LIMIT:
		ret = pmbus_write_word_data(client, 0, ADM1275_IOUT_WARN2_LIMIT,
					    word);
		break;
	case PMBUS_VIRT_RESET_IOUT_HISTORY:
		ret = pmbus_write_word_data(client, 0, ADM1275_PEAK_IOUT, 0);
		break;
	case PMBUS_VIRT_RESET_VOUT_HISTORY:
		ret = pmbus_write_word_data(client, 0, ADM1275_PEAK_VOUT, 0);
		break;
	case PMBUS_VIRT_RESET_VIN_HISTORY:
		ret = pmbus_write_word_data(client, 0, ADM1275_PEAK_VIN, 0);
		break;
	case PMBUS_VIRT_RESET_PIN_HISTORY:
		ret = pmbus_write_word_data(client, 0, ADM1276_PEAK_PIN, 0);
		break;
	default:
		ret = -ENODATA;
		break;
	}
	return ret;
}

static int adm1275_read_byte_data(struct i2c_client *client, int page, int reg)
{
	const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
	const struct adm1275_data *data = to_adm1275_data(info);
	int mfr_status, ret;

	if (page > 0)
		return -ENXIO;

	switch (reg) {
	case PMBUS_STATUS_IOUT:
		ret = pmbus_read_byte_data(client, page, PMBUS_STATUS_IOUT);
		if (ret < 0)
			break;
		mfr_status = pmbus_read_byte_data(client, page,
						  PMBUS_STATUS_MFR_SPECIFIC);
		if (mfr_status < 0) {
			ret = mfr_status;
			break;
		}
		if (mfr_status & ADM1275_MFR_STATUS_IOUT_WARN2) {
			ret |= data->have_oc_fault ?
			  PB_IOUT_OC_FAULT : PB_IOUT_UC_FAULT;
		}
		break;
	case PMBUS_STATUS_VOUT:
		if (data->id != adm1075) {
			ret = -ENODATA;
			break;
		}
		ret = 0;
		mfr_status = pmbus_read_byte_data(client, 0,
						  ADM1075_VAUX_STATUS);
		if (mfr_status & ADM1075_VAUX_OV_WARN)
			ret |= PB_VOLTAGE_OV_WARNING;
		if (mfr_status & ADM1075_VAUX_UV_WARN)
			ret |= PB_VOLTAGE_UV_WARNING;
		break;
	default:
		ret = -ENODATA;
		break;
	}
	return ret;
}

static const struct i2c_device_id adm1275_id[] = {
	{ "adm1075", adm1075 },
	{ "adm1275", adm1275 },
	{ "adm1276", adm1276 },
	{ }
};
MODULE_DEVICE_TABLE(i2c, adm1275_id);

static int adm1275_probe(struct i2c_client *client,
			 const struct i2c_device_id *id)
{
	u8 block_buffer[I2C_SMBUS_BLOCK_MAX + 1];
	int config, device_config;
	int ret;
	struct pmbus_driver_info *info;
	struct adm1275_data *data;
	const struct i2c_device_id *mid;

	if (!i2c_check_functionality(client->adapter,
				     I2C_FUNC_SMBUS_READ_BYTE_DATA
				     | I2C_FUNC_SMBUS_BLOCK_DATA))
		return -ENODEV;

	ret = i2c_smbus_read_block_data(client, PMBUS_MFR_ID, block_buffer);
	if (ret < 0) {
		dev_err(&client->dev, "Failed to read Manufacturer ID\n");
		return ret;
	}
	if (ret != 3 || strncmp(block_buffer, "ADI", 3)) {
		dev_err(&client->dev, "Unsupported Manufacturer ID\n");
		return -ENODEV;
	}

	ret = i2c_smbus_read_block_data(client, PMBUS_MFR_MODEL, block_buffer);
	if (ret < 0) {
		dev_err(&client->dev, "Failed to read Manufacturer Model\n");
		return ret;
	}
	for (mid = adm1275_id; mid->name[0]; mid++) {
		if (!strncasecmp(mid->name, block_buffer, strlen(mid->name)))
			break;
	}
	if (!mid->name[0]) {
		dev_err(&client->dev, "Unsupported device\n");
		return -ENODEV;
	}

	if (id->driver_data != mid->driver_data)
		dev_notice(&client->dev,
			   "Device mismatch: Configured %s, detected %s\n",
			   id->name, mid->name);

	config = i2c_smbus_read_byte_data(client, ADM1275_PMON_CONFIG);
	if (config < 0)
		return config;

	device_config = i2c_smbus_read_byte_data(client, ADM1275_DEVICE_CONFIG);
	if (device_config < 0)
		return device_config;

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

	data->id = mid->driver_data;

	info = &data->info;

	info->pages = 1;
	info->format[PSC_VOLTAGE_IN] = direct;
	info->format[PSC_VOLTAGE_OUT] = direct;
	info->format[PSC_CURRENT_OUT] = direct;
	info->m[PSC_CURRENT_OUT] = 807;
	info->b[PSC_CURRENT_OUT] = 20475;
	info->R[PSC_CURRENT_OUT] = -1;
	info->func[0] = PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT;

	info->read_word_data = adm1275_read_word_data;
	info->read_byte_data = adm1275_read_byte_data;
	info->write_word_data = adm1275_write_word_data;

	if (data->id == adm1075) {
		info->m[PSC_VOLTAGE_IN] = 27169;
		info->b[PSC_VOLTAGE_IN] = 0;
		info->R[PSC_VOLTAGE_IN] = -1;
		info->m[PSC_VOLTAGE_OUT] = 27169;
		info->b[PSC_VOLTAGE_OUT] = 0;
		info->R[PSC_VOLTAGE_OUT] = -1;
	} else if (config & ADM1275_VRANGE) {
		info->m[PSC_VOLTAGE_IN] = 19199;
		info->b[PSC_VOLTAGE_IN] = 0;
		info->R[PSC_VOLTAGE_IN] = -2;
		info->m[PSC_VOLTAGE_OUT] = 19199;
		info->b[PSC_VOLTAGE_OUT] = 0;
		info->R[PSC_VOLTAGE_OUT] = -2;
	} else {
		info->m[PSC_VOLTAGE_IN] = 6720;
		info->b[PSC_VOLTAGE_IN] = 0;
		info->R[PSC_VOLTAGE_IN] = -1;
		info->m[PSC_VOLTAGE_OUT] = 6720;
		info->b[PSC_VOLTAGE_OUT] = 0;
		info->R[PSC_VOLTAGE_OUT] = -1;
	}

	if (device_config & ADM1275_IOUT_WARN2_SELECT)
		data->have_oc_fault = true;

	switch (data->id) {
	case adm1075:
		info->format[PSC_POWER] = direct;
		info->b[PSC_POWER] = 0;
		info->R[PSC_POWER] = -1;
		switch (config & ADM1075_IRANGE_MASK) {
		case ADM1075_IRANGE_25:
			info->m[PSC_POWER] = 8549;
			info->m[PSC_CURRENT_OUT] = 806;
			break;
		case ADM1075_IRANGE_50:
			info->m[PSC_POWER] = 4279;
			info->m[PSC_CURRENT_OUT] = 404;
			break;
		default:
			dev_err(&client->dev, "Invalid input current range");
			info->m[PSC_POWER] = 0;
			info->m[PSC_CURRENT_OUT] = 0;
			break;
		}
		info->func[0] |= PMBUS_HAVE_VIN | PMBUS_HAVE_PIN
		  | PMBUS_HAVE_STATUS_INPUT;
		if (config & ADM1275_VIN_VOUT_SELECT)
			info->func[0] |=
			  PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT;
		break;
	case adm1275:
		if (config & ADM1275_VIN_VOUT_SELECT)
			info->func[0] |=
			  PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT;
		else
			info->func[0] |=
			  PMBUS_HAVE_VIN | PMBUS_HAVE_STATUS_INPUT;
		break;
	case adm1276:
		info->format[PSC_POWER] = direct;
		info->func[0] |= PMBUS_HAVE_VIN | PMBUS_HAVE_PIN
		  | PMBUS_HAVE_STATUS_INPUT;
		if (config & ADM1275_VIN_VOUT_SELECT)
			info->func[0] |=
			  PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT;
		if (config & ADM1275_VRANGE) {
			info->m[PSC_POWER] = 6043;
			info->b[PSC_POWER] = 0;
			info->R[PSC_POWER] = -2;
		} else {
			info->m[PSC_POWER] = 2115;
			info->b[PSC_POWER] = 0;
			info->R[PSC_POWER] = -1;
		}
		break;
	}

	return pmbus_do_probe(client, id, info);
}

static struct i2c_driver adm1275_driver = {
	.driver = {
		   .name = "adm1275",
		   },
	.probe = adm1275_probe,
	.remove = pmbus_do_remove,
	.id_table = adm1275_id,
};

module_i2c_driver(adm1275_driver);

MODULE_AUTHOR("Guenter Roeck");
MODULE_DESCRIPTION("PMBus driver for Analog Devices ADM1275 and compatibles");
MODULE_LICENSE("GPL");
Commit	Line	Data
83f7649c GR	1	/*
	2	* Hardware monitoring driver for Analog Devices ADM1275 Hot-Swap Controller
	3	* and Digital Power Monitor
	4	*
	5	* Copyright (c) 2011 Ericsson AB.
	6	*
	7	* This program is free software; you can redistribute it and/or modify
	8	* it under the terms of the GNU General Public License as published by
	9	* the Free Software Foundation; either version 2 of the License, or
	10	* (at your option) any later version.
	11	*
	12	* This program is distributed in the hope that it will be useful,
	13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	* GNU General Public License for more details.
	16	*/
	17
	18	#include <linux/kernel.h>
	19	#include <linux/module.h>
	20	#include <linux/init.h>
	21	#include <linux/err.h>
	22	#include <linux/slab.h>
	23	#include <linux/i2c.h>
	24	#include "pmbus.h"
	25
92711269	26	enum chips { adm1075, adm1275, adm1276 };
5cf231a3	27
c576e30c GR	28	#define ADM1275_PEAK_IOUT 0xd0
	29	#define ADM1275_PEAK_VIN 0xd1
	30	#define ADM1275_PEAK_VOUT 0xd2
83f7649c GR	31	#define ADM1275_PMON_CONFIG 0xd4
	32
	33	#define ADM1275_VIN_VOUT_SELECT (1 << 6)
	34	#define ADM1275_VRANGE (1 << 5)
92711269 GR	35	#define ADM1075_IRANGE_50 (1 << 4)
	36	#define ADM1075_IRANGE_25 (1 << 3)
	37	#define ADM1075_IRANGE_MASK ((1 << 3) \| (1 << 4))
83f7649c	38
c5e67636 GR	39	#define ADM1275_IOUT_WARN2_LIMIT 0xd7
	40	#define ADM1275_DEVICE_CONFIG 0xd8
	41
	42	#define ADM1275_IOUT_WARN2_SELECT (1 << 4)
	43
5cf231a3 GR	44	#define ADM1276_PEAK_PIN 0xda
5cf231a3 GR	45
c5e67636 GR	46	#define ADM1275_MFR_STATUS_IOUT_WARN2 (1 << 0)
c5e67636 GR	47
92711269 GR	48	#define ADM1075_READ_VAUX 0xdd
	49	#define ADM1075_VAUX_OV_WARN_LIMIT 0xde
	50	#define ADM1075_VAUX_UV_WARN_LIMIT 0xdf
	51	#define ADM1075_VAUX_STATUS 0xf6
	52
	53	#define ADM1075_VAUX_OV_WARN (1<<7)
	54	#define ADM1075_VAUX_UV_WARN (1<<6)
	55
c5e67636	56	struct adm1275_data {
5cf231a3	57	int id;
c5e67636 GR	58	bool have_oc_fault;
	59	struct pmbus_driver_info info;
	60	};
	61
	62	#define to_adm1275_data(x) container_of(x, struct adm1275_data, info)
	63
c576e30c GR	64	static int adm1275_read_word_data(struct i2c_client *client, int page, int reg)
c576e30c GR	65	{
c5e67636 GR	66	const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
c5e67636 GR	67	const struct adm1275_data *data = to_adm1275_data(info);
5cf231a3	68	int ret = 0;
c576e30c GR	69
c576e30c GR	70	if (page)
c5e67636	71	return -ENXIO;
c576e30c GR	72
c576e30c GR	73	switch (reg) {
c5e67636 GR	74	case PMBUS_IOUT_UC_FAULT_LIMIT:
	75	if (data->have_oc_fault) {
	76	ret = -ENXIO;
	77	break;
	78	}
	79	ret = pmbus_read_word_data(client, 0, ADM1275_IOUT_WARN2_LIMIT);
	80	break;
	81	case PMBUS_IOUT_OC_FAULT_LIMIT:
	82	if (!data->have_oc_fault) {
	83	ret = -ENXIO;
	84	break;
	85	}
	86	ret = pmbus_read_word_data(client, 0, ADM1275_IOUT_WARN2_LIMIT);
	87	break;
92711269 GR	88	case PMBUS_VOUT_OV_WARN_LIMIT:
	89	if (data->id != adm1075) {
	90	ret = -ENODATA;
	91	break;
	92	}
	93	ret = pmbus_read_word_data(client, 0,
	94	ADM1075_VAUX_OV_WARN_LIMIT);
	95	break;
	96	case PMBUS_VOUT_UV_WARN_LIMIT:
	97	if (data->id != adm1075) {
	98	ret = -ENODATA;
	99	break;
	100	}
	101	ret = pmbus_read_word_data(client, 0,
	102	ADM1075_VAUX_UV_WARN_LIMIT);
	103	break;
	104	case PMBUS_READ_VOUT:
	105	if (data->id != adm1075) {
	106	ret = -ENODATA;
	107	break;
	108	}
	109	ret = pmbus_read_word_data(client, 0, ADM1075_READ_VAUX);
	110	break;
c576e30c GR	111	case PMBUS_VIRT_READ_IOUT_MAX:
	112	ret = pmbus_read_word_data(client, 0, ADM1275_PEAK_IOUT);
	113	break;
	114	case PMBUS_VIRT_READ_VOUT_MAX:
	115	ret = pmbus_read_word_data(client, 0, ADM1275_PEAK_VOUT);
	116	break;
	117	case PMBUS_VIRT_READ_VIN_MAX:
	118	ret = pmbus_read_word_data(client, 0, ADM1275_PEAK_VIN);
	119	break;
5cf231a3	120	case PMBUS_VIRT_READ_PIN_MAX:
92711269	121	if (data->id == adm1275) {
5cf231a3 GR	122	ret = -ENXIO;
	123	break;
	124	}
	125	ret = pmbus_read_word_data(client, 0, ADM1276_PEAK_PIN);
	126	break;
c576e30c GR	127	case PMBUS_VIRT_RESET_IOUT_HISTORY:
	128	case PMBUS_VIRT_RESET_VOUT_HISTORY:
	129	case PMBUS_VIRT_RESET_VIN_HISTORY:
5cf231a3 GR	130	break;
5cf231a3 GR	131	case PMBUS_VIRT_RESET_PIN_HISTORY:
92711269	132	if (data->id == adm1275)
5cf231a3	133	ret = -ENXIO;
c576e30c GR	134	break;
	135	default:
	136	ret = -ENODATA;
	137	break;
	138	}
	139	return ret;
	140	}
	141
	142	static int adm1275_write_word_data(struct i2c_client *client, int page, int reg,
	143	u16 word)
	144	{
	145	int ret;
	146
	147	if (page)
c5e67636	148	return -ENXIO;
c576e30c GR	149
c576e30c GR	150	switch (reg) {
c5e67636 GR	151	case PMBUS_IOUT_UC_FAULT_LIMIT:
	152	case PMBUS_IOUT_OC_FAULT_LIMIT:
	153	ret = pmbus_write_word_data(client, 0, ADM1275_IOUT_WARN2_LIMIT,
	154	word);
	155	break;
c576e30c GR	156	case PMBUS_VIRT_RESET_IOUT_HISTORY:
	157	ret = pmbus_write_word_data(client, 0, ADM1275_PEAK_IOUT, 0);
	158	break;
	159	case PMBUS_VIRT_RESET_VOUT_HISTORY:
	160	ret = pmbus_write_word_data(client, 0, ADM1275_PEAK_VOUT, 0);
	161	break;
	162	case PMBUS_VIRT_RESET_VIN_HISTORY:
	163	ret = pmbus_write_word_data(client, 0, ADM1275_PEAK_VIN, 0);
	164	break;
5cf231a3 GR	165	case PMBUS_VIRT_RESET_PIN_HISTORY:
	166	ret = pmbus_write_word_data(client, 0, ADM1276_PEAK_PIN, 0);
	167	break;
c576e30c GR	168	default:
	169	ret = -ENODATA;
	170	break;
	171	}
	172	return ret;
	173	}
	174
c5e67636 GR	175	static int adm1275_read_byte_data(struct i2c_client *client, int page, int reg)
	176	{
	177	const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
	178	const struct adm1275_data *data = to_adm1275_data(info);
	179	int mfr_status, ret;
	180
da8e48ab	181	if (page > 0)
c5e67636 GR	182	return -ENXIO;
	183
	184	switch (reg) {
	185	case PMBUS_STATUS_IOUT:
	186	ret = pmbus_read_byte_data(client, page, PMBUS_STATUS_IOUT);
	187	if (ret < 0)
	188	break;
	189	mfr_status = pmbus_read_byte_data(client, page,
	190	PMBUS_STATUS_MFR_SPECIFIC);
	191	if (mfr_status < 0) {
	192	ret = mfr_status;
	193	break;
	194	}
	195	if (mfr_status & ADM1275_MFR_STATUS_IOUT_WARN2) {
	196	ret \|= data->have_oc_fault ?
	197	PB_IOUT_OC_FAULT : PB_IOUT_UC_FAULT;
	198	}
	199	break;
92711269 GR	200	case PMBUS_STATUS_VOUT:
	201	if (data->id != adm1075) {
	202	ret = -ENODATA;
	203	break;
	204	}
	205	ret = 0;
	206	mfr_status = pmbus_read_byte_data(client, 0,
	207	ADM1075_VAUX_STATUS);
	208	if (mfr_status & ADM1075_VAUX_OV_WARN)
	209	ret \|= PB_VOLTAGE_OV_WARNING;
	210	if (mfr_status & ADM1075_VAUX_UV_WARN)
	211	ret \|= PB_VOLTAGE_UV_WARNING;
	212	break;
c5e67636 GR	213	default:
	214	ret = -ENODATA;
	215	break;
	216	}
	217	return ret;
	218	}
	219
87102808	220	static const struct i2c_device_id adm1275_id[] = {
92711269	221	{ "adm1075", adm1075 },
87102808 GR	222	{ "adm1275", adm1275 },
	223	{ "adm1276", adm1276 },
	224	{ }
	225	};
	226	MODULE_DEVICE_TABLE(i2c, adm1275_id);
	227
83f7649c GR	228	static int adm1275_probe(struct i2c_client *client,
	229	const struct i2c_device_id *id)
	230	{
87102808	231	u8 block_buffer[I2C_SMBUS_BLOCK_MAX + 1];
c5e67636	232	int config, device_config;
3b33ca41	233	int ret;
83f7649c	234	struct pmbus_driver_info *info;
c5e67636	235	struct adm1275_data *data;
87102808	236	const struct i2c_device_id *mid;
83f7649c GR	237
83f7649c GR	238	if (!i2c_check_functionality(client->adapter,
87102808 GR	239	I2C_FUNC_SMBUS_READ_BYTE_DATA
87102808 GR	240	\| I2C_FUNC_SMBUS_BLOCK_DATA))
83f7649c GR	241	return -ENODEV;
83f7649c GR	242
87102808 GR	243	ret = i2c_smbus_read_block_data(client, PMBUS_MFR_ID, block_buffer);
	244	if (ret < 0) {
	245	dev_err(&client->dev, "Failed to read Manufacturer ID\n");
	246	return ret;
	247	}
	248	if (ret != 3 \|\| strncmp(block_buffer, "ADI", 3)) {
	249	dev_err(&client->dev, "Unsupported Manufacturer ID\n");
	250	return -ENODEV;
	251	}
83f7649c	252
87102808 GR	253	ret = i2c_smbus_read_block_data(client, PMBUS_MFR_MODEL, block_buffer);
	254	if (ret < 0) {
	255	dev_err(&client->dev, "Failed to read Manufacturer Model\n");
	256	return ret;
	257	}
	258	for (mid = adm1275_id; mid->name[0]; mid++) {
	259	if (!strncasecmp(mid->name, block_buffer, strlen(mid->name)))
	260	break;
	261	}
	262	if (!mid->name[0]) {
	263	dev_err(&client->dev, "Unsupported device\n");
	264	return -ENODEV;
3b33ca41	265	}
83f7649c	266
87102808 GR	267	if (id->driver_data != mid->driver_data)
	268	dev_notice(&client->dev,
	269	"Device mismatch: Configured %s, detected %s\n",
	270	id->name, mid->name);
	271
	272	config = i2c_smbus_read_byte_data(client, ADM1275_PMON_CONFIG);
	273	if (config < 0)
	274	return config;
	275
c5e67636	276	device_config = i2c_smbus_read_byte_data(client, ADM1275_DEVICE_CONFIG);
87102808 GR	277	if (device_config < 0)
	278	return device_config;
	279
8b313ca7 GR	280	data = devm_kzalloc(&client->dev, sizeof(struct adm1275_data),
8b313ca7 GR	281	GFP_KERNEL);
87102808 GR	282	if (!data)
	283	return -ENOMEM;
	284
	285	data->id = mid->driver_data;
c5e67636 GR	286
	287	info = &data->info;
	288
83f7649c	289	info->pages = 1;
1061d851 GR	290	info->format[PSC_VOLTAGE_IN] = direct;
	291	info->format[PSC_VOLTAGE_OUT] = direct;
	292	info->format[PSC_CURRENT_OUT] = direct;
7e97bbba	293	info->m[PSC_CURRENT_OUT] = 807;
83f7649c GR	294	info->b[PSC_CURRENT_OUT] = 20475;
	295	info->R[PSC_CURRENT_OUT] = -1;
	296	info->func[0] = PMBUS_HAVE_IOUT \| PMBUS_HAVE_STATUS_IOUT;
	297
c576e30c	298	info->read_word_data = adm1275_read_word_data;
c5e67636	299	info->read_byte_data = adm1275_read_byte_data;
c576e30c GR	300	info->write_word_data = adm1275_write_word_data;
c576e30c GR	301
92711269 GR	302	if (data->id == adm1075) {
	303	info->m[PSC_VOLTAGE_IN] = 27169;
	304	info->b[PSC_VOLTAGE_IN] = 0;
	305	info->R[PSC_VOLTAGE_IN] = -1;
	306	info->m[PSC_VOLTAGE_OUT] = 27169;
	307	info->b[PSC_VOLTAGE_OUT] = 0;
	308	info->R[PSC_VOLTAGE_OUT] = -1;
	309	} else if (config & ADM1275_VRANGE) {
7e97bbba	310	info->m[PSC_VOLTAGE_IN] = 19199;
83f7649c GR	311	info->b[PSC_VOLTAGE_IN] = 0;
83f7649c GR	312	info->R[PSC_VOLTAGE_IN] = -2;
7e97bbba	313	info->m[PSC_VOLTAGE_OUT] = 19199;
83f7649c GR	314	info->b[PSC_VOLTAGE_OUT] = 0;
	315	info->R[PSC_VOLTAGE_OUT] = -2;
	316	} else {
7e97bbba	317	info->m[PSC_VOLTAGE_IN] = 6720;
83f7649c GR	318	info->b[PSC_VOLTAGE_IN] = 0;
83f7649c GR	319	info->R[PSC_VOLTAGE_IN] = -1;
7e97bbba	320	info->m[PSC_VOLTAGE_OUT] = 6720;
83f7649c GR	321	info->b[PSC_VOLTAGE_OUT] = 0;
	322	info->R[PSC_VOLTAGE_OUT] = -1;
	323	}
	324
c5e67636 GR	325	if (device_config & ADM1275_IOUT_WARN2_SELECT)
	326	data->have_oc_fault = true;
	327
87102808	328	switch (data->id) {
92711269 GR	329	case adm1075:
	330	info->format[PSC_POWER] = direct;
	331	info->b[PSC_POWER] = 0;
	332	info->R[PSC_POWER] = -1;
	333	switch (config & ADM1075_IRANGE_MASK) {
	334	case ADM1075_IRANGE_25:
	335	info->m[PSC_POWER] = 8549;
	336	info->m[PSC_CURRENT_OUT] = 806;
	337	break;
	338	case ADM1075_IRANGE_50:
	339	info->m[PSC_POWER] = 4279;
	340	info->m[PSC_CURRENT_OUT] = 404;
	341	break;
	342	default:
	343	dev_err(&client->dev, "Invalid input current range");
	344	info->m[PSC_POWER] = 0;
	345	info->m[PSC_CURRENT_OUT] = 0;
	346	break;
	347	}
	348	info->func[0] \|= PMBUS_HAVE_VIN \| PMBUS_HAVE_PIN
	349	\| PMBUS_HAVE_STATUS_INPUT;
	350	if (config & ADM1275_VIN_VOUT_SELECT)
	351	info->func[0] \|=
	352	PMBUS_HAVE_VOUT \| PMBUS_HAVE_STATUS_VOUT;
	353	break;
5cf231a3 GR	354	case adm1275:
	355	if (config & ADM1275_VIN_VOUT_SELECT)
	356	info->func[0] \|=
	357	PMBUS_HAVE_VOUT \| PMBUS_HAVE_STATUS_VOUT;
	358	else
	359	info->func[0] \|=
	360	PMBUS_HAVE_VIN \| PMBUS_HAVE_STATUS_INPUT;
	361	break;
	362	case adm1276:
	363	info->format[PSC_POWER] = direct;
	364	info->func[0] \|= PMBUS_HAVE_VIN \| PMBUS_HAVE_PIN
	365	\| PMBUS_HAVE_STATUS_INPUT;
	366	if (config & ADM1275_VIN_VOUT_SELECT)
	367	info->func[0] \|=
	368	PMBUS_HAVE_VOUT \| PMBUS_HAVE_STATUS_VOUT;
	369	if (config & ADM1275_VRANGE) {
	370	info->m[PSC_POWER] = 6043;
	371	info->b[PSC_POWER] = 0;
	372	info->R[PSC_POWER] = -2;
	373	} else {
	374	info->m[PSC_POWER] = 2115;
	375	info->b[PSC_POWER] = 0;
	376	info->R[PSC_POWER] = -1;
	377	}
	378	break;
	379	}
83f7649c	380
8b313ca7	381	return pmbus_do_probe(client, id, info);
83f7649c GR	382	}
83f7649c GR	383
83f7649c GR	384	static struct i2c_driver adm1275_driver = {
	385	.driver = {
	386	.name = "adm1275",
	387	},
	388	.probe = adm1275_probe,
dd285ad7	389	.remove = pmbus_do_remove,
83f7649c GR	390	.id_table = adm1275_id,
	391	};
	392
f0967eea	393	module_i2c_driver(adm1275_driver);
83f7649c GR	394
83f7649c GR	395	MODULE_AUTHOR("Guenter Roeck");
5cf231a3	396	MODULE_DESCRIPTION("PMBus driver for Analog Devices ADM1275 and compatibles");
83f7649c	397	MODULE_LICENSE("GPL");