usbtransunitdata.c

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

* window for the underlying USB host controller.  The frame window specifies
* the maximum number of frames into the future (relative to the current frame
* number) which may be specified by <startFrame>.  <startFrame> should be
* specified only for isochronous transfers.
*
* <dataBlockSize> may also be specified for isochronous transfers.  If non-0,
* the <dataBlockSize> defines the granularity of isochronous data being sent.
* When the underlying Host Controller Driver (HCD) breaks up the transfer into
* individual frames, it will ensure that the amount of data transferred in
* each frame is a multiple of this value.
*
* <timeout> specifies the IRP timeout in milliseconds.	If the caller passes
* a value of zero, then the USBD sets a default timeout of USB_TIMEOUT_DEFAULT.
* If no timeout is desired, then <timeout> should be set to USB_TIMEOUT_NONE.
* Timeouts apply only to control and bulk transfers.  Isochronous and
* interrupt transfers do not time out.
*
* <bfrList> is an array of buffer descriptors which describe data buffers to
* be associated with this IRP.	If more than the one <bfrList> element is
* required then the caller must allocate the IRP by calculating the size as
*
* \cs
* irpLen = sizeof (USB_IRP) + (sizeof (USB_BFR_DESCR) * (bfrCount - 1))
* \ce
*
* <transferLen> must be the total length of data to be transferred.  In other
* words, transferLen is the sum of all <bfrLen> entries in the <bfrList>.
*
* <pid> specifies the packet type to use for the indicated buffer and is
* specified as USB_PID_xxxx.
*
* The IRP <userCallback> routine must point to a client-supplied IRP_CALLBACK
* routine.  The usbdTransfer() function returns as soon as the IRP has been
* successfully enqueued.  If there is a failure in delivering the IRP to the
* HCD, then usbdTransfer() returns an error.  The actual result of the IRP
* should be checked after the <userCallback> routine has been invoked.
*
* RETURNS: OK, or ERROR if unable to submit IRP for transfer.
*
* ERRNO: N/A
*/

