Changeset 17954


Ignore:
Timestamp:
2009-10-06T11:20:30+02:00 (7 years ago)
Author:
claudio
Message:

[etrax] Improve i2c driver slave delay, thanks to Fabrizio Sciarra that provide it

  • support for master/slave delay (provided patch)
  • remove some printk that spam logs
  • introduce new symbols ETRAX_I2C_DYN_ALLOC and ETRAX_I2C_SLAVE_DELAY
  • cleanup a bit the driver
  • dump release number
Location:
trunk/target/linux/etrax
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • trunk/target/linux/etrax/files-2.6.30/arch/cris/arch-v10/drivers/i2c_gvc.c

    r15242 r17954  
    1010*!***************************************************************************/ 
    1111 
    12 #define DYNAMIC_MAJOR_I2CDEV_NUMBER_ALLOC 
    13 //#undef  DYNAMIC_MAJOR_I2CDEV_NUMBER_ALLOC 
    14  
    1512/******************** INCLUDE FILES SECTION ****************************/ 
    1613 
     
    1815#include <linux/fs.h> 
    1916 
    20 /**GVC**/ 
    21 #ifdef DYNAMIC_MAJOR_I2CDEV_NUMBER_ALLOC 
     17#ifdef CONFIG_ETRAX_I2C_DYN_ALLOC 
    2218#include <linux/types.h> /* for dev_t */ 
    2319#include <linux/cdev.h>  /* for struct cdev */ 
    2420#endif 
    25 /**END GVC**/ 
     21 
     22#include <linux/device.h> 
    2623 
    2724#include "etraxi2c.h" 
    2825 
    29 /**GVC**/ 
    3026#include "i2c_errno.h" 
    31 /**END GVC**/ 
    3227 
    3328#include <asm/io.h> 
     
    3833#include "i2c_gvc.h" 
    3934 
    40 MODULE_DESCRIPTION( "I2C Device Driver - 1.1" ); 
     35MODULE_DESCRIPTION( "I2C Device Driver - 2.3" ); 
    4136 
    4237/*!********************************************************************* 
     
    5146 *! 
    5247 *!*********************************************************************/ 
    53   
     48 
    5449MODULE_LICENSE( "GPL" ); 
    5550 
     
    5853#define D( x ) 
    5954 
    60 /**GVC**/ 
    61 #ifndef DYNAMIC_MAJOR_I2CDEV_NUMBER_ALLOC 
    62 /**END GVC**/ 
     55#ifndef CONFIG_ETRAX_I2C_DYN_ALLOC 
    6356#define I2C_MAJOR 123                           /* LOCAL/EXPERIMENTAL */ 
    64 /**GVC**/ 
    65 #endif 
    66 /**END GVC**/ 
    67  
    68 /**GVC**/ 
     57#endif 
     58 
    6959#define WAITONEUS                 1 
    7060/* Following are abbreviations taken from Philips I2C standard */ 
    71 /* Values are representing time in us and are rounded to next whole number, if relevant */  
     61/* Values are representing time in us and are rounded to next whole number, if relevant */ 
    7262#define THDSTA                    4     /* Hold delay time for (repeated) START condition */ 
    7363#define TLOW                      5     /* LOW period of the SCL clock */ 
     
    7969#define TBUF                      5     /* Bus-free time between STOP and START condition */ 
    8070 
     71#ifdef CONFIG_ETRAX_I2C_SLAVE_DELAY 
     72#define MAXSCLRETRIES             100 
     73#endif 
     74 
    8175#define MAXBUSFREERETRIES         5 
    8276#define MAXRETRIES                3 
    8377#define WRITEADDRESS_MASK         ( 0xFE ) 
    8478#define READADDRESS_MASK          ( 0x01 ) 
    85 /**END GVC**/ 
    8679 
    8780#define SCL_HIGH                  1 
     
    10194#define SDABIT CONFIG_ETRAX_I2C_DATA_PORT 
    10295#define SCLBIT CONFIG_ETRAX_I2C_CLK_PORT 
    103 #define i2c_enable()  
    104 #define i2c_disable()  
     96#define i2c_enable() 
     97#define i2c_disable() 
    10598 
    10699/* enable or disable output-enable, to select output or input on the i2c bus */ 
     
    110103  REG_SHADOW_SET( R_PORT_PB_DIR, port_pb_dir_shadow, SDABIT, 0 ) 
    111104 
     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 
    112112/* control the i2c clock and data signals */ 
    113113#define i2c_set_scl( x ) \ 
     
    119119#define i2c_sda_is_high() ( ( ( *R_PORT_PB_READ & ( 1 << SDABIT ) ) ) >> SDABIT ) 
    120120 
    121 /**GVC**/ 
    122121/* read status of SCL bit from the i2c interface */ 
    123122#define i2c_scl_is_high() ( ( ( *R_PORT_PB_READ & ( 1 << SCLBIT ) ) ) >> SCLBIT ) 
    124 /**END GVC**/ 
    125123 
    126124#else 
     
    132130#define i2c_sda_dir_out() \ 
    133131        *R_PORT_PB_I2C = ( port_pb_i2c_shadow &= ~IO_MASK( R_PORT_PB_I2C, i2c_oe_ ) ); \ 
    134         REG_SHADOW_SET( R_PORT_PB_DIR, port_pb_dir_shadow, 0, 1 );  
     132        REG_SHADOW_SET( R_PORT_PB_DIR, port_pb_dir_shadow, 0, 1 ); 
    135133#define i2c_sda_dir_in() \ 
    136134        *R_PORT_PB_I2C = ( port_pb_i2c_shadow |= IO_MASK( R_PORT_PB_I2C, i2c_oe_ ) ); \ 
     
    161159/****************** STATIC (file scope) VARIABLES **********************/ 
    162160static DEFINE_SPINLOCK( i2c_lock ); /* Protect directions etc */ 
    163 /**GVC**/ 
    164 #ifdef DYNAMIC_MAJOR_I2CDEV_NUMBER_ALLOC 
    165 static const char i2c_name[] = "i2cgvc"; 
    166 #else 
    167161static const char i2c_name[] = "i2c"; 
    168 #endif 
    169 /**END GVC**/ 
     162 
    170163 
    171164 
     
    173166static int  i2c_open( struct inode *inode, struct file *filp ); 
    174167static int  i2c_release( struct inode *inode, struct file *filp ); 
    175 /**GVC**/ 
    176168static int  i2c_command( unsigned char  slave 
    177169                       , unsigned char* wbuf 
     
    182174static int  i2c_bus_free_check( unsigned char maxretries ); 
    183175static void i2c_finalise( const char* text, unsigned long irqflags ); 
    184 /**END GVC**/ 
    185                             
     176 
    186177 
    187178/************************************************************************/ 
     
    196187 *# 
    197188 *# PARAMETERS   : *inode: reference to inode 
    198  *#                *filp : reference to file pointer  
     189 *#                *filp : reference to file pointer 
    199190 *# 
    200191 *#--------------------------------------------------------------------------- 
     
    213204 *# 
    214205 *# PARAMETERS   : *inode: reference to inode 
    215  *#                *filp : reference to file pointer  
     206 *#                *filp : reference to file pointer 
    216207 *# 
    217208 *#--------------------------------------------------------------------------- 
     
    227218 *# FUNCTION NAME: i2c_ioctl 
    228219 *# 
    229  *# DESCRIPTION  : Main device API: ioctl's to write/read  
     220 *# DESCRIPTION  : Main device API: ioctl's to write/read 
    230221 *#                to/from i2c registers 
    231222 *# 
    232223 *# PARAMETERS   : *inode: reference to inode 
    233  *#                *filp : reference to file pointer  
    234  *#                cmd   : command to be executed during the ioctl call  
    235  *#                arg   : pointer to a structure with the data???  
     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??? 
    236227 *# 
    237228 *# RETURN       : result of the ioctl call 
     
    248239    I2C_DATA i2cdata; 
    249240    int RetVal = EI2CNOERRORS; 
    250      
    251     if ( _IOC_TYPE( cmd ) != ETRAXI2C_IOCTYPE )  
     241 
     242    if ( _IOC_TYPE( cmd ) != ETRAXI2C_IOCTYPE ) 
    252243    { 
    253244        return ( -EINVAL ); 
    254245    } 
    255      
    256     switch ( _IOC_NR( cmd ) )  
     246 
     247    switch ( _IOC_NR( cmd ) ) 
    257248    { 
    258249    case I2C_WRITEREG: 
     
    262253                             , I2C_ARGVALUE( arg ) 
    263254                             ); 
    264         break;                        
     255        break; 
    265256 
    266257    case I2C_READREG: 
    267258        RetVal = i2c_readreg( I2C_ARGSLAVE( arg ), I2C_ARGREG( arg ) ); 
    268259        break; 
    269      
    270 /**GVC**/ 
    271     /* New functions added by GVC */     
     260 
     261    /* New functions added by GVC */ 
    272262    case I2C_READ: 
    273263        copy_from_user( (char*)&i2cdata, (char*)arg, sizeof( I2C_DATA ) ); 
    274264        { 
    275265            int RetryCntr = MAXRETRIES; 
    276              
     266 
    277267            do 
    278268            { 
    279269                RetVal = i2c_command( i2cdata.slave 
    280270                                    , NULL 
    281                                     , 0  
     271                                    , 0 
    282272                                    , i2cdata.rbuf 
    283273                                    , i2cdata.rlen 
     
    294284        { 
    295285            int RetryCntr = MAXRETRIES; 
    296              
     286 
    297287            do 
    298288            { 
     
    301291                                    , i2cdata.wlen 
    302292                                    , NULL 
    303                                     , 0  
     293                                    , 0 
    304294                                    ); 
    305295             } while ( ( EI2CNOERRORS != RetVal ) 
     
    308298        } 
    309299        break; 
    310            
     300 
    311301    case I2C_WRITEREAD: 
    312302        copy_from_user( (char*)&i2cdata, (char*)arg, sizeof( I2C_DATA ) ); 
    313303        { 
    314304            int RetryCntr = MAXRETRIES; 
    315              
     305 
    316306            do 
    317307            { 
     
    320310                                    , i2cdata.wlen 
    321311                                    , i2cdata.rbuf 
    322                                     , i2cdata.rlen  
     312                                    , i2cdata.rlen 
    323313                                    ); 
    324314             } while ( ( EI2CNOERRORS != RetVal ) 
     
    328318        copy_to_user( (char*)arg, (char*)&i2cdata, sizeof( I2C_DATA ) ); 
    329319        break; 
    330 /**END GVC**/     
    331      
     320 
    332321    default: 
    333322        RetVal = -EINVAL; 
    334323    } 
    335      
     324 
    336325    return ( -RetVal ); 
    337326}   /* i2c_ioctl */ 
     
    343332 *# 
    344333 *# DESCRIPTION  : general routine to read/write bytes from an I2C device 
    345  *#                 
     334 *# 
    346335 *#                'i2c_command()' sends wlen bytes to the I2c bus and receives 
    347  *#                rlen bytes from the I2c bus.   
     336 *#                rlen bytes from the I2c bus. 
    348337 *#                The data to be send must be placed in wbuf[ 0 ] upto wbuf[ wlen - 1 ). 
    349338 *#                The data to be received is assembled in rbuf[ 0 ] upto rbuf[ rlen - 1 ]. 
    350  *#                  
     339 *# 
    351340 *#                If no data is to be sent or received, put appropriate buffer parameter 
    352341 *#                to "NULL" and appropriate length parameter to "0". 
    353  *#  
     342 *# 
    354343 *# PARAMETERS   : slave = slave address of the I2C device 
    355344 *#                wbuf  = address of first element of write buffer (wbuf) 
     
    358347 *#                rlen  = number of bytes to be read from slave 
    359348 *# 
    360  *# RETURN       :  
     349 *# RETURN       : 
    361350 *#    EI2CNOERRORS: I2C communication went fine 
    362351 *#    EI2CBUSNFREE: I2C bus is not free 
     
    375364 *# 
    376365 *# REMARK       : 
    377  *#   First, the send part is completed.   
     366 *#   First, the send part is completed. 
    378367 *#   In the send routine, there is no stop generated.  This is because maybe 
    379368 *#   a repeated start condition must be generated. 
     
    381370 *#   at the end of the general I2c loop the stopcondition is generated. 
    382371 *#   If, on the contrary, there are a number of bytes to be received, a new 
    383  *#   startcondition is generated in the 'if' part of the main I2c routine,  
    384  *#   which controls the receiving part.   
    385  *#   Only when the receiving of data is finished, a final stopcondition is  
     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 
    386375 *#   generated. 
    387376 *# 
     
    435424        local_irq_save( irqflags ); 
    436425 
    437         /* Check if there are bytes to be send,  
     426        /* Check if there are bytes to be send, 
    438427         * or if you immediately want to receive data. 
    439428         */ 
    440429        if ( 0 < wlen ) 
    441430        { 
    442             /* start I2C communication */         
     431            /* start I2C communication */ 
    443432            if ( EI2CNOERRORS != i2c_start() ) 
    444433            { 
    445434                return ( i2c_finalise( "I2C: EI2CSTRTCOND\n", irqflags  ) 
    446                        , EI2CSTRTCOND  
     435                       , EI2CSTRTCOND 
    447436                       ); 
    448437            } 
     
    452441            { 
    453442                return ( i2c_finalise( "I2C: EI2CWADDRESS\n", irqflags  ) 
    454                        , EI2CWADDRESS  
     443                       , EI2CWADDRESS 
    455444                       ); 
    456445            } 
    457446 
    458447            while ( wlen-- ) 
    459             {    
     448            { 
    460449                /* send register data */ 
    461                 if ( EI2CNOERRORS != i2c_outbyte( *wbuf ) ) 
     450                if ( EI2CNOERRORS != i2c_outbyte( *wbuf ) && wlen ) 
    462451                { 
    463452                    return ( i2c_finalise( "I2C: EI2CSENDDATA\n", irqflags  ) 
    464                            , EI2CSENDDATA  
     453                           , EI2CSENDDATA 
    465454                           ); 
    466455                } 
    467                  
     456 
    468457                wbuf++; 
    469458            }; 
    470                  
     459 
    471460            i2c_delay( TLOW ); 
    472461        } 
     
    482471        { 
    483472            /* 
    484              * Generate start condition if wlen == 0  
     473             * Generate start condition if wlen == 0 
    485474             * or repeated start condition if wlen != 0... 
    486475             */ 
    487476            if ( EI2CNOERRORS != i2c_start() ) 
    488477            { 
    489                 return ( i2c_finalise( ( ( 0 < wlen )  
     478                return ( i2c_finalise( ( ( 0 < wlen ) 
    490479                                       ? "I2C: EI2CRSTACOND\n" 
    491480                                       : "I2C: EI2CSTRTCOND\n" 
     
    504493                       ); 
    505494            } 
    506              
     495 
    507496            while ( rlen-- ) 
    508497            { 
     
    510499                *rbuf = i2c_inbyte(); 
    511500                rbuf++; 
    512                  
     501 
    513502                /* last received byte needs to be NACK-ed instead of ACK-ed */ 
    514503                if ( rlen ) 
     
    516505                    i2c_sendack(); 
    517506                } 
    518                 else  
     507                else 
    519508                { 
    520                     i2c_sendnack();  
     509                    i2c_sendnack(); 
    521510                } 
    522511            }; 
     
    526515        if ( EI2CNOERRORS != i2c_stop() ) 
    527516        { 
    528             return ( i2c_finalise( "I2C: EI2CSTOPCOND\n", irqflags ) 
     517            return ( i2c_finalise( "I2C CMD: EI2CSTOPCOND\n", irqflags ) 
    529518                   , EI2CSTOPCOND 
    530519                   ); 
    531         }  
    532      
     520        } 
     521 
    533522        /* enable interrupt again */ 
    534523        local_irq_restore( irqflags ); 
    535524    } 
    536      
     525 
    537526    return ( EI2CNOERRORS ); 
    538527} /*  i2c_command */ 
     
    545534 *# DESCRIPTION  : checks if the I2C bus is free before starting 
    546535 *#                an I2C communication 
    547  *#  
     536 *# 
    548537 *# PARAMETERS   : maxretries, the number of times we will try to release 
    549  *#                the I2C bus   
     538 *#                the I2C bus 
    550539 *# 
    551540 *# RETURN       : I2cStatus_I2cBusNotFreeError in case the bus is not free, 
    552  *#                I2cStatus_I2cNoError otherwise  
     541 *#                I2cStatus_I2cNoError otherwise 
    553542 *# 
    554543 *#--------------------------------------------------------------------------- 
     
    558547    i2c_sda_dir_in();        /* Release SDA line */ 
    559548    i2c_set_scl( SCL_HIGH ); /* put SCL line high */ 
    560      
     549 
    561550    i2c_delay( WAITONEUS ); 
    562          
     551 
    563552    while ( ( !i2c_sda_is_high() || !i2c_scl_is_high() ) 
    564553          &&( maxretries-- ) 
     
    568557        i2c_stop(); 
    569558    } 
    570      
     559 
    571560    if ( 0 == maxretries ) 
    572561    { 
     
    574563        return ( EI2CBUSNFREE ); 
    575564    } 
    576     else  
     565    else 
    577566    { 
    578567        return ( EI2CNOERRORS ); 
     
    593582     */ 
    594583    (void)i2c_bus_free_check( MAXBUSFREERETRIES ); 
    595 }   /* i2c_finalise */                          
    596  
    597  
    598 static struct file_operations i2c_fops =  
     584}   /* i2c_finalise */ 
     585 
     586 
     587static struct file_operations i2c_fops = 
    599588{ 
    600589    .owner    = THIS_MODULE 
     
    624613    static int first = 1; 
    625614 
    626     if ( !first )  
     615    if ( !first ) 
    627616    { 
    628617        return res; 
    629618    } 
    630      
     619 
    631620    first = 0; 
    632621 
     
    635624#ifndef CONFIG_ETRAX_I2C_USES_PB_NOT_PB_I2C 
    636625    /* here, we're using the dedicated I2C pins of FoxBoard */ 
    637     if ( ( res = cris_request_io_interface( if_i2c, "I2C" ) ) )  
     626    if ( ( res = cris_request_io_interface( if_i2c, "I2C" ) ) ) 
    638627    { 
    639628        printk( KERN_CRIT "i2c_init: Failed to get IO interface\n" ); 
     
    641630    } 
    642631 
    643     *R_PORT_PB_I2C = port_pb_i2c_shadow |=  
     632    *R_PORT_PB_I2C = port_pb_i2c_shadow |= 
    644633        IO_STATE( R_PORT_PB_I2C, i2c_en,  on ) | 
    645634        IO_FIELD( R_PORT_PB_I2C, i2c_d,   1 )  | 
     
    654643              IO_STATE( R_PORT_PB_DIR, dir1, output ) ); 
    655644#else 
    656         /* If everything goes fine, res = 0, meaning "if" fails =>  
     645        /* If everything goes fine, res = 0, meaning "if" fails => 
    657646         * will do the "else" too and as such initialise the clock port... 
    658          * Clever trick!  
     647         * Clever trick! 
    659648         */ 
    660649        if ( ( res = cris_io_interface_allocate_pins( if_i2c 
    661650                                                    , 'b' 
    662651                                                    , CONFIG_ETRAX_I2C_DATA_PORT 
    663                                                     , CONFIG_ETRAX_I2C_DATA_PORT  
    664                                                     )  
    665              )  
    666            )  
     652                                                    , CONFIG_ETRAX_I2C_DATA_PORT 
     653                                                    ) 
     654             ) 
     655           ) 
    667656        { 
    668657            printk( KERN_WARNING "i2c_init: Failed to get IO pin for I2C data port\n" ); 
    669658            return ( res ); 
    670659        } 
    671         /* Same here...*/  
     660        /* Same here...*/ 
    672661        else if ( ( res = cris_io_interface_allocate_pins( if_i2c 
    673662                                                         , 'b' 
    674663                                                         , CONFIG_ETRAX_I2C_CLK_PORT 
    675                                                          , CONFIG_ETRAX_I2C_CLK_PORT  
    676                                                          )  
    677                   )  
    678                 )  
     664                                                         , CONFIG_ETRAX_I2C_CLK_PORT 
     665                                                         ) 
     666                  ) 
     667                ) 
    679668        { 
    680669            cris_io_interface_free_pins( if_i2c 
    681670                                       , 'b' 
    682671                                       , CONFIG_ETRAX_I2C_DATA_PORT 
    683                                        , CONFIG_ETRAX_I2C_DATA_PORT  
     672                                       , CONFIG_ETRAX_I2C_DATA_PORT 
    684673                                       ); 
    685674            printk( KERN_WARNING "i2c_init: Failed to get IO pin for I2C clk port\n" ); 
     
    701690 *#--------------------------------------------------------------------------- 
    702691 */ 
     692 
     693static struct class *i2c_class; 
     694 
    703695static int __init i2c_register( void ) 
    704696{ 
    705697    int res; 
    706 /**GVC**/ 
    707 #ifdef DYNAMIC_MAJOR_I2CDEV_NUMBER_ALLOC 
     698#ifdef CONFIG_ETRAX_I2C_DYN_ALLOC 
    708699    dev_t devt; 
    709700    struct cdev *my_i2cdev = NULL; 
    710701#endif 
    711 /**END GVC**/ 
    712702 
    713703    res = i2c_init(); 
    714      
     704 
    715705    if ( res < 0 ) 
    716706    { 
    717707        return res; 
    718708    } 
    719      
    720 /**GVC**/ 
    721 #ifdef DYNAMIC_MAJOR_I2CDEV_NUMBER_ALLOC 
     709 
     710#ifdef CONFIG_ETRAX_I2C_DYN_ALLOC 
    722711    res = alloc_chrdev_region( &devt, 0, 1, i2c_name ); 
    723      
     712 
    724713    if ( res < 0 ) 
    725714    { 
     
    727716        return ( res ); 
    728717    } 
    729      
     718 
    730719    my_i2cdev = cdev_alloc(); 
    731720    my_i2cdev->ops = &i2c_fops; 
    732721    my_i2cdev->owner = THIS_MODULE; 
    733     
    734     /* make device "alive" */  
     722 
     723    /* make device "alive" */ 
    735724    res = cdev_add( my_i2cdev, devt, 1 ); 
    736      
     725 
    737726    if ( res < 0 ) 
    738     {  
     727    { 
    739728        printk( KERN_DEBUG "I2C: EI2CDADDFAIL\n" ); 
    740729        return ( res ); 
    741730    } 
     731 
     732    int i2c_major = MAJOR( devt ); 
    742733#else 
    743 /**END GVC**/ 
    744734    res = register_chrdev( I2C_MAJOR, i2c_name, &i2c_fops ); 
    745      
    746     if ( res < 0 )  
     735 
     736    if ( res < 0 ) 
    747737    { 
    748738        printk( KERN_ERR "i2c: couldn't get a major number.\n" ); 
    749739        return res; 
    750740    } 
    751 /**GVC**/ 
    752 #endif 
    753 /**END GVC**/ 
    754  
    755     printk( KERN_INFO "I2C driver v2.2, (c) 1999-2004 Axis Communications AB\n" ); 
    756  
    757 /**GVC**/ 
    758     printk( KERN_INFO "  ==> Improvements done by Geert Vancompernolle - December 2006\n" ); 
    759  
    760 #ifdef DYNAMIC_MAJOR_I2CDEV_NUMBER_ALLOC 
    761     printk( KERN_INFO "I2C Major: %d / I2C Name: %s\n", MAJOR( devt ), i2c_name ); 
    762 #else 
    763 /**END GVC**/ 
    764     printk( KERN_INFO "I2C Major: %d / I2C Name: %s\n", I2C_MAJOR, i2c_name ); 
    765 /**GVC**/ 
    766 #endif     
    767 /**END GVC**/ 
    768      
     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 
    769756    return ( 0 ); 
    770757}   /* i2c_register */ 
     
    785772int i2c_start( void ) 
    786773{ 
    787     /* Set SCL=1, SDA=1 */ 
     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 
    788820    i2c_sda_dir_out(); 
    789     i2c_set_sda( SDA_HIGH ); 
    790     i2c_delay( WAITONEUS ); 
    791     i2c_set_scl( SCL_HIGH ); 
    792     i2c_delay( WAITONEUS ); 
    793821     
    794     /* Set SCL=1, SDA=0 */ 
    795     i2c_set_sda( SDA_LOW ); 
    796     i2c_delay( THDSTA ); 
    797      
    798     /* Set SCL=0, SDA=0 */ 
    799     i2c_set_scl( SCL_LOW ); 
    800     /* We can take 1 us less than defined in spec (5 us), since the next action 
    801      * will be to set the dataline high or low and this action is 1 us 
    802      * before the clock is put high, so that makes our 5 us. 
    803      */ 
    804     i2c_delay( TLOW - WAITONEUS ); 
    805      
    806     if ( i2c_sda_is_high() || i2c_scl_is_high() ) 
    807     { 
    808         printk( KERN_DEBUG "I2C: EI2CSTRTCOND\n" ); 
    809         return ( EI2CSTRTCOND ); 
    810     } 
    811      
    812     return ( EI2CNOERRORS ); 
    813 }   /* i2c_start */ 
    814  
    815  
    816 /*#--------------------------------------------------------------------------- 
    817  *# 
    818  *# FUNCTION NAME: i2c_stop 
    819  *# 
    820  *# DESCRIPTION  : generate i2c stop condition 
    821  *# 
    822  *# PARAMETERS   : none 
    823  *# 
    824  *# RETURN       : none 
    825  *# 
    826  *#--------------------------------------------------------------------------- 
    827  */ 
    828 int i2c_stop( void ) 
    829 { 
    830     i2c_sda_dir_out(); 
    831  
    832822    /* Set SCL=0, SDA=0 */ 
    833823    /* Don't change order, otherwise you might generate a start condition! */ 
     
    838828     
    839829    /* Set SCL=1, SDA=0 */ 
     830     
     831#ifdef CONFIG_ETRAX_I2C_SLAVE_DELAY 
    840832    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 
    841845    i2c_delay( TSUSTO ); 
    842846     
     
    844848    i2c_set_sda( SDA_HIGH ); 
    845849    i2c_delay( TBUF ); 
    846  
     850     
    847851    i2c_sda_dir_in(); 
    848852     
    849853    if ( !i2c_sda_is_high() || !i2c_scl_is_high() ) 
    850     { 
    851         printk( KERN_DEBUG "I2C: EI2CSTOPCOND\n" ); 
    852         return ( EI2CSTOPCOND ); 
    853     } 
     854      { 
     855        return ( EI2CSTOPCOND ); 
     856      } 
    854857     
    855858    return ( EI2CNOERRORS ); 
     
    875878    i2c_sda_dir_out(); 
    876879 
    877     for ( i = 0; i < 8; i++ )  
    878     { 
    879         if ( x & 0x80 )  
     880    for ( i = 0; i < 8; i++ ) 
     881    { 
     882        if ( x & 0x80 ) 
    880883        { 
    881884            i2c_set_sda( SDA_HIGH ); 
    882         }  
    883         else  
     885        } 
     886        else 
    884887        { 
    885888            i2c_set_sda( SDA_LOW ); 
    886889        } 
    887          
     890 
    888891        i2c_delay( TSUDAT ); 
    889892        i2c_set_scl( SCL_HIGH ); 
     
    902905        x <<= 1; 
    903906    } 
    904      
     907 
    905908    /* enable input */ 
    906909    i2c_sda_dir_in(); 
    907      
     910 
    908911    if ( !i2c_getack() ) 
    909     { 
    910         printk( KERN_DEBUG "I2C: EI2CNOACKNLD\n" ); 
     912      { 
    911913        return( EI2CNOACKNLD ); 
    912     } 
    913      
     914      } 
     915 
    914916    return ( EI2CNOERRORS ); 
    915917}   /* i2c_outbyte */ 
     
    930932unsigned char i2c_inbyte( void ) 
    931933{ 
     934#ifdef CONFIG_ETRAX_I2C_SLAVE_DELAY 
     935    int n=MAXSCLRETRIES; 
     936#endif 
    932937    unsigned char aBitByte = 0; 
    933938    unsigned char Mask     = 0x80;    /* !!! ATTENTION: do NOT use 'char', otherwise shifting is wrong!!! */ 
     
    941946    while ( Mask != 0 ) 
    942947    { 
     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 
    943957        i2c_set_scl( SCL_HIGH ); 
     958        i2c_scl_dir_out(); 
     959#else 
     960        i2c_set_scl( SCL_HIGH ); 
     961#endif 
    944962        i2c_delay( THIGH ); 
    945963 
     
    979997{ 
    980998    int ack = 1; 
     999#ifdef CONFIG_ETRAX_I2C_SLAVE_DELAY 
     1000    int n=MAXSCLRETRIES; 
     1001#endif 
    9811002 
    9821003    /* generate ACK clock pulse */ 
    9831004    i2c_set_scl( SCL_HIGH ); 
    984      
     1005 
    9851006    /* switch off I2C */ 
    9861007    i2c_disable(); 
    9871008 
     1009#ifdef CONFIG_ETRAX_I2C_SLAVE_DELAY 
     1010    /* set clock low */ 
     1011    i2c_set_scl( SCL_LOW ); 
     1012 
    9881013    /* now wait for ack */ 
    9891014    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 
    9901037    /* check for ack: if SDA is high, then NACK, else ACK */ 
    9911038    if ( i2c_sda_is_high() ) 
     
    9971044        ack = 1; 
    9981045    } 
    999      
     1046 
    10001047    /* end clock pulse */ 
    10011048    i2c_enable(); 
     
    10061053    /* Since we "lost" already THDDAT time, we can subtract it here... */ 
    10071054    i2c_delay( TLOW  - THDDAT ); 
    1008      
     1055 
    10091056    return ( ack ); 
    10101057}   /* i2c_getack */ 
     
    10251072void i2c_sendack( void ) 
    10261073{ 
     1074#ifdef CONFIG_ETRAX_I2C_SLAVE_DELAY 
     1075    int n=MAXSCLRETRIES; 
     1076#endif 
     1077 
    10271078    /* enable output */ 
    10281079    /* Clock has been set to TLOW already at end of i2c_inbyte() 
     
    10341085    /* generate clock pulse */ 
    10351086    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 
    10361098    i2c_set_scl( SCL_HIGH ); 
     1099    i2c_scl_dir_out(); 
    10371100    i2c_delay( THIGH ); 
     1101#else 
     1102    i2c_set_scl( SCL_HIGH ); 
     1103 
     1104    i2c_delay( THIGH ); 
     1105#endif 
    10381106    i2c_set_scl( SCL_LOW ); 
    10391107    i2c_delay( THDDAT ); 
     
    10621130void i2c_sendnack( void ) 
    10631131{ 
     1132#ifdef CONFIG_ETRAX_I2C_SLAVE_DELAY 
     1133    int n=MAXSCLRETRIES; 
     1134#endif 
     1135 
    10641136    /* make sure the SDA line is set high prior to activation of the output. 
    10651137     * this way, you avoid an unnecessary peak to ground when a NACK has to 
     
    10731145    /* generate clock pulse */ 
    10741146    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 
    10751158    i2c_set_scl( SCL_HIGH ); 
     1159    i2c_scl_dir_out(); 
    10761160    i2c_delay( THIGH ); 
     1161#else 
     1162    i2c_set_scl( SCL_HIGH ); 
     1163 
     1164    i2c_delay( THIGH ); 
     1165#endif 
    10771166    i2c_set_scl( SCL_LOW ); 
    10781167    i2c_delay( TSUDAT ); 
    10791168    i2c_set_sda( SDA_LOW ); 
    10801169    i2c_delay( TLOW - TSUDAT ); 
    1081      
     1170 
    10821171    /* There's no need to change the direction of SDA to "in" again, 
    10831172     * since a NACK is always followed by a stop condition. 
     
    11091198int i2c_writereg( unsigned char theSlave 
    11101199                , unsigned char theReg 
    1111                 , unsigned char theValue  
     1200                , unsigned char theValue 
    11121201                ) 
    11131202{ 
     
    11171206    spin_lock( &i2c_lock ); 
    11181207 
    1119     do  
     1208    do 
    11201209    { 
    11211210        error = 0; 
     
    11291218            error = 1; 
    11301219        } 
    1131              
     1220 
    11321221        /* now select register */ 
    11331222        if ( EI2CNOACKNLD == i2c_outbyte( theReg ) ) 
     
    11351224            error |= 2; 
    11361225        } 
    1137          
     1226 
    11381227        /* send register register data */ 
    11391228        if ( EI2CNOACKNLD == i2c_outbyte( theValue ) ) 
     
    11411230            error |= 4; 
    11421231        } 
    1143               
     1232 
    11441233        /* end byte stream */ 
    11451234        i2c_stop(); 
    11461235        /* enable interrupt again */ 
    11471236        local_irq_restore( flags ); 
    1148          
     1237 
    11491238    } while ( error && cntr-- ); 
    11501239 
     
    11641253 *#                Function first writes the register that it wants to read 
    11651254 *#                later on. 
    1166  *#   
     1255 *# 
    11671256 *# PARAMETERS   : theSlave = slave address of the I2C device 
    11681257 *#                theReg   = register of the I2C device that needs to be written 
     
    11771266 */ 
    11781267unsigned char i2c_readreg( unsigned char theSlave 
    1179                          , unsigned char theReg  
     1268                         , unsigned char theReg 
    11801269                         ) 
    11811270{ 
     
    11861275    spin_lock( &i2c_lock ); 
    11871276 
    1188     do  
     1277    do 
    11891278    { 
    11901279        error = 0; 
    1191          
     1280 
    11921281        /* we don't like to be interrupted */ 
    11931282        local_irq_save( flags ); 
    1194          
     1283 
    11951284        /* generate start condition */ 
    11961285        i2c_start(); 
    1197      
     1286 
    11981287        /* send slave address */ 
    11991288        if ( EI2CNOACKNLD == i2c_outbyte( theSlave & 0xfe ) ) 
     
    12081297        { 
    12091298            error |= 2; 
    1210         }             
     1299        } 
    12111300 
    12121301        /* repeat start condition */ 
    12131302        i2c_delay( TLOW ); 
    12141303        i2c_start(); 
    1215          
     1304 
    12161305        /* send slave address */ 
    12171306        if ( EI2CNOACKNLD == i2c_outbyte( theSlave | 0x01 ) ) 
     
    12191308            error |= 1; 
    12201309        } 
    1221              
     1310 
    12221311        /* fetch register */ 
    12231312        b = i2c_inbyte(); 
     
    12271316         */ 
    12281317        i2c_sendnack(); 
    1229          
     1318 
    12301319        /* end sequence */ 
    12311320        i2c_stop(); 
    1232          
     1321 
    12331322        /* enable interrupt again */ 
    12341323        local_irq_restore( flags ); 
    1235          
     1324 
    12361325    } while ( error && cntr-- ); 
    12371326 
     
    12471336 *# 
    12481337 *# DESCRIPTION  : 
    1249  *#   
     1338 *# 
    12501339 *# PARAMETERS   : 
    12511340 *# 
     
    12651354 *# 
    12661355 *# DESCRIPTION  : 
    1267  *#   
     1356 *# 
    12681357 *# PARAMETERS   : 
    12691358 *# 
     
    12831372 *# 
    12841373 *# DESCRIPTION  : 
    1285  *#   
     1374 *# 
    12861375 *# PARAMETERS   : 
    12871376 *# 
  • trunk/target/linux/etrax/patches-2.6.30/500-i2c_gvc.patch

    r15581 r17954  
    1 --- a/arch/cris/arch-v10/drivers/Kconfig 
    2 +++ b/arch/cris/arch-v10/drivers/Kconfig 
    3 @@ -450,11 +450,18 @@ config ETRAX_I2C 
     1Index: linux-2.6.30.8/arch/cris/arch-v10/drivers/Kconfig 
     2=================================================================== 
     3--- linux-2.6.30.8.orig/arch/cris/arch-v10/drivers/Kconfig      2009-10-02 11:31:49.000000000 +0200 
     4+++ linux-2.6.30.8/arch/cris/arch-v10/drivers/Kconfig   2009-10-06 10:36:23.000000000 +0200 
     5@@ -450,11 +450,31 @@ 
    46          i2c_arg = I2C_READARG(STA013_READ_ADDR, reg); 
    57          val = ioctl(fd, _IO(ETRAXI2C_IOCTYPE, I2C_READREG), i2c_arg); 
     
    1214+         Enables an I2C driver with Geert Vancompernolle improvement. 
    1315+ 
     16+config ETRAX_I2C_SLAVE_DELAY 
     17+       bool "I2C Slave delay support" 
     18+       depends on ETRAX_I2C_GVC  && EXPERIMENTAL 
     19+       help 
     20+         Enable this to enhanced master/slave dialog 
     21+         Improvement by Positive Going (www.positivegoing.it) and BK srl (www.b-k.it) 
     22+ 
     23+config ETRAX_I2C_DYN_ALLOC 
     24+       bool "I2C major device dynamic alloc" 
     25+       depends on ETRAX_I2C_GVC && EXPERIMENTAL 
     26+       help 
     27+         Enable this to dynamicaly alloc major i2c device number 
     28+ 
    1429 # this is true for most products since PB-I2C seems to be somewhat 
    1530 # flawed.. 
     
    2136          Select whether to use the special I2C mode in the PB I/O register or 
    2237          not.  This option needs to be selected in order to use some drivers 
    23 @@ -478,7 +485,7 @@ config ETRAX_I2C_CLK_PORT 
     38@@ -478,7 +498,7 @@ 
    2439  
    2540 config ETRAX_I2C_EEPROM 
     
    3045          Enables I2C EEPROM (non-volatile RAM) on PB0 and PB1 using the I2C 
    3146          driver.  Select size option: Probed, 2k, 8k, 16k. 
    32 --- a/arch/cris/arch-v10/drivers/Makefile 
    33 +++ b/arch/cris/arch-v10/drivers/Makefile 
     47Index: linux-2.6.30.8/arch/cris/arch-v10/drivers/Makefile 
     48=================================================================== 
     49--- linux-2.6.30.8.orig/arch/cris/arch-v10/drivers/Makefile     2009-10-02 11:31:14.000000000 +0200 
     50+++ linux-2.6.30.8/arch/cris/arch-v10/drivers/Makefile  2009-10-02 11:31:50.000000000 +0200 
    3451@@ -4,6 +4,7 @@ 
    3552  
Note: See TracChangeset for help on using the changeset viewer.