usbclock.c

mx27 f14v2 源代码。包括ADS板上诸多驱动的源码。

//------------------------------------------------------------------------------
//
//  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:  USBClock.c
//
#include <windows.h>
#include <Winbase.h>
#include <ceddk.h>
#include "bsp.h"
#include "mx27_usbname.h"
#include "mx27_usbcommon.h"

HANDLE m_hUSBClockGatingHandle = NULL;
BSP_USB_CLOCK_GATING  *pUSBClkGating = NULL;
extern WORD BSPGetUSBControllerType(void);

//**************************************************************************
// Function: USBClockSet
// Parameter: TRUE : Enabled, FALSE : Disable
// Usage: Local function in actual stopping and enabling the USB clock
// Return: TRUE - operation success, FALSE - operation failed
//**************************************************************************
static BOOL USBClockSet(BOOL fEnabled)
{
	   BOOL rc = FALSE;
	   BOOL SetCLKO = FALSE ;
       PHYSICAL_ADDRESS phyAddr = { CSP_BASE_REG_PA_USB, 0 };
	   PCSP_USB_REG g_pUSB = NULL ;
	   ULONG               inIoSpace = 0;
       PHYSICAL_ADDRESS    ioPhysicalBase = { CSP_BASE_REG_PA_USB, 0 };
       UINT32 Outfreq =0 ;
       DEBUGMSG(TRUE, (L"USBClockSet is ........fEnabled %d\r\n",fEnabled));
       if (fEnabled)
       {
#ifdef DEBUG
		DDKClockGetFreq(DDK_CLOCK_SIGNAL_USB  , &Outfreq) ;
       	RETAILMSG(1, (L"DDK_CLOCK_SIGNAL_USB Outfreq is %d\r\n",Outfreq));
#endif				
		DEBUGMSG(TRUE, (L"DDKClockSet Gating mode ..............\r\n"));
 		// dk disabled for some time DDK_CLOCK_GATE_MODE_DISABLE 
		// DDK_CLOCK_GATE_INDEX_HCLK_USB 
       
		if (!DDKClockSetGatingMode(DDK_CLOCK_GATE_INDEX_USB, DDK_CLOCK_GATE_MODE_ENABLE))
        {
            RETAILMSG(1, (L"DDK_CLOCK_GATE_INDEX_USB failed\r\n"));
            goto cleanUp;
        }
		else
		{
			DEBUGMSG(1, (L"DDK_CLOCK_GATE_INDEX_USB was sucessfull .....\r\n"));
			rc = TRUE ;
        }
	 
		if(!DDKClockSetGatingMode(DDK_CLOCK_GATE_INDEX_HCLK_USB , DDK_CLOCK_GATE_MODE_ENABLE))
        {
            RETAILMSG(1, (L"DDK_CLOCK_GATE_INDEX_HCLK_USB failed\r\n"));
			rc = FALSE;
            goto cleanUp;
        }
		else
		{
			DEBUGMSG(1, (L"DDK_CLOCK_GATE_INDEX_HCLK_USB was sucessfull .....\r\n"));
			rc = TRUE ;
        }
	    DEBUGMSG(TRUE, (L"DDKClockConfigBaud DDK_CLOCK_CKO_DIV_4 ... \r\n"));
		 
		if(!DDKClockConfigBaud(DDK_CLOCK_SIGNAL_USB,  DDK_CLOCK_BAUD_SOURCE_SPLL,  DDK_CLOCK_CKO_DIV_4))
        {
            RETAILMSG(TRUE, (L"DDKClockConfigBaud failed \r\n"));
			rc = FALSE;
            goto cleanUp;
        } 
		else
		{
		  DEBUGMSG(TRUE, (L"DDKClockConfigBaud  successfull \r\n"));
		  rc = TRUE ;
		} 
	 	// changed from DDK_CLOCK_CKO_SRC_CLK26M to DDK_CLOCK_CKO_SRC_CLK60M_ALWAYS       
	    // SetCLKO = DDKClockSetCKO(TRUE, DDK_CLOCK_CKO_SRC_CLK26M, DDK_CLOCK_CKO_DIV_1);

        // Do not run this as this would configure with Audio driver.
        // Also, the CLKO is MX27 is now connecting to Audio only.
#if 0
		SetCLKO = DDKClockSetCKO(TRUE, DDK_CLOCK_CKO_SRC_CLK60M_ALWAYS, DDK_CLOCK_CKO_DIV_1);
		if(SetCLKO==TRUE)
		{ 
	     	RETAILMSG(TRUE, (L"DDKClockSetCKO SetCLKO %d\r\n",SetCLKO ));
			rc = TRUE ;
	    }
		else
		{
		  RETAILMSG(TRUE, (L"DDKClockConfigBaud failed \r\n"));
		  rc = FALSE;
          goto cleanUp;
		}
#endif

	
    }
    else
    {   
		DEBUGMSG(1, (L"<<<< DDK_CLOCK_GATE_MODE_DISABLE <<<< %d\r\n",DDK_CLOCK_GATE_MODE_DISABLE));
		// dk disabled for some time 
        if(!DDKClockSetGatingMode(DDK_CLOCK_GATE_INDEX_HCLK_USB, DDK_CLOCK_GATE_MODE_DISABLE))
        {
            RETAILMSG(TRUE, (L"DDKClockSetGatingMode for DDK_CLOCK_GATE_INDEX_HCLK_USB failed \r\n"));
            rc = FALSE;
			goto cleanUp;
        } 
		else
		{
          DEBUGMSG(1, (L"DDKClockSetGatingMode for DDK_CLOCK_GATE_INDEX_HCLK_USB SucessFull \r\n"));
		  rc = TRUE ;
		}

		if(!DDKClockSetGatingMode(DDK_CLOCK_GATE_INDEX_USB, DDK_CLOCK_GATE_MODE_DISABLE))
        {
            RETAILMSG(TRUE, (L"DDKClockSetGatingMode for DDK_CLOCK_GATE_INDEX_USBfailed\r\n"));
            rc = FALSE;
			goto cleanUp;
        } 
		else
		{
          DEBUGMSG(1, (L"DDKClockSetGatingMode for DDK_CLOCK_GATE_INDEX_USB SucessFull \r\n"));
		  rc = TRUE ;
		}
    }
  	

cleanUp:
  
    DEBUGMSG(1, (TEXT("USBClock %s return %d\r\n"), (fEnabled? TEXT("TRUE"): TEXT("FALSE")), rc));    
    return rc;
}