STATUS usbdTransfer
    (
    USBD_CLIENT_HANDLE clientHandle,	/* Client handle */
    USBD_PIPE_HANDLE pipeHandle,	/* Pipe handle */
    pUSB_IRP pIrp			/* ptr to I/O request packet */
    )

    {
    pUSBTU_IRPCONTEXT pIrpContext;
    pUSBTU_PIPE_INFO pipeInfo = (pUSBTU_PIPE_INFO) pipeHandle;
    pUSBTU_DEVICE_DRIVER clientInfo = (pUSBTU_DEVICE_DRIVER) clientHandle;
    pUSBHST_ISO_PACKET_DESC pIsoPacketDesc;
    pUSBHST_URB pUrb;
    int no;
    int i;
    int bufferlength;
    int bufferIndex;
    int transferflag = 0;
    pUSBTU_DEVICE_DRIVER pDriver = (pUSBTU_DEVICE_DRIVER) clientHandle;
    pUSBTU_IRP tempIrp = NULL;
    UINT32 frameCount = 0;
    UINT32 bytesThroughFrameCount = 0;
    UINT32 maxLen= 0;
    UINT32 bytesSoFar = 0;

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



    USBTU_LOG ( "usbdTransfer entered \n ");

    /* control transfer type not handled by usbdTransfer */

    if (pipeInfo->transferType == USB_XFRTYPE_CONTROL)
        {
        USBTU_LOG ( "usbdTransfer returns ERROR : control transfer  \n ");
        return ERROR;
        }

    /* If pipe is marked for deletion return ERROR */

    if(pipeInfo->markedForDeletion)
        {
        USBTU_LOG ( "usbdTransfer returns ERROR : pipe marked for deletion  \n ");
        return ERROR;
        }


    /* allocate structure for IRP context */

    if ( !(pIrpContext = OSS_CALLOC ( sizeof (USBTU_IRPCONTEXT))))
        {
        USBTU_LOG ( "usbdTransfer returns ERROR : malloc  \n ");
        return ERROR;
        }

    /* allocate an array of URB structures one for each buffer */



    if (!(pIrpContext->urbPtr =
            OSS_CALLOC ( pIrp->bfrCount * sizeof(USBHST_URB))))
        {
         OSS_FREE (pIrpContext);
         USBTU_LOG ( "usbdTransfer returns ERROR : malloc1 failed  \n ");
         return ERROR;
        }

    /* set the array index */

    pIrpContext->urbIndex = 0;

    pIrpContext->pipeInfo = pipeInfo;


    pIrpContext->urbCompleteCount = 0;


    /* store the IRP context structure in IRP  */

    pIrp->usbdPtr = pIrpContext;

    /* set the initial status of IRP to OK */

    pIrp->result = OK;

    /* get the message queue id of client */

    pIrpContext->msgQid = clientInfo->msgQidIrpComplete;

    /* determine the transfer flag */

    if (pIrp->flags == USB_FLAG_SHORT_OK)
        transferflag = USBHST_SHORT_TRANSFER_OK;
    else
        {
        if ( pIrp->flags & USB_FLAG_ISO_ASAP)
            transferflag = USBHST_START_ISOCHRONOUS_TRANSFER_ASAP;
        }

    /* Allocate memory for irp link list element */

    if (!(tempIrp = OSS_CALLOC ( sizeof (USBTU_IRP))))
        {
         OSS_FREE(pIrpContext->urbPtr);
         OSS_FREE (pIrpContext);
         USBTU_LOG ( "usbdTransfer returns ERROR : malloc1 failed  \n ");
         return ERROR;
        }

    tempIrp->pIrp = pIrp;
    tempIrp->nextIrp = NULL;
    tempIrp->prevIrp = NULL;

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

    /* Add the request to the list of requests for 
     * the pipe
     */  
    if(pipeInfo->irpList == NULL)
       	pipeInfo->irpList = tempIrp;
    else
        {
           tempIrp->nextIrp = pipeInfo->irpList;
           pipeInfo->irpList->prevIrp = tempIrp;
           pipeInfo->irpList = tempIrp;
        }

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

    switch ( pipeInfo->transferType)
        {
        case USB_XFRTYPE_ISOCH:

            /* isochronous transfer type */

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

                /* get the length of the buffer */

                bufferlength = (pIrp->bfrList[bufferIndex]).bfrLen;

                /* determine the number of isochronous packet
                 * descriptors required
                 */
                if (pipeInfo->bandwidth == 0)
                    { 
                if ( bufferlength % pipeInfo->uMaxPacketSize)
                    no = ( bufferlength / pipeInfo->uMaxPacketSize ) + 1;
                else
                    no = ( bufferlength / pipeInfo->uMaxPacketSize);

                pIsoPacketDesc = NULL;

                /* allocate ischronous packet descriptors */

                if (!(pIsoPacketDesc =
                        OSS_CALLOC( no * sizeof (USBHST_ISO_PACKET_DESC))))
                    {

                    /* cancel already submitted URB's */

                    usbdTransferAbort(clientHandle, pipeHandle, pIrp);
                    USBTU_LOG ( "usbdTransfer returns ERROR : malloc2  \n ");
                    return ERROR;

                    }

                /* initialize the isochronous packet descriptors  */

                for ( i= 0 ; i< no ; i++)
                   {

                   /* update the length */

                   if ( i == (no - 1) )
                       {
                       pIsoPacketDesc[i].uLength =
                                (bufferlength % pipeInfo->uMaxPacketSize);
                       }
                   else
                       pIsoPacketDesc[i].uLength = pipeInfo->uMaxPacketSize;

                   /* update the offset */

                   pIsoPacketDesc[i].uOffset =pipeInfo->uMaxPacketSize * i;

                   }
                    }
                else
                    {
                    /* Determine the number of packets based on pipeInfo->bandwidth */

                    bytesSoFar = 0;
                    frameCount = 0;
                    while ((int) bytesSoFar < bufferlength)
                        {
               
                        frameCount++;

          	        bytesThroughFrameCount = (frameCount * pipeInfo->bandwidth) / 1000L;

                        maxLen = min (bytesThroughFrameCount - bytesSoFar,
	                          bufferlength - bytesSoFar);


                        maxLen = min (maxLen, pipeInfo->uMaxPacketSize);


                        if (pIrp->dataBlockSize != 0 && maxLen > pIrp->dataBlockSize)
		            maxLen = (maxLen / pIrp->dataBlockSize) * pIrp->dataBlockSize;

                        bytesSoFar += maxLen ;

                        }

                    no = frameCount;
                    pIsoPacketDesc = NULL;

                    /* allocate ischronous packet descriptors */

                    if (!(pIsoPacketDesc =
                        OSS_CALLOC( no * sizeof (USBHST_ISO_PACKET_DESC))))
                        {

                        /* cancel already submitted URB's */

                        usbdTransferAbort(clientHandle, pipeHandle, pIrp);
                        USBTU_LOG ( "usbdTransfer returns ERROR : malloc2  \n ");
                        return ERROR;
 
                        }

                    /* initialize the isochronous packet descriptors  */

                    bytesSoFar = 0;
                    frameCount = 0;
                    while ((int) bytesSoFar < bufferlength)
                       {

                        frameCount++;

          	        bytesThroughFrameCount = (frameCount * pipeInfo->bandwidth) / 1000L;

                        maxLen = min (bytesThroughFrameCount - bytesSoFar,
	                          bufferlength - bytesSoFar);


                        maxLen = min (maxLen, pipeInfo->uMaxPacketSize);


                        if (pIrp->dataBlockSize != 0 && maxLen > pIrp->dataBlockSize)
		            maxLen = (maxLen / pIrp->dataBlockSize) * pIrp->dataBlockSize;

                       /* update the offset */
                       pIsoPacketDesc[frameCount - 1].uOffset =bytesSoFar;
                       /* update the length */
                       pIsoPacketDesc[frameCount - 1].uLength = maxLen;


                       bytesSoFar += maxLen ;

                       }
                  
                    }

                /* get the URB structure to be filled from array of URB structures */

                pUrb = &(pIrpContext->urbPtr[pIrpContext->urbIndex]);

                /* initialize the URB structure */

#if 1

                USBHST_FILL_ISOCHRONOUS_URB(pUrb,
                                            pipeInfo->hDevice,
                                            pipeInfo->endpointAddress,
                                            (pIrp->bfrList[bufferIndex]).pBfr,
                                            (pIrp->bfrList[bufferIndex]).bfrLen,
                                            transferflag,
                                            pIrp->startFrame,
                                            no,
                                            pIsoPacketDesc,
                                            usbtuDataUrbCompleteCallback,
                                            (PVOID)pIrp,
                                            USBHST_SUCCESS);
#else
	/* WARNING**************Just a patch */
		transferflag |= USBHST_START_ISOCHRONOUS_TRANSFER_ASAP;

                USBHST_FILL_ISOCHRONOUS_URB(pUrb,
                                            pipeInfo->hDevice,
                                            pipeInfo->endpointAddress,
                                            (pIrp->bfrList[bufferIndex]).pBfr,
                                            (pIrp->bfrList[bufferIndex]).bfrLen,
                                            transferflag,
                                            0,
                                            no,
                                            pIsoPacketDesc,
                                            usbtuDataUrbCompleteCallback,
                                            (PVOID)pIrp,
                                            USBHST_SUCCESS);

#endif

                /* increment the URB array index */

                (pIrpContext->urbIndex)++;

                /* submit the URB */

                if ( usbHstURBSubmit (pUrb) != USBHST_SUCCESS)
                    {
                    /* cancel already submitted URB's */

                    USBTU_LOG("usbdTransfer returns ERROR : SubmitURB failed\n");

                    usbdTransferAbort(clientHandle, pipeHandle, pIrp);

                    return ERROR;
                    }
                }
             break;

        case USB_XFRTYPE_BULK :

            /* Bulk Transfer Type */

            for ( bufferIndex= 0; bufferIndex < pIrp->bfrCount ; bufferIndex++)
                {
                /* get the URB structure to be filled */

                pUrb = &(pIrpContext->urbPtr[ pIrpContext->urbIndex]);

                /* initialize the URB structure */

                USBHST_FILL_BULK_URB(pUrb,
                                     pipeInfo->hDevice,
                                     pipeInfo->endpointAddress,
                                     (pIrp->bfrList[bufferIndex]).pBfr,
                                     (pIrp->bfrList[bufferIndex]).bfrLen,
                                     transferflag,
                                     usbtuDataUrbCompleteCallback,
                                     (PVOID)pIrp,
                                     USBHST_SUCCESS
                                     );
                /* increment the URB array index */

                (pIrpContext->urbIndex)++;

                /* submit the URB */

                if ( usbHstURBSubmit(pUrb) != USBHST_SUCCESS)
                    {

                    /* cancel already submitted URB's */

                    USBTU_LOG("usbdTransfer returns ERROR : SubmitURB failed\n");

                    usbdTransferAbort(clientHandle, pipeHandle, pIrp);

                    return ERROR;
                    }
                }
            break;
        case USB_XFRTYPE_INTERRUPT:

            /* Interrupt Transfer Type */

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

                /* Get the URB structure to be filled */

                pUrb = &(pIrpContext->urbPtr[ pIrpContext->urbIndex]);

                /* initialize the URB structure */

                USBHST_FILL_INTERRUPT_URB(pUrb,
                                        pipeInfo->hDevice,
                                        pipeInfo->endpointAddress,
                                        (pIrp->bfrList[bufferIndex]).pBfr,
                                        (pIrp->bfrList[bufferIndex]).bfrLen,
                                        transferflag,
                                        usbtuDataUrbCompleteCallback,
                                        (PVOID)pIrp,
                                        USBHST_SUCCESS
                                        );

                /* increment the URB array index */

                (pIrpContext->urbIndex)++;

                /* submit the URB */

                if ( usbHstURBSubmit(pUrb) != OK)
                    {

                    /* cancel already submitted URB's */

                    USBTU_LOG("usbdTransfer returns ERROR : SubmitURB failed\n");

                    usbdTransferAbort(clientHandle, pipeHandle, pIrp);

                    return ERROR;
                    }
                }
            break;
        default: break;
        }

     USBTU_LOG(" usbdTransfer returns OK \n ");
     return OK;
    }


/***************************************************************************
*
* usbdTransferAbort - Aborts a transfer
*
* This function aborts an IRP which was previously submitted through
* a call to usbdTransfer().
*
* RETURNS: OK, or ERROR if unable to abort transfer.
*
* ERRNO: N/A
*/

STATUS usbdTransferAbort
    (
    USBD_CLIENT_HANDLE clientHandle,	/* Client handle */
    USBD_PIPE_HANDLE pipeHandle,	    /* Pipe handle */
    pUSB_IRP pIrp			/* ptr to I/O to abort */
    )

    {
    int i;
    pUSBTU_IRPCONTEXT pIrpContext; 
    pUSBHST_URB pUrb;
    STATUS s = OK;
    pUSBTU_DEVICE_DRIVER pDriver = (pUSBTU_DEVICE_DRIVER) clientHandle;
    USBHST_STATUS status;
    pUSBTU_PIPE_INFO pipeInfo = (pUSBTU_PIPE_INFO) pipeHandle;