2297 lines
82 KiB
C
2297 lines
82 KiB
C
|
/*******************************************************************************
|
||
|
|
||
|
This software file (the "File") is distributed by Marvell International Ltd.
|
||
|
or its affiliate(s) under the terms of the GNU General Public License Version 2,
|
||
|
June 1991 (the "License"). You may use, redistribute and/or modify this File
|
||
|
in accordance with the terms and conditions of the License, a copy of which
|
||
|
is available along with the File in the license.txt file or by writing to the
|
||
|
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
|
||
|
or on the worldwide web at http://www.gnu.org/licenses/gpl.txt.
|
||
|
|
||
|
THE FILE IS DISTRIBUTED AS-IS, WITHOUT WARRANTY OF ANY KIND, AND THE IMPLIED
|
||
|
WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE ARE EXPRESSLY
|
||
|
DISCLAIMED. The GPL License provides additional details about this warranty
|
||
|
disclaimer.
|
||
|
|
||
|
(C) Copyright 2004 - 2007 Marvell Semiconductor Israel Ltd. All Rights Reserved.
|
||
|
(C) Copyright 1999 - 2004 Chipidea Microelectronica, S.A. All Rights Reserved.
|
||
|
|
||
|
*******************************************************************************/
|
||
|
|
||
|
/**************************************************************************
|
||
|
Include the USB stack and local header files.
|
||
|
**************************************************************************/
|
||
|
|
||
|
#include "usb/api/mvUsbDefs.h"
|
||
|
#include "usb/api/mvUsbCh9.h"
|
||
|
#include "usb/api/mvUsbDebug.h"
|
||
|
#include "usb/api/mvUsbDevApi.h"
|
||
|
#include "usb/examples/disk.h"
|
||
|
|
||
|
/* MSB of debug flags for USB device usage */
|
||
|
#define ARC_DEBUG_FLAG_DISK 0x01000000
|
||
|
#define ARC_DEBUG_FLAG_DISK_READ 0x02000000
|
||
|
#define ARC_DEBUG_FLAG_DISK_WRITE 0x04000000
|
||
|
#define ARC_DEBUG_FLAG_DISK_CAP 0x08000000
|
||
|
#define ARC_DEBUG_FLAG_DISK_DATA 0x10000000
|
||
|
#define ARC_DEBUG_FLAG_DISK_DUMP 0x20000000
|
||
|
|
||
|
|
||
|
/**************************************************************************
|
||
|
Include the OS and BSP dependent files that define IO functions and
|
||
|
basic types. You may like to change these files for your board and RTOS
|
||
|
**************************************************************************/
|
||
|
|
||
|
|
||
|
/**************************************************************************
|
||
|
Global variables and some defines for device.
|
||
|
**************************************************************************/
|
||
|
|
||
|
#define BUFFERSIZE (2048)
|
||
|
|
||
|
#define EP_TEMP_BUFFERSIZE (32)
|
||
|
#define MASS_STORAGE_INTERFACE (0)
|
||
|
|
||
|
#define APP_CONTROL_MAX_PKT_SIZE (64)
|
||
|
#define DEV_DESC_MAX_PACKET_SIZE (7)
|
||
|
#define DISK_FS_MAX_PACKET_SIZE (64)
|
||
|
#define DISK_HS_MAX_PACKET_SIZE (512)
|
||
|
|
||
|
#define CFG_DESC_EP_IN_TYPE_OFFSET (21)
|
||
|
#define CFG_DESC_EP_IN_MAX_PACKET_SIZE_OFFSET (22)
|
||
|
#define CFG_DESC_EP_OUT_TYPE_OFFSET (28)
|
||
|
#define CFG_DESC_EP_OUT_MAX_PACKET_SIZE_OFFSET (29)
|
||
|
|
||
|
#define TOTAL_LOGICAL_ADDRESS_BLOCKS (4096)
|
||
|
#define LENGTH_OF_EACH_LAB (512)
|
||
|
|
||
|
#define DISK_IN_EP_NO 1
|
||
|
#define DISK_OUT_EP_NO 2
|
||
|
|
||
|
#define DISK_IN_EP_TYPE 2 /* Bulk */
|
||
|
#define DISK_OUT_EP_TYPE 2 /* Bulk */
|
||
|
|
||
|
typedef struct
|
||
|
{
|
||
|
_usb_device_handle usbDevHandle; /* Must be first field */
|
||
|
uint_32 devNo;
|
||
|
uint_8_ptr Send_Buffer_Unaligned;
|
||
|
|
||
|
uint_8_ptr DevDesc;
|
||
|
uint_8_ptr DevQualifierDesc;
|
||
|
uint_8_ptr ConfigDesc;
|
||
|
uint_8_ptr other_speed_config;
|
||
|
uint_8_ptr ep1_buf;
|
||
|
uint_8_ptr epTemp_buf;
|
||
|
DISK_READ_CAPACITY* pReadCapacity;
|
||
|
CSW_STRUCT* pCSW;
|
||
|
uint_8_ptr MASS_STORAGE_DISK;
|
||
|
|
||
|
SETUP_STRUCT local_setup_packet;
|
||
|
|
||
|
volatile boolean TEST_ENABLED;
|
||
|
volatile boolean ENTER_TEST_MODE;
|
||
|
volatile uint_16 test_mode_index;
|
||
|
volatile uint_8 speed;
|
||
|
uint_16 logicalBlocks;
|
||
|
uint_32 hsMaxPktSize;
|
||
|
uint_32 fsMaxPktSize;
|
||
|
|
||
|
uint_32 inEpType;
|
||
|
uint_32 outEpType;
|
||
|
|
||
|
uint_32 inEpNo;
|
||
|
uint_32 outEpNo;
|
||
|
boolean CBW_PROCESSED;
|
||
|
boolean ZERO_TERMINATE;
|
||
|
|
||
|
} USB_DISK_STRUCT;
|
||
|
|
||
|
uint_32 diskHsMaxPktSize = DISK_HS_MAX_PACKET_SIZE;
|
||
|
uint_32 diskFsMaxPktSize = DISK_FS_MAX_PACKET_SIZE;
|
||
|
|
||
|
uint_32 diskInEpType = DISK_IN_EP_TYPE;
|
||
|
uint_32 diskOutEpType = DISK_OUT_EP_TYPE;
|
||
|
|
||
|
uint_32 diskInEpNo = DISK_IN_EP_NO;
|
||
|
uint_32 diskOutEpNo = DISK_OUT_EP_NO;
|
||
|
|
||
|
static USB_DISK_STRUCT* usbDisksPtr[MAX_USB_DEVICES] = { NULL, NULL };
|
||
|
|
||
|
/**************************************************************************
|
||
|
DESCRIPTORS DESCRIPTORS DESCRIPTORS DESCRIPTORS DESCRIPTORS DESCRIPTORS
|
||
|
**************************************************************************/
|
||
|
|
||
|
#define DEVICE_DESCRIPTOR_SIZE 18
|
||
|
static const uint_8 DevDescData[DEVICE_DESCRIPTOR_SIZE] =
|
||
|
{
|
||
|
/* Length of DevDesc */
|
||
|
DEVICE_DESCRIPTOR_SIZE,
|
||
|
/* "Device" Type of descriptor */
|
||
|
1,
|
||
|
/* BCD USB version */
|
||
|
0, 2,
|
||
|
/* Device Class is indicated in the interface descriptors */
|
||
|
0x00,
|
||
|
/* Device Subclass is indicated in the interface descriptors */
|
||
|
0x00,
|
||
|
/* Mass storage devices do not use class-specific protocols */
|
||
|
0x00,
|
||
|
/* Max packet size */
|
||
|
APP_CONTROL_MAX_PKT_SIZE,
|
||
|
/* Vendor ID */
|
||
|
USB_uint_16_low(0x1286), USB_uint_16_high(0x1286),
|
||
|
/* Product ID */
|
||
|
USB_uint_16_low(0x1), USB_uint_16_high(0x1),
|
||
|
/* BCD Device version */
|
||
|
USB_uint_16_low(0x0002), USB_uint_16_high(0x0002),
|
||
|
/* Manufacturer string index */
|
||
|
0x1,
|
||
|
/* Product string index */
|
||
|
0x2,
|
||
|
/* Serial number string index */
|
||
|
0x6,
|
||
|
/* Number of configurations available */
|
||
|
0x1
|
||
|
};
|
||
|
|
||
|
/* USB 2.0 specific descriptor */
|
||
|
#define DEVICE_QUALIFIER_DESCRIPTOR_SIZE 10
|
||
|
static const uint_8 DevQualifierDescData[DEVICE_QUALIFIER_DESCRIPTOR_SIZE] =
|
||
|
{
|
||
|
DEVICE_QUALIFIER_DESCRIPTOR_SIZE, /* bLength Length of this descriptor */
|
||
|
6, /* bDescType This is a DEVICE Qualifier descr */
|
||
|
0,2, /* bcdUSB USB revision 2.0 */
|
||
|
0, /* bDeviceClass */
|
||
|
0, /* bDeviceSubClass */
|
||
|
0, /* bDeviceProtocol */
|
||
|
APP_CONTROL_MAX_PKT_SIZE, /* bMaxPacketSize0 */
|
||
|
0x01, /* bNumConfigurations */
|
||
|
0
|
||
|
};
|
||
|
|
||
|
#define CONFIG_DESC_NUM_INTERFACES (4)
|
||
|
/* This must be counted manually and updated with the descriptor */
|
||
|
/* 1*Config(9) + 1*Interface(9) + 2*Endpoint(7) = 32 bytes */
|
||
|
#define CONFIG_DESC_SIZE (32)
|
||
|
|
||
|
/**************************************************************
|
||
|
we declare the config desc as USB_Uncached because this descriptor
|
||
|
is updated on the fly for max packet size during enumeration. Making
|
||
|
it uncached ensures that main memory is updated whenever this
|
||
|
descriptor pointer is used.
|
||
|
**************************************************************/
|
||
|
static const uint_8 ConfigDescData[CONFIG_DESC_SIZE] =
|
||
|
{
|
||
|
/* Configuration Descriptor - always 9 bytes */
|
||
|
9,
|
||
|
/* "Configuration" type of descriptor */
|
||
|
2,
|
||
|
/* Total length of the Configuration descriptor */
|
||
|
USB_uint_16_low(CONFIG_DESC_SIZE),
|
||
|
USB_uint_16_high(CONFIG_DESC_SIZE),
|
||
|
/* NumInterfaces */
|
||
|
1,
|
||
|
/* Configuration Value */
|
||
|
1,
|
||
|
/* Configuration Description String Index*/
|
||
|
4,
|
||
|
/* Attributes. Self-powered. */
|
||
|
0xc0,
|
||
|
/* Current draw from bus */
|
||
|
0,
|
||
|
/* Interface 0 Descriptor - always 9 bytes */
|
||
|
9,
|
||
|
/* "Interface" type of descriptor */
|
||
|
4,
|
||
|
/* Number of this interface */
|
||
|
MASS_STORAGE_INTERFACE,
|
||
|
/* Alternate Setting */
|
||
|
0,
|
||
|
/* Number of endpoints on this interface */
|
||
|
2,
|
||
|
/* Interface Class */
|
||
|
0x08,
|
||
|
/* Interface Subclass: SCSI transparent command set */
|
||
|
0x06,
|
||
|
/* Interface Protocol: Bulk only protocol */
|
||
|
0x50,
|
||
|
/* Interface Description String Index */
|
||
|
0,
|
||
|
/* Endpoint 1 (Bulk In Endpoint), Interface 0 Descriptor - always 7 bytes*/
|
||
|
7,
|
||
|
/* "Endpoint" type of descriptor */
|
||
|
5,
|
||
|
/*
|
||
|
** Endpoint address. The low nibble contains the endpoint number and the
|
||
|
** high bit indicates TX(1) or RX(0).
|
||
|
*/
|
||
|
((ARC_USB_SEND<<7) | DISK_IN_EP_NO) /*0x81*/,
|
||
|
/* Attributes. 0=Control 1=Isochronous 2=Bulk 3=Interrupt */
|
||
|
DISK_IN_EP_TYPE,
|
||
|
/* Max Packet Size for this endpoint */
|
||
|
USB_uint_16_low(DISK_FS_MAX_PACKET_SIZE),
|
||
|
USB_uint_16_high(DISK_FS_MAX_PACKET_SIZE),
|
||
|
/* Polling Interval (ms) */
|
||
|
0,
|
||
|
/* Endpoint 2 (Bulk Out Endpoint), Interface 0 Descriptor - always 7 bytes*/
|
||
|
7,
|
||
|
/* "Endpoint" type of descriptor */
|
||
|
5,
|
||
|
/*
|
||
|
** Endpoint address. The low nibble contains the endpoint number and the
|
||
|
** high bit indicates TX(1) or RX(0).
|
||
|
*/
|
||
|
((ARC_USB_RECV<<7) | DISK_OUT_EP_NO), /*0x02*/
|
||
|
/* Attributes. 0=Control 1=Isochronous 2=Bulk 3=Interrupt */
|
||
|
DISK_OUT_EP_TYPE,
|
||
|
/* Max Packet Size for this endpoint */
|
||
|
USB_uint_16_low(DISK_FS_MAX_PACKET_SIZE),
|
||
|
USB_uint_16_high(DISK_FS_MAX_PACKET_SIZE),
|
||
|
/* Polling Interval (ms) */
|
||
|
0
|
||
|
};
|
||
|
|
||
|
#define OTHER_SPEED_CONFIG_DESC_SIZE CONFIG_DESC_SIZE
|
||
|
static const uint_8 other_speed_config_data[CONFIG_DESC_SIZE] =
|
||
|
{
|
||
|
9, /* bLength Length of this descriptor */
|
||
|
7, /* bDescType This is a Other speed config descr */
|
||
|
USB_uint_16_low(OTHER_SPEED_CONFIG_DESC_SIZE),
|
||
|
USB_uint_16_high(OTHER_SPEED_CONFIG_DESC_SIZE),
|
||
|
1,
|
||
|
1,
|
||
|
4,
|
||
|
0xc0,
|
||
|
0,
|
||
|
/* Interface 0 Descriptor - always 9 bytes */
|
||
|
9,
|
||
|
/* "Interface" type of descriptor */
|
||
|
4,
|
||
|
/* Number of this interface */
|
||
|
MASS_STORAGE_INTERFACE,
|
||
|
/* Alternate Setting */
|
||
|
0,
|
||
|
/* Number of endpoints on this interface */
|
||
|
2,
|
||
|
/* Interface Class */
|
||
|
0x08,
|
||
|
/* Interface Subclass: SCSI transparent command set */
|
||
|
0x06,
|
||
|
/* Interface Protocol: Bulk only protocol */
|
||
|
0x50,
|
||
|
/* Interface Description String Index */
|
||
|
0,
|
||
|
/* Endpoint 1 (Bulk In Endpoint), Interface 0 Descriptor - always 7 bytes*/
|
||
|
7,
|
||
|
/* "Endpoint" type of descriptor */
|
||
|
5,
|
||
|
/*
|
||
|
** Endpoint address. The low nibble contains the endpoint number and the
|
||
|
** high bit indicates TX(1) or RX(0).
|
||
|
*/
|
||
|
((ARC_USB_SEND<<7) | DISK_IN_EP_NO), /*0x81*/
|
||
|
/* Attributes. 0=Control 1=Isochronous 2=Bulk 3=Interrupt */
|
||
|
DISK_IN_EP_TYPE,
|
||
|
/* Max Packet Size for this endpoint */
|
||
|
USB_uint_16_low(DISK_HS_MAX_PACKET_SIZE),
|
||
|
USB_uint_16_high(DISK_HS_MAX_PACKET_SIZE),
|
||
|
/* Polling Interval (ms) */
|
||
|
0,
|
||
|
/* Endpoint 2 (Bulk Out Endpoint), Interface 0 Descriptor - always 7 bytes*/
|
||
|
7,
|
||
|
/* "Endpoint" type of descriptor */
|
||
|
5,
|
||
|
/*
|
||
|
** Endpoint address. The low nibble contains the endpoint number and the
|
||
|
** high bit indicates TX(1) or RX(0).
|
||
|
*/
|
||
|
((ARC_USB_RECV<<7) | DISK_OUT_EP_NO), /*0x02*/
|
||
|
|
||
|
/* Attributes. 0=Control 1=Isochronous 2=Bulk 3=Interrupt */
|
||
|
DISK_OUT_EP_TYPE,
|
||
|
/* Max Packet Size for this endpoint */
|
||
|
USB_uint_16_low(DISK_HS_MAX_PACKET_SIZE),
|
||
|
USB_uint_16_high(DISK_HS_MAX_PACKET_SIZE),
|
||
|
/* Polling Interval (ms) */
|
||
|
0
|
||
|
};
|
||
|
|
||
|
static uint_8 USB_IF_ALT[4] = { 0, 0, 0, 0};
|
||
|
|
||
|
/* number of strings in the table not including 0 or n. */
|
||
|
static const uint_8 USB_STR_NUM = 7;
|
||
|
|
||
|
/*
|
||
|
** if the number of strings changes, look for USB_STR_0 everywhere and make
|
||
|
** the obvious changes. It should be found in 3 places.
|
||
|
*/
|
||
|
|
||
|
static uint_16 USB_STR_0[ 2] = {(0x300 + sizeof(USB_STR_0)),(0x0409)};
|
||
|
static uint_16 USB_STR_1[26] = {(0x300 + sizeof(USB_STR_1)),
|
||
|
'M','a','r','v','e','l','l',' ','S','e','m','i','c','o','n','d','u','c','t','o','r',' ','L','t','d'};
|
||
|
static uint_16 USB_STR_2[28] = {(0x300 + sizeof(USB_STR_2)),
|
||
|
'M','A','R','V','E','L','L',' ','M','a','s','s',' ','S','t','o','r','a','g','e',' ',\
|
||
|
'D','e','v','i','c','e'};
|
||
|
static uint_16 USB_STR_3[ 5] = {(0x300 + sizeof(USB_STR_3)),
|
||
|
'B','E','T','A'};
|
||
|
static uint_16 USB_STR_4[ 4] = {(0x300 + sizeof(USB_STR_4)),
|
||
|
'#','0','2'};
|
||
|
static uint_16 USB_STR_5[ 4] = {(0x300 + sizeof(USB_STR_5)),
|
||
|
'_','A','1'};
|
||
|
/* Serial number has to be at least 12 bytes */
|
||
|
static uint_16 USB_STR_6[ 13] = {(0x300 + sizeof(USB_STR_6)),
|
||
|
'0','0','0','0','0','0','0','0','0','0','0','1'};
|
||
|
static uint_16 USB_STR_7[15] = {(0x300 + sizeof(USB_STR_7)),
|
||
|
'Y','o','u','r',' ','n','a','m','e',' ','h','e','r','e'};
|
||
|
static uint_16 USB_STR_n[17] = {(0x300 + sizeof(USB_STR_n)),
|
||
|
'B','A','D',' ','S','T','R','I','N','G',' ','I','n','d','e','x'};
|
||
|
|
||
|
#define USB_STRING_ARRAY_SIZE 9
|
||
|
static uint_8_ptr USB_STRING_DESC[USB_STRING_ARRAY_SIZE] =
|
||
|
{
|
||
|
(uint_8_ptr)((pointer)USB_STR_0),
|
||
|
(uint_8_ptr)((pointer)USB_STR_1),
|
||
|
(uint_8_ptr)((pointer)USB_STR_2),
|
||
|
(uint_8_ptr)((pointer)USB_STR_3),
|
||
|
(uint_8_ptr)((pointer)USB_STR_4),
|
||
|
(uint_8_ptr)((pointer)USB_STR_5),
|
||
|
(uint_8_ptr)((pointer)USB_STR_6),
|
||
|
(uint_8_ptr)((pointer)USB_STR_7),
|
||
|
(uint_8_ptr)((pointer)USB_STR_n)
|
||
|
};
|
||
|
|
||
|
/*****************************************************************
|
||
|
MASS STORAGE SPECIFIC GLOBALS
|
||
|
*****************************************************************/
|
||
|
|
||
|
static const DISK_DEVICE_INFO device_information_data =
|
||
|
{
|
||
|
0, 0x80, 0, 0x01, 0x1F,
|
||
|
/* Reserved */
|
||
|
{0, 0, 0},
|
||
|
/* Vendor information: "MARVELL " */
|
||
|
{0x4D, 0x41, 0x52, 0x56, 0x45, 0x4C, 0x4C, 0x20,},
|
||
|
/* Product information: "Disk " */
|
||
|
{0x44, 0x69, 0x73, 0x6B, 0x20, 0x20, 0x20, 0x20,
|
||
|
0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20},
|
||
|
/* Product Revision level: "Demo" */
|
||
|
{0x44, 0x65, 0x6D, 0x6F}
|
||
|
};
|
||
|
|
||
|
static const DISK_READ_CAPACITY read_capacity =
|
||
|
{
|
||
|
/* Data for the capacity */
|
||
|
{
|
||
|
0x00, 0x00, USB_uint_16_high(TOTAL_LOGICAL_ADDRESS_BLOCKS-14),
|
||
|
USB_uint_16_low(TOTAL_LOGICAL_ADDRESS_BLOCKS-14)
|
||
|
},
|
||
|
{
|
||
|
0x00, 0x00, USB_uint_16_high(LENGTH_OF_EACH_LAB),
|
||
|
USB_uint_16_low(LENGTH_OF_EACH_LAB)
|
||
|
}
|
||
|
};
|
||
|
|
||
|
static const uint_8 BOOT_SECTOR_AREA[512] =
|
||
|
{
|
||
|
/* Block 0 is the boot sector. Following is the data in the boot sector */
|
||
|
/* 80x86 "short: jump instruction, indicating that the disk is formatted */
|
||
|
0xEB,
|
||
|
/* 8-bit displacement */
|
||
|
0x3C,
|
||
|
/* NOP OPCode */
|
||
|
0x90,
|
||
|
/* 8-bytes for OEM identification: "ARC 4.3 " */
|
||
|
0x41, 0x52, 0x43, 0x20, 0x34, 0x2E, 0x33, 0x20,
|
||
|
/* bytes/sector: 512 bytes (0x0200) */
|
||
|
0x00, 0x02,
|
||
|
/* Sectors/allocation unit */
|
||
|
0x01,
|
||
|
/* Reserved sectors: 0x0001 */
|
||
|
0x01, 0x00,
|
||
|
/* Number of File Allocation Tables (FATs): 2 */
|
||
|
0x02,
|
||
|
/* Number of root directory entries */
|
||
|
0x00, 0x02,
|
||
|
/* Total Small sectors in logical volume */
|
||
|
USB_uint_16_low(TOTAL_LOGICAL_ADDRESS_BLOCKS),
|
||
|
USB_uint_16_high(TOTAL_LOGICAL_ADDRESS_BLOCKS),
|
||
|
/* Media descriptor byte: 0xF8: Fixed disk */
|
||
|
0xF8,
|
||
|
/* Sectors/FAT: 3 (Each FAT starts at a new sector) */
|
||
|
0x80, 0x00,
|
||
|
/* Sectors/track: 9 */
|
||
|
0x09, 0x00,
|
||
|
/* Number of heads */
|
||
|
0x02, 0x00,
|
||
|
/* Number of hidden sectors: 0 */
|
||
|
0x00, 0x00, 0x00, 0x00,
|
||
|
/* Total Large sectors in logical volume */
|
||
|
0x00, 0x00, 0x00, 0x00,
|
||
|
/* Physical drive number */
|
||
|
0x00,
|
||
|
/* Reserved */
|
||
|
0x00,
|
||
|
/* Extended boot signature record: 0x29 */
|
||
|
0x29,
|
||
|
/* 32-bit binary volume ID */
|
||
|
0x01, 0x02, 0x03, 0x04,
|
||
|
/* Volume label */
|
||
|
0x53, 0x54, 0x55, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
|
||
|
/* Reserved FAT-16*/
|
||
|
0x46, 0x41, 0x54, 0x31, 0x36, 0x00, 0x00, 0x00,
|
||
|
/* Bootstrap */
|
||
|
0x33, 0xC0, 0x8E, 0xD0, 0xBC, 0x00, 0x7C, 0xFC, 0xE8, 0x45, 0x00,
|
||
|
/* String: \r\nNon-System disk\r\nPress any key to reboot\r\n" */
|
||
|
0x0D, 0x0A, 0x4E, 0x6F, 0x6E, 0x2D, 0x53, 0x79, 0x73, 0x74, 0x65,
|
||
|
0x6D, 0x20, 0x64, 0x69, 0x73, 0x6B, 0x0D, 0x0A, 0x50, 0x72, 0x65,
|
||
|
0x73, 0x73, 0x20, 0x61, 0x6E, 0x79, 0x20, 0x6B, 0x65, 0x79, 0x20,
|
||
|
0x74, 0x6F, 0x20, 0x72, 0x65, 0x62, 0x6F, 0x6F, 0x74, 0x0D, 0x0A,
|
||
|
0x5E, 0xEB, 0x02, 0xCD, 0x10, 0xB4, 0x0E, 0xBB, 0x07, 0x00, 0x2E,
|
||
|
0xAC, 0x84, 0xC0, 0x75, 0xF3, 0x98, 0xCD, 0x16, 0xCD, 0x19, 0xEB,
|
||
|
0xB1, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||
|
/* Partition descriptors */
|
||
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x55, 0xAA
|
||
|
};
|
||
|
|
||
|
|
||
|
static const uint_8 FAT16_SPECIAL_BYTES[3] =
|
||
|
{
|
||
|
/* FAT ID: Same as Media descriptor */
|
||
|
0xF8, 0xFF, 0xFF
|
||
|
};
|
||
|
|
||
|
|
||
|
/*FUNCTION*----------------------------------------------------------------
|
||
|
*
|
||
|
* Function Name : ch9GetDescription
|
||
|
* Returned Value : None
|
||
|
* Comments :
|
||
|
* Chapter 9 GetDescription command
|
||
|
* The Device Request can ask for Device/Config/string/interface/endpoint
|
||
|
* descriptors (via wValue). We then post an IN response to return the
|
||
|
* requested descriptor.
|
||
|
* And then wait for the OUT which terminates the control transfer.
|
||
|
*
|
||
|
*END*--------------------------------------------------------------------*/
|
||
|
static void ch9GetDescription
|
||
|
(
|
||
|
/* USB handle */
|
||
|
_usb_device_handle handle,
|
||
|
|
||
|
/* Is it a Setup phase? */
|
||
|
boolean setup,
|
||
|
|
||
|
/* The setup packet pointer */
|
||
|
SETUP_STRUCT_PTR setup_ptr
|
||
|
)
|
||
|
{ /* Body */
|
||
|
int devNo = _usb_device_get_dev_num(handle);
|
||
|
USB_DISK_STRUCT* pDiskCtrl = usbDisksPtr[devNo];
|
||
|
uint_32 max_pkt_size;
|
||
|
|
||
|
ARC_DEBUG_TRACE(ARC_DEBUG_FLAG_SETUP, "usbDisk %s: setup=%d, value=0x%x, length=%d\n",
|
||
|
__FUNCTION__, (int)setup, setup_ptr->VALUE, setup_ptr->LENGTH);
|
||
|
|
||
|
if (setup)
|
||
|
{
|
||
|
/* Load the appropriate string depending on the descriptor requested.*/
|
||
|
switch (setup_ptr->VALUE & 0xFF00)
|
||
|
{
|
||
|
case 0x0100:
|
||
|
_usb_device_send_data(handle, 0, pDiskCtrl->DevDesc,
|
||
|
MIN(setup_ptr->LENGTH, DEVICE_DESCRIPTOR_SIZE));
|
||
|
break;
|
||
|
|
||
|
case 0x0200:
|
||
|
/* Set the Max Packet Size in the config and other speed config */
|
||
|
if(pDiskCtrl->speed == ARC_USB_SPEED_HIGH)
|
||
|
{
|
||
|
max_pkt_size = pDiskCtrl->hsMaxPktSize;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
max_pkt_size = pDiskCtrl->fsMaxPktSize;
|
||
|
} /* Endif */
|
||
|
|
||
|
*(pDiskCtrl->ConfigDesc + CFG_DESC_EP_IN_TYPE_OFFSET) = (uint_8)pDiskCtrl->inEpType;
|
||
|
|
||
|
*(pDiskCtrl->ConfigDesc + CFG_DESC_EP_IN_MAX_PACKET_SIZE_OFFSET) =
|
||
|
USB_uint_16_low(max_pkt_size);
|
||
|
*(pDiskCtrl->ConfigDesc + CFG_DESC_EP_IN_MAX_PACKET_SIZE_OFFSET+1) =
|
||
|
USB_uint_16_high(max_pkt_size);
|
||
|
|
||
|
*(pDiskCtrl->ConfigDesc + CFG_DESC_EP_OUT_TYPE_OFFSET) = (uint_8)pDiskCtrl->outEpType;
|
||
|
|
||
|
*(pDiskCtrl->ConfigDesc + CFG_DESC_EP_OUT_MAX_PACKET_SIZE_OFFSET) =
|
||
|
USB_uint_16_low(max_pkt_size);
|
||
|
*(pDiskCtrl->ConfigDesc + CFG_DESC_EP_OUT_MAX_PACKET_SIZE_OFFSET+1) =
|
||
|
USB_uint_16_high(max_pkt_size);
|
||
|
|
||
|
_usb_device_send_data(handle, 0, pDiskCtrl->ConfigDesc,
|
||
|
MIN(setup_ptr->LENGTH, CONFIG_DESC_SIZE));
|
||
|
break;
|
||
|
|
||
|
case 0x0300:
|
||
|
if ((setup_ptr->VALUE & 0x00FF) > USB_STR_NUM) {
|
||
|
_usb_device_send_data(handle, 0, USB_STRING_DESC[USB_STR_NUM+1],
|
||
|
MIN(setup_ptr->LENGTH, USB_STRING_DESC[USB_STR_NUM+1][0]));
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
_usb_device_send_data(handle, 0, USB_STRING_DESC[setup_ptr->VALUE & 0x00FF],
|
||
|
MIN(setup_ptr->LENGTH, USB_STRING_DESC[setup_ptr->VALUE & 0x00FF][0]));
|
||
|
} /* Endif */
|
||
|
break;
|
||
|
|
||
|
case 0x600:
|
||
|
_usb_device_send_data(handle, 0, (uint_8_ptr)pDiskCtrl->DevQualifierDesc,
|
||
|
MIN(setup_ptr->LENGTH, DEVICE_QUALIFIER_DESCRIPTOR_SIZE));
|
||
|
break;
|
||
|
|
||
|
case 0x700:
|
||
|
if(pDiskCtrl->speed == ARC_USB_SPEED_HIGH)
|
||
|
{
|
||
|
max_pkt_size = pDiskCtrl->fsMaxPktSize;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
max_pkt_size = pDiskCtrl->hsMaxPktSize;
|
||
|
} /* Endif */
|
||
|
|
||
|
*(pDiskCtrl->other_speed_config + CFG_DESC_EP_IN_TYPE_OFFSET) = (uint_8)pDiskCtrl->inEpType;
|
||
|
|
||
|
*(pDiskCtrl->other_speed_config + CFG_DESC_EP_IN_MAX_PACKET_SIZE_OFFSET) =
|
||
|
USB_uint_16_low(max_pkt_size);
|
||
|
*(pDiskCtrl->other_speed_config + CFG_DESC_EP_IN_MAX_PACKET_SIZE_OFFSET+1) =
|
||
|
USB_uint_16_high(max_pkt_size);
|
||
|
|
||
|
*(pDiskCtrl->other_speed_config + CFG_DESC_EP_OUT_TYPE_OFFSET) = (uint_8)pDiskCtrl->outEpType;
|
||
|
|
||
|
*(pDiskCtrl->other_speed_config + CFG_DESC_EP_OUT_MAX_PACKET_SIZE_OFFSET) =
|
||
|
USB_uint_16_low(max_pkt_size);
|
||
|
*(pDiskCtrl->other_speed_config + CFG_DESC_EP_OUT_MAX_PACKET_SIZE_OFFSET+1) =
|
||
|
USB_uint_16_high(max_pkt_size);
|
||
|
|
||
|
_usb_device_send_data(handle, 0, (uint_8_ptr)pDiskCtrl->other_speed_config,
|
||
|
MIN(setup_ptr->LENGTH, OTHER_SPEED_CONFIG_DESC_SIZE));
|
||
|
|
||
|
break;
|
||
|
|
||
|
default:
|
||
|
USB_printf("usbDisk_%d, %s: Unexpected VALUE=0x%04x\n",
|
||
|
_usb_device_get_dev_num(handle), __FUNCTION__, setup_ptr->VALUE);
|
||
|
_usb_device_stall_endpoint(handle, 0, ARC_USB_RECV);
|
||
|
return;
|
||
|
} /* Endswitch */
|
||
|
/* status phase */
|
||
|
_usb_device_recv_data(handle, 0, NULL, 0);
|
||
|
} /* Endif */
|
||
|
return;
|
||
|
} /* Endbody */
|
||
|
|
||
|
/*FUNCTION*----------------------------------------------------------------
|
||
|
*
|
||
|
* Function Name : ch9SetDescription
|
||
|
* Returned Value : None
|
||
|
* Comments :
|
||
|
* Chapter 9 SetDescription command
|
||
|
*
|
||
|
*END*--------------------------------------------------------------------*/
|
||
|
static void ch9SetDescription
|
||
|
(
|
||
|
/* USB handle */
|
||
|
_usb_device_handle handle,
|
||
|
|
||
|
/* Is it a Setup phase? */
|
||
|
boolean setup,
|
||
|
|
||
|
/* The setup packet pointer */
|
||
|
SETUP_STRUCT_PTR setup_ptr
|
||
|
)
|
||
|
{ /* Body */
|
||
|
USB_printf("usbDisk_%d, %s: setup=%d\n",
|
||
|
_usb_device_get_dev_num(handle), __FUNCTION__, (int)setup);
|
||
|
_usb_device_stall_endpoint(handle, 0, ARC_USB_RECV);
|
||
|
|
||
|
return;
|
||
|
} /* Endbody */
|
||
|
|
||
|
/*FUNCTION*----------------------------------------------------------------
|
||
|
*
|
||
|
* Function Name : ch9GetConfig
|
||
|
* Returned Value : None
|
||
|
* Comments :
|
||
|
* Chapter 9 GetConfig command
|
||
|
*
|
||
|
*END*--------------------------------------------------------------------*/
|
||
|
static void ch9GetConfig
|
||
|
(
|
||
|
/* USB handle */
|
||
|
_usb_device_handle handle,
|
||
|
|
||
|
/* Is it a Setup phase? */
|
||
|
boolean setup,
|
||
|
|
||
|
/* The setup packet pointer */
|
||
|
SETUP_STRUCT_PTR setup_ptr
|
||
|
)
|
||
|
{ /* Body */
|
||
|
uint_16 current_config;
|
||
|
int devNo = _usb_device_get_dev_num(handle);
|
||
|
USB_DISK_STRUCT* pDiskCtrl = usbDisksPtr[devNo];
|
||
|
|
||
|
ARC_DEBUG_TRACE(ARC_DEBUG_FLAG_SETUP, "usbDisk %s: setup=%d\n", __FUNCTION__, (int)setup);
|
||
|
|
||
|
/* Return the currently selected configuration */
|
||
|
if (setup)
|
||
|
{
|
||
|
_usb_device_get_status(handle, ARC_USB_STATUS_CURRENT_CONFIG,
|
||
|
¤t_config);
|
||
|
*pDiskCtrl->epTemp_buf = (current_config & 0xFF);
|
||
|
_usb_device_send_data(handle, 0, pDiskCtrl->epTemp_buf, sizeof(uint_8));
|
||
|
/* status phase */
|
||
|
_usb_device_recv_data(handle, 0, NULL, 0);
|
||
|
} /* Endif */
|
||
|
return;
|
||
|
} /* Endbody */
|
||
|
|
||
|
/*FUNCTION*----------------------------------------------------------------
|
||
|
*
|
||
|
* Function Name : ch9SetConfig
|
||
|
* Returned Value : None
|
||
|
* Comments :
|
||
|
* Chapter 9 SetConfig command
|
||
|
*
|
||
|
*END*--------------------------------------------------------------------*/
|
||
|
static void ch9SetConfig
|
||
|
(
|
||
|
/* USB handle */
|
||
|
_usb_device_handle handle,
|
||
|
|
||
|
/* Is it a Setup phase? */
|
||
|
boolean setup,
|
||
|
|
||
|
/* The setup packet pointer */
|
||
|
SETUP_STRUCT_PTR setup_ptr
|
||
|
)
|
||
|
{ /* Body */
|
||
|
int devNo = _usb_device_get_dev_num(handle);
|
||
|
USB_DISK_STRUCT* pDiskCtrl = usbDisksPtr[devNo];
|
||
|
uint_16 usb_state;
|
||
|
uint_32 max_pkt_size;
|
||
|
|
||
|
ARC_DEBUG_TRACE(ARC_DEBUG_FLAG_SETUP, "usbDisk %s: setup=%d, value=0x%x\n",
|
||
|
__FUNCTION__, (int)setup, setup_ptr->VALUE);
|
||
|
|
||
|
if (setup)
|
||
|
{
|
||
|
if ((setup_ptr->VALUE & 0x00FF) > 1)
|
||
|
{
|
||
|
/* generate stall */
|
||
|
USB_printf("usbDisk_%d, %s: Wrong VALUE=0x%04x\n",
|
||
|
_usb_device_get_dev_num(handle), __FUNCTION__, setup_ptr->VALUE);
|
||
|
_usb_device_stall_endpoint(handle, 0, ARC_USB_RECV);
|
||
|
return;
|
||
|
} /* Endif */
|
||
|
|
||
|
/* 0 indicates return to unconfigured state */
|
||
|
if ((setup_ptr->VALUE & 0x00FF) == 0)
|
||
|
{
|
||
|
_usb_device_get_status(handle, ARC_USB_STATUS_DEVICE_STATE, &usb_state);
|
||
|
if( (usb_state == ARC_USB_STATE_CONFIG) ||
|
||
|
(usb_state == ARC_USB_STATE_ADDRESS) )
|
||
|
{
|
||
|
/* clear the currently selected config value */
|
||
|
_usb_device_set_status(handle, ARC_USB_STATUS_CURRENT_CONFIG, 0);
|
||
|
_usb_device_set_status(handle, ARC_USB_STATUS_DEVICE_STATE,
|
||
|
ARC_USB_STATE_ADDRESS);
|
||
|
/* status phase */
|
||
|
_usb_device_send_data(handle, 0, 0, 0);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
USB_printf("usbDisk_%d, %s: Wrong usb_state=%d\n",
|
||
|
_usb_device_get_dev_num(handle), __FUNCTION__, usb_state);
|
||
|
_usb_device_stall_endpoint(handle, 0, ARC_USB_RECV);
|
||
|
} /* Endif */
|
||
|
return;
|
||
|
} /* Endif */
|
||
|
|
||
|
/*
|
||
|
** If the configuration value (setup_ptr->VALUE & 0x00FF) differs
|
||
|
** from the current configuration value, then endpoints must be
|
||
|
** reconfigured to match the new device configuration
|
||
|
*/
|
||
|
_usb_device_get_status(handle, ARC_USB_STATUS_CURRENT_CONFIG,
|
||
|
&usb_state);
|
||
|
|
||
|
ARC_DEBUG_TRACE(ARC_DEBUG_FLAG_SETUP, "usbDisk: Set configuration: old=%d, new=%d\n",
|
||
|
usb_state, setup_ptr->VALUE & 0x00FF);
|
||
|
|
||
|
if (usb_state != (setup_ptr->VALUE & 0x00FF))
|
||
|
{
|
||
|
/* Reconfigure endpoints here */
|
||
|
switch (setup_ptr->VALUE & 0x00FF)
|
||
|
{
|
||
|
default:
|
||
|
break;
|
||
|
} /* Endswitch */
|
||
|
|
||
|
_usb_device_set_status(handle, ARC_USB_STATUS_CURRENT_CONFIG,
|
||
|
setup_ptr->VALUE & 0x00FF);
|
||
|
} /* Endif */
|
||
|
|
||
|
if (pDiskCtrl->speed == ARC_USB_SPEED_HIGH)
|
||
|
{
|
||
|
max_pkt_size = pDiskCtrl->hsMaxPktSize;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
max_pkt_size = pDiskCtrl->fsMaxPktSize;
|
||
|
} /* Endif */
|
||
|
|
||
|
_usb_device_init_endpoint(handle, pDiskCtrl->outEpNo, max_pkt_size,
|
||
|
ARC_USB_RECV, ARC_USB_BULK_ENDPOINT, ARC_USB_DEVICE_DONT_ZERO_TERMINATE);
|
||
|
_usb_device_init_endpoint(handle, pDiskCtrl->inEpNo, max_pkt_size,
|
||
|
ARC_USB_SEND, ARC_USB_BULK_ENDPOINT, ARC_USB_DEVICE_DONT_ZERO_TERMINATE);
|
||
|
|
||
|
if (_usb_device_get_transfer_status(handle, pDiskCtrl->outEpNo, ARC_USB_RECV) == USB_OK)
|
||
|
{
|
||
|
_usb_device_recv_data(handle, pDiskCtrl->outEpNo, pDiskCtrl->ep1_buf, 31);
|
||
|
} /* Endif */
|
||
|
|
||
|
pDiskCtrl->TEST_ENABLED = TRUE;
|
||
|
|
||
|
_usb_device_set_status(handle, ARC_USB_STATUS_DEVICE_STATE,
|
||
|
ARC_USB_STATE_CONFIG);
|
||
|
/* status phase */
|
||
|
_usb_device_send_data(handle, 0, 0, 0);
|
||
|
|
||
|
USB_printf("USB %s speed disk: config = %d\n",
|
||
|
(pDiskCtrl->speed == ARC_USB_SPEED_HIGH) ? "High" : "Full",
|
||
|
setup_ptr->VALUE & 0x00FF);
|
||
|
|
||
|
} /* Endif */
|
||
|
return;
|
||
|
} /* Endbody */
|
||
|
|
||
|
/*FUNCTION*----------------------------------------------------------------
|
||
|
*
|
||
|
* Function Name : ch9GetInterface
|
||
|
* Returned Value : None
|
||
|
* Comments :
|
||
|
* Chapter 9 GetInterface command
|
||
|
*
|
||
|
*END*--------------------------------------------------------------------*/
|
||
|
static void ch9GetInterface
|
||
|
(
|
||
|
/* USB handle */
|
||
|
_usb_device_handle handle,
|
||
|
|
||
|
/* Is it a Setup phase? */
|
||
|
boolean setup,
|
||
|
|
||
|
/* The setup packet pointer */
|
||
|
SETUP_STRUCT_PTR setup_ptr
|
||
|
)
|
||
|
{ /* Body */
|
||
|
uint_16 usb_state;
|
||
|
|
||
|
ARC_DEBUG_TRACE(ARC_DEBUG_FLAG_SETUP, "usbDisk %s: setup=%d\n", __FUNCTION__, (int)setup);
|
||
|
|
||
|
_usb_device_get_status(handle, ARC_USB_STATUS_DEVICE_STATE, &usb_state);
|
||
|
if (usb_state != ARC_USB_STATE_CONFIG)
|
||
|
{
|
||
|
USB_printf("usbDisk_%d, %s: Wrong usb_state=%d\n",
|
||
|
_usb_device_get_dev_num(handle), __FUNCTION__, usb_state);
|
||
|
_usb_device_stall_endpoint(handle, 0, ARC_USB_RECV);
|
||
|
return;
|
||
|
} /* Endif */
|
||
|
|
||
|
if (setup)
|
||
|
{
|
||
|
_usb_device_send_data(handle, 0, &USB_IF_ALT[setup_ptr->INDEX & 0x00FF],
|
||
|
MIN(setup_ptr->LENGTH, sizeof(uint_8)));
|
||
|
/* status phase */
|
||
|
_usb_device_recv_data(handle, 0, NULL, 0);
|
||
|
} /* Endif */
|
||
|
return;
|
||
|
} /* Endbody */
|
||
|
|
||
|
/*FUNCTION*----------------------------------------------------------------
|
||
|
*
|
||
|
* Function Name : ch9SetInterface
|
||
|
* Returned Value : None
|
||
|
* Comments :
|
||
|
* Chapter 9 SetInterface command
|
||
|
*
|
||
|
*END*--------------------------------------------------------------------*/
|
||
|
static void ch9SetInterface
|
||
|
(
|
||
|
/* USB handle */
|
||
|
_usb_device_handle handle,
|
||
|
|
||
|
/* Is it a Setup phase? */
|
||
|
boolean setup,
|
||
|
|
||
|
/* The setup packet pointer */
|
||
|
SETUP_STRUCT_PTR setup_ptr
|
||
|
)
|
||
|
{ /* Body */
|
||
|
ARC_DEBUG_TRACE(ARC_DEBUG_FLAG_SETUP, "usbDisk %s: setup=%d\n", __FUNCTION__, (int)setup);
|
||
|
|
||
|
if (setup)
|
||
|
{
|
||
|
if (setup_ptr->REQUESTTYPE != 0x01)
|
||
|
{
|
||
|
USB_printf("usbDisk_%d, %s: Wrong REQUESTTYPE=0x%02x\n",
|
||
|
_usb_device_get_dev_num(handle), __FUNCTION__,
|
||
|
setup_ptr->REQUESTTYPE);
|
||
|
_usb_device_stall_endpoint(handle, 0, ARC_USB_RECV);
|
||
|
return;
|
||
|
} /* Endif */
|
||
|
|
||
|
/*
|
||
|
** If the alternate value (setup_ptr->VALUE & 0x00FF) differs
|
||
|
** from the current alternate value for the specified interface,
|
||
|
** then endpoints must be reconfigured to match the new alternate
|
||
|
*/
|
||
|
if (USB_IF_ALT[setup_ptr->INDEX & 0x00FF]
|
||
|
!= (setup_ptr->VALUE & 0x00FF))
|
||
|
{
|
||
|
USB_IF_ALT[setup_ptr->INDEX & 0x00FF] = (setup_ptr->VALUE & 0x00FF);
|
||
|
/* Reconfigure endpoints here. */
|
||
|
|
||
|
} /* Endif */
|
||
|
|
||
|
/* status phase */
|
||
|
_usb_device_send_data(handle, 0, 0, 0);
|
||
|
} /* Endif */
|
||
|
return;
|
||
|
} /* Endbody */
|
||
|
|
||
|
/*FUNCTION*----------------------------------------------------------------
|
||
|
*
|
||
|
* Function Name : ch9SynchFrame
|
||
|
* Returned Value :
|
||
|
* Comments :
|
||
|
* Chapter 9 SynchFrame command
|
||
|
*
|
||
|
*END*--------------------------------------------------------------------*/
|
||
|
static void ch9SynchFrame
|
||
|
(
|
||
|
/* USB handle */
|
||
|
_usb_device_handle handle,
|
||
|
|
||
|
/* Is it a Setup phase? */
|
||
|
boolean setup,
|
||
|
|
||
|
/* The setup packet pointer */
|
||
|
SETUP_STRUCT_PTR setup_ptr
|
||
|
)
|
||
|
{ /* Body */
|
||
|
|
||
|
uint_16 usbStatus;
|
||
|
int devNo = _usb_device_get_dev_num(handle);
|
||
|
USB_DISK_STRUCT* pDiskCtrl = usbDisksPtr[devNo];
|
||
|
|
||
|
ARC_DEBUG_TRACE(ARC_DEBUG_FLAG_SETUP, "usbDisk %s: setup=%d\n",
|
||
|
__FUNCTION__, (int)setup);
|
||
|
|
||
|
if (setup)
|
||
|
{
|
||
|
if (setup_ptr->REQUESTTYPE != (REQ_RECIP_ENDPOINT | REQ_TYPE_STANDARD | REQ_DIR_OUT) )
|
||
|
{
|
||
|
USB_printf("usbDisk_%d, %s: Wrong REQUESTTYPE=0x%02x\n",
|
||
|
_usb_device_get_dev_num(handle), __FUNCTION__,
|
||
|
setup_ptr->REQUESTTYPE);
|
||
|
_usb_device_stall_endpoint(handle, 0, ARC_USB_RECV);
|
||
|
return;
|
||
|
} /* Endif */
|
||
|
|
||
|
if ((setup_ptr->INDEX & 0x00FF) >=
|
||
|
pDiskCtrl->ConfigDesc[CONFIG_DESC_NUM_INTERFACES])
|
||
|
{
|
||
|
USB_printf("usbDisk_%d, %s: Wrong INDEX=0x%02x\n",
|
||
|
_usb_device_get_dev_num(handle), __FUNCTION__, setup_ptr->INDEX);
|
||
|
_usb_device_stall_endpoint(handle, 0, ARC_USB_RECV);
|
||
|
return;
|
||
|
} /* Endif */
|
||
|
|
||
|
_usb_device_get_status(handle, ARC_USB_STATUS_SOF_COUNT, &usbStatus);
|
||
|
pDiskCtrl->epTemp_buf[0] = USB_uint_16_low(usbStatus);
|
||
|
pDiskCtrl->epTemp_buf[1] = USB_uint_16_high(usbStatus);
|
||
|
_usb_device_send_data(handle, 0, pDiskCtrl->epTemp_buf, MIN(setup_ptr->LENGTH, sizeof(uint_16)));
|
||
|
/* status phase */
|
||
|
_usb_device_recv_data(handle, 0, NULL, 0);
|
||
|
} /* Endif */
|
||
|
return;
|
||
|
} /* Endbody */
|
||
|
|
||
|
/*FUNCTION*----------------------------------------------------------------
|
||
|
*
|
||
|
* Function Name : ch9Class
|
||
|
* Returned Value :
|
||
|
* Comments :
|
||
|
* Chapter 9 Class specific request
|
||
|
* See section 9.4.11 (page 195) of the USB 1.1 Specification.
|
||
|
*
|
||
|
*END*--------------------------------------------------------------------*/
|
||
|
static void ch9Class
|
||
|
(
|
||
|
_usb_device_handle handle,
|
||
|
boolean setup,
|
||
|
uint_8 direction,
|
||
|
SETUP_STRUCT_PTR setup_ptr
|
||
|
)
|
||
|
{ /* Body */
|
||
|
int devNo = _usb_device_get_dev_num(handle);
|
||
|
USB_DISK_STRUCT* pDiskCtrl = usbDisksPtr[devNo];
|
||
|
|
||
|
ARC_DEBUG_TRACE(ARC_DEBUG_FLAG_CLASS,
|
||
|
"usbDisk %s: setup=%d, request=0x%x, value=%d, index=%d, size=%d\n",
|
||
|
__FUNCTION__, (int)setup, setup_ptr->REQUEST,
|
||
|
setup_ptr->VALUE, setup_ptr->INDEX, setup_ptr->LENGTH);
|
||
|
|
||
|
if (setup)
|
||
|
{
|
||
|
switch (setup_ptr->REQUEST)
|
||
|
{
|
||
|
case 0xFF:
|
||
|
/* Bulk-Only Mass Storage Reset: Ready the device for the next
|
||
|
** CBW from the host
|
||
|
*/
|
||
|
if ((setup_ptr->VALUE != 0) ||
|
||
|
(setup_ptr->INDEX != MASS_STORAGE_INTERFACE) ||
|
||
|
(setup_ptr->LENGTH != 0))
|
||
|
{
|
||
|
USB_printf("usbDisk_%d, %s: Wrong Setup: VALUE=%d, INDEX=%d, LENGTH=%d\n",
|
||
|
_usb_device_get_dev_num(handle), __FUNCTION__, setup_ptr->VALUE,
|
||
|
setup_ptr->INDEX, setup_ptr->LENGTH);
|
||
|
|
||
|
_usb_device_stall_endpoint(handle, 0, 0);
|
||
|
}
|
||
|
else
|
||
|
{ /* Body */
|
||
|
pDiskCtrl->CBW_PROCESSED = FALSE;
|
||
|
pDiskCtrl->ZERO_TERMINATE = FALSE;
|
||
|
_usb_device_cancel_transfer(handle, pDiskCtrl->outEpNo, ARC_USB_RECV);
|
||
|
_usb_device_cancel_transfer(handle, pDiskCtrl->inEpNo, ARC_USB_SEND);
|
||
|
|
||
|
/* unstall bulk endpoint */
|
||
|
_usb_device_unstall_endpoint(handle, pDiskCtrl->outEpNo, ARC_USB_RECV);
|
||
|
_usb_device_unstall_endpoint(handle, pDiskCtrl->inEpNo, ARC_USB_SEND);
|
||
|
|
||
|
_usb_device_recv_data(handle, pDiskCtrl->outEpNo, pDiskCtrl->ep1_buf, 31);
|
||
|
/* send zero packet to control pipe */
|
||
|
_usb_device_send_data(handle, 0, NULL, 0);
|
||
|
} /* Endbody */
|
||
|
break;
|
||
|
|
||
|
case 0xFE:
|
||
|
/* For Get Max LUN use any of these responses*/
|
||
|
if (setup_ptr->LENGTH == 0)
|
||
|
{ /* Body */
|
||
|
|
||
|
USB_printf("usbDisk_%d, %s: Wrong Length: LENGTH=%d\n",
|
||
|
_usb_device_get_dev_num(handle), __FUNCTION__, setup_ptr->LENGTH);
|
||
|
|
||
|
_usb_device_stall_endpoint(handle, 0, 0);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
if ((setup_ptr->VALUE != 0) ||
|
||
|
(setup_ptr->INDEX != MASS_STORAGE_INTERFACE) ||
|
||
|
(setup_ptr->LENGTH != 1))
|
||
|
{ /* Body */
|
||
|
USB_printf("usbDisk_%d, %s: Wrong Setup: VALUE=%d, INDEX=%d, LENGTH=%d\n",
|
||
|
_usb_device_get_dev_num(handle), __FUNCTION__, setup_ptr->VALUE,
|
||
|
setup_ptr->INDEX, setup_ptr->LENGTH);
|
||
|
_usb_device_stall_endpoint(handle, 0, 0);
|
||
|
}
|
||
|
else
|
||
|
{ /* Body */
|
||
|
/* Send Max LUN = 0 to the the control pipe */
|
||
|
*pDiskCtrl->epTemp_buf = 0;
|
||
|
_usb_device_send_data(handle, 0, pDiskCtrl->epTemp_buf, 1);
|
||
|
/* status phase */
|
||
|
_usb_device_recv_data(handle, 0, 0, 0);
|
||
|
} /* Endbody */
|
||
|
}
|
||
|
break;
|
||
|
|
||
|
default :
|
||
|
USB_printf("usbDisk_%d, %s: Wrong REQUEST=0x%02x\n",
|
||
|
_usb_device_get_dev_num(handle), __FUNCTION__, setup_ptr->REQUEST);
|
||
|
_usb_device_stall_endpoint(handle, 0, 0);
|
||
|
return;
|
||
|
} /* EndSwitch */
|
||
|
}
|
||
|
return;
|
||
|
} /* Endbody */
|
||
|
|
||
|
/*FUNCTION*----------------------------------------------------------------
|
||
|
*
|
||
|
* Function Name : service_ep0
|
||
|
* Returned Value : None
|
||
|
* Comments :
|
||
|
* Called upon a completed endpoint 0 (USB 1.1 Chapter 9) transfer
|
||
|
*
|
||
|
*END*--------------------------------------------------------------------*/
|
||
|
static void service_ep0
|
||
|
(
|
||
|
/* [IN] Handle of the USB device */
|
||
|
_usb_device_handle handle,
|
||
|
|
||
|
/* [IN] request type as registered */
|
||
|
uint_8 type,
|
||
|
|
||
|
/* [IN] Is it a setup packet? */
|
||
|
boolean setup,
|
||
|
|
||
|
/* [IN] Direction of the transfer. Is it transmit? */
|
||
|
uint_8 direction,
|
||
|
|
||
|
/* [IN] Pointer to the data buffer */
|
||
|
uint_8_ptr buffer,
|
||
|
|
||
|
/* [IN] Length of the transfer */
|
||
|
uint_32 length,
|
||
|
|
||
|
/* [IN] Error, if any */
|
||
|
uint_8 error
|
||
|
|
||
|
)
|
||
|
{ /* Body */
|
||
|
int devNo = _usb_device_get_dev_num(handle);
|
||
|
USB_DISK_STRUCT* pDiskCtrl = usbDisksPtr[devNo];
|
||
|
SETUP_STRUCT* pSetupPacket = &pDiskCtrl->local_setup_packet;
|
||
|
|
||
|
if (setup)
|
||
|
{
|
||
|
_usb_device_read_setup_data(handle, 0, (uint_8_ptr)pSetupPacket);
|
||
|
pSetupPacket->VALUE = USB_16BIT_LE(pSetupPacket->VALUE);
|
||
|
pSetupPacket->INDEX = USB_16BIT_LE(pSetupPacket->INDEX);
|
||
|
pSetupPacket->LENGTH = USB_16BIT_LE(pSetupPacket->LENGTH);
|
||
|
}
|
||
|
|
||
|
ARC_DEBUG_TRACE(ARC_DEBUG_FLAG_EP0,
|
||
|
"disk %s: setup=%s, dir=%s, pBuf=0x%x, length=%d, reqType=0x%x, req=0x%x\n",
|
||
|
__FUNCTION__, (setup ? "YES" : "NO"),
|
||
|
(direction == ARC_USB_RECV) ? "RECV" : "SEND",
|
||
|
(unsigned)buffer, (int)length, pSetupPacket->REQUESTTYPE,
|
||
|
pSetupPacket->REQUEST);
|
||
|
|
||
|
switch (pSetupPacket->REQUESTTYPE & REQ_TYPE_MASK)
|
||
|
{
|
||
|
case REQ_TYPE_STANDARD:
|
||
|
switch (pSetupPacket->REQUEST)
|
||
|
{
|
||
|
case REQ_GET_STATUS:
|
||
|
mvUsbCh9GetStatus(handle, setup, pSetupPacket);
|
||
|
break;
|
||
|
|
||
|
case REQ_CLEAR_FEATURE:
|
||
|
mvUsbCh9ClearFeature(handle, setup, pSetupPacket);
|
||
|
break;
|
||
|
|
||
|
case REQ_SET_FEATURE:
|
||
|
mvUsbCh9SetFeature(handle, setup, pSetupPacket);
|
||
|
break;
|
||
|
|
||
|
case REQ_SET_ADDRESS:
|
||
|
mvUsbCh9SetAddress(handle, setup, pSetupPacket);
|
||
|
break;
|
||
|
|
||
|
case REQ_GET_DESCRIPTOR:
|
||
|
ch9GetDescription(handle, setup, pSetupPacket);
|
||
|
break;
|
||
|
|
||
|
case REQ_SET_DESCRIPTOR:
|
||
|
ch9SetDescription(handle, setup, pSetupPacket);
|
||
|
break;
|
||
|
|
||
|
case REQ_GET_CONFIGURATION:
|
||
|
ch9GetConfig(handle, setup, pSetupPacket);
|
||
|
break;
|
||
|
|
||
|
case REQ_SET_CONFIGURATION:
|
||
|
ch9SetConfig(handle, setup, pSetupPacket);
|
||
|
break;
|
||
|
|
||
|
case REQ_GET_INTERFACE:
|
||
|
ch9GetInterface(handle, setup, pSetupPacket);
|
||
|
break;
|
||
|
|
||
|
case REQ_SET_INTERFACE:
|
||
|
ch9SetInterface(handle, setup, pSetupPacket);
|
||
|
break;
|
||
|
|
||
|
case REQ_SYNCH_FRAME:
|
||
|
ch9SynchFrame(handle, setup, pSetupPacket);
|
||
|
break;
|
||
|
|
||
|
default:
|
||
|
USB_printf("usbDisk_%d, %s: Wrong REQUEST = 0x%02x\n",
|
||
|
_usb_device_get_dev_num(handle), __FUNCTION__, pSetupPacket->REQUEST);
|
||
|
_usb_device_stall_endpoint(handle, 0, 0);
|
||
|
break;
|
||
|
|
||
|
} /* Endswitch */
|
||
|
|
||
|
break;
|
||
|
|
||
|
case REQ_TYPE_CLASS:
|
||
|
/* class specific request */
|
||
|
ch9Class(handle, setup, direction, pSetupPacket);
|
||
|
return;
|
||
|
|
||
|
case REQ_TYPE_VENDOR:
|
||
|
/* vendor specific request can be handled here*/
|
||
|
USB_printf("usbDisk_%d, %s: Vendor REQUESTTYPE (%d) not supported\n",
|
||
|
_usb_device_get_dev_num(handle), __FUNCTION__, REQ_TYPE_VENDOR);
|
||
|
|
||
|
_usb_device_stall_endpoint(handle, 0, 0);
|
||
|
break;
|
||
|
|
||
|
default:
|
||
|
USB_printf("usbDisk_%d, %s: Unexpected REQUESTTYPE = 0x%x\n",
|
||
|
_usb_device_get_dev_num(handle), __FUNCTION__,
|
||
|
pSetupPacket->REQUESTTYPE);
|
||
|
|
||
|
_usb_device_stall_endpoint(handle, 0, 0);
|
||
|
break;
|
||
|
|
||
|
} /* Endswitch */
|
||
|
|
||
|
return;
|
||
|
} /* Endbody */
|
||
|
|
||
|
/*FUNCTION*----------------------------------------------------------------
|
||
|
*
|
||
|
* Function Name : _process_inquiry_command
|
||
|
* Returned Value : None
|
||
|
* Comments :
|
||
|
* Process a Mass storage class Inquiry command
|
||
|
*
|
||
|
*END*--------------------------------------------------------------------*/
|
||
|
void _process_inquiry_command
|
||
|
(
|
||
|
/* [IN] Handle of the USB device */
|
||
|
_usb_device_handle handle,
|
||
|
|
||
|
/* [IN] Endpoint number */
|
||
|
uint_8 ep_num,
|
||
|
|
||
|
/* [IN] Pointer to the data buffer */
|
||
|
CBW_STRUCT_PTR cbw_ptr
|
||
|
)
|
||
|
{ /* Body */
|
||
|
int devNo = _usb_device_get_dev_num(handle);
|
||
|
USB_DISK_STRUCT* pDiskCtrl = usbDisksPtr[devNo];
|
||
|
|
||
|
if (cbw_ptr->DCBWDATALENGTH)
|
||
|
{
|
||
|
if (cbw_ptr->BMCBWFLAGS & USB_CBW_DIRECTION_BIT)
|
||
|
{
|
||
|
/* Send the device information */
|
||
|
_usb_device_send_data(handle, pDiskCtrl->inEpNo, (uint_8_ptr)&device_information_data, 36);
|
||
|
} /* Endif */
|
||
|
} /* Endif */
|
||
|
|
||
|
/* The actual length will never exceed the DCBWDATALENGTH */
|
||
|
pDiskCtrl->pCSW->DCSWDATARESIDUE = USB_32BIT_LE(cbw_ptr->DCBWDATALENGTH - 36);
|
||
|
pDiskCtrl->pCSW->BCSWSTATUS = 0;
|
||
|
|
||
|
} /* EndBody */
|
||
|
|
||
|
/*FUNCTION*----------------------------------------------------------------
|
||
|
*
|
||
|
* Function Name : _process_unsupported_command
|
||
|
* Returned Value : None
|
||
|
* Comments :
|
||
|
* Responds appropriately to unsupported commands
|
||
|
*
|
||
|
*END*--------------------------------------------------------------------*/
|
||
|
void _process_unsupported_command
|
||
|
(
|
||
|
/* [IN] Handle of the USB device */
|
||
|
_usb_device_handle handle,
|
||
|
|
||
|
/* [IN] Endpoint number */
|
||
|
uint_8 ep_num,
|
||
|
|
||
|
/* [IN] Pointer to the data buffer */
|
||
|
CBW_STRUCT_PTR cbw_ptr
|
||
|
)
|
||
|
{ /* Body */
|
||
|
int devNo = _usb_device_get_dev_num(handle);
|
||
|
USB_DISK_STRUCT* pDiskCtrl = usbDisksPtr[devNo];
|
||
|
|
||
|
ARC_DEBUG_TRACE(ARC_DEBUG_FLAG_DISK,
|
||
|
"disk unsupported command: BMCBWFLAGS = 0x%02x\n", cbw_ptr->BMCBWFLAGS);
|
||
|
|
||
|
/* The actual length will never exceed the DCBWDATALENGTH */
|
||
|
pDiskCtrl->pCSW->DCSWDATARESIDUE = 0;
|
||
|
pDiskCtrl->pCSW->BCSWSTATUS = 0;
|
||
|
|
||
|
if (cbw_ptr->BMCBWFLAGS & USB_CBW_DIRECTION_BIT)
|
||
|
{
|
||
|
/* Send a zero-length packet */
|
||
|
_usb_device_send_data(handle, pDiskCtrl->inEpNo, (uint_8_ptr)NULL, 0);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
pDiskCtrl->CBW_PROCESSED = FALSE;
|
||
|
/* Send the command status information */
|
||
|
_usb_device_send_data(handle, pDiskCtrl->inEpNo, (uint_8_ptr)pDiskCtrl->pCSW, 13);
|
||
|
_usb_device_recv_data(handle, pDiskCtrl->outEpNo, pDiskCtrl->ep1_buf, 31);
|
||
|
} /* Endif */
|
||
|
|
||
|
} /* EndBody */
|
||
|
|
||
|
/*FUNCTION*----------------------------------------------------------------
|
||
|
*
|
||
|
* Function Name : _process_report_capacity
|
||
|
* Returned Value : None
|
||
|
* Comments :
|
||
|
* Reports the media capacity as a response to READ CAPACITY Command.
|
||
|
*
|
||
|
*END*--------------------------------------------------------------------*/
|
||
|
void _process_report_capacity
|
||
|
(
|
||
|
/* [IN] Handle of the USB device */
|
||
|
_usb_device_handle handle,
|
||
|
|
||
|
/* [IN] Endpoint number */
|
||
|
uint_8 ep_num,
|
||
|
|
||
|
/* [IN] Pointer to the data buffer */
|
||
|
CBW_STRUCT_PTR cbw_ptr
|
||
|
)
|
||
|
{ /* Body */
|
||
|
int devNo = _usb_device_get_dev_num(handle);
|
||
|
USB_DISK_STRUCT* pDiskCtrl = usbDisksPtr[devNo];
|
||
|
|
||
|
ARC_DEBUG_TRACE(ARC_DEBUG_FLAG_DISK_CAP,
|
||
|
"disk read_capacity: BMCBWFLAGS = 0x%02x\n", cbw_ptr->BMCBWFLAGS);
|
||
|
|
||
|
if (cbw_ptr->BMCBWFLAGS & USB_CBW_DIRECTION_BIT)
|
||
|
{
|
||
|
/* Send a zero-length packet */
|
||
|
_usb_device_send_data(handle, pDiskCtrl->inEpNo, (uint_8_ptr)pDiskCtrl->pReadCapacity, 8);
|
||
|
|
||
|
} /* Endif */
|
||
|
|
||
|
/* The actual length will never exceed the DCBWDATALENGTH */
|
||
|
pDiskCtrl->pCSW->DCSWDATARESIDUE = 0;
|
||
|
pDiskCtrl->pCSW->BCSWSTATUS = 0;
|
||
|
|
||
|
} /* EndBody */
|
||
|
|
||
|
/*FUNCTION*----------------------------------------------------------------
|
||
|
*
|
||
|
* Function Name : _process_read_command
|
||
|
* Returned Value : None
|
||
|
* Comments :
|
||
|
* Sends data as a response to READ Command.
|
||
|
*
|
||
|
*END*--------------------------------------------------------------------*/
|
||
|
void _process_read_command
|
||
|
(
|
||
|
/* [IN] Handle of the USB device */
|
||
|
_usb_device_handle handle,
|
||
|
|
||
|
/* [IN] Endpoint number */
|
||
|
uint_8 ep_num,
|
||
|
|
||
|
/* [IN] Pointer to the data buffer */
|
||
|
CBW_STRUCT_PTR cbw_ptr
|
||
|
)
|
||
|
{ /* Body */
|
||
|
uint_32 index1 = 0, index2 = 0;
|
||
|
uint_32 max_pkt_size, byteSize;
|
||
|
int devNo = _usb_device_get_dev_num(handle);
|
||
|
USB_DISK_STRUCT* pDiskCtrl = usbDisksPtr[devNo];
|
||
|
|
||
|
if (cbw_ptr->BMCBWFLAGS & USB_CBW_DIRECTION_BIT)
|
||
|
{
|
||
|
/* Send a zero-length packet */
|
||
|
index1 = ((uint_32)cbw_ptr->CBWCB[4] << 8);
|
||
|
index1 |= cbw_ptr->CBWCB[5];
|
||
|
index2 = ((uint_32)cbw_ptr->CBWCB[7] << 8);
|
||
|
index2 |= (uint_32)cbw_ptr->CBWCB[8];
|
||
|
|
||
|
ARC_DEBUG_TRACE(ARC_DEBUG_FLAG_DISK_READ,
|
||
|
"disk read: FLAGS=0x%02x, LENGTH=0x%x, index1=0x%x, index2=0x%x\n",
|
||
|
cbw_ptr->BMCBWFLAGS, cbw_ptr->DCBWDATALENGTH, index1, index2);
|
||
|
|
||
|
if(cbw_ptr->CBWCB[0] != 0x3E)
|
||
|
{
|
||
|
byteSize = index2 * LENGTH_OF_EACH_LAB;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
byteSize = index2;
|
||
|
index2 = (USB_MEM_ALIGN(byteSize, LENGTH_OF_EACH_LAB) / LENGTH_OF_EACH_LAB);
|
||
|
}
|
||
|
|
||
|
/* Check index validities */
|
||
|
if( (index1 + index2) >= pDiskCtrl->logicalBlocks)
|
||
|
{
|
||
|
USB_printf("USB disk read: invalid indexes - addr=%d, size=%d\n",
|
||
|
index1, index2);
|
||
|
pDiskCtrl->pCSW->DCSWDATARESIDUE = USB_32BIT_LE(cbw_ptr->DCBWDATALENGTH);
|
||
|
pDiskCtrl->pCSW->BCSWSTATUS = 1;
|
||
|
/* Send zero size packet */
|
||
|
_usb_device_send_data(handle, pDiskCtrl->inEpNo, (uint_8_ptr)NULL, 0);
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
if (cbw_ptr->DCBWDATALENGTH == 0)
|
||
|
{ /* Body */
|
||
|
pDiskCtrl->pCSW->DCSWDATARESIDUE = 0;
|
||
|
pDiskCtrl->pCSW->BCSWSTATUS = 2;
|
||
|
pDiskCtrl->CBW_PROCESSED = FALSE;
|
||
|
/* Send the command status information */
|
||
|
_usb_device_send_data(handle, pDiskCtrl->inEpNo, (uint_8_ptr)pDiskCtrl->pCSW, 13);
|
||
|
_usb_device_recv_data(handle, pDiskCtrl->outEpNo, pDiskCtrl->ep1_buf, 31);
|
||
|
return;
|
||
|
}
|
||
|
else
|
||
|
{ /* Body */
|
||
|
pDiskCtrl->pCSW->DCSWDATARESIDUE = 0;
|
||
|
pDiskCtrl->pCSW->BCSWSTATUS = 0;
|
||
|
if (byteSize > cbw_ptr->DCBWDATALENGTH)
|
||
|
{ /* Body */
|
||
|
byteSize = cbw_ptr->DCBWDATALENGTH;
|
||
|
pDiskCtrl->pCSW->DCSWDATARESIDUE = USB_32BIT_LE(cbw_ptr->DCBWDATALENGTH);
|
||
|
pDiskCtrl->pCSW->BCSWSTATUS = 2;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
if (byteSize < cbw_ptr->DCBWDATALENGTH)
|
||
|
{ /* Body */
|
||
|
pDiskCtrl->pCSW->DCSWDATARESIDUE = USB_32BIT_LE(cbw_ptr->DCBWDATALENGTH - index2);
|
||
|
if (byteSize > 0)
|
||
|
{ /* Body */
|
||
|
if (pDiskCtrl->speed == ARC_USB_SPEED_HIGH)
|
||
|
{
|
||
|
max_pkt_size = pDiskCtrl->hsMaxPktSize;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
max_pkt_size = pDiskCtrl->fsMaxPktSize;
|
||
|
}
|
||
|
|
||
|
if( (byteSize % max_pkt_size) == 0)
|
||
|
{ /* Body */
|
||
|
/* Need send a zero terminate packet to host */
|
||
|
pDiskCtrl->ZERO_TERMINATE = TRUE;
|
||
|
} /* Endbody */
|
||
|
} /* Endbody */
|
||
|
} /* Endbody */
|
||
|
}
|
||
|
|
||
|
_usb_device_send_data(handle, pDiskCtrl->inEpNo,
|
||
|
pDiskCtrl->MASS_STORAGE_DISK + (index1*LENGTH_OF_EACH_LAB), byteSize);
|
||
|
} /* Endbody */
|
||
|
}
|
||
|
else
|
||
|
{ /* Body */
|
||
|
USB_printf("disk read incorrect: FLAGS=0x%02x, LENGTH=0x%x\n",
|
||
|
cbw_ptr->BMCBWFLAGS, cbw_ptr->DCBWDATALENGTH);
|
||
|
|
||
|
/* Incorrect but valid CBW */
|
||
|
if (cbw_ptr->DCBWDATALENGTH > BUFFERSIZE)
|
||
|
byteSize = BUFFERSIZE;
|
||
|
else
|
||
|
byteSize = cbw_ptr->DCBWDATALENGTH;
|
||
|
|
||
|
pDiskCtrl->pCSW->DCSWDATARESIDUE = USB_32BIT_LE(cbw_ptr->DCBWDATALENGTH);
|
||
|
pDiskCtrl->pCSW->BCSWSTATUS = 2;
|
||
|
_usb_device_recv_data(handle, pDiskCtrl->outEpNo, pDiskCtrl->ep1_buf, index2);
|
||
|
} /* Endbody */
|
||
|
} /* EndBody */
|
||
|
|
||
|
/*FUNCTION*----------------------------------------------------------------
|
||
|
*
|
||
|
* Function Name : _process_write_command
|
||
|
* Returned Value : None
|
||
|
* Comments :
|
||
|
* Sends data as a response to WRITE Command.
|
||
|
*
|
||
|
*END*--------------------------------------------------------------------*/
|
||
|
void _process_write_command
|
||
|
(
|
||
|
/* [IN] Handle of the USB device */
|
||
|
_usb_device_handle handle,
|
||
|
|
||
|
/* [IN] Endpoint number */
|
||
|
uint_8 ep_num,
|
||
|
|
||
|
/* [IN] Pointer to the data buffer */
|
||
|
CBW_STRUCT_PTR cbw_ptr
|
||
|
)
|
||
|
{ /* Body */
|
||
|
uint_32 index1 = 0, index2 = 0;
|
||
|
uint_32 byteSize;
|
||
|
int devNo = _usb_device_get_dev_num(handle);
|
||
|
USB_DISK_STRUCT* pDiskCtrl = usbDisksPtr[devNo];
|
||
|
|
||
|
if (!(cbw_ptr->BMCBWFLAGS & USB_CBW_DIRECTION_BIT))
|
||
|
{
|
||
|
index1 = ((uint_32)cbw_ptr->CBWCB[4] << 8);
|
||
|
index1 |= cbw_ptr->CBWCB[5];
|
||
|
index2 = ((uint_32)cbw_ptr->CBWCB[7] << 8);
|
||
|
index2 |= (uint_32)cbw_ptr->CBWCB[8];
|
||
|
|
||
|
ARC_DEBUG_TRACE(ARC_DEBUG_FLAG_DISK_WRITE,
|
||
|
"disk write: FLAGS=0x%02x, LENGTH=0x%x, index1=0x%x, index2=0x%x\n",
|
||
|
cbw_ptr->BMCBWFLAGS, cbw_ptr->DCBWDATALENGTH, index1, index2);
|
||
|
|
||
|
if(cbw_ptr->CBWCB[0] != 0x3F)
|
||
|
{
|
||
|
byteSize = index2 * LENGTH_OF_EACH_LAB;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
byteSize = index2;
|
||
|
index2 = (USB_MEM_ALIGN(byteSize, LENGTH_OF_EACH_LAB) / LENGTH_OF_EACH_LAB);
|
||
|
}
|
||
|
|
||
|
/* Check index validities */
|
||
|
if( (index1 + index2) >= pDiskCtrl->logicalBlocks)
|
||
|
{
|
||
|
USB_printf("USB disk write: invalid indexes - addr=%d, size=%d\n",
|
||
|
index1, index2);
|
||
|
pDiskCtrl->pCSW->DCSWDATARESIDUE = 0;
|
||
|
pDiskCtrl->pCSW->BCSWSTATUS = 1;
|
||
|
pDiskCtrl->CBW_PROCESSED = FALSE;
|
||
|
/* Send the command status information */
|
||
|
_usb_device_send_data(handle, pDiskCtrl->inEpNo, (uint_8_ptr)pDiskCtrl->pCSW, 13);
|
||
|
_usb_device_recv_data(handle, pDiskCtrl->outEpNo, pDiskCtrl->ep1_buf, 31);
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
if (cbw_ptr->DCBWDATALENGTH == 0)
|
||
|
{ /* Body */
|
||
|
/* Zero transfer length */
|
||
|
pDiskCtrl->pCSW->DCSWDATARESIDUE = 0;
|
||
|
pDiskCtrl->pCSW->BCSWSTATUS = 2;
|
||
|
pDiskCtrl->CBW_PROCESSED = FALSE;
|
||
|
|
||
|
/* Send the command status information */
|
||
|
_usb_device_send_data(handle, pDiskCtrl->inEpNo, (uint_8_ptr)pDiskCtrl->pCSW, 13);
|
||
|
|
||
|
_usb_device_recv_data(handle, pDiskCtrl->outEpNo, pDiskCtrl->ep1_buf, 31);
|
||
|
return;
|
||
|
}
|
||
|
else
|
||
|
{ /* Body */
|
||
|
pDiskCtrl->pCSW->DCSWDATARESIDUE = 0;
|
||
|
pDiskCtrl->pCSW->BCSWSTATUS = 0;
|
||
|
|
||
|
if (byteSize < cbw_ptr->DCBWDATALENGTH)
|
||
|
{ /* Body */
|
||
|
/* The actual length will never exceed the DCBWDATALENGTH */
|
||
|
pDiskCtrl->pCSW->DCSWDATARESIDUE = USB_32BIT_LE(cbw_ptr->DCBWDATALENGTH - byteSize);
|
||
|
byteSize = cbw_ptr->DCBWDATALENGTH;
|
||
|
}
|
||
|
else if (byteSize > cbw_ptr->DCBWDATALENGTH)
|
||
|
{ /* Body */
|
||
|
pDiskCtrl->pCSW->DCSWDATARESIDUE = USB_32BIT_LE(cbw_ptr->DCBWDATALENGTH);
|
||
|
pDiskCtrl->pCSW->BCSWSTATUS = 2;
|
||
|
byteSize = cbw_ptr->DCBWDATALENGTH;
|
||
|
} /* Endbody */
|
||
|
|
||
|
if (_usb_device_get_transfer_status(handle, pDiskCtrl->outEpNo, ARC_USB_RECV) != USB_OK)
|
||
|
{
|
||
|
_usb_device_cancel_transfer(handle, ep_num, ARC_USB_RECV);
|
||
|
} /* Endif */
|
||
|
|
||
|
_usb_device_recv_data(handle, pDiskCtrl->outEpNo,
|
||
|
pDiskCtrl->MASS_STORAGE_DISK + (index1*LENGTH_OF_EACH_LAB), byteSize);
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{ /* Body */
|
||
|
USB_printf("disk write incorrect: FLAGS=0x%02x, LENGTH=0x%x\n",
|
||
|
cbw_ptr->BMCBWFLAGS, cbw_ptr->DCBWDATALENGTH);
|
||
|
|
||
|
/* Incorrect but valid CBW */
|
||
|
pDiskCtrl->pCSW->DCSWDATARESIDUE = USB_32BIT_LE(cbw_ptr->DCBWDATALENGTH);
|
||
|
pDiskCtrl->pCSW->BCSWSTATUS = 2;
|
||
|
_usb_device_send_data(handle, pDiskCtrl->inEpNo, 0, 0);
|
||
|
return;
|
||
|
} /* Endbody */
|
||
|
|
||
|
} /* EndBody */
|
||
|
|
||
|
/*FUNCTION*----------------------------------------------------------------
|
||
|
*
|
||
|
* Function Name : _process_test_unit_ready
|
||
|
* Returned Value : None
|
||
|
* Comments :
|
||
|
* Responds appropriately to unit ready query
|
||
|
*
|
||
|
*END*--------------------------------------------------------------------*/
|
||
|
void _process_test_unit_ready
|
||
|
(
|
||
|
/* [IN] Handle of the USB device */
|
||
|
_usb_device_handle handle,
|
||
|
|
||
|
/* [IN] Endpoint number */
|
||
|
uint_8 ep_num,
|
||
|
|
||
|
/* [IN] Pointer to the data buffer */
|
||
|
CBW_STRUCT_PTR cbw_ptr
|
||
|
)
|
||
|
{ /* Body */
|
||
|
uint_32 bufSize;
|
||
|
int devNo = _usb_device_get_dev_num(handle);
|
||
|
USB_DISK_STRUCT* pDiskCtrl = usbDisksPtr[devNo];
|
||
|
|
||
|
if ((cbw_ptr->BMCBWFLAGS & USB_CBW_DIRECTION_BIT) ||
|
||
|
(cbw_ptr->DCBWDATALENGTH == 0))
|
||
|
{
|
||
|
/* The actual length will never exceed the DCBWDATALENGTH */
|
||
|
pDiskCtrl->pCSW->DCSWDATARESIDUE = 0;
|
||
|
pDiskCtrl->pCSW->BCSWSTATUS = 0;
|
||
|
|
||
|
pDiskCtrl->CBW_PROCESSED = FALSE;
|
||
|
|
||
|
/* Send the command status information */
|
||
|
_usb_device_send_data(handle, pDiskCtrl->inEpNo, (uint_8_ptr)pDiskCtrl->pCSW, 13);
|
||
|
_usb_device_recv_data(handle, pDiskCtrl->outEpNo, pDiskCtrl->ep1_buf, 31);
|
||
|
}
|
||
|
else
|
||
|
{ /* Body */
|
||
|
/* Incorrect but valid CBW */
|
||
|
if (cbw_ptr->DCBWDATALENGTH > BUFFERSIZE)
|
||
|
bufSize = BUFFERSIZE;
|
||
|
else
|
||
|
bufSize = cbw_ptr->DCBWDATALENGTH;
|
||
|
|
||
|
pDiskCtrl->pCSW->DCSWDATARESIDUE = USB_32BIT_LE(cbw_ptr->DCBWDATALENGTH);
|
||
|
pDiskCtrl->pCSW->BCSWSTATUS = 1;
|
||
|
_usb_device_recv_data(handle, pDiskCtrl->outEpNo, pDiskCtrl->ep1_buf, bufSize);
|
||
|
} /* Endbody */
|
||
|
|
||
|
} /* EndBody */
|
||
|
|
||
|
/*FUNCTION*----------------------------------------------------------------
|
||
|
*
|
||
|
* Function Name : _process_prevent_allow_medium_removal
|
||
|
* Returned Value : None
|
||
|
* Comments :
|
||
|
* Responds appropriately to unit ready query
|
||
|
*
|
||
|
*END*--------------------------------------------------------------------*/
|
||
|
void _process_prevent_allow_medium_removal
|
||
|
(
|
||
|
/* [IN] Handle of the USB device */
|
||
|
_usb_device_handle handle,
|
||
|
|
||
|
/* [IN] Endpoint number */
|
||
|
uint_8 ep_num,
|
||
|
|
||
|
/* [IN] Pointer to the data buffer */
|
||
|
CBW_STRUCT_PTR cbw_ptr
|
||
|
)
|
||
|
{ /* Body */
|
||
|
int devNo = _usb_device_get_dev_num(handle);
|
||
|
USB_DISK_STRUCT* pDiskCtrl = usbDisksPtr[devNo];
|
||
|
|
||
|
/* The actual length will never exceed the DCBWDATALENGTH */
|
||
|
pDiskCtrl->pCSW->DCSWDATARESIDUE = 0;
|
||
|
pDiskCtrl->pCSW->BCSWSTATUS = 0;
|
||
|
|
||
|
pDiskCtrl->CBW_PROCESSED = FALSE;
|
||
|
|
||
|
/* Send the command status information */
|
||
|
_usb_device_send_data(handle, pDiskCtrl->inEpNo, (uint_8_ptr)pDiskCtrl->pCSW, 13);
|
||
|
_usb_device_recv_data(handle, pDiskCtrl->outEpNo, pDiskCtrl->ep1_buf, 31);
|
||
|
|
||
|
} /* EndBody */
|
||
|
|
||
|
/*FUNCTION*----------------------------------------------------------------
|
||
|
*
|
||
|
* Function Name : _process_mass_storage_command
|
||
|
* Returned Value : None
|
||
|
* Comments :
|
||
|
* Process a Mass storage class command
|
||
|
*
|
||
|
*END*--------------------------------------------------------------------*/
|
||
|
void _process_mass_storage_command
|
||
|
(
|
||
|
/* [IN] Handle of the USB device */
|
||
|
_usb_device_handle handle,
|
||
|
|
||
|
/* [IN] Endpoint number */
|
||
|
uint_8 ep_num,
|
||
|
|
||
|
/* [IN] Pointer to the data buffer */
|
||
|
CBW_STRUCT_PTR cbw_ptr
|
||
|
)
|
||
|
{ /* Body */
|
||
|
|
||
|
ARC_DEBUG_TRACE(ARC_DEBUG_FLAG_DISK,
|
||
|
"disk command: CBWCB[0]=0x%02x, FLAGS=0x%02x, LENGTH=0x%x\n",
|
||
|
cbw_ptr->CBWCB[0], cbw_ptr->BMCBWFLAGS, cbw_ptr->DCBWDATALENGTH);
|
||
|
|
||
|
switch (cbw_ptr->CBWCB[0])
|
||
|
{
|
||
|
case 0x00: /* Request the device to report if it is ready */
|
||
|
_process_test_unit_ready(handle, ep_num, cbw_ptr);
|
||
|
break;
|
||
|
|
||
|
case 0x12: /* Inquity command. Get device information */
|
||
|
_process_inquiry_command(handle, ep_num, cbw_ptr);
|
||
|
break;
|
||
|
|
||
|
case 0x1A:
|
||
|
_process_unsupported_command(handle, ep_num, cbw_ptr);
|
||
|
break;
|
||
|
|
||
|
case 0x1E: /* Prevent or allow the removal of media from a removable media device */
|
||
|
_process_prevent_allow_medium_removal(handle, ep_num, cbw_ptr);
|
||
|
break;
|
||
|
|
||
|
case 0x23: /* Read Format Capacities. Report current media capacity and
|
||
|
** formattable capacities supported by media
|
||
|
*/
|
||
|
/* We bahave like already installed medium. No need to send any data */
|
||
|
_process_unsupported_command(handle, ep_num, cbw_ptr);
|
||
|
break;
|
||
|
|
||
|
case 0x25: /* Report current media capacity */
|
||
|
_process_report_capacity(handle, ep_num, cbw_ptr);
|
||
|
break;
|
||
|
|
||
|
case 0x28: /* Read (10) Transfer binary data from media to the host */
|
||
|
case 0x3E:
|
||
|
_process_read_command(handle, ep_num, cbw_ptr);
|
||
|
break;
|
||
|
|
||
|
case 0x2A: /* Write (10) Transfer binary data from the host to the media */
|
||
|
case 0x3F:
|
||
|
_process_write_command(handle, ep_num, cbw_ptr);
|
||
|
break;
|
||
|
|
||
|
case 0x01: /* Position a head of the drive to zero track */
|
||
|
case 0x03: /* Transfer status sense data to the host */
|
||
|
case 0x04: /* Format unformatted media */
|
||
|
case 0x1B: /* Request a request a removable-media device to load or
|
||
|
** unload its media
|
||
|
*/
|
||
|
case 0x1D: /* Perform a hard reset and execute diagnostics */
|
||
|
case 0x2B: /* Seek the device to a specified address */
|
||
|
case 0x2E: /* Transfer binary data from the host to the media and
|
||
|
** verify data
|
||
|
*/
|
||
|
case 0x2F: /* Verify data on the media */
|
||
|
case 0x55: /* Allow the host to set parameters in a peripheral */
|
||
|
case 0x5A: /* Report parameters to the host */
|
||
|
case 0xA8: /* Read (12) Transfer binary data from the media to the host */
|
||
|
case 0xAA: /* Write (12) Transfer binary data from the host to the
|
||
|
** media
|
||
|
*/
|
||
|
default:
|
||
|
_process_unsupported_command(handle, ep_num, cbw_ptr);
|
||
|
break;
|
||
|
} /* Endswitch */
|
||
|
|
||
|
} /* EndBody */
|
||
|
|
||
|
/*FUNCTION*----------------------------------------------------------------
|
||
|
*
|
||
|
* Function Name : service_ep1
|
||
|
* Returned Value : None
|
||
|
* Comments :
|
||
|
* Called upon a completed endpoint 1 (USB 1.1 Chapter 9) transfer
|
||
|
*
|
||
|
*END*--------------------------------------------------------------------*/
|
||
|
static void service_ep1
|
||
|
(
|
||
|
/* [IN] Handle of the USB device */
|
||
|
_usb_device_handle handle,
|
||
|
|
||
|
/* [IN] Service type as registered */
|
||
|
uint_8 type,
|
||
|
|
||
|
/* [IN] Is it a setup packet? */
|
||
|
boolean setup,
|
||
|
|
||
|
/* [IN] Direction of the transfer. Is it transmit? */
|
||
|
uint_8 direction,
|
||
|
|
||
|
/* [IN] Pointer to the data buffer */
|
||
|
uint_8_ptr buffer,
|
||
|
|
||
|
/* [IN] Length of the transfer */
|
||
|
uint_32 length,
|
||
|
|
||
|
/* [IN] Error, if any */
|
||
|
uint_8 error
|
||
|
|
||
|
)
|
||
|
{ /* Body */
|
||
|
int devNo = _usb_device_get_dev_num(handle);
|
||
|
USB_DISK_STRUCT* pDiskCtrl = usbDisksPtr[devNo];
|
||
|
CBW_STRUCT_PTR cbw_ptr = (CBW_STRUCT_PTR)((pointer)buffer);
|
||
|
|
||
|
ARC_DEBUG_TRACE(ARC_DEBUG_FLAG_EP1,
|
||
|
"disk %s: ep=%d, dir=%s, pBuf=0x%x, length=%d, error=0x%x\n",
|
||
|
__FUNCTION__, type, (direction == ARC_USB_RECV) ? "RECV" : "SEND",
|
||
|
(unsigned)buffer, (int)length, error);
|
||
|
|
||
|
if ((!direction) && (!pDiskCtrl->CBW_PROCESSED) && (length == 31) &&
|
||
|
(cbw_ptr->DCBWSIGNATURE == USB_32BIT_LE(USB_DCBWSIGNATURE)))
|
||
|
{
|
||
|
/* A valid CBW was received */
|
||
|
pDiskCtrl->pCSW->DCSWSIGNATURE = USB_32BIT_LE(USB_DCSWSIGNATURE);
|
||
|
pDiskCtrl->pCSW->DCSWTAG = cbw_ptr->DCBWTAG;
|
||
|
pDiskCtrl->CBW_PROCESSED = TRUE;
|
||
|
|
||
|
/* Swap 32 bit fields if neccessary */
|
||
|
cbw_ptr->DCBWDATALENGTH = USB_32BIT_LE(cbw_ptr->DCBWDATALENGTH);
|
||
|
|
||
|
/* Process the command */
|
||
|
_process_mass_storage_command(handle, type, cbw_ptr);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
/* If a CBW was processed then send the status information and
|
||
|
** queue another cbw receive request, else just queue another CBW receive
|
||
|
** request if we received an invalid CBW
|
||
|
*/
|
||
|
if (pDiskCtrl->CBW_PROCESSED)
|
||
|
{
|
||
|
int i;
|
||
|
|
||
|
ARC_DEBUG_TRACE(ARC_DEBUG_FLAG_DISK_DATA,
|
||
|
"disk %s: ep=%d, dir=%s, pBuf=0x%x, length=%d, error=0x%x\n",
|
||
|
__FUNCTION__, type, (direction == ARC_USB_RECV) ? "RECV" : "SEND",
|
||
|
(unsigned)buffer, (int)length, error);
|
||
|
|
||
|
for(i=0; i<64; i++)
|
||
|
{
|
||
|
if( (i % 16) == 0)
|
||
|
{
|
||
|
ARC_DEBUG_TRACE(ARC_DEBUG_FLAG_DISK_DUMP, "\n0x%08x: ", &buffer[i]);
|
||
|
}
|
||
|
ARC_DEBUG_TRACE(ARC_DEBUG_FLAG_DISK_DUMP, "%02x ", buffer[i]);
|
||
|
if( (i % 3) == 0)
|
||
|
ARC_DEBUG_TRACE(ARC_DEBUG_FLAG_DISK_DUMP, " ");
|
||
|
}
|
||
|
|
||
|
if (pDiskCtrl->ZERO_TERMINATE)
|
||
|
{ /* Body */
|
||
|
pDiskCtrl->ZERO_TERMINATE = FALSE;
|
||
|
_usb_device_send_data(handle, pDiskCtrl->inEpNo, 0, 0);
|
||
|
}
|
||
|
else
|
||
|
{ /* Body */
|
||
|
pDiskCtrl->CBW_PROCESSED = FALSE;
|
||
|
|
||
|
/* Send the command status information */
|
||
|
_usb_device_send_data(handle, pDiskCtrl->inEpNo, (uint_8_ptr)pDiskCtrl->pCSW, 13);
|
||
|
_usb_device_recv_data(handle, pDiskCtrl->outEpNo, pDiskCtrl->ep1_buf, 31);
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
if (!direction)
|
||
|
{
|
||
|
USB_printf("usbDisk_%d, %s: Wrong direction = %d\n",
|
||
|
_usb_device_get_dev_num(handle), __FUNCTION__, direction);
|
||
|
_usb_device_stall_endpoint(handle, pDiskCtrl->outEpNo, ARC_USB_RECV);
|
||
|
_usb_device_stall_endpoint(handle, pDiskCtrl->inEpNo, ARC_USB_SEND);
|
||
|
|
||
|
/* Invalid CBW received. Queue another receive buffer */
|
||
|
_usb_device_recv_data(handle, pDiskCtrl->outEpNo, pDiskCtrl->ep1_buf, 31);
|
||
|
}
|
||
|
} /* Endif */
|
||
|
} /* Endif */
|
||
|
|
||
|
return;
|
||
|
} /* Endbody */
|
||
|
|
||
|
/*FUNCTION*----------------------------------------------------------------
|
||
|
*
|
||
|
* Function Name : service_speed
|
||
|
* Returned Value : None
|
||
|
* Comments :
|
||
|
* Called upon a speed detection event.
|
||
|
*
|
||
|
*END*--------------------------------------------------------------------*/
|
||
|
static void service_speed
|
||
|
(
|
||
|
/* [IN] Handle of the USB device */
|
||
|
_usb_device_handle handle,
|
||
|
|
||
|
/* [IN] request type as registered */
|
||
|
uint_8 type,
|
||
|
|
||
|
/* [IN] Unused */
|
||
|
boolean setup,
|
||
|
|
||
|
/* [IN] Unused */
|
||
|
uint_8 direction,
|
||
|
|
||
|
/* [IN] Unused */
|
||
|
uint_8_ptr buffer,
|
||
|
|
||
|
/* [IN] Unused */
|
||
|
uint_32 length,
|
||
|
|
||
|
/* [IN] Error, if any */
|
||
|
uint_8 error
|
||
|
|
||
|
)
|
||
|
{ /* EndBody */
|
||
|
int devNo = _usb_device_get_dev_num(handle);
|
||
|
USB_DISK_STRUCT* pDiskCtrl = usbDisksPtr[devNo];
|
||
|
|
||
|
ARC_DEBUG_TRACE(ARC_DEBUG_FLAG_SPEED, "disk %s: speed = %d\n", __FUNCTION__, (unsigned)length);
|
||
|
|
||
|
pDiskCtrl->speed = length;
|
||
|
return;
|
||
|
} /* EndBody */
|
||
|
|
||
|
/*FUNCTION*----------------------------------------------------------------
|
||
|
*
|
||
|
* Function Name : reset_ep0
|
||
|
* Returned Value : None
|
||
|
* Comments :
|
||
|
* Called upon a bus reset event. Initialises the control endpoint.
|
||
|
*
|
||
|
*END*--------------------------------------------------------------------*/
|
||
|
static void reset_ep0
|
||
|
(
|
||
|
/* [IN] Handle of the USB device */
|
||
|
_usb_device_handle handle,
|
||
|
|
||
|
/* [IN] request type as registered */
|
||
|
uint_8 type,
|
||
|
|
||
|
/* [IN] Unused */
|
||
|
boolean setup,
|
||
|
|
||
|
/* [IN] Unused */
|
||
|
uint_8 direction,
|
||
|
|
||
|
/* [IN] Unused */
|
||
|
uint_8_ptr buffer,
|
||
|
|
||
|
/* [IN] Unused */
|
||
|
uint_32 length,
|
||
|
|
||
|
/* [IN] Error, if any */
|
||
|
uint_8 error
|
||
|
|
||
|
)
|
||
|
{ /* Body */
|
||
|
int devNo = _usb_device_get_dev_num(handle);
|
||
|
USB_DISK_STRUCT* pDiskCtrl = usbDisksPtr[devNo];
|
||
|
|
||
|
ARC_DEBUG_TRACE(ARC_DEBUG_FLAG_RESET, "disk-%d %s: pDiskCtrl=%p, handle=%p\n",
|
||
|
devNo, __FUNCTION__, pDiskCtrl, handle);
|
||
|
|
||
|
/* on a reset always ensure all transfers are cancelled on control EP*/
|
||
|
_usb_device_cancel_transfer(handle, 0, ARC_USB_RECV);
|
||
|
_usb_device_cancel_transfer(handle, 0, ARC_USB_SEND);
|
||
|
|
||
|
_usb_device_start(handle);
|
||
|
/* Initialize the endpoint 0 in both directions */
|
||
|
_usb_device_init_endpoint(handle, 0, pDiskCtrl->DevDesc[DEV_DESC_MAX_PACKET_SIZE],
|
||
|
ARC_USB_RECV, ARC_USB_CONTROL_ENDPOINT, 0);
|
||
|
_usb_device_init_endpoint(handle, 0, pDiskCtrl->DevDesc[DEV_DESC_MAX_PACKET_SIZE],
|
||
|
ARC_USB_SEND, ARC_USB_CONTROL_ENDPOINT, 0);
|
||
|
|
||
|
|
||
|
if (pDiskCtrl->TEST_ENABLED)
|
||
|
{
|
||
|
int out_ep_count=0, in_ep_count=0;
|
||
|
|
||
|
while(_usb_device_get_transfer_status(handle, pDiskCtrl->outEpNo, ARC_USB_RECV) !=
|
||
|
ARC_USB_STATUS_IDLE)
|
||
|
{
|
||
|
out_ep_count++;
|
||
|
_usb_device_cancel_transfer(handle, pDiskCtrl->outEpNo, ARC_USB_RECV);
|
||
|
}
|
||
|
while(_usb_device_get_transfer_status(handle, pDiskCtrl->inEpNo, ARC_USB_SEND) !=
|
||
|
ARC_USB_STATUS_IDLE)
|
||
|
{
|
||
|
in_ep_count++;
|
||
|
_usb_device_cancel_transfer(handle, pDiskCtrl->inEpNo, ARC_USB_SEND);
|
||
|
}
|
||
|
ARC_DEBUG_TRACE(ARC_DEBUG_FLAG_RESET, "disk %s: out_ep_count=%d, in_ep_count=%d\n",
|
||
|
__FUNCTION__, out_ep_count, in_ep_count);
|
||
|
} /* Endif */
|
||
|
|
||
|
pDiskCtrl->TEST_ENABLED = FALSE;
|
||
|
|
||
|
return;
|
||
|
} /* EndBody */
|
||
|
|
||
|
/*FUNCTION*----------------------------------------------------------------
|
||
|
*
|
||
|
* Function Name : usbDiskLoad - main task
|
||
|
* Inputs:
|
||
|
* int diskSize - size of created disk in KBytes
|
||
|
* Returned Value : None
|
||
|
* Comments :
|
||
|
* First function called. Initialises the USB and registers Chapter 9
|
||
|
* callback functions.
|
||
|
*
|
||
|
*END*--------------------------------------------------------------------*/
|
||
|
_usb_device_handle usbDiskLoad(int devNo, int diskSize)
|
||
|
{ /* Body */
|
||
|
_usb_device_handle handle;
|
||
|
USB_DISK_STRUCT* pDiskCtrl;
|
||
|
uint_8_ptr Send_Buffer_aligned;
|
||
|
uint_8 error;
|
||
|
uint_32 send_data_buffer_size=0;
|
||
|
uint_8_ptr temp;
|
||
|
int lockKey, i, j;
|
||
|
static boolean isFirst = TRUE;
|
||
|
|
||
|
ARC_DEBUG_TRACE(ARC_DEBUG_FLAG_INIT, "%s: devNo=%d, diskSize=%d\n",
|
||
|
__FUNCTION__, devNo, diskSize);
|
||
|
|
||
|
if(devNo >= MAX_USB_DEVICES)
|
||
|
{
|
||
|
USB_printf("USB disk: devNo=%d too large\n", devNo);
|
||
|
return NULL;
|
||
|
}
|
||
|
|
||
|
/*lock interrupts */
|
||
|
lockKey = USB_lock();
|
||
|
|
||
|
if(isFirst)
|
||
|
{
|
||
|
for(i=0; i<MAX_USB_DEVICES; i++)
|
||
|
{
|
||
|
usbDisksPtr[i] = NULL;
|
||
|
}
|
||
|
/* Swap all USB_STRING_DESC */
|
||
|
for(i=0; i<(sizeof(USB_STRING_DESC)/sizeof(USB_STRING_DESC[0])); i++)
|
||
|
{
|
||
|
uint_16* usbStr = (uint_16*)(USB_STRING_DESC[i]);
|
||
|
uint_16 size = (usbStr[0]-0x300)/sizeof(uint_16);
|
||
|
|
||
|
for(j=0; j<size; j++)
|
||
|
{
|
||
|
usbStr[j] = USB_16BIT_LE(usbStr[j]);
|
||
|
}
|
||
|
}
|
||
|
isFirst = FALSE;
|
||
|
}
|
||
|
|
||
|
if(usbDisksPtr[devNo] != NULL)
|
||
|
{
|
||
|
USB_printf("USB disk: devNo=%d is busy\n", devNo);
|
||
|
USB_unlock(lockKey);
|
||
|
return NULL;
|
||
|
}
|
||
|
|
||
|
/* Allocate Disk control structure */
|
||
|
pDiskCtrl = USB_memalloc(sizeof(USB_DISK_STRUCT));
|
||
|
if(pDiskCtrl == NULL)
|
||
|
{
|
||
|
USB_printf("USB disk #%d: Can't allocate USB_DISK_STRUCT (%d bytes)\n",
|
||
|
devNo, sizeof(USB_DISK_STRUCT));
|
||
|
USB_unlock(lockKey);
|
||
|
return NULL;
|
||
|
}
|
||
|
USB_memzero(pDiskCtrl, sizeof(USB_DISK_STRUCT));
|
||
|
|
||
|
if(diskSize == 0)
|
||
|
pDiskCtrl->logicalBlocks = TOTAL_LOGICAL_ADDRESS_BLOCKS;
|
||
|
else
|
||
|
pDiskCtrl->logicalBlocks = (diskSize*1024)/LENGTH_OF_EACH_LAB;
|
||
|
|
||
|
if(pDiskCtrl->logicalBlocks < 16)
|
||
|
{
|
||
|
USB_printf("USB disk size (%d) is too small. Minimum is 8 Kbytes\n",
|
||
|
diskSize);
|
||
|
USB_unlock(lockKey);
|
||
|
return NULL;
|
||
|
}
|
||
|
|
||
|
pDiskCtrl->devNo = devNo;
|
||
|
pDiskCtrl->hsMaxPktSize = diskHsMaxPktSize;
|
||
|
pDiskCtrl->fsMaxPktSize = diskFsMaxPktSize;
|
||
|
|
||
|
pDiskCtrl->inEpType = diskInEpType;
|
||
|
pDiskCtrl->outEpType = diskOutEpType;
|
||
|
|
||
|
pDiskCtrl->inEpNo = diskInEpNo;
|
||
|
pDiskCtrl->outEpNo = diskOutEpNo;
|
||
|
|
||
|
/* Initialize the USB interface */
|
||
|
error = _usb_device_init(devNo, &handle);
|
||
|
if (error != USB_OK)
|
||
|
{
|
||
|
USB_unlock(lockKey);
|
||
|
USB_printf("\nUSB Initialization failed. Error: %x", error);
|
||
|
return NULL;
|
||
|
} /* Endif */
|
||
|
|
||
|
/* Self Power, Remote wakeup disable */
|
||
|
_usb_device_set_status(handle, ARC_USB_STATUS_DEVICE, (1 << DEVICE_SELF_POWERED));
|
||
|
|
||
|
error = _usb_device_register_service(handle, ARC_USB_SERVICE_EP0, service_ep0);
|
||
|
if (error != USB_OK)
|
||
|
{
|
||
|
USB_unlock(lockKey);
|
||
|
USB_printf("\nUSB Service Registration failed. Error: %x", error);
|
||
|
return NULL;
|
||
|
} /* Endif */
|
||
|
|
||
|
error = _usb_device_register_service(handle, ARC_USB_SERVICE_BUS_RESET, reset_ep0);
|
||
|
if (error != USB_OK)
|
||
|
{
|
||
|
USB_unlock(lockKey);
|
||
|
USB_printf("\nUSB Service Registration failed. Error: %x", error);
|
||
|
return NULL;
|
||
|
} /* Endif */
|
||
|
|
||
|
error = _usb_device_register_service(handle, ARC_USB_SERVICE_SPEED_DETECTION,
|
||
|
service_speed);
|
||
|
if (error != USB_OK)
|
||
|
{
|
||
|
USB_unlock(lockKey);
|
||
|
USB_printf("\nUSB Service Registration failed. Error: %x", error);
|
||
|
return NULL;
|
||
|
} /* Endif */
|
||
|
|
||
|
error = _usb_device_register_service(handle, pDiskCtrl->outEpNo, service_ep1);
|
||
|
if (error != USB_OK)
|
||
|
{
|
||
|
USB_unlock(lockKey);
|
||
|
USB_printf("\nUSB Service Registration failed. Error: %x", error);
|
||
|
return NULL;
|
||
|
} /* Endif */
|
||
|
|
||
|
if(pDiskCtrl->outEpNo != pDiskCtrl->inEpNo)
|
||
|
{
|
||
|
error = _usb_device_register_service(handle, pDiskCtrl->inEpNo, service_ep1);
|
||
|
if (error != USB_OK)
|
||
|
{
|
||
|
USB_unlock(lockKey);
|
||
|
USB_printf("\nUSB Service Registration failed. Error: %x", error);
|
||
|
return NULL;
|
||
|
} /* Endif */
|
||
|
}
|
||
|
|
||
|
/**************************************************************************
|
||
|
Best way to handle the Data cache is to allocate a large buffer that is
|
||
|
cache aligned and keep all data inside it. Flush the line of the cache
|
||
|
that you have changed. In this program, we have static data such as
|
||
|
descriptors which never changes. Such data can be kept in this buffer
|
||
|
and flushed only once. Note that you can reduce the size of this buffer
|
||
|
by aligning the addresses in a different way.
|
||
|
***************************************************************************/
|
||
|
send_data_buffer_size = (DEVICE_DESCRIPTOR_SIZE + PSP_CACHE_LINE_SIZE) +
|
||
|
(CONFIG_DESC_SIZE + PSP_CACHE_LINE_SIZE) +
|
||
|
(DEVICE_QUALIFIER_DESCRIPTOR_SIZE + PSP_CACHE_LINE_SIZE) +
|
||
|
(OTHER_SPEED_CONFIG_DESC_SIZE + PSP_CACHE_LINE_SIZE) +
|
||
|
(BUFFERSIZE + PSP_CACHE_LINE_SIZE) +
|
||
|
(EP_TEMP_BUFFERSIZE + PSP_CACHE_LINE_SIZE) +
|
||
|
(sizeof(DISK_READ_CAPACITY) + PSP_CACHE_LINE_SIZE) +
|
||
|
(sizeof(CSW_STRUCT) + PSP_CACHE_LINE_SIZE) +
|
||
|
(pDiskCtrl->logicalBlocks*LENGTH_OF_EACH_LAB + PSP_CACHE_LINE_SIZE);
|
||
|
|
||
|
pDiskCtrl->Send_Buffer_Unaligned = (uint_8_ptr) USB_memalloc(send_data_buffer_size);
|
||
|
if (pDiskCtrl->Send_Buffer_Unaligned == NULL)
|
||
|
{
|
||
|
USB_unlock(lockKey);
|
||
|
USB_printf("diskLoad: Buffer allocation of %d bytes is failed\n",
|
||
|
(unsigned)send_data_buffer_size);
|
||
|
return NULL;
|
||
|
}
|
||
|
|
||
|
Send_Buffer_aligned = (uint_8_ptr) USB_CACHE_ALIGN((uint_32)pDiskCtrl->Send_Buffer_Unaligned);
|
||
|
/* keep a temporary copy of the aligned address */
|
||
|
temp = Send_Buffer_aligned;
|
||
|
|
||
|
/**************************************************************************
|
||
|
Assign pointers to different buffers from it and copy data inside.
|
||
|
***************************************************************************/
|
||
|
pDiskCtrl->DevDesc = (uint_8_ptr) Send_Buffer_aligned;
|
||
|
USB_memcopy(DevDescData, pDiskCtrl->DevDesc, DEVICE_DESCRIPTOR_SIZE);
|
||
|
Send_Buffer_aligned += ((DEVICE_DESCRIPTOR_SIZE/PSP_CACHE_LINE_SIZE) + 1)* PSP_CACHE_LINE_SIZE;
|
||
|
|
||
|
pDiskCtrl->ConfigDesc = (uint_8_ptr) Send_Buffer_aligned;
|
||
|
USB_memcopy(ConfigDescData, pDiskCtrl->ConfigDesc, CONFIG_DESC_SIZE);
|
||
|
Send_Buffer_aligned += ((CONFIG_DESC_SIZE/PSP_CACHE_LINE_SIZE) + 1)* PSP_CACHE_LINE_SIZE;
|
||
|
|
||
|
pDiskCtrl->DevQualifierDesc = (uint_8_ptr) Send_Buffer_aligned;
|
||
|
USB_memcopy(DevQualifierDescData, pDiskCtrl->DevQualifierDesc, DEVICE_QUALIFIER_DESCRIPTOR_SIZE);
|
||
|
Send_Buffer_aligned += ((DEVICE_QUALIFIER_DESCRIPTOR_SIZE/PSP_CACHE_LINE_SIZE) + 1) * PSP_CACHE_LINE_SIZE;
|
||
|
|
||
|
pDiskCtrl->other_speed_config = (uint_8_ptr) Send_Buffer_aligned;
|
||
|
USB_memcopy(other_speed_config_data, pDiskCtrl->other_speed_config, OTHER_SPEED_CONFIG_DESC_SIZE);
|
||
|
Send_Buffer_aligned += ((OTHER_SPEED_CONFIG_DESC_SIZE/PSP_CACHE_LINE_SIZE) + 1)* PSP_CACHE_LINE_SIZE;
|
||
|
|
||
|
/*buffer to receive data from Bulk OUT */
|
||
|
pDiskCtrl->ep1_buf = (uint_8_ptr) Send_Buffer_aligned;
|
||
|
USB_memzero(pDiskCtrl->ep1_buf, BUFFERSIZE);
|
||
|
Send_Buffer_aligned += ((BUFFERSIZE/PSP_CACHE_LINE_SIZE) + 1)* PSP_CACHE_LINE_SIZE;
|
||
|
|
||
|
/*buffer for control endpoint to send data */
|
||
|
pDiskCtrl->epTemp_buf = (uint_8_ptr) Send_Buffer_aligned;
|
||
|
USB_memzero(pDiskCtrl->epTemp_buf, EP_TEMP_BUFFERSIZE);
|
||
|
|
||
|
Send_Buffer_aligned += ((EP_TEMP_BUFFERSIZE/PSP_CACHE_LINE_SIZE) + 1)* PSP_CACHE_LINE_SIZE;
|
||
|
|
||
|
/* Buffer for read Capacity message */
|
||
|
pDiskCtrl->pReadCapacity = (DISK_READ_CAPACITY*)Send_Buffer_aligned;
|
||
|
USB_memcopy((void*)&read_capacity, pDiskCtrl->pReadCapacity, sizeof(DISK_READ_CAPACITY));
|
||
|
|
||
|
/* Update read_capacity */
|
||
|
pDiskCtrl->pReadCapacity->LAST_LOGICAL_BLOCK_ADDRESS[2] =
|
||
|
USB_uint_16_high(pDiskCtrl->logicalBlocks-14);
|
||
|
pDiskCtrl->pReadCapacity->LAST_LOGICAL_BLOCK_ADDRESS[3] =
|
||
|
USB_uint_16_low(pDiskCtrl->logicalBlocks-14);
|
||
|
|
||
|
Send_Buffer_aligned += ((sizeof(DISK_READ_CAPACITY)/PSP_CACHE_LINE_SIZE) + 1) * PSP_CACHE_LINE_SIZE;
|
||
|
|
||
|
/* Buffer for CSW message */
|
||
|
pDiskCtrl->pCSW = (CSW_STRUCT*)Send_Buffer_aligned;
|
||
|
USB_memzero(pDiskCtrl->pCSW , sizeof(CSW_STRUCT));
|
||
|
|
||
|
Send_Buffer_aligned += ((sizeof(CSW_STRUCT)/PSP_CACHE_LINE_SIZE) + 1) * PSP_CACHE_LINE_SIZE;
|
||
|
|
||
|
/*buffer for storage disk */
|
||
|
pDiskCtrl->MASS_STORAGE_DISK = (uint_8_ptr)Send_Buffer_aligned;
|
||
|
|
||
|
USB_printf("usbDisk-%d: pDiskCtrl=%p, %d bytes allocated addr=0x%x\n",
|
||
|
devNo, pDiskCtrl, (unsigned)send_data_buffer_size,
|
||
|
(unsigned)pDiskCtrl->Send_Buffer_Unaligned);
|
||
|
USB_printf("usbDisk-%d: DevDesc=0x%x, ConfigDesc=0x%x, QualifierDesc=0x%x, otherSpeedDesc=0x%x\n",
|
||
|
devNo, (unsigned)pDiskCtrl->DevDesc, (unsigned)pDiskCtrl->ConfigDesc,
|
||
|
(unsigned)pDiskCtrl->DevQualifierDesc, (unsigned)pDiskCtrl->other_speed_config);
|
||
|
USB_printf("usbDisk-%d: ep1_buf=0x%x, epTemp_buf=0x%x, MASS_STORAGE_DISK=0x%x\n",
|
||
|
devNo, (unsigned)pDiskCtrl->ep1_buf, (unsigned)pDiskCtrl->epTemp_buf,
|
||
|
(unsigned)pDiskCtrl->MASS_STORAGE_DISK);
|
||
|
|
||
|
USB_memzero(pDiskCtrl->MASS_STORAGE_DISK, (pDiskCtrl->logicalBlocks*LENGTH_OF_EACH_LAB));
|
||
|
|
||
|
/* Format the "disk" */
|
||
|
USB_memcopy(BOOT_SECTOR_AREA, pDiskCtrl->MASS_STORAGE_DISK, 512);
|
||
|
|
||
|
/* Update BOOT Sector "Total Small sectors" field */
|
||
|
pDiskCtrl->MASS_STORAGE_DISK[19] = USB_uint_16_low(pDiskCtrl->logicalBlocks);
|
||
|
pDiskCtrl->MASS_STORAGE_DISK[20] = USB_uint_16_high(pDiskCtrl->logicalBlocks);
|
||
|
|
||
|
USB_memcopy((void *)FAT16_SPECIAL_BYTES, pDiskCtrl->MASS_STORAGE_DISK + 512, 3);
|
||
|
USB_memcopy((void *)FAT16_SPECIAL_BYTES, pDiskCtrl->MASS_STORAGE_DISK + 512*4, 3);
|
||
|
|
||
|
/**************************************************************************
|
||
|
Flush the cache to ensure main memory is updated.
|
||
|
***************************************************************************/
|
||
|
USB_dcache_flush(temp, send_data_buffer_size);
|
||
|
|
||
|
pDiskCtrl->usbDevHandle = handle;
|
||
|
usbDisksPtr[devNo] = pDiskCtrl;
|
||
|
|
||
|
USB_unlock(lockKey);
|
||
|
|
||
|
USB_printf("USB Disk is READY: diskSize=%d KBytes, blockSize=%d Bytes, numBlocks=%d\n",
|
||
|
diskSize, LENGTH_OF_EACH_LAB, pDiskCtrl->logicalBlocks);
|
||
|
|
||
|
return pDiskCtrl->usbDevHandle;
|
||
|
} /* Endbody */
|
||
|
|
||
|
void usbDiskUnload(_usb_device_handle handle)
|
||
|
{
|
||
|
int lockKey;
|
||
|
int devNo = _usb_device_get_dev_num(handle);
|
||
|
USB_DISK_STRUCT* pDiskCtrl = usbDisksPtr[devNo];
|
||
|
|
||
|
if(pDiskCtrl == NULL)
|
||
|
{
|
||
|
USB_printf("USB disk #%d: Disk is not loaded\n", pDiskCtrl->devNo);
|
||
|
return;
|
||
|
}
|
||
|
/*lock interrupts */
|
||
|
lockKey = USB_lock();
|
||
|
|
||
|
/* ensure all transfers are cancelled */
|
||
|
_usb_device_cancel_transfer(handle, pDiskCtrl->outEpNo, ARC_USB_RECV);
|
||
|
_usb_device_cancel_transfer(handle, pDiskCtrl->inEpNo, ARC_USB_SEND);
|
||
|
|
||
|
/* Stop Endpoints */
|
||
|
_usb_device_deinit_endpoint(handle, pDiskCtrl->outEpNo, ARC_USB_RECV);
|
||
|
_usb_device_deinit_endpoint(handle, pDiskCtrl->inEpNo, ARC_USB_SEND);
|
||
|
|
||
|
_usb_device_deinit_endpoint(handle, 0, ARC_USB_RECV);
|
||
|
_usb_device_deinit_endpoint(handle, 0, ARC_USB_SEND);
|
||
|
|
||
|
_usb_device_stop(handle);
|
||
|
|
||
|
/* Deregister all services */
|
||
|
_usb_device_unregister_service(handle, ARC_USB_SERVICE_EP0);
|
||
|
_usb_device_unregister_service(handle, ARC_USB_SERVICE_BUS_RESET);
|
||
|
_usb_device_unregister_service(handle, ARC_USB_SERVICE_SPEED_DETECTION);
|
||
|
_usb_device_unregister_service(handle, pDiskCtrl->outEpNo);
|
||
|
if(pDiskCtrl->outEpNo != pDiskCtrl->inEpNo)
|
||
|
{
|
||
|
_usb_device_unregister_service(handle, pDiskCtrl->inEpNo);
|
||
|
}
|
||
|
|
||
|
_usb_device_shutdown(handle);
|
||
|
|
||
|
/* Free memory allocated for Disk device */
|
||
|
if(pDiskCtrl->Send_Buffer_Unaligned != NULL)
|
||
|
{
|
||
|
USB_memfree(pDiskCtrl->Send_Buffer_Unaligned);
|
||
|
}
|
||
|
|
||
|
/* Free Control structure */
|
||
|
USB_memfree(pDiskCtrl);
|
||
|
usbDisksPtr[devNo] = NULL;
|
||
|
|
||
|
USB_unlock(lockKey);
|
||
|
}
|
||
|
|
||
|
/* EOF */
|
||
|
|