isp1504_ulpi.c

freescale i.mx31 BSP CE5.0全部源码

/*------------------------------------------------------------------------------
 * Copyright (C) 2005-2006, Freescale Semiconductor, Inc. All Rights Reserved.
 * THIS SOURCE CODE IS CONFIDENTIAL AND PROPRIETARY AND MAY NOT
 * BE USED OR DISTRIBUTED WITHOUT THE WRITTEN PERMISSION OF
 * Freescale Semiconductor, Inc.
 *----------------------------------------------------------------------------*/ 

/*
 *  File:     ISP1504_ULPI.c
 *  Purpose:  Common routines for manipulating ISP1504 controller
 *  Functions: WakeUpULPI   - initiate wakeup on suspended 1504 transceiver
 *           The following 3 functions access transceiver directly via ULPI and
 *           must be coordinated with host/device controller access to ULPI.
 *           Controller should be stopped to avoid ULPI bus clash.
 *             ISP1504_ReadReg()     read a transceiver register via viewport
 *             ISP1504_WriteReg()    write a transceiver register via viewport
 *             DumpULPIRegs  - diagnostic dump of transceiver registers
 */
#include <windows.h>
#include <Winbase.h>
#include <ceddk.h>
#include "bsp.h"
#include "mx31_usbcommon.h"

extern WORD BSPGetUSBControllerType(void);
//-----------------------------------------------------------------------------
//
//  Function: WakeUpULPI
//
//  This function is to wakeup the ULPI if it is suspend through viewport
//
//  Parameters:
//     reg - Pointer to the corresponding ULPI viewport registers
//     
//  Returns:
//     TRUE - success, FALSE - failure
//
//-----------------------------------------------------------------------------

static BOOL WakeUpULPI(volatile DWORD *reg)
{
    USB_ULPI_VIEWPORT_T ulpi;
    int i;
    DWORD * temp = (DWORD *)&ulpi;
    
    *temp = INREG32(reg);    
    if (ulpi.ULPISS == 0)
    {
        *temp = 0;
        ulpi.ULPIWU = 1;
        ulpi.ULPIRUN = 0;
        OUTREG32(reg, *temp);
        for (i = 0; i < 2000; i++) {
            *temp = INREG32(reg);
            if (ulpi.ULPIWU == 0)
                return TRUE;
            Sleep(0);
        }
        *temp = INREG32(reg);
        if (ulpi.ULPIWU == 1)
        {
            DEBUGMSG(1, (TEXT("WakeUpULPI return FALSE\r\n")));
            return FALSE;
        }
    }
    return TRUE;
}

//-----------------------------------------------------------------------------
//
//  Function: ISP1504_ReadReg
//
//  This function is to read the value of ULPI transceiver via viewport
//
//  Parameters:
//     reg - Pointer to the ULPI viewport register
//     idx - Offset of the ULPI viewport register want to access.
//     Refer to mx31_usbcommon.h in csp\arm\freescale\mx31\inc for full list
//     
//  Returns:
//     value in the register in unsigned character format.
//     0 - indicate failure
//
//-----------------------------------------------------------------------------

UCHAR ISP1504_ReadReg(volatile DWORD * reg, UCHAR idx)
{
	USB_ULPI_VIEWPORT_T ulpi;
	DWORD * temp=(DWORD *)&ulpi;
    int iAttempts;
	
    WakeUpULPI(reg);
	*temp=0;
	ulpi.ULPIRUN=1;
	ulpi.ULPIADDR=idx;
 	OUTREG32(reg, *temp);	

    iAttempts = 0;
    do {
        Sleep(0);
        *temp = INREG32(reg);
        
        if ( !ulpi.ULPIRUN )
            return ulpi.ULPIDATRD;

    } while ( iAttempts++ < 1000 );

    RETAILMSG(1,(TEXT("Port(%d):ISP1504_ReadReg: ############ Error -- failed to read ULPI reg %d\r\n"),BSPGetUSBControllerType(), idx));

	return 0;
}

//-----------------------------------------------------------------------------
//
//  Function: ISP1504_WriteReg
//
//  This function is to write the data to register of ULPI transceiver via viewport
//
//  Parameters:
//     reg - Pointer to the ULPI viewport register
//     idx - Offset of the ULPI viewport register want to access.
//     Refer to mx31_usbcommon.h in csp\arm\freescale\mx31\inc for full list
//     data - Data to be written
//     
//  Returns:
//     TRUE - success, FALSE - failure
//
//-----------------------------------------------------------------------------

BOOL ISP1504_WriteReg(volatile DWORD * reg, UCHAR idx, UCHAR data)
{
	USB_ULPI_VIEWPORT_T ulpi;
	DWORD * temp=(DWORD *)&ulpi;
    int iAttempts;

    WakeUpULPI(reg);
	*temp=0;
	ulpi.ULPIRUN=1;
	ulpi.ULPIADDR=idx;
	ulpi.ULPIRW=1;
	ulpi.ULPIDATWR=data;
 	OUTREG32(reg, *temp);	

    iAttempts = 0;
    do {
        Sleep(0);
        *temp = INREG32(reg);

        if ( !ulpi.ULPIRUN )
            return TRUE;

    } while ( iAttempts++ < 1000 );

    RETAILMSG(1,(TEXT("Port (%d):ISP1504_WriteReg: ############ Error -- failed to write ULPI reg %d\r\n"),BSPGetUSBControllerType(), idx));
    return FALSE;
}

