Subversion Repositories openrisc

//==========================================================================

//

//      usbs_msd_scsi.c

//

//      Support for slave-side USB mass storage SCSI devices.

//

//==========================================================================

// ####ECOSGPLCOPYRIGHTBEGIN####

// -------------------------------------------

// This file is part of eCos, the Embedded Configurable Operating System.

// Copyright (C) 2008 Free Software Foundation, Inc.

//

// eCos is free software; you can redistribute it and/or modify it under

// the terms of the GNU General Public License as published by the Free

// Software Foundation; either version 2 or (at your option) any later

// version.

//

// eCos is distributed in the hope that it will be useful, but WITHOUT

// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

// FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

// for more details.

//

// You should have received a copy of the GNU General Public License

// along with eCos; if not, write to the Free Software Foundation, Inc.,

// 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

//

// As a special exception, if other files instantiate templates or use

// macros or inline functions from this file, or you compile this file

// and link it with other works to produce a work based on this file,

// this file does not by itself cause the resulting work to be covered by

// the GNU General Public License. However the source code for this file

// must still be made available in accordance with section (3) of the GNU

// General Public License v2.

//

// This exception does not invalidate any other reasons why a work based

// on this file might be covered by the GNU General Public License.

// -------------------------------------------

// ####ECOSGPLCOPYRIGHTEND####

//==========================================================================

//#####DESCRIPTIONBEGIN####

//

// Author(s):    ccoutand <ccoutand@stmi.com>

//

// Date:         2010-06-02

//

//####DESCRIPTIONEND####

//

//==========================================================================

#include <cyg/infra/cyg_type.h>

#include <cyg/infra/cyg_ass.h>

#include <cyg/infra/cyg_trac.h>

#include <cyg/kernel/kapi.h>

#include <cyg/infra/diag.h>

#include <pkgconf/io_usb_slave_msd.h>

#include <cyg/io/usb/usbs_msd.h>

#include <cyg/io/usb/usbs_msd_opcode.h>

#include <cyg/io/usb/usbs_msd_scsi.h>

#include <cyg/io/disk.h>

#include <stdio.h> // for memcpy

#if defined(CYGBLD_IO_USB_SLAVE_MSD_DEBUG)

#define DBG diag_printf

#else

#define DBG (1) ? (void)0 : diag_printf

#endif

#if defined(CYGBLD_IO_USB_SLAVE_MSD_TRACE)

#define TRACE diag_printf

#else

#define TRACE (1) ? (void)0 : diag_printf

#endif

const msd_scsi_inq_resp inq_resp = {

   USBS_SCSI_DIRECT_ACCESS_BLOCK_DEVICE, // Direct Access Block device

   USBS_SCSI_REMOVABLE_DEVICE,           // Device is removable

   0x04,                                 // Comply with SPC-2

   0x02,                                 // Standard format

   0x20,                                 // Response is 0x20 + 4 bytes

   0x00,

   0x00,

   0x00,

   {'e','C','o','s',' ',' ',' ',' '},

   {'M','a','s','s',' ','S','t','o','r','a','g','e',' ',' ',' ',' '},

   {'0','.','0','1'},

};

// Handle Mode Sense Command

//

static inline void

usbs_msd_scsi_update_sense(msd_scsi_req_sense_resp *sense, \

                                cyg_uint8 asc, cyg_uint8 ascq, cyg_uint8 key )

{

   USBS_MSD_SCSI_SET_SENSE_ASC( sense->byte , asc );

   USBS_MSD_SCSI_SET_SENSE_ASCQ( sense->byte , ascq );

   USBS_MSD_SCSI_SET_SENSE_KEY( sense->byte , key );

}

// Handle Inquiry Request Command

//

static inline cyg_int32

usbs_msd_scsi_handle_inquiry( usbs_msd * msd )

{

   cyg_int32 tx_bytes = sizeof(msd_scsi_inq_resp);

   TRACE("USB Slave MSD: SCSI inquiry\n\r");

   // Copy over to message buffer

   memcpy( msd->buffer, (cyg_uint8 *) &inq_resp, tx_bytes );

   tx_bytes = msd->send( msd, msd->buffer, tx_bytes );

   msd->csw.status = USBS_MSD_CSW_STATUS_PASSED;

   return tx_bytes;

}

// Handle Read Capacity Command

//

static inline cyg_int32

usbs_msd_scsi_handle_capacity( usbs_msd * msd )

