hwinit.c

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

//------------------------------------------------------------------------------
//
//  Copyright (C) 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:     hwinit.c
 *  Purpose:  Platform-specific routines for OTG transceiver/controller initialisation
 *            and control, including suspend/resume of transceiver.  Includes set-up of
 *            IOMUX, CPLD, and Vbus drivers for OTG port.
 *  Functions:
 *            BOOL InitializeOTGTransceiver(PCSP_USB_REGS* regs, BOOL IsHost)
 *            - various platform-specific functionality is added through callback functions
 *              which are supplied via generic interface routine:
 *            void RegisterCallback(BSP_USB_CALLBACK_FNS *pfn)
 *
 *            Those callbacks include:
 *              pfn->pfnUSBPowerDown        - called on system power suspend
 *              pfn->pfnUSBPowerUp          - called on system power restore
 *              pfn->pfnUSBSetPhyPowerMode  - called to set PHY to lower power mode
 *              (in this implementation phy/usb-clock/vcore is set to lower-power mode whenever
 *               idle in transceiver mode, so nothing needs to be done on PowerUp/PowerDown)
 */

#include <windows.h>
#include <Winbase.h>
#include <ceddk.h>
#include "bsp.h"
#include "mx27_usb.h"
#include "mx27_usbname.h"
#include "mx27_usbcommon.h"

#ifdef DEBUG

DBGPARAM dpCurSettings = {
    _T("USBXVR"),
    {
        _T("Error"), _T("Warning"), _T("Init"), _T("Function"),
        _T("Comments"), _T(""), _T(""), _T(""),
        _T(""), _T(""), _T(""), _T(""), 
        _T(""), _T(""), _T(""), _T("")
    },
    0x5
};

#endif // DEBUG
//#define USB_HOST_MODE 0           // OTG full speed
#define USB_HOST_MODE 1             // OTG high speed
//#define USB_HOST_MODE 2           // Host 1 full speed
//#define USB_HOST_MODE 3           // Host 2 full speed
//#define USB_HOST_MODE 4           // Host 2 high speed

// ISP1105: Full Speed Host 1
// ISP1504: High Speed OTG
// ISP1301: Full Speed OTG
// ISP1504: High Speed Host 2

static void BSPUsbXvrSetPhyPowerMode(CSP_USB_REGS *pUSBRegs, BOOL bResume);
extern BOOL Initialize1504Client(CSP_USB_REGS * regs);
extern BOOL Initialize1504Host(CSP_USB_REGS * regs);

//-----------------------------------------------------------------------------
//
//  Function: BSPGetUSBControllerType
//
//  This function is to return the USB Core Controller type in WORD format.
//  This is called by CSP public code when accessing the type of controller it
//  is using.
//
//  Parameters:
//     NULL
//     
//  Returns:
//     USB_SEL_OTG
//
//-----------------------------------------------------------------------------
WORD BSPGetUSBControllerType(void)
{
    return USB_SEL_OTG;
}

//-----------------------------------------------------------------------------
//
//  Function: BSPUSBOTGConfigGPIO
//
//  This function configures the gpio for usbotg
//
//  Parameters:
//     bEnable - wheather to enable od disable gpio
//     
//  Returns:
//     TRUE for succes and FALSE for failure
//
//-----------------------------------------------------------------------------
BOOL BSPUSBOTGConfigGPIO(BOOL bEnable)
{
	BOOL result = FALSE;
	DDK_GPIO_CFG  cfg;
	
	DDK_GPIO_SET_CONFIG(cfg, USBOTG_E );
	DEBUGMSG(1, (TEXT("cfg.ConfigType		 0x%x\r\n"),cfg.ConfigType));
	DEBUGMSG(1, (TEXT("cfg.PriConfig.Port    0x%x\r\n"),cfg.PriConfig.Port ));
	DEBUGMSG(1, (TEXT("cfg.PriConfig.PinMap  0x%x\r\n"),cfg.PriConfig.PinMap ));
	DEBUGMSG(1, (TEXT("cfg.PriConfig.PuenMap 0x%x\r\n"),cfg.PriConfig.PuenMap ));
	DDK_GPIO_SET_CONFIG(cfg, USBOTG_C);
	DEBUGMSG(1, (TEXT("cfg.ConfigType		 0x%x\r\n"),cfg.ConfigType));
	DEBUGMSG(1, (TEXT("cfg.PriConfig.Port    0x%x\r\n"),cfg.PriConfig.Port ));
	DEBUGMSG(1, (TEXT("cfg.PriConfig.PinMap  0x%x\r\n"),cfg.PriConfig.PinMap ));
	DEBUGMSG(1, (TEXT("cfg.PriConfig.PuenMap 0x%x\r\n"),cfg.PriConfig.PuenMap ));

	if (bEnable)
	{
		if(DDKGpioEnable(&cfg) == FALSE) 
		{
			ERRORMSG(1, (TEXT("Cannot enable UART gpio!\r\n")));
			goto CleanUp;
		}

    }
    else 
	{
        if(DDKGpioDisable(&cfg) == FALSE) 
		{
            ERRORMSG (1, (TEXT("Cannot Disable UART gpio!\r\n"))); 
            goto CleanUp;
        }

    }

    result = TRUE;

CleanUp:
    return result;
}