//***************************************************************************
// Function: USBClockInit
// Parameter: N/A
// Usage: Init and start the USB Core Clock
// Return: TRUE - success to start the clock, FALSE - fail to start the clock
//***************************************************************************
BOOL USBClockInit(void)
{    
      /* 
	   USBClockDisable(FALSE);
       return USBClockSet(TRUE);
	  */
    return USBClockDisable(FALSE);
}

//*****************************************************************
// Function: USBClockGatingLock
// Parameter: N/A
// Usage: Use the parameter ClockGatingLock as a critical section
//        in controlling the access within the Lock/Unlock for multiple
//        USB drivers
//******************************************************************
void USBClockGatingLock(void)
{
    do
    {
        // Wait until lock is released
        while (*((volatile UINT32 *)(&pUSBClkGating->ClockGatingLock)));
    } while (InterlockedTestExchange(&pUSBClkGating->ClockGatingLock, FALSE, TRUE) != FALSE);

}

//*****************************************************************
// Function: USBClockGatingUnlock
// Parameter: N/A
// Usage: Use the parameter ClockGatingLock as a critical section
//        in controlling the access within the Lock/Unlock for multiple
//        USB drivers
//******************************************************************
void USBClockGatingUnlock(void)
{
    pUSBClkGating->ClockGatingLock = FALSE;
}

