usbtransunitinit.c

This the compressed USB driver source code for vxworks5.6. It has device controller driver and other

    (
    pVOID driverParam
    )

    {
    UINT32 message;
    pUSBTU_CLIENTMSG pMessage;
    pUSBTU_DEVICE_DRIVER pDriverInfo = (pUSBTU_DEVICE_DRIVER) driverParam;
    pUSBTU_NODE_INFO pDevInfo;

    USBTU_LOG ( " Client Thread Function : usbtuInitClientThreadFn entered \n");

    while(1)
        {

        /* wait for a message */

        msgQReceive(pDriverInfo->msgQid,
                    (char*)&message,
                    sizeof(UINT32),
                    WAIT_FOREVER);

        /* get the message pointer  */

        pMessage = (pUSBTU_CLIENTMSG)message;

        switch (pMessage->eventCode)
            {
            case ADDDEVICE:

                /* message indicates device add event */

                USBTU_LOG ( "usbtuInitClientThreadFn ADDDEVICE message received \n");

                /* Wind View Instrumentation */

                if ((usbtuInitWvFilter & USBTU_WV_FILTER) == TRUE)
                    {
                    char evLog[USBTU_WV_LOGSIZE];
                    strncpy ((char*)evLog, (char *)(pDriverInfo->clientName),USBD_NAME_LEN );
                    strcat(evLog, " : ADDDEVICE Event ");
                    USB_HCD_LOG_EVENT(USBTU_WV_CLIENT_INIT, evLog, USBTU_WV_FILTER);
                    }

                /* call the user supplied callback */

                (*pDriverInfo->attachCallback)
                    (
                    (USBD_NODE_ID) pMessage->hDevice,USBD_DYNA_ATTACH,
                    0,
                    pMessage->interface,
                    pDriverInfo->class,
                    pDriverInfo->subclass,
                    pDriverInfo->protocol
                    );

                break;

            case REMOVEDEVICE:

                /* message indicates device removal event */

                USBTU_LOG("usbtuInitClientThreadFn REMOVEDEVICE message received\n");

                /* Wind View Instrumentation */

                if ((usbtuInitWvFilter & USBTU_WV_FILTER) == TRUE)
                    {
                    char evLog[USBTU_WV_LOGSIZE];
                    strncpy ((char*)evLog,(char *)(pDriverInfo->clientName),USBD_NAME_LEN );
                    strcat(evLog, " : REMOVEDEVICE Event ");
                    USB_HCD_LOG_EVENT(USBTU_WV_CLIENT_INIT, evLog, USBTU_WV_FILTER);
                    }

                /* call the user supplied callback */

                 (*pDriverInfo->attachCallback)
                    (
                    (USBD_NODE_ID)pMessage->hDevice,
                    USBD_DYNA_REMOVE,
                    1,
                    pMessage->interface,
                    pDriverInfo->class,
                    pDriverInfo->subclass,
                    pDriverInfo->protocol);

                 /* remove the device structure from global list */

                 OSS_MUTEX_TAKE (usbtuMutex, OSS_BLOCK);

                 pDevInfo = usbListFirst (&usbtuDevList);

                 while (pDevInfo != NULL)
                     {
                     if ( pDevInfo->hDevice == pMessage->hDevice )
	                 break;

                     pDevInfo = usbListNext (&pDevInfo->devLink);

                     }

                 if (!(pDevInfo))
                     {
                     /* did not find device structure */

                     OSS_FREE (pMessage);
                     OSS_MUTEX_RELEASE (usbtuMutex);
                     USBTU_LOG ( "usbtuInitClientThreadFn device not found \n");
                     continue;

                     }

                /* unlink structure for device */

                usbListUnlink(&pDevInfo->devLink);

                OSS_MUTEX_RELEASE (usbtuMutex);

                /* Free the node structure */

                OSS_FREE(pDevInfo);

                break;

            case SUSPENDDEVICE:

                /* message indicates device suspend event */

                USBTU_LOG("usbtuInitClientThreadFn SUSPENDDEVICE message received\n");

                /* Wind View Instrumentation */

                if ((usbtuInitWvFilter & USBTU_WV_FILTER) == TRUE)
                    {
                    char evLog[USBTU_WV_LOGSIZE];
                    strncpy ((char*)evLog, (char *)(pDriverInfo->clientName),USBD_NAME_LEN );
                    strcat(evLog, " : SUSPENDDEVICE Event ");
                    USB_HCD_LOG_EVENT(USBTU_WV_CLIENT_INIT, evLog, USBTU_WV_FILTER);
                    }

                /* no code defined for suspend event by Wind River,
                 * so no call back called
                 */

                break;

            case RESUMEDEVICE:

                /* message indicates device resume event */

                USBTU_LOG("usbtuInitClientThreadFn RESUMEDEVICE message received\n");

                /* Wind View Instrumentation */

                if ((usbtuInitWvFilter & USBTU_WV_FILTER) == TRUE)
                    {
                    char evLog[USBTU_WV_LOGSIZE];
                    strncpy ((char*)evLog, (char *)(pDriverInfo->clientName),USBD_NAME_LEN );
                    strcat(evLog, " : RESUMEDEVICE Event ");
                    USB_HCD_LOG_EVENT(USBTU_WV_CLIENT_INIT, evLog, USBTU_WV_FILTER);
                    }

                /* call the user supplied callback */

                 if ( pDriverInfo->mngmtCallback == NULL)
                     {
                     USBTU_LOG( " management callback NULL \n ");
                     }
                 else
                 {

                 (*(pDriverInfo->mngmtCallback))
                    (
                    pDriverInfo->mngmtCallbackParam,
                    (USBD_NODE_ID)pMessage->hDevice,
                    USBD_MNGMT_RESUME
                    );
                 }

                 break;

            default:
                break;
            }

            OSS_FREE (pMessage);
            USBTU_LOG("usbtuInitClientThreadFn continues to wait for more \
                       messages\n");
        }
    }


