USB: mass_storage: eject LUNs on thread exit
[linux-2.6.git] / drivers / usb / gadget / mass_storage.c
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
68 static 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
85 static 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
95 static 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
107 static char manufacturer[50];
108
109 static 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
116 static struct usb_gadget_strings stringtab_dev = {
117         .language       = 0x0409,       /* en-us */
118         .strings        = strings_dev,
119 };
120
121 static struct usb_gadget_strings *dev_strings[] = {
122         &stringtab_dev,
123         NULL,
124 };
125
126
127
128 /****************************** Configurations ******************************/
129
130 static struct fsg_module_parameters mod_data = {
131         .stall = 1
132 };
133 FSG_MODULE_PARAMETERS(/* no prefix */, mod_data);
134
135 static unsigned long msg_registered = 0;
136 static void msg_cleanup(void);
137
138 static int msg_thread_exits(struct fsg_common *common)
139 {
140         msg_cleanup();
141         return 0;
142 }
143
144 static int __init msg_do_config(struct usb_configuration *c)
145 {
146         struct fsg_common *common;
147         struct fsg_config config;
148         int ret;
149
150         if (gadget_is_otg(c->cdev->gadget)) {
151                 c->descriptors = otg_desc;
152                 c->bmAttributes |= USB_CONFIG_ATT_WAKEUP;
153         }
154
155         fsg_config_from_params(&config, &mod_data);
156         config.thread_exits = msg_thread_exits;
157         common = fsg_common_init(0, c->cdev, &config);
158         if (IS_ERR(common))
159                 return PTR_ERR(common);
160
161         ret = fsg_add(c->cdev, c, common);
162         fsg_common_put(common);
163         return ret;
164 }
165
166 static struct usb_configuration msg_config_driver = {
167         .label                  = "Linux File-Backed Storage",
168         .bind                   = msg_do_config,
169         .bConfigurationValue    = 1,
170         /* .iConfiguration = DYNAMIC */
171         .bmAttributes           = USB_CONFIG_ATT_SELFPOWER,
172 };
173
174
175
176 /****************************** Gadget Bind ******************************/
177
178
179 static int __init msg_bind(struct usb_composite_dev *cdev)
180 {
181         struct usb_gadget *gadget = cdev->gadget;
182         int status;
183
184         /* Allocate string descriptor numbers ... note that string
185          * contents can be overridden by the composite_dev glue.
186          */
187
188         /* device descriptor strings: manufacturer, product */
189         snprintf(manufacturer, sizeof manufacturer, "%s %s with %s",
190                  init_utsname()->sysname, init_utsname()->release,
191                  gadget->name);
192         status = usb_string_id(cdev);
193         if (status < 0)
194                 return status;
195         strings_dev[STRING_MANUFACTURER_IDX].id = status;
196         msg_device_desc.iManufacturer = status;
197
198         status = usb_string_id(cdev);
199         if (status < 0)
200                 return status;
201         strings_dev[STRING_PRODUCT_IDX].id = status;
202         msg_device_desc.iProduct = status;
203
204         status = usb_string_id(cdev);
205         if (status < 0)
206                 return status;
207         strings_dev[STRING_CONFIGURATION_IDX].id = status;
208         msg_config_driver.iConfiguration = status;
209
210         /* register our second configuration */
211         status = usb_add_config(cdev, &msg_config_driver);
212         if (status < 0)
213                 return status;
214
215         dev_info(&gadget->dev, DRIVER_DESC ", version: " DRIVER_VERSION "\n");
216         set_bit(0, &msg_registered);
217         return 0;
218 }
219
220
221 /****************************** Some noise ******************************/
222
223
224 static struct usb_composite_driver msg_driver = {
225         .name           = "g_mass_storage",
226         .dev            = &msg_device_desc,
227         .strings        = dev_strings,
228         .bind           = msg_bind,
229 };
230
231 MODULE_DESCRIPTION(DRIVER_DESC);
232 MODULE_AUTHOR("Michal Nazarewicz");
233 MODULE_LICENSE("GPL");
234
235 static int __init msg_init(void)
236 {
237         return usb_composite_register(&msg_driver);
238 }
239 module_init(msg_init);
240
241 static void msg_cleanup(void)
242 {
243         if (test_and_clear_bit(0, &msg_registered))
244                 usb_composite_unregister(&msg_driver);
245 }
246 module_exit(msg_cleanup);