//------------------------------------------------------------------------------
//
// Copyright (C) 2005-2007, 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)
//------------------------------------------------------------------------------

#pragma warning(push)
#pragma warning(disable: 4115 4201 4204 4214)
#include <windows.h>
#include <Winbase.h>
#include <ceddk.h>
#pragma warning(pop)

#include "bsp.h"
#include "MX31_usb.h"
#include "MX31_usbname.h"
#include "MX31_usbcommon.h"

#ifdef DEBUG

#define ZONE_FUNCTION         DEBUGZONE(3)

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("")
    },
    0xffff//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);
//-----------------------------------------------------------------------------
//
//  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: InitializeOTGMux
//
//  This function is to configure the IOMUX for USB OTG Core
//
//  Parameters:
//     NULL
//     
//  Returns:
//     NULL
//
//-----------------------------------------------------------------------------
static void InitializeOTGMux(void)
{

    //RETAILMSG(1, (TEXT("Configure OTG Mux\r\n")));
    //usb_otg_iomux_connection();
    DDKIomuxSetPinMux(DDK_IOMUX_PIN_USBOTG_DATA7, DDK_IOMUX_OUT_FUNC, DDK_IOMUX_IN_FUNC);
    DDKIomuxSetPinMux(DDK_IOMUX_PIN_USBOTG_DATA6, DDK_IOMUX_OUT_FUNC, DDK_IOMUX_IN_FUNC);
    DDKIomuxSetPinMux(DDK_IOMUX_PIN_USBOTG_DATA5, DDK_IOMUX_OUT_FUNC, DDK_IOMUX_IN_FUNC);
    DDKIomuxSetPinMux(DDK_IOMUX_PIN_USBOTG_DATA4, DDK_IOMUX_OUT_FUNC, DDK_IOMUX_IN_FUNC);
    DDKIomuxSetPinMux(DDK_IOMUX_PIN_USBOTG_DATA3, DDK_IOMUX_OUT_FUNC, DDK_IOMUX_IN_FUNC);
    DDKIomuxSetPinMux(DDK_IOMUX_PIN_USBOTG_DATA2, DDK_IOMUX_OUT_FUNC, DDK_IOMUX_IN_FUNC);
    DDKIomuxSetPinMux(DDK_IOMUX_PIN_USBOTG_DATA1, DDK_IOMUX_OUT_FUNC, DDK_IOMUX_IN_FUNC);
    DDKIomuxSetPinMux(DDK_IOMUX_PIN_USBOTG_DATA0, DDK_IOMUX_OUT_FUNC, DDK_IOMUX_IN_FUNC);
    DDKIomuxSetPinMux(DDK_IOMUX_PIN_USBOTG_NXT, DDK_IOMUX_OUT_FUNC, DDK_IOMUX_IN_FUNC);
    DDKIomuxSetPinMux(DDK_IOMUX_PIN_USBOTG_STP, DDK_IOMUX_OUT_FUNC, DDK_IOMUX_IN_FUNC);
    DDKIomuxSetPinMux(DDK_IOMUX_PIN_USBOTG_DIR, DDK_IOMUX_OUT_FUNC, DDK_IOMUX_IN_FUNC);
    DDKIomuxSetPinMux(DDK_IOMUX_PIN_USBOTG_CLK, DDK_IOMUX_OUT_FUNC, DDK_IOMUX_IN_FUNC);
#if 0
    DDKIomuxSetPinMux(DDK_IOMUX_PIN_USB_PWR, DDK_IOMUX_OUT_FUNC, DDK_IOMUX_IN_FUNC);
#endif

    DDKIomuxSetPadConfig(DDK_IOMUX_PAD_USBOTG_DATA0, DDK_IOMUX_PAD_SLEW_FAST,DDK_IOMUX_PAD_DRIVE_MAX, 
		DDK_IOMUX_PAD_MODE_CMOS, DDK_IOMUX_PAD_TRIG_CMOS, DDK_IOMUX_PAD_PULL_NONE);
    DDKIomuxSetPadConfig(DDK_IOMUX_PAD_USBOTG_DATA1, DDK_IOMUX_PAD_SLEW_FAST,DDK_IOMUX_PAD_DRIVE_MAX, 
		DDK_IOMUX_PAD_MODE_CMOS, DDK_IOMUX_PAD_TRIG_CMOS, DDK_IOMUX_PAD_PULL_NONE);
    DDKIomuxSetPadConfig(DDK_IOMUX_PAD_USBOTG_DATA2, DDK_IOMUX_PAD_SLEW_FAST,DDK_IOMUX_PAD_DRIVE_MAX, 
		DDK_IOMUX_PAD_MODE_CMOS, DDK_IOMUX_PAD_TRIG_CMOS, DDK_IOMUX_PAD_PULL_NONE);
    DDKIomuxSetPadConfig(DDK_IOMUX_PAD_USBOTG_DATA3, DDK_IOMUX_PAD_SLEW_FAST,DDK_IOMUX_PAD_DRIVE_MAX, 
		DDK_IOMUX_PAD_MODE_CMOS, DDK_IOMUX_PAD_TRIG_CMOS, DDK_IOMUX_PAD_PULL_NONE);
    DDKIomuxSetPadConfig(DDK_IOMUX_PAD_USBOTG_DATA4, DDK_IOMUX_PAD_SLEW_FAST,DDK_IOMUX_PAD_DRIVE_MAX, 
		DDK_IOMUX_PAD_MODE_CMOS, DDK_IOMUX_PAD_TRIG_CMOS, DDK_IOMUX_PAD_PULL_NONE);
    DDKIomuxSetPadConfig(DDK_IOMUX_PAD_USBOTG_DATA5, DDK_IOMUX_PAD_SLEW_FAST,DDK_IOMUX_PAD_DRIVE_MAX, 
		DDK_IOMUX_PAD_MODE_CMOS, DDK_IOMUX_PAD_TRIG_CMOS, DDK_IOMUX_PAD_PULL_NONE);
    DDKIomuxSetPadConfig(DDK_IOMUX_PAD_USBOTG_DATA6, DDK_IOMUX_PAD_SLEW_FAST,DDK_IOMUX_PAD_DRIVE_MAX, 
		DDK_IOMUX_PAD_MODE_CMOS, DDK_IOMUX_PAD_TRIG_CMOS, DDK_IOMUX_PAD_PULL_NONE);
    DDKIomuxSetPadConfig(DDK_IOMUX_PAD_USBOTG_DATA7, DDK_IOMUX_PAD_SLEW_FAST,DDK_IOMUX_PAD_DRIVE_MAX, 
		DDK_IOMUX_PAD_MODE_CMOS, DDK_IOMUX_PAD_TRIG_CMOS, DDK_IOMUX_PAD_PULL_NONE);
    DDKIomuxSetPadConfig(DDK_IOMUX_PAD_USBOTG_STP, DDK_IOMUX_PAD_SLEW_FAST,DDK_IOMUX_PAD_DRIVE_MAX, 
		DDK_IOMUX_PAD_MODE_CMOS, DDK_IOMUX_PAD_TRIG_CMOS, DDK_IOMUX_PAD_PULL_NONE);
// Not sure for last 3
    DDKIomuxSetPadConfig(DDK_IOMUX_PAD_USBOTG_NXT, DDK_IOMUX_PAD_SLEW_FAST,DDK_IOMUX_PAD_DRIVE_MAX, 
		DDK_IOMUX_PAD_MODE_CMOS, DDK_IOMUX_PAD_TRIG_CMOS, DDK_IOMUX_PAD_PULL_NONE);
    DDKIomuxSetPadConfig(DDK_IOMUX_PAD_USBOTG_DIR, DDK_IOMUX_PAD_SLEW_FAST,DDK_IOMUX_PAD_DRIVE_MAX, 
		DDK_IOMUX_PAD_MODE_CMOS, DDK_IOMUX_PAD_TRIG_CMOS, DDK_IOMUX_PAD_PULL_NONE);
    DDKIomuxSetPadConfig(DDK_IOMUX_PAD_USBOTG_CLK, DDK_IOMUX_PAD_SLEW_FAST,DDK_IOMUX_PAD_DRIVE_MAX, 
		DDK_IOMUX_PAD_MODE_CMOS, DDK_IOMUX_PAD_TRIG_CMOS, DDK_IOMUX_PAD_PULL_NONE);

#if 0 /*ERIC0524*/
    // reset pin
    DDKIomuxSetPinMux(DDK_IOMUX_PIN_USB_PWR, DDK_IOMUX_OUT_GPIO, DDK_IOMUX_IN_GPIO);
    DDKGpioSetConfig(DDK_GPIO_PORT1, 29, DDK_GPIO_DIR_OUT, DDK_GPIO_INTR_NONE);
    DDKGpioWriteDataPin(DDK_GPIO_PORT1, 29, 1);
#endif
    
    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;
}

