sdmmc_load.c

针对Intel Xscale PXA255的WinCE boot loader源代码包！极具参考价值！

		return(FALSE);
	}
	else
	{
		//RETAILMSG(0, (TEXT("v_pGPIOReg=0x%x, v_pDriverGlobals=0x%x\r\n"), v_pGPIOReg, v_pDriverGlobals));
		return(TRUE);
	}
}

/************************************************************************************************************
* Function: SML_PowerHandler
* 
* Purpose:  Power Handler for the loader. Currently we dont need to do anything here, so these are just stubs.
*  
* Returns:  void
*
************************************************************************************************************/


void WINAPI SML_PowerHandler(
	BOOL	bOff    // @parm TRUE, the system is powering off; FALSE, the system is powering up.
	)
{
    if (bOff) 
	{
		SML_PowerDown();
	}
    else 
	{
		SML_PowerUp();
	}

}

/************************************************************************************************************
* Function: SDMMCDetectThread
* 
* Purpose:  This function is the main thread that looks for the card insertion interrupt from the FPGA. It runs 
*			indefinately and is responsible for loading the driver when it sees the interrupt and unloads the 
*			driver when it sees the card removal. Currently we are polling for the levels because of the inherent 
*			problem in the FPGA not able to deliver a card removal interrupt. This code will change when this 
*			issue is resolved.  
*  
* Returns:  void
*
************************************************************************************************************/

static DWORD WINAPI
SDMMCDetectThread(LPVOID pArgument)
{
//	HANDLE hDevice = NULL;
	int i = 0;
	int iStatusIn[5] = {0,0,0,0,0};
	int iStatusOut[5] = {0,0,0,0,0};
	int iSumIn = 0;
	int iSumOut = 0;

	SDMMC_InitializeAddresses();


	InitializeHardware();
	RETAILMSG(0, (TEXT("InitializeHardware done.\r\n")));	

	
	gSDMMCIntrEvent = CreateEvent(NULL, FALSE, FALSE, TEXT("SDMMC"));

	if (!(InterruptInitialize(SYSINTR_SDMMC, gSDMMCIntrEvent, NULL, 0))) 
	{
		RETAILMSG(0, (TEXT("SDMMC IntrInit Failed\r\n")));
 		return FALSE;		
	}

	Sleep (1000);		// Same as CF driver, wait for 1 sencond to avoid data abort.
	
	
	while(1)
	 {
	 	
		
		Sleep(20);
		
		
		
		if(((v_pGPIOReg->GPLR_x & GPIO_25)) && (SDMMC_DETECT==1))	// hzh
	
		{
			RETAILMSG(0, (TEXT("card is removed\r\n")));
			SDMMC_DETECT = 0;
			
			
			DeactivateDevice( hDevice);
			DoDeleteHandleValue(szRegKey);
			InterruptDone(SYSINTR_SD_INSERT);
			
			v_pGPIOReg->GAFR0_x &= ~(GPIO_8_AF1_MMCCS0 | GPIO_8_AF3);
			v_pGPIOReg->GPDR_x &= ~GPIO_8;
			//RETAILMSG (1, (TEXT("---------------+Finish process remove Card()--------------\r\n")));

		} 		
		
		if( (SDMMC_DETECT==0) && ((v_pGPIOReg->GPLR_x & GPIO_25) == 0))	// hzh
		{		

			SDMMC_DETECT = 1;
			RETAILMSG(0, (TEXT("card is detected\r\n")));
			
			v_pGPIOReg->GAFR0_x |= GPIO_8_AF1_MMCCS0;	// set alternate function for gpio  MMCCLK
			
		
			DoRegSetup(szRegKey);
			hDevice = ActivateDevice( szRegKey, 0);
			DoSetHandleValue( szRegKey, hDevice);
			
			v_pDriverGlobals->misc.SDMMCHandle=hDevice;
			//RETAILMSG(0,(TEXT("SDMMC handle=0x%x\r\n"), hDevice));

			InterruptDone(SYSINTR_SD_INSERT);
			//RETAILMSG (1, (TEXT("---------------+Finish processing insert Card--------------\r\n")));

		}
		else
		{
			
			RETAILMSG(0, (TEXT("===================Done!=================\r\n")));
			InterruptDone(SYSINTR_SD_INSERT);
			//<-- End
		}	
		

		//RETAILMSG(0, (TEXT("Wait next SD card interrupt event...\r\n")));
		WaitForSingleObject(hSDEvent, INFINITE); //normally: 
		// End.
		 
	 } 
}

/************************************************************************************************************
* Function: SML_Init
* 
* Purpose:  performs some initialisation. spawns the main loader thread. 
*  
* Returns:  void
*
************************************************************************************************************/

