usbhalinitexit.c

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

    USBHAL_DEBUG ("usbHalTcdDetach : Entering\n",0,0,0,0,0,0);

    /* Check the validity of the parameters */

    if ((pNexus == NULL)||(pNexus->handle == NULL))
        {

        /* WindView Instrumentation */ 

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

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

    /* Retrieve the hal data structure */

    pUsbHal = (pUSBHAL_TCD)pNexus->handle;

    /* Acquire the mutex for the TCD */

    OSS_MUTEX_TAKE(pUsbHal->mutex, OSS_BLOCK);

    /*
     * If the pointer to the array of Pipe pointers is not NULL, then
     * the active endpoints should be deleted
     */

    if (pUsbHal->pPipeInfo != NULL)
        {
        for (uIndex = 0;
             (uIndex < pUsbHal->halDeviceInfo.uNumberEndpoints);
             uIndex++)
            {

            /*
             * If the array element is valid, call the function to delete the 
             * pipe
             */

            if (*((pUsbHal->pPipeInfo) + uIndex) != NULL)
                {
                if (usbHalTcdEndpointRelease (pNexus,
                                          *((pUsbHal->pPipeInfo) + uIndex)) != 
                                          OK)
                    {
                    /* Release the mutex */
                    OSS_MUTEX_RELEASE(pUsbHal->mutex);

                    return ERROR;
                    }
                }
            }

        /* Free up the memory allocated for the array of pointers */

        OSS_FREE(pUsbHal->pPipeInfo);
        }

    /* Release the mutex */

    OSS_MUTEX_RELEASE(pUsbHal->mutex);

    /* Populate the TRB - Start */

    trbHeaderInit((pTRB_HEADER)&trbDetach,
                  pUsbHal->pTCDHandle,
                  TCD_FNC_DETACH,
                  sizeof(TRB_HEADER));
    
    /* Populate the TRB - End */

    /* Call the single entry point for the TCD */

    status = (*pUsbHal->tcdExecFunc)(&trbDetach);

    /* Check if the function is executed successfully */

    if (status != OK)
        {

        /* WindView Instrumentation */ 

        USB_HAL_LOG_EVENT(USB_HAL_DEVICE_CNTL,
        "usbHalTcdDetach exiting: Error in detaching TCD...",
        USB_HAL_WV_FILTER);   

        USBHAL_ERR ("usbHalTcdDetach : Error in detaching TCD\n",0,0,0,0,0,0);
        }


    /* Destroy the thread created */

    OSS_THREAD_DESTROY(pUsbHal->threadId);

    /* Destroy the mutex */

    OSS_MUTEX_DESTROY(pUsbHal->mutex);

    /* Destroy the semaphore */

    OSS_SEM_DESTROY(pUsbHal->intPendingSemaphore);

    /* Delete the memory allocated for the HAL TCD data structure */

    OSS_FREE(pUsbHal);

    /* Reset the TCD handle value stored in pNexus */

    pNexus->handle = NULL;

    USBHAL_DEBUG ("usbHalTcdDetach : Exiting\n",0,0,0,0,0,0);
    return status;
    }

