Skip site navigation (1)Skip section navigation (2)
Date:      Thu, 9 Nov 2006 01:02:20 GMT
From:      Warner Losh <imp@FreeBSD.org>
To:        Perforce Change Reviews <perforce@freebsd.org>
Subject:   PERFORCE change 109586 for review
Message-ID:  <200611090102.kA912Kr2027279@repoman.freebsd.org>

next in thread | raw e-mail | index | archive | help
http://perforce.freebsd.org/chv.cgi?CH=109586

Change 109586 by imp@imp_lighthouse on 2006/11/09 01:01:32

	Style: no need for all that AT91F_ prefix junk.

Affected files ...

.. //depot/projects/arm/src/sys/boot/arm/at91/libat91/sd-card.c#14 edit

Differences ...

==== //depot/projects/arm/src/sys/boot/arm/at91/libat91/sd-card.c#14 (text+ko) ====

@@ -62,11 +62,11 @@
 #define MCI_UNSUPP_OFFSET_ERROR 6
 
 //*----------------------------------------------------------------------------
-//* \fn    AT91F_MCIDeviceWaitReady
+//* \fn    MCIDeviceWaitReady
 //* \brief Wait for MCI Device ready
 //*----------------------------------------------------------------------------
 static void
-AT91F_MCIDeviceWaitReady(unsigned int timeout)
+MCIDeviceWaitReady(unsigned int timeout)
 {
 	volatile int status;
 	
@@ -114,11 +114,11 @@
 }
 
 //*----------------------------------------------------------------------------
-//* \fn    AT91F_MCI_SendCommand
+//* \fn    MCI_SendCommand
 //* \brief Generic function to send a command to the MMC or SDCard
 //*----------------------------------------------------------------------------
 static int