/***************************************************************************
*
* usbtuInitClientIrpCompleteThreadFn - Client Thread Function
*
* This function is executed by a client Thread.
* The thread waits on the  message queue created for the client
* The message is of the type USBTU_CLIENTMSG.
* Based on the USBTU_EVENTCODE in the message it performs the action.
*
* RETURNS: N/A
*
* ERRNO: N/A
*/


VOID usbtuInitClientIrpCompleteThreadFn
    (
    pVOID driverParam
    )

    {
    UINT32 message;
    pUSB_IRP        pIrp;
    pUSBTU_DEVICE_DRIVER pDriverInfo = (pUSBTU_DEVICE_DRIVER) driverParam;
 
    USBTU_LOG ( " Client Thread Function : usbtuInitClientIrpCompleteThreadFn entered \n");

    while(1)
        {

        /* wait for a message */

        msgQReceive(pDriverInfo->msgQidIrpComplete,
                    (char*)&message,
                    sizeof(UINT32),
                    WAIT_FOREVER);

        /* get the message pointer  */
        pIrp =     (pUSB_IRP) message;


                /* message indicates IRP completion event */

                USBTU_LOG("usbtuInitClientIrpCompleteThreadFn IRPCOMPLETE message received\n");

                /* call the user supplied IRP completion callback */
        (*pIrp->userCallback)(pIrp);
            USBTU_LOG("usbtuInitClientIrpCompleteThreadFn continues to wait for more \
                       messages\n");
        }
    }

/***************************************************************************
*
* usbtuInitDeviceAdd - Device Attach Callback
*
* This function is called from interrupt context by USBD
* on a device attach.
*
* RETURNS: USBHST_SUCCESS, or USBHST_FAILURE on failure
*
* ERRNO: N/A
*/

USBHST_STATUS usbtuInitDeviceAdd
    (
    UINT32 hDevice,
    UINT8 interfaceNumber,
    UINT8 speed,
    void** ppDriverData
    )

    {
    pUSBTU_TUMSG   pTuMessage;

    USBTU_LOG ( " Device Attach Callback usbtuInitDeviceAdd() entered \n");

    /* allocate a message structure to send to Translation Unit thread */

    if ( !(pTuMessage = OSS_CALLOC( sizeof (USBTU_TUMSG))))
        {
        USBTU_LOG ( "usbtuInitDeviceAdd malloc failed \n");
        return USBHST_FAILURE;
        }
    else
        {

        /* initialize message structure */

        pTuMessage->eventCode = ADDDEVICE;
        pTuMessage->hDevice = hDevice;
        pTuMessage->interface = interfaceNumber;
        pTuMessage->ppDriverData = ppDriverData;

        /* send message ptr */

        if (msgQSend(usbtuMsgQid,(char *) &pTuMessage , sizeof(char *),
                     NO_WAIT, MSG_PRI_URGENT )
                     !=OK)
            USBTU_LOG ( "tuinitDeviceAdd msgQSend failed \n");
        }

    USBTU_LOG ( "usbtuInitDeviceAdd left \n");
    return USBHST_SUCCESS;

    }

