[mirror_ubuntu-jammy-kernel.git] / drivers / i2c / busses / i2c-amd756-s4882.c

/*
 * i2c-amd756-s4882.c - i2c-amd756 extras for the Tyan S4882 motherboard
 *
 * Copyright (C) 2004, 2008 Jean Delvare <khali@linux-fr.org>
 *
 * 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.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */
 
/*
 * We select the channels by sending commands to the Philips
 * PCA9556 chip at I2C address 0x18. The main adapter is used for
 * the non-multiplexed part of the bus, and 4 virtual adapters
 * are defined for the multiplexed addresses: 0x50-0x53 (memory
 * module EEPROM) located on channels 1-4, and 0x4c (LM63)
 * located on multiplexed channels 0 and 5-7. We define one
 * virtual adapter per CPU, which corresponds to two multiplexed
 * channels:
 *   CPU0: virtual adapter 1, channels 1 and 0
 *   CPU1: virtual adapter 2, channels 2 and 5
 *   CPU2: virtual adapter 3, channels 3 and 6
 *   CPU3: virtual adapter 4, channels 4 and 7
 */

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/init.h>
#include <linux/i2c.h>
#include <linux/mutex.h>

extern struct i2c_adapter amd756_smbus;

static struct i2c_adapter *s4882_adapter;
static struct i2c_algorithm *s4882_algo;

/* Wrapper access functions for multiplexed SMBus */
static DEFINE_MUTEX(amd756_lock);

static s32 amd756_access_virt0(struct i2c_adapter * adap, u16 addr,
			       unsigned short flags, char read_write,
			       u8 command, int size,
			       union i2c_smbus_data * data)
{
	int error;

	/* We exclude the multiplexed addresses */
	if (addr == 0x4c || (addr & 0xfc) == 0x50 || (addr & 0xfc) == 0x30
	 || addr == 0x18)
		return -ENXIO;

	mutex_lock(&amd756_lock);

	error = amd756_smbus.algo->smbus_xfer(adap, addr, flags, read_write,
					      command, size, data);

	mutex_unlock(&amd756_lock);

	return error;
}

/* We remember the last used channels combination so as to only switch
   channels when it is really needed. This greatly reduces the SMBus
   overhead, but also assumes that nobody will be writing to the PCA9556
   in our back. */
static u8 last_channels;

static inline s32 amd756_access_channel(struct i2c_adapter * adap, u16 addr,
					unsigned short flags, char read_write,
					u8 command, int size,
					union i2c_smbus_data * data,
					u8 channels)
{
	int error;

	/* We exclude the non-multiplexed addresses */
	if (addr != 0x4c && (addr & 0xfc) != 0x50 && (addr & 0xfc) != 0x30)
		return -ENXIO;

	mutex_lock(&amd756_lock);

	if (last_channels != channels) {
		union i2c_smbus_data mplxdata;
		mplxdata.byte = channels;

		error = amd756_smbus.algo->smbus_xfer(adap, 0x18, 0,
						      I2C_SMBUS_WRITE, 0x01,
						      I2C_SMBUS_BYTE_DATA,
						      &mplxdata);
		if (error)
			goto UNLOCK;
		last_channels = channels;
	}
	error = amd756_smbus.algo->smbus_xfer(adap, addr, flags, read_write,
					      command, size, data);

UNLOCK:
	mutex_unlock(&amd756_lock);
	return error;
}

static s32 amd756_access_virt1(struct i2c_adapter * adap, u16 addr,
			       unsigned short flags, char read_write,
			       u8 command, int size,
			       union i2c_smbus_data * data)
{
	/* CPU0: channels 1 and 0 enabled */
	return amd756_access_channel(adap, addr, flags, read_write, command,
				     size, data, 0x03);
}

static s32 amd756_access_virt2(struct i2c_adapter * adap, u16 addr,
			       unsigned short flags, char read_write,
			       u8 command, int size,
			       union i2c_smbus_data * data)
{
	/* CPU1: channels 2 and 5 enabled */
	return amd756_access_channel(adap, addr, flags, read_write, command,
				     size, data, 0x24);
}

