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