mci.c

关于测试at91sam9260的各种驱动和功能的测试源代码。

//*----------------------------------------------------------------------------
AT91S_MCIDeviceStatus AT91F_MCI_GetCSD (AT91PS_MciDevice pMCI_Device, unsigned int relative_card_address , unsigned int * response)
{
 	
    if(AT91F_MCI_SendCommand(pMCI_Device,
                            AT91C_SEND_CSD_CMD,
                            (relative_card_address << 16)) != AT91C_CMD_SEND_OK)
        return AT91C_CMD_SEND_ERROR;
	
    response[0] = AT91C_BASE_MCI->MCI_RSPR[0];
    response[1] = AT91C_BASE_MCI->MCI_RSPR[1];
    response[2] = AT91C_BASE_MCI->MCI_RSPR[2];
    response[3] = AT91C_BASE_MCI->MCI_RSPR[3];
    
    return AT91C_CMD_SEND_OK;
}

//*----------------------------------------------------------------------------
//* \fn    AT91F_MCI_SetBlocklength
//* \brief Select a block length for all following block commands (R/W)
//*----------------------------------------------------------------------------
AT91S_MCIDeviceStatus AT91F_MCI_SetBlocklength(AT91PS_MciDevice pMCI_Device,unsigned int length)
{
    return( AT91F_MCI_SendCommand(pMCI_Device, AT91C_SET_BLOCKLEN_CMD, length) );
}

//*----------------------------------------------------------------------------
//* \fn    AT91F_MCI_SDCard_GetOCR
//* \brief Asks to all cards to send their operations conditions
//*----------------------------------------------------------------------------
AT91S_MCIDeviceStatus AT91F_MCI_SDCard_GetOCR (AT91PS_MciDevice pMCI_Device)
{
    unsigned int	response =0x0;
    
    // The RCA to be used for CMD55 in Idle state shall be the card's default RCA=0x0000.
    pMCI_Device->pMCI_DeviceFeatures->Relative_Card_Address = 0x0;
    
    while( (response & (unsigned int)AT91C_CARD_POWER_UP_BUSY) != (unsigned int)AT91C_CARD_POWER_UP_BUSY )
    {
        response = AT91F_MCI_SDCard_SendAppCommand(pMCI_Device,
                                                  AT91C_SDCARD_APP_OP_COND_CMD,
                                                  AT91C_MMC_HOST_VOLTAGE_RANGE);
        if (response != AT91C_CMD_SEND_OK)
            return AT91C_INIT_ERROR;
    
        response = AT91C_BASE_MCI->MCI_RSPR[0];
     }
    
    return(AT91C_BASE_MCI->MCI_RSPR[0]);
}

//*----------------------------------------------------------------------------
//* \fn    AT91F_MCI_SDCard_GetCID
//* \brief Asks to the SDCard on the chosen slot to send its CID
//*----------------------------------------------------------------------------
AT91S_MCIDeviceStatus AT91F_MCI_SDCard_GetCID (AT91PS_MciDevice pMCI_Device, unsigned int *response)
{
    if(AT91F_MCI_SendCommand(pMCI_Device,
                            AT91C_ALL_SEND_CID_CMD,
                            AT91C_NO_ARGUMENT) != AT91C_CMD_SEND_OK)
        return AT91C_CMD_SEND_ERROR;
    
    response[0] = AT91C_BASE_MCI->MCI_RSPR[0];
    response[1] = AT91C_BASE_MCI->MCI_RSPR[1];
    response[2] = AT91C_BASE_MCI->MCI_RSPR[2];
    response[3] = AT91C_BASE_MCI->MCI_RSPR[3];
    
    return AT91C_CMD_SEND_OK;
}

