usbhalinterrupthandler.c

USB source code of Vxworks 5.6. It has device and the host stack.

* ERRNO:
*   None.
*
* \NOMANUAL
*/

VOID usbHalSuspendInterruptHandler
    (
    pUSBHAL_TCD	pHalTcd		/* USBHAL_TCD  */
    )
    {
    TRB_HANDLE_SUSPEND_INTERRUPT trbSuspendInterruptHandler;

    /* WindView Instrumentation */

    USB_HAL_LOG_EVENT(USB_HAL_INTERRUPT_HANDLER,
    "usbHalSuspendInterruptHandler entered ...", USB_HAL_WV_FILTER);   

    USBHAL_DEBUG("usbHalSuspendInterruptHandler - Entering\n",0,0,0,0,0,0);

    /* Check the validity of the parameters */

    if ((pHalTcd == NULL) || (pHalTcd->pTCDHandle == NULL) ||
        (pHalTcd->mngmtCallback == NULL))
        {

        /* WindView Instrumentation */ 

        USB_HAL_LOG_EVENT(USB_HAL_DEVICE_CNTL,
        "usbHalSuspendInterruptHandler exiting: Bad Parameter Received...",
        USB_HAL_WV_FILTER);   

        USBHAL_ERR("usbHalSuspendInterruptHandler : Invalid parameters\n",
        0,0,0,0,0,0);
        return;
        }

    /* call the management callback */

    (*pHalTcd->mngmtCallback)(pHalTcd->mngmtCallbackParam,
                              TCD_MNGMT_SUSPEND,
                              0);

    /* Populate the TRB - start */

    trbHeaderInit((pTRB_HEADER)(&trbSuspendInterruptHandler),
            pHalTcd->pTCDHandle,
            TCD_FNC_HANDLE_SUSPEND_INTERRUPT,
            sizeof(TRB_HANDLE_SUSPEND_INTERRUPT));

    /* Populate the TRB - end */

    /* call the TCD's SEP */

    (*pHalTcd->tcdExecFunc)(&trbSuspendInterruptHandler);

    USBHAL_DEBUG("usbHalSuspendInterruptHandler - Exiting\n",0,0,0,0,0,0);
    return;
    }

/*******************************************************************************
*
* usbHalResumeInterruptHandler - hal resume interrupt handler.
*
* This function handles the interrupt on device resume
*
* RETURNS: N/A.
*
* ERRNO:
*   None.
*
* \NOMANUAL
*/

VOID usbHalResumeInterruptHandler
    (
    pUSBHAL_TCD	pHalTcd		/* USBHAL_TCD  */
    )
    {
    TRB_HANDLE_RESUME_INTERRUPT trbResumeInterruptHandler;

    /* WindView Instrumentation */

    USB_HAL_LOG_EVENT(USB_HAL_INTERRUPT_HANDLER,
    "usbHalResumeInterruptHandler entered ...", USB_HAL_WV_FILTER);   

    USBHAL_DEBUG("usbHalResumeInterruptHandler - Entering\n",0,0,0,0,0,0);

    /* Check the validity of the parameters */

    if ((pHalTcd == NULL) || (pHalTcd->pTCDHandle == NULL) ||
        (pHalTcd->mngmtCallback == NULL))
        {

        /* WindView Instrumentation */ 

        USB_HAL_LOG_EVENT(USB_HAL_DEVICE_CNTL,
        "usbHalResumeInterruptHandler exiting: Bad Parameter Received...",
        USB_HAL_WV_FILTER);   

        USBHAL_ERR("usbHalResumeInterruptHandler : Invalid parameters\n",
        0,0,0,0,0,0);
        return;
        }

    /* call the management callback */

    (*pHalTcd->mngmtCallback)(pHalTcd->mngmtCallbackParam,
                              TCD_MNGMT_RESUME,
                              0);


    /* Populate the TRB - start */

    trbHeaderInit((pTRB_HEADER)(&trbResumeInterruptHandler),
            pHalTcd->pTCDHandle,
            TCD_FNC_HANDLE_RESUME_INTERRUPT,
            sizeof(TRB_HANDLE_RESUME_INTERRUPT));

    /* Populate the TRB - end */

    /* call the TCD's SEP */

    (*pHalTcd->tcdExecFunc)(&trbResumeInterruptHandler);

    USBHAL_DEBUG("usbHalResumeInterruptHandler - Exiting\n",0,0,0,0,0,0);
    return;

    }

/*******************************************************************************
*
* usbHALISR - hal isr callback.
*
* This is the HAL ISR callback whihc is called whenever an interrupt occurs on
* a target controller.
*
* RETURNS: N/A.
*
* ERRNO:
*   None.
*
* \NOMANUAL
*/

