usbcbiufidevlib.c

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

    pCbiUfiDev->statusIrp.timeout           = USB_TIMEOUT_NONE;
    pCbiUfiDev->statusIrp.transferLen       = 0x02;
    pCbiUfiDev->statusIrp.bfrCount          = 0x01;  
    pCbiUfiDev->statusIrp.bfrList[0].pid    = USB_PID_IN;
    pCbiUfiDev->statusIrp.bfrList[0].pBfr   = pCbiUfiDev->intrStatus;
    pCbiUfiDev->statusIrp.bfrList[0].bfrLen = 0x02;
    pCbiUfiDev->statusIrp.userPtr           = pCbiUfiDev;            

    /* Submit IRP */
 
    if (usbdTransfer (usbdHandle, pCbiUfiDev->intrPipeHandle, 
                      &(pCbiUfiDev->statusIrp)) != OK)
        {
        USB_CBI_UFI_ERR ("usbCbiUfiCmdExecute: Unable to submit IRP for "\
                         "Interrupt status\n", 0, 0, 0, 0, 0, 0);

        OSS_SEM_GIVE (pCbiUfiDev->cbiUfiIrpSem);

        return (USB_INTERNAL_ERROR);
        }

    /* wait till the status bytes are read */

    if ( OSS_SEM_TAKE (pCbiUfiDev->cbiUfiIrpSem, USB_CBI_IRP_TIME_OUT + 1000)  == ERROR )
        {
        USB_CBI_UFI_DEBUG ("usbCbiUfiCmdExecute: Irp time out \n", 
                           0, 0, 0, 0, 0, 0);

        /* Cancel the IRP */
        usbdTransferAbort(usbdHandle,
                          pCbiUfiDev->intrPipeHandle, 
                          &(pCbiUfiDev->statusIrp));

        return (USB_INTERNAL_ERROR);
        }

    OSS_SEM_GIVE (pCbiUfiDev->cbiUfiIrpSem);    

    /* check for the status bytes read..stalled condition */

    if (pCbiUfiDev->statusIrp.result != OK)
        {
        return (USB_BULK_IO_ERROR);
        } 
    else
        {
        return (USB_COMMAND_SUCCESS);
        }
    } 

/***************************************************************************
*
* usbCbiUfiFormCmd - forms a command block for requested UFI command. 
*
* This routine forms UFI command blocks as per the UFI command specifications.  
* The following are the input parameters 
*
* \is
* \i '<pCbiUfiDev>'
* pointer to USB/CBI/UFI device for which the command has to be formed.
*
* \i '<ufiCmd>'
* identifies the UFI command to be formed.
*
* \i '<cmdParam1>'
* parameter required to form a complete UFI comamnd, if any.
*
* \i '<cmdParam2>'
* parameter required to form a complete UFI comamnd, if any.
* \ie
*
* RETURNS: OK, or ERROR if the command is unsupported.
*
* ERRNO: none
*
*\NOMANUAL
*/