//*----------------------------------------------------------------------------
//* \fn    AT91F_MCI_SDCard_SetBusWidth
//* \brief  Set bus width for SDCard
//*----------------------------------------------------------------------------
AT91S_MCIDeviceStatus AT91F_MCI_SDCard_SetBusWidth(AT91PS_MciDevice pMCI_Device)
{
    volatile int	ret_value;
    char			bus_width;
    
    do   {
        ret_value =AT91F_MCI_GetCardStatus(pMCI_Device,pMCI_Device->pMCI_DeviceFeatures->Relative_Card_Address);
    }
    while((ret_value > 0) && ((ret_value & AT91C_SR_READY_FOR_DATA) == 0));
    
    // Select Card
    AT91F_MCI_SendCommand(pMCI_Device,
                          AT91C_SEL_DESEL_CARD_CMD,
                          (pMCI_Device->pMCI_DeviceFeatures->Relative_Card_Address)<<16);
    
    // Set bus width for Sdcard
    if(pMCI_Device->pMCI_DeviceDesc->SDCard_bus_width == AT91C_MCI_SCDBUS)
                    bus_width = AT91C_BUS_WIDTH_4BITS;
    else	bus_width = AT91C_BUS_WIDTH_1BIT;
    
    if (AT91F_MCI_SDCard_SendAppCommand(pMCI_Device,AT91C_SDCARD_SET_BUS_WIDTH_CMD,bus_width) != AT91C_CMD_SEND_OK)
            return AT91C_CMD_SEND_ERROR;
    
    return AT91C_CMD_SEND_OK;
}

//*----------------------------------------------------------------------------
//* \fn    AT91F_MCI_SDCard_Init
//* \brief Return the SDCard initialisation status
//*----------------------------------------------------------------------------
AT91S_MCIDeviceStatus AT91F_MCI_SDCard_Init (AT91PS_MciDevice pMCI_Device)
{
    unsigned int	tab_response[4];
    unsigned int	mult,blocknr;
    
    // Power On Init Special Command
    AT91F_MCI_SendCommand(pMCI_Device, AT91C_POWER_ON_INIT, AT91C_NO_ARGUMENT);

    AT91F_MCI_SendCommand(pMCI_Device, AT91C_GO_IDLE_STATE_CMD, AT91C_NO_ARGUMENT);

    if(AT91F_MCI_SDCard_GetOCR(pMCI_Device) == AT91C_INIT_ERROR)
    	return AT91C_INIT_ERROR;

	if (AT91F_MCI_SDCard_GetCID(pMCI_Device,tab_response) == AT91C_CMD_SEND_OK)
	{
	    pMCI_Device->pMCI_DeviceFeatures->Card_Inserted = AT91C_SD_CARD_INSERTED;

	    if (AT91F_MCI_SendCommand(pMCI_Device, AT91C_SET_RELATIVE_ADDR_CMD, 0) == AT91C_CMD_SEND_OK)
		{
			pMCI_Device->pMCI_DeviceFeatures->Relative_Card_Address = (AT91C_BASE_MCI->MCI_RSPR[0] >> 16);
			if (AT91F_MCI_GetCSD(pMCI_Device,pMCI_Device->pMCI_DeviceFeatures->Relative_Card_Address,tab_response) == AT91C_CMD_SEND_OK)
			{
		  		pMCI_Device->pMCI_DeviceFeatures->Max_Read_DataBlock_Length = 1 << ((tab_response[1] >> AT91C_CSD_RD_B_LEN_S) & AT91C_CSD_RD_B_LEN_M );
	 			pMCI_Device->pMCI_DeviceFeatures->Max_Write_DataBlock_Length =	1 << ((tab_response[3] >> AT91C_CSD_WBLEN_S) & AT91C_CSD_WBLEN_M );
				pMCI_Device->pMCI_DeviceFeatures->Sector_Size = 1 + ((tab_response[2] >> AT91C_CSD_v21_SECT_SIZE_S) & AT91C_CSD_v21_SECT_SIZE_M );
		  		pMCI_Device->pMCI_DeviceFeatures->Read_Partial = (tab_response[1] >> AT91C_CSD_RD_B_PAR_S) & AT91C_CSD_RD_B_PAR_M;
				pMCI_Device->pMCI_DeviceFeatures->Write_Partial = (tab_response[3] >> AT91C_CSD_WBLOCK_P_S) & AT91C_CSD_WBLOCK_P_M;
				pMCI_Device->pMCI_DeviceFeatures->Erase_Block_Enable = (tab_response[3] >> AT91C_CSD_v21_ER_BLEN_EN_S) & AT91C_CSD_v21_ER_BLEN_EN_M;
				pMCI_Device->pMCI_DeviceFeatures->Read_Block_Misalignment = (tab_response[1] >> AT91C_CSD_RD_B_MIS_S) & AT91C_CSD_RD_B_MIS_M;
				pMCI_Device->pMCI_DeviceFeatures->Write_Block_Misalignment = (tab_response[1] >> AT91C_CSD_WR_B_MIS_S) & AT91C_CSD_WR_B_MIS_M;

				//// Compute Memory Capacity
                	// compute MULT
                    mult = 1 << ( ((tab_response[2] >> AT91C_CSD_C_SIZE_M_S) & AT91C_CSD_C_SIZE_M_M) + 2 );
                    // compute MSB of C_SIZE
                    blocknr = ((tab_response[1] >> AT91C_CSD_CSIZE_H_S) & AT91C_CSD_CSIZE_H_M) << 2;
                    // compute MULT * (LSB of C-SIZE + MSB already computed + 1) = BLOCKNR
                    blocknr = mult * ( ( blocknr + ( (tab_response[2] >> AT91C_CSD_CSIZE_L_S) & AT91C_CSD_CSIZE_L_M) ) + 1 );

                    pMCI_Device->pMCI_DeviceFeatures->Memory_Capacity =  pMCI_Device->pMCI_DeviceFeatures->Max_Read_DataBlock_Length * blocknr;
			  	//// End of Compute Memory Capacity

		  		if( AT91F_MCI_SDCard_SetBusWidth(pMCI_Device) == AT91C_CMD_SEND_OK )
				{	
                	if (AT91F_MCI_SetBlocklength(pMCI_Device,pMCI_Device->pMCI_DeviceFeatures->Max_Read_DataBlock_Length) == AT91C_CMD_SEND_OK)
                    	return AT91C_INIT_OK;
				}
			}
		}
	}
    return AT91C_INIT_ERROR;
}

