bspsdhc.c

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

//------------------------------------------------------------------------------
//
//  Copyright (C) 2004, Motorola Inc. All Rights Reserved
//
//------------------------------------------------------------------------------
//---------------------------------------------------------------------------
// Copyright (C) 2006, Freescale Semiconductor, Inc. All Rights Reserved.
// THIS SOURCE CODE, AND ITS USE AND DISTRIBUTION, IS SUBJECT TO THE TERMS
// AND CONDITIONS OF THE APPLICABLE LICENSE AGREEMENT 
//--------------------------------------------------------------------------
#include <windows.h>
#include <nkintr.h>
#include <ceddk.h>
#include <Sdcard.h>
#include "bsp.h"
#include "bspsdhc.h"
#if USE_PMIC
#include "pmic_regulator.h"
#endif //USE_PMIC

//-----------------------------------------------------------------------------
// External Variables
//-----------------------------------------------------------------------------
// External Functions
//-----------------------------------------------------------------------------
#if USE_PMIC
extern PMIC_STATUS PmicVoltageRegulatorOn (PMIC_REGULATOR_VREG regulator);
extern PMIC_STATUS PmicVoltageRegulatorSetVoltageLevel (PMIC_REGULATOR_VREG regulator, 
                                                        PMIC_REGULATOR_VREG_VOLTAGE voltage);
#endif //USE_PMIC
//-----------------------------------------------------------------------------
// Defines

//------------------------------------------------------------------------------
// Types

//------------------------------------------------------------------------------
// Global Variables

//------------------------------------------------------------------------------
// Local Variables
/*******************************************************************************
 EXPORTED FUNCTIONS
*******************************************************************************/
//------------------------------------------------------------------------------
//
// Function: BSPSdhcLoadPlatformRegistrySettings
//
// This function is to get any platform-specific registry setting
//
// Parameters: 
//			hKeyDevice
//				[in] Registry key opened opened by CSP layer 
//
// Returns:
//      Return TRUE if successful
//			   FALSE if unsuccessful  
//------------------------------------------------------------------------------
BOOL BSPSdhcLoadPlatformRegistrySettings( HKEY hKeyDevice )
{
	// Remove-W4: Warning C4100 workaround
    UNREFERENCED_PARAMETER(hKeyDevice);
    return TRUE;
}

