diff options
Diffstat (limited to 'drivers/i2c/algos')
-rw-r--r-- | drivers/i2c/algos/Kconfig | 70 | ||||
-rw-r--r-- | drivers/i2c/algos/Makefile | 14 | ||||
-rw-r--r-- | drivers/i2c/algos/i2c-algo-bit.c | 573 | ||||
-rw-r--r-- | drivers/i2c/algos/i2c-algo-ite.c | 812 | ||||
-rw-r--r-- | drivers/i2c/algos/i2c-algo-ite.h | 117 | ||||
-rw-r--r-- | drivers/i2c/algos/i2c-algo-pca.c | 399 | ||||
-rw-r--r-- | drivers/i2c/algos/i2c-algo-pca.h | 26 | ||||
-rw-r--r-- | drivers/i2c/algos/i2c-algo-pcf.c | 507 | ||||
-rw-r--r-- | drivers/i2c/algos/i2c-algo-pcf.h | 76 | ||||
-rw-r--r-- | drivers/i2c/algos/i2c-algo-sgi.c | 189 | ||||
-rw-r--r-- | drivers/i2c/algos/i2c-algo-sibyte.c | 222 |
11 files changed, 3005 insertions, 0 deletions
diff --git a/drivers/i2c/algos/Kconfig b/drivers/i2c/algos/Kconfig new file mode 100644 index 000000000000..30408015d231 --- /dev/null +++ b/drivers/i2c/algos/Kconfig | |||
@@ -0,0 +1,70 @@ | |||
1 | # | ||
2 | # Character device configuration | ||
3 | # | ||
4 | |||
5 | menu "I2C Algorithms" | ||
6 | depends on I2C | ||
7 | |||
8 | config I2C_ALGOBIT | ||
9 | tristate "I2C bit-banging interfaces" | ||
10 | depends on I2C | ||
11 | help | ||
12 | This allows you to use a range of I2C adapters called bit-banging | ||
13 | adapters. Say Y if you own an I2C adapter belonging to this class | ||
14 | and then say Y to the specific driver for you adapter below. | ||
15 | |||
16 | This support is also available as a module. If so, the module | ||
17 | will be called i2c-algo-bit. | ||
18 | |||
19 | config I2C_ALGOPCF | ||
20 | tristate "I2C PCF 8584 interfaces" | ||
21 | depends on I2C | ||
22 | help | ||
23 | This allows you to use a range of I2C adapters called PCF adapters. | ||
24 | Say Y if you own an I2C adapter belonging to this class and then say | ||
25 | Y to the specific driver for you adapter below. | ||
26 | |||
27 | This support is also available as a module. If so, the module | ||
28 | will be called i2c-algo-pcf. | ||
29 | |||
30 | config I2C_ALGOPCA | ||
31 | tristate "I2C PCA 9564 interfaces" | ||
32 | depends on I2C | ||
33 | help | ||
34 | This allows you to use a range of I2C adapters called PCA adapters. | ||
35 | Say Y if you own an I2C adapter belonging to this class and then say | ||
36 | Y to the specific driver for you adapter below. | ||
37 | |||
38 | This support is also available as a module. If so, the module | ||
39 | will be called i2c-algo-pca. | ||
40 | |||
41 | config I2C_ALGOITE | ||
42 | tristate "ITE I2C Algorithm" | ||
43 | depends on MIPS_ITE8172 && I2C | ||
44 | help | ||
45 | This supports the use of the ITE8172 I2C interface found on some MIPS | ||
46 | systems. Say Y if you have one of these. You should also say Y for | ||
47 | the ITE I2C peripheral driver support below. | ||
48 | |||
49 | This support is also available as a module. If so, the module | ||
50 | will be called i2c-algo-ite. | ||
51 | |||
52 | config I2C_ALGO8XX | ||
53 | tristate "MPC8xx CPM I2C interface" | ||
54 | depends on 8xx && I2C | ||
55 | |||
56 | config I2C_ALGO_SIBYTE | ||
57 | tristate "SiByte SMBus interface" | ||
58 | depends on SIBYTE_SB1xxx_SOC && I2C | ||
59 | help | ||
60 | Supports the SiByte SOC on-chip I2C interfaces (2 channels). | ||
61 | |||
62 | config I2C_ALGO_SGI | ||
63 | tristate "I2C SGI interfaces" | ||
64 | depends on I2C && (SGI_IP22 || SGI_IP32 || X86_VISWS) | ||
65 | help | ||
66 | Supports the SGI interfaces like the ones found on SGI Indy VINO | ||
67 | or SGI O2 MACE. | ||
68 | |||
69 | endmenu | ||
70 | |||
diff --git a/drivers/i2c/algos/Makefile b/drivers/i2c/algos/Makefile new file mode 100644 index 000000000000..867fe1f67401 --- /dev/null +++ b/drivers/i2c/algos/Makefile | |||
@@ -0,0 +1,14 @@ | |||
1 | # | ||
2 | # Makefile for the i2c algorithms | ||
3 | # | ||
4 | |||
5 | obj-$(CONFIG_I2C_ALGOBIT) += i2c-algo-bit.o | ||
6 | obj-$(CONFIG_I2C_ALGOPCF) += i2c-algo-pcf.o | ||
7 | obj-$(CONFIG_I2C_ALGOPCA) += i2c-algo-pca.o | ||
8 | obj-$(CONFIG_I2C_ALGOITE) += i2c-algo-ite.o | ||
9 | obj-$(CONFIG_I2C_ALGO_SIBYTE) += i2c-algo-sibyte.o | ||
10 | obj-$(CONFIG_I2C_ALGO_SGI) += i2c-algo-sgi.o | ||
11 | |||
12 | ifeq ($(CONFIG_I2C_DEBUG_ALGO),y) | ||
13 | EXTRA_CFLAGS += -DDEBUG | ||
14 | endif | ||
diff --git a/drivers/i2c/algos/i2c-algo-bit.c b/drivers/i2c/algos/i2c-algo-bit.c new file mode 100644 index 000000000000..fb5b732238ed --- /dev/null +++ b/drivers/i2c/algos/i2c-algo-bit.c | |||
@@ -0,0 +1,573 @@ | |||
1 | /* ------------------------------------------------------------------------- */ | ||
2 | /* i2c-algo-bit.c i2c driver algorithms for bit-shift adapters */ | ||
3 | /* ------------------------------------------------------------------------- */ | ||
4 | /* Copyright (C) 1995-2000 Simon G. Vogl | ||
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 | /* With some changes from Frodo Looijaard <frodol@dds.nl>, Kyösti Mälkki | ||
22 | <kmalkki@cc.hut.fi> and Jean Delvare <khali@linux-fr.org> */ | ||
23 | |||
24 | #include <linux/kernel.h> | ||
25 | #include <linux/module.h> | ||
26 | #include <linux/delay.h> | ||
27 | #include <linux/slab.h> | ||
28 | #include <linux/init.h> | ||
29 | #include <linux/errno.h> | ||
30 | #include <linux/sched.h> | ||
31 | #include <linux/i2c.h> | ||
32 | #include <linux/i2c-algo-bit.h> | ||
33 | |||
34 | |||
35 | /* ----- global defines ----------------------------------------------- */ | ||
36 | #define DEB(x) if (i2c_debug>=1) x; | ||
37 | #define DEB2(x) if (i2c_debug>=2) x; | ||
38 | #define DEBSTAT(x) if (i2c_debug>=3) x; /* print several statistical values*/ | ||
39 | #define DEBPROTO(x) if (i2c_debug>=9) { x; } | ||
40 | /* debug the protocol by showing transferred bits */ | ||
41 | |||
42 | |||
43 | /* ----- global variables --------------------------------------------- */ | ||
44 | |||
45 | /* module parameters: | ||
46 | */ | ||
47 | static int i2c_debug; | ||
48 | static int bit_test; /* see if the line-setting functions work */ | ||
49 | |||
50 | /* --- setting states on the bus with the right timing: --------------- */ | ||
51 | |||
52 | #define setsda(adap,val) adap->setsda(adap->data, val) | ||
53 | #define setscl(adap,val) adap->setscl(adap->data, val) | ||
54 | #define getsda(adap) adap->getsda(adap->data) | ||
55 | #define getscl(adap) adap->getscl(adap->data) | ||
56 | |||
57 | static inline void sdalo(struct i2c_algo_bit_data *adap) | ||
58 | { | ||
59 | setsda(adap,0); | ||
60 | udelay(adap->udelay); | ||
61 | } | ||
62 | |||
63 | static inline void sdahi(struct i2c_algo_bit_data *adap) | ||
64 | { | ||
65 | setsda(adap,1); | ||
66 | udelay(adap->udelay); | ||
67 | } | ||
68 | |||
69 | static inline void scllo(struct i2c_algo_bit_data *adap) | ||
70 | { | ||
71 | setscl(adap,0); | ||
72 | udelay(adap->udelay); | ||
73 | } | ||
74 | |||
75 | /* | ||
76 | * Raise scl line, and do checking for delays. This is necessary for slower | ||
77 | * devices. | ||
78 | */ | ||
79 | static inline int sclhi(struct i2c_algo_bit_data *adap) | ||
80 | { | ||
81 | unsigned long start; | ||
82 | |||
83 | setscl(adap,1); | ||
84 | |||
85 | /* Not all adapters have scl sense line... */ | ||
86 | if (adap->getscl == NULL ) { | ||
87 | udelay(adap->udelay); | ||
88 | return 0; | ||
89 | } | ||
90 | |||
91 | start=jiffies; | ||
92 | while (! getscl(adap) ) { | ||
93 | /* the hw knows how to read the clock line, | ||
94 | * so we wait until it actually gets high. | ||
95 | * This is safer as some chips may hold it low | ||
96 | * while they are processing data internally. | ||
97 | */ | ||
98 | if (time_after_eq(jiffies, start+adap->timeout)) { | ||
99 | return -ETIMEDOUT; | ||
100 | } | ||
101 | cond_resched(); | ||
102 | } | ||
103 | DEBSTAT(printk(KERN_DEBUG "needed %ld jiffies\n", jiffies-start)); | ||
104 | udelay(adap->udelay); | ||
105 | return 0; | ||
106 | } | ||
107 | |||
108 | |||
109 | /* --- other auxiliary functions -------------------------------------- */ | ||
110 | static void i2c_start(struct i2c_algo_bit_data *adap) | ||
111 | { | ||
112 | /* assert: scl, sda are high */ | ||
113 | DEBPROTO(printk("S ")); | ||
114 | sdalo(adap); | ||
115 | scllo(adap); | ||
116 | } | ||
117 | |||
118 | static void i2c_repstart(struct i2c_algo_bit_data *adap) | ||
119 | { | ||
120 | /* scl, sda may not be high */ | ||
121 | DEBPROTO(printk(" Sr ")); | ||
122 | setsda(adap,1); | ||
123 | sclhi(adap); | ||
124 | udelay(adap->udelay); | ||
125 | |||
126 | sdalo(adap); | ||
127 | scllo(adap); | ||
128 | } | ||
129 | |||
130 | |||
131 | static void i2c_stop(struct i2c_algo_bit_data *adap) | ||
132 | { | ||
133 | DEBPROTO(printk("P\n")); | ||
134 | /* assert: scl is low */ | ||
135 | sdalo(adap); | ||
136 | sclhi(adap); | ||
137 | sdahi(adap); | ||
138 | } | ||
139 | |||
140 | |||
141 | |||
142 | /* send a byte without start cond., look for arbitration, | ||
143 | check ackn. from slave */ | ||
144 | /* returns: | ||
145 | * 1 if the device acknowledged | ||
146 | * 0 if the device did not ack | ||
147 | * -ETIMEDOUT if an error occurred (while raising the scl line) | ||
148 | */ | ||
149 | static int i2c_outb(struct i2c_adapter *i2c_adap, char c) | ||
150 | { | ||
151 | int i; | ||
152 | int sb; | ||
153 | int ack; | ||
154 | struct i2c_algo_bit_data *adap = i2c_adap->algo_data; | ||
155 | |||
156 | /* assert: scl is low */ | ||
157 | for ( i=7 ; i>=0 ; i-- ) { | ||
158 | sb = c & ( 1 << i ); | ||
159 | setsda(adap,sb); | ||
160 | udelay(adap->udelay); | ||
161 | DEBPROTO(printk(KERN_DEBUG "%d",sb!=0)); | ||
162 | if (sclhi(adap)<0) { /* timed out */ | ||
163 | sdahi(adap); /* we don't want to block the net */ | ||
164 | DEB2(printk(KERN_DEBUG " i2c_outb: 0x%02x, timeout at bit #%d\n", c&0xff, i)); | ||
165 | return -ETIMEDOUT; | ||
166 | }; | ||
167 | /* do arbitration here: | ||
168 | * if ( sb && ! getsda(adap) ) -> ouch! Get out of here. | ||
169 | */ | ||
170 | setscl(adap, 0 ); | ||
171 | udelay(adap->udelay); | ||
172 | } | ||
173 | sdahi(adap); | ||
174 | if (sclhi(adap)<0){ /* timeout */ | ||
175 | DEB2(printk(KERN_DEBUG " i2c_outb: 0x%02x, timeout at ack\n", c&0xff)); | ||
176 | return -ETIMEDOUT; | ||
177 | }; | ||
178 | /* read ack: SDA should be pulled down by slave */ | ||
179 | ack=getsda(adap); /* ack: sda is pulled low ->success. */ | ||
180 | DEB2(printk(KERN_DEBUG " i2c_outb: 0x%02x , getsda() = %d\n", c & 0xff, ack)); | ||
181 | |||
182 | DEBPROTO( printk(KERN_DEBUG "[%2.2x]",c&0xff) ); | ||
183 | DEBPROTO(if (0==ack){ printk(KERN_DEBUG " A ");} else printk(KERN_DEBUG " NA ") ); | ||
184 | scllo(adap); | ||
185 | return 0==ack; /* return 1 if device acked */ | ||
186 | /* assert: scl is low (sda undef) */ | ||
187 | } | ||
188 | |||
189 | |||
190 | static int i2c_inb(struct i2c_adapter *i2c_adap) | ||
191 | { | ||
192 | /* read byte via i2c port, without start/stop sequence */ | ||
193 | /* acknowledge is sent in i2c_read. */ | ||
194 | int i; | ||
195 | unsigned char indata=0; | ||
196 | struct i2c_algo_bit_data *adap = i2c_adap->algo_data; | ||
197 | |||
198 | /* assert: scl is low */ | ||
199 | sdahi(adap); | ||
200 | for (i=0;i<8;i++) { | ||
201 | if (sclhi(adap)<0) { /* timeout */ | ||
202 | DEB2(printk(KERN_DEBUG " i2c_inb: timeout at bit #%d\n", 7-i)); | ||
203 | return -ETIMEDOUT; | ||
204 | }; | ||
205 | indata *= 2; | ||
206 | if ( getsda(adap) ) | ||
207 | indata |= 0x01; | ||
208 | scllo(adap); | ||
209 | } | ||
210 | /* assert: scl is low */ | ||
211 | DEB2(printk(KERN_DEBUG "i2c_inb: 0x%02x\n", indata & 0xff)); | ||
212 | |||
213 | DEBPROTO(printk(KERN_DEBUG " 0x%02x", indata & 0xff)); | ||
214 | return (int) (indata & 0xff); | ||
215 | } | ||
216 | |||
217 | /* | ||
218 | * Sanity check for the adapter hardware - check the reaction of | ||
219 | * the bus lines only if it seems to be idle. | ||
220 | */ | ||
221 | static int test_bus(struct i2c_algo_bit_data *adap, char* name) { | ||
222 | int scl,sda; | ||
223 | |||
224 | if (adap->getscl==NULL) | ||
225 | printk(KERN_INFO "i2c-algo-bit.o: Testing SDA only, " | ||
226 | "SCL is not readable.\n"); | ||
227 | |||
228 | sda=getsda(adap); | ||
229 | scl=(adap->getscl==NULL?1:getscl(adap)); | ||
230 | printk(KERN_DEBUG "i2c-algo-bit.o: (0) scl=%d, sda=%d\n",scl,sda); | ||
231 | if (!scl || !sda ) { | ||
232 | printk(KERN_WARNING "i2c-algo-bit.o: %s seems to be busy.\n", name); | ||
233 | goto bailout; | ||
234 | } | ||
235 | |||
236 | sdalo(adap); | ||
237 | sda=getsda(adap); | ||
238 | scl=(adap->getscl==NULL?1:getscl(adap)); | ||
239 | printk(KERN_DEBUG "i2c-algo-bit.o: (1) scl=%d, sda=%d\n",scl,sda); | ||
240 | if ( 0 != sda ) { | ||
241 | printk(KERN_WARNING "i2c-algo-bit.o: SDA stuck high!\n"); | ||
242 | goto bailout; | ||
243 | } | ||
244 | if ( 0 == scl ) { | ||
245 | printk(KERN_WARNING "i2c-algo-bit.o: SCL unexpected low " | ||
246 | "while pulling SDA low!\n"); | ||
247 | goto bailout; | ||
248 | } | ||
249 | |||
250 | sdahi(adap); | ||
251 | sda=getsda(adap); | ||
252 | scl=(adap->getscl==NULL?1:getscl(adap)); | ||
253 | printk(KERN_DEBUG "i2c-algo-bit.o: (2) scl=%d, sda=%d\n",scl,sda); | ||
254 | if ( 0 == sda ) { | ||
255 | printk(KERN_WARNING "i2c-algo-bit.o: SDA stuck low!\n"); | ||
256 | goto bailout; | ||
257 | } | ||
258 | if ( 0 == scl ) { | ||
259 | printk(KERN_WARNING "i2c-algo-bit.o: SCL unexpected low " | ||
260 | "while pulling SDA high!\n"); | ||
261 | goto bailout; | ||
262 | } | ||
263 | |||
264 | scllo(adap); | ||
265 | sda=getsda(adap); | ||
266 | scl=(adap->getscl==NULL?0:getscl(adap)); | ||
267 | printk(KERN_DEBUG "i2c-algo-bit.o: (3) scl=%d, sda=%d\n",scl,sda); | ||
268 | if ( 0 != scl ) { | ||
269 | printk(KERN_WARNING "i2c-algo-bit.o: SCL stuck high!\n"); | ||
270 | goto bailout; | ||
271 | } | ||
272 | if ( 0 == sda ) { | ||
273 | printk(KERN_WARNING "i2c-algo-bit.o: SDA unexpected low " | ||
274 | "while pulling SCL low!\n"); | ||
275 | goto bailout; | ||
276 | } | ||
277 | |||
278 | sclhi(adap); | ||
279 | sda=getsda(adap); | ||
280 | scl=(adap->getscl==NULL?1:getscl(adap)); | ||
281 | printk(KERN_DEBUG "i2c-algo-bit.o: (4) scl=%d, sda=%d\n",scl,sda); | ||
282 | if ( 0 == scl ) { | ||
283 | printk(KERN_WARNING "i2c-algo-bit.o: SCL stuck low!\n"); | ||
284 | goto bailout; | ||
285 | } | ||
286 | if ( 0 == sda ) { | ||
287 | printk(KERN_WARNING "i2c-algo-bit.o: SDA unexpected low " | ||
288 | "while pulling SCL high!\n"); | ||
289 | goto bailout; | ||
290 | } | ||
291 | printk(KERN_INFO "i2c-algo-bit.o: %s passed test.\n",name); | ||
292 | return 0; | ||
293 | bailout: | ||
294 | sdahi(adap); | ||
295 | sclhi(adap); | ||
296 | return -ENODEV; | ||
297 | } | ||
298 | |||
299 | /* ----- Utility functions | ||
300 | */ | ||
301 | |||
302 | /* try_address tries to contact a chip for a number of | ||
303 | * times before it gives up. | ||
304 | * return values: | ||
305 | * 1 chip answered | ||
306 | * 0 chip did not answer | ||
307 | * -x transmission error | ||
308 | */ | ||
309 | static inline int try_address(struct i2c_adapter *i2c_adap, | ||
310 | unsigned char addr, int retries) | ||
311 | { | ||
312 | struct i2c_algo_bit_data *adap = i2c_adap->algo_data; | ||
313 | int i,ret = -1; | ||
314 | for (i=0;i<=retries;i++) { | ||
315 | ret = i2c_outb(i2c_adap,addr); | ||
316 | if (ret==1) | ||
317 | break; /* success! */ | ||
318 | i2c_stop(adap); | ||
319 | udelay(5/*adap->udelay*/); | ||
320 | if (i==retries) /* no success */ | ||
321 | break; | ||
322 | i2c_start(adap); | ||
323 | udelay(adap->udelay); | ||
324 | } | ||
325 | DEB2(if (i) | ||
326 | printk(KERN_DEBUG "i2c-algo-bit.o: Used %d tries to %s client at 0x%02x : %s\n", | ||
327 | i+1, addr & 1 ? "read" : "write", addr>>1, | ||
328 | ret==1 ? "success" : ret==0 ? "no ack" : "failed, timeout?" ) | ||
329 | ); | ||
330 | return ret; | ||
331 | } | ||
332 | |||
333 | static int sendbytes(struct i2c_adapter *i2c_adap, struct i2c_msg *msg) | ||
334 | { | ||
335 | struct i2c_algo_bit_data *adap = i2c_adap->algo_data; | ||
336 | char c; | ||
337 | const char *temp = msg->buf; | ||
338 | int count = msg->len; | ||
339 | unsigned short nak_ok = msg->flags & I2C_M_IGNORE_NAK; | ||
340 | int retval; | ||
341 | int wrcount=0; | ||
342 | |||
343 | while (count > 0) { | ||
344 | c = *temp; | ||
345 | DEB2(dev_dbg(&i2c_adap->dev, "sendbytes: writing %2.2X\n", c&0xff)); | ||
346 | retval = i2c_outb(i2c_adap,c); | ||
347 | if ((retval>0) || (nak_ok && (retval==0))) { /* ok or ignored NAK */ | ||
348 | count--; | ||
349 | temp++; | ||
350 | wrcount++; | ||
351 | } else { /* arbitration or no acknowledge */ | ||
352 | dev_err(&i2c_adap->dev, "sendbytes: error - bailout.\n"); | ||
353 | i2c_stop(adap); | ||
354 | return (retval<0)? retval : -EFAULT; | ||
355 | /* got a better one ?? */ | ||
356 | } | ||
357 | #if 0 | ||
358 | /* from asm/delay.h */ | ||
359 | __delay(adap->mdelay * (loops_per_sec / 1000) ); | ||
360 | #endif | ||
361 | } | ||
362 | return wrcount; | ||
363 | } | ||
364 | |||
365 | static inline int readbytes(struct i2c_adapter *i2c_adap, struct i2c_msg *msg) | ||
366 | { | ||
367 | int inval; | ||
368 | int rdcount=0; /* counts bytes read */ | ||
369 | struct i2c_algo_bit_data *adap = i2c_adap->algo_data; | ||
370 | char *temp = msg->buf; | ||
371 | int count = msg->len; | ||
372 | |||
373 | while (count > 0) { | ||
374 | inval = i2c_inb(i2c_adap); | ||
375 | /*printk("%#02x ",inval); if ( ! (count % 16) ) printk("\n"); */ | ||
376 | if (inval>=0) { | ||
377 | *temp = inval; | ||
378 | rdcount++; | ||
379 | } else { /* read timed out */ | ||
380 | printk(KERN_ERR "i2c-algo-bit.o: readbytes: i2c_inb timed out.\n"); | ||
381 | break; | ||
382 | } | ||
383 | |||
384 | temp++; | ||
385 | count--; | ||
386 | |||
387 | if (msg->flags & I2C_M_NO_RD_ACK) | ||
388 | continue; | ||
389 | |||
390 | if ( count > 0 ) { /* send ack */ | ||
391 | sdalo(adap); | ||
392 | DEBPROTO(printk(" Am ")); | ||
393 | } else { | ||
394 | sdahi(adap); /* neg. ack on last byte */ | ||
395 | DEBPROTO(printk(" NAm ")); | ||
396 | } | ||
397 | if (sclhi(adap)<0) { /* timeout */ | ||
398 | sdahi(adap); | ||
399 | printk(KERN_ERR "i2c-algo-bit.o: readbytes: Timeout at ack\n"); | ||
400 | return -ETIMEDOUT; | ||
401 | }; | ||
402 | scllo(adap); | ||
403 | sdahi(adap); | ||
404 | } | ||
405 | return rdcount; | ||
406 | } | ||
407 | |||
408 | /* doAddress initiates the transfer by generating the start condition (in | ||
409 | * try_address) and transmits the address in the necessary format to handle | ||
410 | * reads, writes as well as 10bit-addresses. | ||
411 | * returns: | ||
412 | * 0 everything went okay, the chip ack'ed, or IGNORE_NAK flag was set | ||
413 | * -x an error occurred (like: -EREMOTEIO if the device did not answer, or | ||
414 | * -ETIMEDOUT, for example if the lines are stuck...) | ||
415 | */ | ||
416 | static inline int bit_doAddress(struct i2c_adapter *i2c_adap, struct i2c_msg *msg) | ||
417 | { | ||
418 | unsigned short flags = msg->flags; | ||
419 | unsigned short nak_ok = msg->flags & I2C_M_IGNORE_NAK; | ||
420 | struct i2c_algo_bit_data *adap = i2c_adap->algo_data; | ||
421 | |||
422 | unsigned char addr; | ||
423 | int ret, retries; | ||
424 | |||
425 | retries = nak_ok ? 0 : i2c_adap->retries; | ||
426 | |||
427 | if ( (flags & I2C_M_TEN) ) { | ||
428 | /* a ten bit address */ | ||
429 | addr = 0xf0 | (( msg->addr >> 7) & 0x03); | ||
430 | DEB2(printk(KERN_DEBUG "addr0: %d\n",addr)); | ||
431 | /* try extended address code...*/ | ||
432 | ret = try_address(i2c_adap, addr, retries); | ||
433 | if ((ret != 1) && !nak_ok) { | ||
434 | printk(KERN_ERR "died at extended address code.\n"); | ||
435 | return -EREMOTEIO; | ||
436 | } | ||
437 | /* the remaining 8 bit address */ | ||
438 | ret = i2c_outb(i2c_adap,msg->addr & 0x7f); | ||
439 | if ((ret != 1) && !nak_ok) { | ||
440 | /* the chip did not ack / xmission error occurred */ | ||
441 | printk(KERN_ERR "died at 2nd address code.\n"); | ||
442 | return -EREMOTEIO; | ||
443 | } | ||
444 | if ( flags & I2C_M_RD ) { | ||
445 | i2c_repstart(adap); | ||
446 | /* okay, now switch into reading mode */ | ||
447 | addr |= 0x01; | ||
448 | ret = try_address(i2c_adap, addr, retries); | ||
449 | if ((ret!=1) && !nak_ok) { | ||
450 | printk(KERN_ERR "died at extended address code.\n"); | ||
451 | return -EREMOTEIO; | ||
452 | } | ||
453 | } | ||
454 | } else { /* normal 7bit address */ | ||
455 | addr = ( msg->addr << 1 ); | ||
456 | if (flags & I2C_M_RD ) | ||
457 | addr |= 1; | ||
458 | if (flags & I2C_M_REV_DIR_ADDR ) | ||
459 | addr ^= 1; | ||
460 | ret = try_address(i2c_adap, addr, retries); | ||
461 | if ((ret!=1) && !nak_ok) | ||
462 | return -EREMOTEIO; | ||
463 | } | ||
464 | |||
465 | return 0; | ||
466 | } | ||
467 | |||
468 | static int bit_xfer(struct i2c_adapter *i2c_adap, | ||
469 | struct i2c_msg msgs[], int num) | ||
470 | { | ||
471 | struct i2c_msg *pmsg; | ||
472 | struct i2c_algo_bit_data *adap = i2c_adap->algo_data; | ||
473 | |||
474 | int i,ret; | ||
475 | unsigned short nak_ok; | ||
476 | |||
477 | i2c_start(adap); | ||
478 | for (i=0;i<num;i++) { | ||
479 | pmsg = &msgs[i]; | ||
480 | nak_ok = pmsg->flags & I2C_M_IGNORE_NAK; | ||
481 | if (!(pmsg->flags & I2C_M_NOSTART)) { | ||
482 | if (i) { | ||
483 | i2c_repstart(adap); | ||
484 | } | ||
485 | ret = bit_doAddress(i2c_adap, pmsg); | ||
486 | if ((ret != 0) && !nak_ok) { | ||
487 | DEB2(printk(KERN_DEBUG "i2c-algo-bit.o: NAK from device addr %2.2x msg #%d\n" | ||
488 | ,msgs[i].addr,i)); | ||
489 | return (ret<0) ? ret : -EREMOTEIO; | ||
490 | } | ||
491 | } | ||
492 | if (pmsg->flags & I2C_M_RD ) { | ||
493 | /* read bytes into buffer*/ | ||
494 | ret = readbytes(i2c_adap, pmsg); | ||
495 | DEB2(printk(KERN_DEBUG "i2c-algo-bit.o: read %d bytes.\n",ret)); | ||
496 | if (ret < pmsg->len ) { | ||
497 | return (ret<0)? ret : -EREMOTEIO; | ||
498 | } | ||
499 | } else { | ||
500 | /* write bytes from buffer */ | ||
501 | ret = sendbytes(i2c_adap, pmsg); | ||
502 | DEB2(printk(KERN_DEBUG "i2c-algo-bit.o: wrote %d bytes.\n",ret)); | ||
503 | if (ret < pmsg->len ) { | ||
504 | return (ret<0) ? ret : -EREMOTEIO; | ||
505 | } | ||
506 | } | ||
507 | } | ||
508 | i2c_stop(adap); | ||
509 | return num; | ||
510 | } | ||
511 | |||
512 | static u32 bit_func(struct i2c_adapter *adap) | ||
513 | { | ||
514 | return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL | | ||
515 | I2C_FUNC_10BIT_ADDR | I2C_FUNC_PROTOCOL_MANGLING; | ||
516 | } | ||
517 | |||
518 | |||
519 | /* -----exported algorithm data: ------------------------------------- */ | ||
520 | |||
521 | static struct i2c_algorithm i2c_bit_algo = { | ||
522 | .name = "Bit-shift algorithm", | ||
523 | .id = I2C_ALGO_BIT, | ||
524 | .master_xfer = bit_xfer, | ||
525 | .functionality = bit_func, | ||
526 | }; | ||
527 | |||
528 | /* | ||
529 | * registering functions to load algorithms at runtime | ||
530 | */ | ||
531 | int i2c_bit_add_bus(struct i2c_adapter *adap) | ||
532 | { | ||
533 | struct i2c_algo_bit_data *bit_adap = adap->algo_data; | ||
534 | |||
535 | if (bit_test) { | ||
536 | int ret = test_bus(bit_adap, adap->name); | ||
537 | if (ret<0) | ||
538 | return -ENODEV; | ||
539 | } | ||
540 | |||
541 | DEB2(dev_dbg(&adap->dev, "hw routines registered.\n")); | ||
542 | |||
543 | /* register new adapter to i2c module... */ | ||
544 | |||
545 | adap->id |= i2c_bit_algo.id; | ||
546 | adap->algo = &i2c_bit_algo; | ||
547 | |||
548 | adap->timeout = 100; /* default values, should */ | ||
549 | adap->retries = 3; /* be replaced by defines */ | ||
550 | |||
551 | i2c_add_adapter(adap); | ||
552 | return 0; | ||
553 | } | ||
554 | |||
555 | |||
556 | int i2c_bit_del_bus(struct i2c_adapter *adap) | ||
557 | { | ||
558 | return i2c_del_adapter(adap); | ||
559 | } | ||
560 | |||
561 | EXPORT_SYMBOL(i2c_bit_add_bus); | ||
562 | EXPORT_SYMBOL(i2c_bit_del_bus); | ||
563 | |||
564 | MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>"); | ||
565 | MODULE_DESCRIPTION("I2C-Bus bit-banging algorithm"); | ||
566 | MODULE_LICENSE("GPL"); | ||
567 | |||
568 | module_param(bit_test, bool, 0); | ||
569 | module_param(i2c_debug, int, S_IRUGO | S_IWUSR); | ||
570 | |||
571 | MODULE_PARM_DESC(bit_test, "Test the lines of the bus to see if it is stuck"); | ||
572 | MODULE_PARM_DESC(i2c_debug, | ||
573 | "debug level - 0 off; 1 normal; 2,3 more verbose; 9 bit-protocol"); | ||
diff --git a/drivers/i2c/algos/i2c-algo-ite.c b/drivers/i2c/algos/i2c-algo-ite.c new file mode 100644 index 000000000000..68e9e6832ca0 --- /dev/null +++ b/drivers/i2c/algos/i2c-algo-ite.c | |||
@@ -0,0 +1,812 @@ | |||
1 | /* | ||
2 | ------------------------------------------------------------------------- | ||
3 | i2c-algo-ite.c i2c driver algorithms for ITE adapters | ||
4 | |||
5 | Hai-Pao Fan, MontaVista Software, Inc. | ||
6 | hpfan@mvista.com or source@mvista.com | ||
7 | |||
8 | Copyright 2000 MontaVista Software Inc. | ||
9 | |||
10 | --------------------------------------------------------------------------- | ||
11 | This file was highly leveraged from i2c-algo-pcf.c, which was created | ||
12 | by Simon G. Vogl and Hans Berglund: | ||
13 | |||
14 | |||
15 | Copyright (C) 1995-1997 Simon G. Vogl | ||
16 | 1998-2000 Hans Berglund | ||
17 | |||
18 | This program is free software; you can redistribute it and/or modify | ||
19 | it under the terms of the GNU General Public License as published by | ||
20 | the Free Software Foundation; either version 2 of the License, or | ||
21 | (at your option) any later version. | ||
22 | |||
23 | This program is distributed in the hope that it will be useful, | ||
24 | but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
25 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
26 | GNU General Public License for more details. | ||
27 | |||
28 | You should have received a copy of the GNU General Public License | ||
29 | along with this program; if not, write to the Free Software | ||
30 | Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ | ||
31 | /* ------------------------------------------------------------------------- */ | ||
32 | |||
33 | /* With some changes from Kyösti Mälkki <kmalkki@cc.hut.fi> and | ||
34 | Frodo Looijaard <frodol@dds.nl> ,and also from Martin Bailey | ||
35 | <mbailey@littlefeet-inc.com> */ | ||
36 | |||
37 | #include <linux/kernel.h> | ||
38 | #include <linux/module.h> | ||
39 | #include <linux/delay.h> | ||
40 | #include <linux/slab.h> | ||
41 | #include <linux/init.h> | ||
42 | #include <asm/uaccess.h> | ||
43 | #include <linux/ioport.h> | ||
44 | #include <linux/errno.h> | ||
45 | #include <linux/sched.h> | ||
46 | |||
47 | #include <linux/i2c.h> | ||
48 | #include <linux/i2c-algo-ite.h> | ||
49 | #include "i2c-algo-ite.h" | ||
50 | |||
51 | #define PM_DSR IT8172_PCI_IO_BASE + IT_PM_DSR | ||
52 | #define PM_IBSR IT8172_PCI_IO_BASE + IT_PM_DSR + 0x04 | ||
53 | #define GPIO_CCR IT8172_PCI_IO_BASE + IT_GPCCR | ||
54 | |||
55 | #define DEB2(x) if (i2c_debug>=2) x | ||
56 | #define DEB3(x) if (i2c_debug>=3) x /* print several statistical values*/ | ||
57 | #define DEF_TIMEOUT 16 | ||
58 | |||
59 | |||
60 | /* module parameters: | ||
61 | */ | ||
62 | static int i2c_debug; | ||
63 | static int iic_test; /* see if the line-setting functions work */ | ||
64 | |||
65 | /* --- setting states on the bus with the right timing: --------------- */ | ||
66 | |||
67 | #define get_clock(adap) adap->getclock(adap->data) | ||
68 | #define iic_outw(adap, reg, val) adap->setiic(adap->data, reg, val) | ||
69 | #define iic_inw(adap, reg) adap->getiic(adap->data, reg) | ||
70 | |||
71 | |||
72 | /* --- other auxiliary functions -------------------------------------- */ | ||
73 | |||
74 | static void iic_start(struct i2c_algo_iic_data *adap) | ||
75 | { | ||
76 | iic_outw(adap,ITE_I2CHCR,ITE_CMD); | ||
77 | } | ||
78 | |||
79 | static void iic_stop(struct i2c_algo_iic_data *adap) | ||
80 | { | ||
81 | iic_outw(adap,ITE_I2CHCR,0); | ||
82 | iic_outw(adap,ITE_I2CHSR,ITE_I2CHSR_TDI); | ||
83 | } | ||
84 | |||
85 | static void iic_reset(struct i2c_algo_iic_data *adap) | ||
86 | { | ||
87 | iic_outw(adap, PM_IBSR, iic_inw(adap, PM_IBSR) | 0x80); | ||
88 | } | ||
89 | |||
90 | |||
91 | static int wait_for_bb(struct i2c_algo_iic_data *adap) | ||
92 | { | ||
93 | int timeout = DEF_TIMEOUT; | ||
94 | short status; | ||
95 | |||
96 | status = iic_inw(adap, ITE_I2CHSR); | ||
97 | #ifndef STUB_I2C | ||
98 | while (timeout-- && (status & ITE_I2CHSR_HB)) { | ||
99 | udelay(1000); /* How much is this? */ | ||
100 | status = iic_inw(adap, ITE_I2CHSR); | ||
101 | } | ||
102 | #endif | ||
103 | if (timeout<=0) { | ||
104 | printk(KERN_ERR "Timeout, host is busy\n"); | ||
105 | iic_reset(adap); | ||
106 | } | ||
107 | return(timeout<=0); | ||
108 | } | ||
109 | |||
110 | /* After we issue a transaction on the IIC bus, this function | ||
111 | * is called. It puts this process to sleep until we get an interrupt from | ||
112 | * from the controller telling us that the transaction we requested in complete. | ||
113 | */ | ||
114 | static int wait_for_pin(struct i2c_algo_iic_data *adap, short *status) { | ||
115 | |||
116 | int timeout = DEF_TIMEOUT; | ||
117 | |||
118 | timeout = wait_for_bb(adap); | ||
119 | if (timeout) { | ||
120 | DEB2(printk("Timeout waiting for host not busy\n");) | ||
121 | return -EIO; | ||
122 | } | ||
123 | timeout = DEF_TIMEOUT; | ||
124 | |||
125 | *status = iic_inw(adap, ITE_I2CHSR); | ||
126 | #ifndef STUB_I2C | ||
127 | while (timeout-- && !(*status & ITE_I2CHSR_TDI)) { | ||
128 | adap->waitforpin(); | ||
129 | *status = iic_inw(adap, ITE_I2CHSR); | ||
130 | } | ||
131 | #endif | ||
132 | if (timeout <= 0) | ||
133 | return(-1); | ||
134 | else | ||
135 | return(0); | ||
136 | } | ||
137 | |||
138 | static int wait_for_fe(struct i2c_algo_iic_data *adap, short *status) | ||
139 | { | ||
140 | int timeout = DEF_TIMEOUT; | ||
141 | |||
142 | *status = iic_inw(adap, ITE_I2CFSR); | ||
143 | #ifndef STUB_I2C | ||
144 | while (timeout-- && (*status & ITE_I2CFSR_FE)) { | ||
145 | udelay(1000); | ||
146 | iic_inw(adap, ITE_I2CFSR); | ||
147 | } | ||
148 | #endif | ||
149 | if (timeout <= 0) | ||
150 | return(-1); | ||
151 | else | ||
152 | return(0); | ||
153 | } | ||
154 | |||
155 | static int iic_init (struct i2c_algo_iic_data *adap) | ||
156 | { | ||
157 | short i; | ||
158 | |||
159 | /* Clear bit 7 to set I2C to normal operation mode */ | ||
160 | i=iic_inw(adap, PM_DSR)& 0xff7f; | ||
161 | iic_outw(adap, PM_DSR, i); | ||
162 | |||
163 | /* set IT_GPCCR port C bit 2&3 as function 2 */ | ||
164 | i = iic_inw(adap, GPIO_CCR) & 0xfc0f; | ||
165 | iic_outw(adap,GPIO_CCR,i); | ||
166 | |||
167 | /* Clear slave address/sub-address */ | ||
168 | iic_outw(adap,ITE_I2CSAR, 0); | ||
169 | iic_outw(adap,ITE_I2CSSAR, 0); | ||
170 | |||
171 | /* Set clock counter register */ | ||
172 | iic_outw(adap,ITE_I2CCKCNT, get_clock(adap)); | ||
173 | |||
174 | /* Set START/reSTART/STOP time registers */ | ||
175 | iic_outw(adap,ITE_I2CSHDR, 0x0a); | ||
176 | iic_outw(adap,ITE_I2CRSUR, 0x0a); | ||
177 | iic_outw(adap,ITE_I2CPSUR, 0x0a); | ||
178 | |||
179 | /* Enable interrupts on completing the current transaction */ | ||
180 | iic_outw(adap,ITE_I2CHCR, ITE_I2CHCR_IE | ITE_I2CHCR_HCE); | ||
181 | |||
182 | /* Clear transfer count */ | ||
183 | iic_outw(adap,ITE_I2CFBCR, 0x0); | ||
184 | |||
185 | DEB2(printk("iic_init: Initialized IIC on ITE 0x%x\n", | ||
186 | iic_inw(adap, ITE_I2CHSR))); | ||
187 | return 0; | ||
188 | } | ||
189 | |||
190 | |||
191 | /* | ||
192 | * Sanity check for the adapter hardware - check the reaction of | ||
193 | * the bus lines only if it seems to be idle. | ||
194 | */ | ||
195 | static int test_bus(struct i2c_algo_iic_data *adap, char *name) { | ||
196 | #if 0 | ||
197 | int scl,sda; | ||
198 | sda=getsda(adap); | ||
199 | if (adap->getscl==NULL) { | ||
200 | printk("test_bus: Warning: Adapter can't read from clock line - skipping test.\n"); | ||
201 | return 0; | ||
202 | } | ||
203 | scl=getscl(adap); | ||
204 | printk("test_bus: Adapter: %s scl: %d sda: %d -- testing...\n", | ||
205 | name,getscl(adap),getsda(adap)); | ||
206 | if (!scl || !sda ) { | ||
207 | printk("test_bus: %s seems to be busy.\n",adap->name); | ||
208 | goto bailout; | ||
209 | } | ||
210 | sdalo(adap); | ||
211 | printk("test_bus:1 scl: %d sda: %d \n",getscl(adap), | ||
212 | getsda(adap)); | ||
213 | if ( 0 != getsda(adap) ) { | ||
214 | printk("test_bus: %s SDA stuck high!\n",name); | ||
215 | sdahi(adap); | ||
216 | goto bailout; | ||
217 | } | ||
218 | if ( 0 == getscl(adap) ) { | ||
219 | printk("test_bus: %s SCL unexpected low while pulling SDA low!\n", | ||
220 | name); | ||
221 | goto bailout; | ||
222 | } | ||
223 | sdahi(adap); | ||
224 | printk("test_bus:2 scl: %d sda: %d \n",getscl(adap), | ||
225 | getsda(adap)); | ||
226 | if ( 0 == getsda(adap) ) { | ||
227 | printk("test_bus: %s SDA stuck low!\n",name); | ||
228 | sdahi(adap); | ||
229 | goto bailout; | ||
230 | } | ||
231 | if ( 0 == getscl(adap) ) { | ||
232 | printk("test_bus: %s SCL unexpected low while SDA high!\n", | ||
233 | adap->name); | ||
234 | goto bailout; | ||
235 | } | ||
236 | scllo(adap); | ||
237 | printk("test_bus:3 scl: %d sda: %d \n",getscl(adap), | ||
238 | getsda(adap)); | ||
239 | if ( 0 != getscl(adap) ) { | ||
240 | |||
241 | sclhi(adap); | ||
242 | goto bailout; | ||
243 | } | ||
244 | if ( 0 == getsda(adap) ) { | ||
245 | printk("test_bus: %s SDA unexpected low while pulling SCL low!\n", | ||
246 | name); | ||
247 | goto bailout; | ||
248 | } | ||
249 | sclhi(adap); | ||
250 | printk("test_bus:4 scl: %d sda: %d \n",getscl(adap), | ||
251 | getsda(adap)); | ||
252 | if ( 0 == getscl(adap) ) { | ||
253 | printk("test_bus: %s SCL stuck low!\n",name); | ||
254 | sclhi(adap); | ||
255 | goto bailout; | ||
256 | } | ||
257 | if ( 0 == getsda(adap) ) { | ||
258 | printk("test_bus: %s SDA unexpected low while SCL high!\n", | ||
259 | name); | ||
260 | goto bailout; | ||
261 | } | ||
262 | printk("test_bus: %s passed test.\n",name); | ||
263 | return 0; | ||
264 | bailout: | ||
265 | sdahi(adap); | ||
266 | sclhi(adap); | ||
267 | return -ENODEV; | ||
268 | #endif | ||
269 | return (0); | ||
270 | } | ||
271 | |||
272 | /* ----- Utility functions | ||
273 | */ | ||
274 | |||
275 | |||
276 | /* Verify the device we want to talk to on the IIC bus really exists. */ | ||
277 | static inline int try_address(struct i2c_algo_iic_data *adap, | ||
278 | unsigned int addr, int retries) | ||
279 | { | ||
280 | int i, ret = -1; | ||
281 | short status; | ||
282 | |||
283 | for (i=0;i<retries;i++) { | ||
284 | iic_outw(adap, ITE_I2CSAR, addr); | ||
285 | iic_start(adap); | ||
286 | if (wait_for_pin(adap, &status) == 0) { | ||
287 | if ((status & ITE_I2CHSR_DNE) == 0) { | ||
288 | iic_stop(adap); | ||
289 | iic_outw(adap, ITE_I2CFCR, ITE_I2CFCR_FLUSH); | ||
290 | ret=1; | ||
291 | break; /* success! */ | ||
292 | } | ||
293 | } | ||
294 | iic_stop(adap); | ||
295 | udelay(adap->udelay); | ||
296 | } | ||
297 | DEB2(if (i) printk("try_address: needed %d retries for 0x%x\n",i, | ||
298 | addr)); | ||
299 | return ret; | ||
300 | } | ||
301 | |||
302 | |||
303 | static int iic_sendbytes(struct i2c_adapter *i2c_adap,const char *buf, | ||
304 | int count) | ||
305 | { | ||
306 | struct i2c_algo_iic_data *adap = i2c_adap->algo_data; | ||
307 | int wrcount=0, timeout; | ||
308 | short status; | ||
309 | int loops, remainder, i, j; | ||
310 | union { | ||
311 | char byte[2]; | ||
312 | unsigned short word; | ||
313 | } tmp; | ||
314 | |||
315 | iic_outw(adap, ITE_I2CSSAR, (unsigned short)buf[wrcount++]); | ||
316 | count--; | ||
317 | if (count == 0) | ||
318 | return -EIO; | ||
319 | |||
320 | loops = count / 32; /* 32-byte FIFO */ | ||
321 | remainder = count % 32; | ||
322 | |||
323 | if(loops) { | ||
324 | for(i=0; i<loops; i++) { | ||
325 | |||
326 | iic_outw(adap, ITE_I2CFBCR, 32); | ||
327 | for(j=0; j<32/2; j++) { | ||
328 | tmp.byte[1] = buf[wrcount++]; | ||
329 | tmp.byte[0] = buf[wrcount++]; | ||
330 | iic_outw(adap, ITE_I2CFDR, tmp.word); | ||
331 | } | ||
332 | |||
333 | /* status FIFO overrun */ | ||
334 | iic_inw(adap, ITE_I2CFSR); | ||
335 | iic_inw(adap, ITE_I2CFBCR); | ||
336 | |||
337 | iic_outw(adap, ITE_I2CHCR, ITE_WRITE); /* Issue WRITE command */ | ||
338 | |||
339 | /* Wait for transmission to complete */ | ||
340 | timeout = wait_for_pin(adap, &status); | ||
341 | if(timeout) { | ||
342 | iic_stop(adap); | ||
343 | printk("iic_sendbytes: %s write timeout.\n", i2c_adap->name); | ||
344 | return -EREMOTEIO; /* got a better one ?? */ | ||
345 | } | ||
346 | if (status & ITE_I2CHSR_DB) { | ||
347 | iic_stop(adap); | ||
348 | printk("iic_sendbytes: %s write error - no ack.\n", i2c_adap->name); | ||
349 | return -EREMOTEIO; /* got a better one ?? */ | ||
350 | } | ||
351 | } | ||
352 | } | ||
353 | if(remainder) { | ||
354 | iic_outw(adap, ITE_I2CFBCR, remainder); | ||
355 | for(i=0; i<remainder/2; i++) { | ||
356 | tmp.byte[1] = buf[wrcount++]; | ||
357 | tmp.byte[0] = buf[wrcount++]; | ||
358 | iic_outw(adap, ITE_I2CFDR, tmp.word); | ||
359 | } | ||
360 | |||
361 | /* status FIFO overrun */ | ||
362 | iic_inw(adap, ITE_I2CFSR); | ||
363 | iic_inw(adap, ITE_I2CFBCR); | ||
364 | |||
365 | iic_outw(adap, ITE_I2CHCR, ITE_WRITE); /* Issue WRITE command */ | ||
366 | |||
367 | timeout = wait_for_pin(adap, &status); | ||
368 | if(timeout) { | ||
369 | iic_stop(adap); | ||
370 | printk("iic_sendbytes: %s write timeout.\n", i2c_adap->name); | ||
371 | return -EREMOTEIO; /* got a better one ?? */ | ||
372 | } | ||
373 | #ifndef STUB_I2C | ||
374 | if (status & ITE_I2CHSR_DB) { | ||
375 | iic_stop(adap); | ||
376 | printk("iic_sendbytes: %s write error - no ack.\n", i2c_adap->name); | ||
377 | return -EREMOTEIO; /* got a better one ?? */ | ||
378 | } | ||
379 | #endif | ||
380 | } | ||
381 | iic_stop(adap); | ||
382 | return wrcount; | ||
383 | } | ||
384 | |||
385 | |||
386 | static int iic_readbytes(struct i2c_adapter *i2c_adap, char *buf, int count, | ||
387 | int sread) | ||
388 | { | ||
389 | int rdcount=0, i, timeout; | ||
390 | short status; | ||
391 | struct i2c_algo_iic_data *adap = i2c_adap->algo_data; | ||
392 | int loops, remainder, j; | ||
393 | union { | ||
394 | char byte[2]; | ||
395 | unsigned short word; | ||
396 | } tmp; | ||
397 | |||
398 | loops = count / 32; /* 32-byte FIFO */ | ||
399 | remainder = count % 32; | ||
400 | |||
401 | if(loops) { | ||
402 | for(i=0; i<loops; i++) { | ||
403 | iic_outw(adap, ITE_I2CFBCR, 32); | ||
404 | if (sread) | ||
405 | iic_outw(adap, ITE_I2CHCR, ITE_SREAD); | ||
406 | else | ||
407 | iic_outw(adap, ITE_I2CHCR, ITE_READ); /* Issue READ command */ | ||
408 | |||
409 | timeout = wait_for_pin(adap, &status); | ||
410 | if(timeout) { | ||
411 | iic_stop(adap); | ||
412 | printk("iic_readbytes: %s read timeout.\n", i2c_adap->name); | ||
413 | return (-1); | ||
414 | } | ||
415 | #ifndef STUB_I2C | ||
416 | if (status & ITE_I2CHSR_DB) { | ||
417 | iic_stop(adap); | ||
418 | printk("iic_readbytes: %s read error - no ack.\n", i2c_adap->name); | ||
419 | return (-1); | ||
420 | } | ||
421 | #endif | ||
422 | |||
423 | timeout = wait_for_fe(adap, &status); | ||
424 | if(timeout) { | ||
425 | iic_stop(adap); | ||
426 | printk("iic_readbytes: %s FIFO is empty\n", i2c_adap->name); | ||
427 | return (-1); | ||
428 | } | ||
429 | |||
430 | for(j=0; j<32/2; j++) { | ||
431 | tmp.word = iic_inw(adap, ITE_I2CFDR); | ||
432 | buf[rdcount++] = tmp.byte[1]; | ||
433 | buf[rdcount++] = tmp.byte[0]; | ||
434 | } | ||
435 | |||
436 | /* status FIFO underrun */ | ||
437 | iic_inw(adap, ITE_I2CFSR); | ||
438 | |||
439 | } | ||
440 | } | ||
441 | |||
442 | |||
443 | if(remainder) { | ||
444 | remainder=(remainder+1)/2 * 2; | ||
445 | iic_outw(adap, ITE_I2CFBCR, remainder); | ||
446 | if (sread) | ||
447 | iic_outw(adap, ITE_I2CHCR, ITE_SREAD); | ||
448 | else | ||
449 | iic_outw(adap, ITE_I2CHCR, ITE_READ); /* Issue READ command */ | ||
450 | |||
451 | timeout = wait_for_pin(adap, &status); | ||
452 | if(timeout) { | ||
453 | iic_stop(adap); | ||
454 | printk("iic_readbytes: %s read timeout.\n", i2c_adap->name); | ||
455 | return (-1); | ||
456 | } | ||
457 | #ifndef STUB_I2C | ||
458 | if (status & ITE_I2CHSR_DB) { | ||
459 | iic_stop(adap); | ||
460 | printk("iic_readbytes: %s read error - no ack.\n", i2c_adap->name); | ||
461 | return (-1); | ||
462 | } | ||
463 | #endif | ||
464 | timeout = wait_for_fe(adap, &status); | ||
465 | if(timeout) { | ||
466 | iic_stop(adap); | ||
467 | printk("iic_readbytes: %s FIFO is empty\n", i2c_adap->name); | ||
468 | return (-1); | ||
469 | } | ||
470 | |||
471 | for(i=0; i<(remainder+1)/2; i++) { | ||
472 | tmp.word = iic_inw(adap, ITE_I2CFDR); | ||
473 | buf[rdcount++] = tmp.byte[1]; | ||
474 | buf[rdcount++] = tmp.byte[0]; | ||
475 | } | ||
476 | |||
477 | /* status FIFO underrun */ | ||
478 | iic_inw(adap, ITE_I2CFSR); | ||
479 | |||
480 | } | ||
481 | |||
482 | iic_stop(adap); | ||
483 | return rdcount; | ||
484 | } | ||
485 | |||
486 | |||
487 | /* This function implements combined transactions. Combined | ||
488 | * transactions consist of combinations of reading and writing blocks of data. | ||
489 | * Each transfer (i.e. a read or a write) is separated by a repeated start | ||
490 | * condition. | ||
491 | */ | ||
492 | #if 0 | ||
493 | static int iic_combined_transaction(struct i2c_adapter *i2c_adap, struct i2c_msg *msgs, int num) | ||
494 | { | ||
495 | int i; | ||
496 | struct i2c_msg *pmsg; | ||
497 | int ret; | ||
498 | |||
499 | DEB2(printk("Beginning combined transaction\n")); | ||
500 | |||
501 | for(i=0; i<(num-1); i++) { | ||
502 | pmsg = &msgs[i]; | ||
503 | if(pmsg->flags & I2C_M_RD) { | ||
504 | DEB2(printk(" This one is a read\n")); | ||
505 | ret = iic_readbytes(i2c_adap, pmsg->buf, pmsg->len, IIC_COMBINED_XFER); | ||
506 | } | ||
507 | else if(!(pmsg->flags & I2C_M_RD)) { | ||
508 | DEB2(printk("This one is a write\n")); | ||
509 | ret = iic_sendbytes(i2c_adap, pmsg->buf, pmsg->len, IIC_COMBINED_XFER); | ||
510 | } | ||
511 | } | ||
512 | /* Last read or write segment needs to be terminated with a stop */ | ||
513 | pmsg = &msgs[i]; | ||
514 | |||
515 | if(pmsg->flags & I2C_M_RD) { | ||
516 | DEB2(printk("Doing the last read\n")); | ||
517 | ret = iic_readbytes(i2c_adap, pmsg->buf, pmsg->len, IIC_SINGLE_XFER); | ||
518 | } | ||
519 | else if(!(pmsg->flags & I2C_M_RD)) { | ||
520 | DEB2(printk("Doing the last write\n")); | ||
521 | ret = iic_sendbytes(i2c_adap, pmsg->buf, pmsg->len, IIC_SINGLE_XFER); | ||
522 | } | ||
523 | |||
524 | return ret; | ||
525 | } | ||
526 | #endif | ||
527 | |||
528 | |||
529 | /* Whenever we initiate a transaction, the first byte clocked | ||
530 | * onto the bus after the start condition is the address (7 bit) of the | ||
531 | * device we want to talk to. This function manipulates the address specified | ||
532 | * so that it makes sense to the hardware when written to the IIC peripheral. | ||
533 | * | ||
534 | * Note: 10 bit addresses are not supported in this driver, although they are | ||
535 | * supported by the hardware. This functionality needs to be implemented. | ||
536 | */ | ||
537 | static inline int iic_doAddress(struct i2c_algo_iic_data *adap, | ||
538 | struct i2c_msg *msg, int retries) | ||
539 | { | ||
540 | unsigned short flags = msg->flags; | ||
541 | unsigned int addr; | ||
542 | int ret; | ||
543 | |||
544 | /* Ten bit addresses not supported right now */ | ||
545 | if ( (flags & I2C_M_TEN) ) { | ||
546 | #if 0 | ||
547 | addr = 0xf0 | (( msg->addr >> 7) & 0x03); | ||
548 | DEB2(printk("addr0: %d\n",addr)); | ||
549 | ret = try_address(adap, addr, retries); | ||
550 | if (ret!=1) { | ||
551 | printk("iic_doAddress: died at extended address code.\n"); | ||
552 | return -EREMOTEIO; | ||
553 | } | ||
554 | iic_outw(adap,msg->addr & 0x7f); | ||
555 | if (ret != 1) { | ||
556 | printk("iic_doAddress: died at 2nd address code.\n"); | ||
557 | return -EREMOTEIO; | ||
558 | } | ||
559 | if ( flags & I2C_M_RD ) { | ||
560 | i2c_repstart(adap); | ||
561 | addr |= 0x01; | ||
562 | ret = try_address(adap, addr, retries); | ||
563 | if (ret!=1) { | ||
564 | printk("iic_doAddress: died at extended address code.\n"); | ||
565 | return -EREMOTEIO; | ||
566 | } | ||
567 | } | ||
568 | #endif | ||
569 | } else { | ||
570 | |||
571 | addr = ( msg->addr << 1 ); | ||
572 | |||
573 | #if 0 | ||
574 | if (flags & I2C_M_RD ) | ||
575 | addr |= 1; | ||
576 | if (flags & I2C_M_REV_DIR_ADDR ) | ||
577 | addr ^= 1; | ||
578 | #endif | ||
579 | |||
580 | if (iic_inw(adap, ITE_I2CSAR) != addr) { | ||
581 | iic_outw(adap, ITE_I2CSAR, addr); | ||
582 | ret = try_address(adap, addr, retries); | ||
583 | if (ret!=1) { | ||
584 | printk("iic_doAddress: died at address code.\n"); | ||
585 | return -EREMOTEIO; | ||
586 | } | ||
587 | } | ||
588 | |||
589 | } | ||
590 | |||
591 | return 0; | ||
592 | } | ||
593 | |||
594 | |||
595 | /* Description: Prepares the controller for a transaction (clearing status | ||
596 | * registers, data buffers, etc), and then calls either iic_readbytes or | ||
597 | * iic_sendbytes to do the actual transaction. | ||
598 | * | ||
599 | * still to be done: Before we issue a transaction, we should | ||
600 | * verify that the bus is not busy or in some unknown state. | ||
601 | */ | ||
602 | static int iic_xfer(struct i2c_adapter *i2c_adap, | ||
603 | struct i2c_msg *msgs, | ||
604 | int num) | ||
605 | { | ||
606 | struct i2c_algo_iic_data *adap = i2c_adap->algo_data; | ||
607 | struct i2c_msg *pmsg; | ||
608 | int i = 0; | ||
609 | int ret, timeout; | ||
610 | |||
611 | pmsg = &msgs[i]; | ||
612 | |||
613 | if(!pmsg->len) { | ||
614 | DEB2(printk("iic_xfer: read/write length is 0\n");) | ||
615 | return -EIO; | ||
616 | } | ||
617 | if(!(pmsg->flags & I2C_M_RD) && (!(pmsg->len)%2) ) { | ||
618 | DEB2(printk("iic_xfer: write buffer length is not odd\n");) | ||
619 | return -EIO; | ||
620 | } | ||
621 | |||
622 | /* Wait for any pending transfers to complete */ | ||
623 | timeout = wait_for_bb(adap); | ||
624 | if (timeout) { | ||
625 | DEB2(printk("iic_xfer: Timeout waiting for host not busy\n");) | ||
626 | return -EIO; | ||
627 | } | ||
628 | |||
629 | /* Flush FIFO */ | ||
630 | iic_outw(adap, ITE_I2CFCR, ITE_I2CFCR_FLUSH); | ||
631 | |||
632 | /* Load address */ | ||
633 | ret = iic_doAddress(adap, pmsg, i2c_adap->retries); | ||
634 | if (ret) | ||
635 | return -EIO; | ||
636 | |||
637 | #if 0 | ||
638 | /* Combined transaction (read and write) */ | ||
639 | if(num > 1) { | ||
640 | DEB2(printk("iic_xfer: Call combined transaction\n")); | ||
641 | ret = iic_combined_transaction(i2c_adap, msgs, num); | ||
642 | } | ||
643 | #endif | ||
644 | |||
645 | DEB3(printk("iic_xfer: Msg %d, addr=0x%x, flags=0x%x, len=%d\n", | ||
646 | i, msgs[i].addr, msgs[i].flags, msgs[i].len);) | ||
647 | |||
648 | if(pmsg->flags & I2C_M_RD) /* Read */ | ||
649 | ret = iic_readbytes(i2c_adap, pmsg->buf, pmsg->len, 0); | ||
650 | else { /* Write */ | ||
651 | udelay(1000); | ||
652 | ret = iic_sendbytes(i2c_adap, pmsg->buf, pmsg->len); | ||
653 | } | ||
654 | |||
655 | if (ret != pmsg->len) | ||
656 | DEB3(printk("iic_xfer: error or fail on read/write %d bytes.\n",ret)); | ||
657 | else | ||
658 | DEB3(printk("iic_xfer: read/write %d bytes.\n",ret)); | ||
659 | |||
660 | return ret; | ||
661 | } | ||
662 | |||
663 | |||
664 | /* Implements device specific ioctls. Higher level ioctls can | ||
665 | * be found in i2c-core.c and are typical of any i2c controller (specifying | ||
666 | * slave address, timeouts, etc). These ioctls take advantage of any hardware | ||
667 | * features built into the controller for which this algorithm-adapter set | ||
668 | * was written. These ioctls allow you to take control of the data and clock | ||
669 | * lines and set the either high or low, | ||
670 | * similar to a GPIO pin. | ||
671 | */ | ||
672 | static int algo_control(struct i2c_adapter *adapter, | ||
673 | unsigned int cmd, unsigned long arg) | ||
674 | { | ||
675 | |||
676 | struct i2c_algo_iic_data *adap = adapter->algo_data; | ||
677 | struct i2c_iic_msg s_msg; | ||
678 | char *buf; | ||
679 | int ret; | ||
680 | |||
681 | if (cmd == I2C_SREAD) { | ||
682 | if(copy_from_user(&s_msg, (struct i2c_iic_msg *)arg, | ||
683 | sizeof(struct i2c_iic_msg))) | ||
684 | return -EFAULT; | ||
685 | buf = kmalloc(s_msg.len, GFP_KERNEL); | ||
686 | if (buf== NULL) | ||
687 | return -ENOMEM; | ||
688 | |||
689 | /* Flush FIFO */ | ||
690 | iic_outw(adap, ITE_I2CFCR, ITE_I2CFCR_FLUSH); | ||
691 | |||
692 | /* Load address */ | ||
693 | iic_outw(adap, ITE_I2CSAR,s_msg.addr<<1); | ||
694 | iic_outw(adap, ITE_I2CSSAR,s_msg.waddr & 0xff); | ||
695 | |||
696 | ret = iic_readbytes(adapter, buf, s_msg.len, 1); | ||
697 | if (ret>=0) { | ||
698 | if(copy_to_user( s_msg.buf, buf, s_msg.len) ) | ||
699 | ret = -EFAULT; | ||
700 | } | ||
701 | kfree(buf); | ||
702 | } | ||
703 | return 0; | ||
704 | } | ||
705 | |||
706 | |||
707 | static u32 iic_func(struct i2c_adapter *adap) | ||
708 | { | ||
709 | return I2C_FUNC_SMBUS_EMUL | I2C_FUNC_10BIT_ADDR | | ||
710 | I2C_FUNC_PROTOCOL_MANGLING; | ||
711 | } | ||
712 | |||
713 | /* -----exported algorithm data: ------------------------------------- */ | ||
714 | |||
715 | static struct i2c_algorithm iic_algo = { | ||
716 | .name = "ITE IIC algorithm", | ||
717 | .id = I2C_ALGO_IIC, | ||
718 | .master_xfer = iic_xfer, | ||
719 | .algo_control = algo_control, /* ioctl */ | ||
720 | .functionality = iic_func, | ||
721 | }; | ||
722 | |||
723 | |||
724 | /* | ||
725 | * registering functions to load algorithms at runtime | ||
726 | */ | ||
727 | int i2c_iic_add_bus(struct i2c_adapter *adap) | ||
728 | { | ||
729 | struct i2c_algo_iic_data *iic_adap = adap->algo_data; | ||
730 | |||
731 | if (iic_test) { | ||
732 | int ret = test_bus(iic_adap, adap->name); | ||
733 | if (ret<0) | ||
734 | return -ENODEV; | ||
735 | } | ||
736 | |||
737 | DEB2(printk("i2c-algo-ite: hw routines for %s registered.\n", | ||
738 | adap->name)); | ||
739 | |||
740 | /* register new adapter to i2c module... */ | ||
741 | |||
742 | adap->id |= iic_algo.id; | ||
743 | adap->algo = &iic_algo; | ||
744 | |||
745 | adap->timeout = 100; /* default values, should */ | ||
746 | adap->retries = 3; /* be replaced by defines */ | ||
747 | adap->flags = 0; | ||
748 | |||
749 | i2c_add_adapter(adap); | ||
750 | iic_init(iic_adap); | ||
751 | |||
752 | return 0; | ||
753 | } | ||
754 | |||
755 | |||
756 | int i2c_iic_del_bus(struct i2c_adapter *adap) | ||
757 | { | ||
758 | int res; | ||
759 | if ((res = i2c_del_adapter(adap)) < 0) | ||
760 | return res; | ||
761 | DEB2(printk("i2c-algo-ite: adapter unregistered: %s\n",adap->name)); | ||
762 | |||
763 | return 0; | ||
764 | } | ||
765 | |||
766 | |||
767 | int __init i2c_algo_iic_init (void) | ||
768 | { | ||
769 | printk(KERN_INFO "ITE iic (i2c) algorithm module\n"); | ||
770 | return 0; | ||
771 | } | ||
772 | |||
773 | |||
774 | void i2c_algo_iic_exit(void) | ||
775 | { | ||
776 | return; | ||
777 | } | ||
778 | |||
779 | |||
780 | EXPORT_SYMBOL(i2c_iic_add_bus); | ||
781 | EXPORT_SYMBOL(i2c_iic_del_bus); | ||
782 | |||
783 | /* The MODULE_* macros resolve to nothing if MODULES is not defined | ||
784 | * when this file is compiled. | ||
785 | */ | ||
786 | MODULE_AUTHOR("MontaVista Software <www.mvista.com>"); | ||
787 | MODULE_DESCRIPTION("ITE iic algorithm"); | ||
788 | MODULE_LICENSE("GPL"); | ||
789 | |||
790 | module_param(iic_test, bool, 0); | ||
791 | module_param(i2c_debug, int, S_IRUGO | S_IWUSR); | ||
792 | |||
793 | MODULE_PARM_DESC(iic_test, "Test if the I2C bus is available"); | ||
794 | MODULE_PARM_DESC(i2c_debug, | ||
795 | "debug level - 0 off; 1 normal; 2,3 more verbose; 9 iic-protocol"); | ||
796 | |||
797 | |||
798 | /* This function resolves to init_module (the function invoked when a module | ||
799 | * is loaded via insmod) when this file is compiled with MODULES defined. | ||
800 | * Otherwise (i.e. if you want this driver statically linked to the kernel), | ||
801 | * a pointer to this function is stored in a table and called | ||
802 | * during the initialization of the kernel (in do_basic_setup in /init/main.c) | ||
803 | * | ||
804 | * All this functionality is complements of the macros defined in linux/init.h | ||
805 | */ | ||
806 | module_init(i2c_algo_iic_init); | ||
807 | |||
808 | |||
809 | /* If MODULES is defined when this file is compiled, then this function will | ||
810 | * resolved to cleanup_module. | ||
811 | */ | ||
812 | module_exit(i2c_algo_iic_exit); | ||
diff --git a/drivers/i2c/algos/i2c-algo-ite.h b/drivers/i2c/algos/i2c-algo-ite.h new file mode 100644 index 000000000000..a8ca3c9b546a --- /dev/null +++ b/drivers/i2c/algos/i2c-algo-ite.h | |||
@@ -0,0 +1,117 @@ | |||
1 | /* | ||
2 | -------------------------------------------------------------------- | ||
3 | i2c-ite.h: Global defines for the I2C controller on board the | ||
4 | ITE MIPS processor. | ||
5 | -------------------------------------------------------------------- | ||
6 | Hai-Pao Fan, MontaVista Software, Inc. | ||
7 | hpfan@mvista.com or source@mvista.com | ||
8 | |||
9 | Copyright 2001 MontaVista Software Inc. | ||
10 | |||
11 | * This program is free software; you can redistribute it and/or modify it | ||
12 | * under the terms of the GNU General Public License as published by the | ||
13 | * Free Software Foundation; either version 2 of the License, or (at your | ||
14 | * option) any later version. | ||
15 | * | ||
16 | * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED | ||
17 | * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF | ||
18 | * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN | ||
19 | * NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, | ||
20 | * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT | ||
21 | * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF | ||
22 | * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON | ||
23 | * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | ||
24 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF | ||
25 | * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | ||
26 | * | ||
27 | * You should have received a copy of the GNU General Public License along | ||
28 | * with this program; if not, write to the Free Software Foundation, Inc., | ||
29 | * 675 Mass Ave, Cambridge, MA 02139, USA. | ||
30 | |||
31 | */ | ||
32 | |||
33 | #ifndef I2C_ITE_H | ||
34 | #define I2C_ITE_H 1 | ||
35 | |||
36 | #include <asm/it8172/it8172.h> | ||
37 | |||
38 | /* I2C Registers */ | ||
39 | #define ITE_I2CHCR IT8172_PCI_IO_BASE + IT_I2C_BASE + 0x30 | ||
40 | #define ITE_I2CHSR IT8172_PCI_IO_BASE + IT_I2C_BASE + 0x34 | ||
41 | #define ITE_I2CSAR IT8172_PCI_IO_BASE + IT_I2C_BASE + 0x38 | ||
42 | #define ITE_I2CSSAR IT8172_PCI_IO_BASE + IT_I2C_BASE + 0x3c | ||
43 | #define ITE_I2CCKCNT IT8172_PCI_IO_BASE + IT_I2C_BASE + 0x48 | ||
44 | #define ITE_I2CSHDR IT8172_PCI_IO_BASE + IT_I2C_BASE + 0x4c | ||
45 | #define ITE_I2CRSUR IT8172_PCI_IO_BASE + IT_I2C_BASE + 0x50 | ||
46 | #define ITE_I2CPSUR IT8172_PCI_IO_BASE + IT_I2C_BASE + 0x54 | ||
47 | |||
48 | #define ITE_I2CFDR IT8172_PCI_IO_BASE + IT_I2C_BASE + 0x70 | ||
49 | #define ITE_I2CFBCR IT8172_PCI_IO_BASE + IT_I2C_BASE + 0x74 | ||
50 | #define ITE_I2CFCR IT8172_PCI_IO_BASE + IT_I2C_BASE + 0x78 | ||
51 | #define ITE_I2CFSR IT8172_PCI_IO_BASE + IT_I2C_BASE + 0x7c | ||
52 | |||
53 | |||
54 | /* Host Control Register ITE_I2CHCR */ | ||
55 | #define ITE_I2CHCR_HCE 0x01 /* Enable I2C Host Controller */ | ||
56 | #define ITE_I2CHCR_IE 0x02 /* Enable the interrupt after completing | ||
57 | the current transaction */ | ||
58 | #define ITE_I2CHCR_CP_W 0x00 /* bit2-4 000 - Write */ | ||
59 | #define ITE_I2CHCR_CP_R 0x08 /* 010 - Current address read */ | ||
60 | #define ITE_I2CHCR_CP_S 0x10 /* 100 - Sequential read */ | ||
61 | #define ITE_I2CHCR_ST 0x20 /* Initiates the I2C host controller to execute | ||
62 | the command and send the data programmed in | ||
63 | all required registers to I2C bus */ | ||
64 | #define ITE_CMD ITE_I2CHCR_HCE | ITE_I2CHCR_IE | ITE_I2CHCR_ST | ||
65 | #define ITE_WRITE ITE_CMD | ITE_I2CHCR_CP_W | ||
66 | #define ITE_READ ITE_CMD | ITE_I2CHCR_CP_R | ||
67 | #define ITE_SREAD ITE_CMD | ITE_I2CHCR_CP_S | ||
68 | |||
69 | /* Host Status Register ITE_I2CHSR */ | ||
70 | #define ITE_I2CHSR_DB 0x01 /* Device is busy, receives NACK response except | ||
71 | in the first and last bytes */ | ||
72 | #define ITE_I2CHSR_DNE 0x02 /* Target address on I2C bus does not exist */ | ||
73 | #define ITE_I2CHSR_TDI 0x04 /* R/W Transaction on I2C bus was completed */ | ||
74 | #define ITE_I2CHSR_HB 0x08 /* Host controller is processing transactions */ | ||
75 | #define ITE_I2CHSR_FER 0x10 /* Error occurs in the FIFO */ | ||
76 | |||
77 | /* Slave Address Register ITE_I2CSAR */ | ||
78 | #define ITE_I2CSAR_SA_MASK 0xfe /* Target I2C device address */ | ||
79 | #define ITE_I2CSAR_ASO 0x0100 /* Output 1/0 to I2CAS port when the | ||
80 | next slave address is addressed */ | ||
81 | |||
82 | /* Slave Sub-address Register ITE_I2CSSAR */ | ||
83 | #define ITE_I2CSSAR_SUBA_MASK 0xff /* Target I2C device sub-address */ | ||
84 | |||
85 | /* Clock Counter Register ITE_I2CCKCNT */ | ||
86 | #define ITE_I2CCKCNT_STOP 0x00 /* stop I2C clock */ | ||
87 | #define ITE_I2CCKCNT_HPCC_MASK 0x7f /* SCL high period counter */ | ||
88 | #define ITE_I2CCKCNT_LPCC_MASK 0x7f00 /* SCL low period counter */ | ||
89 | |||
90 | /* START Hold Time Register ITE_I2CSHDR */ | ||
91 | /* value is counted based on 16 MHz internal clock */ | ||
92 | #define ITE_I2CSHDR_FM 0x0a /* START condition at fast mode */ | ||
93 | #define ITE_I2CSHDR_SM 0x47 /* START contition at standard mode */ | ||
94 | |||
95 | /* (Repeated) START Setup Time Register ITE_I2CRSUR */ | ||
96 | /* value is counted based on 16 MHz internal clock */ | ||
97 | #define ITE_I2CRSUR_FM 0x0a /* repeated START condition at fast mode */ | ||
98 | #define ITE_I2CRSUR_SM 0x50 /* repeated START condition at standard mode */ | ||
99 | |||
100 | /* STOP setup Time Register ITE_I2CPSUR */ | ||
101 | |||
102 | /* FIFO Data Register ITE_I2CFDR */ | ||
103 | #define ITE_I2CFDR_MASK 0xff | ||
104 | |||
105 | /* FIFO Byte Count Register ITE_I2CFBCR */ | ||
106 | #define ITE_I2CFBCR_MASK 0x3f | ||
107 | |||
108 | /* FIFO Control Register ITE_I2CFCR */ | ||
109 | #define ITE_I2CFCR_FLUSH 0x01 /* Flush FIFO and reset the FIFO point | ||
110 | and I2CFSR */ | ||
111 | /* FIFO Status Register ITE_I2CFSR */ | ||
112 | #define ITE_I2CFSR_FO 0x01 /* FIFO is overrun when write */ | ||
113 | #define ITE_I2CFSR_FU 0x02 /* FIFO is underrun when read */ | ||
114 | #define ITE_I2CFSR_FF 0x04 /* FIFO is full when write */ | ||
115 | #define ITE_I2CFSR_FE 0x08 /* FIFO is empty when read */ | ||
116 | |||
117 | #endif /* I2C_ITE_H */ | ||
diff --git a/drivers/i2c/algos/i2c-algo-pca.c b/drivers/i2c/algos/i2c-algo-pca.c new file mode 100644 index 000000000000..c3d912cbbbc3 --- /dev/null +++ b/drivers/i2c/algos/i2c-algo-pca.c | |||
@@ -0,0 +1,399 @@ | |||
1 | /* | ||
2 | * i2c-algo-pca.c i2c driver algorithms for PCA9564 adapters | ||
3 | * Copyright (C) 2004 Arcom Control Systems | ||
4 | * | ||
5 | * This program is free software; you can redistribute it and/or modify | ||
6 | * it under the terms of the GNU General Public License as published by | ||
7 | * the Free Software Foundation; either version 2 of the License, or | ||
8 | * (at your option) any later version. | ||
9 | * | ||
10 | * This program is distributed in the hope that it will be useful, | ||
11 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
12 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
13 | * GNU General Public License for more details. | ||
14 | * | ||
15 | * You should have received a copy of the GNU General Public License | ||
16 | * along with this program; if not, write to the Free Software | ||
17 | * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. | ||
18 | */ | ||
19 | |||
20 | #include <linux/kernel.h> | ||
21 | #include <linux/module.h> | ||
22 | #include <linux/moduleparam.h> | ||
23 | #include <linux/delay.h> | ||
24 | #include <linux/slab.h> | ||
25 | #include <linux/init.h> | ||
26 | #include <linux/errno.h> | ||
27 | #include <linux/i2c.h> | ||
28 | #include <linux/i2c-algo-pca.h> | ||
29 | #include "i2c-algo-pca.h" | ||
30 | |||
31 | #define DRIVER "i2c-algo-pca" | ||
32 | |||
33 | #define DEB1(fmt, args...) do { if (i2c_debug>=1) printk(fmt, ## args); } while(0) | ||
34 | #define DEB2(fmt, args...) do { if (i2c_debug>=2) printk(fmt, ## args); } while(0) | ||
35 | #define DEB3(fmt, args...) do { if (i2c_debug>=3) printk(fmt, ## args); } while(0) | ||
36 | |||
37 | static int i2c_debug=0; | ||
38 | |||
39 | #define pca_outw(adap, reg, val) adap->write_byte(adap, reg, val) | ||
40 | #define pca_inw(adap, reg) adap->read_byte(adap, reg) | ||
41 | |||
42 | #define pca_status(adap) pca_inw(adap, I2C_PCA_STA) | ||
43 | #define pca_clock(adap) adap->get_clock(adap) | ||
44 | #define pca_own(adap) adap->get_own(adap) | ||
45 | #define pca_set_con(adap, val) pca_outw(adap, I2C_PCA_CON, val) | ||
46 | #define pca_get_con(adap) pca_inw(adap, I2C_PCA_CON) | ||
47 | #define pca_wait(adap) adap->wait_for_interrupt(adap) | ||
48 | |||
49 | /* | ||
50 | * Generate a start condition on the i2c bus. | ||
51 | * | ||
52 | * returns after the start condition has occured | ||
53 | */ | ||
54 | static void pca_start(struct i2c_algo_pca_data *adap) | ||
55 | { | ||
56 | int sta = pca_get_con(adap); | ||
57 | DEB2("=== START\n"); | ||
58 | sta |= I2C_PCA_CON_STA; | ||
59 | sta &= ~(I2C_PCA_CON_STO|I2C_PCA_CON_SI); | ||
60 | pca_set_con(adap, sta); | ||
61 | pca_wait(adap); | ||
62 | } | ||
63 | |||
64 | /* | ||
65 | * Generate a repeated start condition on the i2c bus | ||
66 | * | ||
67 | * return after the repeated start condition has occured | ||
68 | */ | ||
69 | static void pca_repeated_start(struct i2c_algo_pca_data *adap) | ||
70 | { | ||
71 | int sta = pca_get_con(adap); | ||
72 | DEB2("=== REPEATED START\n"); | ||
73 | sta |= I2C_PCA_CON_STA; | ||
74 | sta &= ~(I2C_PCA_CON_STO|I2C_PCA_CON_SI); | ||
75 | pca_set_con(adap, sta); | ||
76 | pca_wait(adap); | ||
77 | } | ||
78 | |||
79 | /* | ||
80 | * Generate a stop condition on the i2c bus | ||
81 | * | ||
82 | * returns after the stop condition has been generated | ||
83 | * | ||
84 | * STOPs do not generate an interrupt or set the SI flag, since the | ||
85 | * part returns the the idle state (0xf8). Hence we don't need to | ||
86 | * pca_wait here. | ||
87 | */ | ||
88 | static void pca_stop(struct i2c_algo_pca_data *adap) | ||
89 | { | ||
90 | int sta = pca_get_con(adap); | ||
91 | DEB2("=== STOP\n"); | ||
92 | sta |= I2C_PCA_CON_STO; | ||
93 | sta &= ~(I2C_PCA_CON_STA|I2C_PCA_CON_SI); | ||
94 | pca_set_con(adap, sta); | ||
95 | } | ||
96 | |||
97 | /* | ||
98 | * Send the slave address and R/W bit | ||
99 | * | ||
100 | * returns after the address has been sent | ||
101 | */ | ||
102 | static void pca_address(struct i2c_algo_pca_data *adap, | ||
103 | struct i2c_msg *msg) | ||
104 | { | ||
105 | int sta = pca_get_con(adap); | ||
106 | int addr; | ||
107 | |||
108 | addr = ( (0x7f & msg->addr) << 1 ); | ||
109 | if (msg->flags & I2C_M_RD ) | ||
110 | addr |= 1; | ||
111 | DEB2("=== SLAVE ADDRESS %#04x+%c=%#04x\n", | ||
112 | msg->addr, msg->flags & I2C_M_RD ? 'R' : 'W', addr); | ||
113 | |||
114 | pca_outw(adap, I2C_PCA_DAT, addr); | ||
115 | |||
116 | sta &= ~(I2C_PCA_CON_STO|I2C_PCA_CON_STA|I2C_PCA_CON_SI); | ||
117 | pca_set_con(adap, sta); | ||
118 | |||
119 | pca_wait(adap); | ||
120 | } | ||
121 | |||
122 | /* | ||
123 | * Transmit a byte. | ||
124 | * | ||
125 | * Returns after the byte has been transmitted | ||
126 | */ | ||
127 | static void pca_tx_byte(struct i2c_algo_pca_data *adap, | ||
128 | __u8 b) | ||
129 | { | ||
130 | int sta = pca_get_con(adap); | ||
131 | DEB2("=== WRITE %#04x\n", b); | ||
132 | pca_outw(adap, I2C_PCA_DAT, b); | ||
133 | |||
134 | sta &= ~(I2C_PCA_CON_STO|I2C_PCA_CON_STA|I2C_PCA_CON_SI); | ||
135 | pca_set_con(adap, sta); | ||
136 | |||
137 | pca_wait(adap); | ||
138 | } | ||
139 | |||
140 | /* | ||
141 | * Receive a byte | ||
142 | * | ||
143 | * returns immediately. | ||
144 | */ | ||
145 | static void pca_rx_byte(struct i2c_algo_pca_data *adap, | ||
146 | __u8 *b, int ack) | ||
147 | { | ||
148 | *b = pca_inw(adap, I2C_PCA_DAT); | ||
149 | DEB2("=== READ %#04x %s\n", *b, ack ? "ACK" : "NACK"); | ||
150 | } | ||
151 | |||
152 | /* | ||
153 | * Setup ACK or NACK for next received byte and wait for it to arrive. | ||
154 | * | ||
155 | * Returns after next byte has arrived. | ||
156 | */ | ||
157 | static void pca_rx_ack(struct i2c_algo_pca_data *adap, | ||
158 | int ack) | ||
159 | { | ||
160 | int sta = pca_get_con(adap); | ||
161 | |||
162 | sta &= ~(I2C_PCA_CON_STO|I2C_PCA_CON_STA|I2C_PCA_CON_SI|I2C_PCA_CON_AA); | ||
163 | |||
164 | if ( ack ) | ||
165 | sta |= I2C_PCA_CON_AA; | ||
166 | |||
167 | pca_set_con(adap, sta); | ||
168 | pca_wait(adap); | ||
169 | } | ||
170 | |||
171 | /* | ||
172 | * Reset the i2c bus / SIO | ||
173 | */ | ||
174 | static void pca_reset(struct i2c_algo_pca_data *adap) | ||
175 | { | ||
176 | /* apparently only an external reset will do it. not a lot can be done */ | ||
177 | printk(KERN_ERR DRIVER ": Haven't figured out how to do a reset yet\n"); | ||
178 | } | ||
179 | |||
180 | static int pca_xfer(struct i2c_adapter *i2c_adap, | ||
181 | struct i2c_msg *msgs, | ||
182 | int num) | ||
183 | { | ||
184 | struct i2c_algo_pca_data *adap = i2c_adap->algo_data; | ||
185 | struct i2c_msg *msg = NULL; | ||
186 | int curmsg; | ||
187 | int numbytes = 0; | ||
188 | int state; | ||
189 | int ret; | ||
190 | |||
191 | state = pca_status(adap); | ||
192 | if ( state != 0xF8 ) { | ||
193 | dev_dbg(&i2c_adap->dev, "bus is not idle. status is %#04x\n", state ); | ||
194 | /* FIXME: what to do. Force stop ? */ | ||
195 | return -EREMOTEIO; | ||
196 | } | ||
197 | |||
198 | DEB1("{{{ XFER %d messages\n", num); | ||
199 | |||
200 | if (i2c_debug>=2) { | ||
201 | for (curmsg = 0; curmsg < num; curmsg++) { | ||
202 | int addr, i; | ||
203 | msg = &msgs[curmsg]; | ||
204 | |||
205 | addr = (0x7f & msg->addr) ; | ||
206 | |||
207 | if (msg->flags & I2C_M_RD ) | ||
208 | printk(KERN_INFO " [%02d] RD %d bytes from %#02x [%#02x, ...]\n", | ||
209 | curmsg, msg->len, addr, (addr<<1) | 1); | ||
210 | else { | ||
211 | printk(KERN_INFO " [%02d] WR %d bytes to %#02x [%#02x%s", | ||
212 | curmsg, msg->len, addr, addr<<1, | ||
213 | msg->len == 0 ? "" : ", "); | ||
214 | for(i=0; i < msg->len; i++) | ||
215 | printk("%#04x%s", msg->buf[i], i == msg->len - 1 ? "" : ", "); | ||
216 | printk("]\n"); | ||
217 | } | ||
218 | } | ||
219 | } | ||
220 | |||
221 | curmsg = 0; | ||
222 | ret = -EREMOTEIO; | ||
223 | while (curmsg < num) { | ||
224 | state = pca_status(adap); | ||
225 | |||
226 | DEB3("STATE is 0x%02x\n", state); | ||
227 | msg = &msgs[curmsg]; | ||
228 | |||
229 | switch (state) { | ||
230 | case 0xf8: /* On reset or stop the bus is idle */ | ||
231 | pca_start(adap); | ||
232 | break; | ||
233 | |||
234 | case 0x08: /* A START condition has been transmitted */ | ||
235 | case 0x10: /* A repeated start condition has been transmitted */ | ||
236 | pca_address(adap, msg); | ||
237 | break; | ||
238 | |||
239 | case 0x18: /* SLA+W has been transmitted; ACK has been received */ | ||
240 | case 0x28: /* Data byte in I2CDAT has been transmitted; ACK has been received */ | ||
241 | if (numbytes < msg->len) { | ||
242 | pca_tx_byte(adap, msg->buf[numbytes]); | ||
243 | numbytes++; | ||
244 | break; | ||
245 | } | ||
246 | curmsg++; numbytes = 0; | ||
247 | if (curmsg == num) | ||
248 | pca_stop(adap); | ||
249 | else | ||
250 | pca_repeated_start(adap); | ||
251 | break; | ||
252 | |||
253 | case 0x20: /* SLA+W has been transmitted; NOT ACK has been received */ | ||
254 | DEB2("NOT ACK received after SLA+W\n"); | ||
255 | pca_stop(adap); | ||
256 | goto out; | ||
257 | |||
258 | case 0x40: /* SLA+R has been transmitted; ACK has been received */ | ||
259 | pca_rx_ack(adap, msg->len > 1); | ||
260 | break; | ||
261 | |||
262 | case 0x50: /* Data bytes has been received; ACK has been returned */ | ||
263 | if (numbytes < msg->len) { | ||
264 | pca_rx_byte(adap, &msg->buf[numbytes], 1); | ||
265 | numbytes++; | ||
266 | pca_rx_ack(adap, numbytes < msg->len - 1); | ||
267 | break; | ||
268 | } | ||
269 | curmsg++; numbytes = 0; | ||
270 | if (curmsg == num) | ||
271 | pca_stop(adap); | ||
272 | else | ||
273 | pca_repeated_start(adap); | ||
274 | break; | ||
275 | |||
276 | case 0x48: /* SLA+R has been transmitted; NOT ACK has been received */ | ||
277 | DEB2("NOT ACK received after SLA+R\n"); | ||
278 | pca_stop(adap); | ||
279 | goto out; | ||
280 | |||
281 | case 0x30: /* Data byte in I2CDAT has been transmitted; NOT ACK has been received */ | ||
282 | DEB2("NOT ACK received after data byte\n"); | ||
283 | goto out; | ||
284 | |||
285 | case 0x38: /* Arbitration lost during SLA+W, SLA+R or data bytes */ | ||
286 | DEB2("Arbitration lost\n"); | ||
287 | goto out; | ||
288 | |||
289 | case 0x58: /* Data byte has been received; NOT ACK has been returned */ | ||
290 | if ( numbytes == msg->len - 1 ) { | ||
291 | pca_rx_byte(adap, &msg->buf[numbytes], 0); | ||
292 | curmsg++; numbytes = 0; | ||
293 | if (curmsg == num) | ||
294 | pca_stop(adap); | ||
295 | else | ||
296 | pca_repeated_start(adap); | ||
297 | } else { | ||
298 | DEB2("NOT ACK sent after data byte received. " | ||
299 | "Not final byte. numbytes %d. len %d\n", | ||
300 | numbytes, msg->len); | ||
301 | pca_stop(adap); | ||
302 | goto out; | ||
303 | } | ||
304 | break; | ||
305 | case 0x70: /* Bus error - SDA stuck low */ | ||
306 | DEB2("BUS ERROR - SDA Stuck low\n"); | ||
307 | pca_reset(adap); | ||
308 | goto out; | ||
309 | case 0x90: /* Bus error - SCL stuck low */ | ||
310 | DEB2("BUS ERROR - SCL Stuck low\n"); | ||
311 | pca_reset(adap); | ||
312 | goto out; | ||
313 | case 0x00: /* Bus error during master or slave mode due to illegal START or STOP condition */ | ||
314 | DEB2("BUS ERROR - Illegal START or STOP\n"); | ||
315 | pca_reset(adap); | ||
316 | goto out; | ||
317 | default: | ||
318 | printk(KERN_ERR DRIVER ": unhandled SIO state 0x%02x\n", state); | ||
319 | break; | ||
320 | } | ||
321 | |||
322 | } | ||
323 | |||
324 | ret = curmsg; | ||
325 | out: | ||
326 | DEB1(KERN_CRIT "}}} transfered %d/%d messages. " | ||
327 | "status is %#04x. control is %#04x\n", | ||
328 | curmsg, num, pca_status(adap), | ||
329 | pca_get_con(adap)); | ||
330 | return ret; | ||
331 | } | ||
332 | |||
333 | static u32 pca_func(struct i2c_adapter *adap) | ||
334 | { | ||
335 | return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL; | ||
336 | } | ||
337 | |||
338 | static int pca_init(struct i2c_algo_pca_data *adap) | ||
339 | { | ||
340 | static int freqs[] = {330,288,217,146,88,59,44,36}; | ||
341 | int own, clock; | ||
342 | |||
343 | own = pca_own(adap); | ||
344 | clock = pca_clock(adap); | ||
345 | DEB1(KERN_INFO DRIVER ": own address is %#04x\n", own); | ||
346 | DEB1(KERN_INFO DRIVER ": clock freqeuncy is %dkHz\n", freqs[clock]); | ||
347 | |||
348 | pca_outw(adap, I2C_PCA_ADR, own << 1); | ||
349 | |||
350 | pca_set_con(adap, I2C_PCA_CON_ENSIO | clock); | ||
351 | udelay(500); /* 500 µs for oscilator to stabilise */ | ||
352 | |||
353 | return 0; | ||
354 | } | ||
355 | |||
356 | static struct i2c_algorithm pca_algo = { | ||
357 | .name = "PCA9564 algorithm", | ||
358 | .id = I2C_ALGO_PCA, | ||
359 | .master_xfer = pca_xfer, | ||
360 | .functionality = pca_func, | ||
361 | }; | ||
362 | |||
363 | /* | ||
364 | * registering functions to load algorithms at runtime | ||
365 | */ | ||
366 | int i2c_pca_add_bus(struct i2c_adapter *adap) | ||
367 | { | ||
368 | struct i2c_algo_pca_data *pca_adap = adap->algo_data; | ||
369 | int rval; | ||
370 | |||
371 | /* register new adapter to i2c module... */ | ||
372 | |||
373 | adap->id |= pca_algo.id; | ||
374 | adap->algo = &pca_algo; | ||
375 | |||
376 | adap->timeout = 100; /* default values, should */ | ||
377 | adap->retries = 3; /* be replaced by defines */ | ||
378 | |||
379 | rval = pca_init(pca_adap); | ||
380 | |||
381 | if (!rval) | ||
382 | i2c_add_adapter(adap); | ||
383 | |||
384 | return rval; | ||
385 | } | ||
386 | |||
387 | int i2c_pca_del_bus(struct i2c_adapter *adap) | ||
388 | { | ||
389 | return i2c_del_adapter(adap); | ||
390 | } | ||
391 | |||
392 | EXPORT_SYMBOL(i2c_pca_add_bus); | ||
393 | EXPORT_SYMBOL(i2c_pca_del_bus); | ||
394 | |||
395 | MODULE_AUTHOR("Ian Campbell <icampbell@arcom.com>"); | ||
396 | MODULE_DESCRIPTION("I2C-Bus PCA9564 algorithm"); | ||
397 | MODULE_LICENSE("GPL"); | ||
398 | |||
399 | module_param(i2c_debug, int, 0); | ||
diff --git a/drivers/i2c/algos/i2c-algo-pca.h b/drivers/i2c/algos/i2c-algo-pca.h new file mode 100644 index 000000000000..2fee07e05211 --- /dev/null +++ b/drivers/i2c/algos/i2c-algo-pca.h | |||
@@ -0,0 +1,26 @@ | |||
1 | #ifndef I2C_PCA9564_H | ||
2 | #define I2C_PCA9564_H 1 | ||
3 | |||
4 | #define I2C_PCA_STA 0x00 /* STATUS Read Only */ | ||
5 | #define I2C_PCA_TO 0x00 /* TIMEOUT Write Only */ | ||
6 | #define I2C_PCA_DAT 0x01 /* DATA Read/Write */ | ||
7 | #define I2C_PCA_ADR 0x02 /* OWN ADR Read/Write */ | ||
8 | #define I2C_PCA_CON 0x03 /* CONTROL Read/Write */ | ||
9 | |||
10 | #define I2C_PCA_CON_AA 0x80 /* Assert Acknowledge */ | ||
11 | #define I2C_PCA_CON_ENSIO 0x40 /* Enable */ | ||
12 | #define I2C_PCA_CON_STA 0x20 /* Start */ | ||
13 | #define I2C_PCA_CON_STO 0x10 /* Stop */ | ||
14 | #define I2C_PCA_CON_SI 0x08 /* Serial Interrupt */ | ||
15 | #define I2C_PCA_CON_CR 0x07 /* Clock Rate (MASK) */ | ||
16 | |||
17 | #define I2C_PCA_CON_330kHz 0x00 | ||
18 | #define I2C_PCA_CON_288kHz 0x01 | ||
19 | #define I2C_PCA_CON_217kHz 0x02 | ||
20 | #define I2C_PCA_CON_146kHz 0x03 | ||
21 | #define I2C_PCA_CON_88kHz 0x04 | ||
22 | #define I2C_PCA_CON_59kHz 0x05 | ||
23 | #define I2C_PCA_CON_44kHz 0x06 | ||
24 | #define I2C_PCA_CON_36kHz 0x07 | ||
25 | |||
26 | #endif /* I2C_PCA9564_H */ | ||
diff --git a/drivers/i2c/algos/i2c-algo-pcf.c b/drivers/i2c/algos/i2c-algo-pcf.c new file mode 100644 index 000000000000..8d087dac32af --- /dev/null +++ b/drivers/i2c/algos/i2c-algo-pcf.c | |||
@@ -0,0 +1,507 @@ | |||
1 | /* ------------------------------------------------------------------------- */ | ||
2 | /* i2c-algo-pcf.c i2c driver algorithms for PCF8584 adapters */ | ||
3 | /* ------------------------------------------------------------------------- */ | ||
4 | /* Copyright (C) 1995-1997 Simon G. Vogl | ||
5 | 1998-2000 Hans Berglund | ||
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 | You should have received a copy of the GNU General Public License | ||
18 | along with this program; if not, write to the Free Software | ||
19 | Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ | ||
20 | /* ------------------------------------------------------------------------- */ | ||
21 | |||
22 | /* With some changes from Kyösti Mälkki <kmalkki@cc.hut.fi> and | ||
23 | Frodo Looijaard <frodol@dds.nl> ,and also from Martin Bailey | ||
24 | <mbailey@littlefeet-inc.com> */ | ||
25 | |||
26 | /* Partially rewriten by Oleg I. Vdovikin <vdovikin@jscc.ru> to handle multiple | ||
27 | messages, proper stop/repstart signaling during receive, | ||
28 | added detect code */ | ||
29 | |||
30 | #include <linux/kernel.h> | ||
31 | #include <linux/module.h> | ||
32 | #include <linux/delay.h> | ||
33 | #include <linux/slab.h> | ||
34 | #include <linux/init.h> | ||
35 | #include <linux/errno.h> | ||
36 | #include <linux/i2c.h> | ||
37 | #include <linux/i2c-algo-pcf.h> | ||
38 | #include "i2c-algo-pcf.h" | ||
39 | |||
40 | |||
41 | #define DEB2(x) if (i2c_debug>=2) x | ||
42 | #define DEB3(x) if (i2c_debug>=3) x /* print several statistical values*/ | ||
43 | #define DEBPROTO(x) if (i2c_debug>=9) x; | ||
44 | /* debug the protocol by showing transferred bits */ | ||
45 | #define DEF_TIMEOUT 16 | ||
46 | |||
47 | /* module parameters: | ||
48 | */ | ||
49 | static int i2c_debug; | ||
50 | |||
51 | /* --- setting states on the bus with the right timing: --------------- */ | ||
52 | |||
53 | #define set_pcf(adap, ctl, val) adap->setpcf(adap->data, ctl, val) | ||
54 | #define get_pcf(adap, ctl) adap->getpcf(adap->data, ctl) | ||
55 | #define get_own(adap) adap->getown(adap->data) | ||
56 | #define get_clock(adap) adap->getclock(adap->data) | ||
57 | #define i2c_outb(adap, val) adap->setpcf(adap->data, 0, val) | ||
58 | #define i2c_inb(adap) adap->getpcf(adap->data, 0) | ||
59 | |||
60 | /* --- other auxiliary functions -------------------------------------- */ | ||
61 | |||
62 | static void i2c_start(struct i2c_algo_pcf_data *adap) | ||
63 | { | ||
64 | DEBPROTO(printk("S ")); | ||
65 | set_pcf(adap, 1, I2C_PCF_START); | ||
66 | } | ||
67 | |||
68 | static void i2c_repstart(struct i2c_algo_pcf_data *adap) | ||
69 | { | ||
70 | DEBPROTO(printk(" Sr ")); | ||
71 | set_pcf(adap, 1, I2C_PCF_REPSTART); | ||
72 | } | ||
73 | |||
74 | |||
75 | static void i2c_stop(struct i2c_algo_pcf_data *adap) | ||
76 | { | ||
77 | DEBPROTO(printk("P\n")); | ||
78 | set_pcf(adap, 1, I2C_PCF_STOP); | ||
79 | } | ||
80 | |||
81 | static int wait_for_bb(struct i2c_algo_pcf_data *adap) { | ||
82 | |||
83 | int timeout = DEF_TIMEOUT; | ||
84 | int status; | ||
85 | |||
86 | status = get_pcf(adap, 1); | ||
87 | #ifndef STUB_I2C | ||
88 | while (timeout-- && !(status & I2C_PCF_BB)) { | ||
89 | udelay(100); /* wait for 100 us */ | ||
90 | status = get_pcf(adap, 1); | ||
91 | } | ||
92 | #endif | ||
93 | if (timeout <= 0) { | ||
94 | printk(KERN_ERR "Timeout waiting for Bus Busy\n"); | ||
95 | } | ||
96 | |||
97 | return (timeout<=0); | ||
98 | } | ||
99 | |||
100 | |||
101 | static int wait_for_pin(struct i2c_algo_pcf_data *adap, int *status) { | ||
102 | |||
103 | int timeout = DEF_TIMEOUT; | ||
104 | |||
105 | *status = get_pcf(adap, 1); | ||
106 | #ifndef STUB_I2C | ||
107 | while (timeout-- && (*status & I2C_PCF_PIN)) { | ||
108 | adap->waitforpin(); | ||
109 | *status = get_pcf(adap, 1); | ||
110 | } | ||
111 | if (*status & I2C_PCF_LAB) { | ||
112 | DEB2(printk(KERN_INFO | ||
113 | "i2c-algo-pcf.o: lost arbitration (CSR 0x%02x)\n", | ||
114 | *status)); | ||
115 | /* Cleanup from LAB-- reset and enable ESO. | ||
116 | * This resets the PCF8584; since we've lost the bus, no | ||
117 | * further attempts should be made by callers to clean up | ||
118 | * (no i2c_stop() etc.) | ||
119 | */ | ||
120 | set_pcf(adap, 1, I2C_PCF_PIN); | ||
121 | set_pcf(adap, 1, I2C_PCF_ESO); | ||
122 | /* TODO: we should pause for a time period sufficient for any | ||
123 | * running I2C transaction to complete-- the arbitration | ||
124 | * logic won't work properly until the next START is seen. | ||
125 | */ | ||
126 | DEB2(printk(KERN_INFO | ||
127 | "i2c-algo-pcf.o: reset LAB condition (CSR 0x%02x)\n", | ||
128 | get_pcf(adap,1))); | ||
129 | return(-EINTR); | ||
130 | } | ||
131 | #endif | ||
132 | if (timeout <= 0) | ||
133 | return(-1); | ||
134 | else | ||
135 | return(0); | ||
136 | } | ||
137 | |||
138 | /* | ||
139 | * This should perform the 'PCF8584 initialization sequence' as described | ||
140 | * in the Philips IC12 data book (1995, Aug 29). | ||
141 | * There should be a 30 clock cycle wait after reset, I assume this | ||
142 | * has been fulfilled. | ||
143 | * There should be a delay at the end equal to the longest I2C message | ||
144 | * to synchronize the BB-bit (in multimaster systems). How long is | ||
145 | * this? I assume 1 second is always long enough. | ||
146 | * | ||
147 | * vdovikin: added detect code for PCF8584 | ||
148 | */ | ||
149 | static int pcf_init_8584 (struct i2c_algo_pcf_data *adap) | ||
150 | { | ||
151 | unsigned char temp; | ||
152 | |||
153 | DEB3(printk(KERN_DEBUG "i2c-algo-pcf.o: PCF state 0x%02x\n", get_pcf(adap, 1))); | ||
154 | |||
155 | /* S1=0x80: S0 selected, serial interface off */ | ||
156 | set_pcf(adap, 1, I2C_PCF_PIN); | ||
157 | /* check to see S1 now used as R/W ctrl - | ||
158 | PCF8584 does that when ESO is zero */ | ||
159 | if (((temp = get_pcf(adap, 1)) & 0x7f) != (0)) { | ||
160 | DEB2(printk(KERN_ERR "i2c-algo-pcf.o: PCF detection failed -- can't select S0 (0x%02x).\n", temp)); | ||
161 | return -ENXIO; /* definetly not PCF8584 */ | ||
162 | } | ||
163 | |||
164 | /* load own address in S0, effective address is (own << 1) */ | ||
165 | i2c_outb(adap, get_own(adap)); | ||
166 | /* check it's really written */ | ||
167 | if ((temp = i2c_inb(adap)) != get_own(adap)) { | ||
168 | DEB2(printk(KERN_ERR "i2c-algo-pcf.o: PCF detection failed -- can't set S0 (0x%02x).\n", temp)); | ||
169 | return -ENXIO; | ||
170 | } | ||
171 | |||
172 | /* S1=0xA0, next byte in S2 */ | ||
173 | set_pcf(adap, 1, I2C_PCF_PIN | I2C_PCF_ES1); | ||
174 | /* check to see S2 now selected */ | ||
175 | if (((temp = get_pcf(adap, 1)) & 0x7f) != I2C_PCF_ES1) { | ||
176 | DEB2(printk(KERN_ERR "i2c-algo-pcf.o: PCF detection failed -- can't select S2 (0x%02x).\n", temp)); | ||
177 | return -ENXIO; | ||
178 | } | ||
179 | |||
180 | /* load clock register S2 */ | ||
181 | i2c_outb(adap, get_clock(adap)); | ||
182 | /* check it's really written, the only 5 lowest bits does matter */ | ||
183 | if (((temp = i2c_inb(adap)) & 0x1f) != get_clock(adap)) { | ||
184 | DEB2(printk(KERN_ERR "i2c-algo-pcf.o: PCF detection failed -- can't set S2 (0x%02x).\n", temp)); | ||
185 | return -ENXIO; | ||
186 | } | ||
187 | |||
188 | /* Enable serial interface, idle, S0 selected */ | ||
189 | set_pcf(adap, 1, I2C_PCF_IDLE); | ||
190 | |||
191 | /* check to see PCF is really idled and we can access status register */ | ||
192 | if ((temp = get_pcf(adap, 1)) != (I2C_PCF_PIN | I2C_PCF_BB)) { | ||
193 | DEB2(printk(KERN_ERR "i2c-algo-pcf.o: PCF detection failed -- can't select S1` (0x%02x).\n", temp)); | ||
194 | return -ENXIO; | ||
195 | } | ||
196 | |||
197 | printk(KERN_DEBUG "i2c-algo-pcf.o: deteted and initialized PCF8584.\n"); | ||
198 | |||
199 | return 0; | ||
200 | } | ||
201 | |||
202 | |||
203 | /* ----- Utility functions | ||
204 | */ | ||
205 | |||
206 | static inline int try_address(struct i2c_algo_pcf_data *adap, | ||
207 | unsigned char addr, int retries) | ||
208 | { | ||
209 | int i, status, ret = -1; | ||
210 | int wfp; | ||
211 | for (i=0;i<retries;i++) { | ||
212 | i2c_outb(adap, addr); | ||
213 | i2c_start(adap); | ||
214 | status = get_pcf(adap, 1); | ||
215 | if ((wfp = wait_for_pin(adap, &status)) >= 0) { | ||
216 | if ((status & I2C_PCF_LRB) == 0) { | ||
217 | i2c_stop(adap); | ||
218 | break; /* success! */ | ||
219 | } | ||
220 | } | ||
221 | if (wfp == -EINTR) { | ||
222 | /* arbitration lost */ | ||
223 | udelay(adap->udelay); | ||
224 | return -EINTR; | ||
225 | } | ||
226 | i2c_stop(adap); | ||
227 | udelay(adap->udelay); | ||
228 | } | ||
229 | DEB2(if (i) printk(KERN_DEBUG "i2c-algo-pcf.o: needed %d retries for %d\n",i, | ||
230 | addr)); | ||
231 | return ret; | ||
232 | } | ||
233 | |||
234 | |||
235 | static int pcf_sendbytes(struct i2c_adapter *i2c_adap, const char *buf, | ||
236 | int count, int last) | ||
237 | { | ||
238 | struct i2c_algo_pcf_data *adap = i2c_adap->algo_data; | ||
239 | int wrcount, status, timeout; | ||
240 | |||
241 | for (wrcount=0; wrcount<count; ++wrcount) { | ||
242 | DEB2(dev_dbg(&i2c_adap->dev, "i2c_write: writing %2.2X\n", | ||
243 | buf[wrcount]&0xff)); | ||
244 | i2c_outb(adap, buf[wrcount]); | ||
245 | timeout = wait_for_pin(adap, &status); | ||
246 | if (timeout) { | ||
247 | if (timeout == -EINTR) { | ||
248 | /* arbitration lost */ | ||
249 | return -EINTR; | ||
250 | } | ||
251 | i2c_stop(adap); | ||
252 | dev_err(&i2c_adap->dev, "i2c_write: error - timeout.\n"); | ||
253 | return -EREMOTEIO; /* got a better one ?? */ | ||
254 | } | ||
255 | #ifndef STUB_I2C | ||
256 | if (status & I2C_PCF_LRB) { | ||
257 | i2c_stop(adap); | ||
258 | dev_err(&i2c_adap->dev, "i2c_write: error - no ack.\n"); | ||
259 | return -EREMOTEIO; /* got a better one ?? */ | ||
260 | } | ||
261 | #endif | ||
262 | } | ||
263 | if (last) { | ||
264 | i2c_stop(adap); | ||
265 | } | ||
266 | else { | ||
267 | i2c_repstart(adap); | ||
268 | } | ||
269 | |||
270 | return (wrcount); | ||
271 | } | ||
272 | |||
273 | |||
274 | static int pcf_readbytes(struct i2c_adapter *i2c_adap, char *buf, | ||
275 | int count, int last) | ||
276 | { | ||
277 | int i, status; | ||
278 | struct i2c_algo_pcf_data *adap = i2c_adap->algo_data; | ||
279 | int wfp; | ||
280 | |||
281 | /* increment number of bytes to read by one -- read dummy byte */ | ||
282 | for (i = 0; i <= count; i++) { | ||
283 | |||
284 | if ((wfp = wait_for_pin(adap, &status))) { | ||
285 | if (wfp == -EINTR) { | ||
286 | /* arbitration lost */ | ||
287 | return -EINTR; | ||
288 | } | ||
289 | i2c_stop(adap); | ||
290 | dev_err(&i2c_adap->dev, "pcf_readbytes timed out.\n"); | ||
291 | return (-1); | ||
292 | } | ||
293 | |||
294 | #ifndef STUB_I2C | ||
295 | if ((status & I2C_PCF_LRB) && (i != count)) { | ||
296 | i2c_stop(adap); | ||
297 | dev_err(&i2c_adap->dev, "i2c_read: i2c_inb, No ack.\n"); | ||
298 | return (-1); | ||
299 | } | ||
300 | #endif | ||
301 | |||
302 | if (i == count - 1) { | ||
303 | set_pcf(adap, 1, I2C_PCF_ESO); | ||
304 | } else | ||
305 | if (i == count) { | ||
306 | if (last) { | ||
307 | i2c_stop(adap); | ||
308 | } else { | ||
309 | i2c_repstart(adap); | ||
310 | } | ||
311 | }; | ||
312 | |||
313 | if (i) { | ||
314 | buf[i - 1] = i2c_inb(adap); | ||
315 | } else { | ||
316 | i2c_inb(adap); /* dummy read */ | ||
317 | } | ||
318 | } | ||
319 | |||
320 | return (i - 1); | ||
321 | } | ||
322 | |||
323 | |||
324 | static inline int pcf_doAddress(struct i2c_algo_pcf_data *adap, | ||
325 | struct i2c_msg *msg, int retries) | ||
326 | { | ||
327 | unsigned short flags = msg->flags; | ||
328 | unsigned char addr; | ||
329 | int ret; | ||
330 | if ( (flags & I2C_M_TEN) ) { | ||
331 | /* a ten bit address */ | ||
332 | addr = 0xf0 | (( msg->addr >> 7) & 0x03); | ||
333 | DEB2(printk(KERN_DEBUG "addr0: %d\n",addr)); | ||
334 | /* try extended address code...*/ | ||
335 | ret = try_address(adap, addr, retries); | ||
336 | if (ret!=1) { | ||
337 | printk(KERN_ERR "died at extended address code.\n"); | ||
338 | return -EREMOTEIO; | ||
339 | } | ||
340 | /* the remaining 8 bit address */ | ||
341 | i2c_outb(adap,msg->addr & 0x7f); | ||
342 | /* Status check comes here */ | ||
343 | if (ret != 1) { | ||
344 | printk(KERN_ERR "died at 2nd address code.\n"); | ||
345 | return -EREMOTEIO; | ||
346 | } | ||
347 | if ( flags & I2C_M_RD ) { | ||
348 | i2c_repstart(adap); | ||
349 | /* okay, now switch into reading mode */ | ||
350 | addr |= 0x01; | ||
351 | ret = try_address(adap, addr, retries); | ||
352 | if (ret!=1) { | ||
353 | printk(KERN_ERR "died at extended address code.\n"); | ||
354 | return -EREMOTEIO; | ||
355 | } | ||
356 | } | ||
357 | } else { /* normal 7bit address */ | ||
358 | addr = ( msg->addr << 1 ); | ||
359 | if (flags & I2C_M_RD ) | ||
360 | addr |= 1; | ||
361 | if (flags & I2C_M_REV_DIR_ADDR ) | ||
362 | addr ^= 1; | ||
363 | i2c_outb(adap, addr); | ||
364 | } | ||
365 | return 0; | ||
366 | } | ||
367 | |||
368 | static int pcf_xfer(struct i2c_adapter *i2c_adap, | ||
369 | struct i2c_msg *msgs, | ||
370 | int num) | ||
371 | { | ||
372 | struct i2c_algo_pcf_data *adap = i2c_adap->algo_data; | ||
373 | struct i2c_msg *pmsg; | ||
374 | int i; | ||
375 | int ret=0, timeout, status; | ||
376 | |||
377 | |||
378 | /* Check for bus busy */ | ||
379 | timeout = wait_for_bb(adap); | ||
380 | if (timeout) { | ||
381 | DEB2(printk(KERN_ERR "i2c-algo-pcf.o: " | ||
382 | "Timeout waiting for BB in pcf_xfer\n");) | ||
383 | return -EIO; | ||
384 | } | ||
385 | |||
386 | for (i = 0;ret >= 0 && i < num; i++) { | ||
387 | pmsg = &msgs[i]; | ||
388 | |||
389 | DEB2(printk(KERN_DEBUG "i2c-algo-pcf.o: Doing %s %d bytes to 0x%02x - %d of %d messages\n", | ||
390 | pmsg->flags & I2C_M_RD ? "read" : "write", | ||
391 | pmsg->len, pmsg->addr, i + 1, num);) | ||
392 | |||
393 | ret = pcf_doAddress(adap, pmsg, i2c_adap->retries); | ||
394 | |||
395 | /* Send START */ | ||
396 | if (i == 0) { | ||
397 | i2c_start(adap); | ||
398 | } | ||
399 | |||
400 | /* Wait for PIN (pending interrupt NOT) */ | ||
401 | timeout = wait_for_pin(adap, &status); | ||
402 | if (timeout) { | ||
403 | if (timeout == -EINTR) { | ||
404 | /* arbitration lost */ | ||
405 | return (-EINTR); | ||
406 | } | ||
407 | i2c_stop(adap); | ||
408 | DEB2(printk(KERN_ERR "i2c-algo-pcf.o: Timeout waiting " | ||
409 | "for PIN(1) in pcf_xfer\n");) | ||
410 | return (-EREMOTEIO); | ||
411 | } | ||
412 | |||
413 | #ifndef STUB_I2C | ||
414 | /* Check LRB (last rcvd bit - slave ack) */ | ||
415 | if (status & I2C_PCF_LRB) { | ||
416 | i2c_stop(adap); | ||
417 | DEB2(printk(KERN_ERR "i2c-algo-pcf.o: No LRB(1) in pcf_xfer\n");) | ||
418 | return (-EREMOTEIO); | ||
419 | } | ||
420 | #endif | ||
421 | |||
422 | DEB3(printk(KERN_DEBUG "i2c-algo-pcf.o: Msg %d, addr=0x%x, flags=0x%x, len=%d\n", | ||
423 | i, msgs[i].addr, msgs[i].flags, msgs[i].len);) | ||
424 | |||
425 | /* Read */ | ||
426 | if (pmsg->flags & I2C_M_RD) { | ||
427 | /* read bytes into buffer*/ | ||
428 | ret = pcf_readbytes(i2c_adap, pmsg->buf, pmsg->len, | ||
429 | (i + 1 == num)); | ||
430 | |||
431 | if (ret != pmsg->len) { | ||
432 | DEB2(printk(KERN_DEBUG "i2c-algo-pcf.o: fail: " | ||
433 | "only read %d bytes.\n",ret)); | ||
434 | } else { | ||
435 | DEB2(printk(KERN_DEBUG "i2c-algo-pcf.o: read %d bytes.\n",ret)); | ||
436 | } | ||
437 | } else { /* Write */ | ||
438 | ret = pcf_sendbytes(i2c_adap, pmsg->buf, pmsg->len, | ||
439 | (i + 1 == num)); | ||
440 | |||
441 | if (ret != pmsg->len) { | ||
442 | DEB2(printk(KERN_DEBUG "i2c-algo-pcf.o: fail: " | ||
443 | "only wrote %d bytes.\n",ret)); | ||
444 | } else { | ||
445 | DEB2(printk(KERN_DEBUG "i2c-algo-pcf.o: wrote %d bytes.\n",ret)); | ||
446 | } | ||
447 | } | ||
448 | } | ||
449 | |||
450 | return (i); | ||
451 | } | ||
452 | |||
453 | static u32 pcf_func(struct i2c_adapter *adap) | ||
454 | { | ||
455 | return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL | | ||
456 | I2C_FUNC_10BIT_ADDR | I2C_FUNC_PROTOCOL_MANGLING; | ||
457 | } | ||
458 | |||
459 | /* -----exported algorithm data: ------------------------------------- */ | ||
460 | |||
461 | static struct i2c_algorithm pcf_algo = { | ||
462 | .name = "PCF8584 algorithm", | ||
463 | .id = I2C_ALGO_PCF, | ||
464 | .master_xfer = pcf_xfer, | ||
465 | .functionality = pcf_func, | ||
466 | }; | ||
467 | |||
468 | /* | ||
469 | * registering functions to load algorithms at runtime | ||
470 | */ | ||
471 | int i2c_pcf_add_bus(struct i2c_adapter *adap) | ||
472 | { | ||
473 | struct i2c_algo_pcf_data *pcf_adap = adap->algo_data; | ||
474 | int rval; | ||
475 | |||
476 | DEB2(dev_dbg(&adap->dev, "hw routines registered.\n")); | ||
477 | |||
478 | /* register new adapter to i2c module... */ | ||
479 | |||
480 | adap->id |= pcf_algo.id; | ||
481 | adap->algo = &pcf_algo; | ||
482 | |||
483 | adap->timeout = 100; /* default values, should */ | ||
484 | adap->retries = 3; /* be replaced by defines */ | ||
485 | |||
486 | rval = pcf_init_8584(pcf_adap); | ||
487 | if (!rval) | ||
488 | i2c_add_adapter(adap); | ||
489 | return rval; | ||
490 | } | ||
491 | |||
492 | |||
493 | int i2c_pcf_del_bus(struct i2c_adapter *adap) | ||
494 | { | ||
495 | return i2c_del_adapter(adap); | ||
496 | } | ||
497 | |||
498 | EXPORT_SYMBOL(i2c_pcf_add_bus); | ||
499 | EXPORT_SYMBOL(i2c_pcf_del_bus); | ||
500 | |||
501 | MODULE_AUTHOR("Hans Berglund <hb@spacetec.no>"); | ||
502 | MODULE_DESCRIPTION("I2C-Bus PCF8584 algorithm"); | ||
503 | MODULE_LICENSE("GPL"); | ||
504 | |||
505 | module_param(i2c_debug, int, S_IRUGO | S_IWUSR); | ||
506 | MODULE_PARM_DESC(i2c_debug, | ||
507 | "debug level - 0 off; 1 normal; 2,3 more verbose; 9 pcf-protocol"); | ||
diff --git a/drivers/i2c/algos/i2c-algo-pcf.h b/drivers/i2c/algos/i2c-algo-pcf.h new file mode 100644 index 000000000000..5263a9eeb8d7 --- /dev/null +++ b/drivers/i2c/algos/i2c-algo-pcf.h | |||
@@ -0,0 +1,76 @@ | |||
1 | /* -------------------------------------------------------------------- */ | ||
2 | /* i2c-pcf8584.h: PCF 8584 global defines */ | ||
3 | /* -------------------------------------------------------------------- */ | ||
4 | /* Copyright (C) 1996 Simon G. Vogl | ||
5 | 1999 Hans Berglund | ||
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 | You should have received a copy of the GNU General Public License | ||
18 | along with this program; if not, write to the Free Software | ||
19 | Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ | ||
20 | /* -------------------------------------------------------------------- */ | ||
21 | |||
22 | /* With some changes from Frodo Looijaard <frodol@dds.nl> */ | ||
23 | |||
24 | #ifndef I2C_PCF8584_H | ||
25 | #define I2C_PCF8584_H 1 | ||
26 | |||
27 | /* ----- Control register bits ---------------------------------------- */ | ||
28 | #define I2C_PCF_PIN 0x80 | ||
29 | #define I2C_PCF_ESO 0x40 | ||
30 | #define I2C_PCF_ES1 0x20 | ||
31 | #define I2C_PCF_ES2 0x10 | ||
32 | #define I2C_PCF_ENI 0x08 | ||
33 | #define I2C_PCF_STA 0x04 | ||
34 | #define I2C_PCF_STO 0x02 | ||
35 | #define I2C_PCF_ACK 0x01 | ||
36 | |||
37 | #define I2C_PCF_START (I2C_PCF_PIN | I2C_PCF_ESO | I2C_PCF_STA | I2C_PCF_ACK) | ||
38 | #define I2C_PCF_STOP (I2C_PCF_PIN | I2C_PCF_ESO | I2C_PCF_STO | I2C_PCF_ACK) | ||
39 | #define I2C_PCF_REPSTART ( I2C_PCF_ESO | I2C_PCF_STA | I2C_PCF_ACK) | ||
40 | #define I2C_PCF_IDLE (I2C_PCF_PIN | I2C_PCF_ESO | I2C_PCF_ACK) | ||
41 | |||
42 | /* ----- Status register bits ----------------------------------------- */ | ||
43 | /*#define I2C_PCF_PIN 0x80 as above*/ | ||
44 | |||
45 | #define I2C_PCF_INI 0x40 /* 1 if not initialized */ | ||
46 | #define I2C_PCF_STS 0x20 | ||
47 | #define I2C_PCF_BER 0x10 | ||
48 | #define I2C_PCF_AD0 0x08 | ||
49 | #define I2C_PCF_LRB 0x08 | ||
50 | #define I2C_PCF_AAS 0x04 | ||
51 | #define I2C_PCF_LAB 0x02 | ||
52 | #define I2C_PCF_BB 0x01 | ||
53 | |||
54 | /* ----- Chip clock frequencies --------------------------------------- */ | ||
55 | #define I2C_PCF_CLK3 0x00 | ||
56 | #define I2C_PCF_CLK443 0x10 | ||
57 | #define I2C_PCF_CLK6 0x14 | ||
58 | #define I2C_PCF_CLK 0x18 | ||
59 | #define I2C_PCF_CLK12 0x1c | ||
60 | |||
61 | /* ----- transmission frequencies ------------------------------------- */ | ||
62 | #define I2C_PCF_TRNS90 0x00 /* 90 kHz */ | ||
63 | #define I2C_PCF_TRNS45 0x01 /* 45 kHz */ | ||
64 | #define I2C_PCF_TRNS11 0x02 /* 11 kHz */ | ||
65 | #define I2C_PCF_TRNS15 0x03 /* 1.5 kHz */ | ||
66 | |||
67 | |||
68 | /* ----- Access to internal registers according to ES1,ES2 ------------ */ | ||
69 | /* they are mapped to the data port ( a0 = 0 ) */ | ||
70 | /* available when ESO == 0 : */ | ||
71 | |||
72 | #define I2C_PCF_OWNADR 0 | ||
73 | #define I2C_PCF_INTREG I2C_PCF_ES2 | ||
74 | #define I2C_PCF_CLKREG I2C_PCF_ES1 | ||
75 | |||
76 | #endif /* I2C_PCF8584_H */ | ||
diff --git a/drivers/i2c/algos/i2c-algo-sgi.c b/drivers/i2c/algos/i2c-algo-sgi.c new file mode 100644 index 000000000000..422721b241e5 --- /dev/null +++ b/drivers/i2c/algos/i2c-algo-sgi.c | |||
@@ -0,0 +1,189 @@ | |||
1 | /* | ||
2 | * i2c-algo-sgi.c: i2c driver algorithms for SGI adapters. | ||
3 | * | ||
4 | * This file is subject to the terms and conditions of the GNU General Public | ||
5 | * License version 2 as published by the Free Software Foundation. | ||
6 | * | ||
7 | * Copyright (C) 2003 Ladislav Michl <ladis@linux-mips.org> | ||
8 | */ | ||
9 | |||
10 | #include <linux/kernel.h> | ||
11 | #include <linux/module.h> | ||
12 | #include <linux/init.h> | ||
13 | #include <linux/errno.h> | ||
14 | #include <linux/delay.h> | ||
15 | |||
16 | #include <linux/i2c.h> | ||
17 | #include <linux/i2c-algo-sgi.h> | ||
18 | |||
19 | |||
20 | #define SGI_I2C_FORCE_IDLE (0 << 0) | ||
21 | #define SGI_I2C_NOT_IDLE (1 << 0) | ||
22 | #define SGI_I2C_WRITE (0 << 1) | ||
23 | #define SGI_I2C_READ (1 << 1) | ||
24 | #define SGI_I2C_RELEASE_BUS (0 << 2) | ||
25 | #define SGI_I2C_HOLD_BUS (1 << 2) | ||
26 | #define SGI_I2C_XFER_DONE (0 << 4) | ||
27 | #define SGI_I2C_XFER_BUSY (1 << 4) | ||
28 | #define SGI_I2C_ACK (0 << 5) | ||
29 | #define SGI_I2C_NACK (1 << 5) | ||
30 | #define SGI_I2C_BUS_OK (0 << 7) | ||
31 | #define SGI_I2C_BUS_ERR (1 << 7) | ||
32 | |||
33 | #define get_control() adap->getctrl(adap->data) | ||
34 | #define set_control(val) adap->setctrl(adap->data, val) | ||
35 | #define read_data() adap->rdata(adap->data) | ||
36 | #define write_data(val) adap->wdata(adap->data, val) | ||
37 | |||
38 | |||
39 | static int wait_xfer_done(struct i2c_algo_sgi_data *adap) | ||
40 | { | ||
41 | int i; | ||
42 | |||
43 | for (i = 0; i < adap->xfer_timeout; i++) { | ||
44 | if ((get_control() & SGI_I2C_XFER_BUSY) == 0) | ||
45 | return 0; | ||
46 | udelay(1); | ||
47 | } | ||
48 | |||
49 | return -ETIMEDOUT; | ||
50 | } | ||
51 | |||
52 | static int wait_ack(struct i2c_algo_sgi_data *adap) | ||
53 | { | ||
54 | int i; | ||
55 | |||
56 | if (wait_xfer_done(adap)) | ||
57 | return -ETIMEDOUT; | ||
58 | for (i = 0; i < adap->ack_timeout; i++) { | ||
59 | if ((get_control() & SGI_I2C_NACK) == 0) | ||
60 | return 0; | ||
61 | udelay(1); | ||
62 | } | ||
63 | |||
64 | return -ETIMEDOUT; | ||
65 | } | ||
66 | |||
67 | static int force_idle(struct i2c_algo_sgi_data *adap) | ||
68 | { | ||
69 | int i; | ||
70 | |||
71 | set_control(SGI_I2C_FORCE_IDLE); | ||
72 | for (i = 0; i < adap->xfer_timeout; i++) { | ||
73 | if ((get_control() & SGI_I2C_NOT_IDLE) == 0) | ||
74 | goto out; | ||
75 | udelay(1); | ||
76 | } | ||
77 | return -ETIMEDOUT; | ||
78 | out: | ||
79 | if (get_control() & SGI_I2C_BUS_ERR) | ||
80 | return -EIO; | ||
81 | return 0; | ||
82 | } | ||
83 | |||
84 | static int do_address(struct i2c_algo_sgi_data *adap, unsigned int addr, | ||
85 | int rd) | ||
86 | { | ||
87 | if (rd) | ||
88 | set_control(SGI_I2C_NOT_IDLE); | ||
89 | /* Check if bus is idle, eventually force it to do so */ | ||
90 | if (get_control() & SGI_I2C_NOT_IDLE) | ||
91 | if (force_idle(adap)) | ||
92 | return -EIO; | ||
93 | /* Write out the i2c chip address and specify operation */ | ||
94 | set_control(SGI_I2C_HOLD_BUS | SGI_I2C_WRITE | SGI_I2C_NOT_IDLE); | ||
95 | if (rd) | ||
96 | addr |= 1; | ||
97 | write_data(addr); | ||
98 | if (wait_ack(adap)) | ||
99 | return -EIO; | ||
100 | return 0; | ||
101 | } | ||
102 | |||
103 | static int i2c_read(struct i2c_algo_sgi_data *adap, unsigned char *buf, | ||
104 | unsigned int len) | ||
105 | { | ||
106 | int i; | ||
107 | |||
108 | set_control(SGI_I2C_HOLD_BUS | SGI_I2C_READ | SGI_I2C_NOT_IDLE); | ||
109 | for (i = 0; i < len; i++) { | ||
110 | if (wait_xfer_done(adap)) | ||
111 | return -EIO; | ||
112 | buf[i] = read_data(); | ||
113 | } | ||
114 | set_control(SGI_I2C_RELEASE_BUS | SGI_I2C_FORCE_IDLE); | ||
115 | |||
116 | return 0; | ||
117 | |||
118 | } | ||
119 | |||
120 | static int i2c_write(struct i2c_algo_sgi_data *adap, unsigned char *buf, | ||
121 | unsigned int len) | ||
122 | { | ||
123 | int i; | ||
124 | |||
125 | /* We are already in write state */ | ||
126 | for (i = 0; i < len; i++) { | ||
127 | write_data(buf[i]); | ||
128 | if (wait_ack(adap)) | ||
129 | return -EIO; | ||
130 | } | ||
131 | return 0; | ||
132 | } | ||
133 | |||
134 | static int sgi_xfer(struct i2c_adapter *i2c_adap, struct i2c_msg *msgs, | ||
135 | int num) | ||
136 | { | ||
137 | struct i2c_algo_sgi_data *adap = i2c_adap->algo_data; | ||
138 | struct i2c_msg *p; | ||
139 | int i, err = 0; | ||
140 | |||
141 | for (i = 0; !err && i < num; i++) { | ||
142 | p = &msgs[i]; | ||
143 | err = do_address(adap, p->addr, p->flags & I2C_M_RD); | ||
144 | if (err || !p->len) | ||
145 | continue; | ||
146 | if (p->flags & I2C_M_RD) | ||
147 | err = i2c_read(adap, p->buf, p->len); | ||
148 | else | ||
149 | err = i2c_write(adap, p->buf, p->len); | ||
150 | } | ||
151 | |||
152 | return err; | ||
153 | } | ||
154 | |||
155 | static u32 sgi_func(struct i2c_adapter *adap) | ||
156 | { | ||
157 | return I2C_FUNC_SMBUS_EMUL; | ||
158 | } | ||
159 | |||
160 | static struct i2c_algorithm sgi_algo = { | ||
161 | .name = "SGI algorithm", | ||
162 | .id = I2C_ALGO_SGI, | ||
163 | .master_xfer = sgi_xfer, | ||
164 | .functionality = sgi_func, | ||
165 | }; | ||
166 | |||
167 | /* | ||
168 | * registering functions to load algorithms at runtime | ||
169 | */ | ||
170 | int i2c_sgi_add_bus(struct i2c_adapter *adap) | ||
171 | { | ||
172 | adap->id |= sgi_algo.id; | ||
173 | adap->algo = &sgi_algo; | ||
174 | |||
175 | return i2c_add_adapter(adap); | ||
176 | } | ||
177 | |||
178 | |||
179 | int i2c_sgi_del_bus(struct i2c_adapter *adap) | ||
180 | { | ||
181 | return i2c_del_adapter(adap); | ||
182 | } | ||
183 | |||
184 | EXPORT_SYMBOL(i2c_sgi_add_bus); | ||
185 | EXPORT_SYMBOL(i2c_sgi_del_bus); | ||
186 | |||
187 | MODULE_AUTHOR("Ladislav Michl <ladis@linux-mips.org>"); | ||
188 | MODULE_DESCRIPTION("I2C-Bus SGI algorithm"); | ||
189 | MODULE_LICENSE("GPL"); | ||
diff --git a/drivers/i2c/algos/i2c-algo-sibyte.c b/drivers/i2c/algos/i2c-algo-sibyte.c new file mode 100644 index 000000000000..35789bb7126a --- /dev/null +++ b/drivers/i2c/algos/i2c-algo-sibyte.c | |||
@@ -0,0 +1,222 @@ | |||
1 | /* ------------------------------------------------------------------------- */ | ||
2 | /* i2c-algo-sibyte.c i2c driver algorithms for bit-shift adapters */ | ||
3 | /* ------------------------------------------------------------------------- */ | ||
4 | /* Copyright (C) 2001,2002,2003 Broadcom Corporation | ||
5 | Copyright (C) 1995-2000 Simon G. Vogl | ||
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 | You should have received a copy of the GNU General Public License | ||
18 | along with this program; if not, write to the Free Software | ||
19 | Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ | ||
20 | /* ------------------------------------------------------------------------- */ | ||
21 | |||
22 | /* With some changes from Kyösti Mälkki <kmalkki@cc.hut.fi> and even | ||
23 | Frodo Looijaard <frodol@dds.nl>. */ | ||
24 | |||
25 | /* Ported for SiByte SOCs by Broadcom Corporation. */ | ||
26 | |||
27 | #include <linux/config.h> | ||
28 | #include <linux/kernel.h> | ||
29 | #include <linux/module.h> | ||
30 | #include <linux/init.h> | ||
31 | |||
32 | #include <asm/io.h> | ||
33 | #include <asm/sibyte/sb1250_regs.h> | ||
34 | #include <asm/sibyte/sb1250_smbus.h> | ||
35 | |||
36 | #include <linux/i2c.h> | ||
37 | #include <linux/i2c-algo-sibyte.h> | ||
38 | |||
39 | /* ----- global defines ----------------------------------------------- */ | ||
40 | #define SMB_CSR(a,r) ((long)(a->reg_base + r)) | ||
41 | |||
42 | /* ----- global variables --------------------------------------------- */ | ||
43 | |||
44 | /* module parameters: | ||
45 | */ | ||
46 | static int bit_scan=0; /* have a look at what's hanging 'round */ | ||
47 | |||
48 | |||
49 | static int smbus_xfer(struct i2c_adapter *i2c_adap, u16 addr, | ||
50 | unsigned short flags, char read_write, | ||
51 | u8 command, int size, union i2c_smbus_data * data) | ||
52 | { | ||
53 | struct i2c_algo_sibyte_data *adap = i2c_adap->algo_data; | ||
54 | int data_bytes = 0; | ||
55 | int error; | ||
56 | |||
57 | while (csr_in32(SMB_CSR(adap, R_SMB_STATUS)) & M_SMB_BUSY) | ||
58 | ; | ||
59 | |||
60 | switch (size) { | ||
61 | case I2C_SMBUS_QUICK: | ||
62 | csr_out32((V_SMB_ADDR(addr) | (read_write == I2C_SMBUS_READ ? M_SMB_QDATA : 0) | | ||
63 | V_SMB_TT_QUICKCMD), SMB_CSR(adap, R_SMB_START)); | ||
64 | break; | ||
65 | case I2C_SMBUS_BYTE: | ||
66 | if (read_write == I2C_SMBUS_READ) { | ||
67 | csr_out32((V_SMB_ADDR(addr) | V_SMB_TT_RD1BYTE), | ||
68 | SMB_CSR(adap, R_SMB_START)); | ||
69 | data_bytes = 1; | ||
70 | } else { | ||
71 | csr_out32(V_SMB_CMD(command), SMB_CSR(adap, R_SMB_CMD)); | ||
72 | csr_out32((V_SMB_ADDR(addr) | V_SMB_TT_WR1BYTE), | ||
73 | SMB_CSR(adap, R_SMB_START)); | ||
74 | } | ||
75 | break; | ||
76 | case I2C_SMBUS_BYTE_DATA: | ||
77 | csr_out32(V_SMB_CMD(command), SMB_CSR(adap, R_SMB_CMD)); | ||
78 | if (read_write == I2C_SMBUS_READ) { | ||
79 | csr_out32((V_SMB_ADDR(addr) | V_SMB_TT_CMD_RD1BYTE), | ||
80 | SMB_CSR(adap, R_SMB_START)); | ||
81 | data_bytes = 1; | ||
82 | } else { | ||
83 | csr_out32(V_SMB_LB(data->byte), SMB_CSR(adap, R_SMB_DATA)); | ||
84 | csr_out32((V_SMB_ADDR(addr) | V_SMB_TT_WR2BYTE), | ||
85 | SMB_CSR(adap, R_SMB_START)); | ||
86 | } | ||
87 | break; | ||
88 | case I2C_SMBUS_WORD_DATA: | ||
89 | csr_out32(V_SMB_CMD(command), SMB_CSR(adap, R_SMB_CMD)); | ||
90 | if (read_write == I2C_SMBUS_READ) { | ||
91 | csr_out32((V_SMB_ADDR(addr) | V_SMB_TT_CMD_RD2BYTE), | ||
92 | SMB_CSR(adap, R_SMB_START)); | ||
93 | data_bytes = 2; | ||
94 | } else { | ||
95 | csr_out32(V_SMB_LB(data->word & 0xff), SMB_CSR(adap, R_SMB_DATA)); | ||
96 | csr_out32(V_SMB_MB(data->word >> 8), SMB_CSR(adap, R_SMB_DATA)); | ||
97 | csr_out32((V_SMB_ADDR(addr) | V_SMB_TT_WR2BYTE), | ||
98 | SMB_CSR(adap, R_SMB_START)); | ||
99 | } | ||
100 | break; | ||
101 | default: | ||
102 | return -1; /* XXXKW better error code? */ | ||
103 | } | ||
104 | |||
105 | while (csr_in32(SMB_CSR(adap, R_SMB_STATUS)) & M_SMB_BUSY) | ||
106 | ; | ||
107 | |||
108 | error = csr_in32(SMB_CSR(adap, R_SMB_STATUS)); | ||
109 | if (error & M_SMB_ERROR) { | ||
110 | /* Clear error bit by writing a 1 */ | ||
111 | csr_out32(M_SMB_ERROR, SMB_CSR(adap, R_SMB_STATUS)); | ||
112 | return -1; /* XXXKW better error code? */ | ||
113 | } | ||
114 | |||
115 | if (data_bytes == 1) | ||
116 | data->byte = csr_in32(SMB_CSR(adap, R_SMB_DATA)) & 0xff; | ||
117 | if (data_bytes == 2) | ||
118 | data->word = csr_in32(SMB_CSR(adap, R_SMB_DATA)) & 0xffff; | ||
119 | |||
120 | return 0; | ||
121 | } | ||
122 | |||
123 | static int algo_control(struct i2c_adapter *adapter, | ||
124 | unsigned int cmd, unsigned long arg) | ||
125 | { | ||
126 | return 0; | ||
127 | } | ||
128 | |||
129 | static u32 bit_func(struct i2c_adapter *adap) | ||
130 | { | ||
131 | return (I2C_FUNC_SMBUS_QUICK | I2C_FUNC_SMBUS_BYTE | | ||
132 | I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA); | ||
133 | } | ||
134 | |||
135 | |||
136 | /* -----exported algorithm data: ------------------------------------- */ | ||
137 | |||
138 | static struct i2c_algorithm i2c_sibyte_algo = { | ||
139 | .name = "SiByte algorithm", | ||
140 | .id = I2C_ALGO_SIBYTE, | ||
141 | .smbus_xfer = smbus_xfer, | ||
142 | .algo_control = algo_control, /* ioctl */ | ||
143 | .functionality = bit_func, | ||
144 | }; | ||
145 | |||
146 | /* | ||
147 | * registering functions to load algorithms at runtime | ||
148 | */ | ||
149 | int i2c_sibyte_add_bus(struct i2c_adapter *i2c_adap, int speed) | ||
150 | { | ||
151 | int i; | ||
152 | struct i2c_algo_sibyte_data *adap = i2c_adap->algo_data; | ||
153 | |||
154 | /* register new adapter to i2c module... */ | ||
155 | |||
156 | i2c_adap->id |= i2c_sibyte_algo.id; | ||
157 | i2c_adap->algo = &i2c_sibyte_algo; | ||
158 | |||
159 | /* Set the frequency to 100 kHz */ | ||
160 | csr_out32(speed, SMB_CSR(adap,R_SMB_FREQ)); | ||
161 | csr_out32(0, SMB_CSR(adap,R_SMB_CONTROL)); | ||
162 | |||
163 | /* scan bus */ | ||
164 | if (bit_scan) { | ||
165 | union i2c_smbus_data data; | ||
166 | int rc; | ||
167 | printk(KERN_INFO " i2c-algo-sibyte.o: scanning bus %s.\n", | ||
168 | i2c_adap->name); | ||
169 | for (i = 0x00; i < 0x7f; i++) { | ||
170 | /* XXXKW is this a realistic probe? */ | ||
171 | rc = smbus_xfer(i2c_adap, i, 0, I2C_SMBUS_READ, 0, | ||
172 | I2C_SMBUS_BYTE_DATA, &data); | ||
173 | if (!rc) { | ||
174 | printk("(%02x)",i); | ||
175 | } else | ||
176 | printk("."); | ||
177 | } | ||
178 | printk("\n"); | ||
179 | } | ||
180 | |||
181 | i2c_add_adapter(i2c_adap); | ||
182 | |||
183 | return 0; | ||
184 | } | ||
185 | |||
186 | |||
187 | int i2c_sibyte_del_bus(struct i2c_adapter *adap) | ||
188 | { | ||
189 | int res; | ||
190 | |||
191 | if ((res = i2c_del_adapter(adap)) < 0) | ||
192 | return res; | ||
193 | |||
194 | return 0; | ||
195 | } | ||
196 | |||
197 | int __init i2c_algo_sibyte_init (void) | ||
198 | { | ||
199 | printk("i2c-algo-sibyte.o: i2c SiByte algorithm module\n"); | ||
200 | return 0; | ||
201 | } | ||
202 | |||
203 | |||
204 | EXPORT_SYMBOL(i2c_sibyte_add_bus); | ||
205 | EXPORT_SYMBOL(i2c_sibyte_del_bus); | ||
206 | |||
207 | #ifdef MODULE | ||
208 | MODULE_AUTHOR("Kip Walker, Broadcom Corp."); | ||
209 | MODULE_DESCRIPTION("SiByte I2C-Bus algorithm"); | ||
210 | MODULE_PARM(bit_scan, "i"); | ||
211 | MODULE_PARM_DESC(bit_scan, "Scan for active chips on the bus"); | ||
212 | MODULE_LICENSE("GPL"); | ||
213 | |||
214 | int init_module(void) | ||
215 | { | ||
216 | return i2c_algo_sibyte_init(); | ||
217 | } | ||
218 | |||
219 | void cleanup_module(void) | ||
220 | { | ||
221 | } | ||
222 | #endif | ||