Merge branch 'i2c-for-linus' of git://jdelvare.pck.nerim.net/jdelvare-2.6
[linux-2.6.git] / drivers / i2c / algos / i2c-algo-bit.c
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
37 #ifdef DEBUG
38 #define bit_dbg(level, dev, format, args...) \
39         do { \
40                 if (i2c_debug >= level) \
41                         dev_dbg(dev, format, ##args); \
42         } while (0)
43 #else
44 #define bit_dbg(level, dev, format, args...) \
45         do {} while (0)
46 #endif /* DEBUG */
47
48 /* ----- global variables --------------------------------------------- */
49
50 static int bit_test;    /* see if the line-setting functions work       */
51 module_param(bit_test, bool, 0);
52 MODULE_PARM_DESC(bit_test, "Test the lines of the bus to see if it is stuck");
53
54 #ifdef DEBUG
55 static int i2c_debug = 1;
56 module_param(i2c_debug, int, S_IRUGO | S_IWUSR);
57 MODULE_PARM_DESC(i2c_debug,
58                  "debug level - 0 off; 1 normal; 2 verbose; 3 very verbose");
59 #endif
60
61 /* --- setting states on the bus with the right timing: --------------- */
62
63 #define setsda(adap,val) adap->setsda(adap->data, val)
64 #define setscl(adap,val) adap->setscl(adap->data, val)
65 #define getsda(adap) adap->getsda(adap->data)
66 #define getscl(adap) adap->getscl(adap->data)
67
68 static inline void sdalo(struct i2c_algo_bit_data *adap)
69 {
70         setsda(adap,0);
71         udelay((adap->udelay + 1) / 2);
72 }
73
74 static inline void sdahi(struct i2c_algo_bit_data *adap)
75 {
76         setsda(adap,1);
77         udelay((adap->udelay + 1) / 2);
78 }
79
80 static inline void scllo(struct i2c_algo_bit_data *adap)
81 {
82         setscl(adap,0);
83         udelay(adap->udelay / 2);
84 }
85
86 /*
87  * Raise scl line, and do checking for delays. This is necessary for slower
88  * devices.
89  */
90 static int sclhi(struct i2c_algo_bit_data *adap)
91 {
92         unsigned long start;
93
94         setscl(adap,1);
95
96         /* Not all adapters have scl sense line... */
97         if (!adap->getscl)
98                 goto done;
99
100         start=jiffies;
101         while (! getscl(adap) ) {       
102                 /* the hw knows how to read the clock line,
103                  * so we wait until it actually gets high.
104                  * This is safer as some chips may hold it low
105                  * while they are processing data internally. 
106                  */
107                 if (time_after_eq(jiffies, start+adap->timeout)) {
108                         return -ETIMEDOUT;
109                 }
110                 cond_resched();
111         }
112 #ifdef DEBUG
113         if (jiffies != start && i2c_debug >= 3)
114                 pr_debug("i2c-algo-bit: needed %ld jiffies for SCL to go "
115                          "high\n", jiffies - start);
116 #endif
117
118 done:
119         udelay(adap->udelay);
120         return 0;
121
122
123
124 /* --- other auxiliary functions -------------------------------------- */
125 static void i2c_start(struct i2c_algo_bit_data *adap) 
126 {
127         /* assert: scl, sda are high */
128         setsda(adap, 0);
129         udelay(adap->udelay);
130         scllo(adap);
131 }
132
133 static void i2c_repstart(struct i2c_algo_bit_data *adap) 
134 {
135         /* assert: scl is low */
136         sdahi(adap);
137         sclhi(adap);
138         setsda(adap, 0);
139         udelay(adap->udelay);
140         scllo(adap);
141 }
142
143
144 static void i2c_stop(struct i2c_algo_bit_data *adap) 
145 {
146         /* assert: scl is low */
147         sdalo(adap);
148         sclhi(adap); 
149         setsda(adap, 1);
150         udelay(adap->udelay);
151 }
152
153
154
155 /* send a byte without start cond., look for arbitration, 
156    check ackn. from slave */
157 /* returns:
158  * 1 if the device acknowledged
159  * 0 if the device did not ack
160  * -ETIMEDOUT if an error occurred (while raising the scl line)
161  */
162 static int i2c_outb(struct i2c_adapter *i2c_adap, unsigned char c)
163 {
164         int i;
165         int sb;
166         int ack;
167         struct i2c_algo_bit_data *adap = i2c_adap->algo_data;
168
169         /* assert: scl is low */
170         for ( i=7 ; i>=0 ; i-- ) {
171                 sb = (c >> i) & 1;
172                 setsda(adap,sb);
173                 udelay((adap->udelay + 1) / 2);
174                 if (sclhi(adap)<0) { /* timed out */
175                         bit_dbg(1, &i2c_adap->dev, "i2c_outb: 0x%02x, "
176                                 "timeout at bit #%d\n", (int)c, i);
177                         return -ETIMEDOUT;
178                 };
179                 /* do arbitration here: 
180                  * if ( sb && ! getsda(adap) ) -> ouch! Get out of here.
181                  */
182                 scllo(adap);
183         }
184         sdahi(adap);
185         if (sclhi(adap)<0){ /* timeout */
186                 bit_dbg(1, &i2c_adap->dev, "i2c_outb: 0x%02x, "
187                         "timeout at ack\n", (int)c);
188                 return -ETIMEDOUT;
189         };
190         /* read ack: SDA should be pulled down by slave */
191         ack = !getsda(adap);    /* ack: sda is pulled low -> success */
192         bit_dbg(2, &i2c_adap->dev, "i2c_outb: 0x%02x %s\n", (int)c,
193                 ack ? "A" : "NA");
194
195         scllo(adap);
196         return ack;
197         /* assert: scl is low (sda undef) */
198 }
199
200
201 static int i2c_inb(struct i2c_adapter *i2c_adap) 
202 {
203         /* read byte via i2c port, without start/stop sequence  */
204         /* acknowledge is sent in i2c_read.                     */
205         int i;
206         unsigned char indata=0;
207         struct i2c_algo_bit_data *adap = i2c_adap->algo_data;
208
209         /* assert: scl is low */
210         sdahi(adap);
211         for (i=0;i<8;i++) {
212                 if (sclhi(adap)<0) { /* timeout */
213                         bit_dbg(1, &i2c_adap->dev, "i2c_inb: timeout at bit "
214                                 "#%d\n", 7 - i);
215                         return -ETIMEDOUT;
216                 };
217                 indata *= 2;
218                 if ( getsda(adap) ) 
219                         indata |= 0x01;
220                 setscl(adap, 0);
221                 udelay(i == 7 ? adap->udelay / 2 : adap->udelay);
222         }
223         /* assert: scl is low */
224         return indata;
225 }
226
227 /*
228  * Sanity check for the adapter hardware - check the reaction of
229  * the bus lines only if it seems to be idle.
230  */
231 static int test_bus(struct i2c_algo_bit_data *adap, char* name) {
232         int scl,sda;
233
234         if (adap->getscl==NULL)
235                 pr_info("%s: Testing SDA only, SCL is not readable\n", name);
236
237         sda=getsda(adap);
238         scl=(adap->getscl==NULL?1:getscl(adap));
239         if (!scl || !sda ) {
240                 printk(KERN_WARNING "%s: bus seems to be busy\n", name);
241                 goto bailout;
242         }
243
244         sdalo(adap);
245         sda=getsda(adap);
246         scl=(adap->getscl==NULL?1:getscl(adap));
247         if ( 0 != sda ) {
248                 printk(KERN_WARNING "%s: SDA stuck high!\n", name);
249                 goto bailout;
250         }
251         if ( 0 == scl ) {
252                 printk(KERN_WARNING "%s: SCL unexpected low "
253                        "while pulling SDA low!\n", name);
254                 goto bailout;
255         }               
256
257         sdahi(adap);
258         sda=getsda(adap);
259         scl=(adap->getscl==NULL?1:getscl(adap));
260         if ( 0 == sda ) {
261                 printk(KERN_WARNING "%s: SDA stuck low!\n", name);
262                 goto bailout;
263         }
264         if ( 0 == scl ) {
265                 printk(KERN_WARNING "%s: SCL unexpected low "
266                        "while pulling SDA high!\n", name);
267                 goto bailout;
268         }
269
270         scllo(adap);
271         sda=getsda(adap);
272         scl=(adap->getscl==NULL?0:getscl(adap));
273         if ( 0 != scl ) {
274                 printk(KERN_WARNING "%s: SCL stuck high!\n", name);
275                 goto bailout;
276         }
277         if ( 0 == sda ) {
278                 printk(KERN_WARNING "%s: SDA unexpected low "
279                        "while pulling SCL low!\n", name);
280                 goto bailout;
281         }
282         
283         sclhi(adap);
284         sda=getsda(adap);
285         scl=(adap->getscl==NULL?1:getscl(adap));
286         if ( 0 == scl ) {
287                 printk(KERN_WARNING "%s: SCL stuck low!\n", name);
288                 goto bailout;
289         }
290         if ( 0 == sda ) {
291                 printk(KERN_WARNING "%s: SDA unexpected low "
292                        "while pulling SCL high!\n", name);
293                 goto bailout;
294         }
295         pr_info("%s: Test OK\n", name);
296         return 0;
297 bailout:
298         sdahi(adap);
299         sclhi(adap);
300         return -ENODEV;
301 }
302
303 /* ----- Utility functions
304  */
305
306 /* try_address tries to contact a chip for a number of
307  * times before it gives up.
308  * return values:
309  * 1 chip answered
310  * 0 chip did not answer
311  * -x transmission error
312  */
313 static int try_address(struct i2c_adapter *i2c_adap,
314                        unsigned char addr, int retries)
315 {
316         struct i2c_algo_bit_data *adap = i2c_adap->algo_data;
317         int i,ret = -1;
318         for (i=0;i<=retries;i++) {
319                 ret = i2c_outb(i2c_adap,addr);
320                 if (ret == 1 || i == retries)
321                         break;
322                 bit_dbg(3, &i2c_adap->dev, "emitting stop condition\n");
323                 i2c_stop(adap);
324                 udelay(adap->udelay);
325                 yield();
326                 bit_dbg(3, &i2c_adap->dev, "emitting start condition\n");
327                 i2c_start(adap);
328         }
329         if (i && ret)
330                 bit_dbg(1, &i2c_adap->dev, "Used %d tries to %s client at "
331                         "0x%02x: %s\n", i + 1,
332                         addr & 1 ? "read from" : "write to", addr >> 1,
333                         ret == 1 ? "success" : "failed, timeout?");
334         return ret;
335 }
336
337 static int sendbytes(struct i2c_adapter *i2c_adap, struct i2c_msg *msg)
338 {
339         const unsigned char *temp = msg->buf;
340         int count = msg->len;
341         unsigned short nak_ok = msg->flags & I2C_M_IGNORE_NAK; 
342         int retval;
343         int wrcount=0;
344
345         while (count > 0) {
346                 retval = i2c_outb(i2c_adap, *temp);
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                         return (retval<0)? retval : -EFAULT;
354                                 /* got a better one ?? */
355                 }
356         }
357         return wrcount;
358 }
359
360 static int readbytes(struct i2c_adapter *i2c_adap, struct i2c_msg *msg)
361 {
362         int inval;
363         int rdcount=0;          /* counts bytes read */
364         struct i2c_algo_bit_data *adap = i2c_adap->algo_data;
365         unsigned char *temp = msg->buf;
366         int count = msg->len;
367
368         while (count > 0) {
369                 inval = i2c_inb(i2c_adap);
370                 if (inval>=0) {
371                         *temp = inval;
372                         rdcount++;
373                 } else {   /* read timed out */
374                         break;
375                 }
376
377                 temp++;
378                 count--;
379
380                 if (msg->flags & I2C_M_NO_RD_ACK) {
381                         bit_dbg(2, &i2c_adap->dev, "i2c_inb: 0x%02x\n",
382                                 inval);
383                         continue;
384                 }
385
386                 /* assert: sda is high */
387                 if (count)              /* send ack */
388                         setsda(adap, 0);
389                 udelay((adap->udelay + 1) / 2);
390                 bit_dbg(2, &i2c_adap->dev, "i2c_inb: 0x%02x %s\n", inval,
391                         count ? "A" : "NA");
392                 if (sclhi(adap)<0) {    /* timeout */
393                         dev_err(&i2c_adap->dev, "readbytes: timeout at ack\n");
394                         return -ETIMEDOUT;
395                 };
396                 scllo(adap);
397
398                 /* Some SMBus transactions require that we receive the
399                    transaction length as the first read byte. */
400                 if (rdcount == 1 && (msg->flags & I2C_M_RECV_LEN)) {
401                         if (inval <= 0 || inval > I2C_SMBUS_BLOCK_MAX) {
402                                 dev_err(&i2c_adap->dev, "readbytes: invalid "
403                                         "block length (%d)\n", inval);
404                                 return -EREMOTEIO;
405                         }
406                         /* The original count value accounts for the extra
407                            bytes, that is, either 1 for a regular transaction,
408                            or 2 for a PEC transaction. */
409                         count += inval;
410                         msg->len += inval;
411                 }
412         }
413         return rdcount;
414 }
415
416 /* doAddress initiates the transfer by generating the start condition (in
417  * try_address) and transmits the address in the necessary format to handle
418  * reads, writes as well as 10bit-addresses.
419  * returns:
420  *  0 everything went okay, the chip ack'ed, or IGNORE_NAK flag was set
421  * -x an error occurred (like: -EREMOTEIO if the device did not answer, or
422  *      -ETIMEDOUT, for example if the lines are stuck...) 
423  */
424 static int bit_doAddress(struct i2c_adapter *i2c_adap, struct i2c_msg *msg)
425 {
426         unsigned short flags = msg->flags;
427         unsigned short nak_ok = msg->flags & I2C_M_IGNORE_NAK;
428         struct i2c_algo_bit_data *adap = i2c_adap->algo_data;
429
430         unsigned char addr;
431         int ret, retries;
432
433         retries = nak_ok ? 0 : i2c_adap->retries;
434         
435         if ( (flags & I2C_M_TEN)  ) { 
436                 /* a ten bit address */
437                 addr = 0xf0 | (( msg->addr >> 7) & 0x03);
438                 bit_dbg(2, &i2c_adap->dev, "addr0: %d\n", addr);
439                 /* try extended address code...*/
440                 ret = try_address(i2c_adap, addr, retries);
441                 if ((ret != 1) && !nak_ok)  {
442                         dev_err(&i2c_adap->dev,
443                                 "died at extended address code\n");
444                         return -EREMOTEIO;
445                 }
446                 /* the remaining 8 bit address */
447                 ret = i2c_outb(i2c_adap,msg->addr & 0x7f);
448                 if ((ret != 1) && !nak_ok) {
449                         /* the chip did not ack / xmission error occurred */
450                         dev_err(&i2c_adap->dev, "died at 2nd address code\n");
451                         return -EREMOTEIO;
452                 }
453                 if ( flags & I2C_M_RD ) {
454                         bit_dbg(3, &i2c_adap->dev, "emitting repeated "
455                                 "start condition\n");
456                         i2c_repstart(adap);
457                         /* okay, now switch into reading mode */
458                         addr |= 0x01;
459                         ret = try_address(i2c_adap, addr, retries);
460                         if ((ret!=1) && !nak_ok) {
461                                 dev_err(&i2c_adap->dev,
462                                         "died at repeated address code\n");
463                                 return -EREMOTEIO;
464                         }
465                 }
466         } else {                /* normal 7bit address  */
467                 addr = ( msg->addr << 1 );
468                 if (flags & I2C_M_RD )
469                         addr |= 1;
470                 if (flags & I2C_M_REV_DIR_ADDR )
471                         addr ^= 1;
472                 ret = try_address(i2c_adap, addr, retries);
473                 if ((ret!=1) && !nak_ok)
474                         return -EREMOTEIO;
475         }
476
477         return 0;
478 }
479
480 static int bit_xfer(struct i2c_adapter *i2c_adap,
481                     struct i2c_msg msgs[], int num)
482 {
483         struct i2c_msg *pmsg;
484         struct i2c_algo_bit_data *adap = i2c_adap->algo_data;
485         
486         int i,ret;
487         unsigned short nak_ok;
488
489         bit_dbg(3, &i2c_adap->dev, "emitting start condition\n");
490         i2c_start(adap);
491         for (i=0;i<num;i++) {
492                 pmsg = &msgs[i];
493                 nak_ok = pmsg->flags & I2C_M_IGNORE_NAK; 
494                 if (!(pmsg->flags & I2C_M_NOSTART)) {
495                         if (i) {
496                                 bit_dbg(3, &i2c_adap->dev, "emitting "
497                                         "repeated start condition\n");
498                                 i2c_repstart(adap);
499                         }
500                         ret = bit_doAddress(i2c_adap, pmsg);
501                         if ((ret != 0) && !nak_ok) {
502                                 bit_dbg(1, &i2c_adap->dev, "NAK from "
503                                         "device addr 0x%02x msg #%d\n",
504                                         msgs[i].addr, i);
505                                 goto bailout;
506                         }
507                 }
508                 if (pmsg->flags & I2C_M_RD ) {
509                         /* read bytes into buffer*/
510                         ret = readbytes(i2c_adap, pmsg);
511                         if (ret >= 1)
512                                 bit_dbg(2, &i2c_adap->dev, "read %d byte%s\n",
513                                         ret, ret == 1 ? "" : "s");
514                         if (ret < pmsg->len) {
515                                 if (ret >= 0)
516                                         ret = -EREMOTEIO;
517                                 goto bailout;
518                         }
519                 } else {
520                         /* write bytes from buffer */
521                         ret = sendbytes(i2c_adap, pmsg);
522                         if (ret >= 1)
523                                 bit_dbg(2, &i2c_adap->dev, "wrote %d byte%s\n",
524                                         ret, ret == 1 ? "" : "s");
525                         if (ret < pmsg->len) {
526                                 if (ret >= 0)
527                                         ret = -EREMOTEIO;
528                                 goto bailout;
529                         }
530                 }
531         }
532         ret = i;
533
534 bailout:
535         bit_dbg(3, &i2c_adap->dev, "emitting stop condition\n");
536         i2c_stop(adap);
537         return ret;
538 }
539
540 static u32 bit_func(struct i2c_adapter *adap)
541 {
542         return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL | 
543                I2C_FUNC_SMBUS_READ_BLOCK_DATA |
544                I2C_FUNC_SMBUS_BLOCK_PROC_CALL |
545                I2C_FUNC_10BIT_ADDR | I2C_FUNC_PROTOCOL_MANGLING;
546 }
547
548
549 /* -----exported algorithm data: -------------------------------------  */
550
551 static const struct i2c_algorithm i2c_bit_algo = {
552         .master_xfer    = bit_xfer,
553         .functionality  = bit_func,
554 };
555
556 /* 
557  * registering functions to load algorithms at runtime 
558  */
559 static int i2c_bit_prepare_bus(struct i2c_adapter *adap)
560 {
561         struct i2c_algo_bit_data *bit_adap = adap->algo_data;
562
563         if (bit_test) {
564                 int ret = test_bus(bit_adap, adap->name);
565                 if (ret<0)
566                         return -ENODEV;
567         }
568
569         /* register new adapter to i2c module... */
570         adap->algo = &i2c_bit_algo;
571
572         adap->timeout = 100;    /* default values, should       */
573         adap->retries = 3;      /* be replaced by defines       */
574
575         return 0;
576 }
577
578 int i2c_bit_add_bus(struct i2c_adapter *adap)
579 {
580         int err;
581
582         err = i2c_bit_prepare_bus(adap);
583         if (err)
584                 return err;
585
586         return i2c_add_adapter(adap);
587 }
588 EXPORT_SYMBOL(i2c_bit_add_bus);
589
590 int i2c_bit_add_numbered_bus(struct i2c_adapter *adap)
591 {
592         int err;
593
594         err = i2c_bit_prepare_bus(adap);
595         if (err)
596                 return err;
597
598         return i2c_add_numbered_adapter(adap);
599 }
600 EXPORT_SYMBOL(i2c_bit_add_numbered_bus);
601
602 MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>");
603 MODULE_DESCRIPTION("I2C-Bus bit-banging algorithm");
604 MODULE_LICENSE("GPL");