drivers/iic/iic.c File Reference

Go to the source code of this file.

Enumerations

enum { WRDATA = 1, POLLACK, RDDATA, SETRDADDR }

Functions

void F_IicInit (void)

void F_IicWrite (U32 slvAddr, U32 addr, U8 data)

void F_IicRead (U32 slvAddr, U32 addr, U8 *data)

void F_IicPollingSet (void)

void F_IicPolling (void)

void F_IicDelay (U32 i)

Variables

static U8 _iicData [IICBUFSIZE]

static volatile int _iicDataCount

static volatile int _iicStatus

static volatile int _iicMode

static int _iicPt

Enumeration Type Documentation

anonymous enum

Enumerator:

WRDATA
POLLACK
RDDATA
SETRDADDR

Definition at line 6 of file iic.c.

00006 {WRDATA=1,POLLACK,RDDATA,SETRDADDR};

Function Documentation

void F_IicDelay ( U32 i )

Definition at line 31 of file iic.c.

00031                       {
00032     if(i==0) for(i=0;i<10000;i++);
00033     else if(i==1) for(i=0;i<1000;i++);
00034     else if(i==2) for(i=0;i<100;i++);
00035 }

void F_IicInit ( void )

Definition at line 19 of file iic.c.

00019                     {
00020     rGPEUP  |= 0xc000;                  //Pull-up disable
00021     rGPECON = (rGPECON&~0xf0000000) | 0xa0000000;                //GPE15:IICSDA , GPE14:IICSCL 
00022     //Enable ACK, Prescaler IICCLK=PCLK/16, Enable interrupt, Transmit clock value Tx
00023     //clock=IICCLK/16
00024     //IICCON = 0xaf;  /* PCLK/512 */
00025     rIICCON  = (1<<7) | (0<<6) | (1<<5) | (0xf);
00026     rIICADD  = 0x10;                    //2440 slave address = [7:1]
00027     rIICSTAT = 0x10;                    //IIC bus data output enable(Rx/Tx)
00028     //rIICADD = 0x9f;
00029     //rIICSTAT = 0x9f;
00030 }

void F_IicPolling ( void )

Definition at line 99 of file iic.c.

00100 {
00101     U32 iicSt,i;
00102     
00103     iicSt = rIICSTAT; 
00104     if(iicSt & 0x8){}                   //When bus arbitration is failed.
00105     if(iicSt & 0x4){}                   //When a slave address is matched with IICADD
00106     if(iicSt & 0x2){}                   //When a slave address is 0000000b
00107     if(iicSt & 0x1){}                   //When ACK isn't received
00108     //_iicStatus = iicSt;
00109 
00110     //printk(">");
00111     switch(_iicMode)
00112     {
00113         case POLLACK:
00114             _iicStatus = iicSt;
00115             break;
00116 
00117         case RDDATA:
00118             if((_iicDataCount--)==0)
00119             {
00120                 _iicData[_iicPt++] = rIICDS;
00121             
00122                 rIICSTAT = 0x90;                //Stop MasRx condition 
00123                 rIICCON  = 0xaf;                //Resumes IIC operation.
00124                 //while (rIICSTAT & 0x20);
00125                 
00126                 F_IicDelay(1);                       //Wait until stop condtion is in effect.
00127                                                  //Too long time... 
00128                                                 //The pending bit will not be set after issuing stop condition.
00129                 break;    
00130             }      
00131             _iicData[_iicPt++] = rIICDS;
00132                         //The last data has to be read with no ack.
00133             if((_iicDataCount)==0)
00134                 rIICCON = 0x2f;                 //Resumes IIC operation with NOACK.  
00135             else 
00136                 rIICCON = 0xaf;                 //Resumes IIC operation with ACK
00137             break;
00138 
00139         case WRDATA:
00140             if((_iicDataCount--)==0)
00141             {
00142                 rIICSTAT = 0xd0;                //stop MasTx condition 
00143                 rIICCON  = 0xaf;                //resumes IIC operation.
00144                 //while (rIICSTAT & 0x20);
00145                 F_IicDelay(1);                       //wait until stop condtion is in effect.
00146                        //The pending bit will not be set after issuing stop condition.
00147                 break;    
00148             }
00149             rIICDS = _iicData[_iicPt++];        //_iicData[0] has dummy.
00150             for(i=0;i<100;i++);                  //for setup time until rising edge of IICSCL
00151             rIICCON = 0xaf;                     //resumes IIC operation.
00152             break;
00153 
00154         case SETRDADDR:
00155 //          Uart_Printf("[S%d]",_iicDataCount);
00156             if((_iicDataCount--)==0)
00157             {
00158                 F_IicDelay(1);
00159                 break;                  //IIC operation is stopped because of IICCON[4]    
00160             }
00161             rIICDS = _iicData[_iicPt++];
00162             for(i=0;i<100;i++);          //for setup time until rising edge of IICSCL
00163             rIICCON = 0xaf;             //resumes IIC operation.
00164             break;
00165 
00166         default:
00167             break;
00168     }
00169 }

