main.cpp

Microsoft WinCE 6.0 BSP FINAL release source code for use with the i.MX27ADS TO2 WCE600_FINAL_MX27_S

                   DWORD   dwCode,
                   PBYTE   pBufIn,
                   DWORD   dwLenIn,
                   PBYTE   pBufOut,
                   DWORD   dwLenOut,
                   PDWORD  pdwActualOut)
{
    DEBUGMSG(ZONE_FUNCTION, (TEXT("SDH: +-SDH_IOControl \n")));
    DWORD  dwErr = ERROR_INVALID_PARAMETER;
    BOOL   bRc = FALSE;

    PSDCARD_HC_CONTEXT pHostContext = (PSDCARD_HC_CONTEXT)hOpenContext;
    PSDH_HARDWARE_CONTEXT pHCDevice = GetExtensionFromHCDContext(PSDH_HARDWARE_CONTEXT, pHostContext);
	
    switch (dwCode)
    {
        case  IOCTL_POWER_CAPABILITIES:
            // tell the power manager about ourselves.
            DEBUGMSG(ZONE_INFO, (TEXT(" SDH_IOCTL_POWER_CAPABILITIES\r\n")));
            if( pBufOut != NULL &&  
                dwLenOut >= sizeof(POWER_CAPABILITIES) && 
                pdwActualOut != NULL)
            {
                PPOWER_CAPABILITIES ppc = (PPOWER_CAPABILITIES) pBufOut;
                memset(ppc, 0, sizeof(POWER_CAPABILITIES));
                ppc->DeviceDx = 0x19;   // support D0, D3, D4
                ppc->WakeFromDx = 0x08; // D3 have wake capability
                ppc->InrushDx = 0x00;       // No in rush requirement
                ppc->Power[D0] = 600;                   // 0.6W
                ppc->Power[D1] = PwrDeviceUnspecified;
                ppc->Power[D2] = PwrDeviceUnspecified;
                ppc->Power[D3] = 0;
                ppc->Power[D4] = 0;
                ppc->Latency[D0] = 0;
                ppc->Latency[D1] = PwrDeviceUnspecified;
                ppc->Latency[D2] = PwrDeviceUnspecified;
                ppc->Latency[D3] = 0;
                ppc->Latency[D4] = 0;
                ppc->Flags = 0;
                *pdwActualOut = sizeof(POWER_CAPABILITIES);
                dwErr = ERROR_SUCCESS;
            }
            break;
        case  IOCTL_POWER_GET:
            DEBUGMSG(ZONE_INFO, (TEXT("SDH_IOCTL_POWER_GET\r\n")));
            if( pBufOut != NULL && 
                dwLenOut == sizeof(CEDEVICE_POWER_STATE) && 
                pdwActualOut != NULL)
            {
                // just return our Current Power state
                *(PCEDEVICE_POWER_STATE)pBufOut = pHCDevice->CurrentPowerState;
                *pdwActualOut = sizeof(CEDEVICE_POWER_STATE);
                dwErr = ERROR_SUCCESS;
            }
            break;		
        case  IOCTL_POWER_SET:
            DEBUGMSG(ZONE_INFO, (TEXT("SDH_IOCTL_POWER_SET\r\n")));
            if( pBufOut != NULL && 
                dwLenOut == sizeof(CEDEVICE_POWER_STATE) && 
                pdwActualOut != NULL)
            {
                CEDEVICE_POWER_STATE NewDx = *(PCEDEVICE_POWER_STATE)pBufOut;
                DEBUGMSG(ZONE_INFO, (TEXT("NewDx = %d\r\n"), NewDx));

                if(NewDx != pHCDevice->CurrentPowerState)
                {
                    if(NewDx == D3 ||NewDx == D4 )
					SDPowerDown(pHostContext);
                    else 
					SDPowerUp(pHostContext);			
                }
            }
		 break;
        default:
		break;
    	}
    return TRUE;
}

///////////////////////////////////////////////////////////////////////////////
//  SDH_Open - the open entry point for the bus driver
//  Input:  hDeviceContext - the device context from SDH_Init
//          AccessCode - the desired access
//          ShareMode - the desired share mode
//  Output: 
//  Return: 0
//  Notes:  not used
///////////////////////////////////////////////////////////////////////////////
DWORD SDH_Open(DWORD    hDeviceContext,
               DWORD    AccessCode,
               DWORD    ShareMode)
{
    DEBUGMSG(ZONE_FUNCTION, (TEXT("SDH: +-SDH_Open \n")));
    return 0;
}



///////////////////////////////////////////////////////////////////////////////
//  SDH_Close - the close entry point 
//  Input:  hOpenContext - the context returned from SDH_Open
//  Output: 
//  Return: TRUE
//  Notes:  not used
///////////////////////////////////////////////////////////////////////////////
BOOL SDH_Close(DWORD hOpenContext)
{
    DEBUGMSG(ZONE_FUNCTION, (TEXT("SDH: +-SDH_Close\n")));
    return TRUE;
}

