2 * storage_common.c -- Common definitions for mass storage functionality
4 * Copyright (C) 2003-2008 Alan Stern
5 * Copyeight (C) 2009 Samsung Electronics
6 * Author: Michal Nazarewicz (mina86@mina86.com)
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.
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
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.
26 #include <linux/module.h>
27 #include <linux/blkdev.h>
28 #include <linux/file.h>
30 #include <linux/usb/composite.h>
32 #include "storage_common.h"
34 /* There is only one interface. */
36 struct usb_interface_descriptor fsg_intf_desc = {
37 .bLength = sizeof fsg_intf_desc,
38 .bDescriptorType = USB_DT_INTERFACE,
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,
46 EXPORT_SYMBOL_GPL(fsg_intf_desc);
49 * Three full-speed endpoint descriptors: bulk-in, bulk-out, and
53 struct usb_endpoint_descriptor fsg_fs_bulk_in_desc = {
54 .bLength = USB_DT_ENDPOINT_SIZE,
55 .bDescriptorType = USB_DT_ENDPOINT,
57 .bEndpointAddress = USB_DIR_IN,
58 .bmAttributes = USB_ENDPOINT_XFER_BULK,
59 /* wMaxPacketSize set by autoconfiguration */
61 EXPORT_SYMBOL_GPL(fsg_fs_bulk_in_desc);
63 struct usb_endpoint_descriptor fsg_fs_bulk_out_desc = {
64 .bLength = USB_DT_ENDPOINT_SIZE,
65 .bDescriptorType = USB_DT_ENDPOINT,
67 .bEndpointAddress = USB_DIR_OUT,
68 .bmAttributes = USB_ENDPOINT_XFER_BULK,
69 /* wMaxPacketSize set by autoconfiguration */
71 EXPORT_SYMBOL_GPL(fsg_fs_bulk_out_desc);
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,
79 EXPORT_SYMBOL_GPL(fsg_fs_function);
83 * USB 2.0 devices need to expose both high speed and full speed
84 * descriptors, unless they only run at full speed.
86 * That means alternate endpoint descriptors (bigger packets).
88 struct usb_endpoint_descriptor fsg_hs_bulk_in_desc = {
89 .bLength = USB_DT_ENDPOINT_SIZE,
90 .bDescriptorType = USB_DT_ENDPOINT,
92 /* bEndpointAddress copied from fs_bulk_in_desc during fsg_bind() */
93 .bmAttributes = USB_ENDPOINT_XFER_BULK,
94 .wMaxPacketSize = cpu_to_le16(512),
96 EXPORT_SYMBOL_GPL(fsg_hs_bulk_in_desc);
98 struct usb_endpoint_descriptor fsg_hs_bulk_out_desc = {
99 .bLength = USB_DT_ENDPOINT_SIZE,
100 .bDescriptorType = USB_DT_ENDPOINT,
102 /* bEndpointAddress copied from fs_bulk_out_desc during fsg_bind() */
103 .bmAttributes = USB_ENDPOINT_XFER_BULK,
104 .wMaxPacketSize = cpu_to_le16(512),
105 .bInterval = 1, /* NAK every 1 uframe */
107 EXPORT_SYMBOL_GPL(fsg_hs_bulk_out_desc);
110 struct usb_descriptor_header *fsg_hs_function[] = {
111 (struct usb_descriptor_header *) &fsg_intf_desc,
112 (struct usb_descriptor_header *) &fsg_hs_bulk_in_desc,
113 (struct usb_descriptor_header *) &fsg_hs_bulk_out_desc,
116 EXPORT_SYMBOL_GPL(fsg_hs_function);
118 struct usb_endpoint_descriptor fsg_ss_bulk_in_desc = {
119 .bLength = USB_DT_ENDPOINT_SIZE,
120 .bDescriptorType = USB_DT_ENDPOINT,
122 /* bEndpointAddress copied from fs_bulk_in_desc during fsg_bind() */
123 .bmAttributes = USB_ENDPOINT_XFER_BULK,
124 .wMaxPacketSize = cpu_to_le16(1024),
126 EXPORT_SYMBOL_GPL(fsg_ss_bulk_in_desc);
128 struct usb_ss_ep_comp_descriptor fsg_ss_bulk_in_comp_desc = {
129 .bLength = sizeof(fsg_ss_bulk_in_comp_desc),
130 .bDescriptorType = USB_DT_SS_ENDPOINT_COMP,
132 /*.bMaxBurst = DYNAMIC, */
134 EXPORT_SYMBOL_GPL(fsg_ss_bulk_in_comp_desc);
136 struct usb_endpoint_descriptor fsg_ss_bulk_out_desc = {
137 .bLength = USB_DT_ENDPOINT_SIZE,
138 .bDescriptorType = USB_DT_ENDPOINT,
140 /* bEndpointAddress copied from fs_bulk_out_desc during fsg_bind() */
141 .bmAttributes = USB_ENDPOINT_XFER_BULK,
142 .wMaxPacketSize = cpu_to_le16(1024),
144 EXPORT_SYMBOL_GPL(fsg_ss_bulk_out_desc);
146 struct usb_ss_ep_comp_descriptor fsg_ss_bulk_out_comp_desc = {
147 .bLength = sizeof(fsg_ss_bulk_in_comp_desc),
148 .bDescriptorType = USB_DT_SS_ENDPOINT_COMP,
150 /*.bMaxBurst = DYNAMIC, */
152 EXPORT_SYMBOL_GPL(fsg_ss_bulk_out_comp_desc);
154 struct usb_descriptor_header *fsg_ss_function[] = {
155 (struct usb_descriptor_header *) &fsg_intf_desc,
156 (struct usb_descriptor_header *) &fsg_ss_bulk_in_desc,
157 (struct usb_descriptor_header *) &fsg_ss_bulk_in_comp_desc,
158 (struct usb_descriptor_header *) &fsg_ss_bulk_out_desc,
159 (struct usb_descriptor_header *) &fsg_ss_bulk_out_comp_desc,
162 EXPORT_SYMBOL_GPL(fsg_ss_function);
165 /*-------------------------------------------------------------------------*/
168 * If the next two routines are called while the gadget is registered,
169 * the caller must own fsg->filesem for writing.
172 void fsg_lun_close(struct fsg_lun *curlun)
175 LDBG(curlun, "close backing file\n");
180 EXPORT_SYMBOL_GPL(fsg_lun_close);
182 int fsg_lun_open(struct fsg_lun *curlun, const char *filename)
185 struct file *filp = NULL;
187 struct inode *inode = NULL;
191 unsigned int blkbits;
192 unsigned int blksize;
194 /* R/W if we can, R/O if we must */
195 ro = curlun->initially_ro;
197 filp = filp_open(filename, O_RDWR | O_LARGEFILE, 0);
198 if (PTR_ERR(filp) == -EROFS || PTR_ERR(filp) == -EACCES)
202 filp = filp_open(filename, O_RDONLY | O_LARGEFILE, 0);
204 LINFO(curlun, "unable to open backing file: %s\n", filename);
205 return PTR_ERR(filp);
208 if (!(filp->f_mode & FMODE_WRITE))
211 inode = file_inode(filp);
212 if ((!S_ISREG(inode->i_mode) && !S_ISBLK(inode->i_mode))) {
213 LINFO(curlun, "invalid file type: %s\n", filename);
218 * If we can't read the file, it's no good.
219 * If we can't write the file, use it read-only.
221 if (!(filp->f_mode & FMODE_CAN_READ)) {
222 LINFO(curlun, "file not readable: %s\n", filename);
225 if (!(filp->f_mode & FMODE_CAN_WRITE))
228 size = i_size_read(inode->i_mapping->host);
230 LINFO(curlun, "unable to find file size: %s\n", filename);
238 } else if (inode->i_bdev) {
239 blksize = bdev_logical_block_size(inode->i_bdev);
240 blkbits = blksize_bits(blksize);
246 num_sectors = size >> blkbits; /* File size in logic-block-size blocks */
249 min_sectors = 300; /* Smallest track is 300 frames */
250 if (num_sectors >= 256*60*75) {
251 num_sectors = 256*60*75 - 1;
252 LINFO(curlun, "file too big: %s\n", filename);
253 LINFO(curlun, "using only first %d blocks\n",
257 if (num_sectors < min_sectors) {
258 LINFO(curlun, "file too small: %s\n", filename);
263 if (fsg_lun_is_open(curlun))
264 fsg_lun_close(curlun);
266 curlun->blksize = blksize;
267 curlun->blkbits = blkbits;
270 curlun->file_length = size;
271 curlun->num_sectors = num_sectors;
272 LDBG(curlun, "open backing file: %s\n", filename);
279 EXPORT_SYMBOL_GPL(fsg_lun_open);
282 /*-------------------------------------------------------------------------*/
285 * Sync the file data, don't bother with the metadata.
286 * This code was copied from fs/buffer.c:sys_fdatasync().
288 int fsg_lun_fsync_sub(struct fsg_lun *curlun)
290 struct file *filp = curlun->filp;
292 if (curlun->ro || !filp)
294 return vfs_fsync(filp, 1);
296 EXPORT_SYMBOL_GPL(fsg_lun_fsync_sub);
298 void store_cdrom_address(u8 *dest, int msf, u32 addr)
302 * Convert to Minutes-Seconds-Frames.
303 * Sector size is already set to 2048 bytes.
305 addr += 2*75; /* Lead-in occupies 2 seconds */
306 dest[3] = addr % 75; /* Frames */
308 dest[2] = addr % 60; /* Seconds */
310 dest[1] = addr; /* Minutes */
311 dest[0] = 0; /* Reserved */
313 /* Absolute sector */
314 put_unaligned_be32(addr, dest);
317 EXPORT_SYMBOL_GPL(store_cdrom_address);
319 /*-------------------------------------------------------------------------*/
322 ssize_t fsg_show_ro(struct fsg_lun *curlun, char *buf)
324 return sprintf(buf, "%d\n", fsg_lun_is_open(curlun)
326 : curlun->initially_ro);
328 EXPORT_SYMBOL_GPL(fsg_show_ro);
330 ssize_t fsg_show_nofua(struct fsg_lun *curlun, char *buf)
332 return sprintf(buf, "%u\n", curlun->nofua);
334 EXPORT_SYMBOL_GPL(fsg_show_nofua);
336 ssize_t fsg_show_file(struct fsg_lun *curlun, struct rw_semaphore *filesem,
343 if (fsg_lun_is_open(curlun)) { /* Get the complete pathname */
344 p = file_path(curlun->filp, buf, PAGE_SIZE - 1);
350 buf[rc] = '\n'; /* Add a newline */
353 } else { /* No file, return 0 bytes */
360 EXPORT_SYMBOL_GPL(fsg_show_file);
362 ssize_t fsg_show_cdrom(struct fsg_lun *curlun, char *buf)
364 return sprintf(buf, "%u\n", curlun->cdrom);
366 EXPORT_SYMBOL_GPL(fsg_show_cdrom);
368 ssize_t fsg_show_removable(struct fsg_lun *curlun, char *buf)
370 return sprintf(buf, "%u\n", curlun->removable);
372 EXPORT_SYMBOL_GPL(fsg_show_removable);
374 ssize_t fsg_show_inquiry_string(struct fsg_lun *curlun, char *buf)
376 return sprintf(buf, "%s\n", curlun->inquiry_string);
378 EXPORT_SYMBOL_GPL(fsg_show_inquiry_string);
381 * The caller must hold fsg->filesem for reading when calling this function.
383 static ssize_t _fsg_store_ro(struct fsg_lun *curlun, bool ro)
385 if (fsg_lun_is_open(curlun)) {
386 LDBG(curlun, "read-only status change prevented\n");
391 curlun->initially_ro = ro;
392 LDBG(curlun, "read-only status set to %d\n", curlun->ro);
397 ssize_t fsg_store_ro(struct fsg_lun *curlun, struct rw_semaphore *filesem,
398 const char *buf, size_t count)
403 rc = strtobool(buf, &ro);
408 * Allow the write-enable status to change only while the
409 * backing file is closed.
412 rc = _fsg_store_ro(curlun, ro);
419 EXPORT_SYMBOL_GPL(fsg_store_ro);
421 ssize_t fsg_store_nofua(struct fsg_lun *curlun, const char *buf, size_t count)
426 ret = strtobool(buf, &nofua);
430 /* Sync data when switching from async mode to sync */
431 if (!nofua && curlun->nofua)
432 fsg_lun_fsync_sub(curlun);
434 curlun->nofua = nofua;
438 EXPORT_SYMBOL_GPL(fsg_store_nofua);
440 ssize_t fsg_store_file(struct fsg_lun *curlun, struct rw_semaphore *filesem,
441 const char *buf, size_t count)
445 if (curlun->prevent_medium_removal && fsg_lun_is_open(curlun)) {
446 LDBG(curlun, "eject attempt prevented\n");
447 return -EBUSY; /* "Door is locked" */
450 /* Remove a trailing newline */
451 if (count > 0 && buf[count-1] == '\n')
452 ((char *) buf)[count-1] = 0; /* Ugh! */
454 /* Load new medium */
456 if (count > 0 && buf[0]) {
457 /* fsg_lun_open() will close existing file if any. */
458 rc = fsg_lun_open(curlun, buf);
460 curlun->unit_attention_data =
461 SS_NOT_READY_TO_READY_TRANSITION;
462 } else if (fsg_lun_is_open(curlun)) {
463 fsg_lun_close(curlun);
464 curlun->unit_attention_data = SS_MEDIUM_NOT_PRESENT;
467 return (rc < 0 ? rc : count);
469 EXPORT_SYMBOL_GPL(fsg_store_file);
471 ssize_t fsg_store_cdrom(struct fsg_lun *curlun, struct rw_semaphore *filesem,
472 const char *buf, size_t count)
477 ret = strtobool(buf, &cdrom);
482 ret = cdrom ? _fsg_store_ro(curlun, true) : 0;
485 curlun->cdrom = cdrom;
492 EXPORT_SYMBOL_GPL(fsg_store_cdrom);
494 ssize_t fsg_store_removable(struct fsg_lun *curlun, const char *buf,
500 ret = strtobool(buf, &removable);
504 curlun->removable = removable;
508 EXPORT_SYMBOL_GPL(fsg_store_removable);
510 ssize_t fsg_store_inquiry_string(struct fsg_lun *curlun, const char *buf,
513 const size_t len = min(count, sizeof(curlun->inquiry_string));
515 if (len == 0 || buf[0] == '\n') {
516 curlun->inquiry_string[0] = 0;
518 snprintf(curlun->inquiry_string,
519 sizeof(curlun->inquiry_string), "%-28s", buf);
520 if (curlun->inquiry_string[len-1] == '\n')
521 curlun->inquiry_string[len-1] = ' ';
526 EXPORT_SYMBOL_GPL(fsg_store_inquiry_string);
528 MODULE_LICENSE("GPL");