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