Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
i2c.c
Go to the documentation of this file.
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
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
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
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
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
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
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
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
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
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
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
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
637 i2c_open(struct inode *inode, struct file *filp)
638 {
639  return 0;
640 }
641 
642 static int
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
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 
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 
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 ********************************/
Generated on Thu Jan 10 2013 13:00:10 for Linux Kernel by   doxygen 1.8.2