LOCAL STATUS usbCbiUfiFormCmd 
    (
    pUSB_CBI_UFI_DEV pCbiUfiDev, /* pointer to cbi_ufi device  */
    UINT ufiCmd,                 /* UFI command                */ 
    UINT cmdParam1,              /* command parameter          */
    UINT cmdParam2               /* command parameter          */
    )
    {

    memset (&(pCbiUfiDev->ufiCmdBlk), 0, sizeof(USB_UFI_CMD_BLOCK));

    switch (ufiCmd)
        {
        case USB_UFI_FORMAT_UNIT:    /* UFI Format Unit Command */
      
            pCbiUfiDev->ufiCmdBlk.dataXferLen  = 0;
            pCbiUfiDev->ufiCmdBlk.direction    = 0;
      
            pCbiUfiDev->ufiCmdBlk.cmd[0]  = USB_UFI_FORMAT_UNIT;
            pCbiUfiDev->ufiCmdBlk.cmd[1]  = (USB_UFI_FORMAT_FMTDATA | 
                                             USB_UFI_FORMAT_FMT_DEFECT);

            pCbiUfiDev->ufiCmdBlk.cmd[2]  = 0;  /* Track Number              */
            pCbiUfiDev->ufiCmdBlk.cmd[3]  = 0;  /* Interleave factor MSB     */
            pCbiUfiDev->ufiCmdBlk.cmd[4]  = 0;  /* Interleave factor LSB     */  
            pCbiUfiDev->ufiCmdBlk.cmd[7]  = 0;  /* Parameter List length MSB */
            pCbiUfiDev->ufiCmdBlk.cmd[8]  = 0x0C;	/* Parameter List 
							 * length LSB 
							 */
           
            break;

        case USB_UFI_INQUIRY:        /* UFI Inquiry command  */
  
             
            pCbiUfiDev->ufiCmdBlk.dataXferLen  = UFI_STD_INQUIRY_LEN;
            pCbiUfiDev->ufiCmdBlk.direction    = USB_UFI_DIR_IN;

            pCbiUfiDev->ufiCmdBlk.cmd[0]  = USB_UFI_INQUIRY;

            pCbiUfiDev->ufiCmdBlk.cmd[1]  = 0;   /* Enable Vital 
						  * Product data
						  */      
            pCbiUfiDev->ufiCmdBlk.cmd[2]  = 0;   /* Page Code 
						  * Field
						  */      
            pCbiUfiDev->ufiCmdBlk.cmd[4]  = UFI_STD_INQUIRY_LEN;
  
            break;

        case USB_UFI_MODE_SELECT:   /* UFI Mode Select Command */

            pCbiUfiDev->ufiCmdBlk.cmd[0]  = USB_UFI_MODE_SELECT;

            pCbiUfiDev->ufiCmdBlk.cmd[1]  = USB_UFI_MODE_SEL_PF;  
 
            /* TODO : Set the number of bytes as per the mode pages */ 
 
            pCbiUfiDev->ufiCmdBlk.cmd[7]  = 0; /* Parameter list length MSB */
            pCbiUfiDev->ufiCmdBlk.cmd[8]  = 0; /* Parameter list length LSB */       

            break;

        case USB_UFI_MODE_SENSE:     /* UFI Request Mode Sense command */

            pCbiUfiDev->ufiCmdBlk.dataXferLen  = USB_UFI_MS_HEADER_LEN;
            pCbiUfiDev->ufiCmdBlk.direction    = USB_UFI_DIR_IN;

            pCbiUfiDev->ufiCmdBlk.cmd[0]  = USB_UFI_MODE_SENSE;

            pCbiUfiDev->ufiCmdBlk.cmd[1]  = 0;  

            /* Check the basic header information only. */               

            pCbiUfiDev->ufiCmdBlk.cmd[2]  = 1;  
 
            pCbiUfiDev->ufiCmdBlk.cmd[7]  = 0; /* Parameter list length MSB */
            pCbiUfiDev->ufiCmdBlk.cmd[8]  = USB_UFI_MS_HEADER_LEN; /* Parameter list length LSB */       

            break;

        case USB_UFI_PREVENT_MEDIA_REMOVAL: /* Enable or disable media 
					     * removal 
					     */

            pCbiUfiDev->ufiCmdBlk.dataXferLen  = 0;
            pCbiUfiDev->ufiCmdBlk.direction    = 0;

            pCbiUfiDev->ufiCmdBlk.cmd[0]  = USB_UFI_PREVENT_MEDIA_REMOVAL;            

            pCbiUfiDev->ufiCmdBlk.cmd[1]  = 0;  
            pCbiUfiDev->ufiCmdBlk.cmd[4]  = USB_UFI_MEDIA_REMOVAL_BIT;
  
            break;
 
        case USB_UFI_READ10:         /* UFI 10 byte READ Command */

            pCbiUfiDev->ufiCmdBlk.dataXferLen  = ((cmdParam2) * 
                                                 (pCbiUfiDev->blkDev.bd_bytesPerBlk)); 

            pCbiUfiDev->ufiCmdBlk.direction    = USB_UFI_DIR_IN;
 
            pCbiUfiDev->ufiCmdBlk.cmd[0]  = USB_UFI_READ10;
            pCbiUfiDev->ufiCmdBlk.cmd[1]  = 0;

            /*
             * cmdParam1 for this command will indicate the logical block 
             * address at which the read operation begins.  cmdParam2 will
             * indicate the number of logical blocks to be read. 
             */ 

            pCbiUfiDev->ufiCmdBlk.cmd[2]  =  (cmdParam1 & 0xFF000000) >> 24;
            pCbiUfiDev->ufiCmdBlk.cmd[3]  =  (cmdParam1 & 0x00FF0000) >> 16;
            pCbiUfiDev->ufiCmdBlk.cmd[4]  =  (cmdParam1 & 0x0000FF00) >> 8;
            pCbiUfiDev->ufiCmdBlk.cmd[5]  =  (cmdParam1 & 0xFF);

            pCbiUfiDev->ufiCmdBlk.cmd[7]  =  (cmdParam2 & 0xFF00) >> 8;
            pCbiUfiDev->ufiCmdBlk.cmd[8]  =  (cmdParam2 & 0xFF);

            break;

    
        case USB_UFI_READ_CAPACITY:  /* UFI Read Capacity command */

            pCbiUfiDev->ufiCmdBlk.dataXferLen  = 0x8;
            pCbiUfiDev->ufiCmdBlk.direction    = USB_UFI_DIR_IN;

            pCbiUfiDev->ufiCmdBlk.cmd[0]  =  USB_UFI_READ_CAPACITY;

            pCbiUfiDev->ufiCmdBlk.cmd[1]  = 0;  /* RelAdr bit should be zero */
            pCbiUfiDev->ufiCmdBlk.cmd[2]  = 0;  /* Logical block address     */
            pCbiUfiDev->ufiCmdBlk.cmd[3]  = 0;  /* should be set to zero     */
            pCbiUfiDev->ufiCmdBlk.cmd[4]  = 0;
            pCbiUfiDev->ufiCmdBlk.cmd[5]  = 0;
            pCbiUfiDev->ufiCmdBlk.cmd[8]  = 0;  /* PMI bit should be zero    */

            break;

        case USB_UFI_REQUEST_SENSE:  /* UFI Request Sense command */

            pCbiUfiDev->ufiCmdBlk.dataXferLen  = 0x12;
            pCbiUfiDev->ufiCmdBlk.direction    = USB_UFI_DIR_IN;
 
            pCbiUfiDev->ufiCmdBlk.cmd[0]  = USB_UFI_REQUEST_SENSE;
            pCbiUfiDev->ufiCmdBlk.cmd[1]  = 0;
            pCbiUfiDev->ufiCmdBlk.cmd[4]  = UFI_STD_REQ_SENSE_LEN;

            break;


        case USB_UFI_SEND_DIAGNOSTIC: /* UFI Send Diagnostics command */     

            /* Requests the device to perform self-test or reset */

            pCbiUfiDev->ufiCmdBlk.cmd[0]  = USB_UFI_SEND_DIAGNOSTIC;            

            pCbiUfiDev->ufiCmdBlk.cmd[1]  = 0x04; /* Perform default 
						   * self test 
						   */
        
            break;

 
        case USB_UFI_START_STOP_UNIT: /* UFI Start Stop unit command */   

            /* This command is basically used to update the media type and the
             * write protect status. Load eject bit is not supported by 
	     * USB-FDU.
             */ 

            pCbiUfiDev->ufiCmdBlk.dataXferLen  = 0x0;
            pCbiUfiDev->ufiCmdBlk.direction    = 0;

            pCbiUfiDev->ufiCmdBlk.cmd[0]  = USB_UFI_START_STOP_UNIT; 
            pCbiUfiDev->ufiCmdBlk.cmd[1]  = 0;
            pCbiUfiDev->ufiCmdBlk.cmd[4]  = 0x01;   /* Start the media */
                    
            break;

        case USB_UFI_TEST_UNIT_READY:  /* UFI Test Unit Ready Command */  

            /* This command checks if the device is ready or not */

            pCbiUfiDev->ufiCmdBlk.dataXferLen  = 0x0;
            pCbiUfiDev->ufiCmdBlk.direction    = 0;

            pCbiUfiDev->ufiCmdBlk.cmd[0]  = USB_UFI_TEST_UNIT_READY; 
            pCbiUfiDev->ufiCmdBlk.cmd[1]  = 0; 

            break;
    

        case USB_UFI_WRITE10:        /* UFI 10-byte Write Command */
            
            pCbiUfiDev->ufiCmdBlk.dataXferLen  = ((cmdParam2) * 
                                                 (pCbiUfiDev->blkDev.bd_bytesPerBlk)); 

            pCbiUfiDev->ufiCmdBlk.direction    = USB_UFI_DIR_OUT;

            pCbiUfiDev->ufiCmdBlk.cmd[0]  = USB_UFI_WRITE10;
            pCbiUfiDev->ufiCmdBlk.cmd[1]  = 0;

            /*
             * cmdParam1 for this command will indicate the logical block 
             * address at which the write operation begins.  cmdParam2 will
             * indicate the number of logical blocks to be written. 
             */ 

            pCbiUfiDev->ufiCmdBlk.cmd[2]  =  (cmdParam1 & 0xFF000000) >> 24;
            pCbiUfiDev->ufiCmdBlk.cmd[3]  =  (cmdParam1 & 0x00FF0000) >> 16;
            pCbiUfiDev->ufiCmdBlk.cmd[4]  =  (cmdParam1 & 0x0000FF00) >> 8;
            pCbiUfiDev->ufiCmdBlk.cmd[5]  =  (cmdParam1 & 0xFF);

            pCbiUfiDev->ufiCmdBlk.cmd[7]  =  (cmdParam2 & 0xFF00) >> 8;
            pCbiUfiDev->ufiCmdBlk.cmd[8]  =  (cmdParam2 & 0xFF);

            break;
    

        default: 
            return (ERROR);
        }
 
    return (OK);
 
    } 


