usbtransunitinit.c

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

    pUSBTU_DEVICE_DRIVER pDriver = (pUSBTU_DEVICE_DRIVER)clientHandle;

    USBTU_LOG ( "usbdDynamicAttachUnRegister entered \n");


    /* Wind View Instrumentation */

    if ((usbtuInitWvFilter & USBTU_WV_FILTER) == TRUE)
        {
        char evLog[USBTU_WV_LOGSIZE];
        strncpy ((char*)evLog,(char *)(pDriver->clientName),USBD_NAME_LEN );
        strcat(evLog, " : Dynamic Attach/Dettach Callback Unregister ");
        USB_HCD_LOG_EVENT(USBTU_WV_CLIENT_INIT, evLog, USBTU_WV_FILTER);
        }


    /* unregister */

    if ( pDriver->pDriverData )
        status = usbHstDriverDeregister (pDriver->pDriverData);

    if ( status != USBHST_SUCCESS)
        {
        USBTU_LOG ( "usbdDynamicAttachUnRegister returns ERROR \n");
        return ERROR;
        }
    else
        {
        /* reset client structure members  */

        pDriver->attachCallback = NULL;
        OSS_FREE (pDriver->pDriverData);
        pDriver->pDriverData = NULL;
        }

    USBTU_LOG ( "usbdDynamicAttachUnRegister returns OK \n");

    return OK;
    }

/***************************************************************************
*
* usbtuInitThreadFn - Translation Unit Thread Function
*
* This function is executed by the Translation Unit Thread.
* The thread waits on the  message queue created for the Translation Unit
* The message is of the type USBTU_TUMSG.
* Based on the USBTU_EVENTCODE in the message it performs appropriate actions
*
* RETURNS: N/A
*
* ERRNO: N/A
*/