static s32 amd756_access_virt3(struct i2c_adapter * adap, u16 addr,
			       unsigned short flags, char read_write,
			       u8 command, int size,
			       union i2c_smbus_data * data)
{
	/* CPU2: channels 3 and 6 enabled */
	return amd756_access_channel(adap, addr, flags, read_write, command,
				     size, data, 0x48);
}

static s32 amd756_access_virt4(struct i2c_adapter * adap, u16 addr,
			       unsigned short flags, char read_write,
			       u8 command, int size,
			       union i2c_smbus_data * data)
{
	/* CPU3: channels 4 and 7 enabled */
	return amd756_access_channel(adap, addr, flags, read_write, command,
				     size, data, 0x90);
}

static int __init amd756_s4882_init(void)
{
	int i, error;
	union i2c_smbus_data ioconfig;

	if (!amd756_smbus.dev.parent)
		return -ENODEV;

	/* Configure the PCA9556 multiplexer */
	ioconfig.byte = 0x00; /* All I/O to output mode */
	error = i2c_smbus_xfer(&amd756_smbus, 0x18, 0, I2C_SMBUS_WRITE, 0x03,
			       I2C_SMBUS_BYTE_DATA, &ioconfig);
	if (error) {
		dev_err(&amd756_smbus.dev, "PCA9556 configuration failed\n");
		error = -EIO;
		goto ERROR0;
	}

	/* Unregister physical bus */
	error = i2c_del_adapter(&amd756_smbus);
	if (error) {
		dev_err(&amd756_smbus.dev, "Physical bus removal failed\n");
		goto ERROR0;
	}

	printk(KERN_INFO "Enabling SMBus multiplexing for Tyan S4882\n");
	/* Define the 5 virtual adapters and algorithms structures */
	if (!(s4882_adapter = kzalloc(5 * sizeof(struct i2c_adapter),
				      GFP_KERNEL))) {
		error = -ENOMEM;
		goto ERROR1;
	}
	if (!(s4882_algo = kzalloc(5 * sizeof(struct i2c_algorithm),
				   GFP_KERNEL))) {
		error = -ENOMEM;
		goto ERROR2;
	}

	/* Fill in the new structures */
	s4882_algo[0] = *(amd756_smbus.algo);
	s4882_algo[0].smbus_xfer = amd756_access_virt0;
	s4882_adapter[0] = amd756_smbus;
	s4882_adapter[0].algo = s4882_algo;
	s4882_adapter[0].dev.parent = amd756_smbus.dev.parent;
	for (i = 1; i < 5; i++) {
		s4882_algo[i] = *(amd756_smbus.algo);
		s4882_adapter[i] = amd756_smbus;
		snprintf(s4882_adapter[i].name, sizeof(s4882_adapter[i].name),
			 "SMBus 8111 adapter (CPU%d)", i-1);
		s4882_adapter[i].algo = s4882_algo+i;
		s4882_adapter[i].dev.parent = amd756_smbus.dev.parent;
	}
	s4882_algo[1].smbus_xfer = amd756_access_virt1;
	s4882_algo[2].smbus_xfer = amd756_access_virt2;
	s4882_algo[3].smbus_xfer = amd756_access_virt3;
	s4882_algo[4].smbus_xfer = amd756_access_virt4;

	/* Register virtual adapters */
	for (i = 0; i < 5; i++) {
		error = i2c_add_adapter(s4882_adapter+i);
		if (error) {
			printk(KERN_ERR "i2c-amd756-s4882: "
			       "Virtual adapter %d registration "
			       "failed, module not inserted\n", i);
			for (i--; i >= 0; i--)
				i2c_del_adapter(s4882_adapter+i);
			goto ERROR3;
		}
	}

	return 0;

ERROR3:
	kfree(s4882_algo);
	s4882_algo = NULL;
ERROR2:
	kfree(s4882_adapter);
	s4882_adapter = NULL;
ERROR1:
	/* Restore physical bus */
	i2c_add_adapter(&amd756_smbus);
ERROR0:
	return error;
}

