diff options
author | Andrzej Pietrasiewicz <andrzej.p@samsung.com> | 2014-07-15 07:09:46 -0400 |
---|---|---|
committer | Felipe Balbi <balbi@ti.com> | 2014-07-16 13:50:36 -0400 |
commit | 00a2430ff07d4e0e0e7e24e02fd8adede333b797 (patch) | |
tree | fd6680b6a8941ac1a3149ae4b77f159701bb1a61 /drivers/usb/gadget/function/storage_common.c | |
parent | 90fccb529d241b55829701cfb9eb3086570f38b8 (diff) |
usb: gadget: Gadget directory cleanup - group usb functions
The drivers/usb/gadget directory contains many files.
Files which are related can be distributed into separate directories.
This patch moves the USB functions implementations into a separate directory.
Signed-off-by: Andrzej Pietrasiewicz <andrzej.p@samsung.com>
Signed-off-by: Felipe Balbi <balbi@ti.com>
Diffstat (limited to 'drivers/usb/gadget/function/storage_common.c')
-rw-r--r-- | drivers/usb/gadget/function/storage_common.c | 504 |
1 files changed, 504 insertions, 0 deletions
diff --git a/drivers/usb/gadget/function/storage_common.c b/drivers/usb/gadget/function/storage_common.c new file mode 100644 index 000000000000..648f9e489b39 --- /dev/null +++ b/drivers/usb/gadget/function/storage_common.c | |||
@@ -0,0 +1,504 @@ | |||
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 (mina86@mina86.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 | |||
14 | /* | ||
15 | * This file requires the following identifiers used in USB strings to | ||
16 | * be defined (each of type pointer to char): | ||
17 | * - fsg_string_interface -- name of the interface | ||
18 | */ | ||
19 | |||
20 | /* | ||
21 | * When USB_GADGET_DEBUG_FILES is defined the module param num_buffers | ||
22 | * sets the number of pipeline buffers (length of the fsg_buffhd array). | ||
23 | * The valid range of num_buffers is: num >= 2 && num <= 4. | ||
24 | */ | ||
25 | |||
26 | #include <linux/module.h> | ||
27 | #include <linux/blkdev.h> | ||
28 | #include <linux/file.h> | ||
29 | #include <linux/fs.h> | ||
30 | #include <linux/usb/composite.h> | ||
31 | |||
32 | #include "storage_common.h" | ||
33 | |||
34 | /* There is only one interface. */ | ||
35 | |||
36 | struct usb_interface_descriptor fsg_intf_desc = { | ||
37 | .bLength = sizeof fsg_intf_desc, | ||
38 | .bDescriptorType = USB_DT_INTERFACE, | ||
39 | |||
40 | .bNumEndpoints = 2, /* Adjusted during fsg_bind() */ | ||
41 | .bInterfaceClass = USB_CLASS_MASS_STORAGE, | ||
42 | .bInterfaceSubClass = USB_SC_SCSI, /* Adjusted during fsg_bind() */ | ||
43 | .bInterfaceProtocol = USB_PR_BULK, /* Adjusted during fsg_bind() */ | ||
44 | .iInterface = FSG_STRING_INTERFACE, | ||
45 | }; | ||
46 | EXPORT_SYMBOL_GPL(fsg_intf_desc); | ||
47 | |||
48 | /* | ||
49 | * Three full-speed endpoint descriptors: bulk-in, bulk-out, and | ||
50 | * interrupt-in. | ||
51 | */ | ||
52 | |||
53 | struct usb_endpoint_descriptor fsg_fs_bulk_in_desc = { | ||
54 | .bLength = USB_DT_ENDPOINT_SIZE, | ||
55 | .bDescriptorType = USB_DT_ENDPOINT, | ||
56 | |||
57 | .bEndpointAddress = USB_DIR_IN, | ||
58 | .bmAttributes = USB_ENDPOINT_XFER_BULK, | ||
59 | /* wMaxPacketSize set by autoconfiguration */ | ||
60 | }; | ||
61 | EXPORT_SYMBOL_GPL(fsg_fs_bulk_in_desc); | ||
62 | |||
63 | struct usb_endpoint_descriptor fsg_fs_bulk_out_desc = { | ||
64 | .bLength = USB_DT_ENDPOINT_SIZE, | ||
65 | .bDescriptorType = USB_DT_ENDPOINT, | ||
66 | |||
67 | .bEndpointAddress = USB_DIR_OUT, | ||
68 | .bmAttributes = USB_ENDPOINT_XFER_BULK, | ||
69 | /* wMaxPacketSize set by autoconfiguration */ | ||
70 | }; | ||
71 | EXPORT_SYMBOL_GPL(fsg_fs_bulk_out_desc); | ||
72 | |||
73 | struct usb_descriptor_header *fsg_fs_function[] = { | ||
74 | (struct usb_descriptor_header *) &fsg_intf_desc, | ||
75 | (struct usb_descriptor_header *) &fsg_fs_bulk_in_desc, | ||
76 | (struct usb_descriptor_header *) &fsg_fs_bulk_out_desc, | ||
77 | NULL, | ||
78 | }; | ||
79 | EXPORT_SYMBOL_GPL(fsg_fs_function); | ||
80 | |||
81 | |||
82 | /* | ||
83 | * USB 2.0 devices need to expose both high speed and full speed | ||
84 | * descriptors, unless they only run at full speed. | ||
85 | * | ||
86 | * That means alternate endpoint descriptors (bigger packets) | ||
87 | * and a "device qualifier" ... plus more construction options | ||
88 | * for the configuration descriptor. | ||
89 | */ | ||
90 | struct usb_endpoint_descriptor fsg_hs_bulk_in_desc = { | ||
91 | .bLength = USB_DT_ENDPOINT_SIZE, | ||
92 | .bDescriptorType = USB_DT_ENDPOINT, | ||
93 | |||
94 | /* bEndpointAddress copied from fs_bulk_in_desc during fsg_bind() */ | ||
95 | .bmAttributes = USB_ENDPOINT_XFER_BULK, | ||
96 | .wMaxPacketSize = cpu_to_le16(512), | ||
97 | }; | ||
98 | EXPORT_SYMBOL_GPL(fsg_hs_bulk_in_desc); | ||
99 | |||
100 | struct usb_endpoint_descriptor fsg_hs_bulk_out_desc = { | ||
101 | .bLength = USB_DT_ENDPOINT_SIZE, | ||
102 | .bDescriptorType = USB_DT_ENDPOINT, | ||
103 | |||
104 | /* bEndpointAddress copied from fs_bulk_out_desc during fsg_bind() */ | ||
105 | .bmAttributes = USB_ENDPOINT_XFER_BULK, | ||
106 | .wMaxPacketSize = cpu_to_le16(512), | ||
107 | .bInterval = 1, /* NAK every 1 uframe */ | ||
108 | }; | ||
109 | EXPORT_SYMBOL_GPL(fsg_hs_bulk_out_desc); | ||
110 | |||
111 | |||
112 | struct usb_descriptor_header *fsg_hs_function[] = { | ||
113 | (struct usb_descriptor_header *) &fsg_intf_desc, | ||
114 | (struct usb_descriptor_header *) &fsg_hs_bulk_in_desc, | ||
115 | (struct usb_descriptor_header *) &fsg_hs_bulk_out_desc, | ||
116 | NULL, | ||
117 | }; | ||
118 | EXPORT_SYMBOL_GPL(fsg_hs_function); | ||
119 | |||
120 | struct usb_endpoint_descriptor fsg_ss_bulk_in_desc = { | ||
121 | .bLength = USB_DT_ENDPOINT_SIZE, | ||
122 | .bDescriptorType = USB_DT_ENDPOINT, | ||
123 | |||
124 | /* bEndpointAddress copied from fs_bulk_in_desc during fsg_bind() */ | ||
125 | .bmAttributes = USB_ENDPOINT_XFER_BULK, | ||
126 | .wMaxPacketSize = cpu_to_le16(1024), | ||
127 | }; | ||
128 | EXPORT_SYMBOL_GPL(fsg_ss_bulk_in_desc); | ||
129 | |||
130 | struct usb_ss_ep_comp_descriptor fsg_ss_bulk_in_comp_desc = { | ||
131 | .bLength = sizeof(fsg_ss_bulk_in_comp_desc), | ||
132 | .bDescriptorType = USB_DT_SS_ENDPOINT_COMP, | ||
133 | |||
134 | /*.bMaxBurst = DYNAMIC, */ | ||
135 | }; | ||
136 | EXPORT_SYMBOL_GPL(fsg_ss_bulk_in_comp_desc); | ||
137 | |||
138 | struct usb_endpoint_descriptor fsg_ss_bulk_out_desc = { | ||
139 | .bLength = USB_DT_ENDPOINT_SIZE, | ||
140 | .bDescriptorType = USB_DT_ENDPOINT, | ||
141 | |||
142 | /* bEndpointAddress copied from fs_bulk_out_desc during fsg_bind() */ | ||
143 | .bmAttributes = USB_ENDPOINT_XFER_BULK, | ||
144 | .wMaxPacketSize = cpu_to_le16(1024), | ||
145 | }; | ||
146 | EXPORT_SYMBOL_GPL(fsg_ss_bulk_out_desc); | ||
147 | |||
148 | struct usb_ss_ep_comp_descriptor fsg_ss_bulk_out_comp_desc = { | ||
149 | .bLength = sizeof(fsg_ss_bulk_in_comp_desc), | ||
150 | .bDescriptorType = USB_DT_SS_ENDPOINT_COMP, | ||
151 | |||
152 | /*.bMaxBurst = DYNAMIC, */ | ||
153 | }; | ||
154 | EXPORT_SYMBOL_GPL(fsg_ss_bulk_out_comp_desc); | ||
155 | |||
156 | struct usb_descriptor_header *fsg_ss_function[] = { | ||
157 | (struct usb_descriptor_header *) &fsg_intf_desc, | ||
158 | (struct usb_descriptor_header *) &fsg_ss_bulk_in_desc, | ||
159 | (struct usb_descriptor_header *) &fsg_ss_bulk_in_comp_desc, | ||
160 | (struct usb_descriptor_header *) &fsg_ss_bulk_out_desc, | ||
161 | (struct usb_descriptor_header *) &fsg_ss_bulk_out_comp_desc, | ||
162 | NULL, | ||
163 | }; | ||
164 | EXPORT_SYMBOL_GPL(fsg_ss_function); | ||
165 | |||
166 | |||
167 | /*-------------------------------------------------------------------------*/ | ||
168 | |||
169 | /* | ||
170 | * If the next two routines are called while the gadget is registered, | ||
171 | * the caller must own fsg->filesem for writing. | ||
172 | */ | ||
173 | |||
174 | void fsg_lun_close(struct fsg_lun *curlun) | ||
175 | { | ||
176 | if (curlun->filp) { | ||
177 | LDBG(curlun, "close backing file\n"); | ||
178 | fput(curlun->filp); | ||
179 | curlun->filp = NULL; | ||
180 | } | ||
181 | } | ||
182 | EXPORT_SYMBOL_GPL(fsg_lun_close); | ||
183 | |||
184 | int fsg_lun_open(struct fsg_lun *curlun, const char *filename) | ||
185 | { | ||
186 | int ro; | ||
187 | struct file *filp = NULL; | ||
188 | int rc = -EINVAL; | ||
189 | struct inode *inode = NULL; | ||
190 | loff_t size; | ||
191 | loff_t num_sectors; | ||
192 | loff_t min_sectors; | ||
193 | unsigned int blkbits; | ||
194 | unsigned int blksize; | ||
195 | |||
196 | /* R/W if we can, R/O if we must */ | ||
197 | ro = curlun->initially_ro; | ||
198 | if (!ro) { | ||
199 | filp = filp_open(filename, O_RDWR | O_LARGEFILE, 0); | ||
200 | if (PTR_ERR(filp) == -EROFS || PTR_ERR(filp) == -EACCES) | ||
201 | ro = 1; | ||
202 | } | ||
203 | if (ro) | ||
204 | filp = filp_open(filename, O_RDONLY | O_LARGEFILE, 0); | ||
205 | if (IS_ERR(filp)) { | ||
206 | LINFO(curlun, "unable to open backing file: %s\n", filename); | ||
207 | return PTR_ERR(filp); | ||
208 | } | ||
209 | |||
210 | if (!(filp->f_mode & FMODE_WRITE)) | ||
211 | ro = 1; | ||
212 | |||
213 | inode = file_inode(filp); | ||
214 | if ((!S_ISREG(inode->i_mode) && !S_ISBLK(inode->i_mode))) { | ||
215 | LINFO(curlun, "invalid file type: %s\n", filename); | ||
216 | goto out; | ||
217 | } | ||
218 | |||
219 | /* | ||
220 | * If we can't read the file, it's no good. | ||
221 | * If we can't write the file, use it read-only. | ||
222 | */ | ||
223 | if (!(filp->f_mode & FMODE_CAN_READ)) { | ||
224 | LINFO(curlun, "file not readable: %s\n", filename); | ||
225 | goto out; | ||
226 | } | ||
227 | if (!(filp->f_mode & FMODE_CAN_WRITE)) | ||
228 | ro = 1; | ||
229 | |||
230 | size = i_size_read(inode->i_mapping->host); | ||
231 | if (size < 0) { | ||
232 | LINFO(curlun, "unable to find file size: %s\n", filename); | ||
233 | rc = (int) size; | ||
234 | goto out; | ||
235 | } | ||
236 | |||
237 | if (curlun->cdrom) { | ||
238 | blksize = 2048; | ||
239 | blkbits = 11; | ||
240 | } else if (inode->i_bdev) { | ||
241 | blksize = bdev_logical_block_size(inode->i_bdev); | ||
242 | blkbits = blksize_bits(blksize); | ||
243 | } else { | ||
244 | blksize = 512; | ||
245 | blkbits = 9; | ||
246 | } | ||
247 | |||
248 | num_sectors = size >> blkbits; /* File size in logic-block-size blocks */ | ||
249 | min_sectors = 1; | ||
250 | if (curlun->cdrom) { | ||
251 | min_sectors = 300; /* Smallest track is 300 frames */ | ||
252 | if (num_sectors >= 256*60*75) { | ||
253 | num_sectors = 256*60*75 - 1; | ||
254 | LINFO(curlun, "file too big: %s\n", filename); | ||
255 | LINFO(curlun, "using only first %d blocks\n", | ||
256 | (int) num_sectors); | ||
257 | } | ||
258 | } | ||
259 | if (num_sectors < min_sectors) { | ||
260 | LINFO(curlun, "file too small: %s\n", filename); | ||
261 | rc = -ETOOSMALL; | ||
262 | goto out; | ||
263 | } | ||
264 | |||
265 | if (fsg_lun_is_open(curlun)) | ||
266 | fsg_lun_close(curlun); | ||
267 | |||
268 | curlun->blksize = blksize; | ||
269 | curlun->blkbits = blkbits; | ||
270 | curlun->ro = ro; | ||
271 | curlun->filp = filp; | ||
272 | curlun->file_length = size; | ||
273 | curlun->num_sectors = num_sectors; | ||
274 | LDBG(curlun, "open backing file: %s\n", filename); | ||
275 | return 0; | ||
276 | |||
277 | out: | ||
278 | fput(filp); | ||
279 | return rc; | ||
280 | } | ||
281 | EXPORT_SYMBOL_GPL(fsg_lun_open); | ||
282 | |||
283 | |||
284 | /*-------------------------------------------------------------------------*/ | ||
285 | |||
286 | /* | ||
287 | * Sync the file data, don't bother with the metadata. | ||
288 | * This code was copied from fs/buffer.c:sys_fdatasync(). | ||
289 | */ | ||
290 | int fsg_lun_fsync_sub(struct fsg_lun *curlun) | ||
291 | { | ||
292 | struct file *filp = curlun->filp; | ||
293 | |||
294 | if (curlun->ro || !filp) | ||
295 | return 0; | ||
296 | return vfs_fsync(filp, 1); | ||
297 | } | ||
298 | EXPORT_SYMBOL_GPL(fsg_lun_fsync_sub); | ||
299 | |||
300 | void store_cdrom_address(u8 *dest, int msf, u32 addr) | ||
301 | { | ||
302 | if (msf) { | ||
303 | /* Convert to Minutes-Seconds-Frames */ | ||
304 | addr >>= 2; /* Convert to 2048-byte frames */ | ||
305 | addr += 2*75; /* Lead-in occupies 2 seconds */ | ||
306 | dest[3] = addr % 75; /* Frames */ | ||
307 | addr /= 75; | ||
308 | dest[2] = addr % 60; /* Seconds */ | ||
309 | addr /= 60; | ||
310 | dest[1] = addr; /* Minutes */ | ||
311 | dest[0] = 0; /* Reserved */ | ||
312 | } else { | ||
313 | /* Absolute sector */ | ||
314 | put_unaligned_be32(addr, dest); | ||
315 | } | ||
316 | } | ||
317 | EXPORT_SYMBOL_GPL(store_cdrom_address); | ||
318 | |||
319 | /*-------------------------------------------------------------------------*/ | ||
320 | |||
321 | |||
322 | ssize_t fsg_show_ro(struct fsg_lun *curlun, char *buf) | ||
323 | { | ||
324 | return sprintf(buf, "%d\n", fsg_lun_is_open(curlun) | ||
325 | ? curlun->ro | ||
326 | : curlun->initially_ro); | ||
327 | } | ||
328 | EXPORT_SYMBOL_GPL(fsg_show_ro); | ||
329 | |||
330 | ssize_t fsg_show_nofua(struct fsg_lun *curlun, char *buf) | ||
331 | { | ||
332 | return sprintf(buf, "%u\n", curlun->nofua); | ||
333 | } | ||
334 | EXPORT_SYMBOL_GPL(fsg_show_nofua); | ||
335 | |||
336 | ssize_t fsg_show_file(struct fsg_lun *curlun, struct rw_semaphore *filesem, | ||
337 | char *buf) | ||
338 | { | ||
339 | char *p; | ||
340 | ssize_t rc; | ||
341 | |||
342 | down_read(filesem); | ||
343 | if (fsg_lun_is_open(curlun)) { /* Get the complete pathname */ | ||
344 | p = d_path(&curlun->filp->f_path, buf, PAGE_SIZE - 1); | ||
345 | if (IS_ERR(p)) | ||
346 | rc = PTR_ERR(p); | ||
347 | else { | ||
348 | rc = strlen(p); | ||
349 | memmove(buf, p, rc); | ||
350 | buf[rc] = '\n'; /* Add a newline */ | ||
351 | buf[++rc] = 0; | ||
352 | } | ||
353 | } else { /* No file, return 0 bytes */ | ||
354 | *buf = 0; | ||
355 | rc = 0; | ||
356 | } | ||
357 | up_read(filesem); | ||
358 | return rc; | ||
359 | } | ||
360 | EXPORT_SYMBOL_GPL(fsg_show_file); | ||
361 | |||
362 | ssize_t fsg_show_cdrom(struct fsg_lun *curlun, char *buf) | ||
363 | { | ||
364 | return sprintf(buf, "%u\n", curlun->cdrom); | ||
365 | } | ||
366 | EXPORT_SYMBOL_GPL(fsg_show_cdrom); | ||
367 | |||
368 | ssize_t fsg_show_removable(struct fsg_lun *curlun, char *buf) | ||
369 | { | ||
370 | return sprintf(buf, "%u\n", curlun->removable); | ||
371 | } | ||
372 | EXPORT_SYMBOL_GPL(fsg_show_removable); | ||
373 | |||
374 | /* | ||
375 | * The caller must hold fsg->filesem for reading when calling this function. | ||
376 | */ | ||
377 | static ssize_t _fsg_store_ro(struct fsg_lun *curlun, bool ro) | ||
378 | { | ||
379 | if (fsg_lun_is_open(curlun)) { | ||
380 | LDBG(curlun, "read-only status change prevented\n"); | ||
381 | return -EBUSY; | ||
382 | } | ||
383 | |||
384 | curlun->ro = ro; | ||
385 | curlun->initially_ro = ro; | ||
386 | LDBG(curlun, "read-only status set to %d\n", curlun->ro); | ||
387 | |||
388 | return 0; | ||
389 | } | ||
390 | |||
391 | ssize_t fsg_store_ro(struct fsg_lun *curlun, struct rw_semaphore *filesem, | ||
392 | const char *buf, size_t count) | ||
393 | { | ||
394 | ssize_t rc; | ||
395 | bool ro; | ||
396 | |||
397 | rc = strtobool(buf, &ro); | ||
398 | if (rc) | ||
399 | return rc; | ||
400 | |||
401 | /* | ||
402 | * Allow the write-enable status to change only while the | ||
403 | * backing file is closed. | ||
404 | */ | ||
405 | down_read(filesem); | ||
406 | rc = _fsg_store_ro(curlun, ro); | ||
407 | if (!rc) | ||
408 | rc = count; | ||
409 | up_read(filesem); | ||
410 | |||
411 | return rc; | ||
412 | } | ||
413 | EXPORT_SYMBOL_GPL(fsg_store_ro); | ||
414 | |||
415 | ssize_t fsg_store_nofua(struct fsg_lun *curlun, const char *buf, size_t count) | ||
416 | { | ||
417 | bool nofua; | ||
418 | int ret; | ||
419 | |||
420 | ret = strtobool(buf, &nofua); | ||
421 | if (ret) | ||
422 | return ret; | ||
423 | |||
424 | /* Sync data when switching from async mode to sync */ | ||
425 | if (!nofua && curlun->nofua) | ||
426 | fsg_lun_fsync_sub(curlun); | ||
427 | |||
428 | curlun->nofua = nofua; | ||
429 | |||
430 | return count; | ||
431 | } | ||
432 | EXPORT_SYMBOL_GPL(fsg_store_nofua); | ||
433 | |||
434 | ssize_t fsg_store_file(struct fsg_lun *curlun, struct rw_semaphore *filesem, | ||
435 | const char *buf, size_t count) | ||
436 | { | ||
437 | int rc = 0; | ||
438 | |||
439 | if (curlun->prevent_medium_removal && fsg_lun_is_open(curlun)) { | ||
440 | LDBG(curlun, "eject attempt prevented\n"); | ||
441 | return -EBUSY; /* "Door is locked" */ | ||
442 | } | ||
443 | |||
444 | /* Remove a trailing newline */ | ||
445 | if (count > 0 && buf[count-1] == '\n') | ||
446 | ((char *) buf)[count-1] = 0; /* Ugh! */ | ||
447 | |||
448 | /* Load new medium */ | ||
449 | down_write(filesem); | ||
450 | if (count > 0 && buf[0]) { | ||
451 | /* fsg_lun_open() will close existing file if any. */ | ||
452 | rc = fsg_lun_open(curlun, buf); | ||
453 | if (rc == 0) | ||
454 | curlun->unit_attention_data = | ||
455 | SS_NOT_READY_TO_READY_TRANSITION; | ||
456 | } else if (fsg_lun_is_open(curlun)) { | ||
457 | fsg_lun_close(curlun); | ||
458 | curlun->unit_attention_data = SS_MEDIUM_NOT_PRESENT; | ||
459 | } | ||
460 | up_write(filesem); | ||
461 | return (rc < 0 ? rc : count); | ||
462 | } | ||
463 | EXPORT_SYMBOL_GPL(fsg_store_file); | ||
464 | |||
465 | ssize_t fsg_store_cdrom(struct fsg_lun *curlun, struct rw_semaphore *filesem, | ||
466 | const char *buf, size_t count) | ||
467 | { | ||
468 | bool cdrom; | ||
469 | int ret; | ||
470 | |||
471 | ret = strtobool(buf, &cdrom); | ||
472 | if (ret) | ||
473 | return ret; | ||
474 | |||
475 | down_read(filesem); | ||
476 | ret = cdrom ? _fsg_store_ro(curlun, true) : 0; | ||
477 | |||
478 | if (!ret) { | ||
479 | curlun->cdrom = cdrom; | ||
480 | ret = count; | ||
481 | } | ||
482 | up_read(filesem); | ||
483 | |||
484 | return ret; | ||
485 | } | ||
486 | EXPORT_SYMBOL_GPL(fsg_store_cdrom); | ||
487 | |||
488 | ssize_t fsg_store_removable(struct fsg_lun *curlun, const char *buf, | ||
489 | size_t count) | ||
490 | { | ||
491 | bool removable; | ||
492 | int ret; | ||
493 | |||
494 | ret = strtobool(buf, &removable); | ||
495 | if (ret) | ||
496 | return ret; | ||
497 | |||
498 | curlun->removable = removable; | ||
499 | |||
500 | return count; | ||
501 | } | ||
502 | EXPORT_SYMBOL_GPL(fsg_store_removable); | ||
503 | |||
504 | MODULE_LICENSE("GPL"); | ||