//-----------------------------------------------------------------------------
//
//  Function: InitializeOTGMux
//
//  This function is to configure the IOMUX for USB OTG Core
//
//  Parameters:
//     NULL
//     
//  Returns:
//     NULL
//
//-----------------------------------------------------------------------------
static void InitializeOTGMux()
{
	BSPUSBOTGConfigGPIO(TRUE);
    return;
}

    
//-----------------------------------------------------------------------------
//
//  Function: InitializeMux
//
//  This function is to configure the IOMUX for USB OTG Core,
//
//  Parameters:
//     NULL
//     
//  Returns:
//     offset of the configured USB Core register.
//
//-----------------------------------------------------------------------------
static DWORD InitializeMux(void)
{
    DWORD off=offset(CSP_USB_REGS, OTG)+offset(CSP_USB_REG, CAPLENGTH);

    InitializeOTGMux();
    off=offset(CSP_USB_REG, CAPLENGTH);

    return off;
}

//---------------------------------------------------------------------------------------------
// Function: Reset 
//     - Resets USB otg
// 
// Parameters: 
//      pRegs - Pointer to USB Registers
//
// Return: 
//      NULL
//------------------------------------------------------------------------------------------------
void Reset(CSP_USB_REGS *pRegs)
{
    USB_USBCMD_T Cmd;
    DWORD *temp;  
	int nAttempts = 0;	

    temp = (DWORD *)&Cmd;
    *temp = INREG32(&pRegs->OTG.USBCMD);
    Cmd.RST = USBCMD_RESET;
    OUTREG32(&pRegs->OTG.USBCMD, *temp);
    
    while ((INREG32(&pRegs->OTG.USBCMD)& (USBCMD_RESET << USBCMD_RESET_LSH)) && (nAttempts++ < 50))
    {
        //RETAILMSG(1, (TEXT("USBCMD = 0x%x\r\n"), INREG32(&pRegs->OTG.USBCMD)));
        Sleep(10);
    }

}

//---------------------------------------------------------------------------------------------
// Function: Stop 
//     - Stops USB otg
// 
// Parameters: 
//      pRegs - Pointer to USB Registers
//
// Return: 
//      NULL
//------------------------------------------------------------------------------------------------
void Stop(CSP_USB_REGS *pRegs)
{
    USB_USBCMD_T Cmd;
    DWORD *temp;           
	int nAttempts = 0;

	temp = (DWORD *)&Cmd;
    *temp = INREG32(&pRegs->OTG.USBCMD);
    Cmd.RS = RS_STOP;
    OUTREG32(&pRegs->OTG.USBCMD, *temp);
    while (((INREG32(&pRegs->OTG.USBCMD) & 0x1) == 0x1) && (nAttempts++ < 50) )
	{
    //RETAILMSG(1, (TEXT("USBCMD= 0x%x\r\n"), (INREG32(&(*regs)->OTG.USBCMD))));
         Sleep(10);
    }

}

