hal_spear_i2c.c

Spearhead2000的bootloader

	}

	Status = I2C_SendByte (MSB );
	if( Status)
	{
		return -1;
	}


	// Write the user buffer on the bus


	Status =  I2C_SendBuffer (PtrToBuffer,NbOfBytes) ;
	if(Status)
	{
		return -1;
	}

	return 0;


}





//=======================================================================================
/*					I2C_MultiWriteRegister8													   */
//=======================================================================================
// Description -   	Write multiple bytes to the I2C slave device's registers starting from the given base register
//
// Arguments  -		Input Parameter 1 -
//					SlaveAddress - The I2C chip address.

//Input Parameter 2 -
//					Index -  Index of slave device register

//Input Parameter 3
//					PtrToBuffer - Pointer to the block of data bytes to be written to the
                    // Registers

//Input Parameter 4
//					NbOfBytes - the number of data bytes to be transferred

//
//
// Return value -	0 for success , non zero for failure
//
//======================================================================================


I2C_TxErrCode_t I2C_MultiWriteRegister8( unsigned char SlaveAddress, short int Index, char * PtrToBuffer,int  NbOfBytes)
{

	int Status,i;

	I2C_Init (I2C_ENABLE_ACK) ;                 /* Initialise I2C */

	Status = I2C_Generate_Start() ;
	for(i=0;i<200;i++);

	/* Transmits slave address */
	Status = I2C_Load_Address (0xA0,I2C_TX_MODE);
	for(i=0;i<200;i++);

	 /* Transmit the Byte Address */
	Status = I2C_SendByte (Index);
	for(i=0;i<200;i++);


	// Write the user buffer on the bus

	Status =  I2C_SendBuffer (PtrToBuffer,NbOfBytes) ;
	if(Status)
	{
		return -1;
	}
	//Insert some delay
	for(i=0;i<9000;i++);

	I2C_Generate_Stop ();
	for(i=0;i<9000;i++);

	return 0;


}




//=======================================================================================
/*					I2C_MultiReadRegister16													   */
//=======================================================================================
// Description -   	Read multiple data bytes from a given register of a I2C slave device after sending two data bytes.
//
// Arguments  -		Input Parameter 1 -
//					SlaveAddress - The I2C chip address.
//					Input Parameter 2 -
//					Index -  Index of slave device register
//Input Parameter 3
//					PtrToBuffer - Pointer to the block of data bytes to be written to the
//                     Registers
//Input Parameter 4
//NbOfBytes - the number of data bytes to be transferred
//
//
// Return value -	0 for success , non zero for failure
//
//======================================================================================


I2C_RxErrCode_t I2C_MultiReadRegister16( unsigned char SlaveAddress, short int Index, char * PtrToBuffer,int  NbOfBytes )
{

	int Status;
	unsigned char LSB,MSB;
	Status = I2C_Generate_Start();
	if(Status)
	{
		return -1;
	}

	Status = I2C_Load_Address (SlaveAddress,I2C_TX_MODE );
	if(Status)
	{
		return -1;
	}

	//Transmit the register index
	//Transmit the LSB first

	LSB = (unsigned char ) (Index & 0xFF );
	MSB = (unsigned char )(Index >> 8 );


	Status = I2C_SendByte (LSB );
	if( Status)
	{
		return -1;
	}

	Status = I2C_SendByte (MSB );
	if( Status)
	{
		return -1;
	}


	// Read data bytes from I2C bus and store it in user buffer

	Status =  I2C_RecieveBuffer (PtrToBuffer,NbOfBytes) ;
	if(Status)
	{
		return -1;
	}

	return 0;


}



//=======================================================================================
/*					I2C_MultiReadRegister8													   */
//=======================================================================================
// Description -   	Read multiple data bytes from a given register of a I2C slave device after sending device register index
//
// Arguments  -		Input Parameter 1 -
//					SlaveAddress - The I2C chip address.
//					Input Parameter 2 -
//					Index -  Index of slave device register
//Input Parameter 3
//					PtrToBuffer - Pointer to the block of data bytes to be written to the
//                     Registers
//Input Parameter 4
//NbOfBytes - the number of data bytes to be transferred
//
//
// Return value -	0 for success , non zero for failure
//
//======================================================================================