-AT91F_MCI_SendCommand(
+MCI_SendCommand(
 	unsigned int Cmd,
 	unsigned int Arg)
 {
@@ -139,23 +139,23 @@
 }
 
 //*----------------------------------------------------------------------------
-//* \fn    AT91F_MCI_GetStatus
+//* \fn    MCI_GetStatus
 //* \brief Addressed card sends its status register
 //*----------------------------------------------------------------------------
 static unsigned int
-AT91F_MCI_GetStatus()
+MCI_GetStatus()
 {
-	if (AT91F_MCI_SendCommand(SEND_STATUS_CMD, MCI_Device.RCA << 16))
+	if (MCI_SendCommand(SEND_STATUS_CMD, MCI_Device.RCA << 16))
 		return AT91C_CMD_SEND_ERROR;
 	return (AT91C_BASE_MCI->MCI_RSPR[0]);
 }
 
 //*----------------------------------------------------------------------------
-//* \fn    AT91F_MCI_ReadBlock
+//* \fn    MCI_ReadBlock
 //* \brief Read an ENTIRE block or PARTIAL block
 //*----------------------------------------------------------------------------
 static int
-AT91F_MCI_ReadBlock(int src, unsigned int *dataBuffer, int sizeToRead)
+MCI_ReadBlock(int src, unsigned int *dataBuffer, int sizeToRead)
 {
 	unsigned log2sl = MCI_Device.READ_BL_LEN;
 	unsigned sectorLength = 1 << log2sl;
@@ -164,7 +164,7 @@
 	if (MCI_Device.state != AT91C_MCI_IDLE)
 		return 1;
     
-	if ((AT91F_MCI_GetStatus() & AT91C_SR_READY_FOR_DATA) == 0)
+	if ((MCI_GetStatus() & AT91C_SR_READY_FOR_DATA) == 0)
 		return 1;
 
 	///////////////////////////////////////////////////////////////////////
@@ -179,7 +179,7 @@
 	AT91C_BASE_PDC_MCI->PDC_RCR  = sizeToRead;
 
 	// Send the Read single block command
-	if (AT91F_MCI_SendCommand(READ_SINGLE_BLOCK_CMD, src))
+	if (MCI_SendCommand(READ_SINGLE_BLOCK_CMD, src))
 		return AT91C_READ_ERROR;
 	MCI_Device.state = AT91C_MCI_RX_SINGLE_BLOCK;
 
@@ -208,14 +208,14 @@
 		else
 			sizeToRead = length;
 
-		AT91F_MCIDeviceWaitReady(AT91C_MCI_TIMEOUT);
+		MCIDeviceWaitReady(AT91C_MCI_TIMEOUT);
 		//Do the reading
-		if (AT91F_MCI_ReadBlock(source,
+		if (MCI_ReadBlock(source,
 			(unsigned int*)dest, sizeToRead))
 			return -1;
 
 		//* Wait MCI Device Ready
-		AT91F_MCIDeviceWaitReady(AT91C_MCI_TIMEOUT);
+		MCIDeviceWaitReady(AT91C_MCI_TIMEOUT);
 
 		// Fix erratum in MCI part
 		for (walker = (unsigned int *)dest;
@@ -231,30 +231,12 @@
 	return 0;
 }
 
-
 //*----------------------------------------------------------------------------
-//* \fn    AT91F_CfgDevice
-//* \brief This function is used to initialise MMC or SDCard Features
-//*----------------------------------------------------------------------------
-static void AT91F_CfgDevice(void)
-{
-	// Init Device Structure
-
-	MCI_Device.RCA = 0;
-	MCI_Device.READ_BL_LEN		= 0;
-#ifdef REPORT_SIZE
-	MCI_Device.Memory_Capacity 	= 0;
-#endif
-	MCI_Device.state			= AT91C_MCI_IDLE;
-	MCI_Device.SDCard_bus_width	= AT91C_MCI_SCDBUS;
-}
-
-//*----------------------------------------------------------------------------
-//* \fn    AT91F_MCI_SDCard_SendAppCommand
+//* \fn    MCI_SDCard_SendAppCommand
 //* \brief Specific function to send a specific command to the SDCard
 //*----------------------------------------------------------------------------
 static int
-AT91F_MCI_SDCard_SendAppCommand(
+MCI_SDCard_SendAppCommand(
 	unsigned int Cmd_App,
 	unsigned int Arg)
 {
@@ -266,18 +248,18 @@
 	// if an error occurs
 	if (AT91C_BASE_MCI->MCI_SR & AT91C_MCI_SR_ERROR)
 		return (1);
-	return (AT91F_MCI_SendCommand(Cmd_App,Arg));
+	return (MCI_SendCommand(Cmd_App,Arg));
 }
 
 //*----------------------------------------------------------------------------
-//* \fn    AT91F_MCI_GetCSD
+//* \fn    MCI_GetCSD
 //* \brief Asks to the specified card to send its CSD
 //*----------------------------------------------------------------------------
 static int
-AT91F_MCI_GetCSD(unsigned int rca, unsigned int *response)
+MCI_GetCSD(unsigned int rca, unsigned int *response)
 {
  	
- 	if (AT91F_MCI_SendCommand(SEND_CSD_CMD, (rca << 16)))
+ 	if (MCI_SendCommand(SEND_CSD_CMD, (rca << 16)))
 		return 1;
 	
 	response[0] = AT91C_BASE_MCI->MCI_RSPR[0];
@@ -289,11 +271,11 @@
 }
 
 //*----------------------------------------------------------------------------
-//* \fn    AT91F_MCI_SDCard_GetOCR
+//* \fn    MCI_SDCard_GetOCR
 //* \brief Asks to all cards to send their operations conditions
 //*----------------------------------------------------------------------------
 static int
-AT91F_MCI_SDCard_GetOCR()
+MCI_SDCard_GetOCR()
 {
 	unsigned int	response=0x0;
 
@@ -301,7 +283,7 @@
 	MCI_Device.RCA = 0x0;
  	
  	while( (response & AT91C_CARD_POWER_UP_BUSY) != AT91C_CARD_POWER_UP_BUSY ) {
-		if (AT91F_MCI_SDCard_SendAppCommand(SDCARD_APP_OP_COND_CMD,
+		if (MCI_SDCard_SendAppCommand(SDCARD_APP_OP_COND_CMD,
 			AT91C_MMC_HOST_VOLTAGE_RANGE))
 			return 1;
 		response = AT91C_BASE_MCI->MCI_RSPR[0];
@@ -310,13 +292,13 @@
 }
 
 //*----------------------------------------------------------------------------
-//* \fn    AT91F_MCI_SDCard_GetCID
+//* \fn    MCI_SDCard_GetCID
 //* \brief Asks to the SDCard on the chosen slot to send its CID
 //*----------------------------------------------------------------------------
 static int
-AT91F_MCI_SDCard_GetCID(unsigned int *response)
+MCI_SDCard_GetCID(unsigned int *response)
 {
-	if (AT91F_MCI_SendCommand(ALL_SEND_CID_CMD, AT91C_NO_ARGUMENT))
+	if (MCI_SendCommand(ALL_SEND_CID_CMD, AT91C_NO_ARGUMENT))
 		return 1;
 	
 	response[0] = AT91C_BASE_MCI->MCI_RSPR[0];
@@ -328,22 +310,22 @@
 }
 
 //*----------------------------------------------------------------------------
-//* \fn    AT91F_MCI_SDCard_SetBusWidth
+//* \fn    MCI_SDCard_SetBusWidth
 //* \brief  Set bus width for SDCard
 //*----------------------------------------------------------------------------
 static int
-AT91F_MCI_SDCard_SetBusWidth()
+MCI_SDCard_SetBusWidth()
 {
 	volatile int	ret_value;
 	char			bus_width;
 
 	do {
-		ret_value=AT91F_MCI_GetStatus();
+		ret_value=MCI_GetStatus();
 	}
 	while((ret_value > 0) && ((ret_value & AT91C_SR_READY_FOR_DATA) == 0));
 
 	// Select Card
-	AT91F_MCI_SendCommand(SEL_DESEL_CARD_CMD, (MCI_Device.RCA)<<16);
+	MCI_SendCommand(SEL_DESEL_CARD_CMD, (MCI_Device.RCA)<<16);
 
 	// Set bus width for Sdcard
 	if (MCI_Device.SDCard_bus_width == AT91C_MCI_SCDBUS)
@@ -351,7 +333,7 @@
 	else
 		bus_width = AT91C_BUS_WIDTH_1BIT;
 
-	if (AT91F_MCI_SDCard_SendAppCommand(
+	if (MCI_SDCard_SendAppCommand(
 	      SDCARD_SET_BUS_WIDTH_CMD,bus_width) != AT91C_CMD_SEND_OK)
 		return 1;
 
@@ -376,29 +358,30 @@
 	AT91F_MCI_CfgPMC();
 	AT91F_PDC_Open(AT91C_BASE_PDC_MCI);
 
-	// Init MCI Device Structures
-	AT91F_CfgDevice();
+	// Init Device Structure
+	MCI_Device.state		= AT91C_MCI_IDLE;
+	MCI_Device.SDCard_bus_width	= AT91C_MCI_SCDBUS;
 
 	AT91F_MCI_Configure(AT91C_BASE_MCI,
 	    AT91C_MCI_DTOR_1MEGA_CYCLES,
 	    AT91C_MCI_PDCMODE,
 	    AT91C_MCI_SDCARD_4BITS_SLOTA);
-	AT91F_MCI_SendCommand(GO_IDLE_STATE_CMD, AT91C_NO_ARGUMENT);
+	MCI_SendCommand(GO_IDLE_STATE_CMD, AT91C_NO_ARGUMENT);
 
 	for (i = 0; i < 100; i++) {
-		if (!AT91F_MCI_SDCard_GetOCR(&MCI_Device))
+		if (!MCI_SDCard_GetOCR(&MCI_Device))
 			break;
 		printf(".");
 	}
 	if (i >= 100)
 		return 0;
-	if (AT91F_MCI_SDCard_GetCID(tab_response))
+	if (MCI_SDCard_GetCID(tab_response))
 		return 0;
-	if (AT91F_MCI_SendCommand(SET_RELATIVE_ADDR_CMD, 0))
+	if (MCI_SendCommand(SET_RELATIVE_ADDR_CMD, 0))
 		return 0;
 
 	MCI_Device.RCA = (AT91C_BASE_MCI->MCI_RSPR[0] >> 16);
-	if (AT91F_MCI_GetCSD(MCI_Device.RCA,tab_response))
+	if (MCI_GetCSD(MCI_Device.RCA,tab_response))
 		return 0;
 	MCI_Device.READ_BL_LEN = (tab_response[1] >> CSD_1_RD_B_LEN_S) &
 	    CSD_1_RD_B_LEN_M;
@@ -414,9 +397,9 @@
 	    CSD_2_CSIZE_L_M)) + 1);
 	MCI_Device.Memory_Capacity = (1 << MCI_Device.READ_BL_LEN) * blocknr;
 #endif
-	if (AT91F_MCI_SDCard_SetBusWidth())
+	if (MCI_SDCard_SetBusWidth())
 		return 0;
-	if (AT91F_MCI_SendCommand(SET_BLOCKLEN_CMD, 1 << MCI_Device.READ_BL_LEN))
+	if (MCI_SendCommand(SET_BLOCKLEN_CMD, 1 << MCI_Device.READ_BL_LEN))
 		return 0;
 #ifdef REPORT_SIZE
 	printf("Found SD card %u bytes\n", MCI_Device.Memory_Capacity);



Want to link to this message? Use this URL: <https://mail-archive.FreeBSD.org/cgi/mid.cgi?200611090102.kA912Kr2027279>