//**************************************************************
// Function: USBClockCreateFileMapping
// Parameter: N/A
// Usage: This is use to create the shared memory to be used
//        for controlling the stop/start of USB clock when multiple
//        USB controllers are running
//*************************************************************
BOOL USBClockCreateFileMapping(void)
{
    WORD sel = BSPGetUSBControllerType();

    DEBUGMSG(1, (TEXT("Port(%d):USBCreateFileMapping\r\n"), sel));
    if (m_hUSBClockGatingHandle == NULL)
    {
        m_hUSBClockGatingHandle = CreateFileMapping(INVALID_HANDLE_VALUE, NULL,
            PAGE_READWRITE, 0, sizeof(BSP_USB_CLOCK_GATING), USBClockGatingName);

        if (m_hUSBClockGatingHandle == NULL)
        {
            RETAILMSG(1, (TEXT("Failure to Create File Mapping for USB\r\n")));
            return FALSE;
        }

        if (GetLastError() != ERROR_ALREADY_EXISTS) // you are the first one to create it
        {
            DEBUGMSG(1, (TEXT("Port(%d):First to create USB_CLOCK_GATING\r\n"), sel));
            pUSBClkGating = (BSP_USB_CLOCK_GATING *) MapViewOfFile(m_hUSBClockGatingHandle, 
                    FILE_MAP_ALL_ACCESS, 0, 0, 0);
            pUSBClkGating->ClockGatingMask = 0;
            pUSBClkGating->ClockGatingLock = FALSE;
        }
        else
        {
            DEBUGMSG(1, (TEXT("Port(%d) Open existing USB_CLOCK_GATING\r\n"), sel));
            pUSBClkGating = (BSP_USB_CLOCK_GATING *) MapViewOfFile(m_hUSBClockGatingHandle, 
                    FILE_MAP_ALL_ACCESS, 0, 0, 0);
        }
        
        DEBUGMSG(1, (TEXT("Port(%d):USBClockCreateFileMapping create success\r\n"), sel));
        return TRUE;
    }

    DEBUGMSG(1, (TEXT("-Port(%d):USBClockCreateFileMapping handle exist\r\n"), sel));
    return TRUE;

}

//**************************************************************
// Function: USBClockDeleteFileMapping
// Parameter: N/A
// Usage: This is use to delete the shared memory to be used
//        for controlling the stop/start of USB clock when multiple
//        USB controllers are running
//*************************************************************
void USBClockDeleteFileMapping(void)
{
    if (pUSBClkGating)
    {
        UnmapViewOfFile(pUSBClkGating);
        pUSBClkGating = NULL;
    }

    if (m_hUSBClockGatingHandle)
    {
        CloseHandle(m_hUSBClockGatingHandle);
        m_hUSBClockGatingHandle = NULL;
    }

}


//**************************************************************
// Function: USBClockDisable
// Parameter: TRUE - Stop the clock, FALSE - Start the clock
// Usage: This is use to control multiple USB controllers from accessing
//        the same USB clock. ClockGatingMask is used to control 3 USB controllers
//        (H1, H2 and OTG). If stop is request, it would check against the ClockGatingMask
//        and make sure it is 0 before it actually stop the clock.
//        On other hands, whenever a start is request, it would start right away
//       ClockGatingMask - Bit 0 => H2, Bit 1 => H1, Bit 2 => OTG
//*************************************************************

BOOL USBClockDisable(BOOL fStop)
{
    DWORD dwMask = 0x0;
    BOOL fOK = FALSE;

    WORD sel = BSPGetUSBControllerType();

    // Since only OTG port support client mode.
    dwMask = 0x1 << sel;

    USBClockCreateFileMapping();

    USBClockGatingLock();
    if (fStop)
    {
        pUSBClkGating->ClockGatingMask &= ~dwMask;       
        fOK = ((pUSBClkGating->ClockGatingMask == 0)? TRUE: FALSE);
        if (fOK)
            fOK = USBClockSet(FALSE);
    }
    else
    {
        pUSBClkGating->ClockGatingMask |= dwMask;
        fOK = TRUE;
        fOK = USBClockSet(TRUE);
    }
    USBClockGatingUnlock();

    DEBUGMSG(1, (TEXT("Port(%d) - USBClockCanClockGating(%d), return 0x%x, value 0x%x\r\n"), sel, fStop, fOK, pUSBClkGating->ClockGatingMask));
    return fOK;    
}
//------------------------------------------------------------------------------