I2C_RxErrCode_t I2C_MultiReadRegister8( unsigned char SlaveAddress, unsigned char Index, char * PtrToBuffer,int  NbOfBytes )
{

	int Status;
	int i;

	I2C_Init (I2C_ENABLE_ACK) ;                 /* Initialise I2C */


	Status = I2C_Generate_Start();


	if(Status)
	{
		#ifdef SPEAR_DRIVER_DEBUG
		printk("Start condition not generated\n");
		#endif
		return -1;

	}

	Status = I2C_Load_Address (SlaveAddress,I2C_TX_MODE );


	if(Status)
	{
		return -1;
	}

	//Transmit the register index

	Status = I2C_SendByte (Index );

	if( Status)
	{
		return -1;
	}


	//This portion is EEPROM specific

	Status = I2C_Generate_Start() ;
	for(i=0;i<200;i++);

	Status = I2C_Load_Address (0xA1,I2C_RX_MODE);
	for(i=0;i<200;i++);


	// Read data bytes from I2C bus and store it in user buffer

	Status =  I2C_RecieveBuffer (PtrToBuffer,NbOfBytes) ;
	if(Status)
	{
		return -1;
	}
	for(i=0;i<9000;i++);
	Status = I2C_Generate_Stop ();
	for(i=0;i<9000;i++);

	return 0;


}



//=======================================================================================
/*				I2C_IsTransmitCompleted													   */
//=======================================================================================
// Description -	This function is called for checking the status of Data transmission
//			on I2C bus, This function continously polls the I2C status registers.
//
// Arguments -	        void
//
// Return value -	I2C_TxErrCode_t - The current status of Data transmission
//
/*======================================================================================
*/

I2C_TxErrCode_t I2C_IsTransmitCompleted (void)
{
    volatile unsigned char Temp, Temp1 ;

    Temp1 = I2CSR1 ;
    Temp  = I2CSR2;

	if (Temp1 & SB)
    {
		Temp1 = I2CSR1;
        return (I2C_START_OK);    /* Checking for start condition generation */
    }

    else if (Temp & AF)
    {                                    /* Checking for acknowledge failure */
        return (I2C_TX_AF);               /* Acknowledge failure has occured */
    }
    //ASHWINI - Modifying the following code while debugging


    else if ((Temp1 & EVF)  && (!(Temp1 & BTF)))
    {                     /* Checking for completion of address transmission */

		//EV6: Cleared by reading SR1 register followed by writing CR register

		Temp1 = I2CSR1 ;
		I2CCR |= PE;

		return (I2C_ADD_TX_OK);



    }

	/*Check for the EV8 condition*/
	//EV8 : EVF = 1 and BTF =1
    else if (((Temp1 & EVF)  && (Temp1 & BTF)))
    {                             /* Checking for completion of data transmission */

    	//EV8: Cleared by readinr SR1 register

    	Temp1 = I2CSR1 ;
    	while (!( Temp1 & BTF))
		{
		        Temp1 = I2CSR1 ;             // Waiting till address byte transmitted
		}

        return (I2C_DATA_TX_OK) ;              /* Transmission is successful */
    }
	else
    {
        return (I2C_TX_BUFFER_ONGOING);                      /* Dummy return */
    }
}



//=======================================================================================
/*				I2C_IsReceptionCompleted												   */
//=======================================================================================
// Description -	This function is called for checking the status of Data reception
//			on I2C bus, This function continously polls the I2C status registers.
//
// Arguments -	        void
//
// Return value -	I2C_RxErrCode_t - The current status of Data reception
//
/*======================================================================================
*/

I2C_RxErrCode_t I2C_IsReceptionCompleted (void)
{
    unsigned char Temp, Temp1 ;

    Temp1 = I2CSR1;
    Temp = I2CSR2  ;

    if ((!((Temp1 & BTF)&& (!(Temp1 & TRA)))))
    {
        return (I2C_RX_DATA_EMPTY);                     /* No bytes received */
    }

    else if (Temp & AF)
    {                                    /* Checking for acknowledge failure */
        return (I2C_RX_AF);               /* Acknowledge failure has occured */
    }

    else if (((!(Temp1 & TRA))&& (Temp1 & BTF)))
    {
        return (I2C_DATA_RX_OK) ;                 /* Reception is successful */
    }

    else
    {
        return (I2C_RX_BUFFER_ONGOING);           /* Reception not completed */
    }

}



