usbtransunitdata.c

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

    pUSBTU_IRP tempIrp;
    pUSBTU_IRP prevIrp;

    if(pIrp == NULL)
       return ERROR;

    /* Check if the pipe handle is valid */
    if (pipeInfo == NULL)
       return ERROR;

    /* remove the IRP from the list maintained - start */

    /* Take the mutex before accessing the list */
    OSS_MUTEX_TAKE (usbtuMutex, OSS_BLOCK);

    tempIrp = pipeInfo->irpList;
    prevIrp = pipeInfo->irpList;

    while(tempIrp != NULL )
        {
      	if(tempIrp->pIrp == pIrp )
            break;
        else
           {
           prevIrp =  tempIrp;
           tempIrp = tempIrp->nextIrp;
           }
        }

    if (tempIrp == NULL)
        {
        OSS_MUTEX_RELEASE (usbtuMutex);
	    return ERROR;	          
        }

    if(tempIrp == prevIrp)
       pipeInfo->irpList = pipeInfo->irpList->nextIrp;
    else
       {
       prevIrp->nextIrp = tempIrp->nextIrp;
       if(tempIrp->nextIrp != NULL)
            tempIrp->nextIrp->prevIrp = prevIrp;
       }

    OSS_FREE (tempIrp);

    /* remove the IRP from the list maintained - End */

    /* Release the mutex after accessing the list */
    OSS_MUTEX_RELEASE (usbtuMutex);

    pIrpContext = pIrp->usbdPtr;


    /* Check for NULL Pointer */
    if (pIrpContext == NULL)
    {
       USBTU_LOG ("IRP context is NULL\n");
       return ERROR;
    }


    if(pIrpContext->urbPtr == NULL)
       return ERROR;

    pUrb = pIrpContext->urbPtr;
    

    /* 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, " : USBD Transfer Abort "); 
        USB_HCD_LOG_EVENT(USBTU_WV_CLIENT_TRANSFER, evLog, USBTU_WV_FILTER);
        }  


    USBTU_LOG ( "usbdTransferAbort entered \n ");

    /* if all the URB's are completed , there is nothing to abort */

    if (pIrpContext->urbCompleteCount == pIrp->bfrCount)
        {
        USBTU_LOG ( "Transfer Completed! \n ");
        return OK;
        }

    /* abort the URB's and release URB specific resources */

    for ( i = 0 ; i < pIrp->bfrCount ; i++ )
        {

        status = usbHstURBCancel( &(pUrb[i]));

        if ((status == USBHST_TRANSFER_COMPLETED) ||
            (status == USBHST_INVALID_PARAMETER) || 
             (status == USBHST_INVALID_REQUEST))
      
            {
            USBTU_LOG ( "usbdTransferAbort CancelURB failed \n ");
            s = ERROR;
            break;
            }

        /* This will be freed by the callback */
        if ( pUrb[i].pTransferSpecificData)
            OSS_FREE (pUrb[i].pTransferSpecificData);
        }

    /* Call callback if the cancelling is successful */
     
     if ( s!= ERROR)
         {
     pIrp->result = S_usbHcdLib_IRP_CANCELED;

    (*pIrp->userCallback)(pIrp);


    /* Release resources */

    OSS_FREE(pUrb);

    OSS_FREE(pIrpContext);
    pIrp->usbdPtr = NULL;

         }

    if ( s == OK)
        {
        USBTU_LOG ( "usbdTransferAbort return OK \n ");
        }
    else
        {
        USBTU_LOG ( "usbdTransferAbort return ERROR \n ");
        }

    return s;

   }


/***************************************************************************
*
* usbdVendorSpecific - Allows clients to issue vendor-specific USB requests
*
* Certain devices may implement vendor-specific USB requests which cannot
* be generated using the standard functions described elsewhere.  This
* function allows a client to specify directly the exact parameters for a
* USB control pipe request.
*
* <requestType>, <request>, <value>, <index>, and <length> correspond
* exactly to the bmRequestType, bRequest, wValue, wIndex, and wLength fields
* defined by the USB Specfication.  If <length> is greater than zero, then
* <pBfr> must be a non-NULL pointer to a data buffer which will provide or
* accept data, depending on the direction of the transfer.
*
* Vendor specific requests issued through this function are always directed
* to the control pipe of the device specified by <nodeId>.  This function
* formats and sends a Setup packet based on the parameters provided.  If a
* non-NULL <pBfr> is also provided, then additional IN or OUT transfers
* will be performed following the Setup packet.  The direction of these
* transfers is inferred from the direction bit in the <requestType> param.
* For IN transfers, the actual length of the data transferred will be
* stored in <pActLen> if <pActLen> is not NULL.
*
* RETURNS: OK, or ERROR if unable to execute vendor-specific request.
*
* ERRNO: N/A
*/