#if 0
//-----------------------------------------------------------------------------
//
//  Function: dumpCPLD
//
//  This function is to dump the CPLD information
//
//  Parameters:
//     cpld - Pointer to Mapped CPLD Register
//
//  Returns:
//      None
//
//-----------------------------------------------------------------------------
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) {
            DEBUGMSG(ZONE_ERROR, (TEXT("Problem in CPLD\r\n")));
            return;
        }       
    }
    else
        cpld = org_cpld;

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

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

//-----------------------------------------------------------------------------
//
//  Function: InitializeCPLD
//
//  This function is to configure the CPLD to corresponding USB core
//
//  Parameters:
//     IsHost - TRUE: it is configured as USB Host
//            - FALSE: it is configured as USB client
//     
//  Returns:
//     TRUE: Success
//     FALSE: Failure
//
//-----------------------------------------------------------------------------
static int InitializeCPLD(BOOL IsHost)
{
    UNREFERENCED_PARAMETER(IsHost);
    return TRUE;
}

extern BOOL Initialize1504Client(CSP_USB_REGS * regs);
extern BOOL Initialize1504Host(CSP_USB_REGS * regs);

//-----------------------------------------------------------------------------
//
//  Function: DumpDeviceState
//
//  This function is to dump the device status
//
//  Parameters:
//     state - pointer to PORTSC register
//     
//  Returns:
//     NULL
//
//-----------------------------------------------------------------------------
static void DumpDeviceState( USB_PORTSC_T * state)  
{
    if (state->CCS)
        DEBUGMSG(ZONE_FUNCTION, (L"\t\tCurrent Connect Status: Attached\r\n"));
    if (state->CSC)
        DEBUGMSG(ZONE_FUNCTION, (L"\t\tConnect Status Change: Changed\r\n"));
    if (state->PE)
        DEBUGMSG(ZONE_FUNCTION, (L"\t\tPort Enabled\r\n"));
    if (state->PEC)
        DEBUGMSG(ZONE_FUNCTION, (L"\t\tPort Enable/Disable Change\r\n"));
    if (state->OCA)
        DEBUGMSG(ZONE_FUNCTION, (L"\t\tOver-current Active\r\n"));
    if (state->OCC)
        DEBUGMSG(ZONE_FUNCTION, (L"\t\tOver-current Change\r\n"));
    if (state->FPR)
        DEBUGMSG(ZONE_FUNCTION, (L"\t\tForce Port Resume\r\n"));
    if (state->SUSP)
        DEBUGMSG(ZONE_FUNCTION, (L"\t\tSuspend\r\n"));
    if (state->PR)
        DEBUGMSG(ZONE_FUNCTION, (L"\t\tPort Reset\r\n"));
    if (state->HSP)
        DEBUGMSG(ZONE_FUNCTION, (L"\t\tHigh-Speed Port \r\n"));
    
    DEBUGMSG(ZONE_FUNCTION, (L"\t\tLine Status: %x", state->LS));
    switch (state->LS) {
        case 0:
            DEBUGMSG(ZONE_FUNCTION, (L"\t\t\tSE0\r\n"));
            break;
        case 1:
            DEBUGMSG(ZONE_FUNCTION, (L"\t\t\tJ-state\r\n"));
            break;
        case 2:
            DEBUGMSG(ZONE_FUNCTION, (L"\t\t\tK-state\r\n"));
            break;
        case 3: 
        default:
            DEBUGMSG(ZONE_FUNCTION, (L"\t\t\tUndefined\r\n"));
            break;
    }

    if (state->PP)
        DEBUGMSG(ZONE_FUNCTION, (L"\t\t??? Should be 0 for device\r\n"));
    if (state->PO)
        DEBUGMSG(ZONE_FUNCTION, (L"\t\tPort Owner\r\n"));
    if (state->PIC) {
        DEBUGMSG(ZONE_FUNCTION, (L"\t\tPort Indicator Control"));
        switch (state->PIC) {
            case 1:
                DEBUGMSG(ZONE_FUNCTION, (L"\t\t\tAmber\r\n"));
                break;
            case 2:
                DEBUGMSG(ZONE_FUNCTION, (L"\t\t\tGreen\r\n"));
                break;
            case 3:
            default:
                DEBUGMSG(ZONE_FUNCTION, (L"\t\t\tUndefined\r\n"));
                break;
        }
    }   
    if (state->PTC) 
        DEBUGMSG(ZONE_FUNCTION, (L"\t\tPort Test Control: %x\r\n", state->PTC));
        
    if (state->WKCN) 
        DEBUGMSG(ZONE_FUNCTION, (L"\t\tWake on Connect Enable (WKCNNT_E)\r\n"));
                        
    if (state->WKDC) 
        DEBUGMSG(ZONE_FUNCTION, (L"\t\tWake on Disconnect Enable (WKDSCNNT_E) \r\n"));

    if (state->WKOC) 
        DEBUGMSG(ZONE_FUNCTION, (L"\t\tWake on Over-current Enable (WKOC_E) \r\n"));
    
    if (state->PHCD) 
        DEBUGMSG(ZONE_FUNCTION, (L"\t\tPHY Low Power Suspend - Clock Disable (PLPSCD) \r\n"));

    if (state->PFSC) 
        DEBUGMSG(ZONE_FUNCTION, (L"\t\tPort Force Full Speed Connect \r\n"));

    DEBUGMSG(ZONE_FUNCTION, (L"\t\tPort Speed: %x->", state->PSPD));
    switch (state->PSPD) {
        case 0:
            DEBUGMSG(ZONE_FUNCTION, (L"\t\t\tFull Speed\r\n"));
            break;
        case 1:
            DEBUGMSG(ZONE_FUNCTION, (L"\t\t\tLow Speed\r\n"));
            break;
        case 2:
            DEBUGMSG(ZONE_FUNCTION, (L"\t\t\tHigh Speed\r\n"));
            break;
        case 3:
        default:
            DEBUGMSG(ZONE_FUNCTION, (L"\t\t\tUndefined\r\n"));
            break;
    }
    DEBUGMSG(ZONE_FUNCTION, (L"\t\tParallel Transceiver Width:%x->", state->PTW));
    if (state->PTW) 
        DEBUGMSG(ZONE_FUNCTION, (L"\t\t\t16 bits\r\n"));
    else
        DEBUGMSG(ZONE_FUNCTION, (L"\t\t\t8 bits\r\n"));
    if (state->STS) 
        DEBUGMSG(ZONE_FUNCTION, (L"\t\tSerial Transceiver Select \r\n"));
    
    DEBUGMSG(ZONE_FUNCTION, (L"\t\tParallel Transceiver Select:%x->", state->PTS));
    switch (state->PTS) {
        case 0:
            DEBUGMSG(ZONE_FUNCTION, (L"\t\t\tUTMI/UTMI+\r\n"));
            break;
        case 1:
            DEBUGMSG(ZONE_FUNCTION, (L"\t\t\tPhilips Classic\r\n"));
            break;
        case 2:
            DEBUGMSG(ZONE_FUNCTION, (L"\t\t\tULPI\r\n"));
            break;
        case 3:
            DEBUGMSG(ZONE_FUNCTION, (L"\t\t\tSerial/1.1 PHY (FS Only)\r\n"));
            break;
        default:
            DEBUGMSG(ZONE_FUNCTION, (L"\t\t\tUndefined\r\n"));
            break;
    }                   
}

