xvc.c

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

    if (GetDeviceRegistryParams(pszActiveKey, pXVC, dimof(g_deviceRegParams), g_deviceRegParams) != ERROR_SUCCESS) {
        DEBUGMSG(ZONE_ERROR, (L"ERROR: XVC_Init: "L"Failed read registry parameters\r\n"));
        goto clean;
    }

    if (pXVC->IsOTGSupport == 0)
    {
        RETAILMSG(1, (TEXT("OTG Not support and unload the driver\r\n")));
        goto clean;
    }

    // Initialize CriticalSection object for USB PHY Low-power mode
    InitializeCriticalSection(&pXVC->csPhyLowMode);

    // Initialize XVC variables
    pXVC->bUSBCoreClk = TRUE;
    pXVC->bPanicMode = TRUE;

    pXVC->bResume = FALSE;

    RegisterCallback(&pXVC->fnUsbXvr);
    // Map the USB registers
    pa.QuadPart = ((pXVC->memBase == 0)? CSP_BASE_REG_PA_USBOTG: pXVC->memBase);
    len = ((pXVC->memLen == 0)? 0x1000: pXVC->memLen);

    pXVC->pUSBRegs = MmMapIoSpace(pa, len, FALSE);
    if (pXVC->pUSBRegs == NULL) {
        DEBUGMSG(ZONE_ERROR, (L"ERROR: XVC_Init: Controller registers mapping failed\r\n"));
        goto clean;
    }
    
    irq = ((pXVC->dwIrq == 0)? 0x25: pXVC->dwIrq);
#if 1
    pXVC->dwSysIntr = GetSysIntr();
#else
    if (!KernelIoControl(
            IOCTL_HAL_REQUEST_SYSINTR, &(pXVC->dwIrq), sizeof(DWORD),
            &pXVC->dwSysIntr, sizeof(pXVC->dwSysIntr), NULL
        )) goto clean;
#endif


    USBClockCreateFileMapping();
    //RETAILMSG(1, (TEXT("XVC: irq=0x%x, sysIntr=0x%x\r\n"), irq, pXVC->dwSysIntr));
    pXVC->hIntrEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
    if (pXVC->hIntrEvent == NULL) {
        DEBUGMSG(ZONE_FUNCTION, (TEXT("XVC_Init: CreateEvent failed\r\n")));
        goto clean;
    }

#ifdef USBXVR_INTERRUPT
    // to initialize the interrupt 
    if (!(InterruptInitialize(pXVC->dwSysIntr, pXVC->hIntrEvent, NULL, 0))) {
        DEBUGMSG(1, (TEXT("XVC_Init: Interrupt initialization failed!, ErrCode: 0x%x\r\n"), GetLastError()));
        goto clean;
    }
    
    //RETAILMSG(1, (_T("Transceiver driver working in interrupt mode.\n")));
#else
    RETAILMSG(1, (TEXT("XVC_Init: Transceiver driver working in polling mode\r\n")));
#endif

    KernelIoControl(IOCTL_HAL_ENABLE_WAKE, &pXVC->dwSysIntr, sizeof(pXVC->dwSysIntr), NULL, 0, NULL);

    //RETAILMSG(1, (TEXT("Wakeup enable for transceiver\r\n")));

    DEBUGMSG(ZONE_FUNCTION, (TEXT("XVC_Init: Interrupt initialized\r\n")));
    hInterruptServiceThread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)XVC_ISTMain, NULL, 0, NULL);

    if (hInterruptServiceThread == NULL) {
        DEBUGMSG(ZONE_FUNCTION, (TEXT("XVC_Init: Failed to create Interrupt Service Thread\r\n")));
        goto clean;
    }
    
    CeSetThreadPriority(hInterruptServiceThread, 102);
    //RETAILMSG(1,(TEXT("-XVC_Init: \r\n")));
    return (DWORD)pXVC;

clean:
    if (pXVC && pXVC->pUSBRegs)
        MmUnmapIoSpace((VOID*)pXVC->pUSBRegs, 0x1000);

    if (pXVC)
        LocalFree(pXVC);

    return (DWORD)NULL;
}

/*
 *      Function: XVC_Deinit
 *
 *      The Device Manager calls this function as a result of a call to the
 *      DeactivateDevice() function.  This function will return any resources
 *      allocated while using this driver.
 *
 *      Parameters:
 *           dwContext [in]
 *
 *      Returns:
 *           TRUE
 */