STATUS usbdVendorSpecific
    (
    USBD_CLIENT_HANDLE clientHandle,	/* Client handle */
    USBD_NODE_ID nodeId,		/* Node Id of device/hub */
    UINT8 requestType,			/* bmRequestType in USB spec. */
    UINT8 request,			/* bRequest in USB spec. */
    UINT16 value,			/* wValue in USB spec. */
    UINT16 index,			/* wIndex in USB spec. */
    UINT16 length,			/* wLength in USB spec. */
    pUINT8 pBfr,			/* ptr to data buffer */
    pUINT16 pActLen			/* actual length of IN */
    )

    {
    pUSBHST_URB pUrb;
    pUSBHST_SETUP_PACKET pSetupPacket;
    SEM_ID semMutex;
    STATUS s = OK;
    pUSBTU_DEVICE_DRIVER pDriver = (pUSBTU_DEVICE_DRIVER) clientHandle;


    /* 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, " : Vendor Specific Transfer "); 
        USB_HCD_LOG_EVENT(USBTU_WV_CLIENT_TRANSFER, evLog, USBTU_WV_FILTER);
        }  


    USBTU_LOG ( "usbdVendorSpecific entered \n ");

    if (pActLen != NULL)
        *pActLen = 0;

    /* allocate a URB structure */

    if ( !(pUrb =  OSS_CALLOC ( sizeof (USBHST_URB ))))
        {
        USBTU_LOG ( "usbdVendorSpecific returns ERROR: malloc failed \n ");
        return ERROR;
        }

    /* allocate a setup packet structure */

    if ( !(pSetupPacket = OSS_CALLOC ( sizeof (USBHST_SETUP_PACKET))))
        {
        OSS_FREE (pUrb);
        USBTU_LOG ( "usbdVendorSpecific returns ERROR: malloc1 failed \n ");
        return ERROR;
        }

    /* initialize the setup packet structure */

    USBHST_FILL_SETUP_PACKET(pSetupPacket,requestType,request,value,
                             index,length);

    /* since the call has to block, create a semaphore */

    if ( !(semMutex = semBCreate (SEM_Q_FIFO,SEM_EMPTY)))
        {
        OSS_FREE (pUrb);
        OSS_FREE (pSetupPacket);
        USBTU_LOG ( "usbdVendorSpecific returns ERROR: sem create failed \n ");
        return ERROR;
        }

    /* initialize the URB structure */

    USBHST_FILL_CONTROL_URB (pUrb,
                             (UINT32)nodeId,
                             0,
                             pBfr,
                             length,
                             USBHST_SHORT_TRANSFER_OK,
                             (PVOID)pSetupPacket,
                             usbtuDataVendorSpecificCallback,
                             (PVOID)semMutex,
                             USBHST_SUCCESS
                             );



    /* submit the URB */



    if ( usbHstURBSubmit (pUrb) != USBHST_SUCCESS)
       {
       /* failed to submit the URB */

       OSS_FREE (pUrb);
       OSS_FREE (pSetupPacket);
       semDelete (semMutex);
       USBTU_LOG ( "usbdVendorSpecific returns ERROR: SubmitURB failed \n ");
       return ERROR;
       }

    /* block till vendor specific callback releases the semaphore */

    USBTU_LOG(" waiting for transfer to complete \n ");


    semTake (semMutex, WAIT_FOREVER);

    USBTU_LOG(" transfer completed \n ");

    /* URB completed, callback released the semaphore */

    if (pUrb->nStatus != USBHST_SUCCESS )
       {
       USBTU_LOG("usbdVendorSpecific returns ERROR:URB status!=USBHST_SUCCESS\n");
       s = ERROR;
       }

    /* update length fo data transfer */

    if (pActLen != NULL)
        *pActLen = pUrb->uTransferLength;

    /* release resources allocated */

    OSS_FREE (pUrb);
    OSS_FREE (pSetupPacket);
    semDelete (semMutex);

    /* return status */

    if ( s == OK)
        {
        USBTU_LOG ( "usbdVendorSpecific returns OK \n ");
        }
    else
        {
        USBTU_LOG ( "usbdVendorSpecific returns ERROR \n ");
        }

    return s;

    }