void F_IicPollingSet ( void )

Definition at line 92 of file iic.c.

00093 {
00094     if(rIICCON & 0x10) {                  //Tx/Rx Interrupt Enable
00095        F_IicPolling();
00096     }
00097 }

void F_IicRead	(	U32	slvAddr,
		U32	addr,
		U8 *	data
	)

Definition at line 57 of file iic.c.

00058 {
00059     ulong timeout;
00060     
00061     _iicMode      = SETRDADDR;
00062     _iicPt        = 0;
00063     _iicData[0]   = (U8)addr;
00064     _iicDataCount = 1;
00065 
00066     rIICDS   = slvAddr;
00067     rIICSTAT = 0xf0;                    //MasTx,Start  
00068     //rIICCON  = 0xaf;
00069     //Clearing the pending bit isn't needed because the pending bit has been cleared.
00070     timeout = 0x100000;
00071     while(_iicDataCount!=-1) {
00072        F_IicPollingSet();
00073        if(timeout!=0) timeout--;
00074        if (timeout==0) break;
00075     }
00076     _iicMode      = RDDATA;
00077     _iicPt        = 0;
00078     _iicDataCount = 1;
00079     rIICDS   = slvAddr;
00080     rIICSTAT = 0xb0;                    //Master Rx,Start
00081     rIICCON  = 0xaf;                    //Resumes IIC operation.   
00082     timeout = 0x100000;
00083     while(_iicDataCount!=-1) {
00084        F_IicPollingSet();
00085        if(timeout!=0) timeout--;
00086        if (timeout==0) break;
00087     }
00088     *data = _iicData[1];
00089     F_IicDelay(0);
00090 }

void F_IicWrite	(	U32	slvAddr,
		U32	addr,
		U8	data
	)

Definition at line 36 of file iic.c.

00036                                              {
00037     ulong timeout;
00038 
00039     _iicMode      = WRDATA;
00040     _iicPt        = 0;
00041     _iicData[0]   = (U8)addr;
00042     _iicData[1]   = data;
00043     _iicDataCount = 2;
00044     rIICDS        = slvAddr;            //0xa0
00045     rIICSTAT      = 0xf0;
00046     timeout = 0x100000;
00047     while(_iicDataCount!=-1) {
00048        F_IicPollingSet();
00049        if(timeout!=0) timeout--;
00050        if (timeout==0) break;
00051     }
00052     rIICSTAT = 0xd0;                    //Master Tx condition, Stop(Write), Output Enable
00053     rIICCON  = 0xaf;                    //Resumes IIC operation.
00054     F_IicDelay(0);                           //Wait until stop condtion is in effect.
00055 }

Variable Documentation

U8 _iicData[IICBUFSIZE] [static]

Definition at line 13 of file iic.c.

volatile int _iicDataCount [static]

Definition at line 14 of file iic.c.

volatile int _iicMode [static]

Definition at line 16 of file iic.c.

int _iicPt [static]

Definition at line 17 of file iic.c.

volatile int _iicStatus [static]

Definition at line 15 of file iic.c.


Enumerations
enum	{ WRDATA = 1, POLLACK, RDDATA, SETRDADDR }
Functions
void	F_IicInit (void)
void	F_IicWrite (U32 slvAddr, U32 addr, U8 data)
void	F_IicRead (U32 slvAddr, U32 addr, U8 *data)
void	F_IicPollingSet (void)
void	F_IicPolling (void)
void	F_IicDelay (U32 i)
Variables
static U8	_iicData [IICBUFSIZE]
static volatile int	_iicDataCount
static volatile int	_iicStatus
static volatile int	_iicMode
static int	_iicPt