BOOL XVC_Deinit(DWORD dwContext)
{
    DEBUGMSG(ZONE_FUNCTION, (TEXT("+XVC_Deinit: dwContext = 0x%x\r\n"), dwContext));
    if (pXVC && pXVC->pUSBRegs)
        MmUnmapIoSpace((VOID*)pXVC->pUSBRegs, 0x1000);

    USBClockDeleteFileMapping();
    if (pXVC)
        LocalFree(pXVC);

    DEBUGMSG(ZONE_FUNCTION, (TEXT("-XVC_Deinit\r\n"), dwContext));
    return TRUE;
}

/*
 *      Function: XVC_Open
 *
 *      Called when an application attempts to establish a connection to this driver.
 *      This function will verify that a trusted application has made the request and
 *      deny access to all non-trusted applications.
 *
 *      Parameters:
 *            dwData [in]
 *            dwAccess [in]
 *            dwShareMode [in]
 *
 *      Returns:
 *            dwData
 */

DWORD XVC_Open(DWORD dwData, DWORD dwAccess, DWORD dwShareMode)
{
    DEBUGMSG(ZONE_FUNCTION, (TEXT("+XVC_Open: dwData = 0x%x, dwAccess = 0x%x, dwShareMode = 0x%x\r\n"), dwData, dwAccess, dwShareMode));
    DEBUGMSG(ZONE_FUNCTION, (TEXT("-XVC_Open\r\n")));
    return dwData;
}

/*
 *       Function: XVC_Close
 *
 *       Called when an application attempts to close a connection to this driver.
 *
 *       Parameters:
 *             Handle [in]
 *
 *       Returns:
 *             TRUE
 */

BOOL XVC_Close(DWORD Handle)
{
    DEBUGMSG(ZONE_FUNCTION, (TEXT("+XVC_Close: Handle = 0x%x\r\n"), Handle));
    DEBUGMSG(ZONE_FUNCTION, (TEXT("-XVC_Close: Handle = 0x%x\r\n"), Handle));
    return TRUE;
}

/*
 *     Function: XVC_PowerDown
 *
 *     This function suspends power to the device. It is useful only with devices
 *     that can power down under software control.
 *
 *     Parameters:
 *          void
 *     Returns:
 *          void
 */

void XVC_PowerDown(void)
{
    CSP_USB_REGS *pUSBRegs = pXVC->pUSBRegs;

    DEBUGMSG(ZONE_FUNCTION, (TEXT("+XVC_PowerDown \r\n")));    
    if (pXVC->bInXVC) {
        // Lock Start
        EnterCriticalSection(&pXVC->csPhyLowMode);
        if (pXVC->fnUsbXvr.pfnUSBPowerDown)
            pXVC->fnUsbXvr.pfnUSBPowerDown(pUSBRegs, &pXVC->bUSBCoreClk, &pXVC->bPanicMode);
        LeaveCriticalSection(&pXVC->csPhyLowMode);
    }
    DEBUGMSG(ZONE_FUNCTION, (TEXT("-XVC_PowerDown \r\n")));
    return;

}

/*
 *
 *   Function: XVC_PowerUp
 *
 *   This function restores power to a device.
 *
 *   Parameters:
 *        void
 *   Returns:
 *       void
 */

void XVC_PowerUp(void)
{
    CSP_USB_REGS *pUSBRegs = pXVC->pUSBRegs;
    DEBUGMSG(ZONE_FUNCTION, (TEXT("+XVC_PowerUP \r\n")));
    DEBUGMSG(ZONE_FUNCTION, (TEXT("-XVC_PowerUp \r\n")));   
    if (pXVC->bInXVC) {
        EnterCriticalSection(&pXVC->csPhyLowMode);
        if (pXVC->fnUsbXvr.pfnUSBPowerUp)
            pXVC->fnUsbXvr.pfnUSBPowerUp(pUSBRegs, &pXVC->bUSBCoreClk, &pXVC->bPanicMode);
        LeaveCriticalSection(&pXVC->csPhyLowMode);

        pXVC->bResume = TRUE;
        SetInterruptEvent(pXVC->dwSysIntr);    
    }
    //RETAILMSG(1, (TEXT("-XVC_PowerUp \r\n")));

}