/***************************************************************************
*
* usbtuDataUrbCompleteCallback - Callback called on URB completeion
*
* This function is called from interrupt context by the USBD on a
* URB completion.
* RETURNS:  USBHST_SUCCESS , or USBHST_FAILURE on failure
*
* ERRNO: N/A
*/
USBHST_STATUS usbtuDataUrbCompleteCallback
    (
    pUSBHST_URB urbPtr       /* URB pointer */
    )

    {
    pUSBHST_URB pUrb = (pUSBHST_URB) urbPtr;
    pUSB_IRP pIrp = (pUSB_IRP)pUrb->pContext;
    pUSBTU_IRPCONTEXT pIrpContext = pIrp->usbdPtr;
    MSG_Q_ID msgQid;
    pUSBTU_IRP tempIrp;
    pUSBTU_IRP prevIrp;

    USBTU_LOG ( "usbtuDataUrbCompleteCallback entered \n ");

    /* map the error codes */

    if ( pUrb->nStatus != USBHST_SUCCESS )
        {

        switch (pUrb->nStatus)
            {
            case USBHST_TRANSFER_CANCELLED :
                pIrp->result = S_usbHcdLib_IRP_CANCELED;
                break;
             case USBHST_DATA_UNDERRUN_ERROR :
                pIrp->result = S_usbHcdLib_DATA_BFR_FAULT;
                break;
             case USBHST_TIMEOUT :
                pIrp->result = S_usbHcdLib_CRC_TIMEOUT;
                break;
             case USBHST_STALL_ERROR :
                pIrp->result = S_usbHcdLib_STALLED;
                break;
             case USBHST_DEVICE_NOT_RESPONDING_ERROR :
                pIrp->result = S_usbHcdLib_IRP_CANCELED;
                break;
             default:
              pIrp->result = ERROR;

             }
         }
    else
        pIrp->result = OK;

    /* release URB specific resources */

    if (pUrb->pTransferSpecificData)
        OSS_FREE(pUrb->pTransferSpecificData);

    /* Update the number of bytes transferred */
    pIrp->bfrList[pIrpContext->urbCompleteCount].actLen  = pUrb->uTransferLength;



    /* increment the URB completion count */

    (pIrpContext->urbCompleteCount)++;

    /* if all URB's have completed , call the callback  */

    if ( pIrpContext->urbCompleteCount == pIrp->bfrCount)
        {
        /* get the message queue id */
        msgQid = pIrpContext->msgQid;
        

      if ( msgQSend(msgQid,(char *) &pIrp ,
                         sizeof(char *) , NO_WAIT, MSG_PRI_NORMAL)
                         != OK)
                {
                USBTU_LOG ( "usbtuDataUrbCompleteCallback msgQSend failed \n ");
                }
        /* Take the mutex before accessing the list */
        OSS_MUTEX_TAKE (usbtuMutex, OSS_BLOCK);        

        tempIrp =pIrpContext->pipeInfo->irpList;
        prevIrp =pIrpContext->pipeInfo->irpList;

        /* unlink the irp from pipe info structure */

        while(tempIrp != NULL )
            {
            	if(tempIrp->pIrp == pIrp )
            	   break;
                else
                   {
                    prevIrp =  tempIrp;
                    tempIrp = tempIrp->nextIrp;
                   }
            }

       /* If the IRP is present, unlink it from the pipe's 
        * request list
        */ 
       if (tempIrp != NULL)
           {
       if(tempIrp == prevIrp)
       pIrpContext->pipeInfo->irpList = pIrpContext->pipeInfo->irpList->nextIrp;
       else
       {
       	 prevIrp->nextIrp = tempIrp->nextIrp;
       	 if( tempIrp->nextIrp)
            tempIrp->nextIrp->prevIrp = prevIrp;
       }
       OSS_FREE (tempIrp);
           }

        /* If the pipe is marked for deletion and the list is empty,
         * signal the semaphore so that the pipe can be safely deleted
         */
        if ((pIrpContext->pipeInfo->markedForDeletion == 1) &&
        (pIrpContext->pipeInfo->irpList == NULL)
         && (pIrpContext->pipeInfo->PipeDelete != NULL))
           {
           semGive(pIrpContext->pipeInfo->PipeDelete);
           }

        /* Release the semaphore */
        OSS_MUTEX_RELEASE (usbtuMutex);

        /* release IRP context resources */
        OSS_FREE ( pIrpContext->urbPtr);
        OSS_FREE ( pIrpContext);


        }

    USBTU_LOG ( "usbtuDataUrbCompleteCallback left \n ");
    return USBHST_SUCCESS;
    }

/***************************************************************************
*
* usbtuDataVendorSpecificCallback - Callback called on Vendor Specific Request
* completeion
*
* This function is called from interrupt context by the USBD on a
* Vendor Specific request completion.
*
* RETURNS:  USBHST_SUCCESS
*
* ERRNO: N/A
*/

USBHST_STATUS usbtuDataVendorSpecificCallback
    (
    pUSBHST_URB urbPtr   	/* URB pointer */
    )

    {
    pUSBHST_URB pUrb = (pUSBHST_URB) urbPtr;

    USBTU_LOG ( "usbtuDataVendorSpecificCallback entered \n ");

    /* release the semaphore */

    
    semGive (pUrb->pContext);
    
    USBTU_LOG ( "usbtuDataVendorSpecificCallback left \n ");
    return USBHST_SUCCESS;

    }

/* End of file. */