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