blob: 21c36bfb5e6bf1b25522e7492bef978e29a8bde0 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/* ------------------------------------------------------------------------- */
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 */
47static int i2c_debug;
48static 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
57static inline void sdalo(struct i2c_algo_bit_data *adap)
58{
59 setsda(adap,0);
60 udelay(adap->udelay);
61}
62
63static inline void sdahi(struct i2c_algo_bit_data *adap)
64{
65 setsda(adap,1);
66 udelay(adap->udelay);
67}
68
69static 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 */
Jean Delvare7b288a02006-09-03 22:22:12 +020079static int sclhi(struct i2c_algo_bit_data *adap)
Linus Torvalds1da177e2005-04-16 15:20:36 -070080{
81 unsigned long start;
82
83 setscl(adap,1);
84
85 /* Not all adapters have scl sense line... */
Jean Delvare7b288a02006-09-03 22:22:12 +020086 if (!adap->getscl)
87 goto done;
Linus Torvalds1da177e2005-04-16 15:20:36 -070088
89 start=jiffies;
90 while (! getscl(adap) ) {
91 /* the hw knows how to read the clock line,
92 * so we wait until it actually gets high.
93 * This is safer as some chips may hold it low
94 * while they are processing data internally.
95 */
96 if (time_after_eq(jiffies, start+adap->timeout)) {
97 return -ETIMEDOUT;
98 }
99 cond_resched();
100 }
101 DEBSTAT(printk(KERN_DEBUG "needed %ld jiffies\n", jiffies-start));
Jean Delvare7b288a02006-09-03 22:22:12 +0200102
103done:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104 udelay(adap->udelay);
105 return 0;
106}
107
108
109/* --- other auxiliary functions -------------------------------------- */
110static 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
118static 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700124
125 sdalo(adap);
126 scllo(adap);
127}
128
129
130static void i2c_stop(struct i2c_algo_bit_data *adap)
131{
132 DEBPROTO(printk("P\n"));
133 /* assert: scl is low */
134 sdalo(adap);
135 sclhi(adap);
136 sdahi(adap);
137}
138
139
140
141/* send a byte without start cond., look for arbitration,
142 check ackn. from slave */
143/* returns:
144 * 1 if the device acknowledged
145 * 0 if the device did not ack
146 * -ETIMEDOUT if an error occurred (while raising the scl line)
147 */
148static int i2c_outb(struct i2c_adapter *i2c_adap, char c)
149{
150 int i;
151 int sb;
152 int ack;
153 struct i2c_algo_bit_data *adap = i2c_adap->algo_data;
154
155 /* assert: scl is low */
156 for ( i=7 ; i>=0 ; i-- ) {
157 sb = c & ( 1 << i );
158 setsda(adap,sb);
159 udelay(adap->udelay);
160 DEBPROTO(printk(KERN_DEBUG "%d",sb!=0));
161 if (sclhi(adap)<0) { /* timed out */
162 sdahi(adap); /* we don't want to block the net */
163 DEB2(printk(KERN_DEBUG " i2c_outb: 0x%02x, timeout at bit #%d\n", c&0xff, i));
164 return -ETIMEDOUT;
165 };
166 /* do arbitration here:
167 * if ( sb && ! getsda(adap) ) -> ouch! Get out of here.
168 */
169 setscl(adap, 0 );
170 udelay(adap->udelay);
171 }
172 sdahi(adap);
173 if (sclhi(adap)<0){ /* timeout */
174 DEB2(printk(KERN_DEBUG " i2c_outb: 0x%02x, timeout at ack\n", c&0xff));
175 return -ETIMEDOUT;
176 };
177 /* read ack: SDA should be pulled down by slave */
178 ack=getsda(adap); /* ack: sda is pulled low ->success. */
179 DEB2(printk(KERN_DEBUG " i2c_outb: 0x%02x , getsda() = %d\n", c & 0xff, ack));
180
181 DEBPROTO( printk(KERN_DEBUG "[%2.2x]",c&0xff) );
182 DEBPROTO(if (0==ack){ printk(KERN_DEBUG " A ");} else printk(KERN_DEBUG " NA ") );
183 scllo(adap);
184 return 0==ack; /* return 1 if device acked */
185 /* assert: scl is low (sda undef) */
186}
187
188
189static int i2c_inb(struct i2c_adapter *i2c_adap)
190{
191 /* read byte via i2c port, without start/stop sequence */
192 /* acknowledge is sent in i2c_read. */
193 int i;
194 unsigned char indata=0;
195 struct i2c_algo_bit_data *adap = i2c_adap->algo_data;
196
197 /* assert: scl is low */
198 sdahi(adap);
199 for (i=0;i<8;i++) {
200 if (sclhi(adap)<0) { /* timeout */
201 DEB2(printk(KERN_DEBUG " i2c_inb: timeout at bit #%d\n", 7-i));
202 return -ETIMEDOUT;
203 };
204 indata *= 2;
205 if ( getsda(adap) )
206 indata |= 0x01;
207 scllo(adap);
208 }
209 /* assert: scl is low */
210 DEB2(printk(KERN_DEBUG "i2c_inb: 0x%02x\n", indata & 0xff));
211
212 DEBPROTO(printk(KERN_DEBUG " 0x%02x", indata & 0xff));
213 return (int) (indata & 0xff);
214}
215
216/*
217 * Sanity check for the adapter hardware - check the reaction of
218 * the bus lines only if it seems to be idle.
219 */
220static int test_bus(struct i2c_algo_bit_data *adap, char* name) {
221 int scl,sda;
222
223 if (adap->getscl==NULL)
224 printk(KERN_INFO "i2c-algo-bit.o: Testing SDA only, "
225 "SCL is not readable.\n");
226
227 sda=getsda(adap);
228 scl=(adap->getscl==NULL?1:getscl(adap));
229 printk(KERN_DEBUG "i2c-algo-bit.o: (0) scl=%d, sda=%d\n",scl,sda);
230 if (!scl || !sda ) {
231 printk(KERN_WARNING "i2c-algo-bit.o: %s seems to be busy.\n", name);
232 goto bailout;
233 }
234
235 sdalo(adap);
236 sda=getsda(adap);
237 scl=(adap->getscl==NULL?1:getscl(adap));
238 printk(KERN_DEBUG "i2c-algo-bit.o: (1) scl=%d, sda=%d\n",scl,sda);
239 if ( 0 != sda ) {
240 printk(KERN_WARNING "i2c-algo-bit.o: SDA stuck high!\n");
241 goto bailout;
242 }
243 if ( 0 == scl ) {
244 printk(KERN_WARNING "i2c-algo-bit.o: SCL unexpected low "
245 "while pulling SDA low!\n");
246 goto bailout;
247 }
248
249 sdahi(adap);
250 sda=getsda(adap);
251 scl=(adap->getscl==NULL?1:getscl(adap));
252 printk(KERN_DEBUG "i2c-algo-bit.o: (2) scl=%d, sda=%d\n",scl,sda);
253 if ( 0 == sda ) {
254 printk(KERN_WARNING "i2c-algo-bit.o: SDA stuck low!\n");
255 goto bailout;
256 }
257 if ( 0 == scl ) {
258 printk(KERN_WARNING "i2c-algo-bit.o: SCL unexpected low "
259 "while pulling SDA high!\n");
260 goto bailout;
261 }
262
263 scllo(adap);
264 sda=getsda(adap);
265 scl=(adap->getscl==NULL?0:getscl(adap));
266 printk(KERN_DEBUG "i2c-algo-bit.o: (3) scl=%d, sda=%d\n",scl,sda);
267 if ( 0 != scl ) {
268 printk(KERN_WARNING "i2c-algo-bit.o: SCL stuck high!\n");
269 goto bailout;
270 }
271 if ( 0 == sda ) {
272 printk(KERN_WARNING "i2c-algo-bit.o: SDA unexpected low "
273 "while pulling SCL low!\n");
274 goto bailout;
275 }
276
277 sclhi(adap);
278 sda=getsda(adap);
279 scl=(adap->getscl==NULL?1:getscl(adap));
280 printk(KERN_DEBUG "i2c-algo-bit.o: (4) scl=%d, sda=%d\n",scl,sda);
281 if ( 0 == scl ) {
282 printk(KERN_WARNING "i2c-algo-bit.o: SCL stuck low!\n");
283 goto bailout;
284 }
285 if ( 0 == sda ) {
286 printk(KERN_WARNING "i2c-algo-bit.o: SDA unexpected low "
287 "while pulling SCL high!\n");
288 goto bailout;
289 }
290 printk(KERN_INFO "i2c-algo-bit.o: %s passed test.\n",name);
291 return 0;
292bailout:
293 sdahi(adap);
294 sclhi(adap);
295 return -ENODEV;
296}
297
298/* ----- Utility functions
299 */
300
301/* try_address tries to contact a chip for a number of
302 * times before it gives up.
303 * return values:
304 * 1 chip answered
305 * 0 chip did not answer
306 * -x transmission error
307 */
Jean Delvare7b288a02006-09-03 22:22:12 +0200308static int try_address(struct i2c_adapter *i2c_adap,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700309 unsigned char addr, int retries)
310{
311 struct i2c_algo_bit_data *adap = i2c_adap->algo_data;
312 int i,ret = -1;
313 for (i=0;i<=retries;i++) {
314 ret = i2c_outb(i2c_adap,addr);
315 if (ret==1)
316 break; /* success! */
317 i2c_stop(adap);
318 udelay(5/*adap->udelay*/);
319 if (i==retries) /* no success */
320 break;
321 i2c_start(adap);
322 udelay(adap->udelay);
323 }
324 DEB2(if (i)
325 printk(KERN_DEBUG "i2c-algo-bit.o: Used %d tries to %s client at 0x%02x : %s\n",
326 i+1, addr & 1 ? "read" : "write", addr>>1,
327 ret==1 ? "success" : ret==0 ? "no ack" : "failed, timeout?" )
328 );
329 return ret;
330}
331
332static int sendbytes(struct i2c_adapter *i2c_adap, struct i2c_msg *msg)
333{
334 struct i2c_algo_bit_data *adap = i2c_adap->algo_data;
335 char c;
336 const char *temp = msg->buf;
337 int count = msg->len;
338 unsigned short nak_ok = msg->flags & I2C_M_IGNORE_NAK;
339 int retval;
340 int wrcount=0;
341
342 while (count > 0) {
343 c = *temp;
344 DEB2(dev_dbg(&i2c_adap->dev, "sendbytes: writing %2.2X\n", c&0xff));
345 retval = i2c_outb(i2c_adap,c);
346 if ((retval>0) || (nak_ok && (retval==0))) { /* ok or ignored NAK */
347 count--;
348 temp++;
349 wrcount++;
350 } else { /* arbitration or no acknowledge */
351 dev_err(&i2c_adap->dev, "sendbytes: error - bailout.\n");
352 i2c_stop(adap);
353 return (retval<0)? retval : -EFAULT;
354 /* got a better one ?? */
355 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356 }
357 return wrcount;
358}
359
Jean Delvare7b288a02006-09-03 22:22:12 +0200360static int readbytes(struct i2c_adapter *i2c_adap, struct i2c_msg *msg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361{
362 int inval;
363 int rdcount=0; /* counts bytes read */
364 struct i2c_algo_bit_data *adap = i2c_adap->algo_data;
365 char *temp = msg->buf;
366 int count = msg->len;
367
368 while (count > 0) {
369 inval = i2c_inb(i2c_adap);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370 if (inval>=0) {
371 *temp = inval;
372 rdcount++;
373 } else { /* read timed out */
374 printk(KERN_ERR "i2c-algo-bit.o: readbytes: i2c_inb timed out.\n");
375 break;
376 }
377
378 temp++;
379 count--;
380
381 if (msg->flags & I2C_M_NO_RD_ACK)
382 continue;
383
384 if ( count > 0 ) { /* send ack */
385 sdalo(adap);
386 DEBPROTO(printk(" Am "));
387 } else {
388 sdahi(adap); /* neg. ack on last byte */
389 DEBPROTO(printk(" NAm "));
390 }
391 if (sclhi(adap)<0) { /* timeout */
392 sdahi(adap);
393 printk(KERN_ERR "i2c-algo-bit.o: readbytes: Timeout at ack\n");
394 return -ETIMEDOUT;
395 };
396 scllo(adap);
397 sdahi(adap);
398 }
399 return rdcount;
400}
401
402/* doAddress initiates the transfer by generating the start condition (in
403 * try_address) and transmits the address in the necessary format to handle
404 * reads, writes as well as 10bit-addresses.
405 * returns:
406 * 0 everything went okay, the chip ack'ed, or IGNORE_NAK flag was set
407 * -x an error occurred (like: -EREMOTEIO if the device did not answer, or
408 * -ETIMEDOUT, for example if the lines are stuck...)
409 */
Jean Delvare7b288a02006-09-03 22:22:12 +0200410static int bit_doAddress(struct i2c_adapter *i2c_adap, struct i2c_msg *msg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411{
412 unsigned short flags = msg->flags;
413 unsigned short nak_ok = msg->flags & I2C_M_IGNORE_NAK;
414 struct i2c_algo_bit_data *adap = i2c_adap->algo_data;
415
416 unsigned char addr;
417 int ret, retries;
418
419 retries = nak_ok ? 0 : i2c_adap->retries;
420
421 if ( (flags & I2C_M_TEN) ) {
422 /* a ten bit address */
423 addr = 0xf0 | (( msg->addr >> 7) & 0x03);
424 DEB2(printk(KERN_DEBUG "addr0: %d\n",addr));
425 /* try extended address code...*/
426 ret = try_address(i2c_adap, addr, retries);
427 if ((ret != 1) && !nak_ok) {
428 printk(KERN_ERR "died at extended address code.\n");
429 return -EREMOTEIO;
430 }
431 /* the remaining 8 bit address */
432 ret = i2c_outb(i2c_adap,msg->addr & 0x7f);
433 if ((ret != 1) && !nak_ok) {
434 /* the chip did not ack / xmission error occurred */
435 printk(KERN_ERR "died at 2nd address code.\n");
436 return -EREMOTEIO;
437 }
438 if ( flags & I2C_M_RD ) {
439 i2c_repstart(adap);
440 /* okay, now switch into reading mode */
441 addr |= 0x01;
442 ret = try_address(i2c_adap, addr, retries);
443 if ((ret!=1) && !nak_ok) {
444 printk(KERN_ERR "died at extended address code.\n");
445 return -EREMOTEIO;
446 }
447 }
448 } else { /* normal 7bit address */
449 addr = ( msg->addr << 1 );
450 if (flags & I2C_M_RD )
451 addr |= 1;
452 if (flags & I2C_M_REV_DIR_ADDR )
453 addr ^= 1;
454 ret = try_address(i2c_adap, addr, retries);
455 if ((ret!=1) && !nak_ok)
456 return -EREMOTEIO;
457 }
458
459 return 0;
460}
461
462static int bit_xfer(struct i2c_adapter *i2c_adap,
463 struct i2c_msg msgs[], int num)
464{
465 struct i2c_msg *pmsg;
466 struct i2c_algo_bit_data *adap = i2c_adap->algo_data;
467
468 int i,ret;
469 unsigned short nak_ok;
470
471 i2c_start(adap);
472 for (i=0;i<num;i++) {
473 pmsg = &msgs[i];
474 nak_ok = pmsg->flags & I2C_M_IGNORE_NAK;
475 if (!(pmsg->flags & I2C_M_NOSTART)) {
476 if (i) {
477 i2c_repstart(adap);
478 }
479 ret = bit_doAddress(i2c_adap, pmsg);
480 if ((ret != 0) && !nak_ok) {
481 DEB2(printk(KERN_DEBUG "i2c-algo-bit.o: NAK from device addr %2.2x msg #%d\n"
482 ,msgs[i].addr,i));
483 return (ret<0) ? ret : -EREMOTEIO;
484 }
485 }
486 if (pmsg->flags & I2C_M_RD ) {
487 /* read bytes into buffer*/
488 ret = readbytes(i2c_adap, pmsg);
489 DEB2(printk(KERN_DEBUG "i2c-algo-bit.o: read %d bytes.\n",ret));
490 if (ret < pmsg->len ) {
491 return (ret<0)? ret : -EREMOTEIO;
492 }
493 } else {
494 /* write bytes from buffer */
495 ret = sendbytes(i2c_adap, pmsg);
496 DEB2(printk(KERN_DEBUG "i2c-algo-bit.o: wrote %d bytes.\n",ret));
497 if (ret < pmsg->len ) {
498 return (ret<0) ? ret : -EREMOTEIO;
499 }
500 }
501 }
502 i2c_stop(adap);
503 return num;
504}
505
506static u32 bit_func(struct i2c_adapter *adap)
507{
508 return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL |
509 I2C_FUNC_10BIT_ADDR | I2C_FUNC_PROTOCOL_MANGLING;
510}
511
512
513/* -----exported algorithm data: ------------------------------------- */
514
Jean Delvare9e11a9f2006-09-03 22:38:52 +0200515static const struct i2c_algorithm i2c_bit_algo = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700516 .master_xfer = bit_xfer,
517 .functionality = bit_func,
518};
519
520/*
521 * registering functions to load algorithms at runtime
522 */
523int i2c_bit_add_bus(struct i2c_adapter *adap)
524{
525 struct i2c_algo_bit_data *bit_adap = adap->algo_data;
526
527 if (bit_test) {
528 int ret = test_bus(bit_adap, adap->name);
529 if (ret<0)
530 return -ENODEV;
531 }
532
533 DEB2(dev_dbg(&adap->dev, "hw routines registered.\n"));
534
535 /* register new adapter to i2c module... */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536 adap->algo = &i2c_bit_algo;
537
538 adap->timeout = 100; /* default values, should */
539 adap->retries = 3; /* be replaced by defines */
540
Mark M. Hoffmanb39ad0c2006-07-01 17:16:06 +0200541 return i2c_add_adapter(adap);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542}
543
544
545int i2c_bit_del_bus(struct i2c_adapter *adap)
546{
547 return i2c_del_adapter(adap);
548}
549
550EXPORT_SYMBOL(i2c_bit_add_bus);
551EXPORT_SYMBOL(i2c_bit_del_bus);
552
553MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>");
554MODULE_DESCRIPTION("I2C-Bus bit-banging algorithm");
555MODULE_LICENSE("GPL");
556
557module_param(bit_test, bool, 0);
558module_param(i2c_debug, int, S_IRUGO | S_IWUSR);
559
560MODULE_PARM_DESC(bit_test, "Test the lines of the bus to see if it is stuck");
561MODULE_PARM_DESC(i2c_debug,
562 "debug level - 0 off; 1 normal; 2,3 more verbose; 9 bit-protocol");