1/*
2 * i2c-nforce2-s4985.c - i2c-nforce2 extras for the Tyan S4985 motherboard
3 *
4 * Copyright (C) 2008 Jean Delvare <jdelvare@suse.de>
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
17/*
18 * We select the channels by sending commands to the Philips
19 * PCA9556 chip at I2C address 0x18. The main adapter is used for
20 * the non-multiplexed part of the bus, and 4 virtual adapters
21 * are defined for the multiplexed addresses: 0x50-0x53 (memory
22 * module EEPROM) located on channels 1-4. We define one virtual
23 * adapter per CPU, which corresponds to one multiplexed channel:
24 *   CPU0: virtual adapter 1, channel 1
25 *   CPU1: virtual adapter 2, channel 2
26 *   CPU2: virtual adapter 3, channel 3
27 *   CPU3: virtual adapter 4, channel 4
28 */
29
30#include <linux/module.h>
31#include <linux/kernel.h>
32#include <linux/slab.h>
33#include <linux/init.h>
34#include <linux/i2c.h>
35#include <linux/mutex.h>
36
37extern struct i2c_adapter *nforce2_smbus;
38
39static struct i2c_adapter *s4985_adapter;
40static struct i2c_algorithm *s4985_algo;
41
42/* Wrapper access functions for multiplexed SMBus */
43static DEFINE_MUTEX(nforce2_lock);
44
45static s32 nforce2_access_virt0(struct i2c_adapter *adap, u16 addr,
46				unsigned short flags, char read_write,
47				u8 command, int size,
48				union i2c_smbus_data *data)
49{
50	int error;
51
52	/* We exclude the multiplexed addresses */
53	if ((addr & 0xfc) == 0x50 || (addr & 0xfc) == 0x30
54	 || addr == 0x18)
55		return -ENXIO;
56
57	mutex_lock(&nforce2_lock);
58	error = nforce2_smbus->algo->smbus_xfer(adap, addr, flags, read_write,
59						command, size, data);
60	mutex_unlock(&nforce2_lock);
61
62	return error;
63}
64
65/* We remember the last used channels combination so as to only switch
66   channels when it is really needed. This greatly reduces the SMBus
67   overhead, but also assumes that nobody will be writing to the PCA9556
68   in our back. */
69static u8 last_channels;
70
71static inline s32 nforce2_access_channel(struct i2c_adapter *adap, u16 addr,
72					 unsigned short flags, char read_write,
73					 u8 command, int size,
74					 union i2c_smbus_data *data,
75					 u8 channels)
76{
77	int error;
78
79	/* We exclude the non-multiplexed addresses */
80	if ((addr & 0xfc) != 0x50 && (addr & 0xfc) != 0x30)
81		return -ENXIO;
82
83	mutex_lock(&nforce2_lock);
84	if (last_channels != channels) {
85		union i2c_smbus_data mplxdata;
86		mplxdata.byte = channels;
87
88		error = nforce2_smbus->algo->smbus_xfer(adap, 0x18, 0,
89							I2C_SMBUS_WRITE, 0x01,
90							I2C_SMBUS_BYTE_DATA,
91							&mplxdata);
92		if (error)
93			goto UNLOCK;
94		last_channels = channels;
95	}
96	error = nforce2_smbus->algo->smbus_xfer(adap, addr, flags, read_write,
97						command, size, data);
98
99UNLOCK:
100	mutex_unlock(&nforce2_lock);
101	return error;
102}
103
104static s32 nforce2_access_virt1(struct i2c_adapter *adap, u16 addr,
105				unsigned short flags, char read_write,
106				u8 command, int size,
107				union i2c_smbus_data *data)
108{
109	/* CPU0: channel 1 enabled */
110	return nforce2_access_channel(adap, addr, flags, read_write, command,
111				      size, data, 0x02);
112}
113
114static s32 nforce2_access_virt2(struct i2c_adapter *adap, u16 addr,
115				unsigned short flags, char read_write,
116				u8 command, int size,
117				union i2c_smbus_data *data)
118{
119	/* CPU1: channel 2 enabled */
120	return nforce2_access_channel(adap, addr, flags, read_write, command,
121				      size, data, 0x04);
122}
123
124static s32 nforce2_access_virt3(struct i2c_adapter *adap, u16 addr,
125				unsigned short flags, char read_write,
126				u8 command, int size,
127				union i2c_smbus_data *data)
128{
129	/* CPU2: channel 3 enabled */
130	return nforce2_access_channel(adap, addr, flags, read_write, command,
131				      size, data, 0x08);
132}
133
134static s32 nforce2_access_virt4(struct i2c_adapter *adap, u16 addr,
135				unsigned short flags, char read_write,
136				u8 command, int size,
137				union i2c_smbus_data *data)
138{
139	/* CPU3: channel 4 enabled */
140	return nforce2_access_channel(adap, addr, flags, read_write, command,
141				      size, data, 0x10);
142}
143
144static int __init nforce2_s4985_init(void)
145{
146	int i, error;
147	union i2c_smbus_data ioconfig;
148
149	if (!nforce2_smbus)
150		return -ENODEV;
151
152	/* Configure the PCA9556 multiplexer */
153	ioconfig.byte = 0x00; /* All I/O to output mode */
154	error = i2c_smbus_xfer(nforce2_smbus, 0x18, 0, I2C_SMBUS_WRITE, 0x03,
155			       I2C_SMBUS_BYTE_DATA, &ioconfig);
156	if (error) {
157		dev_err(&nforce2_smbus->dev, "PCA9556 configuration failed\n");
158		error = -EIO;
159		goto ERROR0;
160	}
161
162	/* Unregister physical bus */
163	i2c_del_adapter(nforce2_smbus);
164
165	printk(KERN_INFO "Enabling SMBus multiplexing for Tyan S4985\n");
166	/* Define the 5 virtual adapters and algorithms structures */
167	s4985_adapter = kzalloc(5 * sizeof(struct i2c_adapter), GFP_KERNEL);
168	if (!s4985_adapter) {
169		error = -ENOMEM;
170		goto ERROR1;
171	}
172	s4985_algo = kzalloc(5 * sizeof(struct i2c_algorithm), GFP_KERNEL);
173	if (!s4985_algo) {
174		error = -ENOMEM;
175		goto ERROR2;
176	}
177
178	/* Fill in the new structures */
179	s4985_algo[0] = *(nforce2_smbus->algo);
180	s4985_algo[0].smbus_xfer = nforce2_access_virt0;
181	s4985_adapter[0] = *nforce2_smbus;
182	s4985_adapter[0].algo = s4985_algo;
183	s4985_adapter[0].dev.parent = nforce2_smbus->dev.parent;
184	for (i = 1; i < 5; i++) {
185		s4985_algo[i] = *(nforce2_smbus->algo);
186		s4985_adapter[i] = *nforce2_smbus;
187		snprintf(s4985_adapter[i].name, sizeof(s4985_adapter[i].name),
188			 "SMBus nForce2 adapter (CPU%d)", i - 1);
189		s4985_adapter[i].algo = s4985_algo + i;
190		s4985_adapter[i].dev.parent = nforce2_smbus->dev.parent;
191	}
192	s4985_algo[1].smbus_xfer = nforce2_access_virt1;
193	s4985_algo[2].smbus_xfer = nforce2_access_virt2;
194	s4985_algo[3].smbus_xfer = nforce2_access_virt3;
195	s4985_algo[4].smbus_xfer = nforce2_access_virt4;
196
197	/* Register virtual adapters */
198	for (i = 0; i < 5; i++) {
199		error = i2c_add_adapter(s4985_adapter + i);
200		if (error) {
201			printk(KERN_ERR "i2c-nforce2-s4985: "
202			       "Virtual adapter %d registration "
203			       "failed, module not inserted\n", i);
204			for (i--; i >= 0; i--)
205				i2c_del_adapter(s4985_adapter + i);
206			goto ERROR3;
207		}
208	}
209
210	return 0;
211
212ERROR3:
213	kfree(s4985_algo);
214	s4985_algo = NULL;
215ERROR2:
216	kfree(s4985_adapter);
217	s4985_adapter = NULL;
218ERROR1:
219	/* Restore physical bus */
220	i2c_add_adapter(nforce2_smbus);
221ERROR0:
222	return error;
223}
224
225static void __exit nforce2_s4985_exit(void)
226{
227	if (s4985_adapter) {
228		int i;
229
230		for (i = 0; i < 5; i++)
231			i2c_del_adapter(s4985_adapter+i);
232		kfree(s4985_adapter);
233		s4985_adapter = NULL;
234	}
235	kfree(s4985_algo);
236	s4985_algo = NULL;
237
238	/* Restore physical bus */
239	if (i2c_add_adapter(nforce2_smbus))
240		printk(KERN_ERR "i2c-nforce2-s4985: "
241		       "Physical bus restoration failed\n");
242}
243
244MODULE_AUTHOR("Jean Delvare <jdelvare@suse.de>");
245MODULE_DESCRIPTION("S4985 SMBus multiplexing");
246MODULE_LICENSE("GPL");
247
248module_init(nforce2_s4985_init);
249module_exit(nforce2_s4985_exit);
250