}                        /* Release the exclusive access */            OS_RELEASE_EVENT(pHCDData->RequestSynchEventID);            /* Exclusively access the bandwidth resource */            OS_WAIT_FOR_EVENT(pHCDData->BandwidthEventID,OS_WAIT_INFINITE);            /* This loop will remove the bandwidth             * allocated in each of the frames             */            for (uFrameIndex = pHCDPipe->uListIndex;                USB_EHCD_MAX_FRAMELIST_SIZE > uFrameIndex;                uFrameIndex += pHCDPipe->uStepValue)                {                /* This loop will update the frame list bandwidth                 * for every microframe                 */                for (uUFrameIndex = 0;                    USB_EHCD_MAX_MICROFRAME_NUMBER > uUFrameIndex;                    uUFrameIndex++)                    {                    /* Check if bandwidth is to be updated for this                     * microframe and update the bandwidth                     */                    if (0 !=                        ((pHCDPipe->uUFrameMaskValue >> uUFrameIndex) & 0x01))                        {                        pHCDData->FrameListData[uFrameIndex].                        uBandwidth[uUFrameIndex] -= pHCDPipe->uBandwidth;                        pHCDData->FrameBandwidth[uFrameIndex][uUFrameIndex] -=                        pHCDPipe->uBandwidth;                        }                    }                }            /* Release the bandwidth exclusive access */            OS_RELEASE_EVENT(pHCDData->BandwidthEventID);            /* Update the bandwidth */            bStatus = usbEhcdUpdateBandwidth(pHCDData);            /* Check if bandwidth updation is successful */            if (FALSE == bStatus)                {                OS_ASSERT(FALSE);                }            }/* End of isochronous endpoint removal request handling */        /* Create a synchronisation  event*/        if (NULL == (pHCDPipe->DeleteSynchEventID = OS_CREATE_EVENT(OS_EVENT_NON_SIGNALED)))            {            OS_ASSERT(FALSE);            }        /* Add to the reclamation list */        USB_EHCD_ADD_TO_PERIODIC_RECLAMATION_LIST(pHCDData,                                                  pHCDPipe);        /* Enable the interrupt to be generated on a frame list rollover */        USB_EHCD_SET_BIT_USBINTR_INT_ON_FRAME_LIST_ROLLOVER(pHCDData);        /* Wait for event handler task to free the resources */        OS_WAIT_FOR_EVENT(pHCDPipe->DeleteSynchEventID, OS_WAIT_INFINITE);        /* Delete the event created */        OS_DESTROY_EVENT(pHCDPipe->DeleteSynchEventID);        /* Free the PIPE */        OS_FREE(pHCDPipe);        }/* End of else */    OS_LOG_MESSAGE_LOW(EHCD,"usbEhcdDeletePipe - Exit\n",0,0,0,0);    /* Return the success status */    return USBHST_SUCCESS;    }/* End of function usbEhcdDeletePipe() *//***************************************************************************** usbEhcdModifyDefaultPipe - modifies the default pipe characteristics.** This function is used to modify the properties (device speed and maximum * packet size) of the default pipe (address 0, endpoint 0). <uBusIndex> * specifies the host controller bus index. <uDefaultPipeHandle> holds the* pipe handle of the default pipe. <uDeviceSpeed> is the speed of the * device which needs to be modified. <uMaxPacketSize> is the maximum packet* size of the default pipe which needs to be modified. <uHighSpeedHubInfo>* specifies the nearest high speed hub and the port number information. This* information will be used to handle a split transfer to the full / low speed* device. The high byte will hold the high speed hub address. The low byte* will hold the port number to which the USB 1.1 device is connected.*** RETURNS: *   USBHST_SUCCESS - Returned if the deafult pipe properties were modified*       successfully.*   USBHST_INVALID_PARAMETER - Returned if the parameters are not valid.** ERRNO:*   None.** \NOMANUAL*/USBHST_STATUS usbEhcdModifyDefaultPipe    (    UINT8   uBusIndex,          /* Host controller bus index               */    UINT32  uDefaultPipeHandle, /* Handle to the default pipe              */    UINT8   uDeviceSpeed,       /* Speed of the device in default state    */    UINT8   uMaxPacketSize,     /* Maximum packet size of the default pipe */    UINT16   uHighSpeedHubInfo  /* High speed hub info for USB 1.1 device  */    )    {    /* To hold the pointer to the EHCD maintained pipe data structure */    pUSB_EHCD_PIPE pHCDPipe = NULL;    /* Pointer to the HCD specific data structure */    pUSB_EHCD_DATA  pHCDData = NULL;	/* WindView Instrumentation */	USB_HCD_LOG_EVENT(		USB_EHCI_WV_TRANSFER,		"usbEhcdModifyDefaultPipe() starts",		USB_EHCD_WV_FILTER);    OS_LOG_MESSAGE_LOW(EHCD,"usbEhcdModifyDefaultPipe - Entry\n",0,0,0,0);    /* Check the validity of the parameters */    if ((g_EHCDControllerCount <= uBusIndex) ||        (0 == uDefaultPipeHandle) ||        (USBHST_HIGH_SPEED != uDeviceSpeed &&         USBHST_FULL_SPEED != uDeviceSpeed &&         USBHST_LOW_SPEED != uDeviceSpeed))        {        OS_LOG_MESSAGE_HIGH(EHCD,"usbEhcdModifyDefaultPipe - parameters not valid\n",0,0,0,0);        return USBHST_INVALID_PARAMETER;        }    /* Extract the global data structure */    pHCDData = g_pEHCDData[uBusIndex];    /* Assert if the global pointer is not valid */    OS_ASSERT(NULL != pHCDData);    /* Check if this request is for the Root hub */    if (0 == pHCDData->RHData.uDeviceAddress)        {        return USBHST_SUCCESS;        }    /* WARNING : This function will change on split support */    /* Extract the default pipe handle */    pHCDPipe = (pUSB_EHCD_PIPE)uDefaultPipeHandle;    /* Flush the contents of the QH to RAM */    CACHE_DMA_INVALIDATE (pHCDPipe->pQH, sizeof(USB_EHCD_QH));    /* Modify the default pipe contents */    USB_EHCD_SET_BITFIELD(QH,                          pHCDPipe->pQH->uEndPointCharacteristics,                          uDeviceSpeed,                          ENDPOINT_CHARACTERISTICS_ENDPT_SPEED );                             /*pHCDPipe->pQH->dword2.mult = 1;*/   USB_EHCD_SET_BITFIELD(QH,                         pHCDPipe->pQH->uEndPointCapabilities,                         1,                         ENDPOINT_CAPABILITIES_MULT  );    /* Update the hub address and port number for the USB 1.1 device */    if (uDeviceSpeed != USBHST_HIGH_SPEED)        {        USB_EHCD_SET_BITFIELD(QH,                              pHCDPipe->pQH->uEndPointCapabilities,                              ((uHighSpeedHubInfo &                                    USB_EHCD_PARENT_HUB_ADDRESS_MASK)>> 8),                              ENDPOINT_CAPABILITIES_HUB_ADDR );        USB_EHCD_SET_BITFIELD(QH,                              pHCDPipe->pQH->uEndPointCapabilities,                              (uHighSpeedHubInfo &                                        USB_EHCD_HUB_PORT_NUMBER_MASK),                               ENDPOINT_CAPABILITIES_PORT_NUMBER);        }    else        {        USB_EHCD_SET_BITFIELD(QH,                              pHCDPipe->pQH->uEndPointCapabilities,                              0,                              ENDPOINT_CAPABILITIES_HUB_ADDR );        USB_EHCD_SET_BITFIELD(QH,                              pHCDPipe->pQH->uEndPointCapabilities,                              0,                              ENDPOINT_CAPABILITIES_PORT_NUMBER);        }    /*     * This field is to be set if it is not a high speed device and the     * endpoint is a control endpoint     */    if (USBHST_HIGH_SPEED != uDeviceSpeed)        {        USB_EHCD_SET_BITFIELD(QH,                              pHCDPipe->pQH->uEndPointCharacteristics,                              1 ,                              ENDPOINT_CHARACTERISTICS_CONTROL_ENDPOINT_FLAG);        USB_EHCD_SET_BITFIELD(QH,                              pHCDPipe->pQH->uEndPointCharacteristics,                              0,                              ENDPOINT_CHARACTERISTICS_RL);        }    else        {        USB_EHCD_SET_BITFIELD(QH,                              pHCDPipe->pQH->uEndPointCharacteristics,                              USB_EHCD_MAX_NAK_RATE,                              ENDPOINT_CHARACTERISTICS_RL);        }    /* Modify the maximum packet size */    USB_EHCD_SET_BITFIELD(QH,                          pHCDPipe->pQH->uEndPointCharacteristics,                          uMaxPacketSize,                          ENDPOINT_CHARACTERISTICS_MAXIMUM_PACKET_LENGTH);    /* Flush the contents of the QH to RAM */    CACHE_DMA_FLUSH (pHCDPipe->pQH, sizeof(USB_EHCD_QH));    /* Invalidate the cache */    CACHE_DMA_INVALIDATE (pHCDPipe->pQH, sizeof(USB_EHCD_QH));    OS_LOG_MESSAGE_LOW(EHCD,"usbEhcdModifyDefaultPipe - Exit\n",0,0,0,0);    return USBHST_SUCCESS;    }/* End of usbEhcdModifyDefaultPipe() *//***************************************************************************** usbEhcdIsBandwidthAvailable - checks the bandwidth availability** This function is used to check whether there is enough* bandwidth to support the new configuration or an alternate interface setting* of an interface.* <uBusIndex> specifies the host controller bus index.* <uDeviceAddress> specifies the device address. <uDeviceSpeed> is the speed* of the device which needs to be modified. <pCurrentDescriptor> is the pointer* to the current configuration or interface descriptor. If the pNewDescriptor* corresponds to a USB configuration descriptor, this parameter is ignored* (i.e. this parameter can be NULL). <pNewDescriptor> is the pointer to the new* configuration or interface descriptor.** RETURNS: *   USBHST_SUCCESS - Returned if the new configuration or*       new alternate interface can be supported (ALWAYS)*   USBHST_INVALID_PARAMETER - Returned if the parameters are*       not valid.*   USBHST_INSUFFICIENT_BANDWIDTH - Returned if bandwidth is*       not available.** ERRNO:*   None.** \NOMANUAL*/USBHST_STATUS usbEhcdIsBandwidthAvailable    (    UINT8   uBusIndex,            /* Host controller bus index */    UINT8   uDeviceAddress,       /* Handle to the device addr */    UINT8   uDeviceSpeed,         /* Speed of the device in default state */    UCHAR * pCurrentDescriptor,   /* Ptr to current configuration */    UCHAR * pNewDescriptor        /* Ptr to new configuration */    )    {	/* WindView Instrumentation */    USB_HCD_LOG_EVENT(		USB_EHCI_WV_TRANSFER,		"usbEhcdIsBandwidthAvailable() starts",		USB_EHCD_WV_FILTER);#if 0    /* To hold the pointer to the descriptor header */    pUSBHST_DESCRIPTOR_HEADER   pDescHeader = NULL;    /* To hold the status of the request */    USBHST_STATUS   Status = USBHST_FAILURE;    /* To hold the bandwidth availability status */    BOOLEAN bIsBwAvailable = FALSE;    /* Pointer to the HCD specific data structure */    pEHCD_DATA  pHCDData = NULL;    OS_LOG_MESSAGE_LOW(EHCD,"usbEhcdIsBandwidthAvailable - Entry\n",0,0,0,0);    /* Check the validity of the parameters */    if (g_EHCDControllerCount <= uBusIndex ||        0 == uDeviceAddress ||        NULL == pNewDescriptor)        {        OS_LOG_MESSAGE_HIGH(EHCD,"Parameters are not valid\n",0,0,0,0);        return USBHST_INVALID_PARAMETER;        }    /* Extract the global data structure */    pHCDData = g_pEHCDData[uBusIndex];    /* Assert if the global pointer is not valid */    OS_ASSERT(NULL != pHCDData);    /* If this request is for the Root hub, return success */    if (uDeviceAddress == pHCDData->RHData.uDeviceAddress)        {        return USBHST_SUCCESS;        }    /* Extract the descriptor header of the new descriptor */    pDescHeader = (pUSBHST_DESCRIPTOR_HEADER)pNewDescriptor;    /* Check if it is an interface descriptor */    if (USBHST_INTERFACE_DESC == pDescHeader->uDescriptorType)        {        /* To hold the pointer to the current interface descriptor */        pUSBHST_INTERFACE_DESCRIPTOR pCurrentInterfaceDesc = NULL;        /* To hold the pointer to the new interface descriptor */        pUSBHST_INTERFACE_DESCRIPTOR pNewInterfaceDesc = NULL;        /* Get the current interface descriptor */        pCurrentInterfaceDesc =        (pUSBHST_INTERFACE_DESCRIPTOR)pCurrentDescriptor;        /* Get the new interface descriptor */        pNewInterfaceDesc =        (pUSBHST_INTERFACE_DESCRIPTOR)pNewDescriptor;        /*         * Call the function to check whether the bandwidth can         * be accomodated.         */        bIsBwAvailable = USB_EHCD_CheckBandwidthInterface(pHCDData,                                                          uDeviceAddress);        }    /* Check if it is a configuration descriptor */    else if (USBHST_CONFIG_DESC == pDescHeader->uDescriptorType)        {        /* To hold the pointer to the current configuration descriptor */        pUSBHST_CONFIG_DESCRIPTOR pCurrentConfigDesc = NULL;        /* To hold the pointer to the new configuration descriptor */        pUSBHST_CONFIG_DESCRIPTOR pNewConfigDesc = NULL;        /* Check if the current descriptor is NULL */        if (NULL != pCurrentDescriptor)