usbtargrbccmd.c

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

        /* If not an RBC device, return just the header with no page info */

        g_deviceHdr.dataLen = sizeof(MODE_PARAMETER_HEADER)-1;
        *ppData = (UINT8 *)&g_deviceHdr;
        *pSize = sizeof(MODE_PARAMETER_HEADER);
        }

    /* return only what was requested */

    if (allocLgth < *pSize)
        *pSize = allocLgth;

    /* set sense data */

    usbTargRbcSenseDataSet (SCSI_SENSE_NO_SENSE, SCSI_ADSENSE_NO_SENSE, 0);

    return(OK);
    }


/*******************************************************************************
*
* usbTargRbcTestUnitReady - test if the RBC device is ready
*
* This routine tests whether the RBC block I/O device is ready.
*
* RETURNS: OK or ERROR
* 
* ERRNO:
*  none.
*/

STATUS usbTargRbcTestUnitReady
    (
    UINT8	arg[6]		/* the RBC command */
    )
    {

    /*
     * set sense key to NO SENSE (0x0) and set additional sense code
     * to NO ADDITIONAL SENSE INFORMATION 
     */

    usbTargRbcSenseDataSet(SCSI_SENSE_NO_SENSE,SCSI_ADSENSE_NO_SENSE,0);

    return(OK);
    }


/******************************************************************************
*
* usbTargRbcBufferWrite - write micro-code to the RBC device
*
* This routine writes micro-code to the RBC block I/O device.
*
* RETURNS: OK or ERROR
* 
* ERRNO:
*  none.
*/

STATUS usbTargRbcBufferWrite
    (
    UINT8	arg[10],	/* the RBC command */
    UINT8	** ppData,	/* micro-code location on device */
    UINT32	* pSize		/* size of micro-code location on device */
    )
    {
    UINT32	offset;		/* offset */
    UINT32	paramListLgth;	/* paramter list length */
    UINT8	mode;		/* mode */

    mode = arg[1] & 0x7;
    offset = (arg[3] << 16) | (arg[4] << 8) | arg[5];
    paramListLgth = (arg[6] << 16) | (arg[7] << 8) | arg[8];

    switch(mode)
        {
        case 5:

            /* 
             * vendor-specific Microcode or control information is 
             * transferred to the device and saved saved to 
             * non-volatile memory 
             */ 

            break;

        case 7:

            /*
             * vendor-specific microcode or control information is
             * transferred to the device with two or more WRITE BUFFER commands. 
             */

            break;

        default: 

            /* other modes optional for RBC devices and not implemented */

            /* 
             * set sense key to ILLEGAL REQUEST (05h) and an ASC of COMMAND
             * SEQUENCE ERROR (2Ch) 
             */

            usbTargRbcSenseDataSet (SCSI_SENSE_ILLEGAL_REQUEST, 
                                    SCSI_ADSENSE_CMDSEQ_ERROR, 0x0);
            return(ERROR);
        }

    /*
     * The PARAMETER LIST LENGTH field specifies the maximum number of bytes 
     * that sent by the host to be stored in the specified buffer beginning
     * at the buffer offset. If the BUFFER OFFSET and PARAMETER LIST LENGTH
     * fields specify a transfer in excess of the buffer capacity, return 
     * ERROR and set the sense key to ILLEGAL REQUEST with an additional 
     * sense code of INVALID FIELD IN CDB. 
     */

    if (paramListLgth + offset > DATA_BUFFER_LEN)
        {
        usbTargRbcSenseDataSet (SCSI_SENSE_ILLEGAL_REQUEST, 
                                SCSI_ADSENSE_INVALID_CDB, 0x0);
        return(ERROR);
        }

    usbTargRbcSenseDataSet(SCSI_SENSE_NO_SENSE, SCSI_ADSENSE_NO_SENSE, 0x0);

    *ppData = &g_dataOutBfr[0];
    *pSize = DATA_BUFFER_LEN;
    return(OK);
    }


/* optional routines */

/*******************************************************************************
*
* usbTargRbcFormat - format the RBC device
*
* This routine formats the RBC block I/O device.
*
* RETURNS: OK or ERROR
* 
* ERRNO:
*  none
*/

STATUS usbTargRbcFormat
    (
    UINT8	arg[6]		/* the RBC command */
    )

    {
    /* 
     * This routine should not be called because the mode sense data indicates
     * the unit cannot be formatted. If this routine is called, return a status
     * of ERROR, a sense key of MEDIA ERROR (03h), an ASC/ASCQ
     * of FORMAT COMMAND FAILED (31h /01h). 
     */
    usbTargRbcSenseDataSet (SCSI_SENSE_MEDIUM_ERROR, SCSI_ADSENSE_FORMAT_ERROR,
                            0x1);
    return(ERROR);
    }