//------------------------------------------------------------------------------
//
// Function: BSPSdhcSetClockGatingMode
//
// This function enable or disable CRM clock for SDHC.
//
// Parameters:
//      startClocks
//          [in] boolean variable to enable or disable CRM clock
//		Controller Index 
//			[in] SDHC controller index (1 or 2) 
//
// Returns:
//      Return TRUE.
//
//------------------------------------------------------------------------------
BOOL BSPSdhcSetClockGatingMode(BOOL startClocks, DWORD ControllerIndex)
{
    BOOL rc = FALSE;

	if (startClocks)
    {
    	if(ControllerIndex == 1) 
        	rc = DDKClockSetGatingMode(DDK_CLOCK_GATE_INDEX_SDHC1, 
        	    DDK_CLOCK_GATE_MODE_ENABLE);
	if(ControllerIndex == 2)
		rc = DDKClockSetGatingMode(DDK_CLOCK_GATE_INDEX_SDHC2, 
		    DDK_CLOCK_GATE_MODE_ENABLE);
	if(ControllerIndex == 3)
		rc = DDKClockSetGatingMode(DDK_CLOCK_GATE_INDEX_SDHC3, 
		   DDK_CLOCK_GATE_MODE_ENABLE);
    }
    else
    {
    	if(ControllerIndex == 1) 
        	rc = DDKClockSetGatingMode(DDK_CLOCK_GATE_INDEX_SDHC1, 
        	    DDK_CLOCK_GATE_MODE_DISABLE);
	if(ControllerIndex == 2)
		rc = DDKClockSetGatingMode(DDK_CLOCK_GATE_INDEX_SDHC2, 
		    DDK_CLOCK_GATE_MODE_DISABLE);
	if(ControllerIndex == 3)
		rc = DDKClockSetGatingMode(DDK_CLOCK_GATE_INDEX_SDHC3, 
		    DDK_CLOCK_GATE_MODE_DISABLE);
    }

    return rc;
}
//------------------------------------------------------------------------------
//
// Function: BSPGetSDHCCLK
//
// This function returns the BSP-specific clock
// source selection value for SDHC.
//
// Parameters:
//      None
//
// Returns:
//      The clock source for SDHC.
//
//------------------------------------------------------------------------------
UINT32 BSPGetSDHCCLK(void)
{
    UINT32 freq;

    // SDHC uses the PERCLK for generating the bit clock.
    DDKClockGetFreq(DDK_CLOCK_SIGNAL_PERDIV2, &freq);
    return freq;
}
//------------------------------------------------------------------------------
//
// Function: BSPSlotVoltageOn
//
// This function turns on the voltage to the specified slot
//
// Parameters:
//      dwIndex [in]    requested slot number
//
// Returns:
//------------------------------------------------------------------------------
void BSPSlotVoltageOn(DWORD dwIndex)
{
    #if USE_PMIC
    if (dwIndex == 1)
    {
        PmicVoltageRegulatorOn(VMMC1);
    }
    else if (dwIndex == 2)
    {
        PmicVoltageRegulatorOn(VMMC2);
    }
    #endif //USE_PMIC
}
//------------------------------------------------------------------------------
//
// Function: BSPSlotVoltageOff
//
// This function turns on the voltage to the specified slot
//
// Parameters:
//      dwIndex [in]    requested slot number
//
// Returns:
//------------------------------------------------------------------------------
void BSPSlotVoltageOff(DWORD dwIndex)
{
    #if USE_PMIC
    if (dwIndex == 1)
    {
        PmicVoltageRegulatorOff(VMMC1);
    }
    else if (dwIndex == 2)
    {
        PmicVoltageRegulatorOff(VMMC2);
    }
    #endif //USE_PMIC
}
//------------------------------------------------------------------------------
//
// Function: BSPSetVoltageSlot
//
// This function sets voltage slot
//
// Parameters:
//      dwIndex [in]    requested slot number
//      mask [in]		requested voltage window mask 
//
// Returns:
//------------------------------------------------------------------------------
void BSPSetVoltageSlot(DWORD dwIndex, UINT32 mask)
{
    #if USE_PMIC
    PMIC_REGULATOR_VREG_VOLTAGE voltage;
    PMIC_REGULATOR_VREG  regulator = 0;

    if (dwIndex == 1)
    {
        regulator = VMMC1;
    }
    else if (dwIndex == 2)
    {
        regulator = VMMC2;
    }

    switch (mask)
    {
    case 0:
        //shut down the regulator
        PmicVoltageRegulatorOff(regulator);
        break;

    case SD_VDD_WINDOW_1_6_TO_1_7:
        voltage.vmmc = VMMC_1; //1.6V
        break;

    case SD_VDD_WINDOW_1_7_TO_1_8:
        voltage.vmmc = VMMC_2; //1.8V
        break;

    case SD_VDD_WINDOW_1_8_TO_1_9:
        voltage.vmmc = VMMC_2; //1.8V
        break;

    case SD_VDD_WINDOW_1_9_TO_2_0:
        voltage.vmmc = VMMC_3; //2.0V
        break;

    case SD_VDD_WINDOW_2_0_TO_2_1:
        voltage.vmmc = VMMC_3; //2.0V
        break;

    case SD_VDD_WINDOW_2_1_TO_2_2:
        voltage.vmmc = VMMC_4; //2.6V
        break;

    case SD_VDD_WINDOW_2_2_TO_2_3:
        voltage.vmmc = VMMC_4; //2.6V
        break;

    case SD_VDD_WINDOW_2_3_TO_2_4:
        voltage.vmmc = VMMC_4; //2.6V
        break;

    case SD_VDD_WINDOW_2_4_TO_2_5:
        voltage.vmmc = VMMC_4; //2.6V
        break;

    case SD_VDD_WINDOW_2_5_TO_2_6:
        voltage.vmmc = VMMC_4; //2.6V
        break;

    case SD_VDD_WINDOW_2_6_TO_2_7:
        voltage.vmmc = VMMC_5; //2.7V
        break;

    case SD_VDD_WINDOW_2_7_TO_2_8:
        voltage.vmmc = VMMC_6; //2.8V
        break;

    case SD_VDD_WINDOW_2_8_TO_2_9:
        voltage.vmmc = VMMC_7; //2.9V
        break;

    case SD_VDD_WINDOW_2_9_TO_3_0:
        voltage.vmmc = VMMC_8; //3.0V
        break;

    case SD_VDD_WINDOW_3_0_TO_3_1:
        voltage.vmmc = VMMC_8; //3.0V
        break;

    case SD_VDD_WINDOW_3_1_TO_3_2:
        voltage.vmmc = VMMC_8; //3.0V
        break;

    case SD_VDD_WINDOW_3_2_TO_3_3:
        voltage.vmmc = VMMC_8; //3.0V
        break;

    case SD_VDD_WINDOW_3_3_TO_3_4:
        voltage.vmmc = VMMC_8; //3.0V
        break;

    case SD_VDD_WINDOW_3_4_TO_3_5:
        voltage.vmmc = VMMC_8; //3.0V
        break;

    case SD_VDD_WINDOW_3_5_TO_3_6:
        voltage.vmmc = VMMC_8; //3.0V
        break;
        
    default:
       voltage.vmmc = VMMC_8; //3.0V
       break; 
    }
        
    if (mask != 0)
    {
        //set the level in PMIC
        PmicVoltageRegulatorSetVoltageLevel(regulator, voltage);
    }
    #endif //USE_PMIC
}