/***************************************************************************
*
* usbCbiUfiReqSense - Executes an Request Sense command block. 
*
* Forms and executes Request Sense command on the specified device.
*
* RETURNS: UINT16 value specifying the sense key or ERROR
*
* ERRNO: none
*
*\NOMANUAL
*/

LOCAL UINT16 usbCbiUfiReqSense
    (
    pUSB_CBI_UFI_DEV pCbiUfiDev      /* pointer to cbi_ufi device  */
    )
    {
    UINT8 * pReqSense;
    UINT16 status = 0xFFFF;

    if ((pReqSense = OSS_MALLOC (UFI_STD_REQ_SENSE_LEN)) == NULL)
	{
	return ERROR;
	}

    pCbiUfiDev->bulkInData  = pReqSense; 


    if ( usbCbiUfiFormCmd (pCbiUfiDev, USB_UFI_REQUEST_SENSE, 0, 0) != OK )
        {
        USB_CBI_UFI_ERR ("usbCbiUfiReqSense: Error forming command\n",
                         0, 0, 0, 0, 0, 0);
        } 

    if ( usbCbiUfiCmdExecute (pCbiUfiDev) != USB_COMMAND_SUCCESS )
        {
        USB_CBI_UFI_ERR ("usbCbiUfiReqSense: Error executing "\
                         "USB_UFI_REQUEST_SENSE command\n", 0, 0, 0, 0, 0, 0);        
        }
    else 
        {
        
         /* Request Sense command success. Check the sense key & qualifiers. */
        status = (*(pReqSense + 12)  << 8) & 0xFF00;
        status = status | *(pReqSense + 13);
        switch (*(pReqSense + USB_UFI_SENSE_KEY_OFFSET))
            {
            case USB_UFI_NO_SENSE:
                USB_CBI_UFI_DEBUG ("usbCbiUfiReqSense: No Sense key, %d, %d\n",
                                   *(pReqSense + USB_UFI_SENSE_ASC), 
                                   *(pReqSense + USB_UFI_SENSE_ASCQ), 0, 0, 0, 0);
                break;

            case USB_UFI_RECOVERED_ERROR:
                USB_CBI_UFI_DEBUG ("usbCbiUfiReqSense: Recovered Error, %d, %d\n",
                                   *(pReqSense + USB_UFI_SENSE_ASC), 
                                   *(pReqSense + USB_UFI_SENSE_ASCQ), 0, 0, 0, 0);

                break;

            case USB_UFI_NOT_READY:
                USB_CBI_UFI_DEBUG ("usbCbiUfiReqSense: Device not ready, %d, %d \n",
                                   *(pReqSense + USB_UFI_SENSE_ASC), 
                                   *(pReqSense + USB_UFI_SENSE_ASCQ), 0, 0, 0, 0);
                break;

            case USB_UFI_MEDIUM_ERROR:
                USB_CBI_UFI_DEBUG ("usbCbiUfiReqSense: Medium Error, %d, %d\n",
                                   *(pReqSense + USB_UFI_SENSE_ASC), 
                                   *(pReqSense + USB_UFI_SENSE_ASCQ), 0, 0, 0, 0);
                break;

            case USB_UFI_HARDWARE_ERROR:
                USB_CBI_UFI_DEBUG ("usbCbiUfiReqSense: Hardware Error, %d, %d\n",
				    *(pReqSense + USB_UFI_SENSE_ASC), 
                                   *(pReqSense + USB_UFI_SENSE_ASCQ), 0, 0, 0, 0);

                break;

            case USB_UFI_ILL_REQUEST:
                USB_CBI_UFI_DEBUG ("usbCbiUfiReqSense: Illegal Request, %d, %d\n",
                                   *(pReqSense + USB_UFI_SENSE_ASC), 
                                   *(pReqSense + USB_UFI_SENSE_ASCQ), 0, 0, 0, 0);

                break;

            case USB_UFI_UNIT_ATTN:

                USB_CBI_UFI_DEBUG ("usbCbiUfiReqSense: Unit Attention, %d, %d\n",
                                   *(pReqSense + USB_UFI_SENSE_ASC), 
                                   *(pReqSense + USB_UFI_SENSE_ASCQ), 0, 0, 0, 0);