I2C_TxErrCode_t I2C_MultiWritePages( unsigned char SlaveAddress, short int Index, char * PtrToBuffer,int  NbOfBytes)
{

	int numberofbytes = NbOfBytes;
        unsigned char regindex = Index;
	unsigned char regindex_pages;
        int numberofpages,i,j;
        int numberofbytes_lastpage,numberofbytes_startpage;
	int temp1,temp2,temp3;
	int ret;
	int dataindex=0;
	int delay;

        temp1 = regindex/16;
        temp2 = (temp1 +1) *16;
        temp3= numberofbytes/16;
        //number of bytes to write in starting page

        	if(numberofbytes >= 0 && numberofbytes <=9 )
			{
					numberofbytes_startpage = numberofbytes;
			}
			else
			{
				numberofbytes_startpage = temp2-regindex;
			}
                numberofpages = ( numberofbytes - numberofbytes_startpage)/16;
        		numberofbytes_lastpage = numberofbytes - numberofbytes_startpage - numberofpages*16 ;

	//Write the data in the starting page


	//printk("WRITING DATA in START PAGE \n");
	//printk("SlaveAddress = %x , regindex =%x ,dataindex = %d,numberofbytes_startpage = %d",SlaveAddress,regindex,dataindex,numberofbytes_startpage);

	for(delay=0;delay<50000;delay++);

	for(delay=0;delay<50000;delay++);


	ret = I2C_MultiWriteRegister8(SlaveAddress,regindex,(PtrToBuffer+dataindex),numberofbytes_startpage);

	if(ret != 0)
	{
		#ifdef SPEAR_DRIVER_DEBUG
		printk("Error in writing data I2C \n");
		#endif
		return -1;
	}

	regindex_pages = regindex + numberofbytes_startpage;
	dataindex+=numberofbytes_startpage;


	 //printk("WRITING DATA in PAGES \n");
     //printk("SlaveAddress = %x , regindex_pages =%x ,dataindex = %d,,numberofbytes_startpage = %d",SlaveAddress,regindex_pages,dataindex,numberofbytes_startpage);

	for(delay=0;delay<50000;delay++);
	for(delay=0;delay<50000;delay++);

	//Insert some delay
	for(j=0;j<10000;j++);

	//Write data in the pages
	for(i=0;i<numberofpages;i++)
	{

//		 printk(" regindex_pages =%x ,dataindex = %d,page Number  = %d",regindex_pages,dataindex,i);
	for(delay=0;delay<50000;delay++);
	for(delay=0;delay<50000;delay++);

        	 ret = I2C_MultiWriteRegister8(SlaveAddress,regindex_pages,(PtrToBuffer+dataindex),16);

		 if(ret != 0)
	        {
				#ifdef SPEAR_DRIVER_DEBUG
        	        printk("Error in writing data I2C \n");
        	        #endif
                	return -1;
        	}
                regindex_pages+=16;
		dataindex+=16;

		 //Insert some delay
	        for(j=0;j<5000;j++);




	}


//        printk("WRITING DATA in LAST PAGE \n");
//       printk("SlaveAddress = %x , regindex_pages =%x ,dataindex = %d,,numberofbytes_startpage = %d",SlaveAddress,regindex_pages,dataindex,numberofbytes_startpage);

	for(delay=0;delay<50000;delay++);
	for(delay=0;delay<50000;delay++);


	//write data in the last page if required

	if(numberofbytes_lastpage > 0)
	{
		 ret = I2C_MultiWriteRegister8(SlaveAddress,regindex_pages,(PtrToBuffer+dataindex),numberofbytes_lastpage);
		 if(ret != 0)
        	 {
				 #ifdef SPEAR_DRIVER_DEBUG
                	printk("Error in writing data I2C \n");
                	#endif
	                return -1;
         	}
	}
	return 0;

}






//=======================================================================================
/*				User_Timeout_Function												   */
//=======================================================================================
// Description -	This function is called for avoiding infinite delay while Data
//			transmission or reception
//
// Arguments -	        void
//
// Return value -	int
//
/*======================================================================================
*/

int User_Timeout_Function(void)
{
    while(Timeoutcount < 100000)
    {
        Timeoutcount++ ;
        return (1);                               /* Time-out not elapsed */
    }
    return (0)  ;                                    /* Time-out elapsed */
}