static void __exit amd756_s4882_exit(void)
{
	if (s4882_adapter) {
		int i;

		for (i = 0; i < 5; i++)
			i2c_del_adapter(s4882_adapter+i);
		kfree(s4882_adapter);
		s4882_adapter = NULL;
	}
	kfree(s4882_algo);
	s4882_algo = NULL;

	/* Restore physical bus */
	if (i2c_add_adapter(&amd756_smbus))
		printk(KERN_ERR "i2c-amd756-s4882: "
		       "Physical bus restoration failed\n");
}

MODULE_AUTHOR("Jean Delvare <khali@linux-fr.org>");
MODULE_DESCRIPTION("S4882 SMBus multiplexing");
MODULE_LICENSE("GPL");

module_init(amd756_s4882_init);
module_exit(amd756_s4882_exit);
Commit	Line	Data
1da177e4 LT	1	/*
	2	* i2c-amd756-s4882.c - i2c-amd756 extras for the Tyan S4882 motherboard
	3	*
ee56d977	4	* Copyright (C) 2004, 2008 Jean Delvare <khali@linux-fr.org>
1da177e4 LT	5	*
	6	* This program is free software; you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License as published by
	8	* the Free Software Foundation; either version 2 of the License, or
	9	* (at your option) any later version.
	10	*
	11	* This program is distributed in the hope that it will be useful,
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	* GNU General Public License for more details.
	15	*
	16	* You should have received a copy of the GNU General Public License
	17	* along with this program; if not, write to the Free Software
	18	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
	19	*/
	20
	21	/*
	22	* We select the channels by sending commands to the Philips
	23	* PCA9556 chip at I2C address 0x18. The main adapter is used for
	24	* the non-multiplexed part of the bus, and 4 virtual adapters
	25	* are defined for the multiplexed addresses: 0x50-0x53 (memory
	26	* module EEPROM) located on channels 1-4, and 0x4c (LM63)
	27	* located on multiplexed channels 0 and 5-7. We define one
	28	* virtual adapter per CPU, which corresponds to two multiplexed
	29	* channels:
	30	* CPU0: virtual adapter 1, channels 1 and 0
	31	* CPU1: virtual adapter 2, channels 2 and 5
	32	* CPU2: virtual adapter 3, channels 3 and 6
	33	* CPU3: virtual adapter 4, channels 4 and 7
	34	*/
	35
	36	#include <linux/module.h>
	37	#include <linux/kernel.h>
	38	#include <linux/slab.h>
	39	#include <linux/init.h>
	40	#include <linux/i2c.h>
5c085d36	41	#include <linux/mutex.h>
1da177e4 LT	42
	43	extern struct i2c_adapter amd756_smbus;
	44
	45	static struct i2c_adapter *s4882_adapter;
	46	static struct i2c_algorithm *s4882_algo;
	47
	48	/* Wrapper access functions for multiplexed SMBus */