#ifdef DEBUG
//-----------------------------------------------------------------------------
//
//  Function: DumpUSBRegs
//
//  This function is to dump the USB OTG Register detail
//
//  Parameters:
//     regs - Pointer to 3 USB Core Register
//     
//  Returns:
//     NULL
//
//-----------------------------------------------------------------------------
void DumpUSBRegs(PCSP_USB_REGS regs)
{
    static USHORT first=1;
    CSP_USB_REG *pReg;
    
    RETAILMSG(1, (L"Dump OTG Regs\r\n"));
    pReg=(PCSP_USB_REG)(&(regs->OTG));

    if (first) {
        RETAILMSG(1,(L"\tID(%xh)=%x\r\n",offset(CSP_USB_REG,ID), INREG32(&pReg->ID)));
        RETAILMSG(1,(L"\tHWGENERAL(%xh)=%x\r\n",offset(CSP_USB_REG,HWGENERAL),INREG32(&pReg->HWGENERAL)));
        RETAILMSG(1,(L"\tHWHOST(%xh)=%x\r\n",offset(CSP_USB_REG,HWHOST),INREG32(&pReg->HWHOST)));
        RETAILMSG(1,(L"\tHWDEVICE(%xh)=%x\r\n",offset(CSP_USB_REG,HWDEVICE),INREG32(&pReg->HWDEVICE)));
        RETAILMSG(1,(L"\tHWTXBUF(%xh)=%x\r\n",offset(CSP_USB_REG,HWTXBUF),INREG32(&pReg->HWTXBUF)));
        RETAILMSG(1,(L"\tHWRXBUF(%xh)=%x\r\n",offset(CSP_USB_REG,HWRXBUF),INREG32(&pReg->HWRXBUF)));
        RETAILMSG(1,(L"\tCAPLENGTH(%xh)=%x\r\n",offset(CSP_USB_REG,CAPLENGTH),INREG8(&pReg->CAPLENGTH)));
        RETAILMSG(1,(L"\tHCIVERSION(%xh)=%x\r\n",offset(CSP_USB_REG,HCIVERSION),INREG16(&pReg->HCIVERSION)));
        RETAILMSG(1,(L"\tHCSPARAMS(%xh)=%x\r\n",offset(CSP_USB_REG,HCSPARAMS),INREG32(&pReg->HCSPARAMS)));
        RETAILMSG(1,(L"\tHCCPARAMS(%xh)=%x\r\n",offset(CSP_USB_REG,HCCPARAMS),INREG32(&pReg->HCCPARAMS)));
        RETAILMSG(1,(L"\tDCIVERSION(%xh)=%x\r\n",offset(CSP_USB_REG,DCIVERSION),INREG16(&pReg->DCIVERSION)));
        RETAILMSG(1,(L"\tDCCPARAMS(%xh)=%x\r\n",offset(CSP_USB_REG,DCCPARAMS),INREG32(&pReg->DCCPARAMS)));
        first=0;
    }   
    RETAILMSG(1,(L"\tUSBCMD(%xh)=%x\r\n",offset(CSP_USB_REG,USBCMD),INREG32(&pReg->USBCMD)));
    RETAILMSG(1,(L"\tUSBSTS(%xh)=%x\r\n",offset(CSP_USB_REG,USBSTS),INREG32(&pReg->USBSTS)));
    RETAILMSG(1,(L"\tUSBINTR(%xh)=%x\r\n",offset(CSP_USB_REG,USBINTR),INREG32(&pReg->USBINTR)));
    RETAILMSG(1,(L"\tPORTSC(%xh)[0]=%x\r\n",offset(CSP_USB_REG,PORTSC[0]),INREG32(&pReg->PORTSC[0])));
    {
        USB_PORTSC_T state;
        DWORD * temp=(DWORD*)&state;
        *temp=INREG32(&pReg->PORTSC[0]);
        DumpDeviceState( & state);
    }
    RETAILMSG(1,(L"\tOTGSC(%xh)=%x\r\n",offset(CSP_USB_REG,OTGSC),INREG32(&pReg->OTGSC)));
    RETAILMSG(1,(L"\tUSBMODE(%xh)=%x\r\n",offset(CSP_USB_REG,USBMODE),INREG32(&pReg->USBMODE)));
    RETAILMSG(1,(L"\tULPI_VIEWPORT(%xh)=%x\r\n",offset(CSP_USB_REG,ULPI_VIEWPORT),INREG32(&pReg->ULPI_VIEWPORT)));

    RETAILMSG(1,(L"\t*********************\r\n"));
    RETAILMSG(1,(L"\tAddress of ASYNCLISTADDR at 0x%x\r\n", &pReg->T_158H.ASYNCLISTADDR));
    RETAILMSG(1,(L"\tASYNCLISTADDR(%xh)=%x\r\n",offset(CSP_USB_REG,T_158H),INREG32(&pReg->T_158H.ASYNCLISTADDR)));
    RETAILMSG(1,(L"\tENDPTSETUPSTAT(%xh)=%x\r\n",offset(CSP_USB_REG,ENDPTSETUPSTAT),INREG32(&pReg->ENDPTSETUPSTAT)));
    RETAILMSG(1,(L"\tENDPTPRIME(%xh)=%x\r\n",offset(CSP_USB_REG,ENDPTPRIME),INREG32(&pReg->ENDPTPRIME)));
    RETAILMSG(1,(L"\tENDPTFLUSH(%xh)=%x\r\n",offset(CSP_USB_REG,ENDPTFLUSH),INREG32(&pReg->ENDPTFLUSH)));
    RETAILMSG(1,(L"\tENDPTSTATUS(%xh)=%x\r\n",offset(CSP_USB_REG,ENDPTSTATUS),INREG32(&pReg->ENDPTSTATUS)));
    RETAILMSG(1,(L"\tENDPTCOMPLETE(%xh)=%x\r\n",offset(CSP_USB_REG,ENDPTCOMPLETE),INREG32(&pReg->ENDPTCOMPLETE)));
    RETAILMSG(1,(L"\tENDPTCTRL0(%xh)=%x\r\n",offset(CSP_USB_REG,ENDPTCTRL0),INREG32(&pReg->ENDPTCTRL0)));
    RETAILMSG(1,(L"\t*********************\r\n"));
    
    RETAILMSG(1,(L"\tUSB_CTRL(%xh)=%x\r\n",offset(CSP_USB_REGS,USB_CTRL),INREG32(&regs->USB_CTRL)));
    RETAILMSG(1,(L"\tUSB_OTG_MIRROR(%xh)=%x\r\n",offset(CSP_USB_REGS,USB_OTG_MIRROR),INREG32(&regs->USB_OTG_MIRROR)));

}

