projects / openwrt / openwrt.git / blob
? search:


d94bc1ade9c15422d1ee97a6ffaf0798e9ec7e03
[openwrt/openwrt.git] / target / linux / etrax / files-2.6.25 / arch / cris / arch-v10 / drivers / i2c_gvc.c
1 /*!***************************************************************************
2 *!
3 *! FILE NAME : i2c.c
4 *!
5 *!
6 *! ---------------------------------------------------------------------------
7 *!
8 *! ( C ) Copyright 1999-2002 Axis Communications AB, LUND, SWEDEN
9 *!
10 *!***************************************************************************/
11 /* $Id: i2c.c,v 1.16 2005/09/29 13:33:35 bjarne Exp $ */
12
13 #define DYNAMIC_MAJOR_I2CDEV_NUMBER_ALLOC
14 //#undef DYNAMIC_MAJOR_I2CDEV_NUMBER_ALLOC
15
16 /******************** INCLUDE FILES SECTION ****************************/
17
18 #include <linux/module.h>
19 #include <linux/fs.h>
20
21 /**GVC**/
22 #ifdef DYNAMIC_MAJOR_I2CDEV_NUMBER_ALLOC
23 #include <linux/types.h> /* for dev_t */
24 #include <linux/cdev.h> /* for struct cdev */
25 #endif
26 /**END GVC**/
27
28 #include "etraxi2c.h"
29
30 /**GVC**/
31 #include "i2c_errno.h"
32 /**END GVC**/
33
34 #include <asm/io.h>
35 #include <asm/delay.h>
36 #include <asm/arch/io_interface_mux.h>
37 #include <asm/uaccess.h>
38
39 #include "i2c_gvc.h"
40
41 MODULE_DESCRIPTION( "I2C Device Driver - 1.1" );
42
43 /*!*********************************************************************
44 *!History I2C driver Geert Vancompernolle
45 *!---------------------------------------
46 *!
47 *! - v1.0:
48 *! First official version.
49 *!
50 *! - v1.1:
51 *! Changes to remove unwanted spikes at ACK/NACK time.
52 *!
53 *!*********************************************************************/
54
55 MODULE_LICENSE( "GPL" );
56
57 /****************** MACRO's **********************/
58
59 #define D( x )
60
61 /**GVC**/
62 #ifndef DYNAMIC_MAJOR_I2CDEV_NUMBER_ALLOC
63 /**END GVC**/
64 #define I2C_MAJOR 123 /* LOCAL/EXPERIMENTAL */
65 /**GVC**/
66 #endif
67 /**END GVC**/
68
69 /**GVC**/
70 #define WAITONEUS 1
71 /* Following are abbreviations taken from Philips I2C standard */
72 /* Values are representing time in us and are rounded to next whole number, if relevant */
73 #define THDSTA 4 /* Hold delay time for (repeated) START condition */
74 #define TLOW 5 /* LOW period of the SCL clock */
75 #define THDDAT 1 /* Hold delay time for DATA: value of 0 is allowed but 1 taken to be sure */
76 #define TSUDAT 1 /* Set-up time for DATA */
77 #define THIGH 4 /* HIGH period of the SCL clock */
78 #define TSUSTA 5 /* Set-up time for a repeated START condition */
79 #define TSUSTO 4 /* Set-up time for STOP condition */
80 #define TBUF 5 /* Bus-free time between STOP and START condition */
81
82 #define MAXBUSFREERETRIES 5
83 #define MAXRETRIES 3
84 #define WRITEADDRESS_MASK ( 0xFE )
85 #define READADDRESS_MASK ( 0x01 )
86 /**END GVC**/
87
88 #define SCL_HIGH 1
89 #define SCL_LOW 0
90 #define SDA_HIGH 1
91 #define SDA_LOW 0
92
93 #ifdef CONFIG_ETRAX_I2C_USES_PB_NOT_PB_I2C
94 /* Use PB and not PB_I2C */
95 #ifndef CONFIG_ETRAX_I2C_DATA_PORT
96 #define CONFIG_ETRAX_I2C_DATA_PORT 0
97 #endif
98 #ifndef CONFIG_ETRAX_I2C_CLK_PORT
99 #define CONFIG_ETRAX_I2C_CLK_PORT 1
100 #endif
101
102 #define SDABIT CONFIG_ETRAX_I2C_DATA_PORT
103 #define SCLBIT CONFIG_ETRAX_I2C_CLK_PORT
104 #define i2c_enable()
105 #define i2c_disable()
106
107 /* enable or disable output-enable, to select output or input on the i2c bus */
108 #define i2c_sda_dir_out() \
109 REG_SHADOW_SET( R_PORT_PB_DIR, port_pb_dir_shadow, SDABIT, 1 )
110 #define i2c_sda_dir_in() \
111 REG_SHADOW_SET( R_PORT_PB_DIR, port_pb_dir_shadow, SDABIT, 0 )
112
113 /* control the i2c clock and data signals */
114 #define i2c_set_scl( x ) \
115 REG_SHADOW_SET( R_PORT_PB_DATA, port_pb_data_shadow, SCLBIT, x )
116 #define i2c_set_sda( x ) \
117 REG_SHADOW_SET( R_PORT_PB_DATA, port_pb_data_shadow, SDABIT, x )
118
119 /* read status of SDA bit from the i2c interface */
120 #define i2c_sda_is_high() ( ( ( *R_PORT_PB_READ & ( 1 << SDABIT ) ) ) >> SDABIT )
121
122 /**GVC**/
123 /* read status of SCL bit from the i2c interface */
124 #define i2c_scl_is_high() ( ( ( *R_PORT_PB_READ & ( 1 << SCLBIT ) ) ) >> SCLBIT )
125 /**END GVC**/
126
127 #else
128 /* enable or disable the i2c interface */
129 #define i2c_enable() *R_PORT_PB_I2C = ( port_pb_i2c_shadow |= IO_MASK( R_PORT_PB_I2C, i2c_en ) )
130 #define i2c_disable() *R_PORT_PB_I2C = ( port_pb_i2c_shadow &= ~IO_MASK( R_PORT_PB_I2C, i2c_en ) )
131
132 /* enable or disable output-enable, to select output or input on the i2c bus */
133 #define i2c_sda_dir_out() \
134 *R_PORT_PB_I2C = ( port_pb_i2c_shadow &= ~IO_MASK( R_PORT_PB_I2C, i2c_oe_ ) ); \
135 REG_SHADOW_SET( R_PORT_PB_DIR, port_pb_dir_shadow, 0, 1 );
136 #define i2c_sda_dir_in() \
137 *R_PORT_PB_I2C = ( port_pb_i2c_shadow |= IO_MASK( R_PORT_PB_I2C, i2c_oe_ ) ); \
138 REG_SHADOW_SET( R_PORT_PB_DIR, port_pb_dir_shadow, 0, 0 );
139
140 /* control the i2c clock and data signals */
141 #define i2c_set_scl( x ) \
142 *R_PORT_PB_I2C = ( port_pb_i2c_shadow = ( port_pb_i2c_shadow & \
143 ~IO_MASK( R_PORT_PB_I2C, i2c_set_scl ) ) | IO_FIELD( R_PORT_PB_I2C, i2c_set_scl, ( x ) ) ); \
144 REG_SHADOW_SET( R_PORT_PB_DATA, port_pb_data_shadow, 1, x );
145
146 #define i2c_set_sda( x ) \
147 *R_PORT_PB_I2C = ( port_pb_i2c_shadow = ( port_pb_i2c_shadow & \
148 ~IO_MASK( R_PORT_PB_I2C, i2c_d ) ) | IO_FIELD( R_PORT_PB_I2C, i2c_d, ( x ) ) ); \
149 REG_SHADOW_SET( R_PORT_PB_DATA, port_pb_data_shadow, 0, x );
150
151 /* read a bit from the i2c interface */
152 #define i2c_sda_is_high() ( *R_PORT_PB_READ & 0x1 )
153 #endif
154
155 /* use the kernels delay routine */
156 #define i2c_delay( usecs ) udelay( usecs )
157
158
159 /****************** TYPEDEF's **********************/
160
161
162 /****************** STATIC (file scope) VARIABLES **********************/
163 static DEFINE_SPINLOCK( i2c_lock ); /* Protect directions etc */
164 /**GVC**/
165 #ifdef DYNAMIC_MAJOR_I2CDEV_NUMBER_ALLOC
166 static const char i2c_name[] = "i2cgvc";
167 #else
168 static const char i2c_name[] = "i2c";
169 #endif
170 /**END GVC**/
171
172
173 /****************** PROTOTYPING SECTION *************************/
174 static int i2c_open( struct inode *inode, struct file *filp );
175 static int i2c_release( struct inode *inode, struct file *filp );
176 /**GVC**/
177 static int i2c_command( unsigned char slave
178 , unsigned char* wbuf
179 , unsigned char wlen
180 , unsigned char* rbuf
181 , unsigned char rlen
182 );
183 static int i2c_bus_free_check( unsigned char maxretries );
184 static void i2c_finalise( const char* text, unsigned long irqflags );
185 /**END GVC**/
186
187
188 /************************************************************************/
189 /****************** AUXILIARIES *************************/
190 /************************************************************************/
191
192 /*#---------------------------------------------------------------------------
193 *#
194 *# FUNCTION NAME: i2c_open
195 *#
196 *# DESCRIPTION : opens an I2C device
197 *#
198 *# PARAMETERS : *inode: reference to inode
199 *# *filp : reference to file pointer
200 *#
201 *#---------------------------------------------------------------------------
202 */
203 static int i2c_open( struct inode *inode, struct file *filp )
204 {
205 return 0;
206 } /* i2c_open */
207
208
209 /*#---------------------------------------------------------------------------
210 *#
211 *# FUNCTION NAME: i2c_release
212 *#
213 *# DESCRIPTION : Releases the I2C device
214 *#
215 *# PARAMETERS : *inode: reference to inode
216 *# *filp : reference to file pointer
217 *#
218 *#---------------------------------------------------------------------------
219 */
220 static int i2c_release( struct inode *inode, struct file *filp )
221 {
222 return 0;
223 } /* i2c_release */
224
225
226 /*#---------------------------------------------------------------------------
227 *#
228 *# FUNCTION NAME: i2c_ioctl
229 *#
230 *# DESCRIPTION : Main device API: ioctl's to write/read
231 *# to/from i2c registers
232 *#
233 *# PARAMETERS : *inode: reference to inode
234 *# *filp : reference to file pointer
235 *# cmd : command to be executed during the ioctl call
236 *# arg : pointer to a structure with the data???
237 *#
238 *# RETURN : result of the ioctl call
239 *#
240 *#---------------------------------------------------------------------------
241 */
242 static int i2c_ioctl( struct inode *inode
243 , struct file *file
244 , unsigned int cmd
245 , unsigned long arg
246 )
247 {
248 /* the acme ioctls */
249 I2C_DATA i2cdata;
250 int RetVal = EI2CNOERRORS;
251
252 if ( _IOC_TYPE( cmd ) != ETRAXI2C_IOCTYPE )
253 {
254 return ( -EINVAL );
255 }
256
257 switch ( _IOC_NR( cmd ) )
258 {
259 case I2C_WRITEREG:
260 /* write to an i2c slave */
261 RetVal = i2c_writereg( I2C_ARGSLAVE( arg )
262 , I2C_ARGREG( arg )
263 , I2C_ARGVALUE( arg )
264 );
265 break;
266
267 case I2C_READREG:
268 RetVal = i2c_readreg( I2C_ARGSLAVE( arg ), I2C_ARGREG( arg ) );
269 break;
270
271 /**GVC**/
272 /* New functions added by GVC */
273 case I2C_READ:
274 copy_from_user( (char*)&i2cdata, (char*)arg, sizeof( I2C_DATA ) );
275 {
276 int RetryCntr = MAXRETRIES;
277
278 do
279 {
280 RetVal = i2c_command( i2cdata.slave
281 , NULL
282 , 0
283 , i2cdata.rbuf
284 , i2cdata.rlen
285 );
286 } while ( ( EI2CNOERRORS != RetVal )
287 &&( --RetryCntr )
288 );
289 }
290 copy_to_user( (char*)arg, (char*)&i2cdata, sizeof( I2C_DATA ) );
291 break;
292
293 case I2C_WRITE:
294 copy_from_user( (char*)&i2cdata, (char*)arg, sizeof( I2C_DATA ) );
295 {
296 int RetryCntr = MAXRETRIES;
297
298 do
299 {
300 RetVal = i2c_command( i2cdata.slave
301 , i2cdata.wbuf
302 , i2cdata.wlen
303 , NULL
304 , 0
305 );
306 } while ( ( EI2CNOERRORS != RetVal )
307 &&( --RetryCntr )
308 );
309 }
310 break;
311
312 case I2C_WRITEREAD:
313 copy_from_user( (char*)&i2cdata, (char*)arg, sizeof( I2C_DATA ) );
314 {
315 int RetryCntr = MAXRETRIES;
316
317 do
318 {
319 RetVal = i2c_command( i2cdata.slave
320 , i2cdata.wbuf
321 , i2cdata.wlen
322 , i2cdata.rbuf
323 , i2cdata.rlen
324 );
325 } while ( ( EI2CNOERRORS != RetVal )
326 &&( --RetryCntr )
327 );
328 }
329 copy_to_user( (char*)arg, (char*)&i2cdata, sizeof( I2C_DATA ) );
330 break;
331 /**END GVC**/
332
333 default:
334 RetVal = -EINVAL;
335 }
336
337 return ( -RetVal );
338 } /* i2c_ioctl */
339
340
341 /*#---------------------------------------------------------------------------
342 *#
343 *# FUNCTION NAME: i2c_command
344 *#
345 *# DESCRIPTION : general routine to read/write bytes from an I2C device
346 *#
347 *# 'i2c_command()' sends wlen bytes to the I2c bus and receives
348 *# rlen bytes from the I2c bus.
349 *# The data to be send must be placed in wbuf[ 0 ] upto wbuf[ wlen - 1 ).
350 *# The data to be received is assembled in rbuf[ 0 ] upto rbuf[ rlen - 1 ].
351 *#
352 *# If no data is to be sent or received, put appropriate buffer parameter
353 *# to "NULL" and appropriate length parameter to "0".
354 *#
355 *# PARAMETERS : slave = slave address of the I2C device
356 *# wbuf = address of first element of write buffer (wbuf)
357 *# wlen = number of bytes to be written to slave
358 *# rbuf = address of first element of read buffer (rbuf)
359 *# rlen = number of bytes to be read from slave
360 *#
361 *# RETURN :
362 *# EI2CNOERRORS: I2C communication went fine
363 *# EI2CBUSNFREE: I2C bus is not free
364 *# EI2CWADDRESS: I2C write address failed
365 *# EI2CRADDRESS: I2C read address failed
366 *# EI2CSENDDATA: I2C send data failed
367 *# EI2CRECVDATA: I2C receive data failed
368 *# EI2CSTRTCOND: I2C start condition failed
369 *# EI2CRSTACOND: I2C repeated start condition failed
370 *# EI2CSTOPCOND: I2C stop condition failed
371 *# EI2CNOSNDBYT: I2C no bytes to be sent
372 *# EI2CNOSNDBUF: I2C no send buffer defined
373 *# EI2CNORCVBYT: I2C no bytes to be received
374 *# EI2CNORCVBUF: I2C no receive buffer defined
375 *# EI2CNOACKNLD: I2C no acknowledge received
376 *#
377 *# REMARK :
378 *# First, the send part is completed.
379 *# In the send routine, there is no stop generated. This is because maybe
380 *# a repeated start condition must be generated.
381 *# This happens when we want to receive some data from the I2c bus. If not,
382 *# at the end of the general I2c loop the stopcondition is generated.
383 *# If, on the contrary, there are a number of bytes to be received, a new
384 *# startcondition is generated in the 'if' part of the main I2c routine,
385 *# which controls the receiving part.
386 *# Only when the receiving of data is finished, a final stopcondition is
387 *# generated.
388 *#
389 *#---------------------------------------------------------------------------
390 */
391 static int i2c_command( unsigned char slave
392 , unsigned char* wbuf
393 , unsigned char wlen
394 , unsigned char* rbuf
395 , unsigned char rlen
396 )
397 {
398 /* Check arguments and report error if relevant... */
399 if ( ( wlen > 0 ) && ( wbuf == NULL ) )
400 {
401 printk( KERN_DEBUG "I2C: EI2CNOSNDBUF\n" );
402 return ( EI2CNOSNDBUF );
403 }
404 else if ( ( wlen == 0 ) && ( wbuf != NULL ) )
405 {
406 printk( KERN_DEBUG "I2C: EI2CNOSNDBYT\n" );
407 return ( EI2CNOSNDBYT );
408 }
409 else if ( ( rlen > 0 ) && ( rbuf == NULL ) )
410 {
411 printk( KERN_DEBUG "I2C: EI2CNORCVBUF\n" );
412 return ( EI2CNORCVBUF );
413 }
414 else if ( ( rlen == 0 ) && ( rbuf != NULL ) )
415 {
416 printk( KERN_DEBUG "I2C: EI2CNORCVBYT\n" );
417 return ( EI2CNORCVBYT );
418 }
419 else if ( EI2CBUSNFREE == i2c_bus_free_check( MAXBUSFREERETRIES ) )
420 {
421 /* There's no need to try more, since we weren't even
422 * able to start the I2C communication.
423 * So, no IRQ flags are stored yet, no changes to any other
424 * stuff like START, STOP, SENDBYTES...
425 * Result, simply write down the error and return the correct error code.
426 */
427 printk( KERN_DEBUG "I2C: EI2CBUSNFREE\n" );
428 return ( EI2CBUSNFREE );
429 }
430 else
431 {
432 /* Finally... We made it... */
433 unsigned long irqflags = 0;
434
435 /* we don't like to be interrupted */
436 local_irq_save( irqflags );
437
438 /* Check if there are bytes to be send,
439 * or if you immediately want to receive data.
440 */
441 if ( 0 < wlen )
442 {
443 /* start I2C communication */
444 if ( EI2CNOERRORS != i2c_start() )
445 {
446 return ( i2c_finalise( "I2C: EI2CSTRTCOND\n", irqflags )
447 , EI2CSTRTCOND
448 );
449 }
450
451 /* send slave address: xxxxxxx0B (last bit must be zero) */
452 if ( EI2CNOERRORS != i2c_outbyte( slave & WRITEADDRESS_MASK ) )
453 {
454 return ( i2c_finalise( "I2C: EI2CWADDRESS\n", irqflags )
455 , EI2CWADDRESS
456 );
457 }
458
459 while ( wlen-- )
460 {
461 /* send register data */
462 if ( EI2CNOERRORS != i2c_outbyte( *wbuf ) )
463 {
464 return ( i2c_finalise( "I2C: EI2CSENDDATA\n", irqflags )
465 , EI2CSENDDATA
466 );
467 }
468
469 wbuf++;
470 };
471
472 i2c_delay( TLOW );
473 }
474
475 /*
476 * Receiving data from I2c_bus
477 * If there are bytes to be received, a new start condition is
478 * generated => Repeated Startcondition.
479 * A final stopcondition is generated at the end of the main I2c
480 * routine.
481 */
482 if ( 0 < rlen )
483 {
484 /*
485 * Generate start condition if wlen == 0
486 * or repeated start condition if wlen != 0...
487 */
488 if ( EI2CNOERRORS != i2c_start() )
489 {
490 return ( i2c_finalise( ( ( 0 < wlen )
491 ? "I2C: EI2CRSTACOND\n"
492 : "I2C: EI2CSTRTCOND\n"
493 )
494 , irqflags
495 )
496 , ( ( 0 < wlen ) ? EI2CRSTACOND : EI2CSTRTCOND )
497 );
498 }
499
500 /* Send ReadAddress: xxxxxxx1B (last bit must be one) */
501 if ( EI2CNOERRORS != i2c_outbyte( slave | READADDRESS_MASK ) )
502 {
503 return ( i2c_finalise( "I2C: EI2CRADDRESS\n", irqflags )
504 , EI2CRADDRESS
505 );
506 }
507
508 while ( rlen-- )
509 {
510 /* fetch register */
511 *rbuf = i2c_inbyte();
512 rbuf++;
513
514 /* last received byte needs to be NACK-ed instead of ACK-ed */
515 if ( rlen )
516 {
517 i2c_sendack();
518 }
519 else
520 {
521 i2c_sendnack();
522 }
523 };
524 }
525
526 /* Generate final stop condition */
527 if ( EI2CNOERRORS != i2c_stop() )
528 {
529 return ( i2c_finalise( "I2C: EI2CSTOPCOND\n", irqflags )
530 , EI2CSTOPCOND
531 );
532 }
533
534 /* enable interrupt again */
535 local_irq_restore( irqflags );
536 }
537
538 return ( EI2CNOERRORS );
539 } /* i2c_command */
540
541
542 /*#---------------------------------------------------------------------------
543 *#
544 *# FUNCTION NAME: i2c_bus_free_check
545 *#
546 *# DESCRIPTION : checks if the I2C bus is free before starting
547 *# an I2C communication
548 *#
549 *# PARAMETERS : maxretries, the number of times we will try to release
550 *# the I2C bus
551 *#
552 *# RETURN : I2cStatus_I2cBusNotFreeError in case the bus is not free,
553 *# I2cStatus_I2cNoError otherwise
554 *#
555 *#---------------------------------------------------------------------------
556 */
557 static int i2c_bus_free_check( unsigned char maxretries )
558 {
559 i2c_sda_dir_in(); /* Release SDA line */
560 i2c_set_scl( SCL_HIGH ); /* put SCL line high */
561
562 i2c_delay( WAITONEUS );
563
564 while ( ( !i2c_sda_is_high() || !i2c_scl_is_high() )
565 &&( maxretries-- )
566 )
567 {
568 /* Try to release I2C bus by generating STOP conditions */
569 i2c_stop();
570 }
571
572 if ( 0 == maxretries )
573 {
574 printk( KERN_DEBUG "I2C: EI2CBUSNFREE\n" );
575 return ( EI2CBUSNFREE );
576 }
577 else
578 {
579 return ( EI2CNOERRORS );
580 }
581 } /* i2c_bus_free_check */
582
583
584 static void i2c_finalise( const char* errortxt
585 , unsigned long irqflags
586 )
587 {
588 printk( KERN_DEBUG "%s", errortxt );
589 local_irq_restore( irqflags );
590 /* The least we can do when things go terribly wrong,
591 * is to try to release the bus.
592 * If this fails, well, then I don't know
593 * what I can do more for the moment...
594 */
595 (void)i2c_bus_free_check( MAXBUSFREERETRIES );
596 } /* i2c_finalise */
597
598
599 static struct file_operations i2c_fops =
600 {
601 .owner = THIS_MODULE
602 , .ioctl = i2c_ioctl
603 , .open = i2c_open
604 , .release = i2c_release
605 };
606
607
608 /***********************************************************************/
609 /************* EXTERNAL FUNCTION DEFINITION SECTION ********************/
610 /***********************************************************************/
611
612 /*#---------------------------------------------------------------------------
613 *#
614 *# FUNCTION NAME: i2c_init
615 *#
616 *# DESCRIPTION : initialises the I2C device driver
617 *#
618 *# PARAMETERS :
619 *#
620 *#---------------------------------------------------------------------------
621 */
622 int __init i2c_init( void )
623 {
624 static int res = 0;
625 static int first = 1;
626
627 if ( !first )
628 {
629 return res;
630 }
631
632 first = 0;
633
634 /* Setup and enable the Port B I2C interface */
635
636 #ifndef CONFIG_ETRAX_I2C_USES_PB_NOT_PB_I2C
637 /* here, we're using the dedicated I2C pins of FoxBoard */
638 if ( ( res = cris_request_io_interface( if_i2c, "I2C" ) ) )
639 {
640 printk( KERN_CRIT "i2c_init: Failed to get IO interface\n" );
641 return res;
642 }
643
644 *R_PORT_PB_I2C = port_pb_i2c_shadow |=
645 IO_STATE( R_PORT_PB_I2C, i2c_en, on ) |
646 IO_FIELD( R_PORT_PB_I2C, i2c_d, 1 ) |
647 IO_FIELD( R_PORT_PB_I2C, i2c_set_scl, 1 ) |
648 IO_STATE( R_PORT_PB_I2C, i2c_oe_, enable );
649
650 port_pb_dir_shadow &= ~IO_MASK( R_PORT_PB_DIR, dir0 );
651 port_pb_dir_shadow &= ~IO_MASK( R_PORT_PB_DIR, dir1 );
652
653 *R_PORT_PB_DIR = ( port_pb_dir_shadow |=
654 IO_STATE( R_PORT_PB_DIR, dir0, input ) |
655 IO_STATE( R_PORT_PB_DIR, dir1, output ) );
656 #else
657 /* If everything goes fine, res = 0, meaning "if" fails =>
658 * will do the "else" too and as such initialise the clock port...
659 * Clever trick!
660 */
661 if ( ( res = cris_io_interface_allocate_pins( if_i2c
662 , 'b'
663 , CONFIG_ETRAX_I2C_DATA_PORT
664 , CONFIG_ETRAX_I2C_DATA_PORT
665 )
666 )
667 )
668 {
669 printk( KERN_WARNING "i2c_init: Failed to get IO pin for I2C data port\n" );
670 return ( res );
671 }
672 /* Same here...*/
673 else if ( ( res = cris_io_interface_allocate_pins( if_i2c
674 , 'b'
675 , CONFIG_ETRAX_I2C_CLK_PORT
676 , CONFIG_ETRAX_I2C_CLK_PORT
677 )
678 )
679 )
680 {
681 cris_io_interface_free_pins( if_i2c
682 , 'b'
683 , CONFIG_ETRAX_I2C_DATA_PORT
684 , CONFIG_ETRAX_I2C_DATA_PORT
685 );
686 printk( KERN_WARNING "i2c_init: Failed to get IO pin for I2C clk port\n" );
687 }
688 #endif
689
690 return ( res );
691 } /* i2c_init */
692
693
694 /*#---------------------------------------------------------------------------
695 *#
696 *# FUNCTION NAME: i2c_register
697 *#
698 *# DESCRIPTION : this registers the i2c driver as a character device
699 *#
700 *# PARAMETERS :
701 *#
702 *#---------------------------------------------------------------------------
703 */
704 static int __init i2c_register( void )
705 {
706 int res;
707 /**GVC**/
708 #ifdef DYNAMIC_MAJOR_I2CDEV_NUMBER_ALLOC
709 dev_t devt;
710 struct cdev *my_i2cdev = NULL;
711 #endif
712 /**END GVC**/
713
714 res = i2c_init();
715
716 if ( res < 0 )
717 {
718 return res;
719 }
720
721 /**GVC**/
722 #ifdef DYNAMIC_MAJOR_I2CDEV_NUMBER_ALLOC
723 res = alloc_chrdev_region( &devt, 0, 1, i2c_name );
724
725 if ( res < 0 )
726 {
727 printk( KERN_DEBUG "I2C: EI2CNOMNUMBR\n" );
728 return ( res );
729 }
730
731 my_i2cdev = cdev_alloc();
732 my_i2cdev->ops = &i2c_fops;
733 my_i2cdev->owner = THIS_MODULE;
734
735 /* make device "alive" */
736 res = cdev_add( my_i2cdev, devt, 1 );
737
738 if ( res < 0 )
739 {
740 printk( KERN_DEBUG "I2C: EI2CDADDFAIL\n" );
741 return ( res );
742 }
743 #else
744 /**END GVC**/
745 res = register_chrdev( I2C_MAJOR, i2c_name, &i2c_fops );
746
747 if ( res < 0 )
748 {
749 printk( KERN_ERR "i2c: couldn't get a major number.\n" );
750 return res;
751 }
752 /**GVC**/
753 #endif
754 /**END GVC**/
755
756 printk( KERN_INFO "I2C driver v2.2, (c) 1999-2004 Axis Communications AB\n" );
757
758 /**GVC**/
759 printk( KERN_INFO " ==> Improvements done by Geert Vancompernolle - December 2006\n" );
760
761 #ifdef DYNAMIC_MAJOR_I2CDEV_NUMBER_ALLOC
762 printk( KERN_INFO "I2C Major: %d / I2C Name: %s\n", MAJOR( devt ), i2c_name );
763 #else
764 /**END GVC**/
765 printk( KERN_INFO "I2C Major: %d / I2C Name: %s\n", I2C_MAJOR, i2c_name );
766 /**GVC**/
767 #endif
768 /**END GVC**/
769
770 return ( 0 );
771 } /* i2c_register */
772
773
774 /*#---------------------------------------------------------------------------
775 *#
776 *# FUNCTION NAME: i2c_start
777 *#
778 *# DESCRIPTION : generate i2c start condition
779 *#
780 *# PARAMETERS : none
781 *#
782 *# RETURN : EI2CNOERRORS if OK, EI2CSTRTCOND otherwise
783 *#
784 *#---------------------------------------------------------------------------
785 */
786 int i2c_start( void )
787 {
788 /* Set SCL=1, SDA=1 */
789 i2c_sda_dir_out();
790 i2c_set_sda( SDA_HIGH );
791 i2c_delay( WAITONEUS );
792 i2c_set_scl( SCL_HIGH );
793 i2c_delay( WAITONEUS );
794
795 /* Set SCL=1, SDA=0 */
796 i2c_set_sda( SDA_LOW );
797 i2c_delay( THDSTA );
798
799 /* Set SCL=0, SDA=0 */
800 i2c_set_scl( SCL_LOW );
801 /* We can take 1 us less than defined in spec (5 us), since the next action
802 * will be to set the dataline high or low and this action is 1 us
803 * before the clock is put high, so that makes our 5 us.
804 */
805 i2c_delay( TLOW - WAITONEUS );
806
807 if ( i2c_sda_is_high() || i2c_scl_is_high() )
808 {
809 printk( KERN_DEBUG "I2C: EI2CSTRTCOND\n" );
810 return ( EI2CSTRTCOND );
811 }
812
813 return ( EI2CNOERRORS );
814 } /* i2c_start */
815
816
817 /*#---------------------------------------------------------------------------
818 *#
819 *# FUNCTION NAME: i2c_stop
820 *#
821 *# DESCRIPTION : generate i2c stop condition
822 *#
823 *# PARAMETERS : none
824 *#
825 *# RETURN : none
826 *#
827 *#---------------------------------------------------------------------------
828 */
829 int i2c_stop( void )
830 {
831 i2c_sda_dir_out();
832
833 /* Set SCL=0, SDA=0 */
834 /* Don't change order, otherwise you might generate a start condition! */
835 i2c_set_scl( SCL_LOW );
836 i2c_delay( WAITONEUS );
837 i2c_set_sda( SDA_LOW );
838 i2c_delay( WAITONEUS );
839
840 /* Set SCL=1, SDA=0 */
841 i2c_set_scl( SCL_HIGH );
842 i2c_delay( TSUSTO );
843
844 /* Set SCL=1, SDA=1 */
845 i2c_set_sda( SDA_HIGH );
846 i2c_delay( TBUF );
847
848 i2c_sda_dir_in();
849
850 if ( !i2c_sda_is_high() || !i2c_scl_is_high() )
851 {
852 printk( KERN_DEBUG "I2C: EI2CSTOPCOND\n" );
853 return ( EI2CSTOPCOND );
854 }
855
856 return ( EI2CNOERRORS );
857 } /* i2c_stop */
858
859
860 /*#---------------------------------------------------------------------------
861 *#
862 *# FUNCTION NAME: i2c_outbyte
863 *#
864 *# DESCRIPTION : write a byte to the i2c interface
865 *#
866 *# PARAMETERS : x: byte to be sent on the I2C bus
867 *#
868 *# RETURN : none
869 *#
870 *#---------------------------------------------------------------------------
871 */
872 int i2c_outbyte( unsigned char x )
873 {
874 int i;
875
876 i2c_sda_dir_out();
877
878 for ( i = 0; i < 8; i++ )
879 {
880 if ( x & 0x80 )
881 {
882 i2c_set_sda( SDA_HIGH );
883 }
884 else
885 {
886 i2c_set_sda( SDA_LOW );
887 }
888
889 i2c_delay( TSUDAT );
890 i2c_set_scl( SCL_HIGH );
891 i2c_delay( THIGH );
892 i2c_set_scl( SCL_LOW );
893 i2c_delay( TSUDAT );
894 i2c_set_sda( SDA_LOW );
895 /* There should be only 5 us between falling edge and new rising
896 * edge of clock pulse.
897 * Since we spend already 1 us since clock edge was low, there are
898 * only ( TLOW - TSUDAT ) us left.
899 * Next to this, since the data line will be set up 1 us before the
900 * clock line is set up, we can reduce the delay with another us.
901 */
902 i2c_delay( TLOW - TSUDAT - WAITONEUS );
903 x <<= 1;
904 }
905
906 /* enable input */
907 i2c_sda_dir_in();
908
909 if ( !i2c_getack() )
910 {
911 printk( KERN_DEBUG "I2C: EI2CNOACKNLD\n" );
912 return( EI2CNOACKNLD );
913 }
914
915 return ( EI2CNOERRORS );
916 } /* i2c_outbyte */
917
918
919 /*#---------------------------------------------------------------------------
920 *#
921 *# FUNCTION NAME: i2c_inbyte
922 *#
923 *# DESCRIPTION : read a byte from the i2c interface
924 *#
925 *# PARAMETERS : none
926 *#
927 *# RETURN : returns the byte read from the I2C device
928 *#
929 *#---------------------------------------------------------------------------
930 */
931 unsigned char i2c_inbyte( void )
932 {
933 unsigned char aBitByte = 0;
934 unsigned char Mask = 0x80; /* !!! ATTENTION: do NOT use 'char', otherwise shifting is wrong!!! */
935 /* Must be UNSIGNED, not SIGNED! */
936
937
938 /* Switch off I2C to get bit */
939 i2c_disable();
940 i2c_sda_dir_in();
941
942 while ( Mask != 0 )
943 {
944 i2c_set_scl( SCL_HIGH );
945 i2c_delay( THIGH );
946
947 if ( i2c_sda_is_high() )
948 {
949 aBitByte |= Mask;
950 }
951
952 i2c_set_scl( SCL_LOW );
953
954 Mask >>= 1;
955
956 i2c_delay( TLOW );
957 }
958
959 /*
960 * we leave the clock low, getbyte is usually followed
961 * by sendack/nack, they assume the clock to be low
962 */
963 return ( aBitByte );
964 } /* i2c_inbyte */
965
966
967 /*#---------------------------------------------------------------------------
968 *#
969 *# FUNCTION NAME: i2c_getack
970 *#
971 *# DESCRIPTION : checks if ack was received from ic2
972 *#
973 *# PARAMETERS : none
974 *#
975 *# RETURN : returns the ack state of the I2C device
976 *#
977 *#---------------------------------------------------------------------------
978 */
979 int i2c_getack( void )
980 {
981 int ack = 1;
982
983 /* generate ACK clock pulse */
984 i2c_set_scl( SCL_HIGH );
985
986 /* switch off I2C */
987 i2c_disable();
988
989 /* now wait for ack */
990 i2c_delay( THIGH );
991 /* check for ack: if SDA is high, then NACK, else ACK */
992 if ( i2c_sda_is_high() )
993 {
994 ack = 0;
995 }
996 else
997 {
998 ack = 1;
999 }
1000
1001 /* end clock pulse */
1002 i2c_enable();
1003 i2c_set_scl( SCL_LOW );
1004 i2c_sda_dir_out();
1005 i2c_set_sda( SDA_LOW );
1006
1007 /* Since we "lost" already THDDAT time, we can subtract it here... */
1008 i2c_delay( TLOW - THDDAT );
1009
1010 return ( ack );
1011 } /* i2c_getack */
1012
1013
1014 /*#---------------------------------------------------------------------------
1015 *#
1016 *# FUNCTION NAME: i2c_sendack
1017 *#
1018 *# DESCRIPTION : sends ACK on received data
1019 *#
1020 *# PARAMETERS : none
1021 *#
1022 *# RETURN : none
1023 *#
1024 *#---------------------------------------------------------------------------
1025 */
1026 void i2c_sendack( void )
1027 {
1028 /* enable output */
1029 /* Clock has been set to TLOW already at end of i2c_inbyte()
1030 * and i2c_outbyte(), so no need to do it again.
1031 */
1032 i2c_sda_dir_out();
1033 /* set ack pulse low */
1034 i2c_set_sda( SDA_LOW );
1035 /* generate clock pulse */
1036 i2c_delay( TSUDAT );
1037 i2c_set_scl( SCL_HIGH );
1038 i2c_delay( THIGH );
1039 i2c_set_scl( SCL_LOW );
1040 i2c_delay( THDDAT );
1041 /* reset data out */
1042 i2c_set_sda( SDA_HIGH );
1043 /* Subtract time spend already when waited to put SDA high */
1044 i2c_delay( TLOW - THDDAT );
1045
1046 /* release the SDA line */
1047 i2c_sda_dir_in();
1048 } /* i2c_sendack */
1049
1050
1051 /*#---------------------------------------------------------------------------
1052 *#
1053 *# FUNCTION NAME: i2c_sendnack
1054 *#
1055 *# DESCRIPTION : sends NACK on received data
1056 *#
1057 *# PARAMETERS : none
1058 *#
1059 *# RETURN : none
1060 *#
1061 *#---------------------------------------------------------------------------
1062 */
1063 void i2c_sendnack( void )
1064 {
1065 /* make sure the SDA line is set high prior to activation of the output.
1066 * this way, you avoid an unnecessary peak to ground when a NACK has to
1067 * be created.
1068 */
1069 /* set data high */
1070 i2c_set_sda( SDA_HIGH );
1071 /* enable output */
1072 i2c_sda_dir_out();
1073
1074 /* generate clock pulse */
1075 i2c_delay( TSUDAT );
1076 i2c_set_scl( SCL_HIGH );
1077 i2c_delay( THIGH );
1078 i2c_set_scl( SCL_LOW );
1079 i2c_delay( TSUDAT );
1080 i2c_set_sda( SDA_LOW );
1081 i2c_delay( TLOW - TSUDAT );
1082
1083 /* There's no need to change the direction of SDA to "in" again,
1084 * since a NACK is always followed by a stop condition.
1085 * A STOP condition will put the direction of SDA back to "out"
1086 * resulting in a useless SDA "dip" on the line...
1087 */
1088 /* i2c_sda_dir_in(); */
1089 } /* i2c_sendnack */
1090
1091
1092 /*#---------------------------------------------------------------------------
1093 *#
1094 *# FUNCTION NAME: i2c_writereg
1095 *#
1096 *# DESCRIPTION : writes a value to a register of an I2C device
1097 *#
1098 *# PARAMETERS : theSlave = slave address of the I2C device
1099 *# theReg = register of the I2C device that needs to be written
1100 *# theValue = value to be written to the register
1101 *#
1102 *# RETURN : returns OR-ed result of the write action:
1103 *# 0 = Ok
1104 *# 1 = Slave_NoAck
1105 *# 2 = Reg_NoAck
1106 *# 4 = Val_NoAck
1107 *#
1108 *#---------------------------------------------------------------------------
1109 */
1110 int i2c_writereg( unsigned char theSlave
1111 , unsigned char theReg
1112 , unsigned char theValue
1113 )
1114 {
1115 int error, cntr = 3;
1116 unsigned long flags;
1117
1118 spin_lock( &i2c_lock );
1119
1120 do
1121 {
1122 error = 0;
1123 /* we don't like to be interrupted */
1124 local_irq_save( flags );
1125
1126 i2c_start();
1127 /* send slave address */
1128 if ( EI2CNOACKNLD == i2c_outbyte( theSlave & 0xfe ) )
1129 {
1130 error = 1;
1131 }
1132
1133 /* now select register */
1134 if ( EI2CNOACKNLD == i2c_outbyte( theReg ) )
1135 {
1136 error |= 2;
1137 }
1138
1139 /* send register register data */
1140 if ( EI2CNOACKNLD == i2c_outbyte( theValue ) )
1141 {
1142 error |= 4;
1143 }
1144
1145 /* end byte stream */
1146 i2c_stop();
1147 /* enable interrupt again */
1148 local_irq_restore( flags );
1149
1150 } while ( error && cntr-- );
1151
1152 i2c_delay( TLOW );
1153
1154 spin_unlock( &i2c_lock );
1155
1156 return ( -error );
1157 } /* i2c_writereg */
1158
1159
1160 /*#---------------------------------------------------------------------------
1161 *#
1162 *# FUNCTION NAME: i2c_readreg
1163 *#
1164 *# DESCRIPTION : reads the value from a certain register of an I2C device.
1165 *# Function first writes the register that it wants to read
1166 *# later on.
1167 *#
1168 *# PARAMETERS : theSlave = slave address of the I2C device
1169 *# theReg = register of the I2C device that needs to be written
1170 *#
1171 *# RETURN : returns OR-ed result of the write action:
1172 *# 0 = Ok
1173 *# 1 = Slave_NoAck
1174 *# 2 = Reg_NoAck
1175 *# 4 = Val_NoAck
1176 *#
1177 *#---------------------------------------------------------------------------
1178 */
1179 unsigned char i2c_readreg( unsigned char theSlave
1180 , unsigned char theReg
1181 )
1182 {
1183 unsigned char b = 0;
1184 int error, cntr = 3;
1185 unsigned long flags;
1186
1187 spin_lock( &i2c_lock );
1188
1189 do
1190 {
1191 error = 0;
1192
1193 /* we don't like to be interrupted */
1194 local_irq_save( flags );
1195
1196 /* generate start condition */
1197 i2c_start();
1198
1199 /* send slave address */
1200 if ( EI2CNOACKNLD == i2c_outbyte( theSlave & 0xfe ) )
1201 {
1202 error = 1;
1203 }
1204
1205 /* now select register */
1206 i2c_sda_dir_out();
1207
1208 if ( EI2CNOACKNLD == i2c_outbyte( theReg ) )
1209 {
1210 error |= 2;
1211 }
1212
1213 /* repeat start condition */
1214 i2c_delay( TLOW );
1215 i2c_start();
1216
1217 /* send slave address */
1218 if ( EI2CNOACKNLD == i2c_outbyte( theSlave | 0x01 ) )
1219 {
1220 error |= 1;
1221 }
1222
1223 /* fetch register */
1224 b = i2c_inbyte();
1225 /*
1226 * last received byte needs to be nacked
1227 * instead of acked
1228 */
1229 i2c_sendnack();
1230
1231 /* end sequence */
1232 i2c_stop();
1233
1234 /* enable interrupt again */
1235 local_irq_restore( flags );
1236
1237 } while ( error && cntr-- );
1238
1239 spin_unlock( &i2c_lock );
1240
1241 return ( b );
1242 } /* i2c_readreg */
1243
1244
1245 /*#---------------------------------------------------------------------------
1246 *#
1247 *# FUNCTION NAME: i2c_read
1248 *#
1249 *# DESCRIPTION :
1250 *#
1251 *# PARAMETERS :
1252 *#
1253 *# RETURN :
1254 *#
1255 *#---------------------------------------------------------------------------
1256 */
1257 int i2c_read( unsigned char slave, unsigned char* rbuf, unsigned char rlen )
1258 {
1259 return ( i2c_command( slave, NULL, 0, rbuf, rlen ) );
1260 } /* i2c_read */
1261
1262
1263 /*#---------------------------------------------------------------------------
1264 *#
1265 *# FUNCTION NAME: i2c_write
1266 *#
1267 *# DESCRIPTION :
1268 *#
1269 *# PARAMETERS :
1270 *#
1271 *# RETURN :
1272 *#
1273 *#---------------------------------------------------------------------------
1274 */
1275 int i2c_write( unsigned char slave, unsigned char* wbuf, unsigned char wlen )
1276 {
1277 return ( i2c_command( slave, wbuf, wlen, NULL, 0 ) );
1278 } /* i2c_write */
1279
1280
1281 /*#---------------------------------------------------------------------------
1282 *#
1283 *# FUNCTION NAME: i2c_writeread
1284 *#
1285 *# DESCRIPTION :
1286 *#
1287 *# PARAMETERS :
1288 *#
1289 *# RETURN :
1290 *#
1291 *#---------------------------------------------------------------------------
1292 */
1293 int i2c_writeread( unsigned char slave
1294 , unsigned char* wbuf
1295 , unsigned char wlen
1296 , unsigned char* rbuf
1297 , unsigned char rlen
1298 )
1299 {
1300 return ( i2c_command( slave, wbuf, wlen, rbuf, rlen ) );
1301 } /* i2c_writeread */
1302
1303
1304 /*#---------------------------------------------------------------------------
1305 *#
1306 *# FUNCTION NAME: module_init
1307 *#
1308 *# DESCRIPTION : this makes sure that i2c_register is called during boot
1309 *#
1310 *# PARAMETERS :
1311 *#
1312 *#---------------------------------------------------------------------------
1313 */
1314 module_init( i2c_register );
1315
1316 /****************** END OF FILE i2c.c ********************************/
OpenWrt Source Repository