usb:gadget: USB Mass Storage Gadget
v2 cover usb:gadget: USB Mass Storage Gadget
From: Piotr Wilczek <[email protected]>
This patch series add support for the USB Mass Storage (UMS) New "ums" command provide access to on-device persistent memory.
The storage_common.c and f_mass_storage.c source files are ported from v2.6.36 Linux kernel
Changes in v2:
- removed commented code;
Lukasz Majewski (3):
usb:composite: USB Mass Storage - storage_common.c from Linux kernel usb:gadget: USB Mass Storage Gadget support
arm:trats: Use new ums command
Piotr Wilczek (1):
usb:composite: USB Mass Storage - f_mass_storage.c from Linux kernel
board/samsung/trats/trats.c | 63 + common/Makefile | 1 + common/cmd_usb_mass_storage.c | 86 ++ drivers/usb/gadget/f_mass_storage.c | 2793 +++++++++++++++++++++++++++++++++++ drivers/usb/gadget/g_dnl.c | 6 + drivers/usb/gadget/storage_common.c | 653 ++++++++ include/configs/trats.h | 5 + include/usb_mass_storage.h | 55 + 8 files changed, 3662 insertions(+) create mode 100644 common/cmd_usb_mass_storage.c create mode 100644 drivers/usb/gadget/f_mass_storage.c create mode 100644 drivers/usb/gadget/storage_common.c create mode 100644 include/usb_mass_storage.h
Signature · 1 line
1.7.9.5
[U-Boot] =?y?q?=5BPATCH=20RESEND=20v2=201/4=5D=20usb=3Acomposite=3A=20USB=20Mass=20Storage=20-=20storage=5Fcommon=2Ec=20from=20Linux=20kernel?=
From: Lukasz Majewski <[email protected]>
The storage_common.c source file from v2.6.36 Linux kernel.
commit d26a6aa08b9f12b44fb1ee65625e7480d3d5bb81
Author: Michal Nazarewicz <[email protected]> Date: Mon Nov 9 14:15:23 2009 +0100
USB: g_mass_storage: code cleaned up and comments updated
---
Changes in v2: None
drivers/usb/gadget/storage_common.c | 653 +++++++++++++++++++++++++++++++++++ 1 file changed, 653 insertions(+) create mode 100644 drivers/usb/gadget/storage_common.c
drivers/usb/gadget/storage_common.c new file +653 -0
@@ -0,0 +1,653 @@ +/* +* storage_common.c -- Common definitions for mass storage functionality +* +* Copyright (C) 2003-2008 Alan Stern +* Copyeight (C) 2009 Samsung Electronics +* Author: Michal Nazarewicz (m.nazarewicz at samsung.com) +* +* Ported to u-boot: +* Andrzej Pietrasiewicz <[email protected]> +* +* Code refactoring & cleanup: +* ??ukasz Majewski <[email protected]> +* +* This program 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 of the License, or +* (at your option) any later version. +* +* This program 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 this program; if not, write to the Free Software +* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +*/ + + +/* +* This file requires the following identifiers used in USB strings to +* be defined (each of type pointer to char): +* - fsg_string_manufacturer -- name of the manufacturer +* - fsg_string_product -- name of the product +* - fsg_string_serial -- product's serial +* - fsg_string_config -- name of the configuration +* - fsg_string_interface -- name of the interface +* The first four are only needed when FSG_DESCRIPTORS_DEVICE_STRINGS +* macro is defined prior to including this file. +*/ + +/* +* When FSG_NO_INTR_EP is defined fsg_fs_intr_in_desc and +* fsg_hs_intr_in_desc objects as well as +* FSG_FS_FUNCTION_PRE_EP_ENTRIES and FSG_HS_FUNCTION_PRE_EP_ENTRIES +* macros are not defined. +* +* When FSG_NO_DEVICE_STRINGS is defined FSG_STRING_MANUFACTURER, +* FSG_STRING_PRODUCT, FSG_STRING_SERIAL and FSG_STRING_CONFIG are not +* defined (as well as corresponding entries in string tables are +* missing) and FSG_STRING_INTERFACE has value of zero. +* +* When FSG_NO_OTG is defined fsg_otg_desc won't be defined. +*/ + +/* +* When FSG_BUFFHD_STATIC_BUFFER is defined when this file is included +* the fsg_buffhd structure's buf field will be an array of FSG_BUFLEN +* characters rather then a pointer to void. +*/ + + +/* #include <asm/unaligned.h> */ + + +/* +* Thanks to NetChip Technologies for donating this product ID. +* +* DO NOT REUSE THESE IDs with any other driver!! Ever!! +* Instead: allocate your own, using normal USB-IF procedures. +*/ +#define FSG_VENDOR_ID 0x0525/* NetChip */ +#define FSG_PRODUCT_ID 0xa4a5/* Linux-USB File-backed Storage Gadget */ + +/*-------------------------------------------------------------------------*/ + +#ifndef DEBUG +#undef VERBOSE_DEBUG +#undef DUMP_MSGS +#endif /* !DEBUG */ + +#ifdef VERBOSE_DEBUG +#define VLDBG LDBG +#else +#define VLDBG(lun, fmt, args...) do { } while (0) +#endif /* VERBOSE_DEBUG */ + +/* +#define LDBG(lun, fmt, args...) dev_dbg (&(lun)->dev, fmt, ## args) +#define LERROR(lun, fmt, args...) dev_err (&(lun)->dev, fmt, ## args) +#define LWARN(lun, fmt, args...) dev_warn(&(lun)->dev, fmt, ## args) +#define LINFO(lun, fmt, args...) dev_info(&(lun)->dev, fmt, ## args) +*/ + +#define LDBG(lun, fmt, args...) do { } while (0) +#define LERROR(lun, fmt, args...) do { } while (0) +#define LWARN(lun, fmt, args...) do { } while (0) +#define LINFO(lun, fmt, args...) do { } while (0) + +/* +* Keep those macros in sync with those in +* include/linux/usb/composite.h or else GCC will complain. If they +* are identical (the same names of arguments, white spaces in the +* same places) GCC will allow redefinition otherwise (even if some +* white space is removed or added) warning will be issued. +* +* Those macros are needed here because File Storage Gadget does not +* include the composite.h header. For composite gadgets those macros +* are redundant since composite.h is included any way. +* +* One could check whether those macros are already defined (which +* would indicate composite.h had been included) or not (which would +* indicate we were in FSG) but this is not done because a warning is +* desired if definitions here differ from the ones in composite.h. +* +* We want the definitions to match and be the same in File Storage +* Gadget as well as Mass Storage Function (and so composite gadgets +* using MSF). If someone changes them in composite.h it will produce +* a warning in this file when building MSF. +*/ + +#define DBG(d, fmt, args...) debug(fmt , ## args) +#define VDBG(d, fmt, args...) debug(fmt , ## args) +/* #define ERROR(d, fmt, args...) printf(fmt , ## args) */ +/* #define WARNING(d, fmt, args...) printf(fmt , ## args) */ +/* #define INFO(d, fmt, args...) printf(fmt , ## args) */ + +/* #define DBG(d, fmt, args...) do { } while (0) */ +/* #define VDBG(d, fmt, args...) do { } while (0) */ +#define ERROR(d, fmt, args...) do { } while (0) +#define WARNING(d, fmt, args...) do { } while (0) +#define INFO(d, fmt, args...) do { } while (0) + +#ifdef DUMP_MSGS + +/* dump_msg(fsg, const char * label, const u8 * buf, unsigned length); */ +# define dump_msg (fsg, label, buf, length) do { \ + if (length < 512) { \ + DBG(fsg, "%s, length %u:\n", label, length); \ + print_hex_dump(KERN_DEBUG, "", DUMP_PREFIX_OFFSET, \ + 16, 1, buf, length, 0); \ + } \ +} while (0) + +# define dump_cdb (fsg) do { } while (0) + +#else + +# define dump_msg (fsg,/* const char * */ label, \ +/* const u8 * */ buf,/* unsigned */ length) do { } while (0) + +# ifdef VERBOSE_DEBUG + +# define dump_cdb (fsg) \ + print_hex_dump(KERN_DEBUG, "SCSI CDB: ", DUMP_PREFIX_NONE, \ + 16, 1, (fsg)->cmnd, (fsg)->cmnd_size, 0) \ + +# else + +# define dump_cdb (fsg) do { } while (0) + +# endif /* VERBOSE_DEBUG */ + +#endif /* DUMP_MSGS */ + +/*-------------------------------------------------------------------------*/ + +/* SCSI device types */ +#define TYPE_DISK 0x00 +#define TYPE_CDROM 0x05 + +/* USB protocol value = the transport method */ +#define USB_PR_CBI 0x00/* Control/Bulk/Interrupt */ +#define USB_PR_CB 0x01/* Control/Bulk w/o interrupt */ +#define USB_PR_BULK 0x50/* Bulk-only */ + +/* USB subclass value = the protocol encapsulation */ +#define USB_SC_RBC 0x01/* Reduced Block Commands (flash) */ +#define USB_SC_8020 0x02/* SFF-8020i, MMC-2, ATAPI (CD-ROM) */ +#define USB_SC_QIC 0x03/* QIC-157 (tape) */ +#define USB_SC_UFI 0x04/* UFI (floppy) */ +#define USB_SC_8070 0x05/* SFF-8070i (removable) */ +#define USB_SC_SCSI 0x06/* Transparent SCSI */ + +/* Bulk-only data structures */ + +/* Command Block Wrapper */ +struct fsg_bulk_cb_wrap { +__le32 Signature;/* Contains 'USBC' */ +u32 Tag;/* Unique per command id */ +__le32 DataTransferLength;/* Size of the data */ +u8 Flags;/* Direction in bit 7 */ +u8 Lun;/* LUN (normally 0) */ +u8 Length;/* Of the CDB, <= MAX_COMMAND_SIZE */ +u8 CDB[16 ];/* Command Data Block */ +}; + +#define USB_BULK_CB_WRAP_LEN 31 +#define USB_BULK_CB_SIG 0x43425355/* Spells out USBC */ +#define USB_BULK_IN_FLAG 0x80 + +/* Command Status Wrapper */ +struct bulk_cs_wrap { +__le32 Signature;/* Should = 'USBS' */ +u32 Tag;/* Same as original command */ +__le32 Residue;/* Amount not transferred */ +u8 Status;/* See below */ +}; + +#define USB_BULK_CS_WRAP_LEN 13 +#define USB_BULK_CS_SIG 0x53425355/* Spells out 'USBS' */ +#define USB_STATUS_PASS 0 +#define USB_STATUS_FAIL 1 +#define USB_STATUS_PHASE_ERROR 2 + +/* Bulk-only class specific requests */ +#define USB_BULK_RESET_REQUEST 0xff +#define USB_BULK_GET_MAX_LUN_REQUEST 0xfe + +/* CBI Interrupt data structure */ +struct interrupt_data { +u8 bType; +u8 bValue; +}; + +#define CBI_INTERRUPT_DATA_LEN 2 + +/* CBI Accept Device-Specific Command request */ +#define USB_CBI_ADSC_REQUEST 0x00 + +/* Length of a SCSI Command Data Block */ +#define MAX_COMMAND_SIZE 16 + +/* SCSI commands that we recognize */ +#define SC_FORMAT_UNIT 0x04 +#define SC_INQUIRY 0x12 +#define SC_MODE_SELECT_6 0x15 +#define SC_MODE_SELECT_10 0x55 +#define SC_MODE_SENSE_6 0x1a +#define SC_MODE_SENSE_10 0x5a +#define SC_PREVENT_ALLOW_MEDIUM_REMOVAL 0x1e +#define SC_READ_6 0x08 +#define SC_READ_10 0x28 +#define SC_READ_12 0xa8 +#define SC_READ_CAPACITY 0x25 +#define SC_READ_FORMAT_CAPACITIES 0x23 +#define SC_READ_HEADER 0x44 +#define SC_READ_TOC 0x43 +#define SC_RELEASE 0x17 +#define SC_REQUEST_SENSE 0x03 +#define SC_RESERVE 0x16 +#define SC_SEND_DIAGNOSTIC 0x1d +#define SC_START_STOP_UNIT 0x1b +#define SC_SYNCHRONIZE_CACHE 0x35 +#define SC_TEST_UNIT_READY 0x00 +#define SC_VERIFY 0x2f +#define SC_WRITE_6 0x0a +#define SC_WRITE_10 0x2a +#define SC_WRITE_12 0xaa + +/* SCSI Sense Key/Additional Sense Code/ASC Qualifier values */ +#define SS_NO_SENSE 0 +#define SS_COMMUNICATION_FAILURE 0x040800 +#define SS_INVALID_COMMAND 0x052000 +#define SS_INVALID_FIELD_IN_CDB 0x052400 +#define SS_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE 0x052100 +#define SS_LOGICAL_UNIT_NOT_SUPPORTED 0x052500 +#define SS_MEDIUM_NOT_PRESENT 0x023a00 +#define SS_MEDIUM_REMOVAL_PREVENTED 0x055302 +#define SS_NOT_READY_TO_READY_TRANSITION 0x062800 +#define SS_RESET_OCCURRED 0x062900 +#define SS_SAVING_PARAMETERS_NOT_SUPPORTED 0x053900 +#define SS_UNRECOVERED_READ_ERROR 0x031100 +#define SS_WRITE_ERROR 0x030c02 +#define SS_WRITE_PROTECTED 0x072700 + +#define SK (x) ((u8) ((x) >> 16))/* Sense Key byte, etc. */ +#define ASC (x) ((u8) ((x) >> 8)) +#define ASCQ (x) ((u8) (x)) + +struct device_attribute {int i; }; +struct rw_semaphore {int i; }; +#define down_write (...) do { } while (0) +#define up_write (...) do { } while (0) +#define down_read (...) do { } while (0) +#define up_read (...) do { } while (0) +#define ETOOSMALL 525 + +#include <usb_mass_storage.h> +extern struct ums_board_info *ums_info; + +/*-------------------------------------------------------------------------*/ + +struct fsg_lun { +loff_t file_length; +loff_t num_sectors; + +unsigned int initially_ro:1 ; +unsigned int ro:1 ; +unsigned int removable:1 ; +unsigned int cdrom:1 ; +unsigned int prevent_medium_removal:1 ; +unsigned int registered:1 ; +unsigned int info_valid:1 ; +unsigned int nofua:1 ; + +u32 sense_data; +u32 sense_data_info; +u32 unit_attention_data; + +struct device dev; +}; + +#define fsg_lun_is_open (curlun) ((curlun)->filp != NULL) +#if 0 +static struct fsg_lun *fsg_lun_from_dev (struct device *dev) +{ + return container_of(dev, struct fsg_lun, dev); +} +#endif + +/* Big enough to hold our biggest descriptor */ +#define EP0_BUFSIZE 256 +#define DELAYED_STATUS (EP0_BUFSIZE + 999)/* An impossibly large value */ + +/* Number of buffers we will use. 2 is enough for double-buffering */ +#define FSG_NUM_BUFFERS 2 + +/* Default size of buffer length. */ +#define FSG_BUFLEN ((u32)16384) + +/* Maximal number of LUNs supported in mass storage function */ +#define FSG_MAX_LUNS 8 + +enum fsg_buffer_state { +BUF_STATE_EMPTY =0 , +BUF_STATE_FULL , +BUF_STATE_BUSY +}; + +struct fsg_buffhd { +#ifdef FSG_BUFFHD_STATIC_BUFFER +char buf[FSG_BUFLEN ]; +#else +void *buf; +#endif +enum fsg_buffer_state state; +struct fsg_buffhd *next; + +/* +* The NetChip 2280 is faster, and handles some protocol faults +* better, if we don't submit any short bulk-out read requests. +* So we will record the intended request length here. +*/ +unsigned int bulk_out_intended_length; + +struct usb_request *inreq; +int inreq_busy; +struct usb_request *outreq; +int outreq_busy; +}; + +enum fsg_state { +/* This one isn't used anywhere */ +FSG_STATE_COMMAND_PHASE =-10 , +FSG_STATE_DATA_PHASE , +FSG_STATE_STATUS_PHASE , + +FSG_STATE_IDLE =0 , +FSG_STATE_ABORT_BULK_OUT , +FSG_STATE_RESET , +FSG_STATE_INTERFACE_CHANGE , +FSG_STATE_CONFIG_CHANGE , +FSG_STATE_DISCONNECT , +FSG_STATE_EXIT , +FSG_STATE_TERMINATED +}; + +enum data_direction { +DATA_DIR_UNKNOWN =0 , +DATA_DIR_FROM_HOST , +DATA_DIR_TO_HOST , +DATA_DIR_NONE +}; + +/*-------------------------------------------------------------------------*/ + +static inline u32 get_unaligned_be24 (u8 *buf) +{ +return 0xffffff & (u32 )get_unaligned_be32 (buf -1 ); +} + +/*-------------------------------------------------------------------------*/ + +enum { +#ifndef FSG_NO_DEVICE_STRINGS +FSG_STRING_MANUFACTURER =1 , +FSG_STRING_PRODUCT , +FSG_STRING_SERIAL , +FSG_STRING_CONFIG , +#endif +FSG_STRING_INTERFACE +}; + +#ifndef FSG_NO_OTG +static struct usb_otg_descriptor +fsg_otg_desc = { + .bLength =sizeof fsg_otg_desc, + .bDescriptorType =USB_DT_OTG , + + .bmAttributes =USB_OTG_SRP , +}; +#endif + +/* There is only one interface. */ + +static struct usb_interface_descriptor +fsg_intf_desc = { + .bLength =sizeof fsg_intf_desc, + .bDescriptorType =USB_DT_INTERFACE , + + .bNumEndpoints =2 ,/* Adjusted during fsg_bind() */ + .bInterfaceClass =USB_CLASS_MASS_STORAGE , + .bInterfaceSubClass =USB_SC_SCSI ,/* Adjusted during fsg_bind() */ + .bInterfaceProtocol =USB_PR_BULK ,/* Adjusted during fsg_bind() */ + .iInterface =FSG_STRING_INTERFACE , +}; + +/* +* Three full-speed endpoint descriptors: bulk-in, bulk-out, and +* interrupt-in. +*/ + +static struct usb_endpoint_descriptor +fsg_fs_bulk_in_desc = { + .bLength =USB_DT_ENDPOINT_SIZE , + .bDescriptorType =USB_DT_ENDPOINT , + + .bEndpointAddress =USB_DIR_IN , + .bmAttributes =USB_ENDPOINT_XFER_BULK , +/* wMaxPacketSize set by autoconfiguration */ +}; + +static struct usb_endpoint_descriptor +fsg_fs_bulk_out_desc = { + .bLength =USB_DT_ENDPOINT_SIZE , + .bDescriptorType =USB_DT_ENDPOINT , + + .bEndpointAddress =USB_DIR_OUT , + .bmAttributes =USB_ENDPOINT_XFER_BULK , +/* wMaxPacketSize set by autoconfiguration */ +}; + +#ifndef FSG_NO_INTR_EP + +static struct usb_endpoint_descriptor +fsg_fs_intr_in_desc = { + .bLength =USB_DT_ENDPOINT_SIZE , + .bDescriptorType =USB_DT_ENDPOINT , + + .bEndpointAddress =USB_DIR_IN , + .bmAttributes =USB_ENDPOINT_XFER_INT , + .wMaxPacketSize =cpu_to_le16 (2 ), + .bInterval =32 ,/* frames -> 32 ms */ +}; + +#ifndef FSG_NO_OTG +# define FSG_FS_FUNCTION_PRE_EP_ENTRIES 2 +#else +# define FSG_FS_FUNCTION_PRE_EP_ENTRIES 1 +#endif + +#endif + +static struct usb_descriptor_header *fsg_fs_function[] = { +#ifndef FSG_NO_OTG + (struct usb_descriptor_header *) &fsg_otg_desc, +#endif + (struct usb_descriptor_header *) &fsg_intf_desc, + (struct usb_descriptor_header *) &fsg_fs_bulk_in_desc, + (struct usb_descriptor_header *) &fsg_fs_bulk_out_desc, +#ifndef FSG_NO_INTR_EP + (struct usb_descriptor_header *) &fsg_fs_intr_in_desc, +#endif +NULL , +}; + +/* +* USB 2.0 devices need to expose both high speed and full speed +* descriptors, unless they only run at full speed. +* +* That means alternate endpoint descriptors (bigger packets) +* and a "device qualifier" ... plus more construction options +* for the configuration descriptor. +*/ +static struct usb_endpoint_descriptor +fsg_hs_bulk_in_desc = { + .bLength =USB_DT_ENDPOINT_SIZE , + .bDescriptorType =USB_DT_ENDPOINT , + +/* bEndpointAddress copied from fs_bulk_in_desc during fsg_bind() */ + .bmAttributes =USB_ENDPOINT_XFER_BULK , + .wMaxPacketSize =cpu_to_le16 (512 ), +}; + +static struct usb_endpoint_descriptor +fsg_hs_bulk_out_desc = { + .bLength =USB_DT_ENDPOINT_SIZE , + .bDescriptorType =USB_DT_ENDPOINT , + +/* bEndpointAddress copied from fs_bulk_out_desc during fsg_bind() */ + .bmAttributes =USB_ENDPOINT_XFER_BULK , + .wMaxPacketSize =cpu_to_le16 (512 ), + .bInterval =1 ,/* NAK every 1 uframe */ +}; + +#ifndef FSG_NO_INTR_EP + +static struct usb_endpoint_descriptor +fsg_hs_intr_in_desc = { + .bLength =USB_DT_ENDPOINT_SIZE , + .bDescriptorType =USB_DT_ENDPOINT , + +/* bEndpointAddress copied from fs_intr_in_desc during fsg_bind() */ + .bmAttributes =USB_ENDPOINT_XFER_INT , + .wMaxPacketSize =cpu_to_le16 (2 ), + .bInterval =9 ,/* 2**(9-1) = 256 uframes -> 32 ms */ +}; + +#ifndef FSG_NO_OTG +# define FSG_HS_FUNCTION_PRE_EP_ENTRIES 2 +#else +# define FSG_HS_FUNCTION_PRE_EP_ENTRIES 1 +#endif + +#endif + +static struct usb_descriptor_header *fsg_hs_function[] = { +#ifndef FSG_NO_OTG + (struct usb_descriptor_header *) &fsg_otg_desc, +#endif + (struct usb_descriptor_header *) &fsg_intf_desc, + (struct usb_descriptor_header *) &fsg_hs_bulk_in_desc, + (struct usb_descriptor_header *) &fsg_hs_bulk_out_desc, +#ifndef FSG_NO_INTR_EP + (struct usb_descriptor_header *) &fsg_hs_intr_in_desc, +#endif +NULL , +}; + +/* Maxpacket and other transfer characteristics vary by speed. */ +static struct usb_endpoint_descriptor * +fsg_ep_desc (struct usb_gadget *g,struct usb_endpoint_descriptor *fs, +struct usb_endpoint_descriptor *hs) +{ +if (gadget_is_dualspeed (g) && g->speed ==USB_SPEED_HIGH ) +return hs; +return fs; +} + +/* Static strings, in UTF-8 (for simplicity we use only ASCII characters) */ +static struct usb_string fsg_strings[] = { +#ifndef FSG_NO_DEVICE_STRINGS + {FSG_STRING_MANUFACTURER, fsg_string_manufacturer}, + {FSG_STRING_PRODUCT, fsg_string_product}, + {FSG_STRING_SERIAL, fsg_string_serial}, + {FSG_STRING_CONFIG, fsg_string_config}, +#endif + {FSG_STRING_INTERFACE, fsg_string_interface}, + {} +}; + +static struct usb_gadget_strings fsg_stringtab = { + .language = 0x0409, /* en-us */ + .strings = fsg_strings, +}; + +/*-------------------------------------------------------------------------*/ + +/* + * If the next two routines are called while the gadget is registered, + * the caller must own fsg->filesem for writing. + */ + +static int fsg_lun_open(struct fsg_lun *curlun, const char *filename) +{ + int ro; + int rc = -EINVAL; + loff_t size; + loff_t num_sectors; + loff_t min_sectors; + + /* R/W if we can, R/O if we must */ + ro = curlun->initially_ro; + + ums_info->get_capacity(&(ums_info->ums_dev), &size); + if (size < 0) { + printf("unable to find file size: %s\n", filename); + rc = (int) size; + goto out; + } + num_sectors = size >> 9; /* File size in 512-byte blocks */ + min_sectors = 1; + if (num_sectors < min_sectors) { + printf("file too small: %s\n", filename); + rc = -ETOOSMALL; + goto out; + } + + curlun->ro = ro; + curlun->file_length = size; + curlun->num_sectors = num_sectors; + debug("open backing file: %s\n", filename); + rc = 0; + +out: + return rc; +} + +static void fsg_lun_close(struct fsg_lun *curlun) +{ +} + +/*-------------------------------------------------------------------------*/ + +/* + * Sync the file data, don't bother with the metadata. + * This code was copied from fs/buffer.c:sys_fdatasync(). + */ +static int fsg_lun_fsync_sub(struct fsg_lun *curlun) +{ + return 0; +} + +static void store_cdrom_address(u8 *dest, int msf, u32 addr) +{ + if (msf) { + /* Convert to Minutes-Seconds-Frames */ + addr >>= 2; /* Convert to 2048-byte frames */ + addr += 2*75; /* Lead-in occupies 2 seconds */ + dest[3] = addr % 75; /* Frames */ + addr /= 75; + dest[2] = addr % 60; /* Seconds */ + addr /= 60; + dest[1] = addr; /* Minutes */ + dest[0] = 0; /* Reserved */ + } else { + /* Absolute sector */ + put_unaligned_be32(addr, dest); + } +} + +/*-------------------------------------------------------------------------*/
Signature · 1 line
1.7.9.5
PATCH RESEND v2 2/4 usb:composite: USB Mass Storage - f_mass_storage.c from Linux kernel
In reply to y at samsung.comFrom: Piotr Wilczek <[email protected]>
The f_mass_storage.c source file from v2.6.36 Linux kernel.
commit 8876f5e7d3b2a320777dd4f6f5301d474c97a06c
Author: Michal Nazarewicz <[email protected]> Date: Mon Jun 21 13:57:09 2010 +0200
USB: gadget: f_mass_storage: added eject callback
---
Changes in v2:
- removed commented code;
drivers/usb/gadget/f_mass_storage.c | 2793 +++++++++++++++++++++++++++++++++++ 1 file changed, 2793 insertions(+) create mode 100644 drivers/usb/gadget/f_mass_storage.c
drivers/usb/gadget/f_mass_storage.c new file +2793 -0
@@ -0,0 +1,2793 @@ +/* +* f_mass_storage.c -- Mass Storage USB Composite Function +* +* Copyright (C) 2003-2008 Alan Stern +* Copyright (C) 2009 Samsung Electronics +* Author: Michal Nazarewicz <[email protected]> +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions +* are met: +* 1. Redistributions of source code must retain the above copyright +* notice, this list of conditions, and the following disclaimer, +* without modification. +* 2. Redistributions in binary form must reproduce the above copyright +* notice, this list of conditions and the following disclaimer in the +* documentation and/or other materials provided with the distribution. +* 3. The names of the above-listed copyright holders may not be used +* to endorse or promote products derived from this software without +* specific prior written permission. +* +* ALTERNATIVELY, this software may be distributed under the terms of the +* GNU General Public License ("GPL") as published by the Free Software +* Foundation, either version 2 of that License or (at your option) any +* later version. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS +* IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, +* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR +* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, +* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR +* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF +* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + + +/* +* The Mass Storage Function acts as a USB Mass Storage device, +* appearing to the host as a disk drive or as a CD-ROM drive. In +* addition to providing an example of a genuinely useful composite +* function for a USB device, it also illustrates a technique of +* double-buffering for increased throughput. +* +* Function supports multiple logical units (LUNs). Backing storage +* for each LUN is provided by a regular file or a block device. +* Access for each LUN can be limited to read-only. Moreover, the +* function can indicate that LUN is removable and/or CD-ROM. (The +* later implies read-only access.) +* +* MSF is configured by specifying a fsg_config structure. It has the +* following fields: +* +* nluns Number of LUNs function have (anywhere from 1 +* to FSG_MAX_LUNS which is 8). +* luns An array of LUN configuration values. This +* should be filled for each LUN that +* function will include (ie. for "nluns" +* LUNs). Each element of the array has +* the following fields: +* ->filename The path to the backing file for the LUN. +* Required if LUN is not marked as +* removable. +* ->ro Flag specifying access to the LUN shall be +* read-only. This is implied if CD-ROM +* emulation is enabled as well as when +* it was impossible to open "filename" +* in R/W mode. +* ->removable Flag specifying that LUN shall be indicated as +* being removable. +* ->cdrom Flag specifying that LUN shall be reported as +* being a CD-ROM. +* +* lun_name_format A printf-like format for names of the LUN +* devices. This determines how the +* directory in sysfs will be named. +* Unless you are using several MSFs in +* a single gadget (as opposed to single +* MSF in many configurations) you may +* leave it as NULL (in which case +* "lun%d" will be used). In the format +* you can use "%d" to index LUNs for +* MSF's with more than one LUN. (Beware +* that there is only one integer given +* as an argument for the format and +* specifying invalid format may cause +* unspecified behaviour.) +* thread_name Name of the kernel thread process used by the +* MSF. You can safely set it to NULL +* (in which case default "file-storage" +* will be used). +* +* vendor_name +* product_name +* release Information used as a reply to INQUIRY +* request. To use default set to NULL, +* NULL, 0xffff respectively. The first +* field should be 8 and the second 16 +* characters or less. +* +* can_stall Set to permit function to halt bulk endpoints. +* Disabled on some USB devices known not +* to work correctly. You should set it +* to true. +* +* If "removable" is not set for a LUN then a backing file must be +* specified. If it is set, then NULL filename means the LUN's medium +* is not loaded (an empty string as "filename" in the fsg_config +* structure causes error). The CD-ROM emulation includes a single +* data track and no audio tracks; hence there need be only one +* backing file per LUN. Note also that the CD-ROM block length is +* set to 512 rather than the more common value 2048. +* +* +* MSF includes support for module parameters. If gadget using it +* decides to use it, the following module parameters will be +* available: +* +* file=filename[,filename...] +* Names of the files or block devices used for +* backing storage. +* ro=b[,b...] Default false, boolean for read-only access. +* removable=b[,b...] +* Default true, boolean for removable media. +* cdrom=b[,b...] Default false, boolean for whether to emulate +* a CD-ROM drive. +* luns=N Default N = number of filenames, number of +* LUNs to support. +* stall Default determined according to the type of +* USB device controller (usually true), +* boolean to permit the driver to halt +* bulk endpoints. +* +* The module parameters may be prefixed with some string. You need +* to consult gadget's documentation or source to verify whether it is +* using those module parameters and if it does what are the prefixes +* (look for FSG_MODULE_PARAMETERS() macro usage, what's inside it is +* the prefix). +* +* +* Requirements are modest; only a bulk-in and a bulk-out endpoint are +* needed. The memory requirement amounts to two 16K buffers, size +* configurable by a parameter. Support is included for both +* full-speed and high-speed operation. +* +* Note that the driver is slightly non-portable in that it assumes a +* single memory/DMA buffer will be useable for bulk-in, bulk-out, and +* interrupt-in endpoints. With most device controllers this isn't an +* issue, but there may be some with hardware restrictions that prevent +* a buffer from being used by more than one endpoint. +* +* +* The pathnames of the backing files and the ro settings are +* available in the attribute files "file" and "ro" in the lun<n> (or +* to be more precise in a directory which name comes from +* "lun_name_format" option!) subdirectory of the gadget's sysfs +* directory. If the "removable" option is set, writing to these +* files will simulate ejecting/loading the medium (writing an empty +* line means eject) and adjusting a write-enable tab. Changes to the +* ro setting are not allowed when the medium is loaded or if CD-ROM +* emulation is being used. +* +* When a LUN receive an "eject" SCSI request (Start/Stop Unit), +* if the LUN is removable, the backing file is released to simulate +* ejection. +* +* +* This function is heavily based on "File-backed Storage Gadget" by +* Alan Stern which in turn is heavily based on "Gadget Zero" by David +* Brownell. The driver's SCSI command interface was based on the +* "Information technology - Small Computer System Interface - 2" +* document from X3T9.2 Project 375D, Revision 10L, 7-SEP-93, +* available at <http://www.t10.org/ftp/t10/drafts/s2/s2-r10l.pdf>. +* The single exception is opcode 0x23 (READ FORMAT CAPACITIES), which +* was based on the "Universal Serial Bus Mass Storage Class UFI +* Command Specification" document, Revision 1.0, December 14, 1998, +* available at +* <http://www.usb.org/developers/devclass_docs/usbmass-ufi10.pdf>. +*/ + + +/* +* Driver Design +* +* The MSF is fairly straightforward. There is a main kernel +* thread that handles most of the work. Interrupt routines field +* callbacks from the controller driver: bulk- and interrupt-request +* completion notifications, endpoint-0 events, and disconnect events. +* Completion events are passed to the main thread by wakeup calls. Many +* ep0 requests are handled at interrupt time, but SetInterface, +* SetConfiguration, and device reset requests are forwarded to the +* thread in the form of "exceptions" using SIGUSR1 signals (since they +* should interrupt any ongoing file I/O operations). +* +* The thread's main routine implements the standard command/data/status +* parts of a SCSI interaction. It and its subroutines are full of tests +* for pending signals/exceptions -- all this polling is necessary since +* the kernel has no setjmp/longjmp equivalents. (Maybe this is an +* indication that the driver really wants to be running in userspace.) +* An important point is that so long as the thread is alive it keeps an +* open reference to the backing file. This will prevent unmounting +* the backing file's underlying filesystem and could cause problems +* during system shutdown, for example. To prevent such problems, the +* thread catches INT, TERM, and KILL signals and converts them into +* an EXIT exception. +* +* In normal operation the main thread is started during the gadget's +* fsg_bind() callback and stopped during fsg_unbind(). But it can +* also exit when it receives a signal, and there's no point leaving +* the gadget running when the thread is dead. At of this moment, MSF +* provides no way to deregister the gadget when thread dies -- maybe +* a callback functions is needed. +* +* To provide maximum throughput, the driver uses a circular pipeline of +* buffer heads (struct fsg_buffhd). In principle the pipeline can be +* arbitrarily long; in practice the benefits don't justify having more +* than 2 stages (i.e., double buffering). But it helps to think of the +* pipeline as being a long one. Each buffer head contains a bulk-in and +* a bulk-out request pointer (since the buffer can be used for both +* output and input -- directions always are given from the host's +* point of view) as well as a pointer to the buffer and various state +* variables. +* +* Use of the pipeline follows a simple protocol. There is a variable +* (fsg->next_buffhd_to_fill) that points to the next buffer head to use. +* At any time that buffer head may still be in use from an earlier +* request, so each buffer head has a state variable indicating whether +* it is EMPTY, FULL, or BUSY. Typical use involves waiting for the +* buffer head to be EMPTY, filling the buffer either by file I/O or by +* USB I/O (during which the buffer head is BUSY), and marking the buffer +* head FULL when the I/O is complete. Then the buffer will be emptied +* (again possibly by USB I/O, during which it is marked BUSY) and +* finally marked EMPTY again (possibly by a completion routine). +* +* A module parameter tells the driver to avoid stalling the bulk +* endpoints wherever the transport specification allows. This is +* necessary for some UDCs like the SuperH, which cannot reliably clear a +* halt on a bulk endpoint. However, under certain circumstances the +* Bulk-only specification requires a stall. In such cases the driver +* will halt the endpoint and set a flag indicating that it should clear +* the halt in software during the next device reset. Hopefully this +* will permit everything to work correctly. Furthermore, although the +* specification allows the bulk-out endpoint to halt when the host sends +* too much data, implementing this would cause an unavoidable race. +* The driver will always use the "no-stall" approach for OUT transfers. +* +* One subtle point concerns sending status-stage responses for ep0 +* requests. Some of these requests, such as device reset, can involve +* interrupting an ongoing file I/O operation, which might take an +* arbitrarily long time. During that delay the host might give up on +* the original ep0 request and issue a new one. When that happens the +* driver should not notify the host about completion of the original +* request, as the host will no longer be waiting for it. So the driver +* assigns to each ep0 request a unique tag, and it keeps track of the +* tag value of the request associated with a long-running exception +* (device-reset, interface-change, or configuration-change). When the +* exception handler is finished, the status-stage response is submitted +* only if the current ep0 request tag is equal to the exception request +* tag. Thus only the most recently received ep0 request will get a +* status-stage response. +* +* Warning: This driver source file is too long. It ought to be split up +* into a header file plus about 3 separate .c files, to handle the details +* of the Gadget, USB Mass Storage, and SCSI protocols. +*/ + +/* #define VERBOSE_DEBUG */ +/* #define DUMP_MSGS */ + +#include <config.h> +#include <malloc.h> +#include <common.h> + +#include <linux/err.h> +#include <linux/usb/ch9.h> +#include <linux/usb/gadget.h> +#include <usb_mass_storage.h> + +#include <asm/unaligned.h> +#include <linux/usb/gadget.h> +#include <linux/usb/gadget.h> +#include <linux/usb/composite.h> +#include <usb/lin_gadget_compat.h> + +/*------------------------------------------------------------------------*/ + +#define FSG_DRIVER_DESC "Mass Storage Function" +#define FSG_DRIVER_VERSION "2012/06/5" + +static const char fsg_string_interface[] ="Mass Storage" ; + + +#define FSG_NO_INTR_EP 1 +#define FSG_NO_DEVICE_STRINGS 1 +#define FSG_NO_OTG 1 +#define FSG_NO_INTR_EP 1 + +#include "storage_common.c" + +/*-------------------------------------------------------------------------*/ + +#define GFP_ATOMIC ((gfp_t) 0) +#define PAGE_CACHE_SHIFT 12 +#define PAGE_CACHE_SIZE (1 << PAGE_CACHE_SHIFT) +#define kthread_create (...) __builtin_return_address(0) +#define wait_for_completion (...) do {} while (0) + +struct kref {int x; }; +struct completion {int x; }; + +inline void set_bit (int nr,volatile void *addr) +{ +int mask; +unsigned int *a = (unsigned int *) addr; + + a += nr >>5 ; + mask =1 << (nr &0x1f ); + *a |= mask; +} + +inline void clear_bit (int nr,volatile void *addr) +{ +int mask; +unsigned int *a = (unsigned int *) addr; + + a += nr >>5 ; + mask =1 << (nr &0x1f ); + *a &= ~mask; +} + +struct fsg_dev ; +struct fsg_common ; + +/* Data shared by all the FSG instances. */ +struct fsg_common { +struct usb_gadget *gadget; +struct fsg_dev *fsg, *new_fsg; + +struct usb_ep *ep0;/* Copy of gadget->ep0 */ +struct usb_request *ep0req;/* Copy of cdev->req */ +unsigned int ep0_req_tag; + +struct fsg_buffhd *next_buffhd_to_fill; +struct fsg_buffhd *next_buffhd_to_drain; +struct fsg_buffhd buffhds[FSG_NUM_BUFFERS ]; + +int cmnd_size; +u8 cmnd[MAX_COMMAND_SIZE ]; + +unsigned int nluns; +unsigned int lun; +struct fsg_lun luns[FSG_MAX_LUNS ]; + +unsigned int bulk_out_maxpacket; +enum fsg_state state;/* For exception handling */ +unsigned int exception_req_tag; + +enum data_direction data_dir; +u32 data_size; +u32 data_size_from_cmnd; +u32 tag; +u32 residue; +u32 usb_amount_left; + +unsigned int can_stall:1 ; +unsigned int free_storage_on_release:1 ; +unsigned int phase_error:1 ; +unsigned int short_packet_received:1 ; +unsigned int bad_lun_okay:1 ; +unsigned int running:1 ; + +int thread_wakeup_needed; +struct completion thread_notifier; +struct task_struct *thread_task; + +/* Callback functions. */ +const struct fsg_operations *ops; +/* Gadget's private data. */ +void *private_data; + +const char *vendor_name;/* 8 characters or less */ +const char *product_name;/* 16 characters or less */ +u16 release; + +/* Vendor (8 chars), product (16 chars), release (4 +* hexadecimal digits) and NUL byte */ +char inquiry_string[8 +16 +4 +1 ]; + +struct kref ref; +}; + +struct fsg_config { +unsigned nluns; +struct fsg_lun_config { +const char *filename; +char ro; +char removable; +char cdrom; +char nofua; + } luns[FSG_MAX_LUNS ]; + +/* Callback functions. */ +const struct fsg_operations *ops; +/* Gadget's private data. */ +void *private_data; + +const char *vendor_name;/* 8 characters or less */ +const char *product_name;/* 16 characters or less */ + +char can_stall; +}; + +struct fsg_dev { +struct usb_function function; +struct usb_gadget *gadget;/* Copy of cdev->gadget */ +struct fsg_common *common; + +u16 interface_number; + +unsigned int bulk_in_enabled:1 ; +unsigned int bulk_out_enabled:1 ; + +unsigned long atomic_bitflags; +#define IGNORE_BULK_OUT 0 + +struct usb_ep *bulk_in; +struct usb_ep *bulk_out; +}; + + +static inline int __fsg_is_set (struct fsg_common *common, +const char *func,unsigned line) +{ +if (common->fsg) +return 1 ; +ERROR (common,"common->fsg is NULL in %s at %u\n" , func, line); +WARN_ON (1 ); +return 0 ; +} + +#define fsg_is_set (common) likely(__fsg_is_set(common, __func__, __LINE__)) + + +static inline struct fsg_dev *fsg_from_func (struct usb_function *f) +{ + return container_of(f, struct fsg_dev, function); +} + + +typedef void (*fsg_routine_t )(struct fsg_dev *); + +static int exception_in_progress (struct fsg_common *common) +{ +return common->state >FSG_STATE_IDLE ; +} + +/* Make bulk-out requests be divisible by the maxpacket size */ +static void set_bulk_out_req_length (struct fsg_common *common, +struct fsg_buffhd *bh,unsigned int length) +{ +unsigned int rem; + + bh->bulk_out_intended_length = length; + rem = length % common->bulk_out_maxpacket; +if (rem >0 ) + length += common->bulk_out_maxpacket - rem; + bh->outreq->length = length; +} + +/*-------------------------------------------------------------------------*/ + +struct ums_board_info *ums_info; +struct fsg_common *the_fsg_common; + +static int fsg_set_halt (struct fsg_dev *fsg,struct usb_ep *ep) +{ +const char *name; + +if (ep == fsg->bulk_in) + name ="bulk-in" ; +else if (ep == fsg->bulk_out) + name ="bulk-out" ; +else + name = ep->name; +DBG (fsg,"%s set halt\n" , name); +return usb_ep_set_halt (ep); +} + +/*-------------------------------------------------------------------------*/ + +/* These routines may be called in process context or in_irq */ + +/* Caller must hold fsg->lock */ +static void wakeup_thread (struct fsg_common *common) +{ + common->thread_wakeup_needed =1 ; +} + +static void raise_exception (struct fsg_common *common,enum fsg_state new_state) +{ +/* Do nothing if a higher-priority exception is already in progress. +* If a lower-or-equal priority exception is in progress, preempt it +* and notify the main thread by sending it a signal. */ +if (common->state <= new_state) { + common->exception_req_tag = common->ep0_req_tag; + common->state = new_state; + common->thread_wakeup_needed =1 ; + } +} + +/*-------------------------------------------------------------------------*/ + +static int ep0_queue (struct fsg_common *common) +{ +int rc; + + rc =usb_ep_queue (common->ep0, common->ep0req,GFP_ATOMIC ); + common->ep0->driver_data = common; +if (rc !=0 && rc != -ESHUTDOWN ) { +/* We can't do much more than wait for a reset */ +WARNING (common,"error in submission: %s --> %d\n" , + common->ep0->name, rc); + } +return rc; +} + +/*-------------------------------------------------------------------------*/ + +/* Bulk and interrupt endpoint completion handlers. +* These always run in_irq. */ + +static void bulk_in_complete (struct usb_ep *ep,struct usb_request *req) +{ +struct fsg_common *common = ep->driver_data; +struct fsg_buffhd *bh = req->context; + +if (req->status || req->actual != req->length) +DBG (common,"%s --> %d, %u/%u\n" , __func__, + req->status, req->actual, req->length); +if (req->status == -ECONNRESET )/* Request was cancelled */ +usb_ep_fifo_flush (ep); + +/* Hold the lock while we update the request and buffer states */ + bh->inreq_busy =0 ; + bh->state =BUF_STATE_EMPTY ; +wakeup_thread (common); +} + +static void bulk_out_complete (struct usb_ep *ep,struct usb_request *req) +{ +struct fsg_common *common = ep->driver_data; +struct fsg_buffhd *bh = req->context; + +dump_msg (common,"bulk-out" , req->buf, req->actual); +if (req->status || req->actual != bh->bulk_out_intended_length) +DBG (common,"%s --> %d, %u/%u\n" , __func__, + req->status, req->actual, + bh->bulk_out_intended_length); +if (req->status == -ECONNRESET )/* Request was cancelled */ +usb_ep_fifo_flush (ep); + +/* Hold the lock while we update the request and buffer states */ + bh->outreq_busy =0 ; + bh->state =BUF_STATE_FULL ; +wakeup_thread (common); +} + +/*-------------------------------------------------------------------------*/ + +/* Ep0 class-specific handlers. These always run in_irq. */ + +static int fsg_setup (struct usb_function *f, +const struct usb_ctrlrequest *ctrl) +{ +struct fsg_dev *fsg =fsg_from_func (f); +struct usb_request *req = fsg->common->ep0req; +u16 w_index =le16_to_cpu (ctrl->wIndex); +u16 w_value =le16_to_cpu (ctrl->wValue); +u16 w_length =le16_to_cpu (ctrl->wLength); + +if (!fsg_is_set (fsg->common)) +return -EOPNOTSUPP ; + +switch (ctrl->bRequest) { + +case USB_BULK_RESET_REQUEST : +if (ctrl->bRequestType != + (USB_DIR_OUT |USB_TYPE_CLASS |USB_RECIP_INTERFACE )) +break ; +if (w_index != fsg->interface_number || w_value !=0 ) +return -EDOM ; + +/* Raise an exception to stop the current operation +* and reinitialize our state. */ +DBG (fsg,"bulk reset request\n" ); +raise_exception (fsg->common,FSG_STATE_RESET ); +return DELAYED_STATUS ; + +case USB_BULK_GET_MAX_LUN_REQUEST : +if (ctrl->bRequestType != + (USB_DIR_IN |USB_TYPE_CLASS |USB_RECIP_INTERFACE )) +break ; +if (w_index != fsg->interface_number || w_value !=0 ) +return -EDOM ; +VDBG (fsg,"get max LUN\n" ); + *(u8 *) req->buf = fsg->common->nluns -1 ; + +/* Respond with data/status */ + req->length =min ((u16 )1 , w_length); +return ep0_queue (fsg->common); + } + +VDBG (fsg, +"unknown class-specific control req " +"%02x.%02x v%04x i%04x l%u\n" , + ctrl->bRequestType, ctrl->bRequest, +le16_to_cpu (ctrl->wValue), w_index, w_length); +return -EOPNOTSUPP ; +} + +/*-------------------------------------------------------------------------*/ + +/* All the following routines run in process context */ + +/* Use this for bulk or interrupt transfers, not ep0 */ +static void start_transfer (struct fsg_dev *fsg,struct usb_ep *ep, +struct usb_request *req,int *pbusy, +enum fsg_buffer_state *state) +{ +int rc; + +if (ep == fsg->bulk_in) +dump_msg (fsg,"bulk-in" , req->buf, req->length); + + *pbusy =1 ; + *state =BUF_STATE_BUSY ; + rc =usb_ep_queue (ep, req,GFP_KERNEL ); +if (rc !=0 ) { + *pbusy =0 ; + *state =BUF_STATE_EMPTY ; + +/* We can't do much more than wait for a reset */ + +/* Note: currently the net2280 driver fails zero-length +* submissions if DMA is enabled. */ +if (rc != -ESHUTDOWN && !(rc == -EOPNOTSUPP && + req->length ==0 )) +WARNING (fsg,"error in submission: %s --> %d\n" , + ep->name, rc); + } +} + +#define START_TRANSFER_OR (common, ep_name, req, pbusy, state) \ + if (fsg_is_set(common)) \ + start_transfer((common)->fsg, (common)->fsg->ep_name, \ + req, pbusy, state); \ + else + +#define START_TRANSFER (common, ep_name, req, pbusy, state) \ + START_TRANSFER_OR(common, ep_name, req, pbusy, state) (void)0 + +static void busy_indicator (void ) +{ +static int state; + +switch (state) { +case 0 : +puts ("\r|" );break ; +case 1 : +puts ("\r/" );break ; +case 2 : +puts ("\r-" );break ; +case 3 : +puts ("\r\\" );break ; +case 4 : +puts ("\r|" );break ; +case 5 : +puts ("\r/" );break ; +case 6 : +puts ("\r-" );break ; +case 7 : +puts ("\r\\" );break ; +default : + state =0 ; + } +if (state++ ==8 ) + state =0 ; +} + +static int sleep_thread (struct fsg_common *common) +{ +int rc =0 ; +int i =0 , k =0 ; + +/* Wait until a signal arrives or we are woken up */ +for (;;) { +if (common->thread_wakeup_needed) +break ; + +if (++i ==50000 ) { +busy_indicator (); + i =0 ; + k++; + } + +usb_gadget_handle_interrupts (); + } + common->thread_wakeup_needed =0 ; +return rc; +} + +/*-------------------------------------------------------------------------*/ + +static int do_read (struct fsg_common *common) +{ +struct fsg_lun *curlun = &common->luns[common->lun]; +u32 lba; +struct fsg_buffhd *bh; +int rc; +u32 amount_left; +loff_t file_offset; +unsigned int amount; +unsigned int partial_page; +ssize_t nread; + +/* Get the starting Logical Block Address and check that it's +* not too big */ +if (common->cmnd[0 ] ==SC_READ_6 ) + lba =get_unaligned_be24 (&common->cmnd[1 ]); +else { + lba =get_unaligned_be32 (&common->cmnd[2 ]); + +/* We allow DPO (Disable Page Out = don't save data in the +* cache) and FUA (Force Unit Access = don't read from the +* cache), but we don't implement them. */ +if ((common->cmnd[1 ] & ~0x18 ) !=0 ) { + curlun->sense_data =SS_INVALID_FIELD_IN_CDB ; +return -EINVAL ; + } + } +if (lba >= curlun->num_sectors) { + curlun->sense_data =SS_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE ; +return -EINVAL ; + } + file_offset = ((loff_t ) lba) <<9 ; + +/* Carry out the file reads */ + amount_left = common->data_size_from_cmnd; +if (unlikely (amount_left ==0 )) +return -EIO ;/* No default reply */ + +for (;;) { + +/* Figure out how much we need to read: +* Try to read the remaining amount. +* But don't read more than the buffer size. +* And don't try to read past the end of the file. +* Finally, if we're not at a page boundary, don't read past +* the next page. +* If this means reading 0 then we were asked to read past +* the end of file. */ + amount =min (amount_left,FSG_BUFLEN ); + partial_page = file_offset & (PAGE_CACHE_SIZE -1 ); +if (partial_page >0 ) + amount =min (amount, (unsigned int )PAGE_CACHE_SIZE - + partial_page); + +/* Wait for the next buffer to become available */ + bh = common->next_buffhd_to_fill; +while (bh->state !=BUF_STATE_EMPTY ) { + rc =sleep_thread (common); +if (rc) +return rc; + } + +/* If we were asked to read past the end of file, +* end with an empty buffer. */ +if (amount ==0 ) { + curlun->sense_data = +SS_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE ; + curlun->info_valid =1 ; + bh->inreq->length =0 ; + bh->state =BUF_STATE_FULL ; +break ; + } + +/* Perform the read */ + nread =0 ; + rc = ums_info->read_sector (&(ums_info->ums_dev), + file_offset /SECTOR_SIZE , + amount /SECTOR_SIZE , + (char __user *)bh->buf); +if (rc) +return -EIO ; + nread = amount; + +VLDBG (curlun,"file read %u @ %llu -> %d\n" , amount, + (unsigned long long ) file_offset, + (int ) nread); + +if (nread <0 ) { +LDBG (curlun,"error in file read: %d\n" , + (int ) nread); + nread =0 ; + }else if (nread < amount) { +LDBG (curlun,"partial file read: %d/%u\n" , + (int ) nread, amount); + nread -= (nread &511 );/* Round down to a block */ + } + file_offset += nread; + amount_left -= nread; + common->residue -= nread; + bh->inreq->length = nread; + bh->state =BUF_STATE_FULL ; + +/* If an error occurred, report it and its position */ +if (nread < amount) { + curlun->sense_data =SS_UNRECOVERED_READ_ERROR ; + curlun->info_valid =1 ; +break ; + } + +if (amount_left ==0 ) +break ;/* No more left to read */ + +/* Send this buffer and go read some more */ + bh->inreq->zero =0 ; +START_TRANSFER_OR (common, bulk_in, bh->inreq, + &bh->inreq_busy, &bh->state) +/* Don't know what to do if +* common->fsg is NULL */ + return -EIO; + common->next_buffhd_to_fill = bh->next; + } + +return -EIO ;/* No default reply */ +} + +/*-------------------------------------------------------------------------*/ + +static int do_write (struct fsg_common *common) +{ +struct fsg_lun *curlun = &common->luns[common->lun]; +u32 lba; +struct fsg_buffhd *bh; +int get_some_more; +u32 amount_left_to_req, amount_left_to_write; +loff_t usb_offset, file_offset; +unsigned int amount; +unsigned int partial_page; +ssize_t nwritten; +int rc; + +if (curlun->ro) { + curlun->sense_data =SS_WRITE_PROTECTED ; +return -EINVAL ; + } + +/* Get the starting Logical Block Address and check that it's +* not too big */ +if (common->cmnd[0 ] ==SC_WRITE_6 ) + lba =get_unaligned_be24 (&common->cmnd[1 ]); +else { + lba =get_unaligned_be32 (&common->cmnd[2 ]); + +/* We allow DPO (Disable Page Out = don't save data in the +* cache) and FUA (Force Unit Access = write directly to the +* medium). We don't implement DPO; we implement FUA by +* performing synchronous output. */ +if (common->cmnd[1 ] & ~0x18 ) { + curlun->sense_data =SS_INVALID_FIELD_IN_CDB ; +return -EINVAL ; + } + } +if (lba >= curlun->num_sectors) { + curlun->sense_data =SS_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE ; +return -EINVAL ; + } + +/* Carry out the file writes */ + get_some_more =1 ; + file_offset = usb_offset = ((loff_t ) lba) <<9 ; + amount_left_to_req = common->data_size_from_cmnd; + amount_left_to_write = common->data_size_from_cmnd; + +while (amount_left_to_write >0 ) { + +/* Queue a request for more data from the host */ + bh = common->next_buffhd_to_fill; +if (bh->state ==BUF_STATE_EMPTY && get_some_more) { + +/* Figure out how much we want to get: +* Try to get the remaining amount. +* But don't get more than the buffer size. +* And don't try to go past the end of the file. +* If we're not at a page boundary, +* don't go past the next page. +* If this means getting 0, then we were asked +* to write past the end of file. +* Finally, round down to a block boundary. */ + amount =min (amount_left_to_req,FSG_BUFLEN ); + partial_page = usb_offset & (PAGE_CACHE_SIZE -1 ); +if (partial_page >0 ) + amount =min (amount, + (unsigned int )PAGE_CACHE_SIZE - partial_page); + +if (amount ==0 ) { + get_some_more =0 ; + curlun->sense_data = +SS_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE ; + curlun->info_valid =1 ; +continue ; + } + amount -= (amount &511 ); +if (amount ==0 ) { + +/* Why were we were asked to transfer a +* partial block? */ + get_some_more =0 ; +continue ; + } + +/* Get the next buffer */ + usb_offset += amount; + common->usb_amount_left -= amount; + amount_left_to_req -= amount; +if (amount_left_to_req ==0 ) + get_some_more =0 ; + +/* amount is always divisible by 512, hence by +* the bulk-out maxpacket size */ + bh->outreq->length = amount; + bh->bulk_out_intended_length = amount; + bh->outreq->short_not_ok =1 ; +START_TRANSFER_OR (common, bulk_out, bh->outreq, + &bh->outreq_busy, &bh->state) +/* Don't know what to do if +* common->fsg is NULL */ + return -EIO; + common->next_buffhd_to_fill = bh->next; +continue ; + } + +/* Write the received data to the backing file */ + bh = common->next_buffhd_to_drain; +if (bh->state ==BUF_STATE_EMPTY && !get_some_more) +break ;/* We stopped early */ +if (bh->state ==BUF_STATE_FULL ) { + common->next_buffhd_to_drain = bh->next; + bh->state =BUF_STATE_EMPTY ; + +/* Did something go wrong with the transfer? */ +if (bh->outreq->status !=0 ) { + curlun->sense_data =SS_COMMUNICATION_FAILURE ; + curlun->info_valid =1 ; +break ; + } + + amount = bh->outreq->actual; + +/* Perform the write */ + rc = ums_info->write_sector (&(ums_info->ums_dev), + file_offset /SECTOR_SIZE , + amount /SECTOR_SIZE , + (char __user *)bh->buf); +if (rc) +return -EIO ; + nwritten = amount; + +VLDBG (curlun,"file write %u @ %llu -> %d\n" , amount, + (unsigned long long ) file_offset, + (int ) nwritten); + +if (nwritten <0 ) { +LDBG (curlun,"error in file write: %d\n" , + (int ) nwritten); + nwritten =0 ; + }else if (nwritten < amount) { +LDBG (curlun,"partial file write: %d/%u\n" , + (int ) nwritten, amount); + nwritten -= (nwritten &511 ); +/* Round down to a block */ + } + file_offset += nwritten; + amount_left_to_write -= nwritten; + common->residue -= nwritten; + +/* If an error occurred, report it and its position */ +if (nwritten < amount) { + curlun->sense_data =SS_WRITE_ERROR ; + curlun->info_valid =1 ; +break ; + } + +/* Did the host decide to stop early? */ +if (bh->outreq->actual != bh->outreq->length) { + common->short_packet_received =1 ; +break ; + } +continue ; + } + +/* Wait for something to happen */ + rc =sleep_thread (common); +if (rc) +return rc; + } + +return -EIO ;/* No default reply */ +} + +/*-------------------------------------------------------------------------*/ + +static int do_synchronize_cache (struct fsg_common *common) +{ +return 0 ; +} + +/*-------------------------------------------------------------------------*/ + +static int do_verify (struct fsg_common *common) +{ +struct fsg_lun *curlun = &common->luns[common->lun]; +u32 lba; +u32 verification_length; +struct fsg_buffhd *bh = common->next_buffhd_to_fill; +loff_t file_offset; +u32 amount_left; +unsigned int amount; +ssize_t nread; +int rc; + +/* Get the starting Logical Block Address and check that it's +* not too big */ + lba =get_unaligned_be32 (&common->cmnd[2 ]); +if (lba >= curlun->num_sectors) { + curlun->sense_data =SS_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE ; +return -EINVAL ; + } + +/* We allow DPO (Disable Page Out = don't save data in the +* cache) but we don't implement it. */ +if (common->cmnd[1 ] & ~0x10 ) { + curlun->sense_data =SS_INVALID_FIELD_IN_CDB ; +return -EINVAL ; + } + + verification_length =get_unaligned_be16 (&common->cmnd[7 ]); +if (unlikely (verification_length ==0 )) +return -EIO ;/* No default reply */ + +/* Prepare to carry out the file verify */ + amount_left = verification_length <<9 ; + file_offset = ((loff_t ) lba) <<9 ; + +/* Write out all the dirty buffers before invalidating them */ + +/* Just try to read the requested blocks */ +while (amount_left >0 ) { + +/* Figure out how much we need to read: +* Try to read the remaining amount, but not more than +* the buffer size. +* And don't try to read past the end of the file. +* If this means reading 0 then we were asked to read +* past the end of file. */ + amount =min (amount_left,FSG_BUFLEN ); +if (amount ==0 ) { + curlun->sense_data = +SS_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE ; + curlun->info_valid =1 ; +break ; + } + +/* Perform the read */ + nread =0 ; + rc = ums_info->read_sector (&(ums_info->ums_dev), + file_offset /SECTOR_SIZE , + amount /SECTOR_SIZE , + (char __user *)bh->buf); +if (rc) +return -EIO ; + nread = amount; + +VLDBG (curlun,"file read %u @ %llu -> %d\n" , amount, + (unsigned long long ) file_offset, + (int ) nread); +if (nread <0 ) { +LDBG (curlun,"error in file verify: %d\n" , + (int ) nread); + nread =0 ; + }else if (nread < amount) { +LDBG (curlun,"partial file verify: %d/%u\n" , + (int ) nread, amount); + nread -= (nread &511 );/* Round down to a sector */ + } +if (nread ==0 ) { + curlun->sense_data =SS_UNRECOVERED_READ_ERROR ; + curlun->info_valid =1 ; +break ; + } + file_offset += nread; + amount_left -= nread; + } +return 0 ; +} + +/*-------------------------------------------------------------------------*/ + +static int do_inquiry (struct fsg_common *common,struct fsg_buffhd *bh) +{ +struct fsg_lun *curlun = &common->luns[common->lun]; +static const char vendor_id[] ="Linux " ; +u8 *buf = (u8 *) bh->buf; + +if (!curlun) {/* Unsupported LUNs are okay */ + common->bad_lun_okay =1 ; +memset (buf,0 ,36 ); + buf[0 ] =0x7f ;/* Unsupported, no device-type */ + buf[4 ] =31 ;/* Additional length */ +return 36 ; + } + +memset (buf,0 ,8 ); + buf[0 ] =TYPE_DISK ; + buf[2 ] =2 ;/* ANSI SCSI level 2 */ + buf[3 ] =2 ;/* SCSI-2 INQUIRY data format */ + buf[4 ] =31 ;/* Additional length */ +/* No special options */ +sprintf ((char *) (buf +8 ),"%-8s%-16s%04x" , (char *) vendor_id , + ums_info->name, (u16 )0xffff ); + +return 36 ; +} + + +static int do_request_sense (struct fsg_common *common,struct fsg_buffhd *bh) +{ +struct fsg_lun *curlun = &common->luns[common->lun]; +u8 *buf = (u8 *) bh->buf; +u32 sd, sdinfo; +int valid; + +/* +* From the SCSI-2 spec., section 7.9 (Unit attention condition): +* +* If a REQUEST SENSE command is received from an initiator +* with a pending unit attention condition (before the target +* generates the contingent allegiance condition), then the +* target shall either: +* a) report any pending sense data and preserve the unit +* attention condition on the logical unit, or, +* b) report the unit attention condition, may discard any +* pending sense data, and clear the unit attention +* condition on the logical unit for that initiator. +* +* FSG normally uses option a); enable this code to use option b). +*/ +#if 0 +if (curlun && curlun->unit_attention_data !=SS_NO_SENSE ) { + curlun->sense_data = curlun->unit_attention_data; + curlun->unit_attention_data =SS_NO_SENSE ; + } +#endif + +if (!curlun) {/* Unsupported LUNs are okay */ + common->bad_lun_okay =1 ; + sd =SS_LOGICAL_UNIT_NOT_SUPPORTED ; + sdinfo =0 ; + valid =0 ; + }else { + sd = curlun->sense_data; + valid = curlun->info_valid <<7 ; + curlun->sense_data =SS_NO_SENSE ; + curlun->info_valid =0 ; + } + +memset (buf,0 ,18 ); + buf[0 ] = valid |0x70 ;/* Valid, current error */ + buf[2 ] =SK (sd); +put_unaligned_be32 (sdinfo, &buf[3 ]);/* Sense information */ + buf[7 ] =18 -8 ;/* Additional sense length */ + buf[12 ] =ASC (sd); + buf[13 ] =ASCQ (sd); +return 18 ; +} + +static int do_read_capacity (struct fsg_common *common,struct fsg_buffhd *bh) +{ +struct fsg_lun *curlun = &common->luns[common->lun]; +u32 lba =get_unaligned_be32 (&common->cmnd[2 ]); +int pmi = common->cmnd[8 ]; +u8 *buf = (u8 *) bh->buf; + +/* Check the PMI and LBA fields */ +if (pmi >1 || (pmi ==0 && lba !=0 )) { + curlun->sense_data =SS_INVALID_FIELD_IN_CDB ; +return -EINVAL ; + } + +put_unaligned_be32 (curlun->num_sectors -1 , &buf[0 ]); +/* Max logical block */ +put_unaligned_be32 (512 , &buf[4 ]);/* Block length */ +return 8 ; +} + +static int do_read_header (struct fsg_common *common,struct fsg_buffhd *bh) +{ +struct fsg_lun *curlun = &common->luns[common->lun]; +int msf = common->cmnd[1 ] &0x02 ; +u32 lba =get_unaligned_be32 (&common->cmnd[2 ]); +u8 *buf = (u8 *) bh->buf; + +if (common->cmnd[1 ] & ~0x02 ) {/* Mask away MSF */ + curlun->sense_data =SS_INVALID_FIELD_IN_CDB ; +return -EINVAL ; + } +if (lba >= curlun->num_sectors) { + curlun->sense_data =SS_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE ; +return -EINVAL ; + } + +memset (buf,0 ,8 ); + buf[0 ] =0x01 ;/* 2048 bytes of user data, rest is EC */ +store_cdrom_address (&buf[4 ], msf, lba); +return 8 ; +} + + +static int do_read_toc (struct fsg_common *common,struct fsg_buffhd *bh) +{ +struct fsg_lun *curlun = &common->luns[common->lun]; +int msf = common->cmnd[1 ] &0x02 ; +int start_track = common->cmnd[6 ]; +u8 *buf = (u8 *) bh->buf; + +if ((common->cmnd[1 ] & ~0x02 ) !=0 ||/* Mask away MSF */ + start_track >1 ) { + curlun->sense_data =SS_INVALID_FIELD_IN_CDB ; +return -EINVAL ; + } + +memset (buf,0 ,20 ); + buf[1 ] = (20 -2 );/* TOC data length */ + buf[2 ] =1 ;/* First track number */ + buf[3 ] =1 ;/* Last track number */ + buf[5 ] =0x16 ;/* Data track, copying allowed */ + buf[6 ] =0x01 ;/* Only track is number 1 */ +store_cdrom_address (&buf[8 ], msf,0 ); + + buf[13 ] =0x16 ;/* Lead-out track is data */ + buf[14 ] =0xAA ;/* Lead-out track number */ +store_cdrom_address (&buf[16 ], msf, curlun->num_sectors); + +return 20 ; +} + +static int do_mode_sense (struct fsg_common *common,struct fsg_buffhd *bh) +{ +struct fsg_lun *curlun = &common->luns[common->lun]; +int mscmnd = common->cmnd[0 ]; +u8 *buf = (u8 *) bh->buf; +u8 *buf0 = buf; +int pc, page_code; +int changeable_values, all_pages; +int valid_page =0 ; +int len, limit; + +if ((common->cmnd[1 ] & ~0x08 ) !=0 ) {/* Mask away DBD */ + curlun->sense_data =SS_INVALID_FIELD_IN_CDB ; +return -EINVAL ; + } + pc = common->cmnd[2 ] >>6 ; + page_code = common->cmnd[2 ] &0x3f ; +if (pc ==3 ) { + curlun->sense_data =SS_SAVING_PARAMETERS_NOT_SUPPORTED ; +return -EINVAL ; + } + changeable_values = (pc ==1 ); + all_pages = (page_code ==0x3f ); + +/* Write the mode parameter header. Fixed values are: default +* medium type, no cache control (DPOFUA), and no block descriptors. +* The only variable value is the WriteProtect bit. We will fill in +* the mode data length later. */ +memset (buf,0 ,8 ); +if (mscmnd ==SC_MODE_SENSE_6 ) { + buf[2 ] = (curlun->ro ?0x80 :0x00 );/* WP, DPOFUA */ + buf +=4 ; + limit =255 ; + }else {/* SC_MODE_SENSE_10 */ + buf[3 ] = (curlun->ro ?0x80 :0x00 );/* WP, DPOFUA */ + buf +=8 ; + limit =65535 ;/* Should really be FSG_BUFLEN */ + } + +/* No block descriptors */ + +/* The mode pages, in numerical order. The only page we support +* is the Caching page. */ +if (page_code ==0x08 || all_pages) { + valid_page =1 ; + buf[0 ] =0x08 ;/* Page code */ + buf[1 ] =10 ;/* Page length */ +memset (buf+2 ,0 ,10 );/* None of the fields are changeable */ + +if (!changeable_values) { + buf[2 ] =0x04 ;/* Write cache enable, */ +/* Read cache not disabled */ +/* No cache retention priorities */ +put_unaligned_be16 (0xffff , &buf[4 ]); +/* Don't disable prefetch */ +/* Minimum prefetch = 0 */ +put_unaligned_be16 (0xffff , &buf[8 ]); +/* Maximum prefetch */ +put_unaligned_be16 (0xffff , &buf[10 ]); +/* Maximum prefetch ceiling */ + } + buf +=12 ; + } + +/* Check that a valid page was requested and the mode data length +* isn't too long. */ + len = buf - buf0; +if (!valid_page || len > limit) { + curlun->sense_data =SS_INVALID_FIELD_IN_CDB ; +return -EINVAL ; + } + +/* Store the mode data length */ +if (mscmnd ==SC_MODE_SENSE_6 ) + buf0[0 ] = len -1 ; +else +put_unaligned_be16 (len -2 , buf0); +return len; +} + + +static int do_start_stop (struct fsg_common *common) +{ +struct fsg_lun *curlun = &common->luns[common->lun]; + +if (!curlun) { +return -EINVAL ; + }else if (!curlun->removable) { + curlun->sense_data =SS_INVALID_COMMAND ; +return -EINVAL ; + } + +return 0 ; +} + +static int do_prevent_allow (struct fsg_common *common) +{ +struct fsg_lun *curlun = &common->luns[common->lun]; +int prevent; + +if (!curlun->removable) { + curlun->sense_data =SS_INVALID_COMMAND ; +return -EINVAL ; + } + + prevent = common->cmnd[4 ] &0x01 ; +if ((common->cmnd[4 ] & ~0x01 ) !=0 ) {/* Mask away Prevent */ + curlun->sense_data =SS_INVALID_FIELD_IN_CDB ; +return -EINVAL ; + } + +if (curlun->prevent_medium_removal && !prevent) +fsg_lun_fsync_sub (curlun); + curlun->prevent_medium_removal = prevent; +return 0 ; +} + + +static int do_read_format_capacities (struct fsg_common *common, +struct fsg_buffhd *bh) +{ +struct fsg_lun *curlun = &common->luns[common->lun]; +u8 *buf = (u8 *) bh->buf; + + buf[0 ] = buf[1 ] = buf[2 ] =0 ; + buf[3 ] =8 ;/* Only the Current/Maximum Capacity Descriptor */ + buf +=4 ; + +put_unaligned_be32 (curlun->num_sectors, &buf[0 ]); +/* Number of blocks */ +put_unaligned_be32 (512 , &buf[4 ]);/* Block length */ + buf[4 ] =0x02 ;/* Current capacity */ +return 12 ; +} + + +static int do_mode_select (struct fsg_common *common,struct fsg_buffhd *bh) +{ +struct fsg_lun *curlun = &common->luns[common->lun]; + +/* We don't support MODE SELECT */ +if (curlun) + curlun->sense_data =SS_INVALID_COMMAND ; +return -EINVAL ; +} + + +/*-------------------------------------------------------------------------*/ + +static int halt_bulk_in_endpoint (struct fsg_dev *fsg) +{ +int rc; + + rc =fsg_set_halt (fsg, fsg->bulk_in); +if (rc == -EAGAIN ) +VDBG (fsg,"delayed bulk-in endpoint halt\n" ); +while (rc !=0 ) { +if (rc != -EAGAIN ) { +WARNING (fsg,"usb_ep_set_halt -> %d\n" , rc); + rc =0 ; +break ; + } + + rc =usb_ep_set_halt (fsg->bulk_in); + } +return rc; +} + +static int wedge_bulk_in_endpoint (struct fsg_dev *fsg) +{ +int rc; + +DBG (fsg,"bulk-in set wedge\n" ); + rc =0 ;/* usb_ep_set_wedge(fsg->bulk_in); */ +if (rc == -EAGAIN ) +VDBG (fsg,"delayed bulk-in endpoint wedge\n" ); +while (rc !=0 ) { +if (rc != -EAGAIN ) { +WARNING (fsg,"usb_ep_set_wedge -> %d\n" , rc); + rc =0 ; +break ; + } + } +return rc; +} + +static int pad_with_zeros (struct fsg_dev *fsg) +{ +struct fsg_buffhd *bh = fsg->common->next_buffhd_to_fill; +u32 nkeep = bh->inreq->length; +u32 nsend; +int rc; + + bh->state =BUF_STATE_EMPTY ;/* For the first iteration */ + fsg->common->usb_amount_left = nkeep + fsg->common->residue; +while (fsg->common->usb_amount_left >0 ) { + +/* Wait for the next buffer to be free */ +while (bh->state !=BUF_STATE_EMPTY ) { + rc =sleep_thread (fsg->common); +if (rc) +return rc; + } + + nsend =min (fsg->common->usb_amount_left,FSG_BUFLEN ); +memset (bh->buf + nkeep,0 , nsend - nkeep); + bh->inreq->length = nsend; + bh->inreq->zero =0 ; +start_transfer (fsg, fsg->bulk_in, bh->inreq, + &bh->inreq_busy, &bh->state); + bh = fsg->common->next_buffhd_to_fill = bh->next; + fsg->common->usb_amount_left -= nsend; + nkeep =0 ; + } +return 0 ; +} + +static int throw_away_data (struct fsg_common *common) +{ +struct fsg_buffhd *bh; +u32 amount; +int rc; + +for (bh = common->next_buffhd_to_drain; + bh->state !=BUF_STATE_EMPTY || common->usb_amount_left >0 ; + bh = common->next_buffhd_to_drain) { + +/* Throw away the data in a filled buffer */ +if (bh->state ==BUF_STATE_FULL ) { + bh->state =BUF_STATE_EMPTY ; + common->next_buffhd_to_drain = bh->next; + +/* A short packet or an error ends everything */ +if (bh->outreq->actual != bh->outreq->length || + bh->outreq->status !=0 ) { +raise_exception (common, +FSG_STATE_ABORT_BULK_OUT ); +return -EINTR ; + } +continue ; + } + +/* Try to submit another request if we need one */ + bh = common->next_buffhd_to_fill; +if (bh->state ==BUF_STATE_EMPTY + && common->usb_amount_left >0 ) { + amount =min (common->usb_amount_left,FSG_BUFLEN ); + +/* amount is always divisible by 512, hence by +* the bulk-out maxpacket size */ + bh->outreq->length = amount; + bh->bulk_out_intended_length = amount; + bh->outreq->short_not_ok =1 ; +START_TRANSFER_OR (common, bulk_out, bh->outreq, + &bh->outreq_busy, &bh->state) +/* Don't know what to do if +* common->fsg is NULL */ + return -EIO; + common->next_buffhd_to_fill = bh->next; + common->usb_amount_left -= amount; +continue ; + } + +/* Otherwise wait for something to happen */ + rc =sleep_thread (common); +if (rc) +return rc; + } +return 0 ; +} + + +static int finish_reply (struct fsg_common *common) +{ +struct fsg_buffhd *bh = common->next_buffhd_to_fill; +int rc =0 ; + +switch (common->data_dir) { +case DATA_DIR_NONE : +break ;/* Nothing to send */ + +/* If we don't know whether the host wants to read or write, +* this must be CB or CBI with an unknown command. We mustn't +* try to send or receive any data. So stall both bulk pipes +* if we can and wait for a reset. */ +case DATA_DIR_UNKNOWN : +if (!common->can_stall) { +/* Nothing */ + }else if (fsg_is_set (common)) { +fsg_set_halt (common->fsg, common->fsg->bulk_out); + rc =halt_bulk_in_endpoint (common->fsg); + }else { +/* Don't know what to do if common->fsg is NULL */ + rc = -EIO ; + } +break ; + +/* All but the last buffer of data must have already been sent */ +case DATA_DIR_TO_HOST : +if (common->data_size ==0 ) { +/* Nothing to send */ + +/* If there's no residue, simply send the last buffer */ + }else if (common->residue ==0 ) { + bh->inreq->zero =0 ; +START_TRANSFER_OR (common, bulk_in, bh->inreq, + &bh->inreq_busy, &bh->state) + return -EIO; + common->next_buffhd_to_fill = bh->next; + +/* For Bulk-only, if we're allowed to stall then send the +* short packet and halt the bulk-in endpoint. If we can't +* stall, pad out the remaining data with 0's. */ + }else if (common->can_stall) { + bh->inreq->zero =1 ; +START_TRANSFER_OR (common, bulk_in, bh->inreq, + &bh->inreq_busy, &bh->state) +/* Don't know what to do if +* common->fsg is NULL */ + rc = -EIO; + common->next_buffhd_to_fill = bh->next; +if (common->fsg) + rc =halt_bulk_in_endpoint (common->fsg); + }else if (fsg_is_set (common)) { + rc =pad_with_zeros (common->fsg); + }else { +/* Don't know what to do if common->fsg is NULL */ + rc = -EIO ; + } +break ; + +/* We have processed all we want from the data the host has sent. +* There may still be outstanding bulk-out requests. */ +case DATA_DIR_FROM_HOST : +if (common->residue ==0 ) { +/* Nothing to receive */ + +/* Did the host stop sending unexpectedly early? */ + }else if (common->short_packet_received) { +raise_exception (common,FSG_STATE_ABORT_BULK_OUT ); + rc = -EINTR ; + +/* We haven't processed all the incoming data. Even though +* we may be allowed to stall, doing so would cause a race. +* The controller may already have ACK'ed all the remaining +* bulk-out packets, in which case the host wouldn't see a +* STALL. Not realizing the endpoint was halted, it wouldn't +* clear the halt -- leading to problems later on. */ +#if 0 + } else if (common->can_stall) { +if (fsg_is_set (common)) +fsg_set_halt (common->fsg, + common->fsg->bulk_out); +raise_exception (common,FSG_STATE_ABORT_BULK_OUT ); + rc = -EINTR ; +#endif + +/* We can't stall. Read in the excess data and throw it +* all away. */ + }else { + rc =throw_away_data (common); + } +break ; + } +return rc; +} + + +static int send_status (struct fsg_common *common) +{ +struct fsg_lun *curlun = &common->luns[common->lun]; +struct fsg_buffhd *bh; +struct bulk_cs_wrap *csw; +int rc; +u8 status =USB_STATUS_PASS ; +u32 sd, sdinfo =0 ; + +/* Wait for the next buffer to become available */ + bh = common->next_buffhd_to_fill; +while (bh->state !=BUF_STATE_EMPTY ) { + rc =sleep_thread (common); +if (rc) +return rc; + } + +if (curlun) + sd = curlun->sense_data; +else if (common->bad_lun_okay) + sd =SS_NO_SENSE ; +else + sd =SS_LOGICAL_UNIT_NOT_SUPPORTED ; + +if (common->phase_error) { +DBG (common,"sending phase-error status\n" ); + status =USB_STATUS_PHASE_ERROR ; + sd =SS_INVALID_COMMAND ; + }else if (sd !=SS_NO_SENSE ) { +DBG (common,"sending command-failure status\n" ); + status =USB_STATUS_FAIL ; +VDBG (common," sense data: SK x%02x, ASC x%02x, ASCQ x%02x;" +" info x%x\n" , +SK (sd),ASC (sd),ASCQ (sd), sdinfo); + } + +/* Store and send the Bulk-only CSW */ + csw = (void *)bh->buf; + + csw->Signature =cpu_to_le32 (USB_BULK_CS_SIG ); + csw->Tag = common->tag; + csw->Residue =cpu_to_le32 (common->residue); + csw->Status = status; + + bh->inreq->length =USB_BULK_CS_WRAP_LEN ; + bh->inreq->zero =0 ; +START_TRANSFER_OR (common, bulk_in, bh->inreq, + &bh->inreq_busy, &bh->state) +/* Don't know what to do if common->fsg is NULL */ + return -EIO; + + common->next_buffhd_to_fill = bh->next; +return 0 ; +} + + +/*-------------------------------------------------------------------------*/ + +/* Check whether the command is properly formed and whether its data size +* and direction agree with the values we already have. */ +static int check_command (struct fsg_common *common,int cmnd_size, +enum data_direction data_dir,unsigned int mask, +int needs_medium,const char *name) +{ +int i; +int lun = common->cmnd[1 ] >>5 ; +static const char dirletter[4 ] = {'u' ,'o' ,'i' ,'n' }; +char hdlen[20 ]; +struct fsg_lun *curlun; + + hdlen[0 ] =0 ; +if (common->data_dir !=DATA_DIR_UNKNOWN ) +sprintf (hdlen,", H%c=%u" , dirletter[(int ) common->data_dir], + common->data_size); +VDBG (common,"SCSI command: %s; Dc=%d, D%c=%u; Hc=%d%s\n" , + name, cmnd_size, dirletter[(int ) data_dir], + common->data_size_from_cmnd, common->cmnd_size, hdlen); + +/* We can't reply at all until we know the correct data direction +* and size. */ +if (common->data_size_from_cmnd ==0 ) + data_dir =DATA_DIR_NONE ; +if (common->data_size < common->data_size_from_cmnd) { +/* Host data size < Device data size is a phase error. +* Carry out the command, but only transfer as much as +* we are allowed. */ + common->data_size_from_cmnd = common->data_size; + common->phase_error =1 ; + } + common->residue = common->data_size; + common->usb_amount_left = common->data_size; + +/* Conflicting data directions is a phase error */ +if (common->data_dir != data_dir + && common->data_size_from_cmnd >0 ) { + common->phase_error =1 ; +return -EINVAL ; + } + +/* Verify the length of the command itself */ +if (cmnd_size != common->cmnd_size) { + +/* Special case workaround: There are plenty of buggy SCSI +* implementations. Many have issues with cbw->Length +* field passing a wrong command size. For those cases we +* always try to work around the problem by using the length +* sent by the host side provided it is at least as large +* as the correct command length. +* Examples of such cases would be MS-Windows, which issues +* REQUEST SENSE with cbw->Length == 12 where it should +* be 6, and xbox360 issuing INQUIRY, TEST UNIT READY and +* REQUEST SENSE with cbw->Length == 10 where it should +* be 6 as well. +*/ +if (cmnd_size <= common->cmnd_size) { +DBG (common,"%s is buggy! Expected length %d " +"but we got %d\n" , name, + cmnd_size, common->cmnd_size); + cmnd_size = common->cmnd_size; + }else { + common->phase_error =1 ; +return -EINVAL ; + } + } + +/* Check that the LUN values are consistent */ +if (common->lun != lun) +DBG (common,"using LUN %d from CBW, not LUN %d from CDB\n" , + common->lun, lun); + +/* Check the LUN */ +if (common->lun >=0 && common->lun < common->nluns) { + curlun = &common->luns[common->lun]; +if (common->cmnd[0 ] !=SC_REQUEST_SENSE ) { + curlun->sense_data =SS_NO_SENSE ; + curlun->info_valid =0 ; + } + }else { + curlun =NULL ; + common->bad_lun_okay =0 ; + +/* INQUIRY and REQUEST SENSE commands are explicitly allowed +* to use unsupported LUNs; all others may not. */ +if (common->cmnd[0 ] !=SC_INQUIRY && + common->cmnd[0 ] !=SC_REQUEST_SENSE ) { +DBG (common,"unsupported LUN %d\n" , common->lun); +return -EINVAL ; + } + } +#if 0 +/* If a unit attention condition exists, only INQUIRY and +* REQUEST SENSE commands are allowed; anything else must fail. */ +if (curlun && curlun->unit_attention_data !=SS_NO_SENSE && + common->cmnd[0 ] !=SC_INQUIRY && + common->cmnd[0 ] !=SC_REQUEST_SENSE ) { + curlun->sense_data = curlun->unit_attention_data; + curlun->unit_attention_data =SS_NO_SENSE ; +return -EINVAL ; + } +#endif +/* Check that only command bytes listed in the mask are non-zero */ + common->cmnd[1 ] &=0x1f ;/* Mask away the LUN */ +for (i =1 ; i < cmnd_size; ++i) { +if (common->cmnd[i] && !(mask & (1 << i))) { +if (curlun) + curlun->sense_data =SS_INVALID_FIELD_IN_CDB ; +return -EINVAL ; + } + } + +return 0 ; +} + + +static int do_scsi_command (struct fsg_common *common) +{ +struct fsg_buffhd *bh; +int rc; +int reply = -EINVAL ; +int i; +static char unknown[16 ]; +struct fsg_lun *curlun = &common->luns[common->lun]; + +dump_cdb (common); + +/* Wait for the next buffer to become available for data or status */ + bh = common->next_buffhd_to_fill; + common->next_buffhd_to_drain = bh; +while (bh->state !=BUF_STATE_EMPTY ) { + rc =sleep_thread (common); +if (rc) +return rc; + } + common->phase_error =0 ; + common->short_packet_received =0 ; + +down_read (&common->filesem);/* We're using the backing file */ +switch (common->cmnd[0 ]) { + +case SC_INQUIRY : + common->data_size_from_cmnd = common->cmnd[4 ]; + reply =check_command (common,6 ,DATA_DIR_TO_HOST , + (1 <<4 ),0 , +"INQUIRY" ); +if (reply ==0 ) + reply =do_inquiry (common, bh); +break ; + +case SC_MODE_SELECT_6 : + common->data_size_from_cmnd = common->cmnd[4 ]; + reply =check_command (common,6 ,DATA_DIR_FROM_HOST , + (1 <<1 ) | (1 <<4 ),0 , +"MODE SELECT(6)" ); +if (reply ==0 ) + reply =do_mode_select (common, bh); +break ; + +case SC_MODE_SELECT_10 : + common->data_size_from_cmnd = +get_unaligned_be16 (&common->cmnd[7 ]); + reply =check_command (common,10 ,DATA_DIR_FROM_HOST , + (1 <<1 ) | (3 <<7 ),0 , +"MODE SELECT(10)" ); +if (reply ==0 ) + reply =do_mode_select (common, bh); +break ; + +case SC_MODE_SENSE_6 : + common->data_size_from_cmnd = common->cmnd[4 ]; + reply =check_command (common,6 ,DATA_DIR_TO_HOST , + (1 <<1 ) | (1 <<2 ) | (1 <<4 ),0 , +"MODE SENSE(6)" ); +if (reply ==0 ) + reply =do_mode_sense (common, bh); +break ; + +case SC_MODE_SENSE_10 : + common->data_size_from_cmnd = +get_unaligned_be16 (&common->cmnd[7 ]); + reply =check_command (common,10 ,DATA_DIR_TO_HOST , + (1 <<1 ) | (1 <<2 ) | (3 <<7 ),0 , +"MODE SENSE(10)" ); +if (reply ==0 ) + reply =do_mode_sense (common, bh); +break ; + +case SC_PREVENT_ALLOW_MEDIUM_REMOVAL : + common->data_size_from_cmnd =0 ; + reply =check_command (common,6 ,DATA_DIR_NONE , + (1 <<4 ),0 , +"PREVENT-ALLOW MEDIUM REMOVAL" ); +if (reply ==0 ) + reply =do_prevent_allow (common); +break ; + +case SC_READ_6 : + i = common->cmnd[4 ]; + common->data_size_from_cmnd = (i ==0 ?256 : i) <<9 ; + reply =check_command (common,6 ,DATA_DIR_TO_HOST , + (7 <<1 ) | (1 <<4 ),1 , +"READ(6)" ); +if (reply ==0 ) + reply =do_read (common); +break ; + +case SC_READ_10 : + common->data_size_from_cmnd = +get_unaligned_be16 (&common->cmnd[7 ]) <<9 ; + reply =check_command (common,10 ,DATA_DIR_TO_HOST , + (1 <<1 ) | (0xf <<2 ) | (3 <<7 ),1 , +"READ(10)" ); +if (reply ==0 ) + reply =do_read (common); +break ; + +case SC_READ_12 : + common->data_size_from_cmnd = +get_unaligned_be32 (&common->cmnd[6 ]) <<9 ; + reply =check_command (common,12 ,DATA_DIR_TO_HOST , + (1 <<1 ) | (0xf <<2 ) | (0xf <<6 ),1 , +"READ(12)" ); +if (reply ==0 ) + reply =do_read (common); +break ; + +case SC_READ_CAPACITY : + common->data_size_from_cmnd =8 ; + reply =check_command (common,10 ,DATA_DIR_TO_HOST , + (0xf <<2 ) | (1 <<8 ),1 , +"READ CAPACITY" ); +if (reply ==0 ) + reply =do_read_capacity (common, bh); +break ; + +case SC_READ_HEADER : +if (!common->luns[common->lun].cdrom) + goto unknown_cmnd; + common->data_size_from_cmnd = +get_unaligned_be16 (&common->cmnd[7 ]); + reply =check_command (common,10 ,DATA_DIR_TO_HOST , + (3 <<7 ) | (0x1f <<1 ),1 , +"READ HEADER" ); +if (reply ==0 ) + reply =do_read_header (common, bh); +break ; + +case SC_READ_TOC : +if (!common->luns[common->lun].cdrom) + goto unknown_cmnd; + common->data_size_from_cmnd = +get_unaligned_be16 (&common->cmnd[7 ]); + reply =check_command (common,10 ,DATA_DIR_TO_HOST , + (7 <<6 ) | (1 <<1 ),1 , +"READ TOC" ); +if (reply ==0 ) + reply =do_read_toc (common, bh); +break ; + +case SC_READ_FORMAT_CAPACITIES : + common->data_size_from_cmnd = +get_unaligned_be16 (&common->cmnd[7 ]); + reply =check_command (common,10 ,DATA_DIR_TO_HOST , + (3 <<7 ),1 , +"READ FORMAT CAPACITIES" ); +if (reply ==0 ) + reply =do_read_format_capacities (common, bh); +break ; + +case SC_REQUEST_SENSE : + common->data_size_from_cmnd = common->cmnd[4 ]; + reply =check_command (common,6 ,DATA_DIR_TO_HOST , + (1 <<4 ),0 , +"REQUEST SENSE" ); +if (reply ==0 ) + reply =do_request_sense (common, bh); +break ; + +case SC_START_STOP_UNIT : + common->data_size_from_cmnd =0 ; + reply =check_command (common,6 ,DATA_DIR_NONE , + (1 <<1 ) | (1 <<4 ),0 , +"START-STOP UNIT" ); +if (reply ==0 ) + reply =do_start_stop (common); +break ; + +case SC_SYNCHRONIZE_CACHE : + common->data_size_from_cmnd =0 ; + reply =check_command (common,10 ,DATA_DIR_NONE , + (0xf <<2 ) | (3 <<7 ),1 , +"SYNCHRONIZE CACHE" ); +if (reply ==0 ) + reply =do_synchronize_cache (common); +break ; + +case SC_TEST_UNIT_READY : + common->data_size_from_cmnd =0 ; + reply =check_command (common,6 ,DATA_DIR_NONE , +0 ,1 , +"TEST UNIT READY" ); +break ; + +/* Although optional, this command is used by MS-Windows. We +* support a minimal version: BytChk must be 0. */ +case SC_VERIFY : + common->data_size_from_cmnd =0 ; + reply =check_command (common,10 ,DATA_DIR_NONE , + (1 <<1 ) | (0xf <<2 ) | (3 <<7 ),1 , +"VERIFY" ); +if (reply ==0 ) + reply =do_verify (common); +break ; + +case SC_WRITE_6 : + i = common->cmnd[4 ]; + common->data_size_from_cmnd = (i ==0 ?256 : i) <<9 ; + reply =check_command (common,6 ,DATA_DIR_FROM_HOST , + (7 <<1 ) | (1 <<4 ),1 , +"WRITE(6)" ); +if (reply ==0 ) + reply =do_write (common); +break ; + +case SC_WRITE_10 : + common->data_size_from_cmnd = +get_unaligned_be16 (&common->cmnd[7 ]) <<9 ; + reply =check_command (common,10 ,DATA_DIR_FROM_HOST , + (1 <<1 ) | (0xf <<2 ) | (3 <<7 ),1 , +"WRITE(10)" ); +if (reply ==0 ) + reply =do_write (common); +break ; + +case SC_WRITE_12 : + common->data_size_from_cmnd = +get_unaligned_be32 (&common->cmnd[6 ]) <<9 ; + reply =check_command (common,12 ,DATA_DIR_FROM_HOST , + (1 <<1 ) | (0xf <<2 ) | (0xf <<6 ),1 , +"WRITE(12)" ); +if (reply ==0 ) + reply =do_write (common); +break ; + +/* Some mandatory commands that we recognize but don't implement. +* They don't mean much in this setting. It's left as an exercise +* for anyone interested to implement RESERVE and RELEASE in terms +* of Posix locks. */ +case SC_FORMAT_UNIT : +case SC_RELEASE : +case SC_RESERVE : +case SC_SEND_DIAGNOSTIC : +/* Fall through */ + +default : +unknown_cmnd: + common->data_size_from_cmnd =0 ; +sprintf (unknown,"Unknown x%02x" , common->cmnd[0 ]); + reply =check_command (common, common->cmnd_size, +DATA_DIR_UNKNOWN ,0xff ,0 , unknown); +if (reply ==0 ) { + curlun->sense_data =SS_INVALID_COMMAND ; + reply = -EINVAL ; + } +break ; + } +up_read (&common->filesem); + +if (reply == -EINTR ) +return -EINTR ; + +/* Set up the single reply buffer for finish_reply() */ +if (reply == -EINVAL ) + reply =0 ;/* Error reply length */ +if (reply >=0 && common->data_dir ==DATA_DIR_TO_HOST ) { + reply =min ((u32 ) reply, common->data_size_from_cmnd); + bh->inreq->length = reply; + bh->state =BUF_STATE_FULL ; + common->residue -= reply; + }/* Otherwise it's already set */ + +return 0 ; +} + +/*-------------------------------------------------------------------------*/ + +static int received_cbw (struct fsg_dev *fsg,struct fsg_buffhd *bh) +{ +struct usb_request *req = bh->outreq; +struct fsg_bulk_cb_wrap *cbw = req->buf; +struct fsg_common *common = fsg->common; + +/* Was this a real packet? Should it be ignored? */ +if (req->status ||test_bit (IGNORE_BULK_OUT , &fsg->atomic_bitflags)) +return -EINVAL ; + +/* Is the CBW valid? */ +if (req->actual !=USB_BULK_CB_WRAP_LEN || + cbw->Signature !=cpu_to_le32 ( +USB_BULK_CB_SIG )) { +DBG (fsg,"invalid CBW: len %u sig 0x%x\n" , + req->actual, +le32_to_cpu (cbw->Signature)); + +/* The Bulk-only spec says we MUST stall the IN endpoint +* (6.6.1), so it's unavoidable. It also says we must +* retain this state until the next reset, but there's +* no way to tell the controller driver it should ignore +* Clear-Feature(HALT) requests. +* +* We aren't required to halt the OUT endpoint; instead +* we can simply accept and discard any data received +* until the next reset. */ +wedge_bulk_in_endpoint (fsg); +set_bit (IGNORE_BULK_OUT , &fsg->atomic_bitflags); +return -EINVAL ; + } + +/* Is the CBW meaningful? */ +if (cbw->Lun >=FSG_MAX_LUNS || cbw->Flags & ~USB_BULK_IN_FLAG || + cbw->Length <=0 || cbw->Length >MAX_COMMAND_SIZE ) { +DBG (fsg,"non-meaningful CBW: lun = %u, flags = 0x%x, " +"cmdlen %u\n" , + cbw->Lun, cbw->Flags, cbw->Length); + +/* We can do anything we want here, so let's stall the +* bulk pipes if we are allowed to. */ +if (common->can_stall) { +fsg_set_halt (fsg, fsg->bulk_out); +halt_bulk_in_endpoint (fsg); + } +return -EINVAL ; + } + +/* Save the command for later */ + common->cmnd_size = cbw->Length; +memcpy (common->cmnd, cbw->CDB, common->cmnd_size); +if (cbw->Flags &USB_BULK_IN_FLAG ) + common->data_dir =DATA_DIR_TO_HOST ; +else + common->data_dir =DATA_DIR_FROM_HOST ; + common->data_size =le32_to_cpu (cbw->DataTransferLength); +if (common->data_size ==0 ) + common->data_dir =DATA_DIR_NONE ; + common->lun = cbw->Lun; + common->tag = cbw->Tag; +return 0 ; +} + + +static int get_next_command (struct fsg_common *common) +{ +struct fsg_buffhd *bh; +int rc =0 ; + +/* Wait for the next buffer to become available */ + bh = common->next_buffhd_to_fill; +while (bh->state !=BUF_STATE_EMPTY ) { + rc =sleep_thread (common); +if (rc) +return rc; + } + +/* Queue a request to read a Bulk-only CBW */ +set_bulk_out_req_length (common, bh,USB_BULK_CB_WRAP_LEN ); + bh->outreq->short_not_ok =1 ; +START_TRANSFER_OR (common, bulk_out, bh->outreq, + &bh->outreq_busy, &bh->state) +/* Don't know what to do if common->fsg is NULL */ + return -EIO; + +/* We will drain the buffer in software, which means we +* can reuse it for the next filling. No need to advance +* next_buffhd_to_fill. */ + +/* Wait for the CBW to arrive */ +while (bh->state !=BUF_STATE_FULL ) { + rc =sleep_thread (common); +if (rc) +return rc; + } + + rc =fsg_is_set (common) ?received_cbw (common->fsg, bh) : -EIO ; + bh->state =BUF_STATE_EMPTY ; + +return rc; +} + + +/*-------------------------------------------------------------------------*/ + +static int enable_endpoint (struct fsg_common *common,struct usb_ep *ep, +const struct usb_endpoint_descriptor *d) +{ +int rc; + + ep->driver_data = common; + rc =usb_ep_enable (ep, d); +if (rc) +ERROR (common,"can't enable %s, result %d\n" , ep->name, rc); +return rc; +} + +static int alloc_request (struct fsg_common *common,struct usb_ep *ep, +struct usb_request **preq) +{ + *preq =usb_ep_alloc_request (ep,GFP_ATOMIC ); +if (*preq) +return 0 ; +ERROR (common,"can't allocate request for %s\n" , ep->name); +return -ENOMEM ; +} + +/* Reset interface setting and re-init endpoint state (toggle etc). */ +static int do_set_interface (struct fsg_common *common,struct fsg_dev *new_fsg) +{ +const struct usb_endpoint_descriptor *d; +struct fsg_dev *fsg; +int i, rc =0 ; + +if (common->running) +DBG (common,"reset interface\n" ); + +reset: +/* Deallocate the requests */ +if (common->fsg) { + fsg = common->fsg; + +for (i =0 ; i <FSG_NUM_BUFFERS ; ++i) { +struct fsg_buffhd *bh = &common->buffhds[i]; + +if (bh->inreq) { +usb_ep_free_request (fsg->bulk_in, bh->inreq); + bh->inreq =NULL ; + } +if (bh->outreq) { +usb_ep_free_request (fsg->bulk_out, bh->outreq); + bh->outreq =NULL ; + } + } + +/* Disable the endpoints */ +if (fsg->bulk_in_enabled) { +usb_ep_disable (fsg->bulk_in); + fsg->bulk_in_enabled =0 ; + } +if (fsg->bulk_out_enabled) { +usb_ep_disable (fsg->bulk_out); + fsg->bulk_out_enabled =0 ; + } + + common->fsg =NULL ; +/* wake_up(&common->fsg_wait); */ + } + + common->running =0 ; +if (!new_fsg || rc) +return rc; + + common->fsg = new_fsg; + fsg = common->fsg; + +/* Enable the endpoints */ + d =fsg_ep_desc (common->gadget, + &fsg_fs_bulk_in_desc, &fsg_hs_bulk_in_desc); + rc =enable_endpoint (common, fsg->bulk_in, d); +if (rc) + goto reset; + fsg->bulk_in_enabled =1 ; + + d =fsg_ep_desc (common->gadget, + &fsg_fs_bulk_out_desc, &fsg_hs_bulk_out_desc); + rc =enable_endpoint (common, fsg->bulk_out, d); +if (rc) + goto reset; + fsg->bulk_out_enabled =1 ; + common->bulk_out_maxpacket =le16_to_cpu (d->wMaxPacketSize); +clear_bit (IGNORE_BULK_OUT , &fsg->atomic_bitflags); + +/* Allocate the requests */ +for (i =0 ; i <FSG_NUM_BUFFERS ; ++i) { +struct fsg_buffhd *bh = &common->buffhds[i]; + + rc =alloc_request (common, fsg->bulk_in, &bh->inreq); +if (rc) + goto reset; + rc =alloc_request (common, fsg->bulk_out, &bh->outreq); +if (rc) + goto reset; + bh->inreq->buf = bh->outreq->buf = bh->buf; + bh->inreq->context = bh->outreq->context = bh; + bh->inreq->complete = bulk_in_complete; + bh->outreq->complete = bulk_out_complete; + } + + common->running =1 ; + +return rc; +} + + +/****************************** ALT CONFIGS ******************************/ + + +static int fsg_set_alt (struct usb_function *f,unsigned intf,unsigned alt) +{ +struct fsg_dev *fsg =fsg_from_func (f); + fsg->common->new_fsg = fsg; +raise_exception (fsg->common,FSG_STATE_CONFIG_CHANGE ); +return 0 ; +} + +static void fsg_disable (struct usb_function *f) +{ +struct fsg_dev *fsg =fsg_from_func (f); + fsg->common->new_fsg =NULL ; +raise_exception (fsg->common,FSG_STATE_CONFIG_CHANGE ); +} + +/*-------------------------------------------------------------------------*/ + +static void handle_exception (struct fsg_common *common) +{ +int i; +struct fsg_buffhd *bh; +enum fsg_state old_state; +struct fsg_lun *curlun; +unsigned int exception_req_tag; + +/* Cancel all the pending transfers */ +if (common->fsg) { +for (i =0 ; i <FSG_NUM_BUFFERS ; ++i) { + bh = &common->buffhds[i]; +if (bh->inreq_busy) +usb_ep_dequeue (common->fsg->bulk_in, bh->inreq); +if (bh->outreq_busy) +usb_ep_dequeue (common->fsg->bulk_out, + bh->outreq); + } + +/* Wait until everything is idle */ +for (;;) { +int num_active =0 ; +for (i =0 ; i <FSG_NUM_BUFFERS ; ++i) { + bh = &common->buffhds[i]; + num_active += bh->inreq_busy + bh->outreq_busy; + } +if (num_active ==0 ) +break ; +if (sleep_thread (common)) +return ; + } + +/* Clear out the controller's fifos */ +if (common->fsg->bulk_in_enabled) +usb_ep_fifo_flush (common->fsg->bulk_in); +if (common->fsg->bulk_out_enabled) +usb_ep_fifo_flush (common->fsg->bulk_out); + } + +/* Reset the I/O buffer states and pointers, the SCSI +* state, and the exception. Then invoke the handler. */ + +for (i =0 ; i <FSG_NUM_BUFFERS ; ++i) { + bh = &common->buffhds[i]; + bh->state =BUF_STATE_EMPTY ; + } + common->next_buffhd_to_fill = &common->buffhds[0 ]; + common->next_buffhd_to_drain = &common->buffhds[0 ]; + exception_req_tag = common->exception_req_tag; + old_state = common->state; + +if (old_state ==FSG_STATE_ABORT_BULK_OUT ) + common->state =FSG_STATE_STATUS_PHASE ; +else { +for (i =0 ; i < common->nluns; ++i) { + curlun = &common->luns[i]; + curlun->sense_data =SS_NO_SENSE ; + curlun->info_valid =0 ; + } + common->state =FSG_STATE_IDLE ; + } + +/* Carry out any extra actions required for the exception */ +switch (old_state) { +case FSG_STATE_ABORT_BULK_OUT : +send_status (common); + +if (common->state ==FSG_STATE_STATUS_PHASE ) + common->state =FSG_STATE_IDLE ; +break ; + +case FSG_STATE_RESET : +/* In case we were forced against our will to halt a +* bulk endpoint, clear the halt now. (The SuperH UDC +* requires this.) */ +if (!fsg_is_set (common)) +break ; +if (test_and_clear_bit (IGNORE_BULK_OUT , + &common->fsg->atomic_bitflags)) +usb_ep_clear_halt (common->fsg->bulk_in); + +if (common->ep0_req_tag == exception_req_tag) +ep0_queue (common);/* Complete the status stage */ + +break ; + +case FSG_STATE_CONFIG_CHANGE : +do_set_interface (common, common->new_fsg); +break ; + +case FSG_STATE_EXIT : +case FSG_STATE_TERMINATED : +do_set_interface (common,NULL );/* Free resources */ + common->state =FSG_STATE_TERMINATED ;/* Stop the thread */ +break ; + +case FSG_STATE_INTERFACE_CHANGE : +case FSG_STATE_DISCONNECT : +case FSG_STATE_COMMAND_PHASE : +case FSG_STATE_DATA_PHASE : +case FSG_STATE_STATUS_PHASE : +case FSG_STATE_IDLE : +break ; + } +} + +/*-------------------------------------------------------------------------*/ + +int fsg_main_thread (void *common_) +{ +struct fsg_common *common = the_fsg_common; +/* The main loop */ +do { +if (exception_in_progress (common)) { +handle_exception (common); +continue ; + } + +if (!common->running) { +sleep_thread (common); +continue ; + } + +if (get_next_command (common)) +continue ; + +if (!exception_in_progress (common)) + common->state =FSG_STATE_DATA_PHASE ; + +if (do_scsi_command (common) ||finish_reply (common)) +continue ; + +if (!exception_in_progress (common)) + common->state =FSG_STATE_STATUS_PHASE ; + +if (send_status (common)) +continue ; + +if (!exception_in_progress (common)) + common->state =FSG_STATE_IDLE ; + }while (0 ); + + common->thread_task =NULL ; + +return 0 ; +} + +static void fsg_common_release (struct kref *ref); + +static struct fsg_common *fsg_common_init (struct fsg_common *common, +struct usb_composite_dev *cdev) +{ +struct usb_gadget *gadget = cdev->gadget; +struct fsg_buffhd *bh; +struct fsg_lun *curlun; +int nluns, i, rc; + +/* Find out how many LUNs there should be */ + nluns =1 ; +if (nluns <1 || nluns >FSG_MAX_LUNS ) { +printf ("invalid number of LUNs: %u\n" , nluns); +return ERR_PTR (-EINVAL ); + } + +/* Allocate? */ +if (!common) { + common =calloc (sizeof *common,1 ); +if (!common) +return ERR_PTR (-ENOMEM ); + common->free_storage_on_release =1 ; + }else { +memset (common,0 ,sizeof common); + common->free_storage_on_release =0 ; + } + + common->ops =NULL ; + common->private_data =NULL ; + + common->gadget = gadget; + common->ep0 = gadget->ep0; + common->ep0req = cdev->req; + +/* Maybe allocate device-global string IDs, and patch descriptors */ +if (fsg_strings[FSG_STRING_INTERFACE ].id ==0 ) { + rc =usb_string_id (cdev); +if (unlikely (rc <0 )) + goto error_release; + fsg_strings[FSG_STRING_INTERFACE ].id = rc; + fsg_intf_desc.iInterface = rc; + } + +/* Create the LUNs, open their backing files, and register the +* LUN devices in sysfs. */ + curlun =calloc (nluns,sizeof *curlun); +if (!curlun) { + rc = -ENOMEM ; + goto error_release; + } + common->nluns = nluns; + +for (i =0 ; i < nluns; i++) { + common->luns[i].removable =1 ; + + rc =fsg_lun_open (&common->luns[i],"" ); +if (rc) + goto error_luns; + } + common->lun =0 ; + +/* Data buffers cyclic list */ + bh = common->buffhds; + + i =FSG_NUM_BUFFERS ; + goto buffhds_first_it; +do { + bh->next = bh +1 ; + ++bh; +buffhds_first_it: + bh->inreq_busy =0 ; + bh->outreq_busy =0 ; + bh->buf =kmalloc (FSG_BUFLEN ,GFP_KERNEL ); +if (unlikely (!bh->buf)) { + rc = -ENOMEM ; + goto error_release; + } + }while (--i); + bh->next = common->buffhds; + +snprintf (common->inquiry_string,sizeof common->inquiry_string, +"%-8s%-16s%04x" , +"Linux " , +"File-Store Gadget" , +0xffff ); + +/* Some peripheral controllers are known not to be able to +* halt bulk endpoints correctly. If one of them is present, +* disable stalls. +*/ + +/* Tell the thread to start working */ + common->thread_task = +kthread_create (fsg_main_thread, common, +OR (cfg->thread_name,"file-storage" )); +if (IS_ERR (common->thread_task)) { + rc =PTR_ERR (common->thread_task); + goto error_release; + } + +#undef OR +/* Information */ +INFO (common,FSG_DRIVER_DESC ", version: " FSG_DRIVER_VERSION "\n" ); +INFO (common,"Number of LUNs=%d\n" , common->nluns); + +return common; + +error_luns: + common->nluns = i +1 ; +error_release: + common->state =FSG_STATE_TERMINATED ;/* The thread is dead */ +/* Call fsg_common_release() directly, ref might be not +* initialised */ +fsg_common_release (&common->ref); +return ERR_PTR (rc); +} + +static void fsg_common_release (struct kref *ref) +{ + struct fsg_common *common = container_of(ref, struct fsg_common, ref); + +/* If the thread isn't already dead, tell it to exit now */ +if (common->state !=FSG_STATE_TERMINATED ) { +raise_exception (common,FSG_STATE_EXIT ); +wait_for_completion (&common->thread_notifier); + } + +if (likely (common->luns)) { +struct fsg_lun *lun = common->luns; +unsigned i = common->nluns; + +/* In error recovery common->nluns may be zero. */ +for (; i; --i, ++lun) +fsg_lun_close (lun); + +kfree (common->luns); + } + + { +struct fsg_buffhd *bh = common->buffhds; +unsigned i =FSG_NUM_BUFFERS ; +do { +kfree (bh->buf); + }while (++bh, --i); + } + +if (common->free_storage_on_release) +kfree (common); +} + + +/*-------------------------------------------------------------------------*/ + +/** +* usb_copy_descriptors - copy a vector of USB descriptors +* @src: null-terminated vector to copy +* Context: initialization code, which may sleep +* +* This makes a copy of a vector of USB descriptors. Its primary use +* is to support usb_function objects which can have multiple copies, +* each needing different descriptors. Functions may have static +* tables of descriptors, which are used as templates and customized +* with identifiers (for interfaces, strings, endpoints, and more) +* as needed by a given function instance. +*/ +struct usb_descriptor_header ** +usb_copy_descriptors (struct usb_descriptor_header **src) +{ +struct usb_descriptor_header **tmp; +unsigned bytes; +unsigned n_desc; +void *mem; +struct usb_descriptor_header **ret; + +/* count descriptors and their sizes; then add vector size */ +for (bytes =0 , n_desc =0 , tmp = src; *tmp; tmp++, n_desc++) + bytes += (*tmp)->bLength; + bytes += (n_desc +1 ) *sizeof (*tmp); + + mem =kmalloc (bytes,GFP_KERNEL ); +if (!mem) +return NULL ; + +/* fill in pointers starting at "tmp", +* to descriptors copied starting at "mem"; +* and return "ret" +*/ + tmp = mem; + ret = mem; + mem += (n_desc +1 ) *sizeof (*tmp); +while (*src) { +memcpy (mem, *src, (*src)->bLength); + *tmp = mem; + tmp++; + mem += (*src)->bLength; + src++; + } + *tmp =NULL ; + +return ret; +} + + + +static void fsg_unbind (struct usb_configuration *c,struct usb_function *f) +{ +struct fsg_dev *fsg =fsg_from_func (f); + +DBG (fsg,"unbind\n" ); +if (fsg->common->fsg == fsg) { + fsg->common->new_fsg =NULL ; +raise_exception (fsg->common,FSG_STATE_CONFIG_CHANGE ); + } + +free (fsg->function.descriptors); +free (fsg->function.hs_descriptors); +kfree (fsg); +} + +static int fsg_bind (struct usb_configuration *c,struct usb_function *f) +{ +struct fsg_dev *fsg =fsg_from_func (f); +struct usb_gadget *gadget = c->cdev->gadget; +int i; +struct usb_ep *ep; + fsg->gadget = gadget; + +/* New interface */ + i =usb_interface_id (c, f); +if (i <0 ) +return i; + fsg_intf_desc.bInterfaceNumber = i; + fsg->interface_number = i; + +/* Find all the endpoints we will use */ + ep =usb_ep_autoconfig (gadget, &fsg_fs_bulk_in_desc); +if (!ep) + goto autoconf_fail; + ep->driver_data = fsg->common;/* claim the endpoint */ + fsg->bulk_in = ep; + + ep =usb_ep_autoconfig (gadget, &fsg_fs_bulk_out_desc); +if (!ep) + goto autoconf_fail; + ep->driver_data = fsg->common;/* claim the endpoint */ + fsg->bulk_out = ep; + +/* Copy descriptors */ + f->descriptors =usb_copy_descriptors (fsg_fs_function); +if (unlikely (!f->descriptors)) +return -ENOMEM ; + +if (gadget_is_dualspeed (gadget)) { +/* Assume endpoint addresses are the same for both speeds */ + fsg_hs_bulk_in_desc.bEndpointAddress = + fsg_fs_bulk_in_desc.bEndpointAddress; + fsg_hs_bulk_out_desc.bEndpointAddress = + fsg_fs_bulk_out_desc.bEndpointAddress; + f->hs_descriptors =usb_copy_descriptors (fsg_hs_function); +if (unlikely (!f->hs_descriptors)) { +free (f->descriptors); +return -ENOMEM ; + } + } +return 0 ; + +autoconf_fail: +ERROR (fsg,"unable to autoconfigure all endpoints\n" ); +return -ENOTSUPP ; +} + + +/****************************** ADD FUNCTION ******************************/ + +static struct usb_gadget_strings *fsg_strings_array[] = { + &fsg_stringtab, +NULL , +}; + +static int fsg_bind_config (struct usb_composite_dev *cdev, +struct usb_configuration *c, +struct fsg_common *common) +{ +struct fsg_dev *fsg; +int rc; + + fsg =calloc (1 ,sizeof *fsg); +if (!fsg) +return -ENOMEM ; + fsg->function.name =FSG_DRIVER_DESC ; + fsg->function.strings = fsg_strings_array; + fsg->function.bind = fsg_bind; + fsg->function.unbind = fsg_unbind; + fsg->function.setup = fsg_setup; + fsg->function.set_alt = fsg_set_alt; + fsg->function.disable = fsg_disable; + + fsg->common = common; + common->fsg = fsg; +/* Our caller holds a reference to common structure so we +* don't have to be worry about it being freed until we return +* from this function. So instead of incrementing counter now +* and decrement in error recovery we increment it only when +* call to usb_add_function() was successful. */ + + rc =usb_add_function (c, &fsg->function); + +if (rc) +kfree (fsg); + +return rc; +} + +int fsg_add (struct usb_configuration *c) +{ +struct fsg_common *fsg_common; + + fsg_common =fsg_common_init (NULL , c->cdev); + + fsg_common->vendor_name =0 ; + fsg_common->product_name =0 ; + fsg_common->release =0xffff ; + + fsg_common->ops =NULL ; + fsg_common->private_data =NULL ; + + the_fsg_common = fsg_common; + +return fsg_bind_config (c->cdev, c, fsg_common); +} + +int fsg_init (struct ums_board_info *ums) +{ + ums_info = ums; + +return 0 ; +}
Signature · 1 line
1.7.9.5
PATCH RESEND v2 3/4 usb:gadget: USB Mass Storage Gadget support
In reply to y at samsung.comFrom: Lukasz Majewski <[email protected]>
This patch adds the USB Mass Storage Gadget to u-boot New command called "ums" is implemented to provide access to on-device embedded persistent memory.
USB Mass Storage is supposed to work on top of the USB Gadget framework
---
Changes in v2: None
common/Makefile | 1 + common/cmd_usb_mass_storage.c | 86 +++++++++++++++++++++++++++++++++++++++++ drivers/usb/gadget/g_dnl.c | 6 +++ include/usb_mass_storage.h | 55 ++++++++++++++++++++++++++ 4 files changed, 148 insertions(+) create mode 100644 common/cmd_usb_mass_storage.c create mode 100644 include/usb_mass_storage.h
common/Makefile +1 -0
@@ -174,6 +174,7 @@ COBJS-y += cmd_usb.o COBJS-y += usb.o usb_hub.o COBJS-$(CONFIG_USB_STORAGE) += usb_storage.o endif +COBJS-$(CONFIG_CMD_USB_MASS_STORAGE) += cmd_usb_mass_storage.o COBJS-$(CONFIG_CMD_XIMG) += cmd_ximg.o COBJS-$(CONFIG_YAFFS2) += cmd_yaffs2.o COBJS-$(CONFIG_CMD_SPL) += cmd_spl.o
common/cmd_usb_mass_storage.c new file +86 -0
86 lines not on this page · raw message
drivers/usb/gadget/g_dnl.c +6 -0
@@ -31,6 +31,7 @@#include "gadget_chips.h" #include "composite.c" +#include "f_mass_storage.c" /* * One needs to define the following:
@@ -104,6 +105,8 @@ static int g_dnl_do_config(struct usb_configuration *c)printf ("GADGET DRIVER: %s\n" , s);if (!strcmp (s,"usb_dnl_dfu" )) ret =dfu_add (c); +else if (!strcmp (s,"usb_dnl_ums" )) + ret =fsg_add (c);return ret; }
@@ -188,6 +191,9 @@ int g_dnl_register(const char *type)if (!strcmp (type,"dfu" )) {strcpy (name, shortname);strcat (name, type); + }else if (!strcmp (type,"ums" )) { +strcpy (name, shortname); +strcat (name, type); }else {printf ("%s: unknown command: %s\n" , __func__, type);return -EINVAL ;
include/usb_mass_storage.h new file +55 -0
55 lines not on this page · raw message
Signature · 1 line
1.7.9.5
PATCH RESEND v2 4/4 arm:trats: Use new ums command
In reply to y at samsung.comFrom: Lukasz Majewski <[email protected]>
This patch enables new "ums" command on Trats board
---
Changes in v2: None
board/samsung/trats/trats.c | 63 +++++++++++++++++++++++++++++++++++++++++++ include/configs/trats.h | 5 ++++ 2 files changed, 68 insertions(+)
board/samsung/trats/trats.c +63 -0
@@ -42,6 +42,7 @@#include <power/max8997_muic.h> #include <power/battery.h> #include <power/max17042_fg.h> +#include <usb_mass_storage.h> #include "setup.h"
@@ -791,3 +792,65 @@ void init_panel_info(vidinfo_t *vid)setenv ("lcdinfo" ,"lcd=s6e8ax0" ); } + +#ifdef CONFIG_USB_GADGET_MASS_STORAGE +static int ums_read_sector (struct ums_device *ums_dev, +ulong start,lbaint_t blkcnt,void *buf) +{ +if (ums_dev->mmc->block_dev.block_read (ums_dev->dev_num, + start + ums_dev->offset, blkcnt, buf) != blkcnt) +return -1 ; + +return 0 ; +} + +static int ums_write_sector (struct ums_device *ums_dev, +ulong start,lbaint_t blkcnt,const void *buf) +{ +if (ums_dev->mmc->block_dev.block_write (ums_dev->dev_num, + start + ums_dev->offset, blkcnt, buf) != blkcnt) +return -1 ; + +return 0 ; +} + +static void ums_get_capacity (struct ums_device *ums_dev, +long long int *capacity) +{ +long long int tmp_capacity; + + tmp_capacity = (long long int ) ((ums_dev->offset + ums_dev->part_size) + *SECTOR_SIZE ); + *capacity = ums_dev->mmc->capacity - tmp_capacity; +} + +static struct ums_board_info ums_board = { + .read_sector = ums_read_sector, + .write_sector = ums_write_sector, + .get_capacity = ums_get_capacity, + .name ="TRATS UMS disk" , + .ums_dev = { + .mmc =NULL , + .dev_num =0 , + .offset =0 , + .part_size =0. + }, +}; + +struct ums_board_info *board_ums_init (unsigned int dev_num,unsigned int offset, +unsigned int part_size) +{ +struct mmc *mmc; + + mmc =find_mmc_device (dev_num); +if (!mmc) +return NULL ; + + ums_board.ums_dev.mmc = mmc; + ums_board.ums_dev.dev_num = dev_num; + ums_board.ums_dev.offset = offset; + ums_board.ums_dev.part_size = part_size; + +return &ums_board; +} +#endif
include/configs/trats.h +5 -0
@@ -316,4 +316,9 @@#define CONFIG_VIDEO_BMP_GZIP #define CONFIG_SYS_VIDEO_LOGO_MAX_SIZE ((500 * 120 * 4) + (1 << 12)) +#define CONFIG_CMD_USB_MASS_STORAGE +#if defined(CONFIG_CMD_USB_MASS_STORAGE ) +#define CONFIG_USB_GADGET_MASS_STORAGE +#endif +#endif /* __CONFIG_H */
Signature · 1 line
1.7.9.5