//*----------------------------------------------------------------------------
//* \fn    AT91F_MCIDeviceWaitReady
//* \brief Wait for MCI Device ready
//*----------------------------------------------------------------------------
void AT91F_MCIDeviceWaitReady(unsigned int timeout)
{
	volatile int status;
	
	do  {
            status = AT91C_BASE_MCI->MCI_SR;
            timeout--;
	}
	while( !(status & AT91C_MCI_NOTBUSY)  && (timeout>0) );	
}

//*----------------------------------------------------------------------------
//* \fn    AT91F_TestMCI
//* \brief Test Functions
//*----------------------------------------------------------------------------
unsigned int AT91F_TestMCI(void)
{
	int 			i;
	unsigned int 	Max_Read_DataBlock_Length;
	char			TestBuffer[BUFFER_SIZE_MCI_DEVICE];
		
	Max_Read_DataBlock_Length = MCI_Device.pMCI_DeviceFeatures->Max_Read_DataBlock_Length;
	
	// Wait end of Read
	AT91F_MCIDeviceWaitReady(AT91C_MCI_TIMEOUT);

	// Write Page
	for(i=0;i<BUFFER_SIZE_MCI_DEVICE;i++)
        TestBuffer[i] = 0x00;	    
        sprintf(TestBuffer,"\n\rThis sentence is written in your device... Congratulations\n\r");

	AT91F_MCI_WriteBlock(&MCI_Device,(2*Max_Read_DataBlock_Length),(unsigned int*) TestBuffer,Max_Read_DataBlock_Length);

	// Wait end of Write
	AT91F_MCIDeviceWaitReady(AT91C_MCI_TIMEOUT);

	// Read Block
	for(i=0;i<BUFFER_SIZE_MCI_DEVICE;i++)
            Buffer[i] = 0x00;	
	AT91F_MCI_ReadBlock(&MCI_Device,(2*Max_Read_DataBlock_Length),(unsigned int*) Buffer,Max_Read_DataBlock_Length);

	// Wait end of Read
	AT91F_MCIDeviceWaitReady(AT91C_MCI_TIMEOUT);

	for(i=0;i<BUFFER_SIZE_MCI_DEVICE;i++)
	 	TestBuffer[i] = 0x00;	
        sprintf(TestBuffer,"\n\rThis sentence is written in your device... Congratulations\n\r");

	for(i=0;i<BUFFER_SIZE_MCI_DEVICE;i++)	{
		if (Buffer[i] != TestBuffer[i])
			return FALSE;
	}
	
	return TRUE;
}