[deliverable/linux.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 <jdelvare@suse.de>
 *
 * 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 */
	i2c_del_adapter(&amd756_smbus);

	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 <jdelvare@suse.de>");
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	*
7c81c60f	4	* Copyright (C) 2004, 2008 Jean Delvare <jdelvare@suse.de>
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	171	/* Unregister physical bus */
bf51a8c5	172	i2c_del_adapter(&amd756_smbus);
1da177e4 LT	173
1da177e4 LT	174	printk(KERN_INFO "Enabling SMBus multiplexing for Tyan S4882\n");
1da177e4	175	/* Define the 5 virtual adapters and algorithms structures */
deb875c7	176	if (!(s4882_adapter = kzalloc(5 * sizeof(struct i2c_adapter),
1da177e4 LT	177	GFP_KERNEL))) {
	178	error = -ENOMEM;
	179	goto ERROR1;
	180	}
deb875c7	181	if (!(s4882_algo = kzalloc(5 * sizeof(struct i2c_algorithm),
1da177e4 LT	182	GFP_KERNEL))) {
	183	error = -ENOMEM;
	184	goto ERROR2;
	185	}
	186
	187	/* Fill in the new structures */
	188	s4882_algo[0] = *(amd756_smbus.algo);
	189	s4882_algo[0].smbus_xfer = amd756_access_virt0;
	190	s4882_adapter[0] = amd756_smbus;
	191	s4882_adapter[0].algo = s4882_algo;
12a917f6	192	s4882_adapter[0].dev.parent = amd756_smbus.dev.parent;
1da177e4 LT	193	for (i = 1; i < 5; i++) {
	194	s4882_algo[i] = *(amd756_smbus.algo);
	195	s4882_adapter[i] = amd756_smbus;
66c7acf6 JD	196	snprintf(s4882_adapter[i].name, sizeof(s4882_adapter[i].name),
66c7acf6 JD	197	"SMBus 8111 adapter (CPU%d)", i-1);
1da177e4	198	s4882_adapter[i].algo = s4882_algo+i;
12a917f6	199	s4882_adapter[i].dev.parent = amd756_smbus.dev.parent;
1da177e4 LT	200	}
	201	s4882_algo[1].smbus_xfer = amd756_access_virt1;
	202	s4882_algo[2].smbus_xfer = amd756_access_virt2;
	203	s4882_algo[3].smbus_xfer = amd756_access_virt3;
	204	s4882_algo[4].smbus_xfer = amd756_access_virt4;
	205
1da177e4 LT	206	/* Register virtual adapters */
	207	for (i = 0; i < 5; i++) {
	208	error = i2c_add_adapter(s4882_adapter+i);
	209	if (error) {
bd4bc3db	210	printk(KERN_ERR "i2c-amd756-s4882: "
1da177e4 LT	211	"Virtual adapter %d registration "
	212	"failed, module not inserted\n", i);
	213	for (i--; i >= 0; i--)
	214	i2c_del_adapter(s4882_adapter+i);
	215	goto ERROR3;
	216	}
	217	}
	218
	219	return 0;
	220
	221	ERROR3:
	222	kfree(s4882_algo);
	223	s4882_algo = NULL;
	224	ERROR2:
	225	kfree(s4882_adapter);
	226	s4882_adapter = NULL;
	227	ERROR1:
ee56d977 JD	228	/* Restore physical bus */
ee56d977 JD	229	i2c_add_adapter(&amd756_smbus);
1da177e4 LT	230	ERROR0:
	231	return error;
	232	}
	233
	234	static void __exit amd756_s4882_exit(void)
	235	{
	236	if (s4882_adapter) {
	237	int i;
	238
	239	for (i = 0; i < 5; i++)
	240	i2c_del_adapter(s4882_adapter+i);
	241	kfree(s4882_adapter);
	242	s4882_adapter = NULL;
	243	}
6044ec88 JJ	244	kfree(s4882_algo);
6044ec88 JJ	245	s4882_algo = NULL;
1da177e4 LT	246
	247	/* Restore physical bus */
	248	if (i2c_add_adapter(&amd756_smbus))
bd4bc3db JD	249	printk(KERN_ERR "i2c-amd756-s4882: "
bd4bc3db JD	250	"Physical bus restoration failed\n");
1da177e4 LT	251	}
1da177e4 LT	252
7c81c60f	253	MODULE_AUTHOR("Jean Delvare <jdelvare@suse.de>");
1da177e4 LT	254	MODULE_DESCRIPTION("S4882 SMBus multiplexing");
	255	MODULE_LICENSE("GPL");
	256
	257	module_init(amd756_s4882_init);
	258	module_exit(amd756_s4882_exit);