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

Archive Download this file

Branches:
backfire
history
master
release_2010-11-17
release_2010-12-14
release_2011-02-23
release_2011-05-28
release_2011-08-27
release_2011-11-13
release_2012-03-18
release_2012-04-09
release_2012-10-11
uclibc_nptl



interactive