///////////////////////////////////////////////////////////////////////////////
//  SDH_PowerDown - the power down entry point
//  Input:  hDeviceContext - the device context from SDH_Init
//  Output: 
//  Notes:  preforms no actions
///////////////////////////////////////////////////////////////////////////////
void SDH_PowerDown(DWORD    hDeviceContext)
{
    DEBUGMSG(ZONE_FUNCTION, (TEXT("SDH: +-SDH_PowerDown\n"))); 
    PSDCARD_HC_CONTEXT pHostContext = (PSDCARD_HC_CONTEXT)hDeviceContext;
    //SDPowerDown(pHostContext);
    // Do not allow client driver to continue submit request during power down.
    //Since 1 controller support 1 SD slot, we use index 0
    SDHCDPowerUpDown(pHostContext, FALSE, FALSE, 0);
    return;
}

///////////////////////////////////////////////////////////////////////////////
//  SDH_PowerUp - the power up entry point 
//  Input:  hDeviceContext - the device context from SDH_Init
//  Output: 
//  Notes:  preforms no actions
///////////////////////////////////////////////////////////////////////////////
void SDH_PowerUp(DWORD  hDeviceContext)
{
    DEBUGMSG(ZONE_FUNCTION, (TEXT("SDH: +-SDH_PowerUp\n")));
    PSDCARD_HC_CONTEXT pHostContext = (PSDCARD_HC_CONTEXT)hDeviceContext;
    //SDPowerUp(pHostContext);
    //Since 1 controller support 1 SD slot, we use index 0
    SDHCDPowerUpDown(pHostContext, TRUE, TRUE, 0);
    return;
}

///////////////////////////////////////////////////////////////////////////////
//  SDH_Read - the read entry point for the CE file system wrapper
//  Input:  hOpenContext - the context from SDH_Open
//          pBuffer - the user's buffer
//          Count - the size of the transfer
//  Output: 
//  Return: zero
//  Notes:  not used
///////////////////////////////////////////////////////////////////////////////
DWORD SDH_Read(DWORD    hOpenContext,
               LPVOID   pBuffer,
               DWORD    Count)
{
    DEBUGMSG(ZONE_FUNCTION, (TEXT("SDH: +-SDH_Read\n")));
    return 0;
}

///////////////////////////////////////////////////////////////////////////////
//  SDH_Seek - the seek entry point for the CE file system wrapper
//  Input:  hOpenContext - the context from SDH_Open
//          Amount - the amount to seek
//          Type - the type of seek
//  Output: 
//  Return: zero
//  Notes:  not used
///////////////////////////////////////////////////////////////////////////////
DWORD SDH_Seek(DWORD    hOpenContext,
               long     Amount,
               DWORD    Type)
{
    DEBUGMSG(ZONE_FUNCTION, (TEXT("SDH: +-SDH_Seek\n")));
    return 0;
}

///////////////////////////////////////////////////////////////////////////////
//  SDH_Write - the write entry point for the CE file system wrapper
//  Input:  hOpenContext - the context from SDH_Open
//          pBuffer - the user's buffer
//          Count - the size of the transfer
//  Output: 
//  Return: zero
//  Notes:  Not used
///////////////////////////////////////////////////////////////////////////////
DWORD SDH_Write(DWORD   hOpenContext,
                LPCVOID pBuffer,
                DWORD   Count)
{
    DEBUGMSG(ZONE_FUNCTION, (TEXT("SDH: +-SDH_Write\n")));
    return 0;
}

BOOL LoadRegistrySettings( HKEY hKeyDevice, PSDH_HARDWARE_CONTEXT pController )
{
    DWORD dwRegVal;
    DWORD dwDataSize;
    DWORD dwType;

    dwDataSize = sizeof(DWORD);
    if( ERROR_SUCCESS == RegQueryValueEx( hKeyDevice, CONTROLLER_IST_PRI_TEXT,
                                          NULL, &dwType, (LPBYTE)&dwRegVal, &dwDataSize ) &&
        REG_DWORD == dwType )
    {
        pController->ControllerIstThreadPriority = dwRegVal;
    }
    else
    {
        pController->ControllerIstThreadPriority = SDHC_DEFAULT_CARD_CONTROLLER_PRIORITY;
    }

    if (hKeyDevice && 
		ERROR_SUCCESS == RegQueryValueEx(hKeyDevice, CARDDETECT_IST_PRI_TEXT,
			NULL, &dwType, (LPBYTE)&dwRegVal, &dwDataSize) &&
		REG_DWORD == dwType)
    {
        pController->dwCardDetectIstThreadPriority = dwRegVal;
    }
    else
    {
        pController->dwCardDetectIstThreadPriority = SDHC_DEFAULT_CARD_DETECT_PRIORITY;
    }
	
	if( ERROR_SUCCESS == RegQueryValueEx( hKeyDevice, CONTROLLER_INDEX_PRI_TEXT,
                                          NULL, &dwType, (LPBYTE)&dwRegVal, &dwDataSize ) &&
        REG_DWORD == dwType )
    {
        pController->ControllerIndex = dwRegVal;
    }
    else
    {
        return FALSE ; 
    }
    return BSPSdhcLoadPlatformRegistrySettings(hKeyDevice);
}

// DO NOT REMOVE --- END EXTERNALLY DEVELOPED SOURCE CODE ID --- DO NOT REMOVE