/*
 *   Function: XVC_Read
 *
 *   This function reads data from the device identified by the open context.
 *
 *   Parameters:
 *        Handle [in]
 *        pBuffer [out]
 *        dwNumBytes [in]
 *   Returns:
 *        Zero
 *
 */

DWORD XVC_Read(DWORD Handle, LPVOID pBuffer, DWORD dwNumBytes)
{
    DEBUGMSG(ZONE_FUNCTION, (TEXT("XVC_Read: Handle = 0x%x, pBuffer = 0x%x, dwNumBytes = 0x%x\r\n"), Handle, pBuffer, dwNumBytes));
    return 0;
}

/*
 *    Function: XVC_Write
 *
 *    This function writes data to the device.
 *
 *    Parameters:
 *         Handle [in]
 *         pBuffer [out]
 *         dwNumBytes [in]
 *
 *    Returns:
 *         zero
 */

DWORD XVC_Write(DWORD Handle, LPCVOID pBuffer, DWORD dwNumBytes)
{
    DEBUGMSG(ZONE_FUNCTION, (TEXT("XVC_Write: Handle = 0x%x, pBuffer = 0x%x, dwNumBytes = 0x%x\r\n"), Handle, pBuffer, dwNumBytes));
    return 0;
}

/*
 *    Function: XVC_Seek
 *
 *    This function moves the data pointer in the device.
 *
 *    Parameters:
 *         Handle [in]
 *         lDistance
 *         dwMoveMethod
 *
 *    Returns:
 *        -1
 */

DWORD XVC_Seek(DWORD Handle, long lDistance, DWORD dwMoveMethod)
{
    DEBUGMSG(ZONE_FUNCTION, (TEXT("XVC_Seek: Handle = 0x%x, lDistance = 0x%x, dwMoveMethod = 0x%x\r\n"), Handle, lDistance, dwMoveMethod));
    return (DWORD) -1;
}

/*
 *      Function: XVC_IOControl
 *
 *      Called when an application calls the DeviceIoControl() function.  This
 *      function operates differently based upon the IOCTL that is passed to it.
 *
 *      Parameters:
 *           Handle [in]
 *
 *           dwIoControlCode [in] The IOCTL requested.
 *
 *          pInBuf [in] Input buffer.
 *
 *          nInBufSize [in] Length of the input buffer.
 *
 *           pOutBuf [out] Output buffer.
 *
 *           nOutBufSize [in] The length of the output buffer.
 *
 *           pBytesReturned [out] Size of output buffer returned to application.
 *
 *      Returns:
 *           TRUE if the IOCTL is handled. FALSE if the IOCTL was not recognized or
 *           an error occurred while processing the IOCTL
 */

BOOL XVC_IOControl(
                   VOID *pXVCContext, IOCTL_SOURCE source, DWORD code, UCHAR *pInBuffer,
                   DWORD inSize, UCHAR *pOutBuffer, DWORD outSize, DWORD *pOutSize
                   )

{
    CE_BUS_POWER_STATE *pBusPowerState;    
    DEBUGMSG(ZONE_FUNCTION, (TEXT("+XVC_IOControl: dwIoControlCode = 0x%x\r\n"), code));
    //RETAILMSG(1, (TEXT("+XVC_IOControl: dwIoControlCode = 0x%x\r\n"), code));
    switch (code)
    {
        case IOCTL_BUS_GET_POWER_STATE:         
            if (source != MDD_IOCTL)
            {
                RETAILMSG(1, (TEXT("IOCTL_BUS_GET_POWER_STATE not MDD_IOCTL\r\n")));
                break;
            }

            RETAILMSG(1, (TEXT("IOCTL_BUS_GET_POWER_STATE\r\n")));
            pBusPowerState = (CE_BUS_POWER_STATE*)pInBuffer;
            *pBusPowerState->lpceDevicePowerState = pXVC->CurPMPowerState;
            break;

        case IOCTL_BUS_SET_POWER_STATE:
            if (source == MDD_IOCTL)
            {
                RETAILMSG(1, (TEXT("IOCTL_BUS_SET_POWER_STATE MDD_IOCTL\r\n")));
                break;
            }
            RETAILMSG(1, (TEXT("IOCTL_BUS_SET_POWER_STATE\r\n")));
            pBusPowerState = (CE_BUS_POWER_STATE*)pInBuffer;
            pXVC->CurPMPowerState = *pBusPowerState->lpceDevicePowerState;

        default:
            break;
    }
    return TRUE;
}

/* EOF*/