#endif // if debug

//-----------------------------------------------------------------------------
//
//  Function: ConfigOTGHost
//
//  This function is to configure host functionality on the USB OTG Core.
//
//  Parameters:
//     pRegs - Pointer to 3 USB Core Registers
//     
//  Returns:
//     NULL
//
//-----------------------------------------------------------------------------
static void ConfigOTGHost(CSP_USB_REGS *pRegs)
{
    USB_PORTSC_T portsc;
    USB_CTRL_T   ctrl;
    USB_USBMODE_T mode;
    USB_USBCMD_T cmd;
    DWORD *temp;
            

    //RETAILMSG(1, (TEXT("ConfigOTGHost\r\n")));
    //usb_otg_ulpi_interface_configure
    temp  = (DWORD *)&portsc;
    *temp = INREG32(&pRegs->OTG.PORTSC);
    portsc.LS  = 0x2;
    portsc.PTS = 0x2;
    OUTREG32(&pRegs->OTG.PORTSC, *temp);

    // usb_ulpi_interrupt_enable
    temp  = (DWORD *)&ctrl;
    *temp = INREG32(&pRegs->USB_CTRL);
    ctrl.OUIE = 1;
    OUTREG32(&pRegs->USB_CTRL, *temp);

    // usb_otg_interrupt_enable
    temp = (DWORD *)&ctrl;
    *temp = INREG32(&pRegs->USB_CTRL);
    ctrl.OWIE = 1;
    OUTREG32(&pRegs->USB_CTRL, *temp);

    // usb_otg_power_mask_enable
    temp = (DWORD *)&ctrl;
    *temp = INREG32(&pRegs->USB_CTRL);
    ctrl.OPM = 1;
    OUTREG32(&pRegs->USB_CTRL, *temp);

    // usb_bypass_inactive
    temp = (DWORD *)&ctrl;  
    *temp=0;
    ctrl.BPE=1;     //  Bypass Enable bit, clear it
    CLRREG32(&pRegs->USB_CTRL, *temp);

    // otg_setmode
    temp = (DWORD *)&cmd;
    *temp = INREG32(&pRegs->OTG.USBCMD);
    cmd.RST = 1;
    OUTREG32(&pRegs->OTG.USBCMD, *temp);
    
    while (INREG32(&pRegs->OTG.USBCMD)& (0x1 << 1))
    {
        //RETAILMSG(1, (TEXT("USBCMD = 0x%x\r\n"), INREG32(&pRegs->OTG.USBCMD)));
        Sleep(1000);
    }

    temp = (DWORD *)&mode;
    *temp = INREG32(&pRegs->OTG.USBMODE);
    mode.CM = 0x3;
    OUTREG32(&pRegs->OTG.USBMODE, *temp);

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

    // otg_power_on_port1
    if (INREG32(&pRegs->OTG.HCSPARAMS) &(0x1 << 4))
    {
        DWORD mask = (0x1<<1) + (0x1<<3)+(0x1<<5);
        CLRREG32(&pRegs->OTG.PORTSC, mask);
        temp = (DWORD *)&portsc;
        *temp = INREG32(&pRegs->OTG.PORTSC);
        portsc.PP = 1;      
        OUTREG32(&pRegs->OTG.PORTSC, *temp);
    }
    else
        DEBUGMSG(ZONE_FUNCTION, (TEXT("Host does not control power\r\n")));

    //otg_controller_reset
    temp=(DWORD *)&cmd; 
    *temp=0;
    cmd.RST=1;  
    CLRREG32(&pRegs->OTG.USBCMD, *temp);
    *temp = INREG32(&pRegs->OTG.USBCMD);
    cmd.RST=1;
    OUTREG32(&pRegs->OTG.USBCMD, *temp);
    while (INREG32(&pRegs->OTG.USBCMD) & (0x1 << 1));

    temp = (DWORD *)&mode;
    *temp = INREG32(&pRegs->OTG.USBMODE);
    mode.CM = 0x3;
    OUTREG32(&pRegs->OTG.USBMODE, *temp);

    Sleep(10);  
    while ((INREG32(&pRegs->OTG.USBMODE)& 0x3) != 0x3);
}