/***************************************************************************
*
* usbtuInitDeviceRemove - Device Detach Callback
*
* This function is called from interrupt context by USBD
* on a device detach.
*
* RETURNS: N/A
*
* ERRNO: N/A
*/

VOID usbtuInitDeviceRemove
    (
    UINT32 hDevice,
    PVOID pDriverData
    )

    {
    pUSBTU_TUMSG   pTuMessage;

    USBTU_LOG ( " Device Detach Callback usbtuInitDeviceRemove() entered \n");

    /* allocate a message structure to send to Translation Unit thread */

    if ( !(pTuMessage = OSS_CALLOC( sizeof (USBTU_TUMSG))))
        {
        USBTU_LOG ( "usbtuInitDeviceRemove malloc failed \n");
        }
    else
        {

        /* initialize message structure */

        pTuMessage->eventCode = REMOVEDEVICE;
        pTuMessage->hDevice = hDevice;
        pTuMessage->ppDriverData = pDriverData;

        /* send message ptr */

        if ( msgQSend(usbtuMsgQid,(char *) &pTuMessage,
                      sizeof(char *) , NO_WAIT, MSG_PRI_URGENT )
                      != OK)

            USBTU_LOG ( "usbtuInitDeviceRemove msgQSend failed \n");
        }

    USBTU_LOG ( "usbtuInitDeviceRemove left \n");

    }

/***************************************************************************
*
* usbtuInitDeviceSuspend - Device Suspend Callback
*
* This function is called from interrupt context by USBD
* on a device suspend.
*
* RETURNS: N/A
*
* ERRNO: N/A
*/

VOID usbtuInitDeviceSuspend
    (
    UINT32 hDevice,
    PVOID ppSuspendData
    )

    {
    pUSBTU_TUMSG   pTuMessage;

    USBTU_LOG ( "Device Suspend Callback usbtuInitDeviceSuspend() entered \n");


    /* allocate a message structure to send to Translation Unit thread */

    if ( !(pTuMessage = OSS_CALLOC( sizeof (USBTU_TUMSG))))
        {
        USBTU_LOG ( "usbtuInitDeviceSuspend malloc failed \n");
        }
    else
        {

        /* initialize message structure */

        pTuMessage->eventCode = SUSPENDDEVICE;
        pTuMessage->hDevice = hDevice;
        pTuMessage->ppDriverData = ppSuspendData;

        /* send message ptr */

        if ( msgQSend(usbtuMsgQid,(char *) &pTuMessage,
                      sizeof(char *) , NO_WAIT, MSG_PRI_URGENT )
                      != OK)
            USBTU_LOG ( "usbtuInitDeviceSuspend msgQSend failed \n");
        }

    USBTU_LOG ( "usbtuInitDeviceSuspend left \n");

    }

/***************************************************************************
*
* usbtuInitDeviceResume - Device Resume Callback
*
* This function is called from interrupt context by USBD
* on a device resume.
*
* RETURNS: N/A
*
* ERRNO: N/A
*/

VOID usbtuInitDeviceResume
    (
    UINT32 hDevice,
    PVOID pSuspendData
    )

    {
    pUSBTU_TUMSG   pTuMessage;

    USBTU_LOG ( "Device Resume Callback usbtuInitDeviceResume() entered \n");

    /* allocate a message structure to send to Translation Unit thread */

    if (!(pTuMessage = OSS_CALLOC( sizeof (USBTU_TUMSG))))
        {
        USBTU_LOG ( "usbtuInitDeviceResume malloc failed \n");
        }
    else
        {

        /* initialize message structure */

        pTuMessage->eventCode = RESUMEDEVICE;
        pTuMessage->hDevice = hDevice;
        pTuMessage->ppDriverData = pSuspendData;

        /* send message ptr  */

        if ( msgQSend(usbtuMsgQid,(char *) &pTuMessage , sizeof(char *),
                      NO_WAIT, MSG_PRI_URGENT )
                      != OK )
            USBTU_LOG ( "usbtuInitDeviceResume msgQSend failed \n");
        }

    USBTU_LOG ( "usbtuInitDeviceResume left \n");

    }
/* End of file. */