VOID usbtuInitThreadFn 
    ( 
    pVOID param                      /* User Parameter */
    )
    {
    pUSB_CONFIG_DESCR pCfgDescr;
    pUSB_INTERFACE_DESCR pIfDescr;
    UINT8 * pBfr;
    UINT8 * pScratchBfr;
    UINT16 actLen;
    UINT16 ifNo;
    pUSBTU_NODE_INFO pNodeInfo;
    UINT32   message;
    pUSBTU_TUMSG pMessage;
    pUSBTU_CLIENTMSG pClientMessage;
    pUSBTU_DEVICE_DRIVER pDriverInfo;
    pUSBTU_NODE_INFO     pDevInfo;

    USBTU_LOG ( "Translation Unit Thread Function:usbtuInitThreadFn entered \n");

    while(1)
        {

        /* receive message */

        msgQReceive(usbtuMsgQid, (char*)&message,sizeof(UINT32), WAIT_FOREVER);


        /* get pointer to USBTU_TUMSG message structure */

        pMessage = (pUSBTU_TUMSG)message;

        switch (pMessage->eventCode)
            {
            case ADDDEVICE:

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


                /* message indicates device attach event */

                /* allocate buffer to get configuration descriptor */

                if ((pBfr = OSS_CALLOC (USB_MAX_DESCR_LEN)) == NULL)
                    {
                    OSS_FREE (pMessage);
                    USBTU_LOG ( "usbtuInitThreadFn malloc failed \n");
	                continue;
	                }

                /* Get the configuration descriptor  */

                if (usbdDescriptorGet (NULL,
		                              (USBD_NODE_ID)pMessage->hDevice,
		                              USB_RT_DEVICE,
		                              USB_DESCR_CONFIGURATION,
		                              0,
	                                  0,
	 	                              USB_MAX_DESCR_LEN,
		                              pBfr,
		                              &actLen)
		                              != OK)
	                {
	                OSS_FREE (pBfr);
	                OSS_FREE (pMessage);
                    USBTU_LOG("usbtuInitThreadFn usbdDescriptorGet failed \n");
    	            continue;
	                }

                if ((pCfgDescr = usbDescrParse (pBfr,
                                      	        actLen,
                                                USB_DESCR_CONFIGURATION))== NULL)
                    {
                    OSS_FREE (pBfr);
                    OSS_FREE (pMessage);
                    USBTU_LOG ( "usbtuInitThreadFn usbDescrParse failed \n");
                    continue;
                    }

                /* Look for required interface descriptor   */

                ifNo = 0;

                /*
                 * usbDescrParseSkip() modifies the value of the pointer
                 * it recieves.
                 * so we pass it a copy of our buffer pointer
                 */

                pScratchBfr = pBfr;

                while ((pIfDescr = usbDescrParseSkip (&pScratchBfr,
		               &actLen,
			           USB_DESCR_INTERFACE))
    			       != NULL)
    	            {
    	            if (ifNo == pMessage->interface)
	                    break;
    	            ifNo++;
    	            }

                if (pIfDescr == NULL)
                    {
                    OSS_FREE (pBfr);
                    OSS_FREE (pMessage);
                    USBTU_LOG("usbtuInitThreadFn usbDescrParseSkip failed\n");
                    continue;
                    }

                /* allocate structure for new device attached */

                if ( !(pNodeInfo = OSS_CALLOC( sizeof(USBTU_NODE_INFO))))
                    {
                    OSS_FREE (pBfr);
                    OSS_FREE (pMessage);
                    USBTU_LOG ( "usbtuInitThreadFn malloc1 failed \n");
                    continue;
                    }

                /* initialize members of structure */

                pNodeInfo->hDevice = pMessage->hDevice;
                pNodeInfo->configuration = 0;
                pNodeInfo->interface = pMessage->interface;

                /* search for client that manages device attached */

                OSS_MUTEX_TAKE (usbtuMutex, OSS_BLOCK);

                pDriverInfo = usbListFirst (&usbtuClientList);
                while (pDriverInfo != NULL)
                    {


                    if ((pDriverInfo->class == pIfDescr->interfaceClass) &&
                      (pDriverInfo->subclass == pIfDescr->interfaceSubClass) &&
                      (pDriverInfo->protocol == pIfDescr->interfaceProtocol))
	                    break;
                    
                    /* Check if driver only cared about class and subclass */
                    if ((pDriverInfo->class == pIfDescr->interfaceClass) &&
                      (pDriverInfo->subclass == pIfDescr->interfaceSubClass) &&
                      (pDriverInfo->protocol == USBD_NOTIFY_ALL))
	                    break;

                    /* Check if driver only cared about class */
                    if ((pDriverInfo->class == pIfDescr->interfaceClass) &&
                      (pDriverInfo->subclass == USBD_NOTIFY_ALL) &&
                      (pDriverInfo->protocol == USBD_NOTIFY_ALL))
	                    break;


                    pDriverInfo = usbListNext (&pDriverInfo->tuDriverLink);

                    }

                OSS_MUTEX_RELEASE(usbtuMutex);

                if (!(pDriverInfo))
                    {

                    /* no client registered for device type */

                    OSS_FREE (pNodeInfo);
                    OSS_FREE (pBfr);
                    OSS_FREE (pMessage);
                    USBTU_LOG ( "usbtuInitThreadFn no client for device \n");
                    continue;
                    }

                /* store message queue id of client */

                pNodeInfo->msgQid = pDriverInfo->msgQid;

                /* allocate a message structure to be sent to client thread */

                if ( !(pClientMessage = OSS_CALLOC (sizeof (USBTU_CLIENTMSG))))
                    {
                    OSS_FREE (pNodeInfo);
                    OSS_FREE (pBfr);
                    OSS_FREE (pMessage);
                    USBTU_LOG ( "usbtuInitThreadFn malloc2 failed \n");
                    continue;
                    }

                /* initialize message structure */

                pClientMessage->eventCode = ADDDEVICE;
                pClientMessage->hDevice = pNodeInfo->hDevice;
                pClientMessage->interface = pNodeInfo->interface;

                /* send the message to client thread */

                if ( msgQSend(pNodeInfo->msgQid,(char *) &pClientMessage,
                              sizeof(char *), NO_WAIT, MSG_PRI_URGENT )
                              != OK)
                    {

                    /* could not send message to client thread */

                    OSS_FREE (pNodeInfo);
                    OSS_FREE (pBfr);
                    OSS_FREE (pClientMessage);
                    OSS_FREE (pMessage);
                    USBTU_LOG ( "usbtuInitThreadFn msgQSend failed \n");
                    continue;
                    }

                /* update driver data with pointer to message q id */

                *(pMessage->ppDriverData) = pNodeInfo->msgQid;

                /* Link device structure to global list */

                OSS_MUTEX_TAKE (usbtuMutex, OSS_BLOCK);

                usbListLink (&usbtuDevList, pNodeInfo,
                             &(pNodeInfo->devLink), LINK_TAIL);

                OSS_MUTEX_RELEASE (usbtuMutex);

                /* Free the memory allocated for the buffer */

                OSS_FREE(pBfr);

                break;

            case REMOVEDEVICE:

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

                /* message indicates device removal event */

                /* allocate a message structure to send to client thread */

                if ( !(pClientMessage = OSS_CALLOC( sizeof (USBTU_CLIENTMSG))))
                    {
                    OSS_FREE (pMessage);
                    USBTU_LOG ( "usbtuInitThreadFn malloc failed \n");
                    continue;
                    }

                /* initialize message structure */

                pClientMessage->eventCode = REMOVEDEVICE;
                pClientMessage->hDevice = pMessage->hDevice;

                /* send message */

                if ( msgQSend((MSG_Q_ID)pMessage->ppDriverData,
                              (char *) &pClientMessage ,
                              sizeof(char *), NO_WAIT, MSG_PRI_URGENT)
                              != OK)
                    {

                    /* could not send message to client thread  */

                    OSS_FREE ( pClientMessage);
                    OSS_FREE (pMessage);
                    USBTU_LOG ( "usbtuInitThreadFn msgQSend failed \n");
                    continue;
                    }

                break;

             case SUSPENDDEVICE:

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

                 /* message indicates device suspend  event */

                 /* search devList for device structure */

                 OSS_MUTEX_TAKE (usbtuMutex, OSS_BLOCK);

                 pDevInfo = usbListFirst (&usbtuDevList);

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

                     pDevInfo = usbListNext (&pDevInfo->devLink);

                     }

                 OSS_MUTEX_RELEASE (usbtuMutex);

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

                     OSS_FREE (pMessage);
                     USBTU_LOG ( "usbtuInitThreadFn device not found \n");
                     continue;

                     }

                 /* allocate a message structure to send to client thread */

                 if ( !(pClientMessage = OSS_CALLOC(sizeof (USBTU_CLIENTMSG))))
                     {
                     OSS_FREE (pMessage);
                     USBTU_LOG ( "usbtuInitThreadFn malloc failed \n");
                     continue;
                     }

                 /* initialze message structure */

                 pClientMessage->eventCode = SUSPENDDEVICE;
                 pClientMessage->hDevice = pMessage->hDevice;

                 /* send message */

                 if ( msgQSend(pDevInfo->msgQid,(char *) &pClientMessage,
                               sizeof(char *), NO_WAIT, MSG_PRI_URGENT )
                               != OK)
                     {

                     /* could not send message to client */

                     OSS_FREE ( pClientMessage);
                     OSS_FREE (pMessage);
                     USBTU_LOG ( "usbtuInitThreadFn msgQSend failed \n");
                     continue;
                     }

                 /* update driver data */

                 *(pMessage->ppDriverData) = pDevInfo->msgQid;

                 break;

            case RESUMEDEVICE:

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

                /* message indicates device resume  event */

                /* allocate a message structure to be sent to client thread */


                if ( !(pClientMessage = OSS_CALLOC( sizeof (USBTU_CLIENTMSG))))
                    {
                    OSS_FREE (pMessage);
                    USBTU_LOG ( "usbtuInitThreadFn malloc failed \n");
                    continue;
                    }


                /* initialize message structure */

                pClientMessage->eventCode = RESUMEDEVICE;
                pClientMessage->hDevice = pMessage->hDevice;

                /* send the message to client  */

                if ( msgQSend((MSG_Q_ID)pMessage->ppDriverData,
                              (char *) &pClientMessage,
                               sizeof(char *),
                               NO_WAIT,
                               MSG_PRI_URGENT )
                               != OK )
                    {

                    /* could not send message to client */

                    OSS_FREE (pClientMessage);
                    OSS_FREE (pMessage);
                    USBTU_LOG ( "usbtuInitThreadFn msgQSend failed \n");
                    continue;
                    }

                break;
            default:
                break;
            }

        OSS_FREE(pMessage);

        USBTU_LOG("Translation Unit Thread Function:waiting for more messages\n");
        }
    }
/***************************************************************************
*
* usbtuInitClientThreadFn - 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 usbtuInitClientThreadFn