//-----------------------------------------------------------------------------
//
//  Function: DumpULPIRegs
//
//  This function is to dump the ULPI register for debug purpose
//
//  Parameters:
//     regs - Pointer to the 3 USB Core Registers
//     
//  Returns:
//     NULL
//
//-----------------------------------------------------------------------------

void DumpULPIRegs(CSP_USB_REGS * regs)
{
    volatile CSP_USB_REG *pReg;
    // Read the ID
    WORD sel = BSPGetUSBControllerType();
    
    if (sel == USB_SEL_OTG)
        pReg = &regs->OTG;
    else if (sel == USB_SEL_H2)
        pReg = &regs->H2;
    else
        return;

    RETAILMSG(1, (L"Dump PORTSC (0x%x)\r\n", INREG32(&pReg->PORTSC[0])));
    RETAILMSG(1, (L"Dump ULPI registers(%x)\r\n", INREG32(&pReg->ULPI_VIEWPORT)));    
    RETAILMSG(1, (L"\tULPI_VID=(%x,%x)\r\n", 
            ISP1504_ReadReg(&pReg->ULPI_VIEWPORT, ISP1504_VENDERID_LOW_R),
            ISP1504_ReadReg(&pReg->ULPI_VIEWPORT, ISP1504_VENDERID_HIGH_R)));
    RETAILMSG(1, (L"\tULPI_PID=(%x,%x)\r\n", 
            ISP1504_ReadReg(&pReg->ULPI_VIEWPORT, ISP1504_PRODUCT_LOW_R),
            ISP1504_ReadReg(&pReg->ULPI_VIEWPORT, ISP1504_PRODUCT_HIGH_R)));

    // XCVR Select[1:0]=00, Term Select[2]=0, OP Mode[4:3]=00
//      ISP1504_WriteReg(&pReg->ULPI_VIEWPORT, ISP1504_FUNCTION_CTRL_C, 0x1f);
    RETAILMSG(1, (L"\tFunction Control(%x)=%x\r\n", 
            ISP1504_FUNCTION_CTRL_RW,
            ISP1504_ReadReg(&pReg->ULPI_VIEWPORT, ISP1504_FUNCTION_CTRL_RW)));
    RETAILMSG(1, (L"\tInterface Control(%x)=%x\r\n", 
            ISP1504_INTERFACE_CTRL_RW,
            ISP1504_ReadReg(&pReg->ULPI_VIEWPORT, ISP1504_INTERFACE_CTRL_RW)));
    // DP_PullDown[1]=0, DM_PullDown[2]=0
//      ISP1504_WriteReg(&pReg->ULPI_VIEWPORT, ISP1504_OTG_CTRL_C, 0x6);
    RETAILMSG(1, (L"\tOTG Control(%x)=%x\r\n", 
            ISP1504_OTG_CTRL_RW,
            ISP1504_ReadReg(&pReg->ULPI_VIEWPORT, ISP1504_OTG_CTRL_RW)));
    RETAILMSG(1, (L"\tInterrupt Enable rising(%x)=%x\r\n", 
            ISP1504_INTR_RISING_RW,
            ISP1504_ReadReg(&pReg->ULPI_VIEWPORT, ISP1504_INTR_RISING_RW)));
    RETAILMSG(1, (L"\tInterrupt Enable Falling(%x)=%x\r\n", 
            ISP1504_INTR_FALLING_RW,
            ISP1504_ReadReg(&pReg->ULPI_VIEWPORT, ISP1504_INTR_FALLING_RW)));
    RETAILMSG(1, (L"\tInterrupt Status(%x)=%x\r\n", 
            ISP1504_INTR_STATUS_R,
            ISP1504_ReadReg(&pReg->ULPI_VIEWPORT, ISP1504_INTR_STATUS_R)));
    RETAILMSG(1, (L"\tInterrupt Latch(%x)=%x\r\n", 
            ISP1504_INTR_LATCH_RC,
            ISP1504_ReadReg(&pReg->ULPI_VIEWPORT, ISP1504_INTR_LATCH_RC)));
    RETAILMSG(1, (L"\tDebug(%x)=%x\r\n", 
            ISP1504_DEBUG_R,
            ISP1504_ReadReg(&pReg->ULPI_VIEWPORT, ISP1504_DEBUG_R)));
    RETAILMSG(1, (L"\tScratch(%x)=%x\r\n", 
            ISP1504_SCRATCH_RW,
            ISP1504_ReadReg(&pReg->ULPI_VIEWPORT, ISP1504_SCRATCH_RW)));
    RETAILMSG(1, (L"\tPower(%x)=%x\r\n", 
            ISP1504_POWER_CTRL_RW,
            ISP1504_ReadReg(&pReg->ULPI_VIEWPORT, ISP1504_POWER_CTRL_RW)));
}