bspsdhc.c

IMX开发板BSP驱动程序

//------------------------------------------------------------------------------
//
//  Copyright (C) 2004, Motorola Inc. All Rights Reserved
//
//------------------------------------------------------------------------------
/*---------------------------------------------------------------------------
* Copyright (C) 2004, 2005, 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 
*--------------------------------------------------------------------------*/

//------------------------------------------------------------------------------
//
//  File:  bspsdhc.c
//
//  Implementation of SDHC Driver Platform Device Driver
//
//  This file implements platform specific functions for SDHC.
//------------------------------------------------------------------------------
#include <windows.h>
#include <nkintr.h>
#include <ceddk.h>
#include <Sdcard.h>
#include "bsp.h"
#include "bspsdhc.h"
#include "pmic_regulator.h"

//-----------------------------------------------------------------------------
// External Variables
//-----------------------------------------------------------------------------
// External Functions
//-----------------------------------------------------------------------------
extern PMIC_STATUS PmicVoltageRegulatorOn (PMIC_REGULATOR_VREG regulator);
extern PMIC_STATUS PmicVoltageRegulatorSetVoltageLevel (PMIC_REGULATOR_VREG regulator, 
                                                        PMIC_REGULATOR_VREG_VOLTAGE voltage);
//-----------------------------------------------------------------------------
// 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 )
{
    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;

    if (startClocks)
    {
    	if(ControllerIndex == 1) 
        	rc = DDKClockSetGatingMode(DDK_CLOCK_GATE_INDEX_SDHC1, 
        	    DDK_CLOCK_GATE_MODE_ENABLED_ALL);
		if(ControllerIndex == 2)
			rc = DDKClockSetGatingMode(DDK_CLOCK_GATE_INDEX_SDHC2, 
			    DDK_CLOCK_GATE_MODE_ENABLED_ALL);
    }
    else
    {
    	if(ControllerIndex == 1) 
        	rc = DDKClockSetGatingMode(DDK_CLOCK_GATE_INDEX_SDHC1, 
        	    DDK_CLOCK_GATE_MODE_DISABLED);
		if(ControllerIndex == 2)
			rc = DDKClockSetGatingMode(DDK_CLOCK_GATE_INDEX_SDHC2, 
			    DDK_CLOCK_GATE_MODE_DISABLED);
    }
    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_PER, &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 (dwIndex == 1)
    {
        PmicVoltageRegulatorOn(VMMC1);
    }
    else
    {
        PmicVoltageRegulatorOn(VMMC2);
    }
}
//------------------------------------------------------------------------------
//
// 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)
{
    PMIC_REGULATOR_VREG_VOLTAGE voltage;
    DWORD regulator;

    if (dwIndex == 1)
    {
        regulator = VMMC1;
    }
    else
    {
        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);
    }
}

//TODO: (currently not used)
//------------------------------------------------------------------------------
//
// Function: BSPGetVoltageSlot
//
// This function gets voltage window mask and optimal voltage
//
// Parameters:
//      mask [out]		supported voltage window mask 
//		voltage [out] 	optimum voltage mask
//
// Returns:
//      The clock source for SDHC.
//
//------------------------------------------------------------------------------
//void BSPGetVoltageSlot(UINT32 *mask, UINT32 *voltage, UINT32 *PowerUpDelay)
//{
//     *mask = SD_VDD_WINDOW_3_2_TO_3_3 | SD_VDD_WINDOW_3_3_TO_3_4 ; 
//	 *voltage = SD_VDD_WINDOW_3_2_TO_3_3 ;
//	 *PowerUpDelay = SDHC_MAX_POWER_SUPPLY_RAMP_UP ; 
//}

//------------------------------------------------------------------------------
//
// Function: BSPSdhcInit
//
// BSP specific initialization
//
// Parameters:
//      ControllerIndex [in]		SDHC controller index 
//
// Returns:
//      TRUE if success 
//
//------------------------------------------------------------------------------
BOOL BSPSdhcInit(DWORD ControllerIndex) 
{
	return TRUE  ; 
}
//------------------------------------------------------------------------------
//
// Function: BspSdhcIsCardPresent
//
// function to check card existence
//
// Parameters:
//      ControllerIndex [in]		controller index
//
// Returns:
//      TRUE if success 
//
//------------------------------------------------------------------------------
BOOL BspSdhcIsCardPresent(DWORD ControllerIndex)
{
	UINT32 card_exist = 0 ; 
	
	if(ControllerIndex == 1)
	{
        //Read from hardware whether card exist
		if(DDKGpioReadDataPin(DDK_GPIO_PORT1, 1, &card_exist) == FALSE)
			card_exist = 0 ; //GPIO read failed
	}
	else
	{
        //Read from hardware whether card exist
		if(DDKGpioReadDataPin(DDK_GPIO_PORT1, 2, &card_exist) == FALSE)
			card_exist = 0 ; //GPIO read failed
	}

	return (card_exist ? TRUE : FALSE); 
}
//------------------------------------------------------------------------------
//
// Function: BspSdhcCardDetectDeinitialize
//
// function to clean up preiously configured iomux, gpio 
//
// Parameters:
//      ControllerIndex [in]		controller index 
//
// Returns: None
//
//------------------------------------------------------------------------------
void BspSdhcCardDetectDeinitialize(DWORD ControllerIndex)
{
	if(ControllerIndex == 1)
	{
        //disable the GPIO pins
        DDKGpioClearIntrPin(DDK_GPIO_PORT1, 1);
        DDKGpioUnbindIrq(DDK_GPIO_PORT1, 1);
	}
    else
	{
        //disable the GPIO pins
		DDKGpioClearIntrPin(DDK_GPIO_PORT1, 2);
        DDKGpioUnbindIrq(DDK_GPIO_PORT1, 2);
	}
}

