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/errno.h>
31 #include <linux/kernel.h>
32 #include <linux/fs.h>
33 #include <linux/string.h>
34 #include <linux/init.h>
35 #include <linux/mutex.h>
36
37 #include <asm/etraxi2c.h>
38
39 #include <asm/io.h>
40 #include <asm/delay.h>
41
42 #include "i2c.h"
43
44 /****************** I2C DEFINITION SECTION *************************/
45
46 #define D(x)
47
48 #define I2C_MAJOR 123 /* LOCAL/EXPERIMENTAL */
49 static DEFINE_MUTEX(i2c_mutex);
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
i2c_start(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
i2c_stop(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
i2c_outbyte(unsigned char x)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
i2c_inbyte(void)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
i2c_getack(void)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
i2c_sendack(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
i2c_sendnack(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
i2c_write(unsigned char theSlave,void * data,size_t nbytes)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
i2c_read(unsigned char theSlave,void * data,size_t nbytes)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
i2c_writereg(unsigned char theSlave,unsigned char theReg,unsigned char theValue)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
i2c_readreg(unsigned char theSlave,unsigned char theReg)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
i2c_open(struct inode * inode,struct file * filp)637 i2c_open(struct inode *inode, struct file *filp)
638 {
639 return 0;
640 }
641
642 static int
i2c_release(struct inode * inode,struct file * filp)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 long
i2c_ioctl(struct file * file,unsigned int cmd,unsigned long arg)652 i2c_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
653 {
654 int ret;
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 mutex_lock(&i2c_mutex);
668 ret = i2c_writereg(I2C_ARGSLAVE(arg),
669 I2C_ARGREG(arg),
670 I2C_ARGVALUE(arg));
671 mutex_unlock(&i2c_mutex);
672 return ret;
673
674 case I2C_READREG:
675 {
676 unsigned char val;
677 /* read from an i2c slave */
678 D(printk("i2cr %d %d ",
679 I2C_ARGSLAVE(arg),
680 I2C_ARGREG(arg)));
681 mutex_lock(&i2c_mutex);
682 val = i2c_readreg(I2C_ARGSLAVE(arg), I2C_ARGREG(arg));
683 mutex_unlock(&i2c_mutex);
684 D(printk("= %d\n", val));
685 return val;
686 }
687 default:
688 return -EINVAL;
689
690 }
691
692 return 0;
693 }
694
695 static const struct file_operations i2c_fops = {
696 .owner = THIS_MODULE,
697 .unlocked_ioctl = i2c_ioctl,
698 .open = i2c_open,
699 .release = i2c_release,
700 .llseek = noop_llseek,
701 };
702
i2c_init(void)703 static int __init i2c_init(void)
704 {
705 static int res;
706 static int first = 1;
707
708 if (!first)
709 return res;
710
711 first = 0;
712
713 /* Setup and enable the DATA and CLK pins */
714
715 res = crisv32_io_get_name(&cris_i2c_data,
716 CONFIG_ETRAX_V32_I2C_DATA_PORT);
717 if (res < 0)
718 return res;
719
720 res = crisv32_io_get_name(&cris_i2c_clk, CONFIG_ETRAX_V32_I2C_CLK_PORT);
721 crisv32_io_set_dir(&cris_i2c_clk, crisv32_io_dir_out);
722
723 return res;
724 }
725
726
i2c_register(void)727 static int __init i2c_register(void)
728 {
729 int res;
730
731 res = i2c_init();
732 if (res < 0)
733 return res;
734
735 /* register char device */
736
737 res = register_chrdev(I2C_MAJOR, i2c_name, &i2c_fops);
738 if (res < 0) {
739 printk(KERN_ERR "i2c: couldn't get a major number.\n");
740 return res;
741 }
742
743 printk(KERN_INFO
744 "I2C driver v2.2, (c) 1999-2007 Axis Communications AB\n");
745
746 return 0;
747 }
748 /* this makes sure that i2c_init is called during boot */
749 module_init(i2c_register);
750
751 /****************** END OF FILE i2c.c ********************************/
752