usbehcdeventhandler.c

vxWorks下USB2.0中的EHCI的HCD源码,极具有参考价值

                 */
                for (pTempRequestInfo = pEHCDData->pRequestQueueHead;
                    (NULL != pTempRequestInfo) &&
                    (pRequestInfo != pTempRequestInfo->pListRequest);
                    pTempRequestInfo = pTempRequestInfo->pListRequest);

                /* Assert if the request is not found */

                OS_ASSERT(NULL != pTempRequestInfo);

                /* Unlink the request from the HCD list */

                pTempRequestInfo->pListRequest = pRequestInfo->pListRequest;
                if (NULL == pTempRequestInfo->pListRequest)
                    {
                    pEHCDData->pRequestQueueTail = pTempRequestInfo;
                    }
                }
            /* This is the head of the HCD request queue */
            else
                {
                /* Update the head element */

                pEHCDData->pRequestQueueHead = pRequestInfo->pListRequest;
                if (NULL == pEHCDData->pRequestQueueHead)
                    {
                    pEHCDData->pRequestQueueTail = NULL;
                    }
                }

            /* Update the head of the pipe request queue */

            pHCDPipe->pRequestQueueHead = pRequestInfo->pNext;

            /* Release the request synchronisation event */

            OS_RELEASE_EVENT(pEHCDData->RequestSynchEventID);

            /* If the pipe is an interrupt pipe, add all
             * the TDs to the free QTD pool
             */
            if (USBHST_INTERRUPT_TRANSFER == pHCDPipe->uEndpointType)
                {
                /* Pointer to the tail of Queue TD */

                pUSB_EHCD_QTD pQTDTail = NULL;

                /* Pointer to the head of Queue TD */

                pUSB_EHCD_QTD pQTDHead = NULL;

                /* Pointer to the temporary QTD */

                pUSB_EHCD_QTD pTempQTD = NULL;

                /* Get the tail of the TD list */

                pQTDTail = (pUSB_EHCD_QTD)pRequestInfo->pTail;

                /* Get the head of the TD list */

                pQTDHead = (pUSB_EHCD_QTD)pRequestInfo->pHead;

                /* Assert if the head or tail is invalid */

                OS_ASSERT(NULL != pQTDHead);
                OS_ASSERT(NULL != pQTDTail);

                /* Release all the TDs associated with this Request */

                for (; pQTDHead != pQTDTail; pQTDHead = pTempQTD)
                    {
                    /* Store the next pointer temporarily */

                    pTempQTD = pQTDHead->pNext;

                    /* Add the TD to the free list */

                    usbEhcdAddToFreeQTDList(pQTDHead);
                    }

                /* Add the tail element to the list */

                usbEhcdAddToFreeQTDList(pQTDTail);

                }
            /* This endpoint is an isochronous endpoint */
            else
                {
                /* Check if the endpoint is for a full speed device. It would
                 * contain split isochronous TDs
                 */
                if (USBHST_FULL_SPEED == pHCDPipe->uSpeed)
                    {
                    /* Pointer to the tail of SITD */

                    pUSB_EHCD_SITD pSITDTail = NULL;

                    /* Pointer to the head of SITD */

                    pUSB_EHCD_SITD pSITDHead = NULL;

                    /* Pointer to the temporary SITD */

                    pUSB_EHCD_SITD pTempSITD = NULL;

                    /* Get the tail of the TD list */

                    pSITDTail = (pUSB_EHCD_SITD)pRequestInfo->pTail;

                    /* Get the head of the TD list */

                    pSITDHead = (pUSB_EHCD_SITD)pRequestInfo->pHead;

                    /* Assert if the head or tail is invalid */

                    OS_ASSERT(NULL != pSITDHead);
                    OS_ASSERT(NULL != pSITDTail);

                    /* Release all the TDs associated with this Request */

                    for (; pSITDHead != pSITDTail; pSITDHead = pTempSITD)
                        {
                        /* Store the next pointer temporarily */

                        pTempSITD = pSITDHead->pVerticalNext;

                        /* Add the TD to the free list */

                        usbEhcdAddToFreeSITDList(pSITDHead);
                        }

                    /* Add the tail element to the list */

                    usbEhcdAddToFreeSITDList(pSITDTail);
                    }
                /* Check if the endpoint is for a high speed device. It would
                 * contain isochronous TDs
                 */
                else if (USBHST_HIGH_SPEED == pHCDPipe->uSpeed)
                    {
                    /* Pointer to the tail of ITD */

                    pUSB_EHCD_ITD pITDTail = NULL;

                    /* Pointer to the head of ITD */

                    pUSB_EHCD_ITD pITDHead = NULL;

                    /* Pointer to the temporary ITD */

                    pUSB_EHCD_ITD pTempITD = NULL;

                    /* Get the tail of the TD list */

                    pITDTail = (pUSB_EHCD_ITD)pRequestInfo->pTail;

                    /* Get the head of the TD list */

                    pITDHead = (pUSB_EHCD_ITD)pRequestInfo->pHead;

                    /* Assert if the head or tail is invalid */

                    OS_ASSERT(NULL != pITDHead);
                    OS_ASSERT(NULL != pITDTail);

                    /* Release all the TDs associated with this Request */

                    for (; pITDHead != pITDTail; pITDHead = pTempITD)
                        {
                        /* Store the next pointer temporarily */

                        pTempITD = pITDHead->pVerticalNext;

                        /* Add the TD to the free list */

                        usbEhcdAddToFreeITDList(pITDHead);
                        }

                    /* Add the tail element to the list */

                    usbEhcdAddToFreeITDList(pITDTail);
                    }

                /* Invalid speed */
                else
                    {
                    OS_LOG_MESSAGE_HIGH(EHCD,"usbEhcdCleanupPeriodicPipes - \
                                        Invalid isochronous speed\n",0,0,0,0);
                    OS_ASSERT(FALSE);
                    }
                }

            /* Call the callback function if it is registered */

            if (NULL != pRequestInfo->pUrb->pfCallback)
                {
                (pRequestInfo->pUrb->pfCallback)(pRequestInfo->pUrb);
                }

            /* Free the memory allocated for the request information */
            OS_FREE(pRequestInfo);

            /* Exclusively access the request synchronisation list */
            OS_WAIT_FOR_EVENT(pEHCDData->RequestSynchEventID,
                              OS_WAIT_INFINITE);
            }/* End of for () */

        /* Release the request synchronisation event */

        OS_RELEASE_EVENT(pEHCDData->RequestSynchEventID);

        /* If it is a non-isochronous endpoint, release the QHs */

        if (USBHST_INTERRUPT_TRANSFER == pHCDPipe->uEndpointType)
            {
            /* Assert if the QH is invalid */

            OS_ASSERT(NULL != pHCDPipe->pQH);

            /* Add the QH to the free list */

            usbEhcdAddToFreeQHList(pHCDPipe->pQH);
            }
        /* Release the event to the waiting task */
        OS_RELEASE_EVENT(pHCDPipe->DeleteSynchEventID);

        /* Exclusively access the reclamation list */

        OS_WAIT_FOR_EVENT(pEHCDData->ReclamationListSynchEventID,
                          OS_WAIT_INFINITE);
        }

    /* Search the list which contains the requests which need to be removed
     * and release the memory allocated for all of them.
     */
    for (pRequestInfo = pEHCDData->pHeadPeriodicCancelList;
        NULL != pRequestInfo;
        pRequestInfo = pEHCDData->pHeadPeriodicCancelList)
        {

        /* Update the head of the asynch request reclamation list */

        pEHCDData->pHeadPeriodicCancelList = pRequestInfo->pListRequest;

        /* Release the exclusive access */
        OS_RELEASE_EVENT(pEHCDData->ReclamationListSynchEventID);

        /* Assert if the pipe pointer is invalid */

        OS_ASSERT(NULL != pRequestInfo->pHCDPipe);

        /* The following condition will check if the request is for an
         * interrupt endpoint and will remove the request elements.
         */
        if (USBHST_INTERRUPT_TRANSFER == pRequestInfo->pHCDPipe->uEndpointType)
            {
            /* Pointer to the tail of Queue TD */

            pUSB_EHCD_QTD pQTDTail = NULL;

            /* Pointer to the head of Queue TD */

            pUSB_EHCD_QTD pQTDHead = NULL;

            /* Pointer to the temporary QTD */

            pUSB_EHCD_QTD pTempQTD = NULL;

            /* Get the tail of the TD list */

            pQTDTail = (pUSB_EHCD_QTD)pRequestInfo->pTail;

            /* Get the head of the TD list */
            pQTDHead = (pUSB_EHCD_QTD)pRequestInfo->pHead;

            /* Assert if the head or tail is invalid */

            OS_ASSERT(NULL != pQTDHead);
            OS_ASSERT(NULL != pQTDTail);

            /* Release all the TDs associated with this Request */

            for (; pQTDHead != pQTDTail; pQTDHead = pTempQTD)
                {
                /* Store the next pointer temporarily */

                pTempQTD = pQTDHead->pNext;

                /* Add the TD to the free list */
                usbEhcdAddToFreeQTDList(pQTDHead);
                }

            /* Add the tail element to the list */

            usbEhcdAddToFreeQTDList(pQTDTail);

            /* The status is updated to cancel in usbEhcdCancelURB() function. So
             * it is not updated to Cancelled here.
             */
            }
        else if (USBHST_ISOCHRONOUS_TRANSFER ==
                 pRequestInfo->pHCDPipe->uEndpointType)
            {
            /* To be done for isochronous */
            }
        else
            {
            OS_ASSERT(FALSE);
            }

        /* Release the semaphore to the waiting task */
        OS_RELEASE_EVENT(pRequestInfo->pHCDPipe->DeleteSynchEventID);

        /* Free the memory allocated for the request information */

        OS_FREE(pRequestInfo);

        /* Exclusively access the reclamation list */

        OS_WAIT_FOR_EVENT(pEHCDData->ReclamationListSynchEventID,
                          OS_WAIT_INFINITE);
        }

    /* Check if some request pending in Reclamation list or cancel list,
       if not disable the intr
    */
    if ((NULL == pEHCDData->pPeriodicReclamationListHead) &&
        (NULL == pEHCDData->pHeadPeriodicCancelList))
        {
        USB_EHCD_CLR_BIT_USBINTR_INT_ON_FRAME_LIST_ROLLOVER(pEHCDData);
        }
    /* Release the exclusive access */
    OS_RELEASE_EVENT(pEHCDData->ReclamationListSynchEventID);

    OS_LOG_MESSAGE_LOW(EHCD,"usbEhcdCleanupPeriodicPipes - Exit\n",0,0,0,0);

    return;
    }/* End of usbEhcdCleanupPeriodicPipes() */