/*******************************************************************************
*
* usbTargRbcPersistentReserveIn - send reserve data to the host
*
* This routine requests reserve data to be sent to the initiator.
*
* RETURNS: OK or ERROR
* 
* ERRNO:
*  none
*/

STATUS usbTargRbcPersistentReserveIn
    (
    UINT8	arg[10],	/* the RBC command */
    UINT8	** ppData,	/* location of reserve data on device */
    UINT32	*pSize		/* size of reserve data */
    )
    {
    *ppData = NULL;
    *pSize  = 0;

    /*
     * This routine is optional and is not implemented. If this routine is called,
     * return a status of ERROR, a sense key of ILLEGAL REQUEST (05h),
     * and an ASC/ASCQ of INVALID COMMAND OPERATION CODE (20h). 
     */

    usbTargRbcSenseDataSet (SCSI_SENSE_ILLEGAL_REQUEST, 
                            SCSI_ADSENSE_ILLEGAL_COMMAND, 0x0);

    return(ERROR);
    }

/*******************************************************************************
*
* usbTargRbcPersistentReserveOut - reserve resources on the RBC device
*
* This routine reserves resources on the RBC block I/O device.
*
* RETURNS: OK or ERROR
* 
* ERRNO:
*  none
*/

STATUS usbTargRbcPersistentReserveOut
    (
    UINT8	arg[10],	/* the RBC command */
    UINT8	** ppData,	/* location of reserve data on device */
    UINT32	*pSize		/* size of reserve data */
    )
    {
    *ppData = NULL;
    *pSize = 0;

    /*
     * This routine is optional and is not implemented. If this routine is 
     * called, return a status of ERROR, a sense key of ILLEGAL REQUEST (05h),
     * and an ASC/ASCQ of INVALID COMMAND OPERATION CODE (20h).
     */

    usbTargRbcSenseDataSet (SCSI_SENSE_ILLEGAL_REQUEST,
                            SCSI_ADSENSE_ILLEGAL_COMMAND, 0x0);

    return(ERROR);
    }

/*******************************************************************************
*
* usbTargRbcRelease - release a resource on the RBC device
*
* This routine releases a resource on the RBC block I/O device.
*
* RETURNS: OK or ERROR
*
* ERRNO:
*  none.
*/

STATUS usbTargRbcRelease
    (
    UINT8	arg[6]		/* the RBC command */
    )
    {

    /*
     * This routine is optional and is not implemented. If this routine is 
     * called, return a status of ERROR, a sense key of ILLEGAL REQUEST (05h),
     * and an ASC/ASCQ of INVALID COMMAND OPERATION CODE (20h).
     */

    usbTargRbcSenseDataSet (SCSI_SENSE_ILLEGAL_REQUEST,
                            SCSI_ADSENSE_ILLEGAL_COMMAND, 0x0);

    return(ERROR);
    }


/*******************************************************************************
*
* usbTargRbcRequestSense - request sense data from the RBC device
*
* This routine requests sense data from the RBC block I/O device.
*
* RETURNS: OK or ERROR
*
* ERRNO: N/A
*/

STATUS usbTargRbcRequestSense
    (
    UINT8	arg[6],		/* the RBC command */
    UINT8	** ppData,	/* location of sense data on device */
    UINT32	*pSize		/* size of sense data */
    )
    {
    UINT8	allocLgth = arg[4];	/* allocation length */

    *ppData = (UINT8 *)&g_senseData;
    *pSize  = sizeof(SENSE_DATA);

    if (allocLgth < *pSize)
        *pSize = allocLgth;

    return(OK);
    }

/*******************************************************************************
*
* usbTargRbcReserve - reserve a resource on the RBC device
*
* This routine reserves a resource on the RBC block I/O device.
*
* RETURNS: OK or ERROR
* 
* ERRNO:
*  none
*/

STATUS usbTargRbcReserve
    (
    UINT8	arg[6]		/* the RBC command */
    )
    {
    /*
     * set sense key to ILLEGAL REQUEST 0x5 and 
     * set additional sense code to INVALID COMMAND OPERATION CODE 0x20 
     */

    usbTargRbcSenseDataSet (SCSI_SENSE_ILLEGAL_REQUEST,
                            SCSI_ADSENSE_ILLEGAL_COMMAND, 0);
    return(ERROR);
    }

/******************************************************************************
*
* usbTargRbcCacheSync - synchronize the cache of the RBC device
*
* This routine synchronizes the cache of the RBC block I/O device.
*
* RETURNS: OK or ERROR
* 
* ERRNO:
*  none
*/

STATUS usbTargRbcCacheSync
    (
    UINT8	arg[10]		/* the RBC command */
    )
    {
    usbTargRbcSenseDataSet (SCSI_SENSE_NO_SENSE,
                            SCSI_ADSENSE_NO_SENSE, 0);
    return(OK);
    }