VOID usbHalIsr
    (
    pUSBHAL_TCD	pHalTcd		/* USBHAL_TCD */
    )
    {
    TRB_INTERRUPT_STATUS_GET_CLEAR	trbIntStatusGetClear;
    STATUS	status = OK;

    /* WindView Instrumentation */

    USB_HAL_LOG_EVENT(USB_HAL_INTERRUPT_HANDLER,
    "usbHalISR entered ...", USB_HAL_WV_FILTER);   

    USBHAL_DEBUG("usbHalISR - Entering\n",0,0,0,0,0,0);

    /* Check the validity of the parameters */

    if ((pHalTcd == NULL) || (pHalTcd->pTCDHandle == NULL))
        {

        /* WindView Instrumentation */ 

        USB_HAL_LOG_EVENT(USB_HAL_DEVICE_CNTL,
        "usbHalISR exiting: Bad Parameter Received...",
        USB_HAL_WV_FILTER);   

        USBHAL_ERR("usbHalISR : Invalid parameters\n",0,0,0,0,0,0);
        USBHAL_DEBUG("usbHalISR - Exiting\n",0,0,0,0,0,0);
        return;
        }

    /* Populate the TRB - start */
    
    trbHeaderInit((pTRB_HEADER)(&trbIntStatusGetClear),
            pHalTcd->pTCDHandle,
            TCD_FNC_INTERRUPT_STATUS_GET,
            sizeof(TRB_INTERRUPT_STATUS_GET_CLEAR));
    
    /* Populate the TRB - end */

    /* call the TCD's SEP to get interrupt status*/

    status = (*pHalTcd->tcdExecFunc)(&trbIntStatusGetClear);

    if ( status == OK)
        {

        /* store interrupt status retrieved */

        pHalTcd->uInterruptStatus |=  trbIntStatusGetClear.uInterruptStatus;

        /* Reuse the TRB for clearing the interrupt status */

        trbIntStatusGetClear.header.function = TCD_FNC_INTERRUPT_STATUS_CLEAR;

        /* call the TCD's SEP to clear interrupt status */

        (*pHalTcd->tcdExecFunc)(&trbIntStatusGetClear);

        /* signal the HAL interrupt handler thread */

        OSS_SEM_GIVE(pHalTcd->intPendingSemaphore);

        }
    else
        USBHAL_ERR("usbHalISR : Error in getting interrupt status\n",
                    0,0,0,0,0,0);

    USBHAL_DEBUG("usbHalISR - Exiting\n",0,0,0,0,0,0);
    return;
    }

/*******************************************************************************
*
* usbHalInterruptThread - hal interrupt handler thread.
*
* This thread handles interrupts on receiving a signal from usbHalISR 
* callback.
*
* RETURNS: N/A.
*
* ERRNO:
*   None.
*
* \NOMANUAL
*/

VOID usbHalInterruptThread
    (
    pUSBHAL_TCD	pHalTcd		/* USBHAL_TCD */
    )
    {
    UINT32	uInterruptStatus = 0;	/* bitmap to hold interrupt status */

    /* WindView Instrumentation */

    USB_HAL_LOG_EVENT(USB_HAL_INTERRUPT_HANDLER,
    "usbHalInterruptThread entered ...", USB_HAL_WV_FILTER);   

    USBHAL_DEBUG("usbHalInterruptThread - Entering\n",0,0,0,0,0,0);

    /* Check the validity of the parameters */

    if ((pHalTcd == NULL) || (pHalTcd->intPendingSemaphore == NULL)
        || (pHalTcd->mutex == NULL))
        {

        /* WindView Instrumentation */ 

        USB_HAL_LOG_EVENT(USB_HAL_DEVICE_CNTL,
        "usbHalInterruptThread exiting: Bad Parameter Received...",
        USB_HAL_WV_FILTER);

        USBHAL_ERR("usbHalInterruptThread : Invalid parameters\n",0,0,0,0,0,0);
        return;
        }

    while (1)
        {

        /*  wait for signal from HAL ISR callback */

        OSS_SEM_TAKE(pHalTcd->intPendingSemaphore, OSS_BLOCK);

        USBHAL_DEBUG ("usbHalInterruptThread - usbHalISR'signal received\n",
        0,0,0,0,0,0);

        /*
         * If there is no interrupt pending, wait for the semaphore to be
         * signalled from the ISR
         */

        if ( pHalTcd->uInterruptStatus == 0 )
            continue;

        /* Copy the interrupt status value */

        uInterruptStatus = pHalTcd->uInterruptStatus;

        /* Clear the interrupt status */

        pHalTcd->uInterruptStatus &= ~uInterruptStatus; 

        /* If disconnect interrupt pending call disconnect interrupt handler */

        if ((uInterruptStatus & USBTCD_DISCONNECT_INTERRUPT_MASK) != 0)
            {
            usbHalDisconnectInterruptHandler(pHalTcd);
            }

        /* If reset interrupt pending call reset interrupt handler */

        if ((uInterruptStatus & USBTCD_RESET_INTERRUPT_MASK) != 0)
            {
            usbHalResetInterruptHandler(pHalTcd);
            }

        /* If suspend interrupt pending call suspend interrupt handler */

        if ((uInterruptStatus & USBTCD_SUSPEND_INTERRUPT_MASK) != 0)
            {
            usbHalSuspendInterruptHandler(pHalTcd);
            }

        /* If resume interrupt pending call resume interrupt handler */

        if ((uInterruptStatus & USBTCD_RESUME_INTERRUPT_MASK) != 0)
            {
            usbHalResumeInterruptHandler(pHalTcd);
            }

        /* If endpoint interrupt pending, call endpoint interrupt handler */

        if ((uInterruptStatus & USBTCD_ENDPOINT_INTERRUPT_MASK) != 0 )
            {
            usbHalEndpointInterruptHandler(pHalTcd);
            }
        }
    }