{

   cyg_disk_info_t disk_info;

   cyg_int32 tx_bytes = sizeof(cyg_uint32) << 1;

   cyg_uint32 len     = sizeof(cyg_disk_info_t);

   cyg_uint32 key     = CYG_IO_GET_CONFIG_DISK_INFO;

   cyg_io_handle_t lun = msd->lun->handle[msd->cbw.lun];

   TRACE("USB Slave MSD: SCSI capacity\n\r");

   // Get the configuration of a device

   cyg_io_get_config( lun, key, &disk_info, &len );

   msd->buffer[0] = BYTE3_32( disk_info.blocks_num );

   msd->buffer[1] = BYTE2_32( disk_info.blocks_num );

   msd->buffer[2] = BYTE1_32( disk_info.blocks_num );

   msd->buffer[3] = BYTE0_32( disk_info.blocks_num );

   msd->buffer[4] = BYTE3_32( disk_info.block_size );

   msd->buffer[5] = BYTE2_32( disk_info.block_size );

   msd->buffer[6] = BYTE1_32( disk_info.block_size );

   msd->buffer[7] = BYTE0_32( disk_info.block_size );

   tx_bytes = msd->send( msd, msd->buffer, tx_bytes );

   msd->csw.status = USBS_MSD_CSW_STATUS_PASSED;

   return tx_bytes;

}

// Handle Read Command

//

static inline cyg_int32

usbs_msd_scsi_handle_read( usbs_msd * msd, msd_scsi_req_sense_resp *sense )

{

   Cyg_ErrNo ret;

   cyg_uint32 transfert_len = 0, pos = 0, len = 1;

   cyg_int32 ret_len = 0;

   cyg_int32 tx_byte = 0;

   cyg_io_handle_t lun = msd->lun->handle[msd->cbw.lun];

   TRACE("USB Slave MSD: SCSI read\n\r");

   pos = ( msd->cbw.cb.data[2] << 24 ) | \

         ( msd->cbw.cb.data[3] << 16 ) | \

         ( msd->cbw.cb.data[4] <<  8 ) | \

           msd->cbw.cb.data[5];

   transfert_len = ( msd->cbw.cb.data[7] << 8 ) | msd->cbw.cb.data[8];

   // Read data from a block device

   while ( transfert_len > 0 ) {

     if( ( ret = cyg_io_bread( lun, msd->buffer, &len, pos)) != ENOERR )

       break;

     tx_byte = msd->send( msd, msd->buffer, (USBS_MSD_DISK_SECTOR_SIZE) );

     TRACE("USB Slave MSD: Read %d block, %d bytes\n\r", transfert_len, tx_byte);

     ret_len += tx_byte;

     // Substract 1 sector

     transfert_len -= 1;

     pos += 1;

   }

   if ( ret == ENOERR )

   {

      msd->csw.status = USBS_MSD_CSW_STATUS_PASSED;

   }

   else

   {

     msd->csw.status = USBS_MSD_CSW_STATUS_FAILED;

     usbs_msd_scsi_update_sense( sense, \

             USBS_MSD_SCSI_SENSE_ASC_UNRECOVERED_READ_ERROR, \

             USBS_MSD_SCSI_SENSE_ASCQ_UNRECOVERED_READ_ERROR, \

             USBS_MSD_SCSI_SENSE_MEDIUM_ERROR );

   }

   return ret_len;

}

// Handle Write Command

//

static inline cyg_int32

usbs_msd_scsi_handle_write( usbs_msd * msd , msd_scsi_req_sense_resp *sense )

{

   Cyg_ErrNo ret;

   cyg_uint32 transfert_len = 0, pos = 0, len = 1;

   cyg_int32 ret_len = 0;

   cyg_int32 rx_byte = 0;

   cyg_io_handle_t lun = msd->lun->handle[msd->cbw.lun];

   DBG("USB Slave MSD: SCSI Write\n\r");

   pos = ( msd->cbw.cb.data[2] << 24 ) | \

             ( msd->cbw.cb.data[3] << 16 ) | \

             ( msd->cbw.cb.data[4] <<  8 ) | \

               msd->cbw.cb.data[5];

   transfert_len = ( msd->cbw.cb.data[7] << 8 ) | msd->cbw.cb.data[8];

   // Read data from a block device

   while ( transfert_len > 0 ) {

     rx_byte = msd->receive( msd, msd->buffer, (USBS_MSD_DISK_SECTOR_SIZE) );

     if( ( ret = cyg_io_bwrite( lun, msd->buffer, &len, pos)) != ENOERR )

       break;

     TRACE("USB Slave MSD: Write %d block, %d bytes\n\r", transfert_len, rx_byte);

     ret_len += ( rx_byte );

     // Substract 1 sector

     transfert_len -= 1;

     pos += 1;

   }

   if ( ret == ENOERR )

   {

     msd->csw.status = USBS_MSD_CSW_STATUS_PASSED;

   }

   else

   {

     msd->csw.status = USBS_MSD_CSW_STATUS_FAILED;

     usbs_msd_scsi_update_sense( sense, \

             USBS_MSD_SCSI_SENSE_ASC_WRITE_ERROR, \

             USBS_MSD_SCSI_SENSE_ASCQ_WRITE_ERROR, \

             USBS_MSD_SCSI_SENSE_MEDIUM_ERROR );

   }

   return ret_len;

}