/*******************************************************************************
*
* usbTargRbcBlockDevGet - return opaque pointer to the RBC BLK I/O DEV device 
* structure.
*
* This routine returns an opaque pointer to the RBC BLK I/O DEV device 
* structure.
*
* RETURNS: Pointer to the RBC BLK I/O DEV structure
* 
* ERRNO:
*  none
*/

pVOID usbTargRbcBlockDevGet (void)
    {

    /* return current instance of the RBC BLK_DEV structure */

    return(g_rbcBlkDev);
    }


/*******************************************************************************
*
* usbTargRbcBlockDevSet - set the pointer to the RBC BLK I/O DEV device structure.
*
* This routine sets the RBC BLK_DEV pointer that is accessed by the 
* usbTargRbcBlockDevGet() routine.
*
* RETURNS: OK or ERROR
* 
* ERRNO:
*  none
*/

STATUS usbTargRbcBlockDevSet
    (
    pVOID	*blkDev		/* pointer to the BLK_DEV device */
    )
    {

    /* set the RBC BLK_DEV pointer to the value of the argument */

    g_rbcBlkDev = blkDev;
    return(OK);
    }


/******************************************************************************
*
* usbTargRbcBlockDevCreate - create an RBC BLK_DEV device.
*
* This routine creates an RBC BLK I/O device. The RAM driver will be used for
* the actual implementation.
*
* RETURNS: Pointer to BLK_DEV structure
* 
* ERRNO:
*  none.
*/

STATUS usbTargRbcBlockDevCreate (void)
    {
    CBIO_DEV_ID		cbio;	/* CBIO_DEV_ID */

    if (g_rbcBlkDev != NULL)
        return(OK);

#if (USB_MS_BLK_DRV == USB_MS_CBIO_DRV)

    /* create a RAM disk cache block I/O device (CBIO) */

    cbio = (CBIO_DEV_ID)ramDiskDevCreate
        (
        NULL,               /* where it is in memory (0 = malloc)     */
        BYTES_PER_BLOCK,    /* number of bytes per block              */
        BLKS_PER_TRACK,     /* number of blocks per track             */
        NUM_BLOCKS,         /* number of blocks on this device        */
        BLK_OFFSET          /* no. of blks to skip at start of device */
        );

    if (cbio == NULL)
        {
        usbDbgPrint("usbTargRbcBlockDevCreate: ramDiskDevCreate returned \
                     NULL\n");
        return(ERROR);
        }


    /* create the DOS file system */

    if (dosFsDevCreate (BLK_DEV_NAME, cbio, 0x20, NONE) == ERROR)
        {
        usbDbgPrint ("usbTargRbcFileSystemCreate: dosFsDevCreate \
                      returned ERROR\n");
        return ERROR;
        }

    /* Format the first partition */  

    if(dosFsVolFormat (BLK_DEV_NAME, 2,0) == ERROR)
        {
        usbDbgPrint ("usbTargRbcBlockDevCreate: dosFsVolFormat returned \
                      ERROR\n");
        return ERROR;
        }


#elif (USB_MS_BLK_DRV == USB_MS_RAM_DRV)

    /* create a RAM driver and use CBIO wrapper routines */        

    cbio = cbioWrapBlkDev (ramDevCreate (NULL, BYTES_PER_BLOCK, BLKS_PER_TRACK,	
                                         NUM_BLOCKS, BLK_OFFSET));
    if (cbio == NULL)
        {
        usbDbgPrint("usbTargRbcBlockDevCreate: ramDevCreate returned NULL\n");
        return(ERROR);
        }

    if(cbioIoctl(cbio,CBIO_RESET,NULL) != OK)
        {
        usbDbgPrint ("usbTargRbcBlockDevCreate: CBIO_RESET returned ERROR\n");
        return ERROR;
        }

#else

#error usbTargRbcBlockDevCreate: USB_MS_BLK_DRV is an unknown device

#endif

    /* reset the device */

    if(cbioIoctl(cbio,CBIO_RESET,NULL) != OK)
        {
        usbDbgPrint ("usbTargRbcBlockDevCreate: CBIO_RESET returned ERROR\n");
        return ERROR;
        }

    /* save the pointer */

    g_rbcBlkDev = (pVOID)cbio;

    return(OK);
    }


/******************************************************************************
*
* usbTargRbcVendorSpecific - vendor specific call
*
* This routine is a vendor specific call.
*
* RETURNS: OK
* 
* ERRNO:
*  none
*/
STATUS usbTargRbcVendorSpecific
    (
    UINT8	arg[10],	/* the RBC command */
    UINT8	** ppData,	/* location of sense data on device */
    UINT32	*  pSize	/* size of sense data */
    )
    {
    *ppData = g_VendorSpecificData;
    *pSize = VENDOR_SPECIFIC_23_LENGTH;

    return(OK);
    }