//-----------------------------------------------------------------------------
//
//  Function: ConfigOTGClient
//
//  This function is to configure client functionality on the USB OTG Core.
//
//  Parameters:
//     pRegs - Pointer to 3 USB Core Registers
//     
//  Returns:
//     NULL
//
//-----------------------------------------------------------------------------
static void ConfigOTGClient(CSP_USB_REGS *regs)
{
    USB_PORTSC_T port;
    USB_USBMODE_T mode;
    USB_USBCMD_T cmd;
    USB_HCSPARAMS_T hcs;
    DWORD *temp;

    DEBUGMSG(ZONE_FUNCTION, (TEXT("ConfigOTGClient: Stop controller\r\n")));
    // Stop the controller first
    {
        temp = (DWORD *)&cmd;
        *temp = INREG32(&regs->OTG.USBCMD);
        cmd.RS = 0;
        OUTREG32(&regs->OTG.USBCMD, *temp);
        while ((INREG32(&regs->OTG.USBCMD) & 0x1) == 0x1){
            //DEBUGMSG(ZONE_FUNCTION, (TEXT("USBCMD= 0x%x\r\n"), (INREG32(&(*regs)->OTG.USBCMD))));
            Sleep(100);
        }
    }

    DEBUGMSG(ZONE_FUNCTION, (TEXT("ConfigOTGClient: Reset\r\n")));
    // Do a reset first no matter what
    {
        temp = (DWORD *)&cmd;
        *temp = INREG32(&regs->OTG.USBCMD);
        cmd.RST = 1;
        OUTREG32(&regs->OTG.USBCMD, *temp);
        while ((INREG32(&regs->OTG.USBCMD) & 0x1<<1) == (0x1<<1)){
            //DEBUGMSG(ZONE_FUNCTION, (TEXT("USBCMD= 0x%x\r\n"), (INREG32(&(*regs)->OTG.USBCMD))));
            Sleep(100);
        }
    }

    // Enable power for OTG on port 1
    temp=(DWORD *)&hcs;
    *temp=INREG32(&regs->OTG.HCSPARAMS);
    if (hcs.PPC) {
        WORD USB_OTG_PORTSC1_Write_MASK = (0x1<<1)+(0x1<<3)+(0x1<<5);   
        *temp=INREG32(&regs->OTG.PORTSC[0]);
        *temp&=~USB_OTG_PORTSC1_Write_MASK;
        *temp|=1<<12;
        SETREG32(&regs->OTG.PORTSC[0], *temp);
    }
        
    // reset the usb otg
    SETREG32(&regs->OTG.USBCMD, (1<<1));
    while(INREG32(&regs->OTG.USBCMD) & (0x1<<1));
        
    // Set USB Mode 
    temp=(DWORD *)&mode;
    *temp=0;
    //DEBUGMSG(ZONE_FUNCTION, (TEXT("Set USB Mode to 2\r\n")));
    mode.CM=2;
    mode.SLOM=1;        // 2.3 hardware and later

    OUTREG32(&regs->OTG.USBMODE, *temp);
        
    // otg_itc_setup(0);
    temp=(DWORD *)&cmd;
    *temp=INREG32(&regs->OTG.USBCMD);
    cmd.ITC=0;
    OUTREG32(&regs->OTG.USBCMD, *temp);

    // otg_frindex_setup(1);
    OUTREG32(&regs->OTG.FRINDEX, 1);

    // otg_set_configflag_on();
    OUTREG32(&regs->OTG.CONFIGFLAG, 1);


    // for debug, just check the Port Reset bit
    temp=(DWORD *)&port;
    *temp=INREG32(&regs->OTG.PORTSC[0]);
    DEBUGMSG(ZONE_FUNCTION,(TEXT("ConfigOTGClient: PORTSC 0x%x PR=%d\r\n"), *temp, port.PR));


    //DEBUGMSG(ZONE_FUNCTION, (TEXT("Initialize1504 OTG HighSpeed Client\r\n")));
    //DumpUSBRegs((PCSP_USB_REGS)(regs));
    Initialize1504Client(regs); 

}