//---------------------------------------------------------------------------------------------
// Function: SetMode 
//     - Sets otg mode to host or device controller
// 
// Parameters: 
//      pRegs - Pointer to USB Registers
//
// Return: 
//      NULL
//------------------------------------------------------------------------------------------------
void SetMode(CSP_USB_REGS *pRegs, UINT uCMMode)
{
    USB_USBMODE_T Mode;
    DWORD *temp;            

    temp = (DWORD *)&Mode;
    *temp = INREG32(&pRegs->OTG.USBMODE);
    Mode.CM = uCMMode;
	if(uCMMode == CM_DEVICE_CONTROLLER)
	{
		Mode.SLOM = SLOM_LOCKOUT_OFF;        // 2.3 hardware and later

	}
    OUTREG32(&pRegs->OTG.USBMODE, *temp);

    Sleep(10);
    if ((INREG32(&pRegs->OTG.USBMODE)& CM_HOST_CONTROLLER) != CM_HOST_CONTROLLER)
    {
        //RETAILMSG(1, (TEXT("USBMode setting failure\r\n")));
        return;
    }

}

//-----------------------------------------------------------------------------
//
//  Function: dumpCPLD
//
//  This function is to dump the CPLD information
//
//  Parameters:
//     cpld - Pointer to Mapped CPLD Register
//
//  Returns:
//      None
//
//-----------------------------------------------------------------------------
#ifdef DEBUG
void dumpCPLD(PCSP_PBC_REGS org_cpld)
{
    volatile PCSP_PBC_REGS  cpld;
    PHYSICAL_ADDRESS phyAddr;

    phyAddr.QuadPart = BSP_BASE_REG_PA_PBC_BASE;

    if (org_cpld == NULL)
    {
        cpld = (PCSP_PBC_REGS) MmMapIoSpace(phyAddr, sizeof(CSP_PBC_REGS), FALSE);
        if (cpld == NULL) {
            RETAILMSG(1, (TEXT("Problem in CPLD\r\n")));
            return;
        }       
    }
    else
        cpld = org_cpld;

    RETAILMSG(1,(L"Dump PBC registers:\r\n"));
    RETAILMSG(1,(L"\tVERSION=%x\r\n", INREG16(&cpld->VERSION)));
    RETAILMSG(1,(L"\tBCTRL1_SET=%x\r\n", INREG16(&cpld->BCTRL1_SET)));
    RETAILMSG(1,(L"\tBCTRL1_CLEAR=%x\r\n", INREG16(&cpld->BCTRL1_CLEAR)));
    RETAILMSG(1,(L"\tBCTRL2_SET=%x\r\n", INREG16(&cpld->BCTRL2_SET)));
    RETAILMSG(1,(L"\tBCTRL2_CLEAR=%x\r\n", INREG16(&cpld->BCTRL2_CLEAR)));
    RETAILMSG(1,(L"\tBCTRL3_SET=%x\r\n", INREG16(&cpld->BCTRL3_SET)));
    RETAILMSG(1,(L"\tBCTRL3_CLEAR=%x\r\n", INREG16(&cpld->BCTRL3_CLEAR)));
    RETAILMSG(1,(L"\tBCTRL4_SET=%x\r\n", INREG16(&cpld->BCTRL4_SET)));
    RETAILMSG(1,(L"\tBCTRL4_CLEAR=%x\r\n", INREG16(&cpld->BCTRL4_CLEAR)));
    RETAILMSG(1,(L"\tBSTAT1=%x\r\n", INREG16(&cpld->BSTAT1)));
    RETAILMSG(1,(L"\tINT_STATUS=%x\r\n", INREG16(&cpld->INT_STATUS)));
    RETAILMSG(1,(L"\tINT_CUR_STATUS=%x\r\n", INREG16(&cpld->INT_CUR_STATUS)));
    RETAILMSG(1,(L"\tINT_MASK_SET=%x\r\n", INREG16(&cpld->INT_MASK_SET)));
    RETAILMSG(1,(L"\tINT_MASK_CLEAR=%x\r\n", INREG16(&cpld->INT_MASK_CLEAR)));

    if (org_cpld == NULL) 
        MmUnmapIoSpace(cpld, sizeof(CSP_PBC_REGS));