sdcontrol.cpp

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

    case SDHCDEnableSDIOInterrupts:
        if (!pData && OptionSize == 0)
        {
            DEBUGMSG(ZONE_INFO, 
                     (TEXT("SDHSlotOptionHandler - called - SDHCDAckSDIOInterrupt & EnableSDIOInterrupts : on slot %d\r\n"),
                      SlotNumber));
            //Enable SDIO interrupt 
            INSREG32BF(&pController->pSDMMCRegisters->INT_CNTR, SDHC_INT_SDIOIRQ, 1);
            // Enable SDIO Wakeup interrupt before cutting off the controller clock
            INSREG32BF(&pController->pSDMMCRegisters->INT_CNTR, SDHC_INT_SDIOIRQWKP, 1);
            pController->fSDIOEnabled = TRUE;
        } else
            status = SD_API_STATUS_INVALID_PARAMETER;
        break;

    case SDHCDDisableSDIOInterrupts:
        if (!pData && OptionSize == 0)
        {
            DEBUGMSG(ZONE_INFO, 
                     (TEXT("SDHSlotOptionHandler - called - DisableSDIOInterrupts : on slot %d  \r\n"),
                      SlotNumber));
            // Disable SDIO interrupt
            INSREG32BF(&pController->pSDMMCRegisters->INT_CNTR, SDHC_INT_SDIOIRQ, 0);
            pController->fSDIOEnabled = FALSE;
        } else
            status = SD_API_STATUS_INVALID_PARAMETER;
        break;

    case SDHCDSetSlotInterface:
        if (pData && OptionSize == sizeof(SD_CARD_INTERFACE))
        {
            DEBUGMSG(ZONE_INFO, 
                     (TEXT("SDHSlotOptionHandler - called - SetSlotInterface : Clock Setting: %d \r\n"), 
                      ((PSD_CARD_INTERFACE)pData)->ClockRate));

            if (SD_INTERFACE_SD_MMC_1BIT == 
                ((PSD_CARD_INTERFACE)pData)->InterfaceMode)
            {
                DEBUGMSG(ZONE_INFO, 
                         (TEXT("SDHSlotOptionHandler - called - SetSlotInterface : setting for 1 bit mode \r\n")));
                pController->f4BitMode = FALSE;
                pController->BusWidthSetting = 0;
                pController->Units_in_fifo  = 4;    
                pController->Bytes_in_fifo  = 16 ;  //16bytes

            } else if (SD_INTERFACE_SD_4BIT == ((PSD_CARD_INTERFACE)pData)->InterfaceMode)
            {
                DEBUGMSG(ZONE_INFO, 
                         (TEXT("SDHSlotOptionHandler - called - SetSlotInterface : setting for 4 bit mode \r\n")));
                pController->f4BitMode = TRUE;
                pController->BusWidthSetting = 2;
                pController->Units_in_fifo  = 4*4; 
                pController->Bytes_in_fifo  = 64; //64 bytes
            }

            // set rate
            SetClock(pController, FALSE);
            SetRate(pController, &((PSD_CARD_INTERFACE)pData)->ClockRate, TRUE);
	        SetClock(pController, TRUE);

            if (!SD_API_SUCCESS(status))
            {
                DEBUGMSG(ZONE_ERROR, (TEXT("SDHSlotOptionHandler: Failed to set Card Interface\n")));  
            }
        } else
            status = SD_API_STATUS_INVALID_PARAMETER;
        break;

    case SDHCDSetSlotPower:
        if (pData && OptionSize == sizeof(DWORD))
        {
            //takes a DWORD for the power bit mask
            UINT32 dwVddSettingMask = *(UINT32 *)pData;
            DEBUGMSG(ZONE_INFO, 
                     (TEXT("SDHSlotOptionHandler - called - SDHCDSetSlotPower : 0x%X  \r\n"), 
                      dwVddSettingMask));

            //Copy Slot Vdd voltage to hardware context. This will be used to set slot power 
            //during wakeup 
            pController->dwVddSettingMask = dwVddSettingMask ; 
			
            // Vary voltage setting based on request. 
            BSPSetVoltageSlot(pController->ControllerIndex, dwVddSettingMask) ; 
     
        } else
            status = SD_API_STATUS_INVALID_PARAMETER;
        break;

    case SDHCDSetSlotPowerState:
        if (pData && OptionSize == sizeof(CEDEVICE_POWER_STATE))
        {
            CEDEVICE_POWER_STATE ps = *(CEDEVICE_POWER_STATE *)pData;
            DEBUGMSG(ZONE_INFO, 
                     (TEXT("SDHSlotOptionHandler - called - SDHCDSetSlotPowerState : %d  \r\n"), 
                      ps));
            SetHardwarePowerState(pController, ps);
        } else
            status = SD_API_STATUS_INVALID_PARAMETER;
        break;

    case SDHCDGetSlotPowerState:
        if (pData && OptionSize == sizeof(CEDEVICE_POWER_STATE))
        {
            *(CEDEVICE_POWER_STATE *)pData = pController->CurrentPowerState;
            DEBUGMSG(ZONE_INFO, 
                     (TEXT("SDHSlotOptionHandler - called - GetSlotPower : %d  \r\n"), 
                      *((CEDEVICE_POWER_STATE *)pData)));
        } else
            status = SD_API_STATUS_INVALID_PARAMETER;
        break;

    case SDHCDWakeOnSDIOInterrupts:
        if (pData && OptionSize == sizeof(BOOL))
        {
            // TODO: Enable wake on SDIO int
            BOOL fEnable = *(BOOL *)pData;
            if (fEnable)
            {
                //Indicate that SDIO wake up is supported
                pController->fWakeOnSDIOInt = TRUE;
                DEBUGMSG(ZONE_INFO,(TEXT("SDHSlotOptionHandler - Support SDIO Wanke Up\r\n")));
            } else
            {
                //Indicate that SDIO wake up is not supported
                pController->fWakeOnSDIOInt = FALSE;
                DEBUGMSG(ZONE_INFO,(TEXT("SDHSlotOptionHandler - not Support SDIO Wanke Up\r\n")));
            }
        } else
            status = SD_API_STATUS_INVALID_PARAMETER;
        break;

    case SDHCDGetWriteProtectStatus:
        if (pData && OptionSize == sizeof(SD_CARD_INTERFACE))
        {
            DEBUGMSG(ZONE_INFO, 
                     (TEXT("SDHSlotOptionHandler - called - SDHCDGetWriteProtectStatus : on slot %d  \r\n"),
                      SlotNumber)); 
            if ( BSPSdhcIsCardWriteProtected(pController->pBspSpecificContext) )
            {
                ((PSD_CARD_INTERFACE)pData)->WriteProtected = TRUE;
                DEBUGMSG(ZONE_INFO, (TEXT("SDHSlotOptionHandler - Card is write protected \r\n"))); 
            } else
            {
                ((PSD_CARD_INTERFACE)pData)->WriteProtected = FALSE;
                DEBUGMSG(ZONE_INFO, (TEXT("SDHSlotOptionHandler - Card is write enabled \r\n"))); 
            }
        } else
            status = SD_API_STATUS_INVALID_PARAMETER;
        break;

    case SDHCDQueryBlockCapability:
        if (pData && OptionSize == sizeof(SD_HOST_BLOCK_CAPABILITY))
        {
            pBlockCaps = (PSD_HOST_BLOCK_CAPABILITY)pData;
            DEBUGMSG(ZONE_INFO, 
                     (TEXT("SDHSlotOptionHandler: Read Block Length: %d , Read Blocks: %d\r\n"), 
                      pBlockCaps->ReadBlockSize, 
                      pBlockCaps->ReadBlocks));
            DEBUGMSG(ZONE_INFO, 
                     (TEXT("SDHSlotOptionHandler: Write Block Length: %d , Write Blocks: %d\r\n"), 
                      pBlockCaps->WriteBlockSize, 
                      pBlockCaps->WriteBlocks));

            if (pBlockCaps->ReadBlockSize > SDH_MAX_BLOCK_SIZE)
            {
                pBlockCaps->ReadBlockSize = SDH_MAX_BLOCK_SIZE;
            }

            if (pBlockCaps->ReadBlockSize < SDH_MIN_BLOCK_SIZE )
            {
                pBlockCaps->ReadBlockSize = SDH_MIN_BLOCK_SIZE;
            }

            if (pBlockCaps->WriteBlockSize > SDH_MAX_BLOCK_SIZE)
            {
                pBlockCaps->WriteBlockSize = SDH_MAX_BLOCK_SIZE;
            }

            if (pBlockCaps->WriteBlockSize < SDH_MIN_BLOCK_SIZE )
            {
                pBlockCaps->WriteBlockSize = SDH_MIN_BLOCK_SIZE;
            }

            pBlockCaps->ReadBlocks = (USHORT)  (pController->DmaRxBufSize / SDH_MAX_BLOCK_SIZE ); 
            pBlockCaps->WriteBlocks = (USHORT)  (pController->DmaTxBufSize / SDH_MAX_BLOCK_SIZE) ; 
        } else
            status = SD_API_STATUS_INVALID_PARAMETER;
        break;

    case SDHCDGetSlotInfo:
        DEBUGMSG(ZONE_INFO, 
                 (TEXT("SDHSlotOptionHandler - called - SDHCDGetSlotInfo   \r\n"))); 
        if ( OptionSize != sizeof(SDCARD_HC_SLOT_INFO) || pData == NULL )
        {
            status = SD_API_STATUS_INVALID_PARAMETER;
        } else
        {
            PSDCARD_HC_SLOT_INFO pSlotInfo = (PSDCARD_HC_SLOT_INFO)pData;
            // set the slot capabilities
            SDHCDSetSlotCapabilities(pSlotInfo, SD_SLOT_SD_1BIT_CAPABLE | 
                                     SD_SLOT_SD_4BIT_CAPABLE |
                                     SD_SLOT_SDIO_CAPABLE |
                                     SD_SLOT_SDMEM_4BIT_CAPABLE |
									 SD_SLOT_SDIO_4BIT_CAPABLE |
                                     SD_SLOT_SDIO_INT_DETECT_4BIT_MULTI_BLOCK);

            //TODO: Set all valid masks.
            //TODO: PMIC do not support ranges >3.00V. 
            //Set Slot voltage window
            pController->dwVoltageWindowMask = (SD_VDD_WINDOW_2_9_TO_3_0 | 
                                                SD_VDD_WINDOW_3_0_TO_3_1 |
                                                SD_VDD_WINDOW_3_1_TO_3_2);

            SDHCDSetVoltageWindowMask(pSlotInfo, pController->dwVoltageWindowMask);

            // Set optimal voltage
            //TODO : is this range supported
            pController->dwOptVoltageMask = SLOT_VOLTAGE_MAX_BITMASK;
            SDHCDSetDesiredSlotVoltage(pSlotInfo, pController->dwOptVoltageMask);

            // Controller may be able to clock at higher than the max SD rate,
            // but we should only report the highest rate in the range.
            DWORD dwMaxClockRateInSDRange = SD_FULL_SPEED_RATE;
            SetRate(pController, &dwMaxClockRateInSDRange, FALSE);
            SDHCDSetMaxClockRate(pSlotInfo, dwMaxClockRateInSDRange);

            // Set power up delay. 
            pController->dwPowerUpDelay = SDHC_MAX_POWER_SUPPLY_RAMP_UP;
            SDHCDSetPowerUpDelay(pSlotInfo, pController->dwPowerUpDelay);
        }
        break;

    default:
        status = SD_API_STATUS_INVALID_PARAMETER;
        break;
    }
    return status;
}
//------------------------------------------------------------------------------
//
// Function: SDPowerUp
//
// Power up handler. To be called within XXX_PowerOn only
//
// Parameters:
//      pHostContext[in] - host controller context
//
// Returns:
//      none
//
//------------------------------------------------------------------------------
void SDPowerUp(PSDCARD_HC_CONTEXT pHCContext)
{
    PSDH_HARDWARE_CONTEXT pHCDevice;

    DEBUGMSG(ZONE_FUNCTION, (TEXT("SDPowerUp+\r\n")));
    pHCDevice = GetExtensionFromHCDContext(PSDH_HARDWARE_CONTEXT, pHCContext);

    SetHardwarePowerState(pHCDevice, pHCDevice->PsAtPowerDown);


    DEBUGMSG(ZONE_FUNCTION, (TEXT("SDPowerUp-\r\n")));
}    
//------------------------------------------------------------------------------
//
// Function: SDPowerDown
//
// Power down handler. To be called within XXX_PowerDown only 
//
// Parameters:
//      pHostContext[in] - host controller context
//
// Returns:
//      none
//
//------------------------------------------------------------------------------
void SDPowerDown(PSDCARD_HC_CONTEXT pHCContext)
{
    PSDH_HARDWARE_CONTEXT pHCDevice;
    CEDEVICE_POWER_STATE cps;
    DEBUGMSG(ZONE_FUNCTION, (TEXT("SDPowerDown+\r\n")));

    pHCDevice = GetExtensionFromHCDContext(PSDH_HARDWARE_CONTEXT, pHCContext);

    pHCDevice->PsAtPowerDown = pHCDevice->CurrentPowerState;

    if (pHCDevice->fWakeOnSDIOInt)
    {
        cps = D3;

    } else
    {
        cps = D4;
    }

    SetHardwarePowerState(pHCDevice, cps);

    DEBUGMSG(ZONE_FUNCTION, (TEXT("SDPowerDown-\r\n")));
}
/*******************************************************************************
 PRIVATE FUNCTIONS
*******************************************************************************/
//------------------------------------------------------------------------------
//
// Function: SDControllerIstThread
//
// IST thread for MMC Controller driver
//
// Parameters:
//      pHCDevice[in] - the controller instance
//
// Returns:
//      Thread exit code
//
//------------------------------------------------------------------------------
DWORD SDControllerIstThread(PSDH_HARDWARE_CONTEXT pHCDevice)
{
    DEBUGMSG(ZONE_FUNCTION, (TEXT("+SDControllerIstThread: IST thread for MMC Controller driver\r\n")));

    if (!CeSetThreadPriority(GetCurrentThread(), pHCDevice->ControllerIstThreadPriority))
    {
        ERRORMSG(ZONE_ERROR, (TEXT("SDControllerIstThread: warning, failed to set CEThreadPriority \n")));