/* Pointer to the allocated memory location */    VOID * pAllocatedMem = NULL;    OS_LOG_MESSAGE_LOW(EHCD,"usbEhcdAddToFreeSITDList - Entry\n",0,0,0,0);    /* Check the validity of the parameter */    if (NULL == pSITD)        {    	OS_LOG_MESSAGE_HIGH(EHCD,"usbEhcdAddToFreeSITDList - \                                    Parameter not valid\n",0,0,0,0);        return FALSE;        }    /* Assert if the Allocated memory for the ITD is not valid */    OS_ASSERT(NULL != pSITD->pAllocatedMem);    /* Store the allocated memory in a temporary pointer */    pAllocatedMem = pSITD->pAllocatedMem;    /* Reinitialize the memory */    OS_MEMSET(pSITD, 0, sizeof(USB_EHCD_SITD));    /* Copy the allocated memory pointer back */    pSITD->pAllocatedMem = pAllocatedMem;    /* Wait on the signalling of the event */    OS_WAIT_FOR_EVENT(g_ListAccessEvent,OS_WAIT_INFINITE);    /* Update the next element of the SITD */    pSITD->pNext = pHeadFreeSITD;    /* Make this ITD as the head of the free list */    pHeadFreeSITD = pSITD;    /* If tail pointer is NULL, this SITD becomes the tail pointer */    if (NULL == pTailFreeSITD)        {        pTailFreeSITD = pSITD;        }    /* Release the event */    OS_RELEASE_EVENT(g_ListAccessEvent);    OS_LOG_MESSAGE_LOW(EHCD,"usbEhcdAddToFreeSITDList - Exit\n",0,0,0,0);    return TRUE;    }    /* End of usbEhcdAddToFreeSITDList() *//***************************************************************************** usbEhcdGetFreeQTD - gets a QTD from the free list** This function is used to retrieve a QTD from the free QTD list** RETURNS: Pointer to the USB_EHCD_QTD data structure if the list is non-empty*          NULL if the list is empty.** ERRNO:*   None.** \NOMANUAL*/pUSB_EHCD_QTD usbEhcdGetFreeQTD    (    VOID    )    {    /* Pointer to the QTD */    pUSB_EHCD_QTD pQTD = NULL;    VOID * pTempAllocatedMemory = NULL;    OS_LOG_MESSAGE_LOW(EHCD,"usbEhcdGetFreeQTD - Entry\n",0,0,0,0);    /* Assert if the list access event is not valid */    OS_ASSERT(NULL != g_ListAccessEvent);    /* Check if there is any element in the free list and extract the element.     * Update the free list. This is done acquiring and releasing an event.     */    /* Wait on the signalling of the event */    OS_WAIT_FOR_EVENT(g_ListAccessEvent,OS_WAIT_INFINITE);    /* There are elements in the free list */    if (NULL != pHeadFreeQTD)        {        pQTD = pHeadFreeQTD;        pHeadFreeQTD = pHeadFreeQTD->pNext;        /*         * If this is the only element in the free list,         * the list becomes empty.         */        if (pQTD == pTailFreeQTD)            {            pTailFreeQTD = NULL;            }        /* remember the allocated memory pointer */        pTempAllocatedMemory = pQTD->pAllocatedMem;        /* Initialize all the elements of the Queue Head */        OS_MEMSET(pQTD, 0, sizeof(USB_EHCD_QTD));        /* written back the remembered allocated memory */        pQTD->pAllocatedMem = pTempAllocatedMemory;        }    /* Release the event */    OS_RELEASE_EVENT(g_ListAccessEvent);    OS_LOG_MESSAGE_LOW(EHCD,"usbEhcdGetFreeQTD - Exit\n",0,0,0,0);    /* Return the pointer to QTD */    return pQTD;    }    /* End of usbEhcdGetFreeQTD() *//***************************************************************************** usbEhcdGetFreeQH - gets a QH from the free list** This function is used to retrieve a QH from the free QH list** RETURNS: Pointer to the USB_EHCD_QH data structure if the list is non-empty*          NULL if the list is empty.** ERRNO:*   None.** \NOMANUAL*/pUSB_EHCD_QH usbEhcdGetFreeQH( void )    {    /* Pointer to the QH */    pUSB_EHCD_QH pQH = NULL;    VOID   *pTempAllocatedMemory = NULL;    /* Assert if the list access event is not valid */    OS_ASSERT(NULL != g_ListAccessEvent);    /* Check if there is any element in the free list and extract the element.     * Update the free list. This is done acquiring and releasing an event.     */    /* Wait on the signalling of the event */    OS_WAIT_FOR_EVENT(g_ListAccessEvent,OS_WAIT_INFINITE);    /* There are elements in the free list */    if (NULL != pHeadFreeQH)        {        pQH = pHeadFreeQH;        pHeadFreeQH = pHeadFreeQH->pNext;        /*         * If this is the only element in the free list,         * the list becomes empty.         */        if (pQH == pTailFreeQH)            {            pTailFreeQH = NULL;            }        /* remember the allocated memory pointer */        pTempAllocatedMemory = pQH->pAllocatedMem;        /* Initialize all the elements of the Queue Head */        OS_MEMSET(pQH, 0, sizeof(USB_EHCD_QH));        /* written back the remembered allocated memory */        pQH->pAllocatedMem = pTempAllocatedMemory;        }    /* Release the event */    OS_RELEASE_EVENT(g_ListAccessEvent);    /* Return the QH pointer */    return pQH;    }    /* End of usbEhcdGetFreeQH() *//***************************************************************************** usbEhcdGetFreeITD - gets a ITD from the free list** This function is used to retrieve a ITD from the free ITD list** RETURNS: Pointer to the USB_EHCD_ITD data structure if the list is non-empty*          NULL if the list is empty.** ERRNO:*   None.** \NOMANUAL*/pUSB_EHCD_ITD usbEhcdGetFreeITD(void)    {    /* Pointer to the ITD */    pUSB_EHCD_ITD pITD = NULL;    VOID  *pTempAllocatedMemory = NULL;    /* Assert if the list access event is not valid */    OS_ASSERT(NULL != g_ListAccessEvent);    /* Check if there is any element in the free list and extract the element.     * Update the free list. This is done acquiring and releasing an event.     */    /* Wait on the signalling of the event */    OS_WAIT_FOR_EVENT(g_ListAccessEvent,OS_WAIT_INFINITE);    /* There are elements in the free list */    if (NULL != pHeadFreeITD)        {        pITD = pHeadFreeITD;        pHeadFreeITD = pHeadFreeITD->pNext;        /*         * If this is the only element in the free list,         * the list becomes empty.         */        if (pITD == pTailFreeITD)            {            pTailFreeITD = NULL;            }        /* remember the allocated memory pointer */        pTempAllocatedMemory = pITD->pAllocatedMem;        /* Initialize all the elements of the Queue Head */        OS_MEMSET(pITD, 0, sizeof(USB_EHCD_ITD));        /* written back the remembered allocated memory */        pITD->pAllocatedMem = pTempAllocatedMemory;        }    /* Release the event */    OS_RELEASE_EVENT(g_ListAccessEvent);    /* Return the ITD pointer */    return pITD;    }    /* End of usbEhcdGetFreeITD() *//***************************************************************************** usbEhcdGetFreeSITD - gets a SITD from the free list** This function is used to retrieve a SITD from the free ITD list** RETURNS: Pointer to the USB_EHCD_SITD data structure if the list is non-empty*          NULL if the list is empty.** ERRNO:*   None.** \NOMANUAL*/pUSB_EHCD_SITD usbEhcdGetFreeSITD( void )    {    /* Pointer to the SITD */    pUSB_EHCD_SITD pSITD = NULL;    VOID *pTempAllocatedMemory = NULL;    /* Assert if the list access event is not valid */    OS_ASSERT(NULL != g_ListAccessEvent);    /*     * Check if there is any element in the free list and extract the element.     * Update the free list. This is done acquiring and releasing an event.     */    /* Wait on the signalling of the event */    OS_WAIT_FOR_EVENT(g_ListAccessEvent,OS_WAIT_INFINITE);    /* There are elements in the free list */    if (NULL != pHeadFreeSITD)        {        pSITD = pHeadFreeSITD;        pHeadFreeSITD = pHeadFreeSITD->pNext;        /*         * If this is the only element in the free list,         * the list becomes empty.         */        if (pSITD == pTailFreeSITD)            {            pTailFreeSITD = NULL;            }        /* remember the allocated memory pointer */        pTempAllocatedMemory = pSITD->pAllocatedMem;        /* Initialize all the elements of the Queue Head */        OS_MEMSET(pSITD, 0, sizeof(USB_EHCD_SITD));        /* written back the remembered allocated memory */        pSITD->pAllocatedMem = pTempAllocatedMemory;        }    /* Release the event */    OS_RELEASE_EVENT(g_ListAccessEvent);    /* Return the pointer to SITD */    return pSITD;    }    /* End of usbEhcdGetFreeSITD() *//***************************************************************************** usbEhcdFreeAllLists - releases all the free lists.** This function frees up all the elements in the free list during the HCD* uninitialization.** RETURNS: None.** ERRNO:*   None.** \NOMANUAL*/VOID usbEhcdFreeAllLists(VOID)    {    /* Pointer to the USB_EHCD_QH data structure */    pUSB_EHCD_QH pQH = NULL;    /* Pointer to the USB_EHCD_QTD data structure */    pUSB_EHCD_QTD pQTD = NULL;    /* Pointer to the USB_EHCD_ITD data structure */    pUSB_EHCD_ITD pITD = NULL;    /* Pointer to the USB_EHCD_SITD data structure */    pUSB_EHCD_SITD pSITD = NULL;    OS_LOG_MESSAGE_LOW(EHCD,"usbEhcdFreeAllLists - Entry\n",0,0,0,0);    /* Assert if the list access event is not valid */    OS_ASSERT(NULL != g_ListAccessEvent);    /* Wait on the signalling of the event */    OS_WAIT_FOR_EVENT(g_ListAccessEvent,OS_WAIT_INFINITE);    /* Free the elements in the QH list */    for (; pHeadFreeQH != NULL; pHeadFreeQH = pQH)        {    	/* Store the next pointer temporarily */    	pQH = pHeadFreeQH->pNext;        /* Assert if the allocated memory pointer is invalid */        OS_ASSERT(NULL != pHeadFreeQH->pAllocatedMem);    	/* Free the Queue head data structure */    	memPartFree(ehcdmemPartID, pHeadFreeQH->pAllocatedMem);        }    /* Update the head and tail pointers to NULL */    pHeadFreeQH = NULL;    pTailFreeQH = NULL;    /* Free the elements in the QTD list */    for (; pHeadFreeQTD != NULL; pHeadFreeQTD = pQTD)        {    	/* Store the next pointer temporarily */    	pQTD = pHeadFreeQTD->pNext;        /* Assert if the allocated memory pointer is invalid */        OS_ASSERT(NULL != pHeadFreeQTD->pAllocatedMem);    	/* Free the Queue element data structure */    	memPartFree(ehcdmemPartID, pHeadFreeQTD->pAllocatedMem);        }    /* Update the head and tail pointers to NULL */    pHeadFreeQTD = NULL;    pTailFreeQTD = NULL;    /* Free the elements in the ITD list */    for (; pHeadFreeITD != NULL; pHeadFreeITD = pITD)        {    	/* Store the next pointer temporarily */    	pITD = pHeadFreeITD->pNext;        /* Assert if the allocated memory pointer is invalid */        OS_ASSERT(NULL != pHeadFreeITD->pAllocatedMem);    	/* Free the iTD data structure */    	memPartFree(ehcdmemPartID, pHeadFreeITD->pAllocatedMem);        }    /* Update the head and tail pointers to NULL */    pHeadFreeITD = NULL;    pTailFreeITD = NULL;    /* Free the elements in the SITD list */    for (; pHeadFreeSITD != NULL; pHeadFreeSITD = pSITD)        {    	/* Store the next pointer temporarily */    	pSITD = pHeadFreeSITD->pNext;        /* Assert if the allocated memory pointer is invalid */        OS_ASSERT(NULL != pHeadFreeSITD->pAllocatedMem);