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