d7d2fe38	49	static DEFINE_MUTEX(amd756_lock);
1da177e4 LT	50
	51	static s32 amd756_access_virt0(struct i2c_adapter * adap, u16 addr,
	52	unsigned short flags, char read_write,
	53	u8 command, int size,
	54	union i2c_smbus_data * data)
	55	{
	56	int error;
	57
	58	/* We exclude the multiplexed addresses */
	59	if (addr == 0x4c \|\| (addr & 0xfc) == 0x50 \|\| (addr & 0xfc) == 0x30
	60	\|\| addr == 0x18)
97140342	61	return -ENXIO;
1da177e4	62
5c085d36	63	mutex_lock(&amd756_lock);
1da177e4 LT	64
	65	error = amd756_smbus.algo->smbus_xfer(adap, addr, flags, read_write,
	66	command, size, data);
	67
5c085d36	68	mutex_unlock(&amd756_lock);
1da177e4 LT	69
	70	return error;
	71	}
	72
	73	/* We remember the last used channels combination so as to only switch
	74	channels when it is really needed. This greatly reduces the SMBus
	75	overhead, but also assumes that nobody will be writing to the PCA9556
	76	in our back. */
	77	static u8 last_channels;
	78
	79	static inline s32 amd756_access_channel(struct i2c_adapter * adap, u16 addr,
	80	unsigned short flags, char read_write,
	81	u8 command, int size,
	82	union i2c_smbus_data * data,
	83	u8 channels)
	84	{
	85	int error;
	86
	87	/* We exclude the non-multiplexed addresses */
	88	if (addr != 0x4c && (addr & 0xfc) != 0x50 && (addr & 0xfc) != 0x30)
97140342	89	return -ENXIO;
1da177e4	90
5c085d36	91	mutex_lock(&amd756_lock);
1da177e4 LT	92
	93	if (last_channels != channels) {
	94	union i2c_smbus_data mplxdata;
	95	mplxdata.byte = channels;
	96
	97	error = amd756_smbus.algo->smbus_xfer(adap, 0x18, 0,
	98	I2C_SMBUS_WRITE, 0x01,
	99	I2C_SMBUS_BYTE_DATA,
	100	&mplxdata);
	101	if (error)
	102	goto UNLOCK;
	103	last_channels = channels;
	104	}
	105	error = amd756_smbus.algo->smbus_xfer(adap, addr, flags, read_write,
	106	command, size, data);
	107
	108	UNLOCK:
5c085d36	109	mutex_unlock(&amd756_lock);
1da177e4 LT	110	return error;
	111	}
	112
	113	static s32 amd756_access_virt1(struct i2c_adapter * adap, u16 addr,
	114	unsigned short flags, char read_write,
	115	u8 command, int size,
	116	union i2c_smbus_data * data)
	117	{
	118	/* CPU0: channels 1 and 0 enabled */
	119	return amd756_access_channel(adap, addr, flags, read_write, command,
	120	size, data, 0x03);
	121	}
	122
	123	static s32 amd756_access_virt2(struct i2c_adapter * adap, u16 addr,
	124	unsigned short flags, char read_write,
	125	u8 command, int size,
	126	union i2c_smbus_data * data)
	127	{
	128	/* CPU1: channels 2 and 5 enabled */
	129	return amd756_access_channel(adap, addr, flags, read_write, command,
	130	size, data, 0x24);
	131	}
	132
	133	static s32 amd756_access_virt3(struct i2c_adapter * adap, u16 addr,
	134	unsigned short flags, char read_write,
	135	u8 command, int size,
	136	union i2c_smbus_data * data)
	137	{
	138	/* CPU2: channels 3 and 6 enabled */
	139	return amd756_access_channel(adap, addr, flags, read_write, command,
	140	size, data, 0x48);
	141	}
	142
	143	static s32 amd756_access_virt4(struct i2c_adapter * adap, u16 addr,
	144	unsigned short flags, char read_write,
	145	u8 command, int size,
	146	union i2c_smbus_data * data)
	147	{
	148	/* CPU3: channels 4 and 7 enabled */
	149	return amd756_access_channel(adap, addr, flags, read_write, command,
	150	size, data, 0x90);
	151	}
	152
	153	static int __init amd756_s4882_init(void)
	154	{
	155	int i, error;
	156	union i2c_smbus_data ioconfig;
	157
399d6b26 JD	158	if (!amd756_smbus.dev.parent)
	159	return -ENODEV;
	160
bd4bc3db JD	161	/* Configure the PCA9556 multiplexer */
	162	ioconfig.byte = 0x00; /* All I/O to output mode */
	163	error = i2c_smbus_xfer(&amd756_smbus, 0x18, 0, I2C_SMBUS_WRITE, 0x03,
	164	I2C_SMBUS_BYTE_DATA, &ioconfig);
	165	if (error) {
	166	dev_err(&amd756_smbus.dev, "PCA9556 configuration failed\n");
	167	error = -EIO;
	168	goto ERROR0;
	169	}
	170
1da177e4 LT	171	/* Unregister physical bus */
	172	error = i2c_del_adapter(&amd756_smbus);
	173	if (error) {
399d6b26	174	dev_err(&amd756_smbus.dev, "Physical bus removal failed\n");
1da177e4 LT	175	goto ERROR0;
	176	}
	177
	178	printk(KERN_INFO "Enabling SMBus multiplexing for Tyan S4882\n");
1da177e4	179	/* Define the 5 virtual adapters and algorithms structures */
deb875c7	180	if (!(s4882_adapter = kzalloc(5 * sizeof(struct i2c_adapter),
1da177e4 LT	181	GFP_KERNEL))) {
	182	error = -ENOMEM;
	183	goto ERROR1;
	184	}
deb875c7	185	if (!(s4882_algo = kzalloc(5 * sizeof(struct i2c_algorithm),
1da177e4 LT	186	GFP_KERNEL))) {
	187	error = -ENOMEM;
	188	goto ERROR2;
	189	}
	190
	191	/* Fill in the new structures */
	192	s4882_algo[0] = *(amd756_smbus.algo);
	193	s4882_algo[0].smbus_xfer = amd756_access_virt0;
	194	s4882_adapter[0] = amd756_smbus;
	195	s4882_adapter[0].algo = s4882_algo;
12a917f6	196	s4882_adapter[0].dev.parent = amd756_smbus.dev.parent;
1da177e4 LT	197	for (i = 1; i < 5; i++) {
	198	s4882_algo[i] = *(amd756_smbus.algo);
	199	s4882_adapter[i] = amd756_smbus;
66c7acf6 JD	200	snprintf(s4882_adapter[i].name, sizeof(s4882_adapter[i].name),
66c7acf6 JD	201	"SMBus 8111 adapter (CPU%d)", i-1);
1da177e4	202	s4882_adapter[i].algo = s4882_algo+i;
12a917f6	203	s4882_adapter[i].dev.parent = amd756_smbus.dev.parent;
1da177e4 LT	204	}
	205	s4882_algo[1].smbus_xfer = amd756_access_virt1;
	206	s4882_algo[2].smbus_xfer = amd756_access_virt2;
	207	s4882_algo[3].smbus_xfer = amd756_access_virt3;
	208	s4882_algo[4].smbus_xfer = amd756_access_virt4;
	209
1da177e4 LT	210	/* Register virtual adapters */
	211	for (i = 0; i < 5; i++) {
	212	error = i2c_add_adapter(s4882_adapter+i);
	213	if (error) {
bd4bc3db	214	printk(KERN_ERR "i2c-amd756-s4882: "
1da177e4 LT	215	"Virtual adapter %d registration "
	216	"failed, module not inserted\n", i);
	217	for (i--; i >= 0; i--)
	218	i2c_del_adapter(s4882_adapter+i);
	219	goto ERROR3;
	220	}
	221	}
	222
	223	return 0;
	224
	225	ERROR3:
	226	kfree(s4882_algo);
	227	s4882_algo = NULL;
	228	ERROR2:
	229	kfree(s4882_adapter);
	230	s4882_adapter = NULL;
	231	ERROR1:
ee56d977 JD	232	/* Restore physical bus */
ee56d977 JD	233	i2c_add_adapter(&amd756_smbus);
1da177e4 LT	234	ERROR0:
	235	return error;
	236	}
	237
	238	static void __exit amd756_s4882_exit(void)
	239	{
	240	if (s4882_adapter) {
	241	int i;
	242
	243	for (i = 0; i < 5; i++)
	244	i2c_del_adapter(s4882_adapter+i);
	245	kfree(s4882_adapter);
	246	s4882_adapter = NULL;
	247	}
6044ec88 JJ	248	kfree(s4882_algo);
6044ec88 JJ	249	s4882_algo = NULL;
1da177e4 LT	250
	251	/* Restore physical bus */
	252	if (i2c_add_adapter(&amd756_smbus))
bd4bc3db JD	253	printk(KERN_ERR "i2c-amd756-s4882: "
bd4bc3db JD	254	"Physical bus restoration failed\n");
1da177e4 LT	255	}
	256
	257	MODULE_AUTHOR("Jean Delvare <khali@linux-fr.org>");
	258	MODULE_DESCRIPTION("S4882 SMBus multiplexing");
	259	MODULE_LICENSE("GPL");
	260
	261	module_init(amd756_s4882_init);
	262	module_exit(amd756_s4882_exit);