/***************************************************************************
*
* usbEhcdHostSystemErrorHandler - handles the host system error interrupt
*
* This is used to handle the host system error interrupt.
*
* RETURNS: N/A.
*
* ERRNO:
*   None.
*
* \NOMANUAL
*/

LOCAL VOID usbEhcdHostSystemErrorHandler
    (
    pUSB_EHCD_DATA pEHCDData
    )
    {
	/* WindView Instrumentation */
	USB_HCD_LOG_EVENT(
		USB_EHCI_WV_EVENT_HANDLER,
		"usbEhcdHostSystemErrorHandler() starts",
		USB_EHCD_WV_FILTER);

    OS_LOG_MESSAGE_LOW(EHCD,"usbEhcdHostSystemErrorHandler - Entry\n",0,0,0,0);

    /* Check the validity of the parameters */

    if (NULL == pEHCDData)
        {
        OS_LOG_MESSAGE_HIGH(EHCD,"usbEhcdHostSystemErrorHandler - parameter not\
                         valid\n",0,0,0,0);
        return;
        }

    /* Stop the Host controller from processing the schedule */

    USB_EHCD_CLR_BIT(pEHCDData,
                     USBCMD,
                     RS);

    OS_LOG_MESSAGE_LOW(EHCD,"usbEhcdHostSystemErrorHandler - Exit\n",0,0,0,0);

    return;
    }/* End of usbEhcdHostSystemErrorHandler() */


/***************************************