// Handle Request Sense Command

//

static inline cyg_int32

usbs_msd_scsi_handle_req_sense( usbs_msd * msd,  \

                                      msd_scsi_req_sense_resp *sense )

{

   cyg_uint8 i = 0;

   cyg_int32 tx_bytes = sizeof(msd_scsi_req_sense_resp);

   TRACE("USB Slave MSD: SCSI request sense\n\r");

   // Copy over to message buffer

   for(i = 0 ; i < tx_bytes ; i++)

       msd->buffer[i] = sense->byte[i];

   tx_bytes = msd->send( msd, msd->buffer, tx_bytes );

   msd->csw.status = USBS_MSD_CSW_STATUS_PASSED;

   return tx_bytes;

}

// Handle Mode Sense Command

//

static inline cyg_int32

usbs_msd_scsi_handle_sense( usbs_msd * msd,  \

                           msd_scsi_req_sense_resp *sense )

{

   cyg_int32 tx_bytes = 0x0;

   DBG("USB Slave MSD: SCSI sense\n\r");

   msd->buffer[0] = 0x03; // Number of byte in the following message

   msd->buffer[1] = 0x00; // Media type

   msd->buffer[2] = 0x00; // Not Write protected, no cache-control-bit support

   msd->buffer[3] = 0x00; // No Mode parameter

   // FIXME : handle different option correctly. For the time being,

   // just respond with minimum data

   if( ( msd->cbw.cb.data[2] & 0x3F ) == \

        USBS_MSD_SCSI_MODE_PAGE_CODE_ALL )

   {

     DBG("USB Slave MSD: SCSI sense all\n\r");

     tx_bytes = msd->send( msd, msd->buffer, 4 );

     msd->csw.status = USBS_MSD_CSW_STATUS_PASSED;

   }

   else

   {

     DBG("USB Slave MSD: SCSI sense page: %x\n\r", \

             msd->cbw.cb.data[2]);

     tx_bytes = msd->send( msd, msd->buffer, 4 );

     msd->csw.status = USBS_MSD_CSW_STATUS_FAILED;

   }

   return tx_bytes;

}

// Handle Test Unit Ready Command

//

static inline cyg_int32

usbs_msd_scsi_handle_test_unit_ready( usbs_msd * msd , \

                                         msd_scsi_req_sense_resp *sense )

{

   cyg_disk_info_t disk_info;

   Cyg_ErrNo ret;

   cyg_uint32 len = sizeof(cyg_disk_info_t);

   cyg_uint32 key = CYG_IO_GET_CONFIG_DISK_INFO;

   cyg_io_handle_t lun = msd->lun->handle[msd->cbw.lun];

   TRACE("USB Slave MSD: SCSI test unit ready\n\r");

   // Get the configuration of a device

   ret = cyg_io_get_config( lun, key, &disk_info, &len);

   msd->csw.status = USBS_MSD_CSW_STATUS_PASSED;

   USBS_MSD_SCSI_INIT_SENSE_DATA( sense->byte );

   // check if disk is connected / mounted here

   if( disk_info.connected == false )

   {

      DBG("USB Slave MSD: Disk not mounted \n\r");

      usbs_msd_scsi_update_sense( sense, \

             USBS_MSD_SCSI_SENSE_ASC_MEDIUM_NOT_PRESENT, \

             USBS_MSD_SCSI_SENSE_ASCQ_MEDIUM_NOT_PRESENT, \

             USBS_MSD_SCSI_SENSE_UNIT_ATTENTION);

      msd->csw.status = USBS_MSD_CSW_STATUS_FAILED;

   }

   // No data to transfer

   return 0;

}

// Windows host operating system uses this command. Usually if

// a command is not supported, the CSW should return failure.

// Since no data is sent in the data transfer phase, the TX

// endpoint shall be stalled. Since some USB driver in eCos

// do not support endpoint stall, is it required to respond

// with some data, otherwise the driver would freeze. In the

// following case, we fill the data structure but report

// failure in the CSW.