/*******************************************************************************
*
* usbHalTcdEnable - enables the target controller.
*
* This sub-routine is used to enable the Target Controller.
*
* RETURNS: OK if target controller is successfully enabled, ERROR otherwise.
*
* ERRNO:
*   None.
*/
STATUS usbHalTcdEnable
    (
    pUSBHAL_TCD_NEXUS	pNexus   /* USBHAL_TCD_NEXUS */
    )
    {
    pUSBHAL_TCD		pUsbHal = NULL;	/* USBHAL_TCD */
    TRB_ENABLE_DISABLE	trbEnable;	/* TRB_ENABLE_DISABLE */
    STATUS		status = ERROR;

    /* WindView Instrumentation */

    USB_HAL_LOG_EVENT(USB_HAL_INIT_EXIT,"usbHalTcdEnable entered ...",
    USB_HAL_WV_FILTER);   

    USBHAL_DEBUG ("usbHalTcdEnable : Entering\n",0,0,0,0,0,0);

    /* Check the validity of the parameters */

    if ((pNexus == NULL)||(pNexus->handle == NULL))
        {

        /* WindView Instrumentation */ 

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

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

    /* Retrieve the hal data structure */

    pUsbHal = (pUSBHAL_TCD)pNexus->handle;

    /* Populate the TRB - Start */

    trbHeaderInit((pTRB_HEADER)&trbEnable,
                  pUsbHal->pTCDHandle,
                  TCD_FNC_ENABLE,
                  sizeof(TRB_ENABLE_DISABLE));

    /* Populate the TRB - End */

    /* Call the single entry point for the TCD */

    status = (*pUsbHal->tcdExecFunc)(&trbEnable);

    /* If the return status is an error, display an error message */

    if (status == ERROR)
        {

        /* WindView Instrumentation */ 

        USB_HAL_LOG_EVENT(USB_HAL_DEVICE_CNTL,
        "usbHalTcdEnable exiting: SEP returned ERROR...",
        USB_HAL_WV_FILTER);   

        USBHAL_ERR ("usbHalTcdEnable : SEP returned ERROR - exiting\n",
                    0,0,0,0,0,0);
        }
    else
        {
        USBHAL_DEBUG ("usbHalTcdEnable : Success - exiting\n",0,0,0,0,0,0);
        }
    return status;
    }

/*******************************************************************************
*
* usbHalTcdDisable - disables the target controller
*
* This sub-routine is used to disable the target controller.
*
* RETURNS: OK if target controller is successfully disabled, ERROR otherwise.
*
* ERRNO:
*   None.
*/

STATUS usbHalTcdDisable
    (
    pUSBHAL_TCD_NEXUS	pNexus		/* USBHAL_TCD_NEXUS */
    )
    {
    pUSBHAL_TCD		pUsbHal = NULL;	/* USBHAL_TCD */
    TRB_ENABLE_DISABLE	trbDisable;	/* TRB_ENABLE_DISABLE */	
    STATUS		status = ERROR;

    /* WindView Instrumentation */

    USB_HAL_LOG_EVENT(USB_HAL_INIT_EXIT,"usbHalTcdDisable entered ...",
    USB_HAL_WV_FILTER);   

    USBHAL_DEBUG ("usbHalTcdDisable : Entering\n",0,0,0,0,0,0);

    /* Check the validity of the parameters */

    if ((pNexus == NULL)||(pNexus->handle == NULL))
        {

        /* WindView Instrumentation */ 

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

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

    /* Retrieve the hal data structure */

    pUsbHal = (pUSBHAL_TCD)pNexus->handle;

    /* Populate the TRB - Start */

    trbHeaderInit((pTRB_HEADER)&trbDisable,
                  pUsbHal->pTCDHandle,
                  TCD_FNC_DISABLE,
                  sizeof(TRB_ENABLE_DISABLE));

    /* Populate the TRB - End */

    /* Call the single entry point for the TCD */

    status = (*pUsbHal->tcdExecFunc)(&trbDisable);
    
    /* If the return status is an error, display an error message */

    if (status == ERROR)
        {

        /* WindView Instrumentation */ 

        USB_HAL_LOG_EVENT(USB_HAL_DEVICE_CNTL,
        "usbHalTcdDisable exiting: SEP returned ERROR...",
        USB_HAL_WV_FILTER);   

        USBHAL_ERR("usbHalTcdDisable : SEP returned ERROR - exiting\n",
                    0,0,0,0,0,0);
        }
    else
        {

        /* WindView Instrumentation */
 
        USB_HAL_LOG_EVENT(USB_HAL_INIT_EXIT,"usbHalTcdDisable exiting ...",
        USB_HAL_WV_FILTER);

        USBHAL_DEBUG ("usbHalTcdDisable : Success - exiting\n",0,0,0,0,0,0);
        }
    return status;
    }

/*******************************************************************************
*
* usbHalFreeTCDResources - frees HAL Resources
*
* This function frees the resources allocated for the HAL TCD data structure.
*
* RETURNS: None.
*
* ERRNO:
*   None.
*
* \NOMANUAL
*/

LOCAL VOID usbHalFreeTCDResources
    (
    pUSBHAL_TCD	pUsbHal			/* USBHAL_TCD */
    )
    {

    USBHAL_DEBUG("usbHalFreeTCDResources : Entering\n",0,0,0,0,0,0);

    /* Check if the parameter passed is valid */
 
   if (pUsbHal == NULL)
        {
        USBHAL_ERR("usbHalFreeTCDResources : Invalid parameter\n",0,0,0,0,0,0);
        return;
        }


    /* If the thread ID is valid, destroy the thread created */

    if (pUsbHal->threadId != NULL)
        OSS_THREAD_DESTROY(pUsbHal->threadId);

    /* If semaphore handle is valid, destroy the semaphore */

    if (pUsbHal->intPendingSemaphore != NULL)
        OSS_SEM_DESTROY(pUsbHal->intPendingSemaphore);

    /* If mutex handle is valid, destroy the mutex */

    if (pUsbHal->mutex != NULL)
        OSS_MUTEX_DESTROY(pUsbHal->mutex);

    /* Delete the memory allocated for the HAL TCD data structure */

    OSS_FREE(pUsbHal);

    USBHAL_DEBUG("usbHalFreeTCDResources : Exiting\n",0,0,0,0,0,0);

    return;
    }