//-----------------------------------------------------------------------------
//
//  Function: InitializeOTGTransceiver
//
//  This function is to configure the OTG USB Core.
//
//  Parameters:
//     pRegs - Pointer to 3 USB Core Registers
//     IsHost - TRUE: it is configured as host
//              FALSE: it is configured as client
//     
//  Returns:
//     TRUE: Success
//     FALSE: Failure
//
//-----------------------------------------------------------------------------
BOOL InitializeOTGTransceiver(PCSP_USB_REGS* regs, BOOL IsHost)
{
        // Clear USB Interrupt enable registers
    OUTREG32(&(*regs)->OTG.USBINTR, 0);

    InitializeCPLD(IsHost);
    
    InitializeMux();  
    USBClockInit();
    
    if (IsHost) 
    {
        // Stop the controller first
        {
            USB_USBCMD_T cmd;           
            USB_USBSTS_T sts;
            USB_USBMODE_T mode;
            DWORD * temp = (DWORD *)&cmd;
            DWORD * temp2 = (DWORD*)&sts;
            DWORD *pTmpMode = (DWORD*)&mode;
            int nAttempts = 0;

            *temp = INREG32(&(*regs)->OTG.USBCMD);
            cmd.RS = 0;
            OUTREG32(&(*regs)->OTG.USBCMD, *temp);

            *pTmpMode = INREG32(&(*regs)->OTG.USBMODE);
            if ( mode.CM == 0x3 )
            {
                *temp2 = INREG32(&(*regs)->OTG.USBSTS);
                while ( (sts.HCH == 0) && (nAttempts++ < 50) )
                {
                    Sleep(10);
                    *temp2 = INREG32(&(*regs)->OTG.USBSTS);
                }
            }
        }

        // Do a reset first no matter what
        {
            USB_USBCMD_T cmd;           
            DWORD * temp = (DWORD *)&cmd;

            *temp = INREG32(&(*regs)->OTG.USBCMD);

            cmd.RST = 1;
            OUTREG32(&(*regs)->OTG.USBCMD, *temp);

            *temp = INREG32(&(*regs)->OTG.USBCMD);

            while ( cmd.RST )
            {
                //DEBUGMSG(ZONE_FUNCTION, (TEXT("USBCMD= 0x%x\r\n"), (INREG32(&(*regs)->OTG.USBCMD))));
                Sleep(10);
                *temp = INREG32(&(*regs)->OTG.USBCMD);
            }
        }

        // actually set the mode to HOST now
        {
            USB_USBMODE_T mode;
            DWORD *temp = (DWORD *)&mode;
            temp = (DWORD *)&mode;
            *temp = INREG32(&(*regs)->OTG.USBMODE);
            mode.CM = 0x3;
            OUTREG32(&(*regs)->OTG.USBMODE, *temp);
        }

        ConfigOTGHost(*regs);
        {   //usb_bypass_inactive()
            USB_CTRL_T ctrl;
            DWORD * temp=(DWORD *)&ctrl;
        
            *temp=0;
            ctrl.BPE=1;     //  Bypass Enable bit, clear it
            CLRREG32(&(*regs)->USB_CTRL, *temp);
        }

        {
            USB_USBMODE_T mode;
            DWORD * temp=(DWORD *)&mode;
        
            // Set USB Mode 
            *temp=0;
            mode.CM=3;      // Host 

            //DEBUGMSG(ZONE_FUNCTION, (TEXT("USBMode:H1[0x%x], H2[0x%x], OTG[0x%x]\r\n"), 
            //INREG32(&(*regs)->H1.USBMODE),INREG32(&(*regs)->H2.USBMODE), INREG32(&(*regs)->OTG.USBMODE)));

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

        //DEBUGMSG(ZONE_FUNCTION, (TEXT("PowerOnPort\r\n")));

        // power on port
        {
            DWORD *temp;
            USB_HCSPARAMS_T hcs;
            temp=(DWORD *)&hcs;
            *temp=INREG32(&(*regs)->OTG.HCSPARAMS);

            if (hcs.PPC) 
            {
                USB_PORTSC_T portsc;
                DWORD * temp2= (DWORD *)&portsc;

                *temp2 = INREG32(&(*regs)->OTG.PORTSC);
                portsc.PP = 1;
                SETREG32(&(*regs)->OTG.PORTSC, *temp2);
            }   
        }

        //DEBUGMSG(ZONE_FUNCTION, (TEXT("Initialize1504 Host\r\n")));
        Initialize1504Host(*regs);
    }
    else
    {
        ConfigOTGClient(*regs);

        // Reset all interrupts
        {
            USB_USBSTS_T temp;
            DWORD       *t=(DWORD*)&temp;
            *t=0;
            temp.UI=1;   temp.UEI=1; temp.PCI=1; temp.FRI=1; 
            temp.SEI=1; temp.AAI=1; temp.URI=1; temp.SRI=1;
            temp.SLI=1; temp.ULPII=1;
            OUTREG32(&(*regs)->OTG.USBSTS, *t);
        }
    }

    // Last to do: Enable the ID Pin Interrupt in OTGSC
    {
        USB_OTGSC_T temp;
        DWORD       *t = (DWORD *)&temp;

        *t = INREG32(&(*regs)->OTG.OTGSC);
        temp.IDIE = 1;
        OUTREG32(&(*regs)->OTG.OTGSC, *t);
    }

    return TRUE;
}

//-----------------------------------------------------------------------------
//
//  Function: GetSysIntr
//
//  This function is to return the SYSINTR value of the USB OTG Core.
//
//  Parameters:
//     NULL
//     
//  Returns:
//     SYSINTR_USBOTG
//
//-----------------------------------------------------------------------------
DWORD GetSysIntr(void)
{
    return SYSINTR_USBOTG;
}


//-------------------------------------------------------------------------------------------------------
// Function: BSPUsbXvrSetPhyPowerMode - function for platform to call when they want to suspend/resume 
//			 the PHY
//
// Parameters: 
//      1) regs - USB registers
//      2) bResume - TRUE - request to resume, FALSE - request suspend
//
// Return: 
//      NULL
//-----------------------------------------------------------------------------------------------------------
static void BSPUsbXvrSetPhyPowerMode(CSP_USB_REGS *pUSBRegs, BOOL bResume)
{
    DEBUGMSG(ZONE_FUNCTION, (TEXT("BSPUsbXvrSetPhyPowerMode bResume = %d\r\n"),bResume));
    if (bResume)
    {
        if (INREG32(&pUSBRegs->OTG.PORTSC[0]) & 0x800000)
        {
            // Clear the PHCD
            CLRREG32(&pUSBRegs->OTG.PORTSC[0], INREG32(&pUSBRegs->OTG.PORTSC[0]) & 0x800000);
            // Force Resume bit
            OUTREG32(&pUSBRegs->OTG.PORTSC[0], INREG32(&pUSBRegs->OTG.PORTSC[0])|0x40); 
            //DEBUGMSG(ZONE_FUNCTION, (TEXT("Force resume\r\n")));
        }
    }
    else
    {
        USB_PORTSC_T portsc;
        DWORD *temp = (DWORD *)&portsc;

        *temp = INREG32(&(pUSBRegs)->OTG.PORTSC);
        portsc.PHCD = 1;
        OUTREG32(&(pUSBRegs)->OTG.PORTSC, *temp);
    }
}

//---------------------------------------------------------------------------------------------
// Function: RegisterCallback - function call by XVC to register the callback function during the 
//			 XVC_Init.
// 
// Parameters: 
//      Pointer to USB Callback function pointers
//
// Return: 
//      NULL
//------------------------------------------------------------------------------------------------
void RegisterCallback(BSP_USB_CALLBACK_FNS *pfn)
{
    DEBUGMSG(ZONE_FUNCTION, (TEXT("+RegisterCallback\r\n")));
    if (pfn)
    {
        pfn->pfnUSBPowerDown = NULL;
        pfn->pfnUSBPowerUp = NULL;
        //pfn->pfnUSBPowerUp = BSPUsbXvrPowerUp;
        //pfn->pfnUSBPowerDown = BSPUsbXvrPowerDown;
        pfn->pfnUSBSetPhyPowerMode = BSPUsbXvrSetPhyPowerMode;
        DEBUGMSG(ZONE_FUNCTION, (TEXT("RegisterCallback for XVC\r\n")));
    }
    DEBUGMSG(ZONE_FUNCTION, (TEXT("-RegisterCallback\r\n")));
}