BOOL WINAPI SML_Init()
{
	//RETAILMSG(0, (TEXT("Entering Init.\r\n")));



	hSDEvent = CreateEvent(
					NULL,   // No Security
					FALSE,  // Not manual reset
					FALSE,  // Not initially signalled
					NULL    // No name
					);
					
	if(! hSDEvent)
	{
		//RETAILMSG( 1, (TEXT("SML_Init: CreateEvent hSDEvent failed, error = %x\r\n"), GetLastError()));
		return FALSE;
	}
//	//RETAILMSG( 1, (TEXT("SML_Init:	SYSINTR_SD_INSERT=%d, hSDEvent=%d\r\n"),SYSINTR_SD_INSERT,hSDEvent));

	InterruptDone(SYSINTR_SD_INSERT);
//	//RETAILMSG( 1, (TEXT("MMC_Init:	InterruptDone\r\n")));
	InterruptDisable(SYSINTR_SD_INSERT);
//	//RETAILMSG( 1, (TEXT("MMC_Init:	InterruptDisable\r\n")));

	if (!InterruptInitialize(SYSINTR_SD_INSERT, hSDEvent, NULL, 0))
	{
		//RETAILMSG( 1, (TEXT("SML_Init: InterruptInitialize SYSINTR_SD_INSERT failed!!!\r\n")));
		return FALSE;
	}
	//RETAILMSG(0, (TEXT("SDLoader InterruptInitialize done.\r\n")));	

// End.

    SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_NORMAL);
	
	gSDMMCDetectThread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) SDMMCDetectThread, NULL, 0, NULL);
		
	if ( gSDMMCDetectThread == NULL ) 
	{
        RETAILMSG(0, (TEXT("Fatal Error!  Failed to create MMC card detect thread.\r\n")));
        return (FALSE);
	}
		
	RETAILMSG(0, (TEXT("create MMC card detect thread(0x%x) successfull.\r\n"), gSDMMCDetectThread));
 	return TRUE;
	
}


BOOL WINAPI SML_DllEntry( HANDLE  hInstDll,
						  DWORD   dwReason,
						  LPVOID  lpvReserved
						)
{
    switch ( dwReason ) 
	{
		case DLL_PROCESS_ATTACH:
								DEBUGREGISTER((HINSTANCE) hInstDll);
								//RETAILMSG(0, (TEXT("SDMMCLoader : DLL_PROCESS_ATTACH\r\n")));
								break;

		case DLL_PROCESS_DETACH:
								// should be signaling thread here
								//RETAILMSG(0, (TEXT("SDMMCLoader : DLL_PROCESS_DETACH\r\n")));
								break;
    }

    return (TRUE);
}

// The following functions are all stubbed out. They are not required but are provided for the sake 
// of code completion.

DWORD SML_Open (DWORD dwData, DWORD dwAccess, DWORD dwShareMode) 
{
	return (4);
}

BOOL  SML_Close(DWORD dwData) 
{
	SDMMC_FreeAddresses();	
	return (TRUE);
}

DWORD SML_Read (DWORD dwData,  LPVOID pBuf, DWORD Len) 
{
	return (0);
}

DWORD SML_Write(DWORD dwData, LPCVOID pBuf, DWORD Len) 
{
	return (0);
}

DWORD SML_Seek (DWORD dwData, long pos, DWORD type) 
{
	return (DWORD)-1;
}


VOID  SML_PowerUp  (VOID) 
{
	
	SetInterruptEvent(SYSINTR_SD_INSERT);
	//RETAILMSG (1, (TEXT("SMLoader Power up end...\r\n")));
}

BOOL  SML_PowerDown(VOID) 
{
	
	RETAILMSG (1, (TEXT("SMLoader Power down end...\r\n")));
	return (TRUE);
}

BOOL  SML_Deinit(DWORD dwData) 
{
	return (TRUE);
}

BOOL  SML_IOControl(DWORD p1, DWORD p2, PBYTE p3, DWORD p4, PBYTE p5, 
                    DWORD p6, PDWORD p7) 
{
	return (TRUE);
}

void InitializeHardware()
{
	//RETAILMSG (1, (TEXT("---------------+InitializeHardware()--------------\r\n")));
	v_pGPIOReg->GAFR1_x &= ~GPIO_25_AF3;  	// GPIO25 set as GPIO pin, hzh
	v_pGPIOReg->GAFR1_z &= ~GPIO_80_AF3;  	// GPIO80 set as GPIO pin, hzh
	v_pGPIOReg->GPDR_x &= ~GPIO_25;  	// GPIO25 set as input for #CD, hzh
	v_pGPIOReg->GPDR_z &= ~GPIO_80;  	// GPIO80 set as input for WP, hzh
	
		
	v_pGPIOReg->GEDR_x |= GPIO_25;  // hzh
	//RETAILMSG (1, (TEXT("----------------v_pGPIOReg->GPDR_x:0x%x--------------\r\n"),v_pGPIOReg->GPDR_x));
	//RETAILMSG (1, (TEXT("----------------InitializeHardware()--------------\r\n")));
	return;
}

void FromSuspend()
{
	SetEvent(hSDEvent);
}