//-----------------------------------------------------------------------------
//
// Function: BspSdhcSetIOMux
//
// This function configures IOMUX for successful operation of the SDHC.
//
// Parameters:
//      ControllerIndex [in]    SDHC controller index.
//
// Returns: None
//-----------------------------------------------------------------------------
void BspSdhcSetIOMux(DWORD ControllerIndex)
{
    if (ControllerIndex == 1)
    {
        // Configure IOMUX to request SDHC1 bus signals
        DDKIomuxSetPinMux(DDK_IOMUX_PIN_SD1_CMD,   DDK_IOMUX_OUT_FUNC, DDK_IOMUX_IN_FUNC);
        DDKIomuxSetPinMux(DDK_IOMUX_PIN_SD1_CLK,   DDK_IOMUX_OUT_FUNC, DDK_IOMUX_IN_FUNC);
        DDKIomuxSetPinMux(DDK_IOMUX_PIN_SD1_DATA0, DDK_IOMUX_OUT_FUNC, DDK_IOMUX_IN_FUNC);
        DDKIomuxSetPinMux(DDK_IOMUX_PIN_SD1_DATA1, DDK_IOMUX_OUT_FUNC, DDK_IOMUX_IN_FUNC);
        DDKIomuxSetPinMux(DDK_IOMUX_PIN_SD1_DATA2, DDK_IOMUX_OUT_FUNC, DDK_IOMUX_IN_FUNC);
        DDKIomuxSetPinMux(DDK_IOMUX_PIN_SD1_DATA3, DDK_IOMUX_OUT_FUNC, DDK_IOMUX_IN_FUNC);

        DDKIomuxSetPadConfig(DDK_IOMUX_PAD_SD1_CMD, DDK_IOMUX_PAD_SLEW_FAST, 
                             DDK_IOMUX_PAD_DRIVE_MAX, DDK_IOMUX_PAD_MODE_CMOS, 
                             DDK_IOMUX_PAD_TRIG_SCHMITT, 
                             DDK_IOMUX_PAD_PULL_UP_22K);
  
        DDKIomuxSetPadConfig(DDK_IOMUX_PAD_SD1_CLK, DDK_IOMUX_PAD_SLEW_FAST, 
                             DDK_IOMUX_PAD_DRIVE_MAX, DDK_IOMUX_PAD_MODE_CMOS, 
                             DDK_IOMUX_PAD_TRIG_SCHMITT, 
                             DDK_IOMUX_PAD_PULL_UP_22K);
  
        DDKIomuxSetPadConfig(DDK_IOMUX_PAD_SD1_DATA0, DDK_IOMUX_PAD_SLEW_FAST, 
                             DDK_IOMUX_PAD_DRIVE_MAX, DDK_IOMUX_PAD_MODE_CMOS, 
                             DDK_IOMUX_PAD_TRIG_SCHMITT, 
                             DDK_IOMUX_PAD_PULL_UP_22K);
  
        DDKIomuxSetPadConfig(DDK_IOMUX_PAD_SD1_DATA1, DDK_IOMUX_PAD_SLEW_FAST, 
                             DDK_IOMUX_PAD_DRIVE_MAX, DDK_IOMUX_PAD_MODE_CMOS, 
                             DDK_IOMUX_PAD_TRIG_SCHMITT, 
                             DDK_IOMUX_PAD_PULL_UP_22K);
  
        DDKIomuxSetPadConfig(DDK_IOMUX_PAD_SD1_DATA2, DDK_IOMUX_PAD_SLEW_FAST, 
                             DDK_IOMUX_PAD_DRIVE_MAX, DDK_IOMUX_PAD_MODE_CMOS, 
                             DDK_IOMUX_PAD_TRIG_SCHMITT, 
                             DDK_IOMUX_PAD_PULL_UP_22K);
  
        DDKIomuxSetPadConfig(DDK_IOMUX_PAD_SD1_DATA3, DDK_IOMUX_PAD_SLEW_FAST,