Merge branches 'master', 'omap1-upstream' and 'orion' into devel
[linux-2.6] / arch / cris / arch-v32 / drivers / i2c.c
1 /*!***************************************************************************
2 *!
3 *! FILE NAME  : i2c.c
4 *!
5 *! DESCRIPTION: implements an interface for IIC/I2C, both directly from other
6 *!              kernel modules (i2c_writereg/readreg) and from userspace using
7 *!              ioctl()'s
8 *!
9 *! Nov 30 1998  Torbjorn Eliasson  Initial version.
10 *!              Bjorn Wesen        Elinux kernel version.
11 *! Jan 14 2000  Johan Adolfsson    Fixed PB shadow register stuff -
12 *!                                 don't use PB_I2C if DS1302 uses same bits,
13 *!                                 use PB.
14 *| June 23 2003 Pieter Grimmerink  Added 'i2c_sendnack'. i2c_readreg now
15 *|                                 generates nack on last received byte,
16 *|                                 instead of ack.
17 *|                                 i2c_getack changed data level while clock
18 *|                                 was high, causing DS75 to see  a stop condition
19 *!
20 *! ---------------------------------------------------------------------------
21 *!
22 *! (C) Copyright 1999-2007 Axis Communications AB, LUND, SWEDEN
23 *!
24 *!***************************************************************************/
25
26 /****************** INCLUDE FILES SECTION ***********************************/
27
28 #include <linux/module.h>
29 #include <linux/sched.h>
30 #include <linux/slab.h>
31 #include <linux/errno.h>
32 #include <linux/kernel.h>
33 #include <linux/fs.h>
34 #include <linux/string.h>
35 #include <linux/init.h>
36
37 #include <asm/etraxi2c.h>
38
39 #include <asm/system.h>
40 #include <asm/io.h>
41 #include <asm/delay.h>
42
43 #include "i2c.h"
44
45 /****************** I2C DEFINITION SECTION *************************/
46
47 #define D(x)
48
49 #define I2C_MAJOR 123  /* LOCAL/EXPERIMENTAL */
50 static const char i2c_name[] = "i2c";
51
52 #define CLOCK_LOW_TIME            8
53 #define CLOCK_HIGH_TIME           8
54 #define START_CONDITION_HOLD_TIME 8
55 #define STOP_CONDITION_HOLD_TIME  8
56 #define ENABLE_OUTPUT 0x01
57 #define ENABLE_INPUT 0x00
58 #define I2C_CLOCK_HIGH 1
59 #define I2C_CLOCK_LOW 0
60 #define I2C_DATA_HIGH 1
61 #define I2C_DATA_LOW 0
62
63 #define i2c_enable()
64 #define i2c_disable()
65
66 /* enable or disable output-enable, to select output or input on the i2c bus */
67
68 #define i2c_dir_out() crisv32_io_set_dir(&cris_i2c_data, crisv32_io_dir_out)
69 #define i2c_dir_in() crisv32_io_set_dir(&cris_i2c_data, crisv32_io_dir_in)
70
71 /* control the i2c clock and data signals */
72
73 #define i2c_clk(x) crisv32_io_set(&cris_i2c_clk, x)
74 #define i2c_data(x) crisv32_io_set(&cris_i2c_data, x)
75
76 /* read a bit from the i2c interface */
77
78 #define i2c_getbit() crisv32_io_rd(&cris_i2c_data)
79
80 #define i2c_delay(usecs) udelay(usecs)
81
82 static DEFINE_SPINLOCK(i2c_lock); /* Protect directions etc */
83
84 /****************** VARIABLE SECTION ************************************/
85
86 static struct crisv32_iopin cris_i2c_clk;
87 static struct crisv32_iopin cris_i2c_data;
88
89 /****************** FUNCTION DEFINITION SECTION *************************/
90
91
92 /* generate i2c start condition */
93
94 void
95 i2c_start(void)
96 {
97         /*
98          * SCL=1 SDA=1
99          */
100         i2c_dir_out();
101         i2c_delay(CLOCK_HIGH_TIME/6);
102         i2c_data(I2C_DATA_HIGH);
103         i2c_clk(I2C_CLOCK_HIGH);
104         i2c_delay(CLOCK_HIGH_TIME);
105         /*
106          * SCL=1 SDA=0
107          */
108         i2c_data(I2C_DATA_LOW);
109         i2c_delay(START_CONDITION_HOLD_TIME);
110         /*
111          * SCL=0 SDA=0
112          */
113         i2c_clk(I2C_CLOCK_LOW);
114         i2c_delay(CLOCK_LOW_TIME);
115 }
116
117 /* generate i2c stop condition */
118
119 void
120 i2c_stop(void)
121 {
122         i2c_dir_out();
123
124         /*
125          * SCL=0 SDA=0
126          */
127         i2c_clk(I2C_CLOCK_LOW);
128         i2c_data(I2C_DATA_LOW);
129         i2c_delay(CLOCK_LOW_TIME*2);
130         /*
131          * SCL=1 SDA=0
132          */
133         i2c_clk(I2C_CLOCK_HIGH);
134         i2c_delay(CLOCK_HIGH_TIME*2);
135         /*
136          * SCL=1 SDA=1
137          */
138         i2c_data(I2C_DATA_HIGH);
139         i2c_delay(STOP_CONDITION_HOLD_TIME);
140
141         i2c_dir_in();
142 }
143
144 /* write a byte to the i2c interface */
145
146 void
147 i2c_outbyte(unsigned char x)
148 {
149         int i;
150
151         i2c_dir_out();
152
153         for (i = 0; i < 8; i++) {
154                 if (x & 0x80) {
155                         i2c_data(I2C_DATA_HIGH);
156                 } else {
157                         i2c_data(I2C_DATA_LOW);
158                 }
159
160                 i2c_delay(CLOCK_LOW_TIME/2);
161                 i2c_clk(I2C_CLOCK_HIGH);
162                 i2c_delay(CLOCK_HIGH_TIME);
163                 i2c_clk(I2C_CLOCK_LOW);
164                 i2c_delay(CLOCK_LOW_TIME/2);
165                 x <<= 1;
166         }
167         i2c_data(I2C_DATA_LOW);
168         i2c_delay(CLOCK_LOW_TIME/2);
169
170         /*
171          * enable input
172          */
173         i2c_dir_in();
174 }
175
176 /* read a byte from the i2c interface */
177
178 unsigned char
179 i2c_inbyte(void)
180 {
181         unsigned char aBitByte = 0;
182         int i;
183
184         /* Switch off I2C to get bit */
185         i2c_disable();
186         i2c_dir_in();
187         i2c_delay(CLOCK_HIGH_TIME/2);
188
189         /* Get bit */
190         aBitByte |= i2c_getbit();
191
192         /* Enable I2C */
193         i2c_enable();
194         i2c_delay(CLOCK_LOW_TIME/2);
195
196         for (i = 1; i < 8; i++) {
197                 aBitByte <<= 1;
198                 /* Clock pulse */
199                 i2c_clk(I2C_CLOCK_HIGH);
200                 i2c_delay(CLOCK_HIGH_TIME);
201                 i2c_clk(I2C_CLOCK_LOW);
202                 i2c_delay(CLOCK_LOW_TIME);
203
204                 /* Switch off I2C to get bit */
205                 i2c_disable();
206                 i2c_dir_in();
207                 i2c_delay(CLOCK_HIGH_TIME/2);
208
209                 /* Get bit */
210                 aBitByte |= i2c_getbit();
211
212                 /* Enable I2C */
213                 i2c_enable();
214                 i2c_delay(CLOCK_LOW_TIME/2);
215         }
216         i2c_clk(I2C_CLOCK_HIGH);
217         i2c_delay(CLOCK_HIGH_TIME);
218
219         /*
220          * we leave the clock low, getbyte is usually followed
221          * by sendack/nack, they assume the clock to be low
222          */
223         i2c_clk(I2C_CLOCK_LOW);
224         return aBitByte;
225 }
226
227 /*#---------------------------------------------------------------------------
228 *#
229 *# FUNCTION NAME: i2c_getack
230 *#
231 *# DESCRIPTION  : checks if ack was received from ic2
232 *#
233 *#--------------------------------------------------------------------------*/
234
235 int
236 i2c_getack(void)
237 {
238         int ack = 1;
239         /*
240          * enable output
241          */
242         i2c_dir_out();
243         /*
244          * Release data bus by setting
245          * data high
246          */
247         i2c_data(I2C_DATA_HIGH);
248         /*
249          * enable input
250          */
251         i2c_dir_in();
252         i2c_delay(CLOCK_HIGH_TIME/4);
253         /*
254          * generate ACK clock pulse
255          */
256         i2c_clk(I2C_CLOCK_HIGH);
257 #if 0
258         /*
259          * Use PORT PB instead of I2C
260          * for input. (I2C not working)
261          */
262         i2c_clk(1);
263         i2c_data(1);
264         /*
265          * switch off I2C
266          */
267         i2c_data(1);
268         i2c_disable();
269         i2c_dir_in();
270 #endif
271
272         /*
273          * now wait for ack
274          */
275         i2c_delay(CLOCK_HIGH_TIME/2);
276         /*
277          * check for ack
278          */
279         if (i2c_getbit())
280                 ack = 0;
281         i2c_delay(CLOCK_HIGH_TIME/2);
282         if (!ack) {
283                 if (!i2c_getbit()) /* receiver pulld SDA low */
284                         ack = 1;
285                 i2c_delay(CLOCK_HIGH_TIME/2);
286         }
287
288    /*
289     * our clock is high now, make sure data is low
290     * before we enable our output. If we keep data high
291     * and enable output, we would generate a stop condition.
292     */
293 #if 0
294    i2c_data(I2C_DATA_LOW);
295
296         /*
297          * end clock pulse
298          */
299         i2c_enable();
300         i2c_dir_out();
301 #endif
302         i2c_clk(I2C_CLOCK_LOW);
303         i2c_delay(CLOCK_HIGH_TIME/4);
304         /*
305          * enable output
306          */
307         i2c_dir_out();
308         /*
309          * remove ACK clock pulse
310          */
311         i2c_data(I2C_DATA_HIGH);
312         i2c_delay(CLOCK_LOW_TIME/2);
313         return ack;
314 }
315
316 /*#---------------------------------------------------------------------------
317 *#
318 *# FUNCTION NAME: I2C::sendAck
319 *#
320 *# DESCRIPTION  : Send ACK on received data
321 *#
322 *#--------------------------------------------------------------------------*/
323 void
324 i2c_sendack(void)
325 {
326         /*
327          * enable output
328          */
329         i2c_delay(CLOCK_LOW_TIME);
330         i2c_dir_out();
331         /*
332          * set ack pulse high
333          */
334         i2c_data(I2C_DATA_LOW);
335         /*
336          * generate clock pulse
337          */
338         i2c_delay(CLOCK_HIGH_TIME/6);
339         i2c_clk(I2C_CLOCK_HIGH);
340         i2c_delay(CLOCK_HIGH_TIME);
341         i2c_clk(I2C_CLOCK_LOW);
342         i2c_delay(CLOCK_LOW_TIME/6);
343         /*
344          * reset data out
345          */
346         i2c_data(I2C_DATA_HIGH);
347         i2c_delay(CLOCK_LOW_TIME);
348
349         i2c_dir_in();
350 }
351
352 /*#---------------------------------------------------------------------------
353 *#
354 *# FUNCTION NAME: i2c_sendnack
355 *#
356 *# DESCRIPTION  : Sends NACK on received data
357 *#
358 *#--------------------------------------------------------------------------*/
359 void
360 i2c_sendnack(void)
361 {
362         /*
363          * enable output
364          */
365         i2c_delay(CLOCK_LOW_TIME);
366         i2c_dir_out();
367         /*
368          * set data high
369          */
370         i2c_data(I2C_DATA_HIGH);
371         /*
372          * generate clock pulse
373          */
374         i2c_delay(CLOCK_HIGH_TIME/6);
375         i2c_clk(I2C_CLOCK_HIGH);
376         i2c_delay(CLOCK_HIGH_TIME);
377         i2c_clk(I2C_CLOCK_LOW);
378         i2c_delay(CLOCK_LOW_TIME);
379
380         i2c_dir_in();
381 }
382
383 /*#---------------------------------------------------------------------------
384 *#
385 *# FUNCTION NAME: i2c_write
386 *#
387 *# DESCRIPTION  : Writes a value to an I2C device
388 *#
389 *#--------------------------------------------------------------------------*/
390 int
391 i2c_write(unsigned char theSlave, void *data, size_t nbytes)
392 {
393         int error, cntr = 3;
394         unsigned char bytes_wrote = 0;
395         unsigned char value;
396         unsigned long flags;
397
398         spin_lock_irqsave(&i2c_lock, flags);
399
400         do {
401                 error = 0;
402
403                 i2c_start();
404                 /*
405                  * send slave address
406                  */
407                 i2c_outbyte((theSlave & 0xfe));
408                 /*
409                  * wait for ack
410                  */
411                 if (!i2c_getack())
412                         error = 1;
413                 /*
414                  * send data
415                  */
416                 for (bytes_wrote = 0; bytes_wrote < nbytes; bytes_wrote++) {
417                         memcpy(&value, data + bytes_wrote, sizeof value);
418                         i2c_outbyte(value);
419                         /*
420                          * now it's time to wait for ack
421                          */
422                         if (!i2c_getack())
423                                 error |= 4;
424                 }
425                 /*
426                  * end byte stream
427                  */
428                 i2c_stop();
429
430         } while (error && cntr--);
431
432         i2c_delay(CLOCK_LOW_TIME);
433
434         spin_unlock_irqrestore(&i2c_lock, flags);
435
436         return -error;
437 }
438
439 /*#---------------------------------------------------------------------------
440 *#
441 *# FUNCTION NAME: i2c_read
442 *#
443 *# DESCRIPTION  : Reads a value from an I2C device
444 *#
445 *#--------------------------------------------------------------------------*/
446 int
447 i2c_read(unsigned char theSlave, void *data, size_t nbytes)
448 {
449         unsigned char b = 0;
450         unsigned char bytes_read = 0;
451         int error, cntr = 3;
452         unsigned long flags;
453
454         spin_lock_irqsave(&i2c_lock, flags);
455
456         do {
457                 error = 0;
458                 memset(data, 0, nbytes);
459                 /*
460                  * generate start condition
461                  */
462                 i2c_start();
463                 /*
464                  * send slave address
465                  */
466                 i2c_outbyte((theSlave | 0x01));
467                 /*
468                  * wait for ack
469                  */
470                 if (!i2c_getack())
471                         error = 1;
472                 /*
473                  * fetch data
474                  */
475                 for (bytes_read = 0; bytes_read < nbytes; bytes_read++) {
476                         b = i2c_inbyte();
477                         memcpy(data + bytes_read, &b, sizeof b);
478
479                         if (bytes_read < (nbytes - 1))
480                                 i2c_sendack();
481                 }
482                 /*
483                  * last received byte needs to be nacked
484                  * instead of acked
485                  */
486                 i2c_sendnack();
487                 /*
488                  * end sequence
489                  */
490                 i2c_stop();
491         } while (error && cntr--);
492
493         spin_unlock_irqrestore(&i2c_lock, flags);
494
495         return -error;
496 }
497
498 /*#---------------------------------------------------------------------------
499 *#
500 *# FUNCTION NAME: i2c_writereg
501 *#
502 *# DESCRIPTION  : Writes a value to an I2C device
503 *#
504 *#--------------------------------------------------------------------------*/
505 int
506 i2c_writereg(unsigned char theSlave, unsigned char theReg,
507              unsigned char theValue)
508 {
509         int error, cntr = 3;
510         unsigned long flags;
511
512         spin_lock_irqsave(&i2c_lock, flags);
513
514         do {
515                 error = 0;
516
517                 i2c_start();
518                 /*
519                  * send slave address
520                  */
521                 i2c_outbyte((theSlave & 0xfe));
522                 /*
523                  * wait for ack
524                  */
525                 if(!i2c_getack())
526                         error = 1;
527                 /*
528                  * now select register
529                  */
530                 i2c_dir_out();
531                 i2c_outbyte(theReg);
532                 /*
533                  * now it's time to wait for ack
534                  */
535                 if(!i2c_getack())
536                         error |= 2;
537                 /*
538                  * send register register data
539                  */
540                 i2c_outbyte(theValue);
541                 /*
542                  * now it's time to wait for ack
543                  */
544                 if(!i2c_getack())
545                         error |= 4;
546                 /*
547                  * end byte stream
548                  */
549                 i2c_stop();
550         } while(error && cntr--);
551
552         i2c_delay(CLOCK_LOW_TIME);
553
554         spin_unlock_irqrestore(&i2c_lock, flags);
555
556         return -error;
557 }
558
559 /*#---------------------------------------------------------------------------
560 *#
561 *# FUNCTION NAME: i2c_readreg
562 *#
563 *# DESCRIPTION  : Reads a value from the decoder registers.
564 *#
565 *#--------------------------------------------------------------------------*/
566 unsigned char
567 i2c_readreg(unsigned char theSlave, unsigned char theReg)
568 {
569         unsigned char b = 0;
570         int error, cntr = 3;
571         unsigned long flags;
572
573         spin_lock_irqsave(&i2c_lock, flags);
574
575         do {
576                 error = 0;
577                 /*
578                  * generate start condition
579                  */
580                 i2c_start();
581
582                 /*
583                  * send slave address
584                  */
585                 i2c_outbyte((theSlave & 0xfe));
586                 /*
587                  * wait for ack
588                  */
589                 if(!i2c_getack())
590                         error = 1;
591                 /*
592                  * now select register
593                  */
594                 i2c_dir_out();
595                 i2c_outbyte(theReg);
596                 /*
597                  * now it's time to wait for ack
598                  */
599                 if(!i2c_getack())
600                         error |= 2;
601                 /*
602                  * repeat start condition
603                  */
604                 i2c_delay(CLOCK_LOW_TIME);
605                 i2c_start();
606                 /*
607                  * send slave address
608                  */
609                 i2c_outbyte(theSlave | 0x01);
610                 /*
611                  * wait for ack
612                  */
613                 if(!i2c_getack())
614                         error |= 4;
615                 /*
616                  * fetch register
617                  */
618                 b = i2c_inbyte();
619                 /*
620                  * last received byte needs to be nacked
621                  * instead of acked
622                  */
623                 i2c_sendnack();
624                 /*
625                  * end sequence
626                  */
627                 i2c_stop();
628
629         } while(error && cntr--);
630
631         spin_unlock_irqrestore(&i2c_lock, flags);
632
633         return b;
634 }
635
636 static int
637 i2c_open(struct inode *inode, struct file *filp)
638 {
639         return 0;
640 }
641
642 static int
643 i2c_release(struct inode *inode, struct file *filp)
644 {
645         return 0;
646 }
647
648 /* Main device API. ioctl's to write or read to/from i2c registers.
649  */
650
651 static int
652 i2c_ioctl(struct inode *inode, struct file *file,
653           unsigned int cmd, unsigned long arg)
654 {
655         if(_IOC_TYPE(cmd) != ETRAXI2C_IOCTYPE) {
656                 return -ENOTTY;
657         }
658
659         switch (_IOC_NR(cmd)) {
660                 case I2C_WRITEREG:
661                         /* write to an i2c slave */
662                         D(printk("i2cw %d %d %d\n",
663                                  I2C_ARGSLAVE(arg),
664                                  I2C_ARGREG(arg),
665                                  I2C_ARGVALUE(arg)));
666
667                         return i2c_writereg(I2C_ARGSLAVE(arg),
668                                             I2C_ARGREG(arg),
669                                             I2C_ARGVALUE(arg));
670                 case I2C_READREG:
671                 {
672                         unsigned char val;
673                         /* read from an i2c slave */
674                         D(printk("i2cr %d %d ",
675                                 I2C_ARGSLAVE(arg),
676                                 I2C_ARGREG(arg)));
677                         val = i2c_readreg(I2C_ARGSLAVE(arg), I2C_ARGREG(arg));
678                         D(printk("= %d\n", val));
679                         return val;
680                 }
681                 default:
682                         return -EINVAL;
683
684         }
685
686         return 0;
687 }
688
689 static const struct file_operations i2c_fops = {
690         .owner =    THIS_MODULE,
691         .ioctl =    i2c_ioctl,
692         .open =     i2c_open,
693         .release =  i2c_release,
694 };
695
696 static int __init i2c_init(void)
697 {
698         static int res;
699         static int first = 1;
700
701         if (!first)
702                 return res;
703
704         first = 0;
705
706         /* Setup and enable the DATA and CLK pins */
707
708         res = crisv32_io_get_name(&cris_i2c_data,
709                 CONFIG_ETRAX_V32_I2C_DATA_PORT);
710         if (res < 0)
711                 return res;
712
713         res = crisv32_io_get_name(&cris_i2c_clk, CONFIG_ETRAX_V32_I2C_CLK_PORT);
714         crisv32_io_set_dir(&cris_i2c_clk, crisv32_io_dir_out);
715
716         return res;
717 }
718
719
720 static int __init i2c_register(void)
721 {
722         int res;
723
724         res = i2c_init();
725         if (res < 0)
726                 return res;
727
728         /* register char device */
729
730         res = register_chrdev(I2C_MAJOR, i2c_name, &i2c_fops);
731         if (res < 0) {
732                 printk(KERN_ERR "i2c: couldn't get a major number.\n");
733                 return res;
734         }
735
736         printk(KERN_INFO
737                 "I2C driver v2.2, (c) 1999-2007 Axis Communications AB\n");
738
739         return 0;
740 }
741 /* this makes sure that i2c_init is called during boot */
742 module_init(i2c_register);
743
744 /****************** END OF FILE i2c.c ********************************/