(    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. */