//------------------------------------------------------------------------------
//
// Function: BSPGetTxDmaChannel
//
// Get TX DMA channel.
//
// Parameters:
//		dwIndex [in]    requested slot number
//
// Returns:
//		TX DMA channel.
//
//------------------------------------------------------------------------------
UINT8 BSPSdhcGetTxDmaChannel(DWORD dwIndex)
{
	if(dwIndex == 1)
        	return BSP_DMAC_CH_SDHC1_TX;
	if(dwIndex == 2)
        	return BSP_DMAC_CH_SDHC2_TX;
	if(dwIndex == 3)
        	return BSP_DMAC_CH_SDHC3_TX;
	return 0;

}

//------------------------------------------------------------------------------
//
// Function: BSPGetRxDmaChannel
//
// Get RX DMA channel.
//
// Parameters:
//		dwIndex [in]    requested slot number
//
// Returns:
//		RX DMA channel.
//
//------------------------------------------------------------------------------
UINT8 BSPSdhcGetRxDmaChannel(DWORD dwIndex)
{
	if(dwIndex == 1)
        	return BSP_DMAC_CH_SDHC1_RX;
	if(dwIndex == 2)
        	return BSP_DMAC_CH_SDHC2_RX;
	if(dwIndex == 3)
        	return BSP_DMAC_CH_SDHC3_RX;
	return 0;

}

//------------------------------------------------------------------------------
//
// Function: BSPGetTxDmaBufferSize
//
// Get TX DMA buffer size.
//
// Parameters:
//		None.
//
// Returns:
//		TX DMA buffer size.
//
//------------------------------------------------------------------------------
UINT32 BSPSdhcGetTxDmaBufferSize(void)
{
	return BSP_DMAC_SDHC_BUFF_SIZE;
}

//------------------------------------------------------------------------------
//
// Function: BSPGetRxDmaBufferSize
//
// Get RX DMA buffer size.
//
// Parameters:
//		None.
//
// Returns:
//		RX DMA buffer size.
//
//------------------------------------------------------------------------------
UINT32 BSPSdhcGetRxDmaBufferSize(void)
{
	return BSP_DMAC_SDHC_BUFF_SIZE;
}

//------------------------------------------------------------------------------
//
// Function: BSPSdhcInit
//