aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/usb/gadget
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/usb/gadget')
-rw-r--r--drivers/usb/gadget/Kconfig60
-rw-r--r--drivers/usb/gadget/Makefile4
-rw-r--r--drivers/usb/gadget/at91_udc.c6
-rw-r--r--drivers/usb/gadget/audio.c115
-rw-r--r--drivers/usb/gadget/composite.c59
-rw-r--r--drivers/usb/gadget/ether.c16
-rw-r--r--drivers/usb/gadget/f_acm.c28
-rw-r--r--drivers/usb/gadget/f_audio.c76
-rw-r--r--drivers/usb/gadget/f_mass_storage.c3091
-rw-r--r--drivers/usb/gadget/f_rndis.c35
-rw-r--r--drivers/usb/gadget/file_storage.c879
-rw-r--r--drivers/usb/gadget/mass_storage.c240
-rw-r--r--drivers/usb/gadget/multi.c358
-rw-r--r--drivers/usb/gadget/storage_common.c778
-rw-r--r--drivers/usb/gadget/u_ether.h2
15 files changed, 4839 insertions, 908 deletions
diff --git a/drivers/usb/gadget/Kconfig b/drivers/usb/gadget/Kconfig
index a18e3c5dd82e..ee411206c699 100644
--- a/drivers/usb/gadget/Kconfig
+++ b/drivers/usb/gadget/Kconfig
@@ -732,6 +732,24 @@ config USB_FILE_STORAGE_TEST
732 behavior of USB Mass Storage hosts. Not needed for 732 behavior of USB Mass Storage hosts. Not needed for
733 normal operation. 733 normal operation.
734 734
735config USB_MASS_STORAGE
736 tristate "Mass Storage Gadget"
737 depends on BLOCK
738 help
739 The Mass Storage Gadget acts as a USB Mass Storage disk drive.
740 As its storage repository it can use a regular file or a block
741 device (in much the same way as the "loop" device driver),
742 specified as a module parameter or sysfs option.
743
744 This is heavily based on File-backed Storage Gadget and in most
745 cases you will want to use FSG instead. This gadget is mostly
746 here to test the functionality of the Mass Storage Function
747 which may be used with composite framework.
748
749 Say "y" to link the driver statically, or "m" to build
750 a dynamically linked module called "g_file_storage". If unsure,
751 consider File-backed Storage Gadget.
752
735config USB_G_SERIAL 753config USB_G_SERIAL
736 tristate "Serial Gadget (with CDC ACM and CDC OBEX support)" 754 tristate "Serial Gadget (with CDC ACM and CDC OBEX support)"
737 help 755 help
@@ -794,6 +812,48 @@ config USB_CDC_COMPOSITE
794 Say "y" to link the driver statically, or "m" to build a 812 Say "y" to link the driver statically, or "m" to build a
795 dynamically linked module. 813 dynamically linked module.
796 814
815config USB_G_MULTI
816 tristate "Multifunction Composite Gadget (EXPERIMENTAL)"
817 depends on BLOCK && NET
818 help
819 The Multifunction Composite Gadget provides Ethernet (RNDIS
820 and/or CDC Ethernet), mass storage and ACM serial link
821 interfaces.
822
823 You will be asked to choose which of the two configurations is
824 to be available in the gadget. At least one configuration must
825 be chosen to make the gadget usable. Selecting more than one
826 configuration will prevent Windows from automatically detecting
827 the gadget as a composite gadget, so an INF file will be needed to
828 use the gadget.
829
830 Say "y" to link the driver statically, or "m" to build a
831 dynamically linked module called "g_multi".
832
833config USB_G_MULTI_RNDIS
834 bool "RNDIS + CDC Serial + Storage configuration"
835 depends on USB_G_MULTI
836 default y
837 help
838 This option enables a configuration with RNDIS, CDC Serial and
839 Mass Storage functions available in the Multifunction Composite
840 Gadget. This is the configuration dedicated for Windows since RNDIS
841 is Microsoft's protocol.
842
843 If unsure, say "y".
844
845config USB_G_MULTI_CDC
846 bool "CDC Ethernet + CDC Serial + Storage configuration"
847 depends on USB_G_MULTI
848 default n
849 help
850 This option enables a configuration with CDC Ethernet (ECM), CDC
851 Serial and Mass Storage functions available in the Multifunction
852 Composite Gadget.
853
854 If unsure, say "y".
855
856
797# put drivers that need isochronous transfer support (for audio 857# put drivers that need isochronous transfer support (for audio
798# or video class gadget drivers), or specific hardware, here. 858# or video class gadget drivers), or specific hardware, here.
799 859
diff --git a/drivers/usb/gadget/Makefile b/drivers/usb/gadget/Makefile
index 9d7b87c52e9f..2e2c047262b7 100644
--- a/drivers/usb/gadget/Makefile
+++ b/drivers/usb/gadget/Makefile
@@ -39,16 +39,20 @@ g_serial-objs := serial.o
39g_midi-objs := gmidi.o 39g_midi-objs := gmidi.o
40gadgetfs-objs := inode.o 40gadgetfs-objs := inode.o
41g_file_storage-objs := file_storage.o 41g_file_storage-objs := file_storage.o
42g_mass_storage-objs := mass_storage.o
42g_printer-objs := printer.o 43g_printer-objs := printer.o
43g_cdc-objs := cdc2.o 44g_cdc-objs := cdc2.o
45g_multi-objs := multi.o
44 46
45obj-$(CONFIG_USB_ZERO) += g_zero.o 47obj-$(CONFIG_USB_ZERO) += g_zero.o
46obj-$(CONFIG_USB_AUDIO) += g_audio.o 48obj-$(CONFIG_USB_AUDIO) += g_audio.o
47obj-$(CONFIG_USB_ETH) += g_ether.o 49obj-$(CONFIG_USB_ETH) += g_ether.o
48obj-$(CONFIG_USB_GADGETFS) += gadgetfs.o 50obj-$(CONFIG_USB_GADGETFS) += gadgetfs.o
49obj-$(CONFIG_USB_FILE_STORAGE) += g_file_storage.o 51obj-$(CONFIG_USB_FILE_STORAGE) += g_file_storage.o
52obj-$(CONFIG_USB_MASS_STORAGE) += g_mass_storage.o
50obj-$(CONFIG_USB_G_SERIAL) += g_serial.o 53obj-$(CONFIG_USB_G_SERIAL) += g_serial.o
51obj-$(CONFIG_USB_G_PRINTER) += g_printer.o 54obj-$(CONFIG_USB_G_PRINTER) += g_printer.o
52obj-$(CONFIG_USB_MIDI_GADGET) += g_midi.o 55obj-$(CONFIG_USB_MIDI_GADGET) += g_midi.o
53obj-$(CONFIG_USB_CDC_COMPOSITE) += g_cdc.o 56obj-$(CONFIG_USB_CDC_COMPOSITE) += g_cdc.o
57obj-$(CONFIG_USB_G_MULTI) += g_multi.o
54 58
diff --git a/drivers/usb/gadget/at91_udc.c b/drivers/usb/gadget/at91_udc.c
index 66450a1abc22..043e04db2a05 100644
--- a/drivers/usb/gadget/at91_udc.c
+++ b/drivers/usb/gadget/at91_udc.c
@@ -892,7 +892,7 @@ static void pullup(struct at91_udc *udc, int is_on)
892 892
893 txvc |= AT91_UDP_TXVC_PUON; 893 txvc |= AT91_UDP_TXVC_PUON;
894 at91_udp_write(udc, AT91_UDP_TXVC, txvc); 894 at91_udp_write(udc, AT91_UDP_TXVC, txvc);
895 } else if (cpu_is_at91sam9261()) { 895 } else if (cpu_is_at91sam9261() || cpu_is_at91sam9g10()) {
896 u32 usbpucr; 896 u32 usbpucr;
897 897
898 usbpucr = at91_sys_read(AT91_MATRIX_USBPUCR); 898 usbpucr = at91_sys_read(AT91_MATRIX_USBPUCR);
@@ -910,7 +910,7 @@ static void pullup(struct at91_udc *udc, int is_on)
910 910
911 txvc &= ~AT91_UDP_TXVC_PUON; 911 txvc &= ~AT91_UDP_TXVC_PUON;
912 at91_udp_write(udc, AT91_UDP_TXVC, txvc); 912 at91_udp_write(udc, AT91_UDP_TXVC, txvc);
913 } else if (cpu_is_at91sam9261()) { 913 } else if (cpu_is_at91sam9261() || cpu_is_at91sam9g10()) {
914 u32 usbpucr; 914 u32 usbpucr;
915 915
916 usbpucr = at91_sys_read(AT91_MATRIX_USBPUCR); 916 usbpucr = at91_sys_read(AT91_MATRIX_USBPUCR);
@@ -1692,7 +1692,7 @@ static int __init at91udc_probe(struct platform_device *pdev)
1692 udc->ep[3].maxpacket = 64; 1692 udc->ep[3].maxpacket = 64;
1693 udc->ep[4].maxpacket = 512; 1693 udc->ep[4].maxpacket = 512;
1694 udc->ep[5].maxpacket = 512; 1694 udc->ep[5].maxpacket = 512;
1695 } else if (cpu_is_at91sam9261()) { 1695 } else if (cpu_is_at91sam9261() || cpu_is_at91sam9g10()) {
1696 udc->ep[3].maxpacket = 64; 1696 udc->ep[3].maxpacket = 64;
1697 } else if (cpu_is_at91sam9263()) { 1697 } else if (cpu_is_at91sam9263()) {
1698 udc->ep[0].maxpacket = 64; 1698 udc->ep[0].maxpacket = 64;
diff --git a/drivers/usb/gadget/audio.c b/drivers/usb/gadget/audio.c
index a3a0f4a27ef0..58f220323847 100644
--- a/drivers/usb/gadget/audio.c
+++ b/drivers/usb/gadget/audio.c
@@ -89,120 +89,6 @@ static const struct usb_descriptor_header *otg_desc[] = {
89 89
90/*-------------------------------------------------------------------------*/ 90/*-------------------------------------------------------------------------*/
91 91
92/**
93 * Handle USB audio endpoint set/get command in setup class request
94 */
95
96static int audio_set_endpoint_req(struct usb_configuration *c,
97 const struct usb_ctrlrequest *ctrl)
98{
99 struct usb_composite_dev *cdev = c->cdev;
100 int value = -EOPNOTSUPP;
101 u16 ep = le16_to_cpu(ctrl->wIndex);
102 u16 len = le16_to_cpu(ctrl->wLength);
103 u16 w_value = le16_to_cpu(ctrl->wValue);
104
105 DBG(cdev, "bRequest 0x%x, w_value 0x%04x, len %d, endpoint %d\n",
106 ctrl->bRequest, w_value, len, ep);
107
108 switch (ctrl->bRequest) {
109 case UAC_SET_CUR:
110 value = 0;
111 break;
112
113 case UAC_SET_MIN:
114 break;
115
116 case UAC_SET_MAX:
117 break;
118
119 case UAC_SET_RES:
120 break;
121
122 case UAC_SET_MEM:
123 break;
124
125 default:
126 break;
127 }
128
129 return value;
130}
131
132static int audio_get_endpoint_req(struct usb_configuration *c,
133 const struct usb_ctrlrequest *ctrl)
134{
135 struct usb_composite_dev *cdev = c->cdev;
136 int value = -EOPNOTSUPP;
137 u8 ep = ((le16_to_cpu(ctrl->wIndex) >> 8) & 0xFF);
138 u16 len = le16_to_cpu(ctrl->wLength);
139 u16 w_value = le16_to_cpu(ctrl->wValue);
140
141 DBG(cdev, "bRequest 0x%x, w_value 0x%04x, len %d, endpoint %d\n",
142 ctrl->bRequest, w_value, len, ep);
143
144 switch (ctrl->bRequest) {
145 case UAC_GET_CUR:
146 case UAC_GET_MIN:
147 case UAC_GET_MAX:
148 case UAC_GET_RES:
149 value = 3;
150 break;
151 case UAC_GET_MEM:
152 break;
153 default:
154 break;
155 }
156
157 return value;
158}
159
160static int
161audio_setup(struct usb_configuration *c, const struct usb_ctrlrequest *ctrl)
162{
163 struct usb_composite_dev *cdev = c->cdev;
164 struct usb_request *req = cdev->req;
165 int value = -EOPNOTSUPP;
166 u16 w_index = le16_to_cpu(ctrl->wIndex);
167 u16 w_value = le16_to_cpu(ctrl->wValue);
168 u16 w_length = le16_to_cpu(ctrl->wLength);
169
170 /* composite driver infrastructure handles everything except
171 * Audio class messages; interface activation uses set_alt().
172 */
173 switch (ctrl->bRequestType) {
174 case USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_ENDPOINT:
175 value = audio_set_endpoint_req(c, ctrl);
176 break;
177
178 case USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_ENDPOINT:
179 value = audio_get_endpoint_req(c, ctrl);
180 break;
181
182 default:
183 ERROR(cdev, "Invalid control req%02x.%02x v%04x i%04x l%d\n",
184 ctrl->bRequestType, ctrl->bRequest,
185 w_value, w_index, w_length);
186 }
187
188 /* respond with data transfer or status phase? */
189 if (value >= 0) {
190 DBG(cdev, "Audio req%02x.%02x v%04x i%04x l%d\n",
191 ctrl->bRequestType, ctrl->bRequest,
192 w_value, w_index, w_length);
193 req->zero = 0;
194 req->length = value;
195 value = usb_ep_queue(cdev->gadget->ep0, req, GFP_ATOMIC);
196 if (value < 0)
197 ERROR(cdev, "Audio response on err %d\n", value);
198 }
199
200 /* device either stalls (value < 0) or reports success */
201 return value;
202}
203
204/*-------------------------------------------------------------------------*/
205
206static int __init audio_do_config(struct usb_configuration *c) 92static int __init audio_do_config(struct usb_configuration *c)
207{ 93{
208 /* FIXME alloc iConfiguration string, set it in c->strings */ 94 /* FIXME alloc iConfiguration string, set it in c->strings */
@@ -220,7 +106,6 @@ static int __init audio_do_config(struct usb_configuration *c)
220static struct usb_configuration audio_config_driver = { 106static struct usb_configuration audio_config_driver = {
221 .label = DRIVER_DESC, 107 .label = DRIVER_DESC,
222 .bind = audio_do_config, 108 .bind = audio_do_config,
223 .setup = audio_setup,
224 .bConfigurationValue = 1, 109 .bConfigurationValue = 1,
225 /* .iConfiguration = DYNAMIC */ 110 /* .iConfiguration = DYNAMIC */
226 .bmAttributes = USB_CONFIG_ATT_SELFPOWER, 111 .bmAttributes = USB_CONFIG_ATT_SELFPOWER,
diff --git a/drivers/usb/gadget/composite.c b/drivers/usb/gadget/composite.c
index d05397ec8a18..09289bb1e20f 100644
--- a/drivers/usb/gadget/composite.c
+++ b/drivers/usb/gadget/composite.c
@@ -373,6 +373,8 @@ static void reset_config(struct usb_composite_dev *cdev)
373 list_for_each_entry(f, &cdev->config->functions, list) { 373 list_for_each_entry(f, &cdev->config->functions, list) {
374 if (f->disable) 374 if (f->disable)
375 f->disable(f); 375 f->disable(f);
376
377 bitmap_zero(f->endpoints, 32);
376 } 378 }
377 cdev->config = NULL; 379 cdev->config = NULL;
378} 380}
@@ -418,10 +420,35 @@ static int set_config(struct usb_composite_dev *cdev,
418 /* Initialize all interfaces by setting them to altsetting zero. */ 420 /* Initialize all interfaces by setting them to altsetting zero. */
419 for (tmp = 0; tmp < MAX_CONFIG_INTERFACES; tmp++) { 421 for (tmp = 0; tmp < MAX_CONFIG_INTERFACES; tmp++) {
420 struct usb_function *f = c->interface[tmp]; 422 struct usb_function *f = c->interface[tmp];
423 struct usb_descriptor_header **descriptors;
421 424
422 if (!f) 425 if (!f)
423 break; 426 break;
424 427
428 /*
429 * Record which endpoints are used by the function. This is used
430 * to dispatch control requests targeted at that endpoint to the
431 * function's setup callback instead of the current
432 * configuration's setup callback.
433 */
434 if (gadget->speed == USB_SPEED_HIGH)
435 descriptors = f->hs_descriptors;
436 else
437 descriptors = f->descriptors;
438
439 for (; *descriptors; ++descriptors) {
440 struct usb_endpoint_descriptor *ep;
441 int addr;
442
443 if ((*descriptors)->bDescriptorType != USB_DT_ENDPOINT)
444 continue;
445
446 ep = (struct usb_endpoint_descriptor *)*descriptors;
447 addr = ((ep->bEndpointAddress & 0x80) >> 3)
448 | (ep->bEndpointAddress & 0x0f);
449 set_bit(addr, f->endpoints);
450 }
451
425 result = f->set_alt(f, tmp, 0); 452 result = f->set_alt(f, tmp, 0);
426 if (result < 0) { 453 if (result < 0) {
427 DBG(cdev, "interface %d (%s/%p) alt 0 --> %d\n", 454 DBG(cdev, "interface %d (%s/%p) alt 0 --> %d\n",
@@ -688,6 +715,7 @@ composite_setup(struct usb_gadget *gadget, const struct usb_ctrlrequest *ctrl)
688 u16 w_value = le16_to_cpu(ctrl->wValue); 715 u16 w_value = le16_to_cpu(ctrl->wValue);
689 u16 w_length = le16_to_cpu(ctrl->wLength); 716 u16 w_length = le16_to_cpu(ctrl->wLength);
690 struct usb_function *f = NULL; 717 struct usb_function *f = NULL;
718 u8 endp;
691 719
692 /* partial re-init of the response message; the function or the 720 /* partial re-init of the response message; the function or the
693 * gadget might need to intercept e.g. a control-OUT completion 721 * gadget might need to intercept e.g. a control-OUT completion
@@ -800,23 +828,33 @@ unknown:
800 ctrl->bRequestType, ctrl->bRequest, 828 ctrl->bRequestType, ctrl->bRequest,
801 w_value, w_index, w_length); 829 w_value, w_index, w_length);
802 830
803 /* functions always handle their interfaces ... punt other 831 /* functions always handle their interfaces and endpoints...
804 * recipients (endpoint, other, WUSB, ...) to the current 832 * punt other recipients (other, WUSB, ...) to the current
805 * configuration code. 833 * configuration code.
806 * 834 *
807 * REVISIT it could make sense to let the composite device 835 * REVISIT it could make sense to let the composite device
808 * take such requests too, if that's ever needed: to work 836 * take such requests too, if that's ever needed: to work
809 * in config 0, etc. 837 * in config 0, etc.
810 */ 838 */
811 if ((ctrl->bRequestType & USB_RECIP_MASK) 839 switch (ctrl->bRequestType & USB_RECIP_MASK) {
812 == USB_RECIP_INTERFACE) { 840 case USB_RECIP_INTERFACE:
813 f = cdev->config->interface[intf]; 841 f = cdev->config->interface[intf];
814 if (f && f->setup) 842 break;
815 value = f->setup(f, ctrl); 843
816 else 844 case USB_RECIP_ENDPOINT:
845 endp = ((w_index & 0x80) >> 3) | (w_index & 0x0f);
846 list_for_each_entry(f, &cdev->config->functions, list) {
847 if (test_bit(endp, f->endpoints))
848 break;
849 }
850 if (&f->list == &cdev->config->functions)
817 f = NULL; 851 f = NULL;
852 break;
818 } 853 }
819 if (value < 0 && !f) { 854
855 if (f && f->setup)
856 value = f->setup(f, ctrl);
857 else {
820 struct usb_configuration *c; 858 struct usb_configuration *c;
821 859
822 c = cdev->config; 860 c = cdev->config;
@@ -1054,7 +1092,8 @@ static struct usb_gadget_driver composite_driver = {
1054 .speed = USB_SPEED_HIGH, 1092 .speed = USB_SPEED_HIGH,
1055 1093
1056 .bind = composite_bind, 1094 .bind = composite_bind,
1057 .unbind = __exit_p(composite_unbind), 1095 /* .unbind = __exit_p(composite_unbind), */
1096 .unbind = composite_unbind,
1058 1097
1059 .setup = composite_setup, 1098 .setup = composite_setup,
1060 .disconnect = composite_disconnect, 1099 .disconnect = composite_disconnect,
@@ -1103,7 +1142,7 @@ int __init usb_composite_register(struct usb_composite_driver *driver)
1103 * This function is used to unregister drivers using the composite 1142 * This function is used to unregister drivers using the composite
1104 * driver framework. 1143 * driver framework.
1105 */ 1144 */
1106void __exit usb_composite_unregister(struct usb_composite_driver *driver) 1145void /* __exit */ usb_composite_unregister(struct usb_composite_driver *driver)
1107{ 1146{
1108 if (composite != driver) 1147 if (composite != driver)
1109 return; 1148 return;
diff --git a/drivers/usb/gadget/ether.c b/drivers/usb/gadget/ether.c
index 167cb2a8ecef..141372b6e7a1 100644
--- a/drivers/usb/gadget/ether.c
+++ b/drivers/usb/gadget/ether.c
@@ -25,6 +25,14 @@
25#include <linux/kernel.h> 25#include <linux/kernel.h>
26#include <linux/utsname.h> 26#include <linux/utsname.h>
27 27
28
29#if defined USB_ETH_RNDIS
30# undef USB_ETH_RNDIS
31#endif
32#ifdef CONFIG_USB_ETH_RNDIS
33# define USB_ETH_RNDIS y
34#endif
35
28#include "u_ether.h" 36#include "u_ether.h"
29 37
30 38
@@ -66,7 +74,7 @@
66#define DRIVER_DESC "Ethernet Gadget" 74#define DRIVER_DESC "Ethernet Gadget"
67#define DRIVER_VERSION "Memorial Day 2008" 75#define DRIVER_VERSION "Memorial Day 2008"
68 76
69#ifdef CONFIG_USB_ETH_RNDIS 77#ifdef USB_ETH_RNDIS
70#define PREFIX "RNDIS/" 78#define PREFIX "RNDIS/"
71#else 79#else
72#define PREFIX "" 80#define PREFIX ""
@@ -87,7 +95,7 @@
87 95
88static inline bool has_rndis(void) 96static inline bool has_rndis(void)
89{ 97{
90#ifdef CONFIG_USB_ETH_RNDIS 98#ifdef USB_ETH_RNDIS
91 return true; 99 return true;
92#else 100#else
93 return false; 101 return false;
@@ -110,7 +118,7 @@ static inline bool has_rndis(void)
110 118
111#include "f_ecm.c" 119#include "f_ecm.c"
112#include "f_subset.c" 120#include "f_subset.c"
113#ifdef CONFIG_USB_ETH_RNDIS 121#ifdef USB_ETH_RNDIS
114#include "f_rndis.c" 122#include "f_rndis.c"
115#include "rndis.c" 123#include "rndis.c"
116#endif 124#endif
@@ -251,7 +259,7 @@ static struct usb_configuration rndis_config_driver = {
251 259
252/*-------------------------------------------------------------------------*/ 260/*-------------------------------------------------------------------------*/
253 261
254#ifdef CONFIG_USB_ETH_EEM 262#ifdef USB_ETH_EEM
255static int use_eem = 1; 263static int use_eem = 1;
256#else 264#else
257static int use_eem; 265static int use_eem;
diff --git a/drivers/usb/gadget/f_acm.c b/drivers/usb/gadget/f_acm.c
index 4e3657808b0f..d10353d46b86 100644
--- a/drivers/usb/gadget/f_acm.c
+++ b/drivers/usb/gadget/f_acm.c
@@ -4,6 +4,8 @@
4 * Copyright (C) 2003 Al Borchers (alborchers@steinerpoint.com) 4 * Copyright (C) 2003 Al Borchers (alborchers@steinerpoint.com)
5 * Copyright (C) 2008 by David Brownell 5 * Copyright (C) 2008 by David Brownell
6 * Copyright (C) 2008 by Nokia Corporation 6 * Copyright (C) 2008 by Nokia Corporation
7 * Copyright (C) 2009 by Samsung Electronics
8 * Author: Michal Nazarewicz (m.nazarewicz@samsung.com)
7 * 9 *
8 * This software is distributed under the terms of the GNU General 10 * This software is distributed under the terms of the GNU General
9 * Public License ("GPL") as published by the Free Software Foundation, 11 * Public License ("GPL") as published by the Free Software Foundation,
@@ -99,6 +101,20 @@ static inline struct f_acm *port_to_acm(struct gserial *p)
99 101
100/* interface and class descriptors: */ 102/* interface and class descriptors: */
101 103
104static struct usb_interface_assoc_descriptor
105acm_iad_descriptor = {
106 .bLength = sizeof acm_iad_descriptor,
107 .bDescriptorType = USB_DT_INTERFACE_ASSOCIATION,
108
109 /* .bFirstInterface = DYNAMIC, */
110 .bInterfaceCount = 2, // control + data
111 .bFunctionClass = USB_CLASS_COMM,
112 .bFunctionSubClass = USB_CDC_SUBCLASS_ACM,
113 .bFunctionProtocol = USB_CDC_PROTO_NONE,
114 /* .iFunction = DYNAMIC */
115};
116
117
102static struct usb_interface_descriptor acm_control_interface_desc __initdata = { 118static struct usb_interface_descriptor acm_control_interface_desc __initdata = {
103 .bLength = USB_DT_INTERFACE_SIZE, 119 .bLength = USB_DT_INTERFACE_SIZE,
104 .bDescriptorType = USB_DT_INTERFACE, 120 .bDescriptorType = USB_DT_INTERFACE,
@@ -178,6 +194,7 @@ static struct usb_endpoint_descriptor acm_fs_out_desc __initdata = {
178}; 194};
179 195
180static struct usb_descriptor_header *acm_fs_function[] __initdata = { 196static struct usb_descriptor_header *acm_fs_function[] __initdata = {
197 (struct usb_descriptor_header *) &acm_iad_descriptor,
181 (struct usb_descriptor_header *) &acm_control_interface_desc, 198 (struct usb_descriptor_header *) &acm_control_interface_desc,
182 (struct usb_descriptor_header *) &acm_header_desc, 199 (struct usb_descriptor_header *) &acm_header_desc,
183 (struct usb_descriptor_header *) &acm_call_mgmt_descriptor, 200 (struct usb_descriptor_header *) &acm_call_mgmt_descriptor,
@@ -216,6 +233,7 @@ static struct usb_endpoint_descriptor acm_hs_out_desc __initdata = {
216}; 233};
217 234
218static struct usb_descriptor_header *acm_hs_function[] __initdata = { 235static struct usb_descriptor_header *acm_hs_function[] __initdata = {
236 (struct usb_descriptor_header *) &acm_iad_descriptor,
219 (struct usb_descriptor_header *) &acm_control_interface_desc, 237 (struct usb_descriptor_header *) &acm_control_interface_desc,
220 (struct usb_descriptor_header *) &acm_header_desc, 238 (struct usb_descriptor_header *) &acm_header_desc,
221 (struct usb_descriptor_header *) &acm_call_mgmt_descriptor, 239 (struct usb_descriptor_header *) &acm_call_mgmt_descriptor,
@@ -232,11 +250,13 @@ static struct usb_descriptor_header *acm_hs_function[] __initdata = {
232 250
233#define ACM_CTRL_IDX 0 251#define ACM_CTRL_IDX 0
234#define ACM_DATA_IDX 1 252#define ACM_DATA_IDX 1
253#define ACM_IAD_IDX 2
235 254
236/* static strings, in UTF-8 */ 255/* static strings, in UTF-8 */
237static struct usb_string acm_string_defs[] = { 256static struct usb_string acm_string_defs[] = {
238 [ACM_CTRL_IDX].s = "CDC Abstract Control Model (ACM)", 257 [ACM_CTRL_IDX].s = "CDC Abstract Control Model (ACM)",
239 [ACM_DATA_IDX].s = "CDC ACM Data", 258 [ACM_DATA_IDX].s = "CDC ACM Data",
259 [ACM_IAD_IDX ].s = "CDC Serial",
240 { /* ZEROES END LIST */ }, 260 { /* ZEROES END LIST */ },
241}; 261};
242 262
@@ -563,6 +583,7 @@ acm_bind(struct usb_configuration *c, struct usb_function *f)
563 if (status < 0) 583 if (status < 0)
564 goto fail; 584 goto fail;
565 acm->ctrl_id = status; 585 acm->ctrl_id = status;
586 acm_iad_descriptor.bFirstInterface = status;
566 587
567 acm_control_interface_desc.bInterfaceNumber = status; 588 acm_control_interface_desc.bInterfaceNumber = status;
568 acm_union_desc .bMasterInterface0 = status; 589 acm_union_desc .bMasterInterface0 = status;
@@ -732,6 +753,13 @@ int __init acm_bind_config(struct usb_configuration *c, u8 port_num)
732 acm_string_defs[ACM_DATA_IDX].id = status; 753 acm_string_defs[ACM_DATA_IDX].id = status;
733 754
734 acm_data_interface_desc.iInterface = status; 755 acm_data_interface_desc.iInterface = status;
756
757 status = usb_string_id(c->cdev);
758 if (status < 0)
759 return status;
760 acm_string_defs[ACM_IAD_IDX].id = status;
761
762 acm_iad_descriptor.iFunction = status;
735 } 763 }
736 764
737 /* allocate and initialize one new instance */ 765 /* allocate and initialize one new instance */
diff --git a/drivers/usb/gadget/f_audio.c b/drivers/usb/gadget/f_audio.c
index 98e9bb977291..c43c89ffa2c8 100644
--- a/drivers/usb/gadget/f_audio.c
+++ b/drivers/usb/gadget/f_audio.c
@@ -445,6 +445,70 @@ static int audio_get_intf_req(struct usb_function *f,
445 return len; 445 return len;
446} 446}
447 447
448static int audio_set_endpoint_req(struct usb_function *f,
449 const struct usb_ctrlrequest *ctrl)
450{
451 struct usb_composite_dev *cdev = f->config->cdev;
452 int value = -EOPNOTSUPP;
453 u16 ep = le16_to_cpu(ctrl->wIndex);
454 u16 len = le16_to_cpu(ctrl->wLength);
455 u16 w_value = le16_to_cpu(ctrl->wValue);
456
457 DBG(cdev, "bRequest 0x%x, w_value 0x%04x, len %d, endpoint %d\n",
458 ctrl->bRequest, w_value, len, ep);
459
460 switch (ctrl->bRequest) {
461 case UAC_SET_CUR:
462 value = 0;
463 break;
464
465 case UAC_SET_MIN:
466 break;
467
468 case UAC_SET_MAX:
469 break;
470
471 case UAC_SET_RES:
472 break;
473
474 case UAC_SET_MEM:
475 break;
476
477 default:
478 break;
479 }
480
481 return value;
482}
483
484static int audio_get_endpoint_req(struct usb_function *f,
485 const struct usb_ctrlrequest *ctrl)
486{
487 struct usb_composite_dev *cdev = f->config->cdev;
488 int value = -EOPNOTSUPP;
489 u8 ep = ((le16_to_cpu(ctrl->wIndex) >> 8) & 0xFF);
490 u16 len = le16_to_cpu(ctrl->wLength);
491 u16 w_value = le16_to_cpu(ctrl->wValue);
492
493 DBG(cdev, "bRequest 0x%x, w_value 0x%04x, len %d, endpoint %d\n",
494 ctrl->bRequest, w_value, len, ep);
495
496 switch (ctrl->bRequest) {
497 case UAC_GET_CUR:
498 case UAC_GET_MIN:
499 case UAC_GET_MAX:
500 case UAC_GET_RES:
501 value = 3;
502 break;
503 case UAC_GET_MEM:
504 break;
505 default:
506 break;
507 }
508
509 return value;
510}
511
448static int 512static int
449f_audio_setup(struct usb_function *f, const struct usb_ctrlrequest *ctrl) 513f_audio_setup(struct usb_function *f, const struct usb_ctrlrequest *ctrl)
450{ 514{
@@ -455,8 +519,8 @@ f_audio_setup(struct usb_function *f, const struct usb_ctrlrequest *ctrl)
455 u16 w_value = le16_to_cpu(ctrl->wValue); 519 u16 w_value = le16_to_cpu(ctrl->wValue);
456 u16 w_length = le16_to_cpu(ctrl->wLength); 520 u16 w_length = le16_to_cpu(ctrl->wLength);
457 521
458 /* composite driver infrastructure handles everything except 522 /* composite driver infrastructure handles everything; interface
459 * Audio class messages; interface activation uses set_alt(). 523 * activation uses set_alt().
460 */ 524 */
461 switch (ctrl->bRequestType) { 525 switch (ctrl->bRequestType) {
462 case USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE: 526 case USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE:
@@ -467,6 +531,14 @@ f_audio_setup(struct usb_function *f, const struct usb_ctrlrequest *ctrl)
467 value = audio_get_intf_req(f, ctrl); 531 value = audio_get_intf_req(f, ctrl);
468 break; 532 break;
469 533
534 case USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_ENDPOINT:
535 value = audio_set_endpoint_req(f, ctrl);
536 break;
537
538 case USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_ENDPOINT:
539 value = audio_get_endpoint_req(f, ctrl);
540 break;
541
470 default: 542 default:
471 ERROR(cdev, "invalid control req%02x.%02x v%04x i%04x l%d\n", 543 ERROR(cdev, "invalid control req%02x.%02x v%04x i%04x l%d\n",
472 ctrl->bRequestType, ctrl->bRequest, 544 ctrl->bRequestType, ctrl->bRequest,
diff --git a/drivers/usb/gadget/f_mass_storage.c b/drivers/usb/gadget/f_mass_storage.c
new file mode 100644
index 000000000000..a37640eba434
--- /dev/null
+++ b/drivers/usb/gadget/f_mass_storage.c
@@ -0,0 +1,3091 @@
1/*
2 * f_mass_storage.c -- Mass Storage USB Composite Function
3 *
4 * Copyright (C) 2003-2008 Alan Stern
5 * Copyright (C) 2009 Samsung Electronics
6 * Author: Michal Nazarewicz <m.nazarewicz@samsung.com>
7 * All rights reserved.
8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions
11 * are met:
12 * 1. Redistributions of source code must retain the above copyright
13 * notice, this list of conditions, and the following disclaimer,
14 * without modification.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
18 * 3. The names of the above-listed copyright holders may not be used
19 * to endorse or promote products derived from this software without
20 * specific prior written permission.
21 *
22 * ALTERNATIVELY, this software may be distributed under the terms of the
23 * GNU General Public License ("GPL") as published by the Free Software
24 * Foundation, either version 2 of that License or (at your option) any
25 * later version.
26 *
27 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
28 * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
29 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
30 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
31 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
32 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
33 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
34 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
35 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
36 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
37 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
38 */
39
40
41/*
42 * The Mass Storage Function acts as a USB Mass Storage device,
43 * appearing to the host as a disk drive or as a CD-ROM drive. In
44 * addition to providing an example of a genuinely useful composite
45 * function for a USB device, it also illustrates a technique of
46 * double-buffering for increased throughput.
47 *
48 * Function supports multiple logical units (LUNs). Backing storage
49 * for each LUN is provided by a regular file or a block device.
50 * Access for each LUN can be limited to read-only. Moreover, the
51 * function can indicate that LUN is removable and/or CD-ROM. (The
52 * later implies read-only access.)
53 *
54 * MSF is configured by specifying a fsg_config structure. It has the
55 * following fields:
56 *
57 * nluns Number of LUNs function have (anywhere from 1
58 * to FSG_MAX_LUNS which is 8).
59 * luns An array of LUN configuration values. This
60 * should be filled for each LUN that
61 * function will include (ie. for "nluns"
62 * LUNs). Each element of the array has
63 * the following fields:
64 * ->filename The path to the backing file for the LUN.
65 * Required if LUN is not marked as
66 * removable.
67 * ->ro Flag specifying access to the LUN shall be
68 * read-only. This is implied if CD-ROM
69 * emulation is enabled as well as when
70 * it was impossible to open "filename"
71 * in R/W mode.
72 * ->removable Flag specifying that LUN shall be indicated as
73 * being removable.
74 * ->cdrom Flag specifying that LUN shall be reported as
75 * being a CD-ROM.
76 *
77 * lun_name_format A printf-like format for names of the LUN
78 * devices. This determines how the
79 * directory in sysfs will be named.
80 * Unless you are using several MSFs in
81 * a single gadget (as opposed to single
82 * MSF in many configurations) you may
83 * leave it as NULL (in which case
84 * "lun%d" will be used). In the format
85 * you can use "%d" to index LUNs for
86 * MSF's with more than one LUN. (Beware
87 * that there is only one integer given
88 * as an argument for the format and
89 * specifying invalid format may cause
90 * unspecified behaviour.)
91 * thread_name Name of the kernel thread process used by the
92 * MSF. You can safely set it to NULL
93 * (in which case default "file-storage"
94 * will be used).
95 *
96 * vendor_name
97 * product_name
98 * release Information used as a reply to INQUIRY
99 * request. To use default set to NULL,
100 * NULL, 0xffff respectively. The first
101 * field should be 8 and the second 16
102 * characters or less.
103 *
104 * can_stall Set to permit function to halt bulk endpoints.
105 * Disabled on some USB devices known not
106 * to work correctly. You should set it
107 * to true.
108 *
109 * If "removable" is not set for a LUN then a backing file must be
110 * specified. If it is set, then NULL filename means the LUN's medium
111 * is not loaded (an empty string as "filename" in the fsg_config
112 * structure causes error). The CD-ROM emulation includes a single
113 * data track and no audio tracks; hence there need be only one
114 * backing file per LUN. Note also that the CD-ROM block length is
115 * set to 512 rather than the more common value 2048.
116 *
117 *
118 * MSF includes support for module parameters. If gadget using it
119 * decides to use it, the following module parameters will be
120 * available:
121 *
122 * file=filename[,filename...]
123 * Names of the files or block devices used for
124 * backing storage.
125 * ro=b[,b...] Default false, boolean for read-only access.
126 * removable=b[,b...]
127 * Default true, boolean for removable media.
128 * cdrom=b[,b...] Default false, boolean for whether to emulate
129 * a CD-ROM drive.
130 * luns=N Default N = number of filenames, number of
131 * LUNs to support.
132 * stall Default determined according to the type of
133 * USB device controller (usually true),
134 * boolean to permit the driver to halt
135 * bulk endpoints.
136 *
137 * The module parameters may be prefixed with some string. You need
138 * to consult gadget's documentation or source to verify whether it is
139 * using those module parameters and if it does what are the prefixes
140 * (look for FSG_MODULE_PARAMETERS() macro usage, what's inside it is
141 * the prefix).
142 *
143 *
144 * Requirements are modest; only a bulk-in and a bulk-out endpoint are
145 * needed. The memory requirement amounts to two 16K buffers, size
146 * configurable by a parameter. Support is included for both
147 * full-speed and high-speed operation.
148 *
149 * Note that the driver is slightly non-portable in that it assumes a
150 * single memory/DMA buffer will be useable for bulk-in, bulk-out, and
151 * interrupt-in endpoints. With most device controllers this isn't an
152 * issue, but there may be some with hardware restrictions that prevent
153 * a buffer from being used by more than one endpoint.
154 *
155 *
156 * The pathnames of the backing files and the ro settings are
157 * available in the attribute files "file" and "ro" in the lun<n> (or
158 * to be more precise in a directory which name comes from
159 * "lun_name_format" option!) subdirectory of the gadget's sysfs
160 * directory. If the "removable" option is set, writing to these
161 * files will simulate ejecting/loading the medium (writing an empty
162 * line means eject) and adjusting a write-enable tab. Changes to the
163 * ro setting are not allowed when the medium is loaded or if CD-ROM
164 * emulation is being used.
165 *
166 *
167 * This function is heavily based on "File-backed Storage Gadget" by
168 * Alan Stern which in turn is heavily based on "Gadget Zero" by David
169 * Brownell. The driver's SCSI command interface was based on the
170 * "Information technology - Small Computer System Interface - 2"
171 * document from X3T9.2 Project 375D, Revision 10L, 7-SEP-93,
172 * available at <http://www.t10.org/ftp/t10/drafts/s2/s2-r10l.pdf>.
173 * The single exception is opcode 0x23 (READ FORMAT CAPACITIES), which
174 * was based on the "Universal Serial Bus Mass Storage Class UFI
175 * Command Specification" document, Revision 1.0, December 14, 1998,
176 * available at
177 * <http://www.usb.org/developers/devclass_docs/usbmass-ufi10.pdf>.
178 */
179
180
181/*
182 * Driver Design
183 *
184 * The MSF is fairly straightforward. There is a main kernel
185 * thread that handles most of the work. Interrupt routines field
186 * callbacks from the controller driver: bulk- and interrupt-request
187 * completion notifications, endpoint-0 events, and disconnect events.
188 * Completion events are passed to the main thread by wakeup calls. Many
189 * ep0 requests are handled at interrupt time, but SetInterface,
190 * SetConfiguration, and device reset requests are forwarded to the
191 * thread in the form of "exceptions" using SIGUSR1 signals (since they
192 * should interrupt any ongoing file I/O operations).
193 *
194 * The thread's main routine implements the standard command/data/status
195 * parts of a SCSI interaction. It and its subroutines are full of tests
196 * for pending signals/exceptions -- all this polling is necessary since
197 * the kernel has no setjmp/longjmp equivalents. (Maybe this is an
198 * indication that the driver really wants to be running in userspace.)
199 * An important point is that so long as the thread is alive it keeps an
200 * open reference to the backing file. This will prevent unmounting
201 * the backing file's underlying filesystem and could cause problems
202 * during system shutdown, for example. To prevent such problems, the
203 * thread catches INT, TERM, and KILL signals and converts them into
204 * an EXIT exception.
205 *
206 * In normal operation the main thread is started during the gadget's
207 * fsg_bind() callback and stopped during fsg_unbind(). But it can
208 * also exit when it receives a signal, and there's no point leaving
209 * the gadget running when the thread is dead. At of this moment, MSF
210 * provides no way to deregister the gadget when thread dies -- maybe
211 * a callback functions is needed.
212 *
213 * To provide maximum throughput, the driver uses a circular pipeline of
214 * buffer heads (struct fsg_buffhd). In principle the pipeline can be
215 * arbitrarily long; in practice the benefits don't justify having more
216 * than 2 stages (i.e., double buffering). But it helps to think of the
217 * pipeline as being a long one. Each buffer head contains a bulk-in and
218 * a bulk-out request pointer (since the buffer can be used for both
219 * output and input -- directions always are given from the host's
220 * point of view) as well as a pointer to the buffer and various state
221 * variables.
222 *
223 * Use of the pipeline follows a simple protocol. There is a variable
224 * (fsg->next_buffhd_to_fill) that points to the next buffer head to use.
225 * At any time that buffer head may still be in use from an earlier
226 * request, so each buffer head has a state variable indicating whether
227 * it is EMPTY, FULL, or BUSY. Typical use involves waiting for the
228 * buffer head to be EMPTY, filling the buffer either by file I/O or by
229 * USB I/O (during which the buffer head is BUSY), and marking the buffer
230 * head FULL when the I/O is complete. Then the buffer will be emptied
231 * (again possibly by USB I/O, during which it is marked BUSY) and
232 * finally marked EMPTY again (possibly by a completion routine).
233 *
234 * A module parameter tells the driver to avoid stalling the bulk
235 * endpoints wherever the transport specification allows. This is
236 * necessary for some UDCs like the SuperH, which cannot reliably clear a
237 * halt on a bulk endpoint. However, under certain circumstances the
238 * Bulk-only specification requires a stall. In such cases the driver
239 * will halt the endpoint and set a flag indicating that it should clear
240 * the halt in software during the next device reset. Hopefully this
241 * will permit everything to work correctly. Furthermore, although the
242 * specification allows the bulk-out endpoint to halt when the host sends
243 * too much data, implementing this would cause an unavoidable race.
244 * The driver will always use the "no-stall" approach for OUT transfers.
245 *
246 * One subtle point concerns sending status-stage responses for ep0
247 * requests. Some of these requests, such as device reset, can involve
248 * interrupting an ongoing file I/O operation, which might take an
249 * arbitrarily long time. During that delay the host might give up on
250 * the original ep0 request and issue a new one. When that happens the
251 * driver should not notify the host about completion of the original
252 * request, as the host will no longer be waiting for it. So the driver
253 * assigns to each ep0 request a unique tag, and it keeps track of the
254 * tag value of the request associated with a long-running exception
255 * (device-reset, interface-change, or configuration-change). When the
256 * exception handler is finished, the status-stage response is submitted
257 * only if the current ep0 request tag is equal to the exception request
258 * tag. Thus only the most recently received ep0 request will get a
259 * status-stage response.
260 *
261 * Warning: This driver source file is too long. It ought to be split up
262 * into a header file plus about 3 separate .c files, to handle the details
263 * of the Gadget, USB Mass Storage, and SCSI protocols.
264 */
265
266
267/* #define VERBOSE_DEBUG */
268/* #define DUMP_MSGS */
269
270
271#include <linux/blkdev.h>
272#include <linux/completion.h>
273#include <linux/dcache.h>
274#include <linux/delay.h>
275#include <linux/device.h>
276#include <linux/fcntl.h>
277#include <linux/file.h>
278#include <linux/fs.h>
279#include <linux/kref.h>
280#include <linux/kthread.h>
281#include <linux/limits.h>
282#include <linux/rwsem.h>
283#include <linux/slab.h>
284#include <linux/spinlock.h>
285#include <linux/string.h>
286#include <linux/freezer.h>
287#include <linux/utsname.h>
288
289#include <linux/usb/ch9.h>
290#include <linux/usb/gadget.h>
291
292#include "gadget_chips.h"
293
294
295
296/*------------------------------------------------------------------------*/
297
298#define FSG_DRIVER_DESC "Mass Storage Function"
299#define FSG_DRIVER_VERSION "2009/09/11"
300
301static const char fsg_string_interface[] = "Mass Storage";
302
303
304#define FSG_NO_INTR_EP 1
305#define FSG_BUFFHD_STATIC_BUFFER 1
306#define FSG_NO_DEVICE_STRINGS 1
307#define FSG_NO_OTG 1
308#define FSG_NO_INTR_EP 1
309
310#include "storage_common.c"
311
312
313/*-------------------------------------------------------------------------*/
314
315struct fsg_dev;
316
317
318/* Data shared by all the FSG instances. */
319struct fsg_common {
320 struct usb_gadget *gadget;
321 struct fsg_dev *fsg;
322 struct fsg_dev *prev_fsg;
323
324 /* filesem protects: backing files in use */
325 struct rw_semaphore filesem;
326
327 /* lock protects: state, all the req_busy's */
328 spinlock_t lock;
329
330 struct usb_ep *ep0; /* Copy of gadget->ep0 */
331 struct usb_request *ep0req; /* Copy of cdev->req */
332 unsigned int ep0_req_tag;
333 const char *ep0req_name;
334
335 struct fsg_buffhd *next_buffhd_to_fill;
336 struct fsg_buffhd *next_buffhd_to_drain;
337 struct fsg_buffhd buffhds[FSG_NUM_BUFFERS];
338
339 int cmnd_size;
340 u8 cmnd[MAX_COMMAND_SIZE];
341
342 unsigned int nluns;
343 unsigned int lun;
344 struct fsg_lun *luns;
345 struct fsg_lun *curlun;
346
347 unsigned int bulk_out_maxpacket;
348 enum fsg_state state; /* For exception handling */
349 unsigned int exception_req_tag;
350
351 u8 config, new_config;
352 enum data_direction data_dir;
353 u32 data_size;
354 u32 data_size_from_cmnd;
355 u32 tag;
356 u32 residue;
357 u32 usb_amount_left;
358
359 unsigned int can_stall:1;
360 unsigned int free_storage_on_release:1;
361 unsigned int phase_error:1;
362 unsigned int short_packet_received:1;
363 unsigned int bad_lun_okay:1;
364 unsigned int running:1;
365
366 int thread_wakeup_needed;
367 struct completion thread_notifier;
368 struct task_struct *thread_task;
369
370 /* Callback function to call when thread exits. */
371 void (*thread_exits)(struct fsg_common *common);
372 /* Gadget's private data. */
373 void *private_data;
374
375 /* Vendor (8 chars), product (16 chars), release (4
376 * hexadecimal digits) and NUL byte */
377 char inquiry_string[8 + 16 + 4 + 1];
378
379 struct kref ref;
380};
381
382
383struct fsg_config {
384 unsigned nluns;
385 struct fsg_lun_config {
386 const char *filename;
387 char ro;
388 char removable;
389 char cdrom;
390 } luns[FSG_MAX_LUNS];
391
392 const char *lun_name_format;
393 const char *thread_name;
394
395 /* Callback function to call when thread exits. */
396 void (*thread_exits)(struct fsg_common *common);
397 /* Gadget's private data. */
398 void *private_data;
399
400 const char *vendor_name; /* 8 characters or less */
401 const char *product_name; /* 16 characters or less */
402 u16 release;
403
404 char can_stall;
405};
406
407
408struct fsg_dev {
409 struct usb_function function;
410 struct usb_gadget *gadget; /* Copy of cdev->gadget */
411 struct fsg_common *common;
412
413 u16 interface_number;
414
415 unsigned int bulk_in_enabled:1;
416 unsigned int bulk_out_enabled:1;
417
418 unsigned long atomic_bitflags;
419#define IGNORE_BULK_OUT 0
420
421 struct usb_ep *bulk_in;
422 struct usb_ep *bulk_out;
423};
424
425
426static inline int __fsg_is_set(struct fsg_common *common,
427 const char *func, unsigned line)
428{
429 if (common->fsg)
430 return 1;
431 ERROR(common, "common->fsg is NULL in %s at %u\n", func, line);
432 return 0;
433}
434
435#define fsg_is_set(common) likely(__fsg_is_set(common, __func__, __LINE__))
436
437
438static inline struct fsg_dev *fsg_from_func(struct usb_function *f)
439{
440 return container_of(f, struct fsg_dev, function);
441}
442
443
444typedef void (*fsg_routine_t)(struct fsg_dev *);
445
446static int exception_in_progress(struct fsg_common *common)
447{
448 return common->state > FSG_STATE_IDLE;
449}
450
451/* Make bulk-out requests be divisible by the maxpacket size */
452static void set_bulk_out_req_length(struct fsg_common *common,
453 struct fsg_buffhd *bh, unsigned int length)
454{
455 unsigned int rem;
456
457 bh->bulk_out_intended_length = length;
458 rem = length % common->bulk_out_maxpacket;
459 if (rem > 0)
460 length += common->bulk_out_maxpacket - rem;
461 bh->outreq->length = length;
462}
463
464/*-------------------------------------------------------------------------*/
465
466static int fsg_set_halt(struct fsg_dev *fsg, struct usb_ep *ep)
467{
468 const char *name;
469
470 if (ep == fsg->bulk_in)
471 name = "bulk-in";
472 else if (ep == fsg->bulk_out)
473 name = "bulk-out";
474 else
475 name = ep->name;
476 DBG(fsg, "%s set halt\n", name);
477 return usb_ep_set_halt(ep);
478}
479
480
481/*-------------------------------------------------------------------------*/
482
483/* These routines may be called in process context or in_irq */
484
485/* Caller must hold fsg->lock */
486static void wakeup_thread(struct fsg_common *common)
487{
488 /* Tell the main thread that something has happened */
489 common->thread_wakeup_needed = 1;
490 if (common->thread_task)
491 wake_up_process(common->thread_task);
492}
493
494
495static void raise_exception(struct fsg_common *common, enum fsg_state new_state)
496{
497 unsigned long flags;
498
499 /* Do nothing if a higher-priority exception is already in progress.
500 * If a lower-or-equal priority exception is in progress, preempt it
501 * and notify the main thread by sending it a signal. */
502 spin_lock_irqsave(&common->lock, flags);
503 if (common->state <= new_state) {
504 common->exception_req_tag = common->ep0_req_tag;
505 common->state = new_state;
506 if (common->thread_task)
507 send_sig_info(SIGUSR1, SEND_SIG_FORCED,
508 common->thread_task);
509 }
510 spin_unlock_irqrestore(&common->lock, flags);
511}
512
513
514/*-------------------------------------------------------------------------*/
515
516static int ep0_queue(struct fsg_common *common)
517{
518 int rc;
519
520 rc = usb_ep_queue(common->ep0, common->ep0req, GFP_ATOMIC);
521 common->ep0->driver_data = common;
522 if (rc != 0 && rc != -ESHUTDOWN) {
523 /* We can't do much more than wait for a reset */
524 WARNING(common, "error in submission: %s --> %d\n",
525 common->ep0->name, rc);
526 }
527 return rc;
528}
529
530/*-------------------------------------------------------------------------*/
531
532/* Bulk and interrupt endpoint completion handlers.
533 * These always run in_irq. */
534
535static void bulk_in_complete(struct usb_ep *ep, struct usb_request *req)
536{
537 struct fsg_common *common = ep->driver_data;
538 struct fsg_buffhd *bh = req->context;
539
540 if (req->status || req->actual != req->length)
541 DBG(common, "%s --> %d, %u/%u\n", __func__,
542 req->status, req->actual, req->length);
543 if (req->status == -ECONNRESET) /* Request was cancelled */
544 usb_ep_fifo_flush(ep);
545
546 /* Hold the lock while we update the request and buffer states */
547 smp_wmb();
548 spin_lock(&common->lock);
549 bh->inreq_busy = 0;
550 bh->state = BUF_STATE_EMPTY;
551 wakeup_thread(common);
552 spin_unlock(&common->lock);
553}
554
555static void bulk_out_complete(struct usb_ep *ep, struct usb_request *req)
556{
557 struct fsg_common *common = ep->driver_data;
558 struct fsg_buffhd *bh = req->context;
559
560 dump_msg(common, "bulk-out", req->buf, req->actual);
561 if (req->status || req->actual != bh->bulk_out_intended_length)
562 DBG(common, "%s --> %d, %u/%u\n", __func__,
563 req->status, req->actual,
564 bh->bulk_out_intended_length);
565 if (req->status == -ECONNRESET) /* Request was cancelled */
566 usb_ep_fifo_flush(ep);
567
568 /* Hold the lock while we update the request and buffer states */
569 smp_wmb();
570 spin_lock(&common->lock);
571 bh->outreq_busy = 0;
572 bh->state = BUF_STATE_FULL;
573 wakeup_thread(common);
574 spin_unlock(&common->lock);
575}
576
577
578/*-------------------------------------------------------------------------*/
579
580/* Ep0 class-specific handlers. These always run in_irq. */
581
582static int fsg_setup(struct usb_function *f,
583 const struct usb_ctrlrequest *ctrl)
584{
585 struct fsg_dev *fsg = fsg_from_func(f);
586 struct usb_request *req = fsg->common->ep0req;
587 u16 w_index = le16_to_cpu(ctrl->wIndex);
588 u16 w_value = le16_to_cpu(ctrl->wValue);
589 u16 w_length = le16_to_cpu(ctrl->wLength);
590
591 if (!fsg->common->config)
592 return -EOPNOTSUPP;
593
594 switch (ctrl->bRequest) {
595
596 case USB_BULK_RESET_REQUEST:
597 if (ctrl->bRequestType !=
598 (USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE))
599 break;
600 if (w_index != fsg->interface_number || w_value != 0)
601 return -EDOM;
602
603 /* Raise an exception to stop the current operation
604 * and reinitialize our state. */
605 DBG(fsg, "bulk reset request\n");
606 raise_exception(fsg->common, FSG_STATE_RESET);
607 return DELAYED_STATUS;
608
609 case USB_BULK_GET_MAX_LUN_REQUEST:
610 if (ctrl->bRequestType !=
611 (USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE))
612 break;
613 if (w_index != fsg->interface_number || w_value != 0)
614 return -EDOM;
615 VDBG(fsg, "get max LUN\n");
616 *(u8 *) req->buf = fsg->common->nluns - 1;
617 return 1;
618 }
619
620 VDBG(fsg,
621 "unknown class-specific control req "
622 "%02x.%02x v%04x i%04x l%u\n",
623 ctrl->bRequestType, ctrl->bRequest,
624 le16_to_cpu(ctrl->wValue), w_index, w_length);
625 return -EOPNOTSUPP;
626}
627
628
629/*-------------------------------------------------------------------------*/
630
631/* All the following routines run in process context */
632
633
634/* Use this for bulk or interrupt transfers, not ep0 */
635static void start_transfer(struct fsg_dev *fsg, struct usb_ep *ep,
636 struct usb_request *req, int *pbusy,
637 enum fsg_buffer_state *state)
638{
639 int rc;
640
641 if (ep == fsg->bulk_in)
642 dump_msg(fsg, "bulk-in", req->buf, req->length);
643
644 spin_lock_irq(&fsg->common->lock);
645 *pbusy = 1;
646 *state = BUF_STATE_BUSY;
647 spin_unlock_irq(&fsg->common->lock);
648 rc = usb_ep_queue(ep, req, GFP_KERNEL);
649 if (rc != 0) {
650 *pbusy = 0;
651 *state = BUF_STATE_EMPTY;
652
653 /* We can't do much more than wait for a reset */
654
655 /* Note: currently the net2280 driver fails zero-length
656 * submissions if DMA is enabled. */
657 if (rc != -ESHUTDOWN && !(rc == -EOPNOTSUPP &&
658 req->length == 0))
659 WARNING(fsg, "error in submission: %s --> %d\n",
660 ep->name, rc);
661 }
662}
663
664#define START_TRANSFER_OR(common, ep_name, req, pbusy, state) \
665 if (fsg_is_set(common)) \
666 start_transfer((common)->fsg, (common)->fsg->ep_name, \
667 req, pbusy, state); \
668 else
669
670#define START_TRANSFER(common, ep_name, req, pbusy, state) \
671 START_TRANSFER_OR(common, ep_name, req, pbusy, state) (void)0
672
673
674
675static int sleep_thread(struct fsg_common *common)
676{
677 int rc = 0;
678
679 /* Wait until a signal arrives or we are woken up */
680 for (;;) {
681 try_to_freeze();
682 set_current_state(TASK_INTERRUPTIBLE);
683 if (signal_pending(current)) {
684 rc = -EINTR;
685 break;
686 }
687 if (common->thread_wakeup_needed)
688 break;
689 schedule();
690 }
691 __set_current_state(TASK_RUNNING);
692 common->thread_wakeup_needed = 0;
693 return rc;
694}
695
696
697/*-------------------------------------------------------------------------*/
698
699static int do_read(struct fsg_common *common)
700{
701 struct fsg_lun *curlun = common->curlun;
702 u32 lba;
703 struct fsg_buffhd *bh;
704 int rc;
705 u32 amount_left;
706 loff_t file_offset, file_offset_tmp;
707 unsigned int amount;
708 unsigned int partial_page;
709 ssize_t nread;
710
711 /* Get the starting Logical Block Address and check that it's
712 * not too big */
713 if (common->cmnd[0] == SC_READ_6)
714 lba = get_unaligned_be24(&common->cmnd[1]);
715 else {
716 lba = get_unaligned_be32(&common->cmnd[2]);
717
718 /* We allow DPO (Disable Page Out = don't save data in the
719 * cache) and FUA (Force Unit Access = don't read from the
720 * cache), but we don't implement them. */
721 if ((common->cmnd[1] & ~0x18) != 0) {
722 curlun->sense_data = SS_INVALID_FIELD_IN_CDB;
723 return -EINVAL;
724 }
725 }
726 if (lba >= curlun->num_sectors) {
727 curlun->sense_data = SS_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE;
728 return -EINVAL;
729 }
730 file_offset = ((loff_t) lba) << 9;
731
732 /* Carry out the file reads */
733 amount_left = common->data_size_from_cmnd;
734 if (unlikely(amount_left == 0))
735 return -EIO; /* No default reply */
736
737 for (;;) {
738
739 /* Figure out how much we need to read:
740 * Try to read the remaining amount.
741 * But don't read more than the buffer size.
742 * And don't try to read past the end of the file.
743 * Finally, if we're not at a page boundary, don't read past
744 * the next page.
745 * If this means reading 0 then we were asked to read past
746 * the end of file. */
747 amount = min(amount_left, FSG_BUFLEN);
748 amount = min((loff_t) amount,
749 curlun->file_length - file_offset);
750 partial_page = file_offset & (PAGE_CACHE_SIZE - 1);
751 if (partial_page > 0)
752 amount = min(amount, (unsigned int) PAGE_CACHE_SIZE -
753 partial_page);
754
755 /* Wait for the next buffer to become available */
756 bh = common->next_buffhd_to_fill;
757 while (bh->state != BUF_STATE_EMPTY) {
758 rc = sleep_thread(common);
759 if (rc)
760 return rc;
761 }
762
763 /* If we were asked to read past the end of file,
764 * end with an empty buffer. */
765 if (amount == 0) {
766 curlun->sense_data =
767 SS_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE;
768 curlun->sense_data_info = file_offset >> 9;
769 curlun->info_valid = 1;
770 bh->inreq->length = 0;
771 bh->state = BUF_STATE_FULL;
772 break;
773 }
774
775 /* Perform the read */
776 file_offset_tmp = file_offset;
777 nread = vfs_read(curlun->filp,
778 (char __user *) bh->buf,
779 amount, &file_offset_tmp);
780 VLDBG(curlun, "file read %u @ %llu -> %d\n", amount,
781 (unsigned long long) file_offset,
782 (int) nread);
783 if (signal_pending(current))
784 return -EINTR;
785
786 if (nread < 0) {
787 LDBG(curlun, "error in file read: %d\n",
788 (int) nread);
789 nread = 0;
790 } else if (nread < amount) {
791 LDBG(curlun, "partial file read: %d/%u\n",
792 (int) nread, amount);
793 nread -= (nread & 511); /* Round down to a block */
794 }
795 file_offset += nread;
796 amount_left -= nread;
797 common->residue -= nread;
798 bh->inreq->length = nread;
799 bh->state = BUF_STATE_FULL;
800
801 /* If an error occurred, report it and its position */
802 if (nread < amount) {
803 curlun->sense_data = SS_UNRECOVERED_READ_ERROR;
804 curlun->sense_data_info = file_offset >> 9;
805 curlun->info_valid = 1;
806 break;
807 }
808
809 if (amount_left == 0)
810 break; /* No more left to read */
811
812 /* Send this buffer and go read some more */
813 bh->inreq->zero = 0;
814 START_TRANSFER_OR(common, bulk_in, bh->inreq,
815 &bh->inreq_busy, &bh->state)
816 /* Don't know what to do if
817 * common->fsg is NULL */
818 return -EIO;
819 common->next_buffhd_to_fill = bh->next;
820 }
821
822 return -EIO; /* No default reply */
823}
824
825
826/*-------------------------------------------------------------------------*/
827
828static int do_write(struct fsg_common *common)
829{
830 struct fsg_lun *curlun = common->curlun;
831 u32 lba;
832 struct fsg_buffhd *bh;
833 int get_some_more;
834 u32 amount_left_to_req, amount_left_to_write;
835 loff_t usb_offset, file_offset, file_offset_tmp;
836 unsigned int amount;
837 unsigned int partial_page;
838 ssize_t nwritten;
839 int rc;
840
841 if (curlun->ro) {
842 curlun->sense_data = SS_WRITE_PROTECTED;
843 return -EINVAL;
844 }
845 spin_lock(&curlun->filp->f_lock);
846 curlun->filp->f_flags &= ~O_SYNC; /* Default is not to wait */
847 spin_unlock(&curlun->filp->f_lock);
848
849 /* Get the starting Logical Block Address and check that it's
850 * not too big */
851 if (common->cmnd[0] == SC_WRITE_6)
852 lba = get_unaligned_be24(&common->cmnd[1]);
853 else {
854 lba = get_unaligned_be32(&common->cmnd[2]);
855
856 /* We allow DPO (Disable Page Out = don't save data in the
857 * cache) and FUA (Force Unit Access = write directly to the
858 * medium). We don't implement DPO; we implement FUA by
859 * performing synchronous output. */
860 if (common->cmnd[1] & ~0x18) {
861 curlun->sense_data = SS_INVALID_FIELD_IN_CDB;
862 return -EINVAL;
863 }
864 if (common->cmnd[1] & 0x08) { /* FUA */
865 spin_lock(&curlun->filp->f_lock);
866 curlun->filp->f_flags |= O_SYNC;
867 spin_unlock(&curlun->filp->f_lock);
868 }
869 }
870 if (lba >= curlun->num_sectors) {
871 curlun->sense_data = SS_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE;
872 return -EINVAL;
873 }
874
875 /* Carry out the file writes */
876 get_some_more = 1;
877 file_offset = usb_offset = ((loff_t) lba) << 9;
878 amount_left_to_req = common->data_size_from_cmnd;
879 amount_left_to_write = common->data_size_from_cmnd;
880
881 while (amount_left_to_write > 0) {
882
883 /* Queue a request for more data from the host */
884 bh = common->next_buffhd_to_fill;
885 if (bh->state == BUF_STATE_EMPTY && get_some_more) {
886
887 /* Figure out how much we want to get:
888 * Try to get the remaining amount.
889 * But don't get more than the buffer size.
890 * And don't try to go past the end of the file.
891 * If we're not at a page boundary,
892 * don't go past the next page.
893 * If this means getting 0, then we were asked
894 * to write past the end of file.
895 * Finally, round down to a block boundary. */
896 amount = min(amount_left_to_req, FSG_BUFLEN);
897 amount = min((loff_t) amount, curlun->file_length -
898 usb_offset);
899 partial_page = usb_offset & (PAGE_CACHE_SIZE - 1);
900 if (partial_page > 0)
901 amount = min(amount,
902 (unsigned int) PAGE_CACHE_SIZE - partial_page);
903
904 if (amount == 0) {
905 get_some_more = 0;
906 curlun->sense_data =
907 SS_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE;
908 curlun->sense_data_info = usb_offset >> 9;
909 curlun->info_valid = 1;
910 continue;
911 }
912 amount -= (amount & 511);
913 if (amount == 0) {
914
915 /* Why were we were asked to transfer a
916 * partial block? */
917 get_some_more = 0;
918 continue;
919 }
920
921 /* Get the next buffer */
922 usb_offset += amount;
923 common->usb_amount_left -= amount;
924 amount_left_to_req -= amount;
925 if (amount_left_to_req == 0)
926 get_some_more = 0;
927
928 /* amount is always divisible by 512, hence by
929 * the bulk-out maxpacket size */
930 bh->outreq->length = amount;
931 bh->bulk_out_intended_length = amount;
932 bh->outreq->short_not_ok = 1;
933 START_TRANSFER_OR(common, bulk_out, bh->outreq,
934 &bh->outreq_busy, &bh->state)
935 /* Don't know what to do if
936 * common->fsg is NULL */
937 return -EIO;
938 common->next_buffhd_to_fill = bh->next;
939 continue;
940 }
941
942 /* Write the received data to the backing file */
943 bh = common->next_buffhd_to_drain;
944 if (bh->state == BUF_STATE_EMPTY && !get_some_more)
945 break; /* We stopped early */
946 if (bh->state == BUF_STATE_FULL) {
947 smp_rmb();
948 common->next_buffhd_to_drain = bh->next;
949 bh->state = BUF_STATE_EMPTY;
950
951 /* Did something go wrong with the transfer? */
952 if (bh->outreq->status != 0) {
953 curlun->sense_data = SS_COMMUNICATION_FAILURE;
954 curlun->sense_data_info = file_offset >> 9;
955 curlun->info_valid = 1;
956 break;
957 }
958
959 amount = bh->outreq->actual;
960 if (curlun->file_length - file_offset < amount) {
961 LERROR(curlun,
962 "write %u @ %llu beyond end %llu\n",
963 amount, (unsigned long long) file_offset,
964 (unsigned long long) curlun->file_length);
965 amount = curlun->file_length - file_offset;
966 }
967
968 /* Perform the write */
969 file_offset_tmp = file_offset;
970 nwritten = vfs_write(curlun->filp,
971 (char __user *) bh->buf,
972 amount, &file_offset_tmp);
973 VLDBG(curlun, "file write %u @ %llu -> %d\n", amount,
974 (unsigned long long) file_offset,
975 (int) nwritten);
976 if (signal_pending(current))
977 return -EINTR; /* Interrupted! */
978
979 if (nwritten < 0) {
980 LDBG(curlun, "error in file write: %d\n",
981 (int) nwritten);
982 nwritten = 0;
983 } else if (nwritten < amount) {
984 LDBG(curlun, "partial file write: %d/%u\n",
985 (int) nwritten, amount);
986 nwritten -= (nwritten & 511);
987 /* Round down to a block */
988 }
989 file_offset += nwritten;
990 amount_left_to_write -= nwritten;
991 common->residue -= nwritten;
992
993 /* If an error occurred, report it and its position */
994 if (nwritten < amount) {
995 curlun->sense_data = SS_WRITE_ERROR;
996 curlun->sense_data_info = file_offset >> 9;
997 curlun->info_valid = 1;
998 break;
999 }
1000
1001 /* Did the host decide to stop early? */
1002 if (bh->outreq->actual != bh->outreq->length) {
1003 common->short_packet_received = 1;
1004 break;
1005 }
1006 continue;
1007 }
1008
1009 /* Wait for something to happen */
1010 rc = sleep_thread(common);
1011 if (rc)
1012 return rc;
1013 }
1014
1015 return -EIO; /* No default reply */
1016}
1017
1018
1019/*-------------------------------------------------------------------------*/
1020
1021static int do_synchronize_cache(struct fsg_common *common)
1022{
1023 struct fsg_lun *curlun = common->curlun;
1024 int rc;
1025
1026 /* We ignore the requested LBA and write out all file's
1027 * dirty data buffers. */
1028 rc = fsg_lun_fsync_sub(curlun);
1029 if (rc)
1030 curlun->sense_data = SS_WRITE_ERROR;
1031 return 0;
1032}
1033
1034
1035/*-------------------------------------------------------------------------*/
1036
1037static void invalidate_sub(struct fsg_lun *curlun)
1038{
1039 struct file *filp = curlun->filp;
1040 struct inode *inode = filp->f_path.dentry->d_inode;
1041 unsigned long rc;
1042
1043 rc = invalidate_mapping_pages(inode->i_mapping, 0, -1);
1044 VLDBG(curlun, "invalidate_inode_pages -> %ld\n", rc);
1045}
1046
1047static int do_verify(struct fsg_common *common)
1048{
1049 struct fsg_lun *curlun = common->curlun;
1050 u32 lba;
1051 u32 verification_length;
1052 struct fsg_buffhd *bh = common->next_buffhd_to_fill;
1053 loff_t file_offset, file_offset_tmp;
1054 u32 amount_left;
1055 unsigned int amount;
1056 ssize_t nread;
1057
1058 /* Get the starting Logical Block Address and check that it's
1059 * not too big */
1060 lba = get_unaligned_be32(&common->cmnd[2]);
1061 if (lba >= curlun->num_sectors) {
1062 curlun->sense_data = SS_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE;
1063 return -EINVAL;
1064 }
1065
1066 /* We allow DPO (Disable Page Out = don't save data in the
1067 * cache) but we don't implement it. */
1068 if (common->cmnd[1] & ~0x10) {
1069 curlun->sense_data = SS_INVALID_FIELD_IN_CDB;
1070 return -EINVAL;
1071 }
1072
1073 verification_length = get_unaligned_be16(&common->cmnd[7]);
1074 if (unlikely(verification_length == 0))
1075 return -EIO; /* No default reply */
1076
1077 /* Prepare to carry out the file verify */
1078 amount_left = verification_length << 9;
1079 file_offset = ((loff_t) lba) << 9;
1080
1081 /* Write out all the dirty buffers before invalidating them */
1082 fsg_lun_fsync_sub(curlun);
1083 if (signal_pending(current))
1084 return -EINTR;
1085
1086 invalidate_sub(curlun);
1087 if (signal_pending(current))
1088 return -EINTR;
1089
1090 /* Just try to read the requested blocks */
1091 while (amount_left > 0) {
1092
1093 /* Figure out how much we need to read:
1094 * Try to read the remaining amount, but not more than
1095 * the buffer size.
1096 * And don't try to read past the end of the file.
1097 * If this means reading 0 then we were asked to read
1098 * past the end of file. */
1099 amount = min(amount_left, FSG_BUFLEN);
1100 amount = min((loff_t) amount,
1101 curlun->file_length - file_offset);
1102 if (amount == 0) {
1103 curlun->sense_data =
1104 SS_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE;
1105 curlun->sense_data_info = file_offset >> 9;
1106 curlun->info_valid = 1;
1107 break;
1108 }
1109
1110 /* Perform the read */
1111 file_offset_tmp = file_offset;
1112 nread = vfs_read(curlun->filp,
1113 (char __user *) bh->buf,
1114 amount, &file_offset_tmp);
1115 VLDBG(curlun, "file read %u @ %llu -> %d\n", amount,
1116 (unsigned long long) file_offset,
1117 (int) nread);
1118 if (signal_pending(current))
1119 return -EINTR;
1120
1121 if (nread < 0) {
1122 LDBG(curlun, "error in file verify: %d\n",
1123 (int) nread);
1124 nread = 0;
1125 } else if (nread < amount) {
1126 LDBG(curlun, "partial file verify: %d/%u\n",
1127 (int) nread, amount);
1128 nread -= (nread & 511); /* Round down to a sector */
1129 }
1130 if (nread == 0) {
1131 curlun->sense_data = SS_UNRECOVERED_READ_ERROR;
1132 curlun->sense_data_info = file_offset >> 9;
1133 curlun->info_valid = 1;
1134 break;
1135 }
1136 file_offset += nread;
1137 amount_left -= nread;
1138 }
1139 return 0;
1140}
1141
1142
1143/*-------------------------------------------------------------------------*/
1144
1145static int do_inquiry(struct fsg_common *common, struct fsg_buffhd *bh)
1146{
1147 struct fsg_lun *curlun = common->curlun;
1148 u8 *buf = (u8 *) bh->buf;
1149
1150 if (!curlun) { /* Unsupported LUNs are okay */
1151 common->bad_lun_okay = 1;
1152 memset(buf, 0, 36);
1153 buf[0] = 0x7f; /* Unsupported, no device-type */
1154 buf[4] = 31; /* Additional length */
1155 return 36;
1156 }
1157
1158 buf[0] = curlun->cdrom ? TYPE_CDROM : TYPE_DISK;
1159 buf[1] = curlun->removable ? 0x80 : 0;
1160 buf[2] = 2; /* ANSI SCSI level 2 */
1161 buf[3] = 2; /* SCSI-2 INQUIRY data format */
1162 buf[4] = 31; /* Additional length */
1163 buf[5] = 0; /* No special options */
1164 buf[6] = 0;
1165 buf[7] = 0;
1166 memcpy(buf + 8, common->inquiry_string, sizeof common->inquiry_string);
1167 return 36;
1168}
1169
1170
1171static int do_request_sense(struct fsg_common *common, struct fsg_buffhd *bh)
1172{
1173 struct fsg_lun *curlun = common->curlun;
1174 u8 *buf = (u8 *) bh->buf;
1175 u32 sd, sdinfo;
1176 int valid;
1177
1178 /*
1179 * From the SCSI-2 spec., section 7.9 (Unit attention condition):
1180 *
1181 * If a REQUEST SENSE command is received from an initiator
1182 * with a pending unit attention condition (before the target
1183 * generates the contingent allegiance condition), then the
1184 * target shall either:
1185 * a) report any pending sense data and preserve the unit
1186 * attention condition on the logical unit, or,
1187 * b) report the unit attention condition, may discard any
1188 * pending sense data, and clear the unit attention
1189 * condition on the logical unit for that initiator.
1190 *
1191 * FSG normally uses option a); enable this code to use option b).
1192 */
1193#if 0
1194 if (curlun && curlun->unit_attention_data != SS_NO_SENSE) {
1195 curlun->sense_data = curlun->unit_attention_data;
1196 curlun->unit_attention_data = SS_NO_SENSE;
1197 }
1198#endif
1199
1200 if (!curlun) { /* Unsupported LUNs are okay */
1201 common->bad_lun_okay = 1;
1202 sd = SS_LOGICAL_UNIT_NOT_SUPPORTED;
1203 sdinfo = 0;
1204 valid = 0;
1205 } else {
1206 sd = curlun->sense_data;
1207 sdinfo = curlun->sense_data_info;
1208 valid = curlun->info_valid << 7;
1209 curlun->sense_data = SS_NO_SENSE;
1210 curlun->sense_data_info = 0;
1211 curlun->info_valid = 0;
1212 }
1213
1214 memset(buf, 0, 18);
1215 buf[0] = valid | 0x70; /* Valid, current error */
1216 buf[2] = SK(sd);
1217 put_unaligned_be32(sdinfo, &buf[3]); /* Sense information */
1218 buf[7] = 18 - 8; /* Additional sense length */
1219 buf[12] = ASC(sd);
1220 buf[13] = ASCQ(sd);
1221 return 18;
1222}
1223
1224
1225static int do_read_capacity(struct fsg_common *common, struct fsg_buffhd *bh)
1226{
1227 struct fsg_lun *curlun = common->curlun;
1228 u32 lba = get_unaligned_be32(&common->cmnd[2]);
1229 int pmi = common->cmnd[8];
1230 u8 *buf = (u8 *) bh->buf;
1231
1232 /* Check the PMI and LBA fields */
1233 if (pmi > 1 || (pmi == 0 && lba != 0)) {
1234 curlun->sense_data = SS_INVALID_FIELD_IN_CDB;
1235 return -EINVAL;
1236 }
1237
1238 put_unaligned_be32(curlun->num_sectors - 1, &buf[0]);
1239 /* Max logical block */
1240 put_unaligned_be32(512, &buf[4]); /* Block length */
1241 return 8;
1242}
1243
1244
1245static int do_read_header(struct fsg_common *common, struct fsg_buffhd *bh)
1246{
1247 struct fsg_lun *curlun = common->curlun;
1248 int msf = common->cmnd[1] & 0x02;
1249 u32 lba = get_unaligned_be32(&common->cmnd[2]);
1250 u8 *buf = (u8 *) bh->buf;
1251
1252 if (common->cmnd[1] & ~0x02) { /* Mask away MSF */
1253 curlun->sense_data = SS_INVALID_FIELD_IN_CDB;
1254 return -EINVAL;
1255 }
1256 if (lba >= curlun->num_sectors) {
1257 curlun->sense_data = SS_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE;
1258 return -EINVAL;
1259 }
1260
1261 memset(buf, 0, 8);
1262 buf[0] = 0x01; /* 2048 bytes of user data, rest is EC */
1263 store_cdrom_address(&buf[4], msf, lba);
1264 return 8;
1265}
1266
1267
1268static int do_read_toc(struct fsg_common *common, struct fsg_buffhd *bh)
1269{
1270 struct fsg_lun *curlun = common->curlun;
1271 int msf = common->cmnd[1] & 0x02;
1272 int start_track = common->cmnd[6];
1273 u8 *buf = (u8 *) bh->buf;
1274
1275 if ((common->cmnd[1] & ~0x02) != 0 || /* Mask away MSF */
1276 start_track > 1) {
1277 curlun->sense_data = SS_INVALID_FIELD_IN_CDB;
1278 return -EINVAL;
1279 }
1280
1281 memset(buf, 0, 20);
1282 buf[1] = (20-2); /* TOC data length */
1283 buf[2] = 1; /* First track number */
1284 buf[3] = 1; /* Last track number */
1285 buf[5] = 0x16; /* Data track, copying allowed */
1286 buf[6] = 0x01; /* Only track is number 1 */
1287 store_cdrom_address(&buf[8], msf, 0);
1288
1289 buf[13] = 0x16; /* Lead-out track is data */
1290 buf[14] = 0xAA; /* Lead-out track number */
1291 store_cdrom_address(&buf[16], msf, curlun->num_sectors);
1292 return 20;
1293}
1294
1295
1296static int do_mode_sense(struct fsg_common *common, struct fsg_buffhd *bh)
1297{
1298 struct fsg_lun *curlun = common->curlun;
1299 int mscmnd = common->cmnd[0];
1300 u8 *buf = (u8 *) bh->buf;
1301 u8 *buf0 = buf;
1302 int pc, page_code;
1303 int changeable_values, all_pages;
1304 int valid_page = 0;
1305 int len, limit;
1306
1307 if ((common->cmnd[1] & ~0x08) != 0) { /* Mask away DBD */
1308 curlun->sense_data = SS_INVALID_FIELD_IN_CDB;
1309 return -EINVAL;
1310 }
1311 pc = common->cmnd[2] >> 6;
1312 page_code = common->cmnd[2] & 0x3f;
1313 if (pc == 3) {
1314 curlun->sense_data = SS_SAVING_PARAMETERS_NOT_SUPPORTED;
1315 return -EINVAL;
1316 }
1317 changeable_values = (pc == 1);
1318 all_pages = (page_code == 0x3f);
1319
1320 /* Write the mode parameter header. Fixed values are: default
1321 * medium type, no cache control (DPOFUA), and no block descriptors.
1322 * The only variable value is the WriteProtect bit. We will fill in
1323 * the mode data length later. */
1324 memset(buf, 0, 8);
1325 if (mscmnd == SC_MODE_SENSE_6) {
1326 buf[2] = (curlun->ro ? 0x80 : 0x00); /* WP, DPOFUA */
1327 buf += 4;
1328 limit = 255;
1329 } else { /* SC_MODE_SENSE_10 */
1330 buf[3] = (curlun->ro ? 0x80 : 0x00); /* WP, DPOFUA */
1331 buf += 8;
1332 limit = 65535; /* Should really be FSG_BUFLEN */
1333 }
1334
1335 /* No block descriptors */
1336
1337 /* The mode pages, in numerical order. The only page we support
1338 * is the Caching page. */
1339 if (page_code == 0x08 || all_pages) {
1340 valid_page = 1;
1341 buf[0] = 0x08; /* Page code */
1342 buf[1] = 10; /* Page length */
1343 memset(buf+2, 0, 10); /* None of the fields are changeable */
1344
1345 if (!changeable_values) {
1346 buf[2] = 0x04; /* Write cache enable, */
1347 /* Read cache not disabled */
1348 /* No cache retention priorities */
1349 put_unaligned_be16(0xffff, &buf[4]);
1350 /* Don't disable prefetch */
1351 /* Minimum prefetch = 0 */
1352 put_unaligned_be16(0xffff, &buf[8]);
1353 /* Maximum prefetch */
1354 put_unaligned_be16(0xffff, &buf[10]);
1355 /* Maximum prefetch ceiling */
1356 }
1357 buf += 12;
1358 }
1359
1360 /* Check that a valid page was requested and the mode data length
1361 * isn't too long. */
1362 len = buf - buf0;
1363 if (!valid_page || len > limit) {
1364 curlun->sense_data = SS_INVALID_FIELD_IN_CDB;
1365 return -EINVAL;
1366 }
1367
1368 /* Store the mode data length */
1369 if (mscmnd == SC_MODE_SENSE_6)
1370 buf0[0] = len - 1;
1371 else
1372 put_unaligned_be16(len - 2, buf0);
1373 return len;
1374}
1375
1376
1377static int do_start_stop(struct fsg_common *common)
1378{
1379 if (!common->curlun) {
1380 return -EINVAL;
1381 } else if (!common->curlun->removable) {
1382 common->curlun->sense_data = SS_INVALID_COMMAND;
1383 return -EINVAL;
1384 }
1385 return 0;
1386}
1387
1388
1389static int do_prevent_allow(struct fsg_common *common)
1390{
1391 struct fsg_lun *curlun = common->curlun;
1392 int prevent;
1393
1394 if (!common->curlun) {
1395 return -EINVAL;
1396 } else if (!common->curlun->removable) {
1397 common->curlun->sense_data = SS_INVALID_COMMAND;
1398 return -EINVAL;
1399 }
1400
1401 prevent = common->cmnd[4] & 0x01;
1402 if ((common->cmnd[4] & ~0x01) != 0) { /* Mask away Prevent */
1403 curlun->sense_data = SS_INVALID_FIELD_IN_CDB;
1404 return -EINVAL;
1405 }
1406
1407 if (curlun->prevent_medium_removal && !prevent)
1408 fsg_lun_fsync_sub(curlun);
1409 curlun->prevent_medium_removal = prevent;
1410 return 0;
1411}
1412
1413
1414static int do_read_format_capacities(struct fsg_common *common,
1415 struct fsg_buffhd *bh)
1416{
1417 struct fsg_lun *curlun = common->curlun;
1418 u8 *buf = (u8 *) bh->buf;
1419
1420 buf[0] = buf[1] = buf[2] = 0;
1421 buf[3] = 8; /* Only the Current/Maximum Capacity Descriptor */
1422 buf += 4;
1423
1424 put_unaligned_be32(curlun->num_sectors, &buf[0]);
1425 /* Number of blocks */
1426 put_unaligned_be32(512, &buf[4]); /* Block length */
1427 buf[4] = 0x02; /* Current capacity */
1428 return 12;
1429}
1430
1431
1432static int do_mode_select(struct fsg_common *common, struct fsg_buffhd *bh)
1433{
1434 struct fsg_lun *curlun = common->curlun;
1435
1436 /* We don't support MODE SELECT */
1437 if (curlun)
1438 curlun->sense_data = SS_INVALID_COMMAND;
1439 return -EINVAL;
1440}
1441
1442
1443/*-------------------------------------------------------------------------*/
1444
1445static int halt_bulk_in_endpoint(struct fsg_dev *fsg)
1446{
1447 int rc;
1448
1449 rc = fsg_set_halt(fsg, fsg->bulk_in);
1450 if (rc == -EAGAIN)
1451 VDBG(fsg, "delayed bulk-in endpoint halt\n");
1452 while (rc != 0) {
1453 if (rc != -EAGAIN) {
1454 WARNING(fsg, "usb_ep_set_halt -> %d\n", rc);
1455 rc = 0;
1456 break;
1457 }
1458
1459 /* Wait for a short time and then try again */
1460 if (msleep_interruptible(100) != 0)
1461 return -EINTR;
1462 rc = usb_ep_set_halt(fsg->bulk_in);
1463 }
1464 return rc;
1465}
1466
1467static int wedge_bulk_in_endpoint(struct fsg_dev *fsg)
1468{
1469 int rc;
1470
1471 DBG(fsg, "bulk-in set wedge\n");
1472 rc = usb_ep_set_wedge(fsg->bulk_in);
1473 if (rc == -EAGAIN)
1474 VDBG(fsg, "delayed bulk-in endpoint wedge\n");
1475 while (rc != 0) {
1476 if (rc != -EAGAIN) {
1477 WARNING(fsg, "usb_ep_set_wedge -> %d\n", rc);
1478 rc = 0;
1479 break;
1480 }
1481
1482 /* Wait for a short time and then try again */
1483 if (msleep_interruptible(100) != 0)
1484 return -EINTR;
1485 rc = usb_ep_set_wedge(fsg->bulk_in);
1486 }
1487 return rc;
1488}
1489
1490static int pad_with_zeros(struct fsg_dev *fsg)
1491{
1492 struct fsg_buffhd *bh = fsg->common->next_buffhd_to_fill;
1493 u32 nkeep = bh->inreq->length;
1494 u32 nsend;
1495 int rc;
1496
1497 bh->state = BUF_STATE_EMPTY; /* For the first iteration */
1498 fsg->common->usb_amount_left = nkeep + fsg->common->residue;
1499 while (fsg->common->usb_amount_left > 0) {
1500
1501 /* Wait for the next buffer to be free */
1502 while (bh->state != BUF_STATE_EMPTY) {
1503 rc = sleep_thread(fsg->common);
1504 if (rc)
1505 return rc;
1506 }
1507
1508 nsend = min(fsg->common->usb_amount_left, FSG_BUFLEN);
1509 memset(bh->buf + nkeep, 0, nsend - nkeep);
1510 bh->inreq->length = nsend;
1511 bh->inreq->zero = 0;
1512 start_transfer(fsg, fsg->bulk_in, bh->inreq,
1513 &bh->inreq_busy, &bh->state);
1514 bh = fsg->common->next_buffhd_to_fill = bh->next;
1515 fsg->common->usb_amount_left -= nsend;
1516 nkeep = 0;
1517 }
1518 return 0;
1519}
1520
1521static int throw_away_data(struct fsg_common *common)
1522{
1523 struct fsg_buffhd *bh;
1524 u32 amount;
1525 int rc;
1526
1527 for (bh = common->next_buffhd_to_drain;
1528 bh->state != BUF_STATE_EMPTY || common->usb_amount_left > 0;
1529 bh = common->next_buffhd_to_drain) {
1530
1531 /* Throw away the data in a filled buffer */
1532 if (bh->state == BUF_STATE_FULL) {
1533 smp_rmb();
1534 bh->state = BUF_STATE_EMPTY;
1535 common->next_buffhd_to_drain = bh->next;
1536
1537 /* A short packet or an error ends everything */
1538 if (bh->outreq->actual != bh->outreq->length ||
1539 bh->outreq->status != 0) {
1540 raise_exception(common,
1541 FSG_STATE_ABORT_BULK_OUT);
1542 return -EINTR;
1543 }
1544 continue;
1545 }
1546
1547 /* Try to submit another request if we need one */
1548 bh = common->next_buffhd_to_fill;
1549 if (bh->state == BUF_STATE_EMPTY
1550 && common->usb_amount_left > 0) {
1551 amount = min(common->usb_amount_left, FSG_BUFLEN);
1552
1553 /* amount is always divisible by 512, hence by
1554 * the bulk-out maxpacket size */
1555 bh->outreq->length = amount;
1556 bh->bulk_out_intended_length = amount;
1557 bh->outreq->short_not_ok = 1;
1558 START_TRANSFER_OR(common, bulk_out, bh->outreq,
1559 &bh->outreq_busy, &bh->state)
1560 /* Don't know what to do if
1561 * common->fsg is NULL */
1562 return -EIO;
1563 common->next_buffhd_to_fill = bh->next;
1564 common->usb_amount_left -= amount;
1565 continue;
1566 }
1567
1568 /* Otherwise wait for something to happen */
1569 rc = sleep_thread(common);
1570 if (rc)
1571 return rc;
1572 }
1573 return 0;
1574}
1575
1576
1577static int finish_reply(struct fsg_common *common)
1578{
1579 struct fsg_buffhd *bh = common->next_buffhd_to_fill;
1580 int rc = 0;
1581
1582 switch (common->data_dir) {
1583 case DATA_DIR_NONE:
1584 break; /* Nothing to send */
1585
1586 /* If we don't know whether the host wants to read or write,
1587 * this must be CB or CBI with an unknown command. We mustn't
1588 * try to send or receive any data. So stall both bulk pipes
1589 * if we can and wait for a reset. */
1590 case DATA_DIR_UNKNOWN:
1591 if (!common->can_stall) {
1592 /* Nothing */
1593 } else if (fsg_is_set(common)) {
1594 fsg_set_halt(common->fsg, common->fsg->bulk_out);
1595 rc = halt_bulk_in_endpoint(common->fsg);
1596 } else {
1597 /* Don't know what to do if common->fsg is NULL */
1598 rc = -EIO;
1599 }
1600 break;
1601
1602 /* All but the last buffer of data must have already been sent */
1603 case DATA_DIR_TO_HOST:
1604 if (common->data_size == 0) {
1605 /* Nothing to send */
1606
1607 /* If there's no residue, simply send the last buffer */
1608 } else if (common->residue == 0) {
1609 bh->inreq->zero = 0;
1610 START_TRANSFER_OR(common, bulk_in, bh->inreq,
1611 &bh->inreq_busy, &bh->state)
1612 return -EIO;
1613 common->next_buffhd_to_fill = bh->next;
1614
1615 /* For Bulk-only, if we're allowed to stall then send the
1616 * short packet and halt the bulk-in endpoint. If we can't
1617 * stall, pad out the remaining data with 0's. */
1618 } else if (common->can_stall) {
1619 bh->inreq->zero = 1;
1620 START_TRANSFER_OR(common, bulk_in, bh->inreq,
1621 &bh->inreq_busy, &bh->state)
1622 /* Don't know what to do if
1623 * common->fsg is NULL */
1624 rc = -EIO;
1625 common->next_buffhd_to_fill = bh->next;
1626 if (common->fsg)
1627 rc = halt_bulk_in_endpoint(common->fsg);
1628 } else if (fsg_is_set(common)) {
1629 rc = pad_with_zeros(common->fsg);
1630 } else {
1631 /* Don't know what to do if common->fsg is NULL */
1632 rc = -EIO;
1633 }
1634 break;
1635
1636 /* We have processed all we want from the data the host has sent.
1637 * There may still be outstanding bulk-out requests. */
1638 case DATA_DIR_FROM_HOST:
1639 if (common->residue == 0) {
1640 /* Nothing to receive */
1641
1642 /* Did the host stop sending unexpectedly early? */
1643 } else if (common->short_packet_received) {
1644 raise_exception(common, FSG_STATE_ABORT_BULK_OUT);
1645 rc = -EINTR;
1646
1647 /* We haven't processed all the incoming data. Even though
1648 * we may be allowed to stall, doing so would cause a race.
1649 * The controller may already have ACK'ed all the remaining
1650 * bulk-out packets, in which case the host wouldn't see a
1651 * STALL. Not realizing the endpoint was halted, it wouldn't
1652 * clear the halt -- leading to problems later on. */
1653#if 0
1654 } else if (common->can_stall) {
1655 if (fsg_is_set(common))
1656 fsg_set_halt(common->fsg,
1657 common->fsg->bulk_out);
1658 raise_exception(common, FSG_STATE_ABORT_BULK_OUT);
1659 rc = -EINTR;
1660#endif
1661
1662 /* We can't stall. Read in the excess data and throw it
1663 * all away. */
1664 } else {
1665 rc = throw_away_data(common);
1666 }
1667 break;
1668 }
1669 return rc;
1670}
1671
1672
1673static int send_status(struct fsg_common *common)
1674{
1675 struct fsg_lun *curlun = common->curlun;
1676 struct fsg_buffhd *bh;
1677 struct bulk_cs_wrap *csw;
1678 int rc;
1679 u8 status = USB_STATUS_PASS;
1680 u32 sd, sdinfo = 0;
1681
1682 /* Wait for the next buffer to become available */
1683 bh = common->next_buffhd_to_fill;
1684 while (bh->state != BUF_STATE_EMPTY) {
1685 rc = sleep_thread(common);
1686 if (rc)
1687 return rc;
1688 }
1689
1690 if (curlun) {
1691 sd = curlun->sense_data;
1692 sdinfo = curlun->sense_data_info;
1693 } else if (common->bad_lun_okay)
1694 sd = SS_NO_SENSE;
1695 else
1696 sd = SS_LOGICAL_UNIT_NOT_SUPPORTED;
1697
1698 if (common->phase_error) {
1699 DBG(common, "sending phase-error status\n");
1700 status = USB_STATUS_PHASE_ERROR;
1701 sd = SS_INVALID_COMMAND;
1702 } else if (sd != SS_NO_SENSE) {
1703 DBG(common, "sending command-failure status\n");
1704 status = USB_STATUS_FAIL;
1705 VDBG(common, " sense data: SK x%02x, ASC x%02x, ASCQ x%02x;"
1706 " info x%x\n",
1707 SK(sd), ASC(sd), ASCQ(sd), sdinfo);
1708 }
1709
1710 /* Store and send the Bulk-only CSW */
1711 csw = (void *)bh->buf;
1712
1713 csw->Signature = cpu_to_le32(USB_BULK_CS_SIG);
1714 csw->Tag = common->tag;
1715 csw->Residue = cpu_to_le32(common->residue);
1716 csw->Status = status;
1717
1718 bh->inreq->length = USB_BULK_CS_WRAP_LEN;
1719 bh->inreq->zero = 0;
1720 START_TRANSFER_OR(common, bulk_in, bh->inreq,
1721 &bh->inreq_busy, &bh->state)
1722 /* Don't know what to do if common->fsg is NULL */
1723 return -EIO;
1724
1725 common->next_buffhd_to_fill = bh->next;
1726 return 0;
1727}
1728
1729
1730/*-------------------------------------------------------------------------*/
1731
1732/* Check whether the command is properly formed and whether its data size
1733 * and direction agree with the values we already have. */
1734static int check_command(struct fsg_common *common, int cmnd_size,
1735 enum data_direction data_dir, unsigned int mask,
1736 int needs_medium, const char *name)
1737{
1738 int i;
1739 int lun = common->cmnd[1] >> 5;
1740 static const char dirletter[4] = {'u', 'o', 'i', 'n'};
1741 char hdlen[20];
1742 struct fsg_lun *curlun;
1743
1744 hdlen[0] = 0;
1745 if (common->data_dir != DATA_DIR_UNKNOWN)
1746 sprintf(hdlen, ", H%c=%u", dirletter[(int) common->data_dir],
1747 common->data_size);
1748 VDBG(common, "SCSI command: %s; Dc=%d, D%c=%u; Hc=%d%s\n",
1749 name, cmnd_size, dirletter[(int) data_dir],
1750 common->data_size_from_cmnd, common->cmnd_size, hdlen);
1751
1752 /* We can't reply at all until we know the correct data direction
1753 * and size. */
1754 if (common->data_size_from_cmnd == 0)
1755 data_dir = DATA_DIR_NONE;
1756 if (common->data_size < common->data_size_from_cmnd) {
1757 /* Host data size < Device data size is a phase error.
1758 * Carry out the command, but only transfer as much as
1759 * we are allowed. */
1760 common->data_size_from_cmnd = common->data_size;
1761 common->phase_error = 1;
1762 }
1763 common->residue = common->data_size;
1764 common->usb_amount_left = common->data_size;
1765
1766 /* Conflicting data directions is a phase error */
1767 if (common->data_dir != data_dir
1768 && common->data_size_from_cmnd > 0) {
1769 common->phase_error = 1;
1770 return -EINVAL;
1771 }
1772
1773 /* Verify the length of the command itself */
1774 if (cmnd_size != common->cmnd_size) {
1775
1776 /* Special case workaround: There are plenty of buggy SCSI
1777 * implementations. Many have issues with cbw->Length
1778 * field passing a wrong command size. For those cases we
1779 * always try to work around the problem by using the length
1780 * sent by the host side provided it is at least as large
1781 * as the correct command length.
1782 * Examples of such cases would be MS-Windows, which issues
1783 * REQUEST SENSE with cbw->Length == 12 where it should
1784 * be 6, and xbox360 issuing INQUIRY, TEST UNIT READY and
1785 * REQUEST SENSE with cbw->Length == 10 where it should
1786 * be 6 as well.
1787 */
1788 if (cmnd_size <= common->cmnd_size) {
1789 DBG(common, "%s is buggy! Expected length %d "
1790 "but we got %d\n", name,
1791 cmnd_size, common->cmnd_size);
1792 cmnd_size = common->cmnd_size;
1793 } else {
1794 common->phase_error = 1;
1795 return -EINVAL;
1796 }
1797 }
1798
1799 /* Check that the LUN values are consistent */
1800 if (common->lun != lun)
1801 DBG(common, "using LUN %d from CBW, not LUN %d from CDB\n",
1802 common->lun, lun);
1803
1804 /* Check the LUN */
1805 if (common->lun >= 0 && common->lun < common->nluns) {
1806 curlun = &common->luns[common->lun];
1807 common->curlun = curlun;
1808 if (common->cmnd[0] != SC_REQUEST_SENSE) {
1809 curlun->sense_data = SS_NO_SENSE;
1810 curlun->sense_data_info = 0;
1811 curlun->info_valid = 0;
1812 }
1813 } else {
1814 common->curlun = NULL;
1815 curlun = NULL;
1816 common->bad_lun_okay = 0;
1817
1818 /* INQUIRY and REQUEST SENSE commands are explicitly allowed
1819 * to use unsupported LUNs; all others may not. */
1820 if (common->cmnd[0] != SC_INQUIRY &&
1821 common->cmnd[0] != SC_REQUEST_SENSE) {
1822 DBG(common, "unsupported LUN %d\n", common->lun);
1823 return -EINVAL;
1824 }
1825 }
1826
1827 /* If a unit attention condition exists, only INQUIRY and
1828 * REQUEST SENSE commands are allowed; anything else must fail. */
1829 if (curlun && curlun->unit_attention_data != SS_NO_SENSE &&
1830 common->cmnd[0] != SC_INQUIRY &&
1831 common->cmnd[0] != SC_REQUEST_SENSE) {
1832 curlun->sense_data = curlun->unit_attention_data;
1833 curlun->unit_attention_data = SS_NO_SENSE;
1834 return -EINVAL;
1835 }
1836
1837 /* Check that only command bytes listed in the mask are non-zero */
1838 common->cmnd[1] &= 0x1f; /* Mask away the LUN */
1839 for (i = 1; i < cmnd_size; ++i) {
1840 if (common->cmnd[i] && !(mask & (1 << i))) {
1841 if (curlun)
1842 curlun->sense_data = SS_INVALID_FIELD_IN_CDB;
1843 return -EINVAL;
1844 }
1845 }
1846
1847 /* If the medium isn't mounted and the command needs to access
1848 * it, return an error. */
1849 if (curlun && !fsg_lun_is_open(curlun) && needs_medium) {
1850 curlun->sense_data = SS_MEDIUM_NOT_PRESENT;
1851 return -EINVAL;
1852 }
1853
1854 return 0;
1855}
1856
1857
1858static int do_scsi_command(struct fsg_common *common)
1859{
1860 struct fsg_buffhd *bh;
1861 int rc;
1862 int reply = -EINVAL;
1863 int i;
1864 static char unknown[16];
1865
1866 dump_cdb(common);
1867
1868 /* Wait for the next buffer to become available for data or status */
1869 bh = common->next_buffhd_to_fill;
1870 common->next_buffhd_to_drain = bh;
1871 while (bh->state != BUF_STATE_EMPTY) {
1872 rc = sleep_thread(common);
1873 if (rc)
1874 return rc;
1875 }
1876 common->phase_error = 0;
1877 common->short_packet_received = 0;
1878
1879 down_read(&common->filesem); /* We're using the backing file */
1880 switch (common->cmnd[0]) {
1881
1882 case SC_INQUIRY:
1883 common->data_size_from_cmnd = common->cmnd[4];
1884 reply = check_command(common, 6, DATA_DIR_TO_HOST,
1885 (1<<4), 0,
1886 "INQUIRY");
1887 if (reply == 0)
1888 reply = do_inquiry(common, bh);
1889 break;
1890
1891 case SC_MODE_SELECT_6:
1892 common->data_size_from_cmnd = common->cmnd[4];
1893 reply = check_command(common, 6, DATA_DIR_FROM_HOST,
1894 (1<<1) | (1<<4), 0,
1895 "MODE SELECT(6)");
1896 if (reply == 0)
1897 reply = do_mode_select(common, bh);
1898 break;
1899
1900 case SC_MODE_SELECT_10:
1901 common->data_size_from_cmnd =
1902 get_unaligned_be16(&common->cmnd[7]);
1903 reply = check_command(common, 10, DATA_DIR_FROM_HOST,
1904 (1<<1) | (3<<7), 0,
1905 "MODE SELECT(10)");
1906 if (reply == 0)
1907 reply = do_mode_select(common, bh);
1908 break;
1909
1910 case SC_MODE_SENSE_6:
1911 common->data_size_from_cmnd = common->cmnd[4];
1912 reply = check_command(common, 6, DATA_DIR_TO_HOST,
1913 (1<<1) | (1<<2) | (1<<4), 0,
1914 "MODE SENSE(6)");
1915 if (reply == 0)
1916 reply = do_mode_sense(common, bh);
1917 break;
1918
1919 case SC_MODE_SENSE_10:
1920 common->data_size_from_cmnd =
1921 get_unaligned_be16(&common->cmnd[7]);
1922 reply = check_command(common, 10, DATA_DIR_TO_HOST,
1923 (1<<1) | (1<<2) | (3<<7), 0,
1924 "MODE SENSE(10)");
1925 if (reply == 0)
1926 reply = do_mode_sense(common, bh);
1927 break;
1928
1929 case SC_PREVENT_ALLOW_MEDIUM_REMOVAL:
1930 common->data_size_from_cmnd = 0;
1931 reply = check_command(common, 6, DATA_DIR_NONE,
1932 (1<<4), 0,
1933 "PREVENT-ALLOW MEDIUM REMOVAL");
1934 if (reply == 0)
1935 reply = do_prevent_allow(common);
1936 break;
1937
1938 case SC_READ_6:
1939 i = common->cmnd[4];
1940 common->data_size_from_cmnd = (i == 0 ? 256 : i) << 9;
1941 reply = check_command(common, 6, DATA_DIR_TO_HOST,
1942 (7<<1) | (1<<4), 1,
1943 "READ(6)");
1944 if (reply == 0)
1945 reply = do_read(common);
1946 break;
1947
1948 case SC_READ_10:
1949 common->data_size_from_cmnd =
1950 get_unaligned_be16(&common->cmnd[7]) << 9;
1951 reply = check_command(common, 10, DATA_DIR_TO_HOST,
1952 (1<<1) | (0xf<<2) | (3<<7), 1,
1953 "READ(10)");
1954 if (reply == 0)
1955 reply = do_read(common);
1956 break;
1957
1958 case SC_READ_12:
1959 common->data_size_from_cmnd =
1960 get_unaligned_be32(&common->cmnd[6]) << 9;
1961 reply = check_command(common, 12, DATA_DIR_TO_HOST,
1962 (1<<1) | (0xf<<2) | (0xf<<6), 1,
1963 "READ(12)");
1964 if (reply == 0)
1965 reply = do_read(common);
1966 break;
1967
1968 case SC_READ_CAPACITY:
1969 common->data_size_from_cmnd = 8;
1970 reply = check_command(common, 10, DATA_DIR_TO_HOST,
1971 (0xf<<2) | (1<<8), 1,
1972 "READ CAPACITY");
1973 if (reply == 0)
1974 reply = do_read_capacity(common, bh);
1975 break;
1976
1977 case SC_READ_HEADER:
1978 if (!common->curlun || !common->curlun->cdrom)
1979 goto unknown_cmnd;
1980 common->data_size_from_cmnd =
1981 get_unaligned_be16(&common->cmnd[7]);
1982 reply = check_command(common, 10, DATA_DIR_TO_HOST,
1983 (3<<7) | (0x1f<<1), 1,
1984 "READ HEADER");
1985 if (reply == 0)
1986 reply = do_read_header(common, bh);
1987 break;
1988
1989 case SC_READ_TOC:
1990 if (!common->curlun || !common->curlun->cdrom)
1991 goto unknown_cmnd;
1992 common->data_size_from_cmnd =
1993 get_unaligned_be16(&common->cmnd[7]);
1994 reply = check_command(common, 10, DATA_DIR_TO_HOST,
1995 (7<<6) | (1<<1), 1,
1996 "READ TOC");
1997 if (reply == 0)
1998 reply = do_read_toc(common, bh);
1999 break;
2000
2001 case SC_READ_FORMAT_CAPACITIES:
2002 common->data_size_from_cmnd =
2003 get_unaligned_be16(&common->cmnd[7]);
2004 reply = check_command(common, 10, DATA_DIR_TO_HOST,
2005 (3<<7), 1,
2006 "READ FORMAT CAPACITIES");
2007 if (reply == 0)
2008 reply = do_read_format_capacities(common, bh);
2009 break;
2010
2011 case SC_REQUEST_SENSE:
2012 common->data_size_from_cmnd = common->cmnd[4];
2013 reply = check_command(common, 6, DATA_DIR_TO_HOST,
2014 (1<<4), 0,
2015 "REQUEST SENSE");
2016 if (reply == 0)
2017 reply = do_request_sense(common, bh);
2018 break;
2019
2020 case SC_START_STOP_UNIT:
2021 common->data_size_from_cmnd = 0;
2022 reply = check_command(common, 6, DATA_DIR_NONE,
2023 (1<<1) | (1<<4), 0,
2024 "START-STOP UNIT");
2025 if (reply == 0)
2026 reply = do_start_stop(common);
2027 break;
2028
2029 case SC_SYNCHRONIZE_CACHE:
2030 common->data_size_from_cmnd = 0;
2031 reply = check_command(common, 10, DATA_DIR_NONE,
2032 (0xf<<2) | (3<<7), 1,
2033 "SYNCHRONIZE CACHE");
2034 if (reply == 0)
2035 reply = do_synchronize_cache(common);
2036 break;
2037
2038 case SC_TEST_UNIT_READY:
2039 common->data_size_from_cmnd = 0;
2040 reply = check_command(common, 6, DATA_DIR_NONE,
2041 0, 1,
2042 "TEST UNIT READY");
2043 break;
2044
2045 /* Although optional, this command is used by MS-Windows. We
2046 * support a minimal version: BytChk must be 0. */
2047 case SC_VERIFY:
2048 common->data_size_from_cmnd = 0;
2049 reply = check_command(common, 10, DATA_DIR_NONE,
2050 (1<<1) | (0xf<<2) | (3<<7), 1,
2051 "VERIFY");
2052 if (reply == 0)
2053 reply = do_verify(common);
2054 break;
2055
2056 case SC_WRITE_6:
2057 i = common->cmnd[4];
2058 common->data_size_from_cmnd = (i == 0 ? 256 : i) << 9;
2059 reply = check_command(common, 6, DATA_DIR_FROM_HOST,
2060 (7<<1) | (1<<4), 1,
2061 "WRITE(6)");
2062 if (reply == 0)
2063 reply = do_write(common);
2064 break;
2065
2066 case SC_WRITE_10:
2067 common->data_size_from_cmnd =
2068 get_unaligned_be16(&common->cmnd[7]) << 9;
2069 reply = check_command(common, 10, DATA_DIR_FROM_HOST,
2070 (1<<1) | (0xf<<2) | (3<<7), 1,
2071 "WRITE(10)");
2072 if (reply == 0)
2073 reply = do_write(common);
2074 break;
2075
2076 case SC_WRITE_12:
2077 common->data_size_from_cmnd =
2078 get_unaligned_be32(&common->cmnd[6]) << 9;
2079 reply = check_command(common, 12, DATA_DIR_FROM_HOST,
2080 (1<<1) | (0xf<<2) | (0xf<<6), 1,
2081 "WRITE(12)");
2082 if (reply == 0)
2083 reply = do_write(common);
2084 break;
2085
2086 /* Some mandatory commands that we recognize but don't implement.
2087 * They don't mean much in this setting. It's left as an exercise
2088 * for anyone interested to implement RESERVE and RELEASE in terms
2089 * of Posix locks. */
2090 case SC_FORMAT_UNIT:
2091 case SC_RELEASE:
2092 case SC_RESERVE:
2093 case SC_SEND_DIAGNOSTIC:
2094 /* Fall through */
2095
2096 default:
2097unknown_cmnd:
2098 common->data_size_from_cmnd = 0;
2099 sprintf(unknown, "Unknown x%02x", common->cmnd[0]);
2100 reply = check_command(common, common->cmnd_size,
2101 DATA_DIR_UNKNOWN, 0xff, 0, unknown);
2102 if (reply == 0) {
2103 common->curlun->sense_data = SS_INVALID_COMMAND;
2104 reply = -EINVAL;
2105 }
2106 break;
2107 }
2108 up_read(&common->filesem);
2109
2110 if (reply == -EINTR || signal_pending(current))
2111 return -EINTR;
2112
2113 /* Set up the single reply buffer for finish_reply() */
2114 if (reply == -EINVAL)
2115 reply = 0; /* Error reply length */
2116 if (reply >= 0 && common->data_dir == DATA_DIR_TO_HOST) {
2117 reply = min((u32) reply, common->data_size_from_cmnd);
2118 bh->inreq->length = reply;
2119 bh->state = BUF_STATE_FULL;
2120 common->residue -= reply;
2121 } /* Otherwise it's already set */
2122
2123 return 0;
2124}
2125
2126
2127/*-------------------------------------------------------------------------*/
2128
2129static int received_cbw(struct fsg_dev *fsg, struct fsg_buffhd *bh)
2130{
2131 struct usb_request *req = bh->outreq;
2132 struct fsg_bulk_cb_wrap *cbw = req->buf;
2133 struct fsg_common *common = fsg->common;
2134
2135 /* Was this a real packet? Should it be ignored? */
2136 if (req->status || test_bit(IGNORE_BULK_OUT, &fsg->atomic_bitflags))
2137 return -EINVAL;
2138
2139 /* Is the CBW valid? */
2140 if (req->actual != USB_BULK_CB_WRAP_LEN ||
2141 cbw->Signature != cpu_to_le32(
2142 USB_BULK_CB_SIG)) {
2143 DBG(fsg, "invalid CBW: len %u sig 0x%x\n",
2144 req->actual,
2145 le32_to_cpu(cbw->Signature));
2146
2147 /* The Bulk-only spec says we MUST stall the IN endpoint
2148 * (6.6.1), so it's unavoidable. It also says we must
2149 * retain this state until the next reset, but there's
2150 * no way to tell the controller driver it should ignore
2151 * Clear-Feature(HALT) requests.
2152 *
2153 * We aren't required to halt the OUT endpoint; instead
2154 * we can simply accept and discard any data received
2155 * until the next reset. */
2156 wedge_bulk_in_endpoint(fsg);
2157 set_bit(IGNORE_BULK_OUT, &fsg->atomic_bitflags);
2158 return -EINVAL;
2159 }
2160
2161 /* Is the CBW meaningful? */
2162 if (cbw->Lun >= FSG_MAX_LUNS || cbw->Flags & ~USB_BULK_IN_FLAG ||
2163 cbw->Length <= 0 || cbw->Length > MAX_COMMAND_SIZE) {
2164 DBG(fsg, "non-meaningful CBW: lun = %u, flags = 0x%x, "
2165 "cmdlen %u\n",
2166 cbw->Lun, cbw->Flags, cbw->Length);
2167
2168 /* We can do anything we want here, so let's stall the
2169 * bulk pipes if we are allowed to. */
2170 if (common->can_stall) {
2171 fsg_set_halt(fsg, fsg->bulk_out);
2172 halt_bulk_in_endpoint(fsg);
2173 }
2174 return -EINVAL;
2175 }
2176
2177 /* Save the command for later */
2178 common->cmnd_size = cbw->Length;
2179 memcpy(common->cmnd, cbw->CDB, common->cmnd_size);
2180 if (cbw->Flags & USB_BULK_IN_FLAG)
2181 common->data_dir = DATA_DIR_TO_HOST;
2182 else
2183 common->data_dir = DATA_DIR_FROM_HOST;
2184 common->data_size = le32_to_cpu(cbw->DataTransferLength);
2185 if (common->data_size == 0)
2186 common->data_dir = DATA_DIR_NONE;
2187 common->lun = cbw->Lun;
2188 common->tag = cbw->Tag;
2189 return 0;
2190}
2191
2192
2193static int get_next_command(struct fsg_common *common)
2194{
2195 struct fsg_buffhd *bh;
2196 int rc = 0;
2197
2198 /* Wait for the next buffer to become available */
2199 bh = common->next_buffhd_to_fill;
2200 while (bh->state != BUF_STATE_EMPTY) {
2201 rc = sleep_thread(common);
2202 if (rc)
2203 return rc;
2204 }
2205
2206 /* Queue a request to read a Bulk-only CBW */
2207 set_bulk_out_req_length(common, bh, USB_BULK_CB_WRAP_LEN);
2208 bh->outreq->short_not_ok = 1;
2209 START_TRANSFER_OR(common, bulk_out, bh->outreq,
2210 &bh->outreq_busy, &bh->state)
2211 /* Don't know what to do if common->fsg is NULL */
2212 return -EIO;
2213
2214 /* We will drain the buffer in software, which means we
2215 * can reuse it for the next filling. No need to advance
2216 * next_buffhd_to_fill. */
2217
2218 /* Wait for the CBW to arrive */
2219 while (bh->state != BUF_STATE_FULL) {
2220 rc = sleep_thread(common);
2221 if (rc)
2222 return rc;
2223 }
2224 smp_rmb();
2225 rc = fsg_is_set(common) ? received_cbw(common->fsg, bh) : -EIO;
2226 bh->state = BUF_STATE_EMPTY;
2227
2228 return rc;
2229}
2230
2231
2232/*-------------------------------------------------------------------------*/
2233
2234static int enable_endpoint(struct fsg_common *common, struct usb_ep *ep,
2235 const struct usb_endpoint_descriptor *d)
2236{
2237 int rc;
2238
2239 ep->driver_data = common;
2240 rc = usb_ep_enable(ep, d);
2241 if (rc)
2242 ERROR(common, "can't enable %s, result %d\n", ep->name, rc);
2243 return rc;
2244}
2245
2246static int alloc_request(struct fsg_common *common, struct usb_ep *ep,
2247 struct usb_request **preq)
2248{
2249 *preq = usb_ep_alloc_request(ep, GFP_ATOMIC);
2250 if (*preq)
2251 return 0;
2252 ERROR(common, "can't allocate request for %s\n", ep->name);
2253 return -ENOMEM;
2254}
2255
2256/*
2257 * Reset interface setting and re-init endpoint state (toggle etc).
2258 * Call with altsetting < 0 to disable the interface. The only other
2259 * available altsetting is 0, which enables the interface.
2260 */
2261static int do_set_interface(struct fsg_common *common, int altsetting)
2262{
2263 int rc = 0;
2264 int i;
2265 const struct usb_endpoint_descriptor *d;
2266
2267 if (common->running)
2268 DBG(common, "reset interface\n");
2269
2270reset:
2271 /* Deallocate the requests */
2272 if (common->prev_fsg) {
2273 struct fsg_dev *fsg = common->prev_fsg;
2274
2275 for (i = 0; i < FSG_NUM_BUFFERS; ++i) {
2276 struct fsg_buffhd *bh = &common->buffhds[i];
2277
2278 if (bh->inreq) {
2279 usb_ep_free_request(fsg->bulk_in, bh->inreq);
2280 bh->inreq = NULL;
2281 }
2282 if (bh->outreq) {
2283 usb_ep_free_request(fsg->bulk_out, bh->outreq);
2284 bh->outreq = NULL;
2285 }
2286 }
2287
2288 /* Disable the endpoints */
2289 if (fsg->bulk_in_enabled) {
2290 usb_ep_disable(fsg->bulk_in);
2291 fsg->bulk_in_enabled = 0;
2292 }
2293 if (fsg->bulk_out_enabled) {
2294 usb_ep_disable(fsg->bulk_out);
2295 fsg->bulk_out_enabled = 0;
2296 }
2297
2298 common->prev_fsg = 0;
2299 }
2300
2301 common->running = 0;
2302 if (altsetting < 0 || rc != 0)
2303 return rc;
2304
2305 DBG(common, "set interface %d\n", altsetting);
2306
2307 if (fsg_is_set(common)) {
2308 struct fsg_dev *fsg = common->fsg;
2309 common->prev_fsg = common->fsg;
2310
2311 /* Enable the endpoints */
2312 d = fsg_ep_desc(common->gadget,
2313 &fsg_fs_bulk_in_desc, &fsg_hs_bulk_in_desc);
2314 rc = enable_endpoint(common, fsg->bulk_in, d);
2315 if (rc)
2316 goto reset;
2317 fsg->bulk_in_enabled = 1;
2318
2319 d = fsg_ep_desc(common->gadget,
2320 &fsg_fs_bulk_out_desc, &fsg_hs_bulk_out_desc);
2321 rc = enable_endpoint(common, fsg->bulk_out, d);
2322 if (rc)
2323 goto reset;
2324 fsg->bulk_out_enabled = 1;
2325 common->bulk_out_maxpacket = le16_to_cpu(d->wMaxPacketSize);
2326 clear_bit(IGNORE_BULK_OUT, &fsg->atomic_bitflags);
2327
2328 /* Allocate the requests */
2329 for (i = 0; i < FSG_NUM_BUFFERS; ++i) {
2330 struct fsg_buffhd *bh = &common->buffhds[i];
2331
2332 rc = alloc_request(common, fsg->bulk_in, &bh->inreq);
2333 if (rc)
2334 goto reset;
2335 rc = alloc_request(common, fsg->bulk_out, &bh->outreq);
2336 if (rc)
2337 goto reset;
2338 bh->inreq->buf = bh->outreq->buf = bh->buf;
2339 bh->inreq->context = bh->outreq->context = bh;
2340 bh->inreq->complete = bulk_in_complete;
2341 bh->outreq->complete = bulk_out_complete;
2342 }
2343
2344 common->running = 1;
2345 for (i = 0; i < common->nluns; ++i)
2346 common->luns[i].unit_attention_data = SS_RESET_OCCURRED;
2347 return rc;
2348 } else {
2349 return -EIO;
2350 }
2351}
2352
2353
2354/*
2355 * Change our operational configuration. This code must agree with the code
2356 * that returns config descriptors, and with interface altsetting code.
2357 *
2358 * It's also responsible for power management interactions. Some
2359 * configurations might not work with our current power sources.
2360 * For now we just assume the gadget is always self-powered.
2361 */
2362static int do_set_config(struct fsg_common *common, u8 new_config)
2363{
2364 int rc = 0;
2365
2366 /* Disable the single interface */
2367 if (common->config != 0) {
2368 DBG(common, "reset config\n");
2369 common->config = 0;
2370 rc = do_set_interface(common, -1);
2371 }
2372
2373 /* Enable the interface */
2374 if (new_config != 0) {
2375 common->config = new_config;
2376 rc = do_set_interface(common, 0);
2377 if (rc != 0)
2378 common->config = 0; /* Reset on errors */
2379 }
2380 return rc;
2381}
2382
2383
2384/****************************** ALT CONFIGS ******************************/
2385
2386
2387static int fsg_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
2388{
2389 struct fsg_dev *fsg = fsg_from_func(f);
2390 fsg->common->prev_fsg = fsg->common->fsg;
2391 fsg->common->fsg = fsg;
2392 fsg->common->new_config = 1;
2393 raise_exception(fsg->common, FSG_STATE_CONFIG_CHANGE);
2394 return 0;
2395}
2396
2397static void fsg_disable(struct usb_function *f)
2398{
2399 struct fsg_dev *fsg = fsg_from_func(f);
2400 fsg->common->prev_fsg = fsg->common->fsg;
2401 fsg->common->fsg = fsg;
2402 fsg->common->new_config = 0;
2403 raise_exception(fsg->common, FSG_STATE_CONFIG_CHANGE);
2404}
2405
2406
2407/*-------------------------------------------------------------------------*/
2408
2409static void handle_exception(struct fsg_common *common)
2410{
2411 siginfo_t info;
2412 int sig;
2413 int i;
2414 struct fsg_buffhd *bh;
2415 enum fsg_state old_state;
2416 u8 new_config;
2417 struct fsg_lun *curlun;
2418 unsigned int exception_req_tag;
2419 int rc;
2420
2421 /* Clear the existing signals. Anything but SIGUSR1 is converted
2422 * into a high-priority EXIT exception. */
2423 for (;;) {
2424 sig = dequeue_signal_lock(current, &current->blocked, &info);
2425 if (!sig)
2426 break;
2427 if (sig != SIGUSR1) {
2428 if (common->state < FSG_STATE_EXIT)
2429 DBG(common, "Main thread exiting on signal\n");
2430 raise_exception(common, FSG_STATE_EXIT);
2431 }
2432 }
2433
2434 /* Cancel all the pending transfers */
2435 if (fsg_is_set(common)) {
2436 for (i = 0; i < FSG_NUM_BUFFERS; ++i) {
2437 bh = &common->buffhds[i];
2438 if (bh->inreq_busy)
2439 usb_ep_dequeue(common->fsg->bulk_in, bh->inreq);
2440 if (bh->outreq_busy)
2441 usb_ep_dequeue(common->fsg->bulk_out,
2442 bh->outreq);
2443 }
2444
2445 /* Wait until everything is idle */
2446 for (;;) {
2447 int num_active = 0;
2448 for (i = 0; i < FSG_NUM_BUFFERS; ++i) {
2449 bh = &common->buffhds[i];
2450 num_active += bh->inreq_busy + bh->outreq_busy;
2451 }
2452 if (num_active == 0)
2453 break;
2454 if (sleep_thread(common))
2455 return;
2456 }
2457
2458 /* Clear out the controller's fifos */
2459 if (common->fsg->bulk_in_enabled)
2460 usb_ep_fifo_flush(common->fsg->bulk_in);
2461 if (common->fsg->bulk_out_enabled)
2462 usb_ep_fifo_flush(common->fsg->bulk_out);
2463 }
2464
2465 /* Reset the I/O buffer states and pointers, the SCSI
2466 * state, and the exception. Then invoke the handler. */
2467 spin_lock_irq(&common->lock);
2468
2469 for (i = 0; i < FSG_NUM_BUFFERS; ++i) {
2470 bh = &common->buffhds[i];
2471 bh->state = BUF_STATE_EMPTY;
2472 }
2473 common->next_buffhd_to_fill = &common->buffhds[0];
2474 common->next_buffhd_to_drain = &common->buffhds[0];
2475 exception_req_tag = common->exception_req_tag;
2476 new_config = common->new_config;
2477 old_state = common->state;
2478
2479 if (old_state == FSG_STATE_ABORT_BULK_OUT)
2480 common->state = FSG_STATE_STATUS_PHASE;
2481 else {
2482 for (i = 0; i < common->nluns; ++i) {
2483 curlun = &common->luns[i];
2484 curlun->prevent_medium_removal = 0;
2485 curlun->sense_data = SS_NO_SENSE;
2486 curlun->unit_attention_data = SS_NO_SENSE;
2487 curlun->sense_data_info = 0;
2488 curlun->info_valid = 0;
2489 }
2490 common->state = FSG_STATE_IDLE;
2491 }
2492 spin_unlock_irq(&common->lock);
2493
2494 /* Carry out any extra actions required for the exception */
2495 switch (old_state) {
2496 case FSG_STATE_ABORT_BULK_OUT:
2497 send_status(common);
2498 spin_lock_irq(&common->lock);
2499 if (common->state == FSG_STATE_STATUS_PHASE)
2500 common->state = FSG_STATE_IDLE;
2501 spin_unlock_irq(&common->lock);
2502 break;
2503
2504 case FSG_STATE_RESET:
2505 /* In case we were forced against our will to halt a
2506 * bulk endpoint, clear the halt now. (The SuperH UDC
2507 * requires this.) */
2508 if (!fsg_is_set(common))
2509 break;
2510 if (test_and_clear_bit(IGNORE_BULK_OUT,
2511 &common->fsg->atomic_bitflags))
2512 usb_ep_clear_halt(common->fsg->bulk_in);
2513
2514 if (common->ep0_req_tag == exception_req_tag)
2515 ep0_queue(common); /* Complete the status stage */
2516
2517 /* Technically this should go here, but it would only be
2518 * a waste of time. Ditto for the INTERFACE_CHANGE and
2519 * CONFIG_CHANGE cases. */
2520 /* for (i = 0; i < common->nluns; ++i) */
2521 /* common->luns[i].unit_attention_data = */
2522 /* SS_RESET_OCCURRED; */
2523 break;
2524
2525 case FSG_STATE_CONFIG_CHANGE:
2526 rc = do_set_config(common, new_config);
2527 if (common->ep0_req_tag != exception_req_tag)
2528 break;
2529 if (rc != 0) { /* STALL on errors */
2530 DBG(common, "ep0 set halt\n");
2531 usb_ep_set_halt(common->ep0);
2532 } else { /* Complete the status stage */
2533 ep0_queue(common);
2534 }
2535 break;
2536
2537 case FSG_STATE_EXIT:
2538 case FSG_STATE_TERMINATED:
2539 do_set_config(common, 0); /* Free resources */
2540 spin_lock_irq(&common->lock);
2541 common->state = FSG_STATE_TERMINATED; /* Stop the thread */
2542 spin_unlock_irq(&common->lock);
2543 break;
2544
2545 case FSG_STATE_INTERFACE_CHANGE:
2546 case FSG_STATE_DISCONNECT:
2547 case FSG_STATE_COMMAND_PHASE:
2548 case FSG_STATE_DATA_PHASE:
2549 case FSG_STATE_STATUS_PHASE:
2550 case FSG_STATE_IDLE:
2551 break;
2552 }
2553}
2554
2555
2556/*-------------------------------------------------------------------------*/
2557
2558static int fsg_main_thread(void *common_)
2559{
2560 struct fsg_common *common = common_;
2561
2562 /* Allow the thread to be killed by a signal, but set the signal mask
2563 * to block everything but INT, TERM, KILL, and USR1. */
2564 allow_signal(SIGINT);
2565 allow_signal(SIGTERM);
2566 allow_signal(SIGKILL);
2567 allow_signal(SIGUSR1);
2568
2569 /* Allow the thread to be frozen */
2570 set_freezable();
2571
2572 /* Arrange for userspace references to be interpreted as kernel
2573 * pointers. That way we can pass a kernel pointer to a routine
2574 * that expects a __user pointer and it will work okay. */
2575 set_fs(get_ds());
2576
2577 /* The main loop */
2578 while (common->state != FSG_STATE_TERMINATED) {
2579 if (exception_in_progress(common) || signal_pending(current)) {
2580 handle_exception(common);
2581 continue;
2582 }
2583
2584 if (!common->running) {
2585 sleep_thread(common);
2586 continue;
2587 }
2588
2589 if (get_next_command(common))
2590 continue;
2591
2592 spin_lock_irq(&common->lock);
2593 if (!exception_in_progress(common))
2594 common->state = FSG_STATE_DATA_PHASE;
2595 spin_unlock_irq(&common->lock);
2596
2597 if (do_scsi_command(common) || finish_reply(common))
2598 continue;
2599
2600 spin_lock_irq(&common->lock);
2601 if (!exception_in_progress(common))
2602 common->state = FSG_STATE_STATUS_PHASE;
2603 spin_unlock_irq(&common->lock);
2604
2605 if (send_status(common))
2606 continue;
2607
2608 spin_lock_irq(&common->lock);
2609 if (!exception_in_progress(common))
2610 common->state = FSG_STATE_IDLE;
2611 spin_unlock_irq(&common->lock);
2612 }
2613
2614 spin_lock_irq(&common->lock);
2615 common->thread_task = NULL;
2616 spin_unlock_irq(&common->lock);
2617
2618 if (common->thread_exits)
2619 common->thread_exits(common);
2620
2621 /* Let the unbind and cleanup routines know the thread has exited */
2622 complete_and_exit(&common->thread_notifier, 0);
2623}
2624
2625
2626/*************************** DEVICE ATTRIBUTES ***************************/
2627
2628/* Write permission is checked per LUN in store_*() functions. */
2629static DEVICE_ATTR(ro, 0644, fsg_show_ro, fsg_store_ro);
2630static DEVICE_ATTR(file, 0644, fsg_show_file, fsg_store_file);
2631
2632
2633/****************************** FSG COMMON ******************************/
2634
2635static void fsg_common_release(struct kref *ref);
2636
2637static void fsg_lun_release(struct device *dev)
2638{
2639 /* Nothing needs to be done */
2640}
2641
2642static inline void fsg_common_get(struct fsg_common *common)
2643{
2644 kref_get(&common->ref);
2645}
2646
2647static inline void fsg_common_put(struct fsg_common *common)
2648{
2649 kref_put(&common->ref, fsg_common_release);
2650}
2651
2652
2653static struct fsg_common *fsg_common_init(struct fsg_common *common,
2654 struct usb_composite_dev *cdev,
2655 struct fsg_config *cfg)
2656{
2657 struct usb_gadget *gadget = cdev->gadget;
2658 struct fsg_buffhd *bh;
2659 struct fsg_lun *curlun;
2660 struct fsg_lun_config *lcfg;
2661 int nluns, i, rc;
2662 char *pathbuf;
2663
2664 /* Find out how many LUNs there should be */
2665 nluns = cfg->nluns;
2666 if (nluns < 1 || nluns > FSG_MAX_LUNS) {
2667 dev_err(&gadget->dev, "invalid number of LUNs: %u\n", nluns);
2668 return ERR_PTR(-EINVAL);
2669 }
2670
2671 /* Allocate? */
2672 if (!common) {
2673 common = kzalloc(sizeof *common, GFP_KERNEL);
2674 if (!common)
2675 return ERR_PTR(-ENOMEM);
2676 common->free_storage_on_release = 1;
2677 } else {
2678 memset(common, 0, sizeof common);
2679 common->free_storage_on_release = 0;
2680 }
2681
2682 common->private_data = cfg->private_data;
2683
2684 common->gadget = gadget;
2685 common->ep0 = gadget->ep0;
2686 common->ep0req = cdev->req;
2687
2688 /* Maybe allocate device-global string IDs, and patch descriptors */
2689 if (fsg_strings[FSG_STRING_INTERFACE].id == 0) {
2690 rc = usb_string_id(cdev);
2691 if (rc < 0) {
2692 kfree(common);
2693 return ERR_PTR(rc);
2694 }
2695 fsg_strings[FSG_STRING_INTERFACE].id = rc;
2696 fsg_intf_desc.iInterface = rc;
2697 }
2698
2699 /* Create the LUNs, open their backing files, and register the
2700 * LUN devices in sysfs. */
2701 curlun = kzalloc(nluns * sizeof *curlun, GFP_KERNEL);
2702 if (!curlun) {
2703 kfree(common);
2704 return ERR_PTR(-ENOMEM);
2705 }
2706 common->luns = curlun;
2707
2708 init_rwsem(&common->filesem);
2709
2710 for (i = 0, lcfg = cfg->luns; i < nluns; ++i, ++curlun, ++lcfg) {
2711 curlun->cdrom = !!lcfg->cdrom;
2712 curlun->ro = lcfg->cdrom || lcfg->ro;
2713 curlun->removable = lcfg->removable;
2714 curlun->dev.release = fsg_lun_release;
2715 curlun->dev.parent = &gadget->dev;
2716 /* curlun->dev.driver = &fsg_driver.driver; XXX */
2717 dev_set_drvdata(&curlun->dev, &common->filesem);
2718 dev_set_name(&curlun->dev,
2719 cfg->lun_name_format
2720 ? cfg->lun_name_format
2721 : "lun%d",
2722 i);
2723
2724 rc = device_register(&curlun->dev);
2725 if (rc) {
2726 INFO(common, "failed to register LUN%d: %d\n", i, rc);
2727 common->nluns = i;
2728 goto error_release;
2729 }
2730
2731 rc = device_create_file(&curlun->dev, &dev_attr_ro);
2732 if (rc)
2733 goto error_luns;
2734 rc = device_create_file(&curlun->dev, &dev_attr_file);
2735 if (rc)
2736 goto error_luns;
2737
2738 if (lcfg->filename) {
2739 rc = fsg_lun_open(curlun, lcfg->filename);
2740 if (rc)
2741 goto error_luns;
2742 } else if (!curlun->removable) {
2743 ERROR(common, "no file given for LUN%d\n", i);
2744 rc = -EINVAL;
2745 goto error_luns;
2746 }
2747 }
2748 common->nluns = nluns;
2749
2750
2751 /* Data buffers cyclic list */
2752 /* Buffers in buffhds are static -- no need for additional
2753 * allocation. */
2754 bh = common->buffhds;
2755 i = FSG_NUM_BUFFERS - 1;
2756 do {
2757 bh->next = bh + 1;
2758 } while (++bh, --i);
2759 bh->next = common->buffhds;
2760
2761
2762 /* Prepare inquiryString */
2763 if (cfg->release != 0xffff) {
2764 i = cfg->release;
2765 } else {
2766 /* The sa1100 controller is not supported */
2767 i = gadget_is_sa1100(gadget)
2768 ? -1
2769 : usb_gadget_controller_number(gadget);
2770 if (i >= 0) {
2771 i = 0x0300 + i;
2772 } else {
2773 WARNING(common, "controller '%s' not recognized\n",
2774 gadget->name);
2775 i = 0x0399;
2776 }
2777 }
2778#define OR(x, y) ((x) ? (x) : (y))
2779 snprintf(common->inquiry_string, sizeof common->inquiry_string,
2780 "%-8s%-16s%04x",
2781 OR(cfg->vendor_name, "Linux "),
2782 /* Assume product name dependent on the first LUN */
2783 OR(cfg->product_name, common->luns->cdrom
2784 ? "File-Stor Gadget"
2785 : "File-CD Gadget "),
2786 i);
2787
2788
2789 /* Some peripheral controllers are known not to be able to
2790 * halt bulk endpoints correctly. If one of them is present,
2791 * disable stalls.
2792 */
2793 common->can_stall = cfg->can_stall &&
2794 !(gadget_is_sh(common->gadget) ||
2795 gadget_is_at91(common->gadget));
2796
2797
2798 spin_lock_init(&common->lock);
2799 kref_init(&common->ref);
2800
2801
2802 /* Tell the thread to start working */
2803 common->thread_exits = cfg->thread_exits;
2804 common->thread_task =
2805 kthread_create(fsg_main_thread, common,
2806 OR(cfg->thread_name, "file-storage"));
2807 if (IS_ERR(common->thread_task)) {
2808 rc = PTR_ERR(common->thread_task);
2809 goto error_release;
2810 }
2811 init_completion(&common->thread_notifier);
2812#undef OR
2813
2814
2815 /* Information */
2816 INFO(common, FSG_DRIVER_DESC ", version: " FSG_DRIVER_VERSION "\n");
2817 INFO(common, "Number of LUNs=%d\n", common->nluns);
2818
2819 pathbuf = kmalloc(PATH_MAX, GFP_KERNEL);
2820 for (i = 0, nluns = common->nluns, curlun = common->luns;
2821 i < nluns;
2822 ++curlun, ++i) {
2823 char *p = "(no medium)";
2824 if (fsg_lun_is_open(curlun)) {
2825 p = "(error)";
2826 if (pathbuf) {
2827 p = d_path(&curlun->filp->f_path,
2828 pathbuf, PATH_MAX);
2829 if (IS_ERR(p))
2830 p = "(error)";
2831 }
2832 }
2833 LINFO(curlun, "LUN: %s%s%sfile: %s\n",
2834 curlun->removable ? "removable " : "",
2835 curlun->ro ? "read only " : "",
2836 curlun->cdrom ? "CD-ROM " : "",
2837 p);
2838 }
2839 kfree(pathbuf);
2840
2841 DBG(common, "I/O thread pid: %d\n", task_pid_nr(common->thread_task));
2842
2843 wake_up_process(common->thread_task);
2844
2845 return common;
2846
2847
2848error_luns:
2849 common->nluns = i + 1;
2850error_release:
2851 common->state = FSG_STATE_TERMINATED; /* The thread is dead */
2852 /* Call fsg_common_release() directly, ref might be not
2853 * initialised */
2854 fsg_common_release(&common->ref);
2855 complete(&common->thread_notifier);
2856 return ERR_PTR(rc);
2857}
2858
2859
2860static void fsg_common_release(struct kref *ref)
2861{
2862 struct fsg_common *common =
2863 container_of(ref, struct fsg_common, ref);
2864 unsigned i = common->nluns;
2865 struct fsg_lun *lun = common->luns;
2866
2867 /* If the thread isn't already dead, tell it to exit now */
2868 if (common->state != FSG_STATE_TERMINATED) {
2869 raise_exception(common, FSG_STATE_EXIT);
2870 wait_for_completion(&common->thread_notifier);
2871
2872 /* The cleanup routine waits for this completion also */
2873 complete(&common->thread_notifier);
2874 }
2875
2876 /* Beware tempting for -> do-while optimization: when in error
2877 * recovery nluns may be zero. */
2878
2879 for (; i; --i, ++lun) {
2880 device_remove_file(&lun->dev, &dev_attr_ro);
2881 device_remove_file(&lun->dev, &dev_attr_file);
2882 fsg_lun_close(lun);
2883 device_unregister(&lun->dev);
2884 }
2885
2886 kfree(common->luns);
2887 if (common->free_storage_on_release)
2888 kfree(common);
2889}
2890
2891
2892/*-------------------------------------------------------------------------*/
2893
2894
2895static void fsg_unbind(struct usb_configuration *c, struct usb_function *f)
2896{
2897 struct fsg_dev *fsg = fsg_from_func(f);
2898
2899 DBG(fsg, "unbind\n");
2900 fsg_common_put(fsg->common);
2901 kfree(fsg);
2902}
2903
2904
2905static int fsg_bind(struct usb_configuration *c, struct usb_function *f)
2906{
2907 struct fsg_dev *fsg = fsg_from_func(f);
2908 struct usb_gadget *gadget = c->cdev->gadget;
2909 int rc;
2910 int i;
2911 struct usb_ep *ep;
2912
2913 fsg->gadget = gadget;
2914
2915 /* New interface */
2916 i = usb_interface_id(c, f);
2917 if (i < 0)
2918 return i;
2919 fsg_intf_desc.bInterfaceNumber = i;
2920 fsg->interface_number = i;
2921
2922 /* Find all the endpoints we will use */
2923 ep = usb_ep_autoconfig(gadget, &fsg_fs_bulk_in_desc);
2924 if (!ep)
2925 goto autoconf_fail;
2926 ep->driver_data = fsg->common; /* claim the endpoint */
2927 fsg->bulk_in = ep;
2928
2929 ep = usb_ep_autoconfig(gadget, &fsg_fs_bulk_out_desc);
2930 if (!ep)
2931 goto autoconf_fail;
2932 ep->driver_data = fsg->common; /* claim the endpoint */
2933 fsg->bulk_out = ep;
2934
2935 if (gadget_is_dualspeed(gadget)) {
2936 /* Assume endpoint addresses are the same for both speeds */
2937 fsg_hs_bulk_in_desc.bEndpointAddress =
2938 fsg_fs_bulk_in_desc.bEndpointAddress;
2939 fsg_hs_bulk_out_desc.bEndpointAddress =
2940 fsg_fs_bulk_out_desc.bEndpointAddress;
2941 f->hs_descriptors = fsg_hs_function;
2942 }
2943
2944 return 0;
2945
2946autoconf_fail:
2947 ERROR(fsg, "unable to autoconfigure all endpoints\n");
2948 rc = -ENOTSUPP;
2949 fsg_unbind(c, f);
2950 return rc;
2951}
2952
2953
2954/****************************** ADD FUNCTION ******************************/
2955
2956static struct usb_gadget_strings *fsg_strings_array[] = {
2957 &fsg_stringtab,
2958 NULL,
2959};
2960
2961static int fsg_add(struct usb_composite_dev *cdev,
2962 struct usb_configuration *c,
2963 struct fsg_common *common)
2964{
2965 struct fsg_dev *fsg;
2966 int rc;
2967
2968 fsg = kzalloc(sizeof *fsg, GFP_KERNEL);
2969 if (unlikely(!fsg))
2970 return -ENOMEM;
2971
2972 fsg->function.name = FSG_DRIVER_DESC;
2973 fsg->function.strings = fsg_strings_array;
2974 fsg->function.descriptors = fsg_fs_function;
2975 fsg->function.bind = fsg_bind;
2976 fsg->function.unbind = fsg_unbind;
2977 fsg->function.setup = fsg_setup;
2978 fsg->function.set_alt = fsg_set_alt;
2979 fsg->function.disable = fsg_disable;
2980
2981 fsg->common = common;
2982 /* Our caller holds a reference to common structure so we
2983 * don't have to be worry about it being freed until we return
2984 * from this function. So instead of incrementing counter now
2985 * and decrement in error recovery we increment it only when
2986 * call to usb_add_function() was successful. */
2987
2988 rc = usb_add_function(c, &fsg->function);
2989
2990 if (likely(rc == 0))
2991 fsg_common_get(fsg->common);
2992 else
2993 kfree(fsg);
2994
2995 return rc;
2996}
2997
2998
2999
3000/************************* Module parameters *************************/
3001
3002
3003struct fsg_module_parameters {
3004 char *file[FSG_MAX_LUNS];
3005 int ro[FSG_MAX_LUNS];
3006 int removable[FSG_MAX_LUNS];
3007 int cdrom[FSG_MAX_LUNS];
3008
3009 unsigned int file_count, ro_count, removable_count, cdrom_count;
3010 unsigned int luns; /* nluns */
3011 int stall; /* can_stall */
3012};
3013
3014
3015#define _FSG_MODULE_PARAM_ARRAY(prefix, params, name, type, desc) \
3016 module_param_array_named(prefix ## name, params.name, type, \
3017 &prefix ## params.name ## _count, \
3018 S_IRUGO); \
3019 MODULE_PARM_DESC(prefix ## name, desc)
3020
3021#define _FSG_MODULE_PARAM(prefix, params, name, type, desc) \
3022 module_param_named(prefix ## name, params.name, type, \
3023 S_IRUGO); \
3024 MODULE_PARM_DESC(prefix ## name, desc)
3025
3026#define FSG_MODULE_PARAMETERS(prefix, params) \
3027 _FSG_MODULE_PARAM_ARRAY(prefix, params, file, charp, \
3028 "names of backing files or devices"); \
3029 _FSG_MODULE_PARAM_ARRAY(prefix, params, ro, bool, \
3030 "true to force read-only"); \
3031 _FSG_MODULE_PARAM_ARRAY(prefix, params, removable, bool, \
3032 "true to simulate removable media"); \
3033 _FSG_MODULE_PARAM_ARRAY(prefix, params, cdrom, bool, \
3034 "true to simulate CD-ROM instead of disk"); \
3035 _FSG_MODULE_PARAM(prefix, params, luns, uint, \
3036 "number of LUNs"); \
3037 _FSG_MODULE_PARAM(prefix, params, stall, bool, \
3038 "false to prevent bulk stalls")
3039
3040
3041static void
3042fsg_config_from_params(struct fsg_config *cfg,
3043 const struct fsg_module_parameters *params)
3044{
3045 struct fsg_lun_config *lun;
3046 unsigned i;
3047
3048 /* Configure LUNs */
3049 cfg->nluns =
3050 min(params->luns ?: (params->file_count ?: 1u),
3051 (unsigned)FSG_MAX_LUNS);
3052 for (i = 0, lun = cfg->luns; i < cfg->nluns; ++i, ++lun) {
3053 lun->ro = !!params->ro[i];
3054 lun->cdrom = !!params->cdrom[i];
3055 lun->removable = /* Removable by default */
3056 params->removable_count <= i || params->removable[i];
3057 lun->filename =
3058 params->file_count > i && params->file[i][0]
3059 ? params->file[i]
3060 : 0;
3061 }
3062
3063 /* Let MSF use defaults */
3064 cfg->lun_name_format = 0;
3065 cfg->thread_name = 0;
3066 cfg->vendor_name = 0;
3067 cfg->product_name = 0;
3068 cfg->release = 0xffff;
3069
3070 cfg->thread_exits = 0;
3071 cfg->private_data = 0;
3072
3073 /* Finalise */
3074 cfg->can_stall = params->stall;
3075}
3076
3077static inline struct fsg_common *
3078fsg_common_from_params(struct fsg_common *common,
3079 struct usb_composite_dev *cdev,
3080 const struct fsg_module_parameters *params)
3081 __attribute__((unused));
3082static inline struct fsg_common *
3083fsg_common_from_params(struct fsg_common *common,
3084 struct usb_composite_dev *cdev,
3085 const struct fsg_module_parameters *params)
3086{
3087 struct fsg_config cfg;
3088 fsg_config_from_params(&cfg, params);
3089 return fsg_common_init(common, cdev, &cfg);
3090}
3091
diff --git a/drivers/usb/gadget/f_rndis.c b/drivers/usb/gadget/f_rndis.c
index c9966cc07d3a..95dae4c1ea40 100644
--- a/drivers/usb/gadget/f_rndis.c
+++ b/drivers/usb/gadget/f_rndis.c
@@ -4,6 +4,8 @@
4 * Copyright (C) 2003-2005,2008 David Brownell 4 * Copyright (C) 2003-2005,2008 David Brownell
5 * Copyright (C) 2003-2004 Robert Schwebel, Benedikt Spranger 5 * Copyright (C) 2003-2004 Robert Schwebel, Benedikt Spranger
6 * Copyright (C) 2008 Nokia Corporation 6 * Copyright (C) 2008 Nokia Corporation
7 * Copyright (C) 2009 Samsung Electronics
8 * Author: Michal Nazarewicz (m.nazarewicz@samsung.com)
7 * 9 *
8 * This program is free software; you can redistribute it and/or modify 10 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by 11 * it under the terms of the GNU General Public License as published by
@@ -149,8 +151,8 @@ static struct usb_cdc_call_mgmt_descriptor call_mgmt_descriptor __initdata = {
149 .bDataInterface = 0x01, 151 .bDataInterface = 0x01,
150}; 152};
151 153
152static struct usb_cdc_acm_descriptor acm_descriptor __initdata = { 154static struct usb_cdc_acm_descriptor rndis_acm_descriptor __initdata = {
153 .bLength = sizeof acm_descriptor, 155 .bLength = sizeof rndis_acm_descriptor,
154 .bDescriptorType = USB_DT_CS_INTERFACE, 156 .bDescriptorType = USB_DT_CS_INTERFACE,
155 .bDescriptorSubType = USB_CDC_ACM_TYPE, 157 .bDescriptorSubType = USB_CDC_ACM_TYPE,
156 158
@@ -179,6 +181,20 @@ static struct usb_interface_descriptor rndis_data_intf __initdata = {
179 /* .iInterface = DYNAMIC */ 181 /* .iInterface = DYNAMIC */
180}; 182};
181 183
184
185static struct usb_interface_assoc_descriptor
186rndis_iad_descriptor = {
187 .bLength = sizeof rndis_iad_descriptor,
188 .bDescriptorType = USB_DT_INTERFACE_ASSOCIATION,
189
190 .bFirstInterface = 0, /* XXX, hardcoded */
191 .bInterfaceCount = 2, // control + data
192 .bFunctionClass = USB_CLASS_COMM,
193 .bFunctionSubClass = USB_CDC_SUBCLASS_ETHERNET,
194 .bFunctionProtocol = USB_CDC_PROTO_NONE,
195 /* .iFunction = DYNAMIC */
196};
197
182/* full speed support: */ 198/* full speed support: */
183 199
184static struct usb_endpoint_descriptor fs_notify_desc __initdata = { 200static struct usb_endpoint_descriptor fs_notify_desc __initdata = {
@@ -208,11 +224,12 @@ static struct usb_endpoint_descriptor fs_out_desc __initdata = {
208}; 224};
209 225
210static struct usb_descriptor_header *eth_fs_function[] __initdata = { 226static struct usb_descriptor_header *eth_fs_function[] __initdata = {
227 (struct usb_descriptor_header *) &rndis_iad_descriptor,
211 /* control interface matches ACM, not Ethernet */ 228 /* control interface matches ACM, not Ethernet */
212 (struct usb_descriptor_header *) &rndis_control_intf, 229 (struct usb_descriptor_header *) &rndis_control_intf,
213 (struct usb_descriptor_header *) &header_desc, 230 (struct usb_descriptor_header *) &header_desc,
214 (struct usb_descriptor_header *) &call_mgmt_descriptor, 231 (struct usb_descriptor_header *) &call_mgmt_descriptor,
215 (struct usb_descriptor_header *) &acm_descriptor, 232 (struct usb_descriptor_header *) &rndis_acm_descriptor,
216 (struct usb_descriptor_header *) &rndis_union_desc, 233 (struct usb_descriptor_header *) &rndis_union_desc,
217 (struct usb_descriptor_header *) &fs_notify_desc, 234 (struct usb_descriptor_header *) &fs_notify_desc,
218 /* data interface has no altsetting */ 235 /* data interface has no altsetting */
@@ -252,11 +269,12 @@ static struct usb_endpoint_descriptor hs_out_desc __initdata = {
252}; 269};
253 270
254static struct usb_descriptor_header *eth_hs_function[] __initdata = { 271static struct usb_descriptor_header *eth_hs_function[] __initdata = {
272 (struct usb_descriptor_header *) &rndis_iad_descriptor,
255 /* control interface matches ACM, not Ethernet */ 273 /* control interface matches ACM, not Ethernet */
256 (struct usb_descriptor_header *) &rndis_control_intf, 274 (struct usb_descriptor_header *) &rndis_control_intf,
257 (struct usb_descriptor_header *) &header_desc, 275 (struct usb_descriptor_header *) &header_desc,
258 (struct usb_descriptor_header *) &call_mgmt_descriptor, 276 (struct usb_descriptor_header *) &call_mgmt_descriptor,
259 (struct usb_descriptor_header *) &acm_descriptor, 277 (struct usb_descriptor_header *) &rndis_acm_descriptor,
260 (struct usb_descriptor_header *) &rndis_union_desc, 278 (struct usb_descriptor_header *) &rndis_union_desc,
261 (struct usb_descriptor_header *) &hs_notify_desc, 279 (struct usb_descriptor_header *) &hs_notify_desc,
262 /* data interface has no altsetting */ 280 /* data interface has no altsetting */
@@ -271,6 +289,7 @@ static struct usb_descriptor_header *eth_hs_function[] __initdata = {
271static struct usb_string rndis_string_defs[] = { 289static struct usb_string rndis_string_defs[] = {
272 [0].s = "RNDIS Communications Control", 290 [0].s = "RNDIS Communications Control",
273 [1].s = "RNDIS Ethernet Data", 291 [1].s = "RNDIS Ethernet Data",
292 [2].s = "RNDIS",
274 { } /* end of list */ 293 { } /* end of list */
275}; 294};
276 295
@@ -587,6 +606,7 @@ rndis_bind(struct usb_configuration *c, struct usb_function *f)
587 if (status < 0) 606 if (status < 0)
588 goto fail; 607 goto fail;
589 rndis->ctrl_id = status; 608 rndis->ctrl_id = status;
609 rndis_iad_descriptor.bFirstInterface = status;
590 610
591 rndis_control_intf.bInterfaceNumber = status; 611 rndis_control_intf.bInterfaceNumber = status;
592 rndis_union_desc.bMasterInterface0 = status; 612 rndis_union_desc.bMasterInterface0 = status;
@@ -798,6 +818,13 @@ int __init rndis_bind_config(struct usb_configuration *c, u8 ethaddr[ETH_ALEN])
798 return status; 818 return status;
799 rndis_string_defs[1].id = status; 819 rndis_string_defs[1].id = status;
800 rndis_data_intf.iInterface = status; 820 rndis_data_intf.iInterface = status;
821
822 /* IAD iFunction label */
823 status = usb_string_id(c->cdev);
824 if (status < 0)
825 return status;
826 rndis_string_defs[2].id = status;
827 rndis_iad_descriptor.iFunction = status;
801 } 828 }
802 829
803 /* allocate and initialize one new instance */ 830 /* allocate and initialize one new instance */
diff --git a/drivers/usb/gadget/file_storage.c b/drivers/usb/gadget/file_storage.c
index 1e6aa504d58a..fca3407e48f2 100644
--- a/drivers/usb/gadget/file_storage.c
+++ b/drivers/usb/gadget/file_storage.c
@@ -248,8 +248,6 @@
248#include <linux/freezer.h> 248#include <linux/freezer.h>
249#include <linux/utsname.h> 249#include <linux/utsname.h>
250 250
251#include <asm/unaligned.h>
252
253#include <linux/usb/ch9.h> 251#include <linux/usb/ch9.h>
254#include <linux/usb/gadget.h> 252#include <linux/usb/gadget.h>
255 253
@@ -274,21 +272,20 @@
274#define DRIVER_NAME "g_file_storage" 272#define DRIVER_NAME "g_file_storage"
275#define DRIVER_VERSION "20 November 2008" 273#define DRIVER_VERSION "20 November 2008"
276 274
277static const char longname[] = DRIVER_DESC; 275static char fsg_string_manufacturer[64];
278static const char shortname[] = DRIVER_NAME; 276static const char fsg_string_product[] = DRIVER_DESC;
277static char fsg_string_serial[13];
278static const char fsg_string_config[] = "Self-powered";
279static const char fsg_string_interface[] = "Mass Storage";
280
281
282#include "storage_common.c"
283
279 284
280MODULE_DESCRIPTION(DRIVER_DESC); 285MODULE_DESCRIPTION(DRIVER_DESC);
281MODULE_AUTHOR("Alan Stern"); 286MODULE_AUTHOR("Alan Stern");
282MODULE_LICENSE("Dual BSD/GPL"); 287MODULE_LICENSE("Dual BSD/GPL");
283 288
284/* Thanks to NetChip Technologies for donating this product ID.
285 *
286 * DO NOT REUSE THESE IDs with any other driver!! Ever!!
287 * Instead: allocate your own, using normal USB-IF procedures. */
288#define DRIVER_VENDOR_ID 0x0525 // NetChip
289#define DRIVER_PRODUCT_ID 0xa4a5 // Linux-USB File-backed Storage Gadget
290
291
292/* 289/*
293 * This driver assumes self-powered hardware and has no way for users to 290 * This driver assumes self-powered hardware and has no way for users to
294 * trigger remote wakeup. It uses autoconfiguration to select endpoints 291 * trigger remote wakeup. It uses autoconfiguration to select endpoints
@@ -298,54 +295,12 @@ MODULE_LICENSE("Dual BSD/GPL");
298 295
299/*-------------------------------------------------------------------------*/ 296/*-------------------------------------------------------------------------*/
300 297
301#define LDBG(lun,fmt,args...) \
302 dev_dbg(&(lun)->dev , fmt , ## args)
303#define MDBG(fmt,args...) \
304 pr_debug(DRIVER_NAME ": " fmt , ## args)
305
306#ifndef DEBUG
307#undef VERBOSE_DEBUG
308#undef DUMP_MSGS
309#endif /* !DEBUG */
310
311#ifdef VERBOSE_DEBUG
312#define VLDBG LDBG
313#else
314#define VLDBG(lun,fmt,args...) \
315 do { } while (0)
316#endif /* VERBOSE_DEBUG */
317
318#define LERROR(lun,fmt,args...) \
319 dev_err(&(lun)->dev , fmt , ## args)
320#define LWARN(lun,fmt,args...) \
321 dev_warn(&(lun)->dev , fmt , ## args)
322#define LINFO(lun,fmt,args...) \
323 dev_info(&(lun)->dev , fmt , ## args)
324
325#define MINFO(fmt,args...) \
326 pr_info(DRIVER_NAME ": " fmt , ## args)
327
328#define DBG(d, fmt, args...) \
329 dev_dbg(&(d)->gadget->dev , fmt , ## args)
330#define VDBG(d, fmt, args...) \
331 dev_vdbg(&(d)->gadget->dev , fmt , ## args)
332#define ERROR(d, fmt, args...) \
333 dev_err(&(d)->gadget->dev , fmt , ## args)
334#define WARNING(d, fmt, args...) \
335 dev_warn(&(d)->gadget->dev , fmt , ## args)
336#define INFO(d, fmt, args...) \
337 dev_info(&(d)->gadget->dev , fmt , ## args)
338
339
340/*-------------------------------------------------------------------------*/
341 298
342/* Encapsulate the module parameter settings */ 299/* Encapsulate the module parameter settings */
343 300
344#define MAX_LUNS 8
345
346static struct { 301static struct {
347 char *file[MAX_LUNS]; 302 char *file[FSG_MAX_LUNS];
348 int ro[MAX_LUNS]; 303 int ro[FSG_MAX_LUNS];
349 unsigned int num_filenames; 304 unsigned int num_filenames;
350 unsigned int num_ros; 305 unsigned int num_ros;
351 unsigned int nluns; 306 unsigned int nluns;
@@ -372,8 +327,8 @@ static struct {
372 .removable = 0, 327 .removable = 0,
373 .can_stall = 1, 328 .can_stall = 1,
374 .cdrom = 0, 329 .cdrom = 0,
375 .vendor = DRIVER_VENDOR_ID, 330 .vendor = FSG_VENDOR_ID,
376 .product = DRIVER_PRODUCT_ID, 331 .product = FSG_PRODUCT_ID,
377 .release = 0xffff, // Use controller chip type 332 .release = 0xffff, // Use controller chip type
378 .buflen = 16384, 333 .buflen = 16384,
379 }; 334 };
@@ -425,125 +380,6 @@ MODULE_PARM_DESC(buflen, "I/O buffer size");
425#endif /* CONFIG_USB_FILE_STORAGE_TEST */ 380#endif /* CONFIG_USB_FILE_STORAGE_TEST */
426 381
427 382
428/*-------------------------------------------------------------------------*/
429
430/* SCSI device types */
431#define TYPE_DISK 0x00
432#define TYPE_CDROM 0x05
433
434/* USB protocol value = the transport method */
435#define USB_PR_CBI 0x00 // Control/Bulk/Interrupt
436#define USB_PR_CB 0x01 // Control/Bulk w/o interrupt
437#define USB_PR_BULK 0x50 // Bulk-only
438
439/* USB subclass value = the protocol encapsulation */
440#define USB_SC_RBC 0x01 // Reduced Block Commands (flash)
441#define USB_SC_8020 0x02 // SFF-8020i, MMC-2, ATAPI (CD-ROM)
442#define USB_SC_QIC 0x03 // QIC-157 (tape)
443#define USB_SC_UFI 0x04 // UFI (floppy)
444#define USB_SC_8070 0x05 // SFF-8070i (removable)
445#define USB_SC_SCSI 0x06 // Transparent SCSI
446
447/* Bulk-only data structures */
448
449/* Command Block Wrapper */
450struct bulk_cb_wrap {
451 __le32 Signature; // Contains 'USBC'
452 u32 Tag; // Unique per command id
453 __le32 DataTransferLength; // Size of the data
454 u8 Flags; // Direction in bit 7
455 u8 Lun; // LUN (normally 0)
456 u8 Length; // Of the CDB, <= MAX_COMMAND_SIZE
457 u8 CDB[16]; // Command Data Block
458};
459
460#define USB_BULK_CB_WRAP_LEN 31
461#define USB_BULK_CB_SIG 0x43425355 // Spells out USBC
462#define USB_BULK_IN_FLAG 0x80
463
464/* Command Status Wrapper */
465struct bulk_cs_wrap {
466 __le32 Signature; // Should = 'USBS'
467 u32 Tag; // Same as original command
468 __le32 Residue; // Amount not transferred
469 u8 Status; // See below
470};
471
472#define USB_BULK_CS_WRAP_LEN 13
473#define USB_BULK_CS_SIG 0x53425355 // Spells out 'USBS'
474#define USB_STATUS_PASS 0
475#define USB_STATUS_FAIL 1
476#define USB_STATUS_PHASE_ERROR 2
477
478/* Bulk-only class specific requests */
479#define USB_BULK_RESET_REQUEST 0xff
480#define USB_BULK_GET_MAX_LUN_REQUEST 0xfe
481
482
483/* CBI Interrupt data structure */
484struct interrupt_data {
485 u8 bType;
486 u8 bValue;
487};
488
489#define CBI_INTERRUPT_DATA_LEN 2
490
491/* CBI Accept Device-Specific Command request */
492#define USB_CBI_ADSC_REQUEST 0x00
493
494
495#define MAX_COMMAND_SIZE 16 // Length of a SCSI Command Data Block
496
497/* SCSI commands that we recognize */
498#define SC_FORMAT_UNIT 0x04
499#define SC_INQUIRY 0x12
500#define SC_MODE_SELECT_6 0x15
501#define SC_MODE_SELECT_10 0x55
502#define SC_MODE_SENSE_6 0x1a
503#define SC_MODE_SENSE_10 0x5a
504#define SC_PREVENT_ALLOW_MEDIUM_REMOVAL 0x1e
505#define SC_READ_6 0x08
506#define SC_READ_10 0x28
507#define SC_READ_12 0xa8
508#define SC_READ_CAPACITY 0x25
509#define SC_READ_FORMAT_CAPACITIES 0x23
510#define SC_READ_HEADER 0x44
511#define SC_READ_TOC 0x43
512#define SC_RELEASE 0x17
513#define SC_REQUEST_SENSE 0x03
514#define SC_RESERVE 0x16
515#define SC_SEND_DIAGNOSTIC 0x1d
516#define SC_START_STOP_UNIT 0x1b
517#define SC_SYNCHRONIZE_CACHE 0x35
518#define SC_TEST_UNIT_READY 0x00
519#define SC_VERIFY 0x2f
520#define SC_WRITE_6 0x0a
521#define SC_WRITE_10 0x2a
522#define SC_WRITE_12 0xaa
523
524/* SCSI Sense Key/Additional Sense Code/ASC Qualifier values */
525#define SS_NO_SENSE 0
526#define SS_COMMUNICATION_FAILURE 0x040800
527#define SS_INVALID_COMMAND 0x052000
528#define SS_INVALID_FIELD_IN_CDB 0x052400
529#define SS_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE 0x052100
530#define SS_LOGICAL_UNIT_NOT_SUPPORTED 0x052500
531#define SS_MEDIUM_NOT_PRESENT 0x023a00
532#define SS_MEDIUM_REMOVAL_PREVENTED 0x055302
533#define SS_NOT_READY_TO_READY_TRANSITION 0x062800
534#define SS_RESET_OCCURRED 0x062900
535#define SS_SAVING_PARAMETERS_NOT_SUPPORTED 0x053900
536#define SS_UNRECOVERED_READ_ERROR 0x031100
537#define SS_WRITE_ERROR 0x030c02
538#define SS_WRITE_PROTECTED 0x072700
539
540#define SK(x) ((u8) ((x) >> 16)) // Sense Key byte, etc.
541#define ASC(x) ((u8) ((x) >> 8))
542#define ASCQ(x) ((u8) (x))
543
544
545/*-------------------------------------------------------------------------*/
546
547/* 383/*
548 * These definitions will permit the compiler to avoid generating code for 384 * These definitions will permit the compiler to avoid generating code for
549 * parts of the driver that aren't used in the non-TEST version. Even gcc 385 * parts of the driver that aren't used in the non-TEST version. Even gcc
@@ -566,81 +402,8 @@ struct interrupt_data {
566#endif /* CONFIG_USB_FILE_STORAGE_TEST */ 402#endif /* CONFIG_USB_FILE_STORAGE_TEST */
567 403
568 404
569struct lun { 405/*-------------------------------------------------------------------------*/
570 struct file *filp;
571 loff_t file_length;
572 loff_t num_sectors;
573
574 unsigned int ro : 1;
575 unsigned int prevent_medium_removal : 1;
576 unsigned int registered : 1;
577 unsigned int info_valid : 1;
578
579 u32 sense_data;
580 u32 sense_data_info;
581 u32 unit_attention_data;
582
583 struct device dev;
584};
585
586#define backing_file_is_open(curlun) ((curlun)->filp != NULL)
587
588static struct lun *dev_to_lun(struct device *dev)
589{
590 return container_of(dev, struct lun, dev);
591}
592
593
594/* Big enough to hold our biggest descriptor */
595#define EP0_BUFSIZE 256
596#define DELAYED_STATUS (EP0_BUFSIZE + 999) // An impossibly large value
597
598/* Number of buffers we will use. 2 is enough for double-buffering */
599#define NUM_BUFFERS 2
600
601enum fsg_buffer_state {
602 BUF_STATE_EMPTY = 0,
603 BUF_STATE_FULL,
604 BUF_STATE_BUSY
605};
606
607struct fsg_buffhd {
608 void *buf;
609 enum fsg_buffer_state state;
610 struct fsg_buffhd *next;
611
612 /* The NetChip 2280 is faster, and handles some protocol faults
613 * better, if we don't submit any short bulk-out read requests.
614 * So we will record the intended request length here. */
615 unsigned int bulk_out_intended_length;
616
617 struct usb_request *inreq;
618 int inreq_busy;
619 struct usb_request *outreq;
620 int outreq_busy;
621};
622
623enum fsg_state {
624 FSG_STATE_COMMAND_PHASE = -10, // This one isn't used anywhere
625 FSG_STATE_DATA_PHASE,
626 FSG_STATE_STATUS_PHASE,
627
628 FSG_STATE_IDLE = 0,
629 FSG_STATE_ABORT_BULK_OUT,
630 FSG_STATE_RESET,
631 FSG_STATE_INTERFACE_CHANGE,
632 FSG_STATE_CONFIG_CHANGE,
633 FSG_STATE_DISCONNECT,
634 FSG_STATE_EXIT,
635 FSG_STATE_TERMINATED
636};
637 406
638enum data_direction {
639 DATA_DIR_UNKNOWN = 0,
640 DATA_DIR_FROM_HOST,
641 DATA_DIR_TO_HOST,
642 DATA_DIR_NONE
643};
644 407
645struct fsg_dev { 408struct fsg_dev {
646 /* lock protects: state, all the req_busy's, and cbbuf_cmnd */ 409 /* lock protects: state, all the req_busy's, and cbbuf_cmnd */
@@ -662,7 +425,7 @@ struct fsg_dev {
662 int intreq_busy; 425 int intreq_busy;
663 struct fsg_buffhd *intr_buffhd; 426 struct fsg_buffhd *intr_buffhd;
664 427
665 unsigned int bulk_out_maxpacket; 428 unsigned int bulk_out_maxpacket;
666 enum fsg_state state; // For exception handling 429 enum fsg_state state; // For exception handling
667 unsigned int exception_req_tag; 430 unsigned int exception_req_tag;
668 431
@@ -687,7 +450,7 @@ struct fsg_dev {
687 450
688 struct fsg_buffhd *next_buffhd_to_fill; 451 struct fsg_buffhd *next_buffhd_to_fill;
689 struct fsg_buffhd *next_buffhd_to_drain; 452 struct fsg_buffhd *next_buffhd_to_drain;
690 struct fsg_buffhd buffhds[NUM_BUFFERS]; 453 struct fsg_buffhd buffhds[FSG_NUM_BUFFERS];
691 454
692 int thread_wakeup_needed; 455 int thread_wakeup_needed;
693 struct completion thread_notifier; 456 struct completion thread_notifier;
@@ -712,8 +475,8 @@ struct fsg_dev {
712 u8 cbbuf_cmnd[MAX_COMMAND_SIZE]; 475 u8 cbbuf_cmnd[MAX_COMMAND_SIZE];
713 476
714 unsigned int nluns; 477 unsigned int nluns;
715 struct lun *luns; 478 struct fsg_lun *luns;
716 struct lun *curlun; 479 struct fsg_lun *curlun;
717}; 480};
718 481
719typedef void (*fsg_routine_t)(struct fsg_dev *); 482typedef void (*fsg_routine_t)(struct fsg_dev *);
@@ -739,49 +502,9 @@ static void set_bulk_out_req_length(struct fsg_dev *fsg,
739static struct fsg_dev *the_fsg; 502static struct fsg_dev *the_fsg;
740static struct usb_gadget_driver fsg_driver; 503static struct usb_gadget_driver fsg_driver;
741 504
742static void close_backing_file(struct lun *curlun);
743
744 505
745/*-------------------------------------------------------------------------*/ 506/*-------------------------------------------------------------------------*/
746 507
747#ifdef DUMP_MSGS
748
749static void dump_msg(struct fsg_dev *fsg, const char *label,
750 const u8 *buf, unsigned int length)
751{
752 if (length < 512) {
753 DBG(fsg, "%s, length %u:\n", label, length);
754 print_hex_dump(KERN_DEBUG, "", DUMP_PREFIX_OFFSET,
755 16, 1, buf, length, 0);
756 }
757}
758
759static void dump_cdb(struct fsg_dev *fsg)
760{}
761
762#else
763
764static void dump_msg(struct fsg_dev *fsg, const char *label,
765 const u8 *buf, unsigned int length)
766{}
767
768#ifdef VERBOSE_DEBUG
769
770static void dump_cdb(struct fsg_dev *fsg)
771{
772 print_hex_dump(KERN_DEBUG, "SCSI CDB: ", DUMP_PREFIX_NONE,
773 16, 1, fsg->cmnd, fsg->cmnd_size, 0);
774}
775
776#else
777
778static void dump_cdb(struct fsg_dev *fsg)
779{}
780
781#endif /* VERBOSE_DEBUG */
782#endif /* DUMP_MSGS */
783
784
785static int fsg_set_halt(struct fsg_dev *fsg, struct usb_ep *ep) 508static int fsg_set_halt(struct fsg_dev *fsg, struct usb_ep *ep)
786{ 509{
787 const char *name; 510 const char *name;
@@ -799,26 +522,11 @@ static int fsg_set_halt(struct fsg_dev *fsg, struct usb_ep *ep)
799 522
800/*-------------------------------------------------------------------------*/ 523/*-------------------------------------------------------------------------*/
801 524
802/* Routines for unaligned data access */
803
804static u32 get_unaligned_be24(u8 *buf)
805{
806 return 0xffffff & (u32) get_unaligned_be32(buf - 1);
807}
808
809
810/*-------------------------------------------------------------------------*/
811
812/* 525/*
813 * DESCRIPTORS ... most are static, but strings and (full) configuration 526 * DESCRIPTORS ... most are static, but strings and (full) configuration
814 * descriptors are built on demand. Also the (static) config and interface 527 * descriptors are built on demand. Also the (static) config and interface
815 * descriptors are adjusted during fsg_bind(). 528 * descriptors are adjusted during fsg_bind().
816 */ 529 */
817#define STRING_MANUFACTURER 1
818#define STRING_PRODUCT 2
819#define STRING_SERIAL 3
820#define STRING_CONFIG 4
821#define STRING_INTERFACE 5
822 530
823/* There is only one configuration. */ 531/* There is only one configuration. */
824#define CONFIG_VALUE 1 532#define CONFIG_VALUE 1
@@ -832,13 +540,13 @@ device_desc = {
832 .bDeviceClass = USB_CLASS_PER_INTERFACE, 540 .bDeviceClass = USB_CLASS_PER_INTERFACE,
833 541
834 /* The next three values can be overridden by module parameters */ 542 /* The next three values can be overridden by module parameters */
835 .idVendor = cpu_to_le16(DRIVER_VENDOR_ID), 543 .idVendor = cpu_to_le16(FSG_VENDOR_ID),
836 .idProduct = cpu_to_le16(DRIVER_PRODUCT_ID), 544 .idProduct = cpu_to_le16(FSG_PRODUCT_ID),
837 .bcdDevice = cpu_to_le16(0xffff), 545 .bcdDevice = cpu_to_le16(0xffff),
838 546
839 .iManufacturer = STRING_MANUFACTURER, 547 .iManufacturer = FSG_STRING_MANUFACTURER,
840 .iProduct = STRING_PRODUCT, 548 .iProduct = FSG_STRING_PRODUCT,
841 .iSerialNumber = STRING_SERIAL, 549 .iSerialNumber = FSG_STRING_SERIAL,
842 .bNumConfigurations = 1, 550 .bNumConfigurations = 1,
843}; 551};
844 552
@@ -850,86 +558,12 @@ config_desc = {
850 /* wTotalLength computed by usb_gadget_config_buf() */ 558 /* wTotalLength computed by usb_gadget_config_buf() */
851 .bNumInterfaces = 1, 559 .bNumInterfaces = 1,
852 .bConfigurationValue = CONFIG_VALUE, 560 .bConfigurationValue = CONFIG_VALUE,
853 .iConfiguration = STRING_CONFIG, 561 .iConfiguration = FSG_STRING_CONFIG,
854 .bmAttributes = USB_CONFIG_ATT_ONE | USB_CONFIG_ATT_SELFPOWER, 562 .bmAttributes = USB_CONFIG_ATT_ONE | USB_CONFIG_ATT_SELFPOWER,
855 .bMaxPower = CONFIG_USB_GADGET_VBUS_DRAW / 2, 563 .bMaxPower = CONFIG_USB_GADGET_VBUS_DRAW / 2,
856}; 564};
857 565
858static struct usb_otg_descriptor
859otg_desc = {
860 .bLength = sizeof(otg_desc),
861 .bDescriptorType = USB_DT_OTG,
862
863 .bmAttributes = USB_OTG_SRP,
864};
865
866/* There is only one interface. */
867 566
868static struct usb_interface_descriptor
869intf_desc = {
870 .bLength = sizeof intf_desc,
871 .bDescriptorType = USB_DT_INTERFACE,
872
873 .bNumEndpoints = 2, // Adjusted during fsg_bind()
874 .bInterfaceClass = USB_CLASS_MASS_STORAGE,
875 .bInterfaceSubClass = USB_SC_SCSI, // Adjusted during fsg_bind()
876 .bInterfaceProtocol = USB_PR_BULK, // Adjusted during fsg_bind()
877 .iInterface = STRING_INTERFACE,
878};
879
880/* Three full-speed endpoint descriptors: bulk-in, bulk-out,
881 * and interrupt-in. */
882
883static struct usb_endpoint_descriptor
884fs_bulk_in_desc = {
885 .bLength = USB_DT_ENDPOINT_SIZE,
886 .bDescriptorType = USB_DT_ENDPOINT,
887
888 .bEndpointAddress = USB_DIR_IN,
889 .bmAttributes = USB_ENDPOINT_XFER_BULK,
890 /* wMaxPacketSize set by autoconfiguration */
891};
892
893static struct usb_endpoint_descriptor
894fs_bulk_out_desc = {
895 .bLength = USB_DT_ENDPOINT_SIZE,
896 .bDescriptorType = USB_DT_ENDPOINT,
897
898 .bEndpointAddress = USB_DIR_OUT,
899 .bmAttributes = USB_ENDPOINT_XFER_BULK,
900 /* wMaxPacketSize set by autoconfiguration */
901};
902
903static struct usb_endpoint_descriptor
904fs_intr_in_desc = {
905 .bLength = USB_DT_ENDPOINT_SIZE,
906 .bDescriptorType = USB_DT_ENDPOINT,
907
908 .bEndpointAddress = USB_DIR_IN,
909 .bmAttributes = USB_ENDPOINT_XFER_INT,
910 .wMaxPacketSize = cpu_to_le16(2),
911 .bInterval = 32, // frames -> 32 ms
912};
913
914static const struct usb_descriptor_header *fs_function[] = {
915 (struct usb_descriptor_header *) &otg_desc,
916 (struct usb_descriptor_header *) &intf_desc,
917 (struct usb_descriptor_header *) &fs_bulk_in_desc,
918 (struct usb_descriptor_header *) &fs_bulk_out_desc,
919 (struct usb_descriptor_header *) &fs_intr_in_desc,
920 NULL,
921};
922#define FS_FUNCTION_PRE_EP_ENTRIES 2
923
924
925/*
926 * USB 2.0 devices need to expose both high speed and full speed
927 * descriptors, unless they only run at full speed.
928 *
929 * That means alternate endpoint descriptors (bigger packets)
930 * and a "device qualifier" ... plus more construction options
931 * for the config descriptor.
932 */
933static struct usb_qualifier_descriptor 567static struct usb_qualifier_descriptor
934dev_qualifier = { 568dev_qualifier = {
935 .bLength = sizeof dev_qualifier, 569 .bLength = sizeof dev_qualifier,
@@ -941,78 +575,6 @@ dev_qualifier = {
941 .bNumConfigurations = 1, 575 .bNumConfigurations = 1,
942}; 576};
943 577
944static struct usb_endpoint_descriptor
945hs_bulk_in_desc = {
946 .bLength = USB_DT_ENDPOINT_SIZE,
947 .bDescriptorType = USB_DT_ENDPOINT,
948
949 /* bEndpointAddress copied from fs_bulk_in_desc during fsg_bind() */
950 .bmAttributes = USB_ENDPOINT_XFER_BULK,
951 .wMaxPacketSize = cpu_to_le16(512),
952};
953
954static struct usb_endpoint_descriptor
955hs_bulk_out_desc = {
956 .bLength = USB_DT_ENDPOINT_SIZE,
957 .bDescriptorType = USB_DT_ENDPOINT,
958
959 /* bEndpointAddress copied from fs_bulk_out_desc during fsg_bind() */
960 .bmAttributes = USB_ENDPOINT_XFER_BULK,
961 .wMaxPacketSize = cpu_to_le16(512),
962 .bInterval = 1, // NAK every 1 uframe
963};
964
965static struct usb_endpoint_descriptor
966hs_intr_in_desc = {
967 .bLength = USB_DT_ENDPOINT_SIZE,
968 .bDescriptorType = USB_DT_ENDPOINT,
969
970 /* bEndpointAddress copied from fs_intr_in_desc during fsg_bind() */
971 .bmAttributes = USB_ENDPOINT_XFER_INT,
972 .wMaxPacketSize = cpu_to_le16(2),
973 .bInterval = 9, // 2**(9-1) = 256 uframes -> 32 ms
974};
975
976static const struct usb_descriptor_header *hs_function[] = {
977 (struct usb_descriptor_header *) &otg_desc,
978 (struct usb_descriptor_header *) &intf_desc,
979 (struct usb_descriptor_header *) &hs_bulk_in_desc,
980 (struct usb_descriptor_header *) &hs_bulk_out_desc,
981 (struct usb_descriptor_header *) &hs_intr_in_desc,
982 NULL,
983};
984#define HS_FUNCTION_PRE_EP_ENTRIES 2
985
986/* Maxpacket and other transfer characteristics vary by speed. */
987static struct usb_endpoint_descriptor *
988ep_desc(struct usb_gadget *g, struct usb_endpoint_descriptor *fs,
989 struct usb_endpoint_descriptor *hs)
990{
991 if (gadget_is_dualspeed(g) && g->speed == USB_SPEED_HIGH)
992 return hs;
993 return fs;
994}
995
996
997/* The CBI specification limits the serial string to 12 uppercase hexadecimal
998 * characters. */
999static char manufacturer[64];
1000static char serial[13];
1001
1002/* Static strings, in UTF-8 (for simplicity we use only ASCII characters) */
1003static struct usb_string strings[] = {
1004 {STRING_MANUFACTURER, manufacturer},
1005 {STRING_PRODUCT, longname},
1006 {STRING_SERIAL, serial},
1007 {STRING_CONFIG, "Self-powered"},
1008 {STRING_INTERFACE, "Mass Storage"},
1009 {}
1010};
1011
1012static struct usb_gadget_strings stringtab = {
1013 .language = 0x0409, // en-us
1014 .strings = strings,
1015};
1016 578
1017 579
1018/* 580/*
@@ -1032,10 +594,9 @@ static int populate_config_buf(struct usb_gadget *gadget,
1032 594
1033 if (gadget_is_dualspeed(gadget) && type == USB_DT_OTHER_SPEED_CONFIG) 595 if (gadget_is_dualspeed(gadget) && type == USB_DT_OTHER_SPEED_CONFIG)
1034 speed = (USB_SPEED_FULL + USB_SPEED_HIGH) - speed; 596 speed = (USB_SPEED_FULL + USB_SPEED_HIGH) - speed;
1035 if (gadget_is_dualspeed(gadget) && speed == USB_SPEED_HIGH) 597 function = gadget_is_dualspeed(gadget) && speed == USB_SPEED_HIGH
1036 function = hs_function; 598 ? (const struct usb_descriptor_header **)fsg_hs_function
1037 else 599 : (const struct usb_descriptor_header **)fsg_fs_function;
1038 function = fs_function;
1039 600
1040 /* for now, don't advertise srp-only devices */ 601 /* for now, don't advertise srp-only devices */
1041 if (!gadget_is_otg(gadget)) 602 if (!gadget_is_otg(gadget))
@@ -1386,7 +947,7 @@ get_config:
1386 VDBG(fsg, "get string descriptor\n"); 947 VDBG(fsg, "get string descriptor\n");
1387 948
1388 /* wIndex == language code */ 949 /* wIndex == language code */
1389 value = usb_gadget_get_string(&stringtab, 950 value = usb_gadget_get_string(&fsg_stringtab,
1390 w_value & 0xff, req->buf); 951 w_value & 0xff, req->buf);
1391 break; 952 break;
1392 } 953 }
@@ -1551,7 +1112,7 @@ static int sleep_thread(struct fsg_dev *fsg)
1551 1112
1552static int do_read(struct fsg_dev *fsg) 1113static int do_read(struct fsg_dev *fsg)
1553{ 1114{
1554 struct lun *curlun = fsg->curlun; 1115 struct fsg_lun *curlun = fsg->curlun;
1555 u32 lba; 1116 u32 lba;
1556 struct fsg_buffhd *bh; 1117 struct fsg_buffhd *bh;
1557 int rc; 1118 int rc;
@@ -1677,7 +1238,7 @@ static int do_read(struct fsg_dev *fsg)
1677 1238
1678static int do_write(struct fsg_dev *fsg) 1239static int do_write(struct fsg_dev *fsg)
1679{ 1240{
1680 struct lun *curlun = fsg->curlun; 1241 struct fsg_lun *curlun = fsg->curlun;
1681 u32 lba; 1242 u32 lba;
1682 struct fsg_buffhd *bh; 1243 struct fsg_buffhd *bh;
1683 int get_some_more; 1244 int get_some_more;
@@ -1864,33 +1425,14 @@ static int do_write(struct fsg_dev *fsg)
1864 1425
1865/*-------------------------------------------------------------------------*/ 1426/*-------------------------------------------------------------------------*/
1866 1427
1867/* Sync the file data, don't bother with the metadata.
1868 * This code was copied from fs/buffer.c:sys_fdatasync(). */
1869static int fsync_sub(struct lun *curlun)
1870{
1871 struct file *filp = curlun->filp;
1872
1873 if (curlun->ro || !filp)
1874 return 0;
1875 return vfs_fsync(filp, filp->f_path.dentry, 1);
1876}
1877
1878static void fsync_all(struct fsg_dev *fsg)
1879{
1880 int i;
1881
1882 for (i = 0; i < fsg->nluns; ++i)
1883 fsync_sub(&fsg->luns[i]);
1884}
1885
1886static int do_synchronize_cache(struct fsg_dev *fsg) 1428static int do_synchronize_cache(struct fsg_dev *fsg)
1887{ 1429{
1888 struct lun *curlun = fsg->curlun; 1430 struct fsg_lun *curlun = fsg->curlun;
1889 int rc; 1431 int rc;
1890 1432
1891 /* We ignore the requested LBA and write out all file's 1433 /* We ignore the requested LBA and write out all file's
1892 * dirty data buffers. */ 1434 * dirty data buffers. */
1893 rc = fsync_sub(curlun); 1435 rc = fsg_lun_fsync_sub(curlun);
1894 if (rc) 1436 if (rc)
1895 curlun->sense_data = SS_WRITE_ERROR; 1437 curlun->sense_data = SS_WRITE_ERROR;
1896 return 0; 1438 return 0;
@@ -1899,7 +1441,7 @@ static int do_synchronize_cache(struct fsg_dev *fsg)
1899 1441
1900/*-------------------------------------------------------------------------*/ 1442/*-------------------------------------------------------------------------*/
1901 1443
1902static void invalidate_sub(struct lun *curlun) 1444static void invalidate_sub(struct fsg_lun *curlun)
1903{ 1445{
1904 struct file *filp = curlun->filp; 1446 struct file *filp = curlun->filp;
1905 struct inode *inode = filp->f_path.dentry->d_inode; 1447 struct inode *inode = filp->f_path.dentry->d_inode;
@@ -1911,7 +1453,7 @@ static void invalidate_sub(struct lun *curlun)
1911 1453
1912static int do_verify(struct fsg_dev *fsg) 1454static int do_verify(struct fsg_dev *fsg)
1913{ 1455{
1914 struct lun *curlun = fsg->curlun; 1456 struct fsg_lun *curlun = fsg->curlun;
1915 u32 lba; 1457 u32 lba;
1916 u32 verification_length; 1458 u32 verification_length;
1917 struct fsg_buffhd *bh = fsg->next_buffhd_to_fill; 1459 struct fsg_buffhd *bh = fsg->next_buffhd_to_fill;
@@ -1944,7 +1486,7 @@ static int do_verify(struct fsg_dev *fsg)
1944 file_offset = ((loff_t) lba) << 9; 1486 file_offset = ((loff_t) lba) << 9;
1945 1487
1946 /* Write out all the dirty buffers before invalidating them */ 1488 /* Write out all the dirty buffers before invalidating them */
1947 fsync_sub(curlun); 1489 fsg_lun_fsync_sub(curlun);
1948 if (signal_pending(current)) 1490 if (signal_pending(current))
1949 return -EINTR; 1491 return -EINTR;
1950 1492
@@ -2041,7 +1583,7 @@ static int do_inquiry(struct fsg_dev *fsg, struct fsg_buffhd *bh)
2041 1583
2042static int do_request_sense(struct fsg_dev *fsg, struct fsg_buffhd *bh) 1584static int do_request_sense(struct fsg_dev *fsg, struct fsg_buffhd *bh)
2043{ 1585{
2044 struct lun *curlun = fsg->curlun; 1586 struct fsg_lun *curlun = fsg->curlun;
2045 u8 *buf = (u8 *) bh->buf; 1587 u8 *buf = (u8 *) bh->buf;
2046 u32 sd, sdinfo; 1588 u32 sd, sdinfo;
2047 int valid; 1589 int valid;
@@ -2095,7 +1637,7 @@ static int do_request_sense(struct fsg_dev *fsg, struct fsg_buffhd *bh)
2095 1637
2096static int do_read_capacity(struct fsg_dev *fsg, struct fsg_buffhd *bh) 1638static int do_read_capacity(struct fsg_dev *fsg, struct fsg_buffhd *bh)
2097{ 1639{
2098 struct lun *curlun = fsg->curlun; 1640 struct fsg_lun *curlun = fsg->curlun;
2099 u32 lba = get_unaligned_be32(&fsg->cmnd[2]); 1641 u32 lba = get_unaligned_be32(&fsg->cmnd[2]);
2100 int pmi = fsg->cmnd[8]; 1642 int pmi = fsg->cmnd[8];
2101 u8 *buf = (u8 *) bh->buf; 1643 u8 *buf = (u8 *) bh->buf;
@@ -2113,27 +1655,9 @@ static int do_read_capacity(struct fsg_dev *fsg, struct fsg_buffhd *bh)
2113} 1655}
2114 1656
2115 1657
2116static void store_cdrom_address(u8 *dest, int msf, u32 addr)
2117{
2118 if (msf) {
2119 /* Convert to Minutes-Seconds-Frames */
2120 addr >>= 2; /* Convert to 2048-byte frames */
2121 addr += 2*75; /* Lead-in occupies 2 seconds */
2122 dest[3] = addr % 75; /* Frames */
2123 addr /= 75;
2124 dest[2] = addr % 60; /* Seconds */
2125 addr /= 60;
2126 dest[1] = addr; /* Minutes */
2127 dest[0] = 0; /* Reserved */
2128 } else {
2129 /* Absolute sector */
2130 put_unaligned_be32(addr, dest);
2131 }
2132}
2133
2134static int do_read_header(struct fsg_dev *fsg, struct fsg_buffhd *bh) 1658static int do_read_header(struct fsg_dev *fsg, struct fsg_buffhd *bh)
2135{ 1659{
2136 struct lun *curlun = fsg->curlun; 1660 struct fsg_lun *curlun = fsg->curlun;
2137 int msf = fsg->cmnd[1] & 0x02; 1661 int msf = fsg->cmnd[1] & 0x02;
2138 u32 lba = get_unaligned_be32(&fsg->cmnd[2]); 1662 u32 lba = get_unaligned_be32(&fsg->cmnd[2]);
2139 u8 *buf = (u8 *) bh->buf; 1663 u8 *buf = (u8 *) bh->buf;
@@ -2156,7 +1680,7 @@ static int do_read_header(struct fsg_dev *fsg, struct fsg_buffhd *bh)
2156 1680
2157static int do_read_toc(struct fsg_dev *fsg, struct fsg_buffhd *bh) 1681static int do_read_toc(struct fsg_dev *fsg, struct fsg_buffhd *bh)
2158{ 1682{
2159 struct lun *curlun = fsg->curlun; 1683 struct fsg_lun *curlun = fsg->curlun;
2160 int msf = fsg->cmnd[1] & 0x02; 1684 int msf = fsg->cmnd[1] & 0x02;
2161 int start_track = fsg->cmnd[6]; 1685 int start_track = fsg->cmnd[6];
2162 u8 *buf = (u8 *) bh->buf; 1686 u8 *buf = (u8 *) bh->buf;
@@ -2184,7 +1708,7 @@ static int do_read_toc(struct fsg_dev *fsg, struct fsg_buffhd *bh)
2184 1708
2185static int do_mode_sense(struct fsg_dev *fsg, struct fsg_buffhd *bh) 1709static int do_mode_sense(struct fsg_dev *fsg, struct fsg_buffhd *bh)
2186{ 1710{
2187 struct lun *curlun = fsg->curlun; 1711 struct fsg_lun *curlun = fsg->curlun;
2188 int mscmnd = fsg->cmnd[0]; 1712 int mscmnd = fsg->cmnd[0];
2189 u8 *buf = (u8 *) bh->buf; 1713 u8 *buf = (u8 *) bh->buf;
2190 u8 *buf0 = buf; 1714 u8 *buf0 = buf;
@@ -2265,7 +1789,7 @@ static int do_mode_sense(struct fsg_dev *fsg, struct fsg_buffhd *bh)
2265 1789
2266static int do_start_stop(struct fsg_dev *fsg) 1790static int do_start_stop(struct fsg_dev *fsg)
2267{ 1791{
2268 struct lun *curlun = fsg->curlun; 1792 struct fsg_lun *curlun = fsg->curlun;
2269 int loej, start; 1793 int loej, start;
2270 1794
2271 if (!mod_data.removable) { 1795 if (!mod_data.removable) {
@@ -2295,7 +1819,7 @@ static int do_start_stop(struct fsg_dev *fsg)
2295 if (loej) { // Simulate an unload/eject 1819 if (loej) { // Simulate an unload/eject
2296 up_read(&fsg->filesem); 1820 up_read(&fsg->filesem);
2297 down_write(&fsg->filesem); 1821 down_write(&fsg->filesem);
2298 close_backing_file(curlun); 1822 fsg_lun_close(curlun);
2299 up_write(&fsg->filesem); 1823 up_write(&fsg->filesem);
2300 down_read(&fsg->filesem); 1824 down_read(&fsg->filesem);
2301 } 1825 }
@@ -2303,7 +1827,7 @@ static int do_start_stop(struct fsg_dev *fsg)
2303 1827
2304 /* Our emulation doesn't support mounting; the medium is 1828 /* Our emulation doesn't support mounting; the medium is
2305 * available for use as soon as it is loaded. */ 1829 * available for use as soon as it is loaded. */
2306 if (!backing_file_is_open(curlun)) { 1830 if (!fsg_lun_is_open(curlun)) {
2307 curlun->sense_data = SS_MEDIUM_NOT_PRESENT; 1831 curlun->sense_data = SS_MEDIUM_NOT_PRESENT;
2308 return -EINVAL; 1832 return -EINVAL;
2309 } 1833 }
@@ -2315,7 +1839,7 @@ static int do_start_stop(struct fsg_dev *fsg)
2315 1839
2316static int do_prevent_allow(struct fsg_dev *fsg) 1840static int do_prevent_allow(struct fsg_dev *fsg)
2317{ 1841{
2318 struct lun *curlun = fsg->curlun; 1842 struct fsg_lun *curlun = fsg->curlun;
2319 int prevent; 1843 int prevent;
2320 1844
2321 if (!mod_data.removable) { 1845 if (!mod_data.removable) {
@@ -2330,7 +1854,7 @@ static int do_prevent_allow(struct fsg_dev *fsg)
2330 } 1854 }
2331 1855
2332 if (curlun->prevent_medium_removal && !prevent) 1856 if (curlun->prevent_medium_removal && !prevent)
2333 fsync_sub(curlun); 1857 fsg_lun_fsync_sub(curlun);
2334 curlun->prevent_medium_removal = prevent; 1858 curlun->prevent_medium_removal = prevent;
2335 return 0; 1859 return 0;
2336} 1860}
@@ -2339,7 +1863,7 @@ static int do_prevent_allow(struct fsg_dev *fsg)
2339static int do_read_format_capacities(struct fsg_dev *fsg, 1863static int do_read_format_capacities(struct fsg_dev *fsg,
2340 struct fsg_buffhd *bh) 1864 struct fsg_buffhd *bh)
2341{ 1865{
2342 struct lun *curlun = fsg->curlun; 1866 struct fsg_lun *curlun = fsg->curlun;
2343 u8 *buf = (u8 *) bh->buf; 1867 u8 *buf = (u8 *) bh->buf;
2344 1868
2345 buf[0] = buf[1] = buf[2] = 0; 1869 buf[0] = buf[1] = buf[2] = 0;
@@ -2356,7 +1880,7 @@ static int do_read_format_capacities(struct fsg_dev *fsg,
2356 1880
2357static int do_mode_select(struct fsg_dev *fsg, struct fsg_buffhd *bh) 1881static int do_mode_select(struct fsg_dev *fsg, struct fsg_buffhd *bh)
2358{ 1882{
2359 struct lun *curlun = fsg->curlun; 1883 struct fsg_lun *curlun = fsg->curlun;
2360 1884
2361 /* We don't support MODE SELECT */ 1885 /* We don't support MODE SELECT */
2362 curlun->sense_data = SS_INVALID_COMMAND; 1886 curlun->sense_data = SS_INVALID_COMMAND;
@@ -2599,7 +2123,7 @@ static int finish_reply(struct fsg_dev *fsg)
2599 2123
2600static int send_status(struct fsg_dev *fsg) 2124static int send_status(struct fsg_dev *fsg)
2601{ 2125{
2602 struct lun *curlun = fsg->curlun; 2126 struct fsg_lun *curlun = fsg->curlun;
2603 struct fsg_buffhd *bh; 2127 struct fsg_buffhd *bh;
2604 int rc; 2128 int rc;
2605 u8 status = USB_STATUS_PASS; 2129 u8 status = USB_STATUS_PASS;
@@ -2691,7 +2215,7 @@ static int check_command(struct fsg_dev *fsg, int cmnd_size,
2691 int lun = fsg->cmnd[1] >> 5; 2215 int lun = fsg->cmnd[1] >> 5;
2692 static const char dirletter[4] = {'u', 'o', 'i', 'n'}; 2216 static const char dirletter[4] = {'u', 'o', 'i', 'n'};
2693 char hdlen[20]; 2217 char hdlen[20];
2694 struct lun *curlun; 2218 struct fsg_lun *curlun;
2695 2219
2696 /* Adjust the expected cmnd_size for protocol encapsulation padding. 2220 /* Adjust the expected cmnd_size for protocol encapsulation padding.
2697 * Transparent SCSI doesn't pad. */ 2221 * Transparent SCSI doesn't pad. */
@@ -2820,7 +2344,7 @@ static int check_command(struct fsg_dev *fsg, int cmnd_size,
2820 2344
2821 /* If the medium isn't mounted and the command needs to access 2345 /* If the medium isn't mounted and the command needs to access
2822 * it, return an error. */ 2346 * it, return an error. */
2823 if (curlun && !backing_file_is_open(curlun) && needs_medium) { 2347 if (curlun && !fsg_lun_is_open(curlun) && needs_medium) {
2824 curlun->sense_data = SS_MEDIUM_NOT_PRESENT; 2348 curlun->sense_data = SS_MEDIUM_NOT_PRESENT;
2825 return -EINVAL; 2349 return -EINVAL;
2826 } 2350 }
@@ -3075,8 +2599,8 @@ static int do_scsi_command(struct fsg_dev *fsg)
3075 2599
3076static int received_cbw(struct fsg_dev *fsg, struct fsg_buffhd *bh) 2600static int received_cbw(struct fsg_dev *fsg, struct fsg_buffhd *bh)
3077{ 2601{
3078 struct usb_request *req = bh->outreq; 2602 struct usb_request *req = bh->outreq;
3079 struct bulk_cb_wrap *cbw = req->buf; 2603 struct fsg_bulk_cb_wrap *cbw = req->buf;
3080 2604
3081 /* Was this a real packet? Should it be ignored? */ 2605 /* Was this a real packet? Should it be ignored? */
3082 if (req->status || test_bit(IGNORE_BULK_OUT, &fsg->atomic_bitflags)) 2606 if (req->status || test_bit(IGNORE_BULK_OUT, &fsg->atomic_bitflags))
@@ -3105,7 +2629,7 @@ static int received_cbw(struct fsg_dev *fsg, struct fsg_buffhd *bh)
3105 } 2629 }
3106 2630
3107 /* Is the CBW meaningful? */ 2631 /* Is the CBW meaningful? */
3108 if (cbw->Lun >= MAX_LUNS || cbw->Flags & ~USB_BULK_IN_FLAG || 2632 if (cbw->Lun >= FSG_MAX_LUNS || cbw->Flags & ~USB_BULK_IN_FLAG ||
3109 cbw->Length <= 0 || cbw->Length > MAX_COMMAND_SIZE) { 2633 cbw->Length <= 0 || cbw->Length > MAX_COMMAND_SIZE) {
3110 DBG(fsg, "non-meaningful CBW: lun = %u, flags = 0x%x, " 2634 DBG(fsg, "non-meaningful CBW: lun = %u, flags = 0x%x, "
3111 "cmdlen %u\n", 2635 "cmdlen %u\n",
@@ -3238,7 +2762,7 @@ static int do_set_interface(struct fsg_dev *fsg, int altsetting)
3238 2762
3239reset: 2763reset:
3240 /* Deallocate the requests */ 2764 /* Deallocate the requests */
3241 for (i = 0; i < NUM_BUFFERS; ++i) { 2765 for (i = 0; i < FSG_NUM_BUFFERS; ++i) {
3242 struct fsg_buffhd *bh = &fsg->buffhds[i]; 2766 struct fsg_buffhd *bh = &fsg->buffhds[i];
3243 2767
3244 if (bh->inreq) { 2768 if (bh->inreq) {
@@ -3276,12 +2800,14 @@ reset:
3276 DBG(fsg, "set interface %d\n", altsetting); 2800 DBG(fsg, "set interface %d\n", altsetting);
3277 2801
3278 /* Enable the endpoints */ 2802 /* Enable the endpoints */
3279 d = ep_desc(fsg->gadget, &fs_bulk_in_desc, &hs_bulk_in_desc); 2803 d = fsg_ep_desc(fsg->gadget,
2804 &fsg_fs_bulk_in_desc, &fsg_hs_bulk_in_desc);
3280 if ((rc = enable_endpoint(fsg, fsg->bulk_in, d)) != 0) 2805 if ((rc = enable_endpoint(fsg, fsg->bulk_in, d)) != 0)
3281 goto reset; 2806 goto reset;
3282 fsg->bulk_in_enabled = 1; 2807 fsg->bulk_in_enabled = 1;
3283 2808
3284 d = ep_desc(fsg->gadget, &fs_bulk_out_desc, &hs_bulk_out_desc); 2809 d = fsg_ep_desc(fsg->gadget,
2810 &fsg_fs_bulk_out_desc, &fsg_hs_bulk_out_desc);
3285 if ((rc = enable_endpoint(fsg, fsg->bulk_out, d)) != 0) 2811 if ((rc = enable_endpoint(fsg, fsg->bulk_out, d)) != 0)
3286 goto reset; 2812 goto reset;
3287 fsg->bulk_out_enabled = 1; 2813 fsg->bulk_out_enabled = 1;
@@ -3289,14 +2815,15 @@ reset:
3289 clear_bit(IGNORE_BULK_OUT, &fsg->atomic_bitflags); 2815 clear_bit(IGNORE_BULK_OUT, &fsg->atomic_bitflags);
3290 2816
3291 if (transport_is_cbi()) { 2817 if (transport_is_cbi()) {
3292 d = ep_desc(fsg->gadget, &fs_intr_in_desc, &hs_intr_in_desc); 2818 d = fsg_ep_desc(fsg->gadget,
2819 &fsg_fs_intr_in_desc, &fsg_hs_intr_in_desc);
3293 if ((rc = enable_endpoint(fsg, fsg->intr_in, d)) != 0) 2820 if ((rc = enable_endpoint(fsg, fsg->intr_in, d)) != 0)
3294 goto reset; 2821 goto reset;
3295 fsg->intr_in_enabled = 1; 2822 fsg->intr_in_enabled = 1;
3296 } 2823 }
3297 2824
3298 /* Allocate the requests */ 2825 /* Allocate the requests */
3299 for (i = 0; i < NUM_BUFFERS; ++i) { 2826 for (i = 0; i < FSG_NUM_BUFFERS; ++i) {
3300 struct fsg_buffhd *bh = &fsg->buffhds[i]; 2827 struct fsg_buffhd *bh = &fsg->buffhds[i];
3301 2828
3302 if ((rc = alloc_request(fsg, fsg->bulk_in, &bh->inreq)) != 0) 2829 if ((rc = alloc_request(fsg, fsg->bulk_in, &bh->inreq)) != 0)
@@ -3372,7 +2899,7 @@ static void handle_exception(struct fsg_dev *fsg)
3372 struct fsg_buffhd *bh; 2899 struct fsg_buffhd *bh;
3373 enum fsg_state old_state; 2900 enum fsg_state old_state;
3374 u8 new_config; 2901 u8 new_config;
3375 struct lun *curlun; 2902 struct fsg_lun *curlun;
3376 unsigned int exception_req_tag; 2903 unsigned int exception_req_tag;
3377 int rc; 2904 int rc;
3378 2905
@@ -3392,7 +2919,7 @@ static void handle_exception(struct fsg_dev *fsg)
3392 /* Cancel all the pending transfers */ 2919 /* Cancel all the pending transfers */
3393 if (fsg->intreq_busy) 2920 if (fsg->intreq_busy)
3394 usb_ep_dequeue(fsg->intr_in, fsg->intreq); 2921 usb_ep_dequeue(fsg->intr_in, fsg->intreq);
3395 for (i = 0; i < NUM_BUFFERS; ++i) { 2922 for (i = 0; i < FSG_NUM_BUFFERS; ++i) {
3396 bh = &fsg->buffhds[i]; 2923 bh = &fsg->buffhds[i];
3397 if (bh->inreq_busy) 2924 if (bh->inreq_busy)
3398 usb_ep_dequeue(fsg->bulk_in, bh->inreq); 2925 usb_ep_dequeue(fsg->bulk_in, bh->inreq);
@@ -3403,7 +2930,7 @@ static void handle_exception(struct fsg_dev *fsg)
3403 /* Wait until everything is idle */ 2930 /* Wait until everything is idle */
3404 for (;;) { 2931 for (;;) {
3405 num_active = fsg->intreq_busy; 2932 num_active = fsg->intreq_busy;
3406 for (i = 0; i < NUM_BUFFERS; ++i) { 2933 for (i = 0; i < FSG_NUM_BUFFERS; ++i) {
3407 bh = &fsg->buffhds[i]; 2934 bh = &fsg->buffhds[i];
3408 num_active += bh->inreq_busy + bh->outreq_busy; 2935 num_active += bh->inreq_busy + bh->outreq_busy;
3409 } 2936 }
@@ -3425,7 +2952,7 @@ static void handle_exception(struct fsg_dev *fsg)
3425 * state, and the exception. Then invoke the handler. */ 2952 * state, and the exception. Then invoke the handler. */
3426 spin_lock_irq(&fsg->lock); 2953 spin_lock_irq(&fsg->lock);
3427 2954
3428 for (i = 0; i < NUM_BUFFERS; ++i) { 2955 for (i = 0; i < FSG_NUM_BUFFERS; ++i) {
3429 bh = &fsg->buffhds[i]; 2956 bh = &fsg->buffhds[i];
3430 bh->state = BUF_STATE_EMPTY; 2957 bh->state = BUF_STATE_EMPTY;
3431 } 2958 }
@@ -3506,7 +3033,8 @@ static void handle_exception(struct fsg_dev *fsg)
3506 break; 3033 break;
3507 3034
3508 case FSG_STATE_DISCONNECT: 3035 case FSG_STATE_DISCONNECT:
3509 fsync_all(fsg); 3036 for (i = 0; i < fsg->nluns; ++i)
3037 fsg_lun_fsync_sub(fsg->luns + i);
3510 do_set_config(fsg, 0); // Unconfigured state 3038 do_set_config(fsg, 0); // Unconfigured state
3511 break; 3039 break;
3512 3040
@@ -3595,201 +3123,10 @@ static int fsg_main_thread(void *fsg_)
3595 3123
3596/*-------------------------------------------------------------------------*/ 3124/*-------------------------------------------------------------------------*/
3597 3125
3598/* If the next two routines are called while the gadget is registered,
3599 * the caller must own fsg->filesem for writing. */
3600
3601static int open_backing_file(struct lun *curlun, const char *filename)
3602{
3603 int ro;
3604 struct file *filp = NULL;
3605 int rc = -EINVAL;
3606 struct inode *inode = NULL;
3607 loff_t size;
3608 loff_t num_sectors;
3609 loff_t min_sectors;
3610
3611 /* R/W if we can, R/O if we must */
3612 ro = curlun->ro;
3613 if (!ro) {
3614 filp = filp_open(filename, O_RDWR | O_LARGEFILE, 0);
3615 if (-EROFS == PTR_ERR(filp))
3616 ro = 1;
3617 }
3618 if (ro)
3619 filp = filp_open(filename, O_RDONLY | O_LARGEFILE, 0);
3620 if (IS_ERR(filp)) {
3621 LINFO(curlun, "unable to open backing file: %s\n", filename);
3622 return PTR_ERR(filp);
3623 }
3624
3625 if (!(filp->f_mode & FMODE_WRITE))
3626 ro = 1;
3627
3628 if (filp->f_path.dentry)
3629 inode = filp->f_path.dentry->d_inode;
3630 if (inode && S_ISBLK(inode->i_mode)) {
3631 if (bdev_read_only(inode->i_bdev))
3632 ro = 1;
3633 } else if (!inode || !S_ISREG(inode->i_mode)) {
3634 LINFO(curlun, "invalid file type: %s\n", filename);
3635 goto out;
3636 }
3637
3638 /* If we can't read the file, it's no good.
3639 * If we can't write the file, use it read-only. */
3640 if (!filp->f_op || !(filp->f_op->read || filp->f_op->aio_read)) {
3641 LINFO(curlun, "file not readable: %s\n", filename);
3642 goto out;
3643 }
3644 if (!(filp->f_op->write || filp->f_op->aio_write))
3645 ro = 1;
3646
3647 size = i_size_read(inode->i_mapping->host);
3648 if (size < 0) {
3649 LINFO(curlun, "unable to find file size: %s\n", filename);
3650 rc = (int) size;
3651 goto out;
3652 }
3653 num_sectors = size >> 9; // File size in 512-byte blocks
3654 min_sectors = 1;
3655 if (mod_data.cdrom) {
3656 num_sectors &= ~3; // Reduce to a multiple of 2048
3657 min_sectors = 300*4; // Smallest track is 300 frames
3658 if (num_sectors >= 256*60*75*4) {
3659 num_sectors = (256*60*75 - 1) * 4;
3660 LINFO(curlun, "file too big: %s\n", filename);
3661 LINFO(curlun, "using only first %d blocks\n",
3662 (int) num_sectors);
3663 }
3664 }
3665 if (num_sectors < min_sectors) {
3666 LINFO(curlun, "file too small: %s\n", filename);
3667 rc = -ETOOSMALL;
3668 goto out;
3669 }
3670
3671 get_file(filp);
3672 curlun->ro = ro;
3673 curlun->filp = filp;
3674 curlun->file_length = size;
3675 curlun->num_sectors = num_sectors;
3676 LDBG(curlun, "open backing file: %s\n", filename);
3677 rc = 0;
3678
3679out:
3680 filp_close(filp, current->files);
3681 return rc;
3682}
3683
3684
3685static void close_backing_file(struct lun *curlun)
3686{
3687 if (curlun->filp) {
3688 LDBG(curlun, "close backing file\n");
3689 fput(curlun->filp);
3690 curlun->filp = NULL;
3691 }
3692}
3693
3694
3695static ssize_t show_ro(struct device *dev, struct device_attribute *attr, char *buf)
3696{
3697 struct lun *curlun = dev_to_lun(dev);
3698
3699 return sprintf(buf, "%d\n", curlun->ro);
3700}
3701
3702static ssize_t show_file(struct device *dev, struct device_attribute *attr,
3703 char *buf)
3704{
3705 struct lun *curlun = dev_to_lun(dev);
3706 struct fsg_dev *fsg = dev_get_drvdata(dev);
3707 char *p;
3708 ssize_t rc;
3709
3710 down_read(&fsg->filesem);
3711 if (backing_file_is_open(curlun)) { // Get the complete pathname
3712 p = d_path(&curlun->filp->f_path, buf, PAGE_SIZE - 1);
3713 if (IS_ERR(p))
3714 rc = PTR_ERR(p);
3715 else {
3716 rc = strlen(p);
3717 memmove(buf, p, rc);
3718 buf[rc] = '\n'; // Add a newline
3719 buf[++rc] = 0;
3720 }
3721 } else { // No file, return 0 bytes
3722 *buf = 0;
3723 rc = 0;
3724 }
3725 up_read(&fsg->filesem);
3726 return rc;
3727}
3728
3729
3730static ssize_t store_ro(struct device *dev, struct device_attribute *attr,
3731 const char *buf, size_t count)
3732{
3733 ssize_t rc = count;
3734 struct lun *curlun = dev_to_lun(dev);
3735 struct fsg_dev *fsg = dev_get_drvdata(dev);
3736 int i;
3737
3738 if (sscanf(buf, "%d", &i) != 1)
3739 return -EINVAL;
3740
3741 /* Allow the write-enable status to change only while the backing file
3742 * is closed. */
3743 down_read(&fsg->filesem);
3744 if (backing_file_is_open(curlun)) {
3745 LDBG(curlun, "read-only status change prevented\n");
3746 rc = -EBUSY;
3747 } else {
3748 curlun->ro = !!i;
3749 LDBG(curlun, "read-only status set to %d\n", curlun->ro);
3750 }
3751 up_read(&fsg->filesem);
3752 return rc;
3753}
3754
3755static ssize_t store_file(struct device *dev, struct device_attribute *attr,
3756 const char *buf, size_t count)
3757{
3758 struct lun *curlun = dev_to_lun(dev);
3759 struct fsg_dev *fsg = dev_get_drvdata(dev);
3760 int rc = 0;
3761
3762 if (curlun->prevent_medium_removal && backing_file_is_open(curlun)) {
3763 LDBG(curlun, "eject attempt prevented\n");
3764 return -EBUSY; // "Door is locked"
3765 }
3766
3767 /* Remove a trailing newline */
3768 if (count > 0 && buf[count-1] == '\n')
3769 ((char *) buf)[count-1] = 0; // Ugh!
3770
3771 /* Eject current medium */
3772 down_write(&fsg->filesem);
3773 if (backing_file_is_open(curlun)) {
3774 close_backing_file(curlun);
3775 curlun->unit_attention_data = SS_MEDIUM_NOT_PRESENT;
3776 }
3777
3778 /* Load new medium */
3779 if (count > 0 && buf[0]) {
3780 rc = open_backing_file(curlun, buf);
3781 if (rc == 0)
3782 curlun->unit_attention_data =
3783 SS_NOT_READY_TO_READY_TRANSITION;
3784 }
3785 up_write(&fsg->filesem);
3786 return (rc < 0 ? rc : count);
3787}
3788
3789 3126
3790/* The write permissions and store_xxx pointers are set in fsg_bind() */ 3127/* The write permissions and store_xxx pointers are set in fsg_bind() */
3791static DEVICE_ATTR(ro, 0444, show_ro, NULL); 3128static DEVICE_ATTR(ro, 0444, fsg_show_ro, NULL);
3792static DEVICE_ATTR(file, 0444, show_file, NULL); 3129static DEVICE_ATTR(file, 0444, fsg_show_file, NULL);
3793 3130
3794 3131
3795/*-------------------------------------------------------------------------*/ 3132/*-------------------------------------------------------------------------*/
@@ -3804,7 +3141,9 @@ static void fsg_release(struct kref *ref)
3804 3141
3805static void lun_release(struct device *dev) 3142static void lun_release(struct device *dev)
3806{ 3143{
3807 struct fsg_dev *fsg = dev_get_drvdata(dev); 3144 struct rw_semaphore *filesem = dev_get_drvdata(dev);
3145 struct fsg_dev *fsg =
3146 container_of(filesem, struct fsg_dev, filesem);
3808 3147
3809 kref_put(&fsg->ref, fsg_release); 3148 kref_put(&fsg->ref, fsg_release);
3810} 3149}
@@ -3813,7 +3152,7 @@ static void /* __init_or_exit */ fsg_unbind(struct usb_gadget *gadget)
3813{ 3152{
3814 struct fsg_dev *fsg = get_gadget_data(gadget); 3153 struct fsg_dev *fsg = get_gadget_data(gadget);
3815 int i; 3154 int i;
3816 struct lun *curlun; 3155 struct fsg_lun *curlun;
3817 struct usb_request *req = fsg->ep0req; 3156 struct usb_request *req = fsg->ep0req;
3818 3157
3819 DBG(fsg, "unbind\n"); 3158 DBG(fsg, "unbind\n");
@@ -3825,7 +3164,7 @@ static void /* __init_or_exit */ fsg_unbind(struct usb_gadget *gadget)
3825 if (curlun->registered) { 3164 if (curlun->registered) {
3826 device_remove_file(&curlun->dev, &dev_attr_ro); 3165 device_remove_file(&curlun->dev, &dev_attr_ro);
3827 device_remove_file(&curlun->dev, &dev_attr_file); 3166 device_remove_file(&curlun->dev, &dev_attr_file);
3828 close_backing_file(curlun); 3167 fsg_lun_close(curlun);
3829 device_unregister(&curlun->dev); 3168 device_unregister(&curlun->dev);
3830 curlun->registered = 0; 3169 curlun->registered = 0;
3831 } 3170 }
@@ -3841,7 +3180,7 @@ static void /* __init_or_exit */ fsg_unbind(struct usb_gadget *gadget)
3841 } 3180 }
3842 3181
3843 /* Free the data buffers */ 3182 /* Free the data buffers */
3844 for (i = 0; i < NUM_BUFFERS; ++i) 3183 for (i = 0; i < FSG_NUM_BUFFERS; ++i)
3845 kfree(fsg->buffhds[i].buf); 3184 kfree(fsg->buffhds[i].buf);
3846 3185
3847 /* Free the request and buffer for endpoint 0 */ 3186 /* Free the request and buffer for endpoint 0 */
@@ -3948,7 +3287,7 @@ static int __init fsg_bind(struct usb_gadget *gadget)
3948 struct fsg_dev *fsg = the_fsg; 3287 struct fsg_dev *fsg = the_fsg;
3949 int rc; 3288 int rc;
3950 int i; 3289 int i;
3951 struct lun *curlun; 3290 struct fsg_lun *curlun;
3952 struct usb_ep *ep; 3291 struct usb_ep *ep;
3953 struct usb_request *req; 3292 struct usb_request *req;
3954 char *pathbuf, *p; 3293 char *pathbuf, *p;
@@ -3963,10 +3302,10 @@ static int __init fsg_bind(struct usb_gadget *gadget)
3963 3302
3964 if (mod_data.removable) { // Enable the store_xxx attributes 3303 if (mod_data.removable) { // Enable the store_xxx attributes
3965 dev_attr_file.attr.mode = 0644; 3304 dev_attr_file.attr.mode = 0644;
3966 dev_attr_file.store = store_file; 3305 dev_attr_file.store = fsg_store_file;
3967 if (!mod_data.cdrom) { 3306 if (!mod_data.cdrom) {
3968 dev_attr_ro.attr.mode = 0644; 3307 dev_attr_ro.attr.mode = 0644;
3969 dev_attr_ro.store = store_ro; 3308 dev_attr_ro.store = fsg_store_ro;
3970 } 3309 }
3971 } 3310 }
3972 3311
@@ -3974,7 +3313,7 @@ static int __init fsg_bind(struct usb_gadget *gadget)
3974 i = mod_data.nluns; 3313 i = mod_data.nluns;
3975 if (i == 0) 3314 if (i == 0)
3976 i = max(mod_data.num_filenames, 1u); 3315 i = max(mod_data.num_filenames, 1u);
3977 if (i > MAX_LUNS) { 3316 if (i > FSG_MAX_LUNS) {
3978 ERROR(fsg, "invalid number of LUNs: %d\n", i); 3317 ERROR(fsg, "invalid number of LUNs: %d\n", i);
3979 rc = -EINVAL; 3318 rc = -EINVAL;
3980 goto out; 3319 goto out;
@@ -3982,7 +3321,7 @@ static int __init fsg_bind(struct usb_gadget *gadget)
3982 3321
3983 /* Create the LUNs, open their backing files, and register the 3322 /* Create the LUNs, open their backing files, and register the
3984 * LUN devices in sysfs. */ 3323 * LUN devices in sysfs. */
3985 fsg->luns = kzalloc(i * sizeof(struct lun), GFP_KERNEL); 3324 fsg->luns = kzalloc(i * sizeof(struct fsg_lun), GFP_KERNEL);
3986 if (!fsg->luns) { 3325 if (!fsg->luns) {
3987 rc = -ENOMEM; 3326 rc = -ENOMEM;
3988 goto out; 3327 goto out;
@@ -3991,13 +3330,14 @@ static int __init fsg_bind(struct usb_gadget *gadget)
3991 3330
3992 for (i = 0; i < fsg->nluns; ++i) { 3331 for (i = 0; i < fsg->nluns; ++i) {
3993 curlun = &fsg->luns[i]; 3332 curlun = &fsg->luns[i];
3994 curlun->ro = mod_data.ro[i]; 3333 curlun->cdrom = !!mod_data.cdrom;
3995 if (mod_data.cdrom) 3334 curlun->ro = mod_data.cdrom || mod_data.ro[i];
3996 curlun->ro = 1; 3335 curlun->initially_ro = curlun->ro;
3336 curlun->removable = mod_data.removable;
3997 curlun->dev.release = lun_release; 3337 curlun->dev.release = lun_release;
3998 curlun->dev.parent = &gadget->dev; 3338 curlun->dev.parent = &gadget->dev;
3999 curlun->dev.driver = &fsg_driver.driver; 3339 curlun->dev.driver = &fsg_driver.driver;
4000 dev_set_drvdata(&curlun->dev, fsg); 3340 dev_set_drvdata(&curlun->dev, &fsg->filesem);
4001 dev_set_name(&curlun->dev,"%s-lun%d", 3341 dev_set_name(&curlun->dev,"%s-lun%d",
4002 dev_name(&gadget->dev), i); 3342 dev_name(&gadget->dev), i);
4003 3343
@@ -4016,7 +3356,7 @@ static int __init fsg_bind(struct usb_gadget *gadget)
4016 kref_get(&fsg->ref); 3356 kref_get(&fsg->ref);
4017 3357
4018 if (mod_data.file[i] && *mod_data.file[i]) { 3358 if (mod_data.file[i] && *mod_data.file[i]) {
4019 if ((rc = open_backing_file(curlun, 3359 if ((rc = fsg_lun_open(curlun,
4020 mod_data.file[i])) != 0) 3360 mod_data.file[i])) != 0)
4021 goto out; 3361 goto out;
4022 } else if (!mod_data.removable) { 3362 } else if (!mod_data.removable) {
@@ -4028,20 +3368,20 @@ static int __init fsg_bind(struct usb_gadget *gadget)
4028 3368
4029 /* Find all the endpoints we will use */ 3369 /* Find all the endpoints we will use */
4030 usb_ep_autoconfig_reset(gadget); 3370 usb_ep_autoconfig_reset(gadget);
4031 ep = usb_ep_autoconfig(gadget, &fs_bulk_in_desc); 3371 ep = usb_ep_autoconfig(gadget, &fsg_fs_bulk_in_desc);
4032 if (!ep) 3372 if (!ep)
4033 goto autoconf_fail; 3373 goto autoconf_fail;
4034 ep->driver_data = fsg; // claim the endpoint 3374 ep->driver_data = fsg; // claim the endpoint
4035 fsg->bulk_in = ep; 3375 fsg->bulk_in = ep;
4036 3376
4037 ep = usb_ep_autoconfig(gadget, &fs_bulk_out_desc); 3377 ep = usb_ep_autoconfig(gadget, &fsg_fs_bulk_out_desc);
4038 if (!ep) 3378 if (!ep)
4039 goto autoconf_fail; 3379 goto autoconf_fail;
4040 ep->driver_data = fsg; // claim the endpoint 3380 ep->driver_data = fsg; // claim the endpoint
4041 fsg->bulk_out = ep; 3381 fsg->bulk_out = ep;
4042 3382
4043 if (transport_is_cbi()) { 3383 if (transport_is_cbi()) {
4044 ep = usb_ep_autoconfig(gadget, &fs_intr_in_desc); 3384 ep = usb_ep_autoconfig(gadget, &fsg_fs_intr_in_desc);
4045 if (!ep) 3385 if (!ep)
4046 goto autoconf_fail; 3386 goto autoconf_fail;
4047 ep->driver_data = fsg; // claim the endpoint 3387 ep->driver_data = fsg; // claim the endpoint
@@ -4055,28 +3395,28 @@ static int __init fsg_bind(struct usb_gadget *gadget)
4055 device_desc.bcdDevice = cpu_to_le16(mod_data.release); 3395 device_desc.bcdDevice = cpu_to_le16(mod_data.release);
4056 3396
4057 i = (transport_is_cbi() ? 3 : 2); // Number of endpoints 3397 i = (transport_is_cbi() ? 3 : 2); // Number of endpoints
4058 intf_desc.bNumEndpoints = i; 3398 fsg_intf_desc.bNumEndpoints = i;
4059 intf_desc.bInterfaceSubClass = mod_data.protocol_type; 3399 fsg_intf_desc.bInterfaceSubClass = mod_data.protocol_type;
4060 intf_desc.bInterfaceProtocol = mod_data.transport_type; 3400 fsg_intf_desc.bInterfaceProtocol = mod_data.transport_type;
4061 fs_function[i + FS_FUNCTION_PRE_EP_ENTRIES] = NULL; 3401 fsg_fs_function[i + FSG_FS_FUNCTION_PRE_EP_ENTRIES] = NULL;
4062 3402
4063 if (gadget_is_dualspeed(gadget)) { 3403 if (gadget_is_dualspeed(gadget)) {
4064 hs_function[i + HS_FUNCTION_PRE_EP_ENTRIES] = NULL; 3404 fsg_hs_function[i + FSG_HS_FUNCTION_PRE_EP_ENTRIES] = NULL;
4065 3405
4066 /* Assume ep0 uses the same maxpacket value for both speeds */ 3406 /* Assume ep0 uses the same maxpacket value for both speeds */
4067 dev_qualifier.bMaxPacketSize0 = fsg->ep0->maxpacket; 3407 dev_qualifier.bMaxPacketSize0 = fsg->ep0->maxpacket;
4068 3408
4069 /* Assume endpoint addresses are the same for both speeds */ 3409 /* Assume endpoint addresses are the same for both speeds */
4070 hs_bulk_in_desc.bEndpointAddress = 3410 fsg_hs_bulk_in_desc.bEndpointAddress =
4071 fs_bulk_in_desc.bEndpointAddress; 3411 fsg_fs_bulk_in_desc.bEndpointAddress;
4072 hs_bulk_out_desc.bEndpointAddress = 3412 fsg_hs_bulk_out_desc.bEndpointAddress =
4073 fs_bulk_out_desc.bEndpointAddress; 3413 fsg_fs_bulk_out_desc.bEndpointAddress;
4074 hs_intr_in_desc.bEndpointAddress = 3414 fsg_hs_intr_in_desc.bEndpointAddress =
4075 fs_intr_in_desc.bEndpointAddress; 3415 fsg_fs_intr_in_desc.bEndpointAddress;
4076 } 3416 }
4077 3417
4078 if (gadget_is_otg(gadget)) 3418 if (gadget_is_otg(gadget))
4079 otg_desc.bmAttributes |= USB_OTG_HNP; 3419 fsg_otg_desc.bmAttributes |= USB_OTG_HNP;
4080 3420
4081 rc = -ENOMEM; 3421 rc = -ENOMEM;
4082 3422
@@ -4090,7 +3430,7 @@ static int __init fsg_bind(struct usb_gadget *gadget)
4090 req->complete = ep0_complete; 3430 req->complete = ep0_complete;
4091 3431
4092 /* Allocate the data buffers */ 3432 /* Allocate the data buffers */
4093 for (i = 0; i < NUM_BUFFERS; ++i) { 3433 for (i = 0; i < FSG_NUM_BUFFERS; ++i) {
4094 struct fsg_buffhd *bh = &fsg->buffhds[i]; 3434 struct fsg_buffhd *bh = &fsg->buffhds[i];
4095 3435
4096 /* Allocate for the bulk-in endpoint. We assume that 3436 /* Allocate for the bulk-in endpoint. We assume that
@@ -4101,23 +3441,24 @@ static int __init fsg_bind(struct usb_gadget *gadget)
4101 goto out; 3441 goto out;
4102 bh->next = bh + 1; 3442 bh->next = bh + 1;
4103 } 3443 }
4104 fsg->buffhds[NUM_BUFFERS - 1].next = &fsg->buffhds[0]; 3444 fsg->buffhds[FSG_NUM_BUFFERS - 1].next = &fsg->buffhds[0];
4105 3445
4106 /* This should reflect the actual gadget power source */ 3446 /* This should reflect the actual gadget power source */
4107 usb_gadget_set_selfpowered(gadget); 3447 usb_gadget_set_selfpowered(gadget);
4108 3448
4109 snprintf(manufacturer, sizeof manufacturer, "%s %s with %s", 3449 snprintf(fsg_string_manufacturer, sizeof fsg_string_manufacturer,
3450 "%s %s with %s",
4110 init_utsname()->sysname, init_utsname()->release, 3451 init_utsname()->sysname, init_utsname()->release,
4111 gadget->name); 3452 gadget->name);
4112 3453
4113 /* On a real device, serial[] would be loaded from permanent 3454 /* On a real device, serial[] would be loaded from permanent
4114 * storage. We just encode it from the driver version string. */ 3455 * storage. We just encode it from the driver version string. */
4115 for (i = 0; i < sizeof(serial) - 2; i += 2) { 3456 for (i = 0; i < sizeof fsg_string_serial - 2; i += 2) {
4116 unsigned char c = DRIVER_VERSION[i / 2]; 3457 unsigned char c = DRIVER_VERSION[i / 2];
4117 3458
4118 if (!c) 3459 if (!c)
4119 break; 3460 break;
4120 sprintf(&serial[i], "%02X", c); 3461 sprintf(&fsg_string_serial[i], "%02X", c);
4121 } 3462 }
4122 3463
4123 fsg->thread_task = kthread_create(fsg_main_thread, fsg, 3464 fsg->thread_task = kthread_create(fsg_main_thread, fsg,
@@ -4133,7 +3474,7 @@ static int __init fsg_bind(struct usb_gadget *gadget)
4133 pathbuf = kmalloc(PATH_MAX, GFP_KERNEL); 3474 pathbuf = kmalloc(PATH_MAX, GFP_KERNEL);
4134 for (i = 0; i < fsg->nluns; ++i) { 3475 for (i = 0; i < fsg->nluns; ++i) {
4135 curlun = &fsg->luns[i]; 3476 curlun = &fsg->luns[i];
4136 if (backing_file_is_open(curlun)) { 3477 if (fsg_lun_is_open(curlun)) {
4137 p = NULL; 3478 p = NULL;
4138 if (pathbuf) { 3479 if (pathbuf) {
4139 p = d_path(&curlun->filp->f_path, 3480 p = d_path(&curlun->filp->f_path,
@@ -4203,7 +3544,7 @@ static struct usb_gadget_driver fsg_driver = {
4203#else 3544#else
4204 .speed = USB_SPEED_FULL, 3545 .speed = USB_SPEED_FULL,
4205#endif 3546#endif
4206 .function = (char *) longname, 3547 .function = (char *) fsg_string_product,
4207 .bind = fsg_bind, 3548 .bind = fsg_bind,
4208 .unbind = fsg_unbind, 3549 .unbind = fsg_unbind,
4209 .disconnect = fsg_disconnect, 3550 .disconnect = fsg_disconnect,
@@ -4212,7 +3553,7 @@ static struct usb_gadget_driver fsg_driver = {
4212 .resume = fsg_resume, 3553 .resume = fsg_resume,
4213 3554
4214 .driver = { 3555 .driver = {
4215 .name = (char *) shortname, 3556 .name = DRIVER_NAME,
4216 .owner = THIS_MODULE, 3557 .owner = THIS_MODULE,
4217 // .release = ... 3558 // .release = ...
4218 // .suspend = ... 3559 // .suspend = ...
diff --git a/drivers/usb/gadget/mass_storage.c b/drivers/usb/gadget/mass_storage.c
new file mode 100644
index 000000000000..19619fbf20ac
--- /dev/null
+++ b/drivers/usb/gadget/mass_storage.c
@@ -0,0 +1,240 @@
1/*
2 * mass_storage.c -- Mass Storage USB Gadget
3 *
4 * Copyright (C) 2003-2008 Alan Stern
5 * Copyright (C) 2009 Samsung Electronics
6 * Author: Michal Nazarewicz <m.nazarewicz@samsung.com>
7 * All rights reserved.
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 */
23
24
25/*
26 * The Mass Storage Gadget acts as a USB Mass Storage device,
27 * appearing to the host as a disk drive or as a CD-ROM drive. In
28 * addition to providing an example of a genuinely useful gadget
29 * driver for a USB device, it also illustrates a technique of
30 * double-buffering for increased throughput. Last but not least, it
31 * gives an easy way to probe the behavior of the Mass Storage drivers
32 * in a USB host.
33 *
34 * Since this file serves only administrative purposes and all the
35 * business logic is implemented in f_mass_storage.* file. Read
36 * comments in this file for more detailed description.
37 */
38
39
40#include <linux/kernel.h>
41#include <linux/utsname.h>
42#include <linux/usb/ch9.h>
43
44
45/*-------------------------------------------------------------------------*/
46
47#define DRIVER_DESC "Mass Storage Gadget"
48#define DRIVER_VERSION "2009/09/11"
49
50/*-------------------------------------------------------------------------*/
51
52/*
53 * kbuild is not very cooperative with respect to linking separately
54 * compiled library objects into one module. So for now we won't use
55 * separate compilation ... ensuring init/exit sections work to shrink
56 * the runtime footprint, and giving us at least some parts of what
57 * a "gcc --combine ... part1.c part2.c part3.c ... " build would.
58 */
59
60#include "composite.c"
61#include "usbstring.c"
62#include "config.c"
63#include "epautoconf.c"
64#include "f_mass_storage.c"
65
66/*-------------------------------------------------------------------------*/
67
68static struct usb_device_descriptor msg_device_desc = {
69 .bLength = sizeof msg_device_desc,
70 .bDescriptorType = USB_DT_DEVICE,
71
72 .bcdUSB = cpu_to_le16(0x0200),
73 .bDeviceClass = USB_CLASS_PER_INTERFACE,
74
75 /* Vendor and product id can be overridden by module parameters. */
76 .idVendor = cpu_to_le16(FSG_VENDOR_ID),
77 .idProduct = cpu_to_le16(FSG_PRODUCT_ID),
78 /* .bcdDevice = f(hardware) */
79 /* .iManufacturer = DYNAMIC */
80 /* .iProduct = DYNAMIC */
81 /* NO SERIAL NUMBER */
82 .bNumConfigurations = 1,
83};
84
85static struct usb_otg_descriptor otg_descriptor = {
86 .bLength = sizeof otg_descriptor,
87 .bDescriptorType = USB_DT_OTG,
88
89 /* REVISIT SRP-only hardware is possible, although
90 * it would not be called "OTG" ...
91 */
92 .bmAttributes = USB_OTG_SRP | USB_OTG_HNP,
93};
94
95static const struct usb_descriptor_header *otg_desc[] = {
96 (struct usb_descriptor_header *) &otg_descriptor,
97 NULL,
98};
99
100
101/* string IDs are assigned dynamically */
102
103#define STRING_MANUFACTURER_IDX 0
104#define STRING_PRODUCT_IDX 1
105#define STRING_CONFIGURATION_IDX 2
106
107static char manufacturer[50];
108
109static struct usb_string strings_dev[] = {
110 [STRING_MANUFACTURER_IDX].s = manufacturer,
111 [STRING_PRODUCT_IDX].s = DRIVER_DESC,
112 [STRING_CONFIGURATION_IDX].s = "Self Powered",
113 { } /* end of list */
114};
115
116static struct usb_gadget_strings stringtab_dev = {
117 .language = 0x0409, /* en-us */
118 .strings = strings_dev,
119};
120
121static struct usb_gadget_strings *dev_strings[] = {
122 &stringtab_dev,
123 NULL,
124};
125
126
127
128/****************************** Configurations ******************************/
129
130static struct fsg_module_parameters mod_data = {
131 .stall = 1
132};
133FSG_MODULE_PARAMETERS(/* no prefix */, mod_data);
134
135static unsigned long msg_registered = 0;
136static void msg_cleanup(void);
137
138static int __init msg_do_config(struct usb_configuration *c)
139{
140 struct fsg_common *common;
141 struct fsg_config config;
142 int ret;
143
144 if (gadget_is_otg(c->cdev->gadget)) {
145 c->descriptors = otg_desc;
146 c->bmAttributes |= USB_CONFIG_ATT_WAKEUP;
147 }
148
149 fsg_config_from_params(&config, &mod_data);
150 config.thread_exits = (void(*)(struct fsg_common*))&msg_cleanup;
151 common = fsg_common_init(0, c->cdev, &config);
152 if (IS_ERR(common))
153 return PTR_ERR(common);
154
155 ret = fsg_add(c->cdev, c, common);
156 fsg_common_put(common);
157 return ret;
158}
159
160static struct usb_configuration msg_config_driver = {
161 .label = "Linux File-Backed Storage",
162 .bind = msg_do_config,
163 .bConfigurationValue = 1,
164 /* .iConfiguration = DYNAMIC */
165 .bmAttributes = USB_CONFIG_ATT_SELFPOWER,
166};
167
168
169
170/****************************** Gadget Bind ******************************/
171
172
173static int __init msg_bind(struct usb_composite_dev *cdev)
174{
175 struct usb_gadget *gadget = cdev->gadget;
176 int status;
177
178 /* Allocate string descriptor numbers ... note that string
179 * contents can be overridden by the composite_dev glue.
180 */
181
182 /* device descriptor strings: manufacturer, product */
183 snprintf(manufacturer, sizeof manufacturer, "%s %s with %s",
184 init_utsname()->sysname, init_utsname()->release,
185 gadget->name);
186 status = usb_string_id(cdev);
187 if (status < 0)
188 return status;
189 strings_dev[STRING_MANUFACTURER_IDX].id = status;
190 msg_device_desc.iManufacturer = status;
191
192 status = usb_string_id(cdev);
193 if (status < 0)
194 return status;
195 strings_dev[STRING_PRODUCT_IDX].id = status;
196 msg_device_desc.iProduct = status;
197
198 status = usb_string_id(cdev);
199 if (status < 0)
200 return status;
201 strings_dev[STRING_CONFIGURATION_IDX].id = status;
202 msg_config_driver.iConfiguration = status;
203
204 /* register our second configuration */
205 status = usb_add_config(cdev, &msg_config_driver);
206 if (status < 0)
207 return status;
208
209 dev_info(&gadget->dev, DRIVER_DESC ", version: " DRIVER_VERSION "\n");
210 set_bit(0, &msg_registered);
211 return 0;
212}
213
214
215/****************************** Some noise ******************************/
216
217
218static struct usb_composite_driver msg_driver = {
219 .name = "g_mass_storage",
220 .dev = &msg_device_desc,
221 .strings = dev_strings,
222 .bind = msg_bind,
223};
224
225MODULE_DESCRIPTION(DRIVER_DESC);
226MODULE_AUTHOR("Michal Nazarewicz");
227MODULE_LICENSE("GPL");
228
229static int __init msg_init(void)
230{
231 return usb_composite_register(&msg_driver);
232}
233module_init(msg_init);
234
235static void msg_cleanup(void)
236{
237 if (test_and_clear_bit(0, &msg_registered))
238 usb_composite_unregister(&msg_driver);
239}
240module_exit(msg_cleanup);
diff --git a/drivers/usb/gadget/multi.c b/drivers/usb/gadget/multi.c
new file mode 100644
index 000000000000..429560100b10
--- /dev/null
+++ b/drivers/usb/gadget/multi.c
@@ -0,0 +1,358 @@
1/*
2 * multi.c -- Multifunction Composite driver
3 *
4 * Copyright (C) 2008 David Brownell
5 * Copyright (C) 2008 Nokia Corporation
6 * Copyright (C) 2009 Samsung Electronics
7 * Author: Michal Nazarewicz (m.nazarewicz@samsung.com)
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 */
23
24
25#include <linux/kernel.h>
26#include <linux/utsname.h>
27
28
29#if defined USB_ETH_RNDIS
30# undef USB_ETH_RNDIS
31#endif
32#ifdef CONFIG_USB_ETH_RNDIS
33# define USB_ETH_RNDIS y
34#endif
35
36
37#define DRIVER_DESC "Multifunction Composite Gadget"
38#define DRIVER_VERSION "2009/07/21"
39
40/*-------------------------------------------------------------------------*/
41
42#define MULTI_VENDOR_NUM 0x0525 /* XXX NetChip */
43#define MULTI_PRODUCT_NUM 0xa4ab /* XXX */
44
45/*-------------------------------------------------------------------------*/
46
47/*
48 * kbuild is not very cooperative with respect to linking separately
49 * compiled library objects into one module. So for now we won't use
50 * separate compilation ... ensuring init/exit sections work to shrink
51 * the runtime footprint, and giving us at least some parts of what
52 * a "gcc --combine ... part1.c part2.c part3.c ... " build would.
53 */
54
55#include "composite.c"
56#include "usbstring.c"
57#include "config.c"
58#include "epautoconf.c"
59
60#include "u_serial.c"
61#include "f_acm.c"
62
63#include "f_ecm.c"
64#include "f_subset.c"
65#ifdef USB_ETH_RNDIS
66# include "f_rndis.c"
67# include "rndis.c"
68#endif
69#include "u_ether.c"
70
71#undef DBG /* u_ether.c has broken idea about macros */
72#undef VDBG /* so clean up after it */
73#undef ERROR
74#undef INFO
75#include "f_mass_storage.c"
76
77/*-------------------------------------------------------------------------*/
78
79static struct usb_device_descriptor device_desc = {
80 .bLength = sizeof device_desc,
81 .bDescriptorType = USB_DT_DEVICE,
82
83 .bcdUSB = cpu_to_le16(0x0200),
84
85 /* .bDeviceClass = USB_CLASS_COMM, */
86 /* .bDeviceSubClass = 0, */
87 /* .bDeviceProtocol = 0, */
88 .bDeviceClass = 0xEF,
89 .bDeviceSubClass = 2,
90 .bDeviceProtocol = 1,
91 /* .bMaxPacketSize0 = f(hardware) */
92
93 /* Vendor and product id can be overridden by module parameters. */
94 .idVendor = cpu_to_le16(MULTI_VENDOR_NUM),
95 .idProduct = cpu_to_le16(MULTI_PRODUCT_NUM),
96 /* .bcdDevice = f(hardware) */
97 /* .iManufacturer = DYNAMIC */
98 /* .iProduct = DYNAMIC */
99 /* NO SERIAL NUMBER */
100 .bNumConfigurations = 1,
101};
102
103static struct usb_otg_descriptor otg_descriptor = {
104 .bLength = sizeof otg_descriptor,
105 .bDescriptorType = USB_DT_OTG,
106
107 /* REVISIT SRP-only hardware is possible, although
108 * it would not be called "OTG" ...
109 */
110 .bmAttributes = USB_OTG_SRP | USB_OTG_HNP,
111};
112
113static const struct usb_descriptor_header *otg_desc[] = {
114 (struct usb_descriptor_header *) &otg_descriptor,
115 NULL,
116};
117
118
119/* string IDs are assigned dynamically */
120
121#define STRING_MANUFACTURER_IDX 0
122#define STRING_PRODUCT_IDX 1
123
124static char manufacturer[50];
125
126static struct usb_string strings_dev[] = {
127 [STRING_MANUFACTURER_IDX].s = manufacturer,
128 [STRING_PRODUCT_IDX].s = DRIVER_DESC,
129 { } /* end of list */
130};
131
132static struct usb_gadget_strings stringtab_dev = {
133 .language = 0x0409, /* en-us */
134 .strings = strings_dev,
135};
136
137static struct usb_gadget_strings *dev_strings[] = {
138 &stringtab_dev,
139 NULL,
140};
141
142static u8 hostaddr[ETH_ALEN];
143
144
145
146/****************************** Configurations ******************************/
147
148static struct fsg_module_parameters mod_data = {
149 .stall = 1
150};
151FSG_MODULE_PARAMETERS(/* no prefix */, mod_data);
152
153static struct fsg_common *fsg_common;
154
155
156#ifdef USB_ETH_RNDIS
157
158static int __init rndis_do_config(struct usb_configuration *c)
159{
160 int ret;
161
162 if (gadget_is_otg(c->cdev->gadget)) {
163 c->descriptors = otg_desc;
164 c->bmAttributes |= USB_CONFIG_ATT_WAKEUP;
165 }
166
167 ret = rndis_bind_config(c, hostaddr);
168 if (ret < 0)
169 return ret;
170
171 ret = acm_bind_config(c, 0);
172 if (ret < 0)
173 return ret;
174
175 ret = fsg_add(c->cdev, c, fsg_common);
176 if (ret < 0)
177 return ret;
178
179 return 0;
180}
181
182static struct usb_configuration rndis_config_driver = {
183 .label = "Multifunction Composite (RNDIS + MS + ACM)",
184 .bind = rndis_do_config,
185 .bConfigurationValue = 2,
186 /* .iConfiguration = DYNAMIC */
187 .bmAttributes = USB_CONFIG_ATT_SELFPOWER,
188};
189
190#endif
191
192#ifdef CONFIG_USB_G_MULTI_CDC
193
194static int __init cdc_do_config(struct usb_configuration *c)
195{
196 int ret;
197
198 if (gadget_is_otg(c->cdev->gadget)) {
199 c->descriptors = otg_desc;
200 c->bmAttributes |= USB_CONFIG_ATT_WAKEUP;
201 }
202
203 ret = ecm_bind_config(c, hostaddr);
204 if (ret < 0)
205 return ret;
206
207 ret = acm_bind_config(c, 0);
208 if (ret < 0)
209 return ret;
210
211 ret = fsg_add(c->cdev, c, fsg_common);
212 if (ret < 0)
213 return ret;
214 if (ret < 0)
215 return ret;
216
217 return 0;
218}
219
220static struct usb_configuration cdc_config_driver = {
221 .label = "Multifunction Composite (CDC + MS + ACM)",
222 .bind = cdc_do_config,
223 .bConfigurationValue = 1,
224 /* .iConfiguration = DYNAMIC */
225 .bmAttributes = USB_CONFIG_ATT_SELFPOWER,
226};
227
228#endif
229
230
231
232/****************************** Gadget Bind ******************************/
233
234
235static int __init multi_bind(struct usb_composite_dev *cdev)
236{
237 struct usb_gadget *gadget = cdev->gadget;
238 int status, gcnum;
239
240 if (!can_support_ecm(cdev->gadget)) {
241 dev_err(&gadget->dev, "controller '%s' not usable\n",
242 gadget->name);
243 return -EINVAL;
244 }
245
246 /* set up network link layer */
247 status = gether_setup(cdev->gadget, hostaddr);
248 if (status < 0)
249 return status;
250
251 /* set up serial link layer */
252 status = gserial_setup(cdev->gadget, 1);
253 if (status < 0)
254 goto fail0;
255
256 /* set up mass storage function */
257 fsg_common = fsg_common_from_params(0, cdev, &mod_data);
258 if (IS_ERR(fsg_common)) {
259 status = PTR_ERR(fsg_common);
260 goto fail1;
261 }
262
263
264 gcnum = usb_gadget_controller_number(gadget);
265 if (gcnum >= 0)
266 device_desc.bcdDevice = cpu_to_le16(0x0300 | gcnum);
267 else {
268 /* We assume that can_support_ecm() tells the truth;
269 * but if the controller isn't recognized at all then
270 * that assumption is a bit more likely to be wrong.
271 */
272 WARNING(cdev, "controller '%s' not recognized\n",
273 gadget->name);
274 device_desc.bcdDevice = cpu_to_le16(0x0300 | 0x0099);
275 }
276
277
278 /* Allocate string descriptor numbers ... note that string
279 * contents can be overridden by the composite_dev glue.
280 */
281
282 /* device descriptor strings: manufacturer, product */
283 snprintf(manufacturer, sizeof manufacturer, "%s %s with %s",
284 init_utsname()->sysname, init_utsname()->release,
285 gadget->name);
286 status = usb_string_id(cdev);
287 if (status < 0)
288 goto fail2;
289 strings_dev[STRING_MANUFACTURER_IDX].id = status;
290 device_desc.iManufacturer = status;
291
292 status = usb_string_id(cdev);
293 if (status < 0)
294 goto fail2;
295 strings_dev[STRING_PRODUCT_IDX].id = status;
296 device_desc.iProduct = status;
297
298#ifdef USB_ETH_RNDIS
299 /* register our first configuration */
300 status = usb_add_config(cdev, &rndis_config_driver);
301 if (status < 0)
302 goto fail2;
303#endif
304
305#ifdef CONFIG_USB_G_MULTI_CDC
306 /* register our second configuration */
307 status = usb_add_config(cdev, &cdc_config_driver);
308 if (status < 0)
309 goto fail2;
310#endif
311
312 dev_info(&gadget->dev, DRIVER_DESC ", version: " DRIVER_VERSION "\n");
313 fsg_common_put(fsg_common);
314 return 0;
315
316fail2:
317 fsg_common_put(fsg_common);
318fail1:
319 gserial_cleanup();
320fail0:
321 gether_cleanup();
322 return status;
323}
324
325static int __exit multi_unbind(struct usb_composite_dev *cdev)
326{
327 gserial_cleanup();
328 gether_cleanup();
329 return 0;
330}
331
332
333/****************************** Some noise ******************************/
334
335
336static struct usb_composite_driver multi_driver = {
337 .name = "g_multi",
338 .dev = &device_desc,
339 .strings = dev_strings,
340 .bind = multi_bind,
341 .unbind = __exit_p(multi_unbind),
342};
343
344MODULE_DESCRIPTION(DRIVER_DESC);
345MODULE_AUTHOR("Michal Nazarewicz");
346MODULE_LICENSE("GPL");
347
348static int __init g_multi_init(void)
349{
350 return usb_composite_register(&multi_driver);
351}
352module_init(g_multi_init);
353
354static void __exit g_multi_cleanup(void)
355{
356 usb_composite_unregister(&multi_driver);
357}
358module_exit(g_multi_cleanup);
diff --git a/drivers/usb/gadget/storage_common.c b/drivers/usb/gadget/storage_common.c
new file mode 100644
index 000000000000..868d8ee86756
--- /dev/null
+++ b/drivers/usb/gadget/storage_common.c
@@ -0,0 +1,778 @@
1/*
2 * storage_common.c -- Common definitions for mass storage functionality
3 *
4 * Copyright (C) 2003-2008 Alan Stern
5 * Copyeight (C) 2009 Samsung Electronics
6 * Author: Michal Nazarewicz (m.nazarewicz@samsung.com)
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 */
22
23
24/*
25 * This file requires the following identifiers used in USB strings to
26 * be defined (each of type pointer to char):
27 * - fsg_string_manufacturer -- name of the manufacturer
28 * - fsg_string_product -- name of the product
29 * - fsg_string_serial -- product's serial
30 * - fsg_string_config -- name of the configuration
31 * - fsg_string_interface -- name of the interface
32 * The first four are only needed when FSG_DESCRIPTORS_DEVICE_STRINGS
33 * macro is defined prior to including this file.
34 */
35
36/*
37 * When FSG_NO_INTR_EP is defined fsg_fs_intr_in_desc and
38 * fsg_hs_intr_in_desc objects as well as
39 * FSG_FS_FUNCTION_PRE_EP_ENTRIES and FSG_HS_FUNCTION_PRE_EP_ENTRIES
40 * macros are not defined.
41 *
42 * When FSG_NO_DEVICE_STRINGS is defined FSG_STRING_MANUFACTURER,
43 * FSG_STRING_PRODUCT, FSG_STRING_SERIAL and FSG_STRING_CONFIG are not
44 * defined (as well as corresponding entries in string tables are
45 * missing) and FSG_STRING_INTERFACE has value of zero.
46 *
47 * When FSG_NO_OTG is defined fsg_otg_desc won't be defined.
48 */
49
50/*
51 * When FSG_BUFFHD_STATIC_BUFFER is defined when this file is included
52 * the fsg_buffhd structure's buf field will be an array of FSG_BUFLEN
53 * characters rather then a pointer to void.
54 */
55
56
57#include <asm/unaligned.h>
58
59
60/* Thanks to NetChip Technologies for donating this product ID.
61 *
62 * DO NOT REUSE THESE IDs with any other driver!! Ever!!
63 * Instead: allocate your own, using normal USB-IF procedures. */
64#define FSG_VENDOR_ID 0x0525 /* NetChip */
65#define FSG_PRODUCT_ID 0xa4a5 /* Linux-USB File-backed Storage Gadget */
66
67
68/*-------------------------------------------------------------------------*/
69
70
71#ifndef DEBUG
72#undef VERBOSE_DEBUG
73#undef DUMP_MSGS
74#endif /* !DEBUG */
75
76#ifdef VERBOSE_DEBUG
77#define VLDBG LDBG
78#else
79#define VLDBG(lun, fmt, args...) do { } while (0)
80#endif /* VERBOSE_DEBUG */
81
82#define LDBG(lun, fmt, args...) dev_dbg (&(lun)->dev, fmt, ## args)
83#define LERROR(lun, fmt, args...) dev_err (&(lun)->dev, fmt, ## args)
84#define LWARN(lun, fmt, args...) dev_warn(&(lun)->dev, fmt, ## args)
85#define LINFO(lun, fmt, args...) dev_info(&(lun)->dev, fmt, ## args)
86
87/* Keep those macros in sync with thos in
88 * include/linux/ubs/composite.h or else GCC will complain. If they
89 * are identical (the same names of arguments, white spaces in the
90 * same places) GCC will allow redefinition otherwise (even if some
91 * white space is removed or added) warning will be issued. No
92 * checking if those symbols is defined is performed because warning
93 * is desired when those macros were defined by someone else to mean
94 * something else. */
95#define DBG(d, fmt, args...) dev_dbg(&(d)->gadget->dev , fmt , ## args)
96#define VDBG(d, fmt, args...) dev_vdbg(&(d)->gadget->dev , fmt , ## args)
97#define ERROR(d, fmt, args...) dev_err(&(d)->gadget->dev , fmt , ## args)
98#define WARNING(d, fmt, args...) dev_warn(&(d)->gadget->dev , fmt , ## args)
99#define INFO(d, fmt, args...) dev_info(&(d)->gadget->dev , fmt , ## args)
100
101
102
103#ifdef DUMP_MSGS
104
105# define dump_msg(fsg, /* const char * */ label, \
106 /* const u8 * */ buf, /* unsigned */ length) do { \
107 if (length < 512) { \
108 DBG(fsg, "%s, length %u:\n", label, length); \
109 print_hex_dump(KERN_DEBUG, "", DUMP_PREFIX_OFFSET, \
110 16, 1, buf, length, 0); \
111 } \
112} while (0)
113
114# define dump_cdb(fsg) do { } while (0)
115
116#else
117
118# define dump_msg(fsg, /* const char * */ label, \
119 /* const u8 * */ buf, /* unsigned */ length) do { } while (0)
120
121# ifdef VERBOSE_DEBUG
122
123# define dump_cdb(fsg) \
124 print_hex_dump(KERN_DEBUG, "SCSI CDB: ", DUMP_PREFIX_NONE, \
125 16, 1, (fsg)->cmnd, (fsg)->cmnd_size, 0) \
126
127# else
128
129# define dump_cdb(fsg) do { } while (0)
130
131# endif /* VERBOSE_DEBUG */
132
133#endif /* DUMP_MSGS */
134
135
136
137
138
139/*-------------------------------------------------------------------------*/
140
141/* SCSI device types */
142#define TYPE_DISK 0x00
143#define TYPE_CDROM 0x05
144
145/* USB protocol value = the transport method */
146#define USB_PR_CBI 0x00 /* Control/Bulk/Interrupt */
147#define USB_PR_CB 0x01 /* Control/Bulk w/o interrupt */
148#define USB_PR_BULK 0x50 /* Bulk-only */
149
150/* USB subclass value = the protocol encapsulation */
151#define USB_SC_RBC 0x01 /* Reduced Block Commands (flash) */
152#define USB_SC_8020 0x02 /* SFF-8020i, MMC-2, ATAPI (CD-ROM) */
153#define USB_SC_QIC 0x03 /* QIC-157 (tape) */
154#define USB_SC_UFI 0x04 /* UFI (floppy) */
155#define USB_SC_8070 0x05 /* SFF-8070i (removable) */
156#define USB_SC_SCSI 0x06 /* Transparent SCSI */
157
158/* Bulk-only data structures */
159
160/* Command Block Wrapper */
161struct fsg_bulk_cb_wrap {
162 __le32 Signature; /* Contains 'USBC' */
163 u32 Tag; /* Unique per command id */
164 __le32 DataTransferLength; /* Size of the data */
165 u8 Flags; /* Direction in bit 7 */
166 u8 Lun; /* LUN (normally 0) */
167 u8 Length; /* Of the CDB, <= MAX_COMMAND_SIZE */
168 u8 CDB[16]; /* Command Data Block */
169};
170
171#define USB_BULK_CB_WRAP_LEN 31
172#define USB_BULK_CB_SIG 0x43425355 /* Spells out USBC */
173#define USB_BULK_IN_FLAG 0x80
174
175/* Command Status Wrapper */
176struct bulk_cs_wrap {
177 __le32 Signature; /* Should = 'USBS' */
178 u32 Tag; /* Same as original command */
179 __le32 Residue; /* Amount not transferred */
180 u8 Status; /* See below */
181};
182
183#define USB_BULK_CS_WRAP_LEN 13
184#define USB_BULK_CS_SIG 0x53425355 /* Spells out 'USBS' */
185#define USB_STATUS_PASS 0
186#define USB_STATUS_FAIL 1
187#define USB_STATUS_PHASE_ERROR 2
188
189/* Bulk-only class specific requests */
190#define USB_BULK_RESET_REQUEST 0xff
191#define USB_BULK_GET_MAX_LUN_REQUEST 0xfe
192
193
194/* CBI Interrupt data structure */
195struct interrupt_data {
196 u8 bType;
197 u8 bValue;
198};
199
200#define CBI_INTERRUPT_DATA_LEN 2
201
202/* CBI Accept Device-Specific Command request */
203#define USB_CBI_ADSC_REQUEST 0x00
204
205
206/* Length of a SCSI Command Data Block */
207#define MAX_COMMAND_SIZE 16
208
209/* SCSI commands that we recognize */
210#define SC_FORMAT_UNIT 0x04
211#define SC_INQUIRY 0x12
212#define SC_MODE_SELECT_6 0x15
213#define SC_MODE_SELECT_10 0x55
214#define SC_MODE_SENSE_6 0x1a
215#define SC_MODE_SENSE_10 0x5a
216#define SC_PREVENT_ALLOW_MEDIUM_REMOVAL 0x1e
217#define SC_READ_6 0x08
218#define SC_READ_10 0x28
219#define SC_READ_12 0xa8
220#define SC_READ_CAPACITY 0x25
221#define SC_READ_FORMAT_CAPACITIES 0x23
222#define SC_READ_HEADER 0x44
223#define SC_READ_TOC 0x43
224#define SC_RELEASE 0x17
225#define SC_REQUEST_SENSE 0x03
226#define SC_RESERVE 0x16
227#define SC_SEND_DIAGNOSTIC 0x1d
228#define SC_START_STOP_UNIT 0x1b
229#define SC_SYNCHRONIZE_CACHE 0x35
230#define SC_TEST_UNIT_READY 0x00
231#define SC_VERIFY 0x2f
232#define SC_WRITE_6 0x0a
233#define SC_WRITE_10 0x2a
234#define SC_WRITE_12 0xaa
235
236/* SCSI Sense Key/Additional Sense Code/ASC Qualifier values */
237#define SS_NO_SENSE 0
238#define SS_COMMUNICATION_FAILURE 0x040800
239#define SS_INVALID_COMMAND 0x052000
240#define SS_INVALID_FIELD_IN_CDB 0x052400
241#define SS_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE 0x052100
242#define SS_LOGICAL_UNIT_NOT_SUPPORTED 0x052500
243#define SS_MEDIUM_NOT_PRESENT 0x023a00
244#define SS_MEDIUM_REMOVAL_PREVENTED 0x055302
245#define SS_NOT_READY_TO_READY_TRANSITION 0x062800
246#define SS_RESET_OCCURRED 0x062900
247#define SS_SAVING_PARAMETERS_NOT_SUPPORTED 0x053900
248#define SS_UNRECOVERED_READ_ERROR 0x031100
249#define SS_WRITE_ERROR 0x030c02
250#define SS_WRITE_PROTECTED 0x072700
251
252#define SK(x) ((u8) ((x) >> 16)) /* Sense Key byte, etc. */
253#define ASC(x) ((u8) ((x) >> 8))
254#define ASCQ(x) ((u8) (x))
255
256
257/*-------------------------------------------------------------------------*/
258
259
260struct fsg_lun {
261 struct file *filp;
262 loff_t file_length;
263 loff_t num_sectors;
264
265 unsigned int initially_ro:1;
266 unsigned int ro:1;
267 unsigned int removable:1;
268 unsigned int cdrom:1;
269 unsigned int prevent_medium_removal:1;
270 unsigned int registered:1;
271 unsigned int info_valid:1;
272
273 u32 sense_data;
274 u32 sense_data_info;
275 u32 unit_attention_data;
276
277 struct device dev;
278};
279
280#define fsg_lun_is_open(curlun) ((curlun)->filp != NULL)
281
282static struct fsg_lun *fsg_lun_from_dev(struct device *dev)
283{
284 return container_of(dev, struct fsg_lun, dev);
285}
286
287
288/* Big enough to hold our biggest descriptor */
289#define EP0_BUFSIZE 256
290#define DELAYED_STATUS (EP0_BUFSIZE + 999) /* An impossibly large value */
291
292/* Number of buffers we will use. 2 is enough for double-buffering */
293#define FSG_NUM_BUFFERS 2
294
295/* Default size of buffer length. */
296#define FSG_BUFLEN ((u32)16384)
297
298/* Maximal number of LUNs supported in mass storage function */
299#define FSG_MAX_LUNS 8
300
301enum fsg_buffer_state {
302 BUF_STATE_EMPTY = 0,
303 BUF_STATE_FULL,
304 BUF_STATE_BUSY
305};
306
307struct fsg_buffhd {
308#ifdef FSG_BUFFHD_STATIC_BUFFER
309 char buf[FSG_BUFLEN];
310#else
311 void *buf;
312#endif
313 enum fsg_buffer_state state;
314 struct fsg_buffhd *next;
315
316 /* The NetChip 2280 is faster, and handles some protocol faults
317 * better, if we don't submit any short bulk-out read requests.
318 * So we will record the intended request length here. */
319 unsigned int bulk_out_intended_length;
320
321 struct usb_request *inreq;
322 int inreq_busy;
323 struct usb_request *outreq;
324 int outreq_busy;
325};
326
327enum fsg_state {
328 /* This one isn't used anywhere */
329 FSG_STATE_COMMAND_PHASE = -10,
330 FSG_STATE_DATA_PHASE,
331 FSG_STATE_STATUS_PHASE,
332
333 FSG_STATE_IDLE = 0,
334 FSG_STATE_ABORT_BULK_OUT,
335 FSG_STATE_RESET,
336 FSG_STATE_INTERFACE_CHANGE,
337 FSG_STATE_CONFIG_CHANGE,
338 FSG_STATE_DISCONNECT,
339 FSG_STATE_EXIT,
340 FSG_STATE_TERMINATED
341};
342
343enum data_direction {
344 DATA_DIR_UNKNOWN = 0,
345 DATA_DIR_FROM_HOST,
346 DATA_DIR_TO_HOST,
347 DATA_DIR_NONE
348};
349
350
351/*-------------------------------------------------------------------------*/
352
353
354static inline u32 get_unaligned_be24(u8 *buf)
355{
356 return 0xffffff & (u32) get_unaligned_be32(buf - 1);
357}
358
359
360/*-------------------------------------------------------------------------*/
361
362
363enum {
364#ifndef FSG_NO_DEVICE_STRINGS
365 FSG_STRING_MANUFACTURER = 1,
366 FSG_STRING_PRODUCT,
367 FSG_STRING_SERIAL,
368 FSG_STRING_CONFIG,
369#endif
370 FSG_STRING_INTERFACE
371};
372
373
374#ifndef FSG_NO_OTG
375static struct usb_otg_descriptor
376fsg_otg_desc = {
377 .bLength = sizeof fsg_otg_desc,
378 .bDescriptorType = USB_DT_OTG,
379
380 .bmAttributes = USB_OTG_SRP,
381};
382#endif
383
384/* There is only one interface. */
385
386static struct usb_interface_descriptor
387fsg_intf_desc = {
388 .bLength = sizeof fsg_intf_desc,
389 .bDescriptorType = USB_DT_INTERFACE,
390
391 .bNumEndpoints = 2, /* Adjusted during fsg_bind() */
392 .bInterfaceClass = USB_CLASS_MASS_STORAGE,
393 .bInterfaceSubClass = USB_SC_SCSI, /* Adjusted during fsg_bind() */
394 .bInterfaceProtocol = USB_PR_BULK, /* Adjusted during fsg_bind() */
395 .iInterface = FSG_STRING_INTERFACE,
396};
397
398/* Three full-speed endpoint descriptors: bulk-in, bulk-out,
399 * and interrupt-in. */
400
401static struct usb_endpoint_descriptor
402fsg_fs_bulk_in_desc = {
403 .bLength = USB_DT_ENDPOINT_SIZE,
404 .bDescriptorType = USB_DT_ENDPOINT,
405
406 .bEndpointAddress = USB_DIR_IN,
407 .bmAttributes = USB_ENDPOINT_XFER_BULK,
408 /* wMaxPacketSize set by autoconfiguration */
409};
410
411static struct usb_endpoint_descriptor
412fsg_fs_bulk_out_desc = {
413 .bLength = USB_DT_ENDPOINT_SIZE,
414 .bDescriptorType = USB_DT_ENDPOINT,
415
416 .bEndpointAddress = USB_DIR_OUT,
417 .bmAttributes = USB_ENDPOINT_XFER_BULK,
418 /* wMaxPacketSize set by autoconfiguration */
419};
420
421#ifndef FSG_NO_INTR_EP
422
423static struct usb_endpoint_descriptor
424fsg_fs_intr_in_desc = {
425 .bLength = USB_DT_ENDPOINT_SIZE,
426 .bDescriptorType = USB_DT_ENDPOINT,
427
428 .bEndpointAddress = USB_DIR_IN,
429 .bmAttributes = USB_ENDPOINT_XFER_INT,
430 .wMaxPacketSize = cpu_to_le16(2),
431 .bInterval = 32, /* frames -> 32 ms */
432};
433
434#ifndef FSG_NO_OTG
435# define FSG_FS_FUNCTION_PRE_EP_ENTRIES 2
436#else
437# define FSG_FS_FUNCTION_PRE_EP_ENTRIES 1
438#endif
439
440#endif
441
442static struct usb_descriptor_header *fsg_fs_function[] = {
443#ifndef FSG_NO_OTG
444 (struct usb_descriptor_header *) &fsg_otg_desc,
445#endif
446 (struct usb_descriptor_header *) &fsg_intf_desc,
447 (struct usb_descriptor_header *) &fsg_fs_bulk_in_desc,
448 (struct usb_descriptor_header *) &fsg_fs_bulk_out_desc,
449#ifndef FSG_NO_INTR_EP
450 (struct usb_descriptor_header *) &fsg_fs_intr_in_desc,
451#endif
452 NULL,
453};
454
455
456/*
457 * USB 2.0 devices need to expose both high speed and full speed
458 * descriptors, unless they only run at full speed.
459 *
460 * That means alternate endpoint descriptors (bigger packets)
461 * and a "device qualifier" ... plus more construction options
462 * for the config descriptor.
463 */
464static struct usb_endpoint_descriptor
465fsg_hs_bulk_in_desc = {
466 .bLength = USB_DT_ENDPOINT_SIZE,
467 .bDescriptorType = USB_DT_ENDPOINT,
468
469 /* bEndpointAddress copied from fs_bulk_in_desc during fsg_bind() */
470 .bmAttributes = USB_ENDPOINT_XFER_BULK,
471 .wMaxPacketSize = cpu_to_le16(512),
472};
473
474static struct usb_endpoint_descriptor
475fsg_hs_bulk_out_desc = {
476 .bLength = USB_DT_ENDPOINT_SIZE,
477 .bDescriptorType = USB_DT_ENDPOINT,
478
479 /* bEndpointAddress copied from fs_bulk_out_desc during fsg_bind() */
480 .bmAttributes = USB_ENDPOINT_XFER_BULK,
481 .wMaxPacketSize = cpu_to_le16(512),
482 .bInterval = 1, /* NAK every 1 uframe */
483};
484
485#ifndef FSG_NO_INTR_EP
486
487static struct usb_endpoint_descriptor
488fsg_hs_intr_in_desc = {
489 .bLength = USB_DT_ENDPOINT_SIZE,
490 .bDescriptorType = USB_DT_ENDPOINT,
491
492 /* bEndpointAddress copied from fs_intr_in_desc during fsg_bind() */
493 .bmAttributes = USB_ENDPOINT_XFER_INT,
494 .wMaxPacketSize = cpu_to_le16(2),
495 .bInterval = 9, /* 2**(9-1) = 256 uframes -> 32 ms */
496};
497
498#ifndef FSG_NO_OTG
499# define FSG_HS_FUNCTION_PRE_EP_ENTRIES 2
500#else
501# define FSG_HS_FUNCTION_PRE_EP_ENTRIES 1
502#endif
503
504#endif
505
506static struct usb_descriptor_header *fsg_hs_function[] = {
507#ifndef FSG_NO_OTG
508 (struct usb_descriptor_header *) &fsg_otg_desc,
509#endif
510 (struct usb_descriptor_header *) &fsg_intf_desc,
511 (struct usb_descriptor_header *) &fsg_hs_bulk_in_desc,
512 (struct usb_descriptor_header *) &fsg_hs_bulk_out_desc,
513#ifndef FSG_NO_INTR_EP
514 (struct usb_descriptor_header *) &fsg_hs_intr_in_desc,
515#endif
516 NULL,
517};
518
519/* Maxpacket and other transfer characteristics vary by speed. */
520static struct usb_endpoint_descriptor *
521fsg_ep_desc(struct usb_gadget *g, struct usb_endpoint_descriptor *fs,
522 struct usb_endpoint_descriptor *hs)
523{
524 if (gadget_is_dualspeed(g) && g->speed == USB_SPEED_HIGH)
525 return hs;
526 return fs;
527}
528
529
530/* Static strings, in UTF-8 (for simplicity we use only ASCII characters) */
531static struct usb_string fsg_strings[] = {
532#ifndef FSG_NO_DEVICE_STRINGS
533 {FSG_STRING_MANUFACTURER, fsg_string_manufacturer},
534 {FSG_STRING_PRODUCT, fsg_string_product},
535 {FSG_STRING_SERIAL, fsg_string_serial},
536 {FSG_STRING_CONFIG, fsg_string_config},
537#endif
538 {FSG_STRING_INTERFACE, fsg_string_interface},
539 {}
540};
541
542static struct usb_gadget_strings fsg_stringtab = {
543 .language = 0x0409, /* en-us */
544 .strings = fsg_strings,
545};
546
547
548 /*-------------------------------------------------------------------------*/
549
550/* If the next two routines are called while the gadget is registered,
551 * the caller must own fsg->filesem for writing. */
552
553static int fsg_lun_open(struct fsg_lun *curlun, const char *filename)
554{
555 int ro;
556 struct file *filp = NULL;
557 int rc = -EINVAL;
558 struct inode *inode = NULL;
559 loff_t size;
560 loff_t num_sectors;
561 loff_t min_sectors;
562
563 /* R/W if we can, R/O if we must */
564 ro = curlun->initially_ro;
565 if (!ro) {
566 filp = filp_open(filename, O_RDWR | O_LARGEFILE, 0);
567 if (-EROFS == PTR_ERR(filp))
568 ro = 1;
569 }
570 if (ro)
571 filp = filp_open(filename, O_RDONLY | O_LARGEFILE, 0);
572 if (IS_ERR(filp)) {
573 LINFO(curlun, "unable to open backing file: %s\n", filename);
574 return PTR_ERR(filp);
575 }
576
577 if (!(filp->f_mode & FMODE_WRITE))
578 ro = 1;
579
580 if (filp->f_path.dentry)
581 inode = filp->f_path.dentry->d_inode;
582 if (inode && S_ISBLK(inode->i_mode)) {
583 if (bdev_read_only(inode->i_bdev))
584 ro = 1;
585 } else if (!inode || !S_ISREG(inode->i_mode)) {
586 LINFO(curlun, "invalid file type: %s\n", filename);
587 goto out;
588 }
589
590 /* If we can't read the file, it's no good.
591 * If we can't write the file, use it read-only. */
592 if (!filp->f_op || !(filp->f_op->read || filp->f_op->aio_read)) {
593 LINFO(curlun, "file not readable: %s\n", filename);
594 goto out;
595 }
596 if (!(filp->f_op->write || filp->f_op->aio_write))
597 ro = 1;
598
599 size = i_size_read(inode->i_mapping->host);
600 if (size < 0) {
601 LINFO(curlun, "unable to find file size: %s\n", filename);
602 rc = (int) size;
603 goto out;
604 }
605 num_sectors = size >> 9; /* File size in 512-byte blocks */
606 min_sectors = 1;
607 if (curlun->cdrom) {
608 num_sectors &= ~3; /* Reduce to a multiple of 2048 */
609 min_sectors = 300*4; /* Smallest track is 300 frames */
610 if (num_sectors >= 256*60*75*4) {
611 num_sectors = (256*60*75 - 1) * 4;
612 LINFO(curlun, "file too big: %s\n", filename);
613 LINFO(curlun, "using only first %d blocks\n",
614 (int) num_sectors);
615 }
616 }
617 if (num_sectors < min_sectors) {
618 LINFO(curlun, "file too small: %s\n", filename);
619 rc = -ETOOSMALL;
620 goto out;
621 }
622
623 get_file(filp);
624 curlun->ro = ro;
625 curlun->filp = filp;
626 curlun->file_length = size;
627 curlun->num_sectors = num_sectors;
628 LDBG(curlun, "open backing file: %s\n", filename);
629 rc = 0;
630
631out:
632 filp_close(filp, current->files);
633 return rc;
634}
635
636
637static void fsg_lun_close(struct fsg_lun *curlun)
638{
639 if (curlun->filp) {
640 LDBG(curlun, "close backing file\n");
641 fput(curlun->filp);
642 curlun->filp = NULL;
643 }
644}
645
646
647/*-------------------------------------------------------------------------*/
648
649/* Sync the file data, don't bother with the metadata.
650 * This code was copied from fs/buffer.c:sys_fdatasync(). */
651static int fsg_lun_fsync_sub(struct fsg_lun *curlun)
652{
653 struct file *filp = curlun->filp;
654
655 if (curlun->ro || !filp)
656 return 0;
657 return vfs_fsync(filp, filp->f_path.dentry, 1);
658}
659
660static void store_cdrom_address(u8 *dest, int msf, u32 addr)
661{
662 if (msf) {
663 /* Convert to Minutes-Seconds-Frames */
664 addr >>= 2; /* Convert to 2048-byte frames */
665 addr += 2*75; /* Lead-in occupies 2 seconds */
666 dest[3] = addr % 75; /* Frames */
667 addr /= 75;
668 dest[2] = addr % 60; /* Seconds */
669 addr /= 60;
670 dest[1] = addr; /* Minutes */
671 dest[0] = 0; /* Reserved */
672 } else {
673 /* Absolute sector */
674 put_unaligned_be32(addr, dest);
675 }
676}
677
678
679/*-------------------------------------------------------------------------*/
680
681
682static ssize_t fsg_show_ro(struct device *dev, struct device_attribute *attr,
683 char *buf)
684{
685 struct fsg_lun *curlun = fsg_lun_from_dev(dev);
686
687 return sprintf(buf, "%d\n", fsg_lun_is_open(curlun)
688 ? curlun->ro
689 : curlun->initially_ro);
690}
691
692static ssize_t fsg_show_file(struct device *dev, struct device_attribute *attr,
693 char *buf)
694{
695 struct fsg_lun *curlun = fsg_lun_from_dev(dev);
696 struct rw_semaphore *filesem = dev_get_drvdata(dev);
697 char *p;
698 ssize_t rc;
699
700 down_read(filesem);
701 if (fsg_lun_is_open(curlun)) { /* Get the complete pathname */
702 p = d_path(&curlun->filp->f_path, buf, PAGE_SIZE - 1);
703 if (IS_ERR(p))
704 rc = PTR_ERR(p);
705 else {
706 rc = strlen(p);
707 memmove(buf, p, rc);
708 buf[rc] = '\n'; /* Add a newline */
709 buf[++rc] = 0;
710 }
711 } else { /* No file, return 0 bytes */
712 *buf = 0;
713 rc = 0;
714 }
715 up_read(filesem);
716 return rc;
717}
718
719
720static ssize_t fsg_store_ro(struct device *dev, struct device_attribute *attr,
721 const char *buf, size_t count)
722{
723 ssize_t rc = count;
724 struct fsg_lun *curlun = fsg_lun_from_dev(dev);
725 struct rw_semaphore *filesem = dev_get_drvdata(dev);
726 int i;
727
728 if (sscanf(buf, "%d", &i) != 1)
729 return -EINVAL;
730
731 /* Allow the write-enable status to change only while the backing file
732 * is closed. */
733 down_read(filesem);
734 if (fsg_lun_is_open(curlun)) {
735 LDBG(curlun, "read-only status change prevented\n");
736 rc = -EBUSY;
737 } else {
738 curlun->ro = !!i;
739 curlun->initially_ro = !!i;
740 LDBG(curlun, "read-only status set to %d\n", curlun->ro);
741 }
742 up_read(filesem);
743 return rc;
744}
745
746static ssize_t fsg_store_file(struct device *dev, struct device_attribute *attr,
747 const char *buf, size_t count)
748{
749 struct fsg_lun *curlun = fsg_lun_from_dev(dev);
750 struct rw_semaphore *filesem = dev_get_drvdata(dev);
751 int rc = 0;
752
753 if (curlun->prevent_medium_removal && fsg_lun_is_open(curlun)) {
754 LDBG(curlun, "eject attempt prevented\n");
755 return -EBUSY; /* "Door is locked" */
756 }
757
758 /* Remove a trailing newline */
759 if (count > 0 && buf[count-1] == '\n')
760 ((char *) buf)[count-1] = 0; /* Ugh! */
761
762 /* Eject current medium */
763 down_write(filesem);
764 if (fsg_lun_is_open(curlun)) {
765 fsg_lun_close(curlun);
766 curlun->unit_attention_data = SS_MEDIUM_NOT_PRESENT;
767 }
768
769 /* Load new medium */
770 if (count > 0 && buf[0]) {
771 rc = fsg_lun_open(curlun, buf);
772 if (rc == 0)
773 curlun->unit_attention_data =
774 SS_NOT_READY_TO_READY_TRANSITION;
775 }
776 up_write(filesem);
777 return (rc < 0 ? rc : count);
778}
diff --git a/drivers/usb/gadget/u_ether.h b/drivers/usb/gadget/u_ether.h
index 91b39ffdf6ea..fd55f450bc0e 100644
--- a/drivers/usb/gadget/u_ether.h
+++ b/drivers/usb/gadget/u_ether.h
@@ -112,7 +112,7 @@ int geth_bind_config(struct usb_configuration *c, u8 ethaddr[ETH_ALEN]);
112int ecm_bind_config(struct usb_configuration *c, u8 ethaddr[ETH_ALEN]); 112int ecm_bind_config(struct usb_configuration *c, u8 ethaddr[ETH_ALEN]);
113int eem_bind_config(struct usb_configuration *c); 113int eem_bind_config(struct usb_configuration *c);
114 114
115#ifdef CONFIG_USB_ETH_RNDIS 115#ifdef USB_ETH_RNDIS
116 116
117int rndis_bind_config(struct usb_configuration *c, u8 ethaddr[ETH_ALEN]); 117int rndis_bind_config(struct usb_configuration *c, u8 ethaddr[ETH_ALEN]);
118 118
generated by cgit v1.2.2 (git 2.25.0) at 2025-01-10 09:27:10 -0500