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