#if !defined(CYGSEM_IO_USB_SLAVE_MSD_STALL_ENABLE)

// Handle Read Format Capacities

//

static inline cyg_int32

usbs_msd_scsi_read_format_capacities( usbs_msd * msd )

{

   cyg_int32 i = 0;

   DBG("USB Slave MSD: SCSI read format capacities\n\r");

   for(i = 0 ; i < msd->cbw.data_transfert_len; i++)

   {

     msd->buffer[i] = 0;

   }

   i = msd->send( msd, msd->buffer, i );

   msd->csw.status = USBS_MSD_CSW_STATUS_FAILED;

   return i;

}

#endif

// Handle Verify

//

static inline cyg_int32

usbs_msd_scsi_handle_verify( usbs_msd * msd )

{

   DBG("USB Slave MSD: SCSI test unit verify\n\r");

   // FIXME: Should do something here?

   // Return success, command is optional

   msd->csw.status = USBS_MSD_CSW_STATUS_PASSED;

   // No data to transfer

   return 0;

}

// Handle Medium Removal

//

static inline cyg_int32

usbs_msd_scsi_handle_removal( usbs_msd * msd )

{

   DBG("USB Slave MSD: SCSI Prevent / Allow device removal, LUN %d, flag %d %d\n\r",

          ( msd->cbw.cb.data[1] & 0xf0 >> 4 ) , ( msd->cbw.cb.data[4] & 0x01 ),

            msd->cbw.data_transfert_len );

   // Support for this command is not mandatory.

   // No specific handling of this command is implemented.

   // Maybe mount / umount the disc?

   msd->csw.status = USBS_MSD_CSW_STATUS_PASSED;

   // No data to transfer

   return 0;

}

// Handle SCSI command

//

cyg_int32

usbs_msd_scsi_handle_cmd( usbs_msd * msd )

{

   bool ret;

   cyg_uint8 cmd = msd->cbw.cb.data[0];

   msd_scsi_req_sense_resp *sense = (msd_scsi_req_sense_resp *) msd->handler_data;

   switch( cmd )

   {

     case USBS_SCSI_INQUIRY:

        ret = usbs_msd_scsi_handle_inquiry( msd );

        break;

     case USBS_SCSI_READ_CAPACITY:

        ret = usbs_msd_scsi_handle_capacity( msd );

        break;

     case USBS_SCSI_READ_10:

        ret = usbs_msd_scsi_handle_read(msd , sense );

        break;

     case USBS_SCSI_WRITE_10:

        ret = usbs_msd_scsi_handle_write( msd , sense );

        break;

     case USBS_SCSI_REQUEST_SENSE:

        ret = usbs_msd_scsi_handle_req_sense( msd , sense );

        break;

     case USBS_SCSI_SENSE_6:

        ret = usbs_msd_scsi_handle_sense( msd , sense);

        break;

     case USBS_SCSI_TEST_UNIT_READY:

        ret = usbs_msd_scsi_handle_test_unit_ready( msd , sense );

        break;

     case USBS_SCSI_VERIFY_10:

        ret = usbs_msd_scsi_handle_verify( msd );

        break;

#if !defined(CYGSEM_IO_USB_SLAVE_MSD_STALL_ENABLE)

     case USBS_SCSI_READ_FORMAT_CAPACITIES:

        ret = usbs_msd_scsi_read_format_capacities( msd );

        break;

#endif

     case USBS_SCSI_PREVENT_ALLOW_REMOVAL:

        ret = usbs_msd_scsi_handle_removal( msd );

        break;

     default:

        // Use for all commands not implemented, not

        // supported

        DBG("USB Slave MSD: SCSI illegal request %x \n\r", cmd );

        USBS_MSD_SCSI_INIT_SENSE_DATA( sense->byte );

        usbs_msd_scsi_update_sense( sense, \

                USBS_MSD_SCSI_SENSE_ASC_INVALID_OPCODE, \

                USBS_MSD_SCSI_SENSE_ASCQ_INVALID_OPCODE, \

                USBS_MSD_SCSI_SENSE_ILLEGAL_REQUEST);

        msd->csw.status = USBS_MSD_CSW_STATUS_FAILED;

        ret = 0;

        break;

   }

   return ret;

}

// SCSI initialization

//

bool

usbs_msd_scsi_init( void ** ctxt )

{

  static msd_scsi_req_sense_resp sense;

  DBG("USB Slave MSD: SCSI init %p\n", &sense);

  USBS_MSD_SCSI_INIT_SENSE_DATA( sense.byte );

  *ctxt = &sense;

  return true;

}