[deliverable/linux.git] / drivers / usb / gadget / function / storage_common.c

/*
 * storage_common.c -- Common definitions for mass storage functionality
 *
 * Copyright (C) 2003-2008 Alan Stern
 * Copyeight (C) 2009 Samsung Electronics
 * Author: Michal Nazarewicz (mina86@mina86.com)
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 */

/*
 * This file requires the following identifiers used in USB strings to
 * be defined (each of type pointer to char):
 *  - fsg_string_interface    -- name of the interface
 */

/*
 * When USB_GADGET_DEBUG_FILES is defined the module param num_buffers
 * sets the number of pipeline buffers (length of the fsg_buffhd array).
 * The valid range of num_buffers is: num >= 2 && num <= 4.
 */

#include <linux/module.h>
#include <linux/blkdev.h>
#include <linux/file.h>
#include <linux/fs.h>
#include <linux/usb/composite.h>

#include "storage_common.h"

/* There is only one interface. */

struct usb_interface_descriptor fsg_intf_desc = {
	.bLength =		sizeof fsg_intf_desc,
	.bDescriptorType =	USB_DT_INTERFACE,

	.bNumEndpoints =	2,		/* Adjusted during fsg_bind() */
	.bInterfaceClass =	USB_CLASS_MASS_STORAGE,
	.bInterfaceSubClass =	USB_SC_SCSI,	/* Adjusted during fsg_bind() */
	.bInterfaceProtocol =	USB_PR_BULK,	/* Adjusted during fsg_bind() */
	.iInterface =		FSG_STRING_INTERFACE,
};
EXPORT_SYMBOL_GPL(fsg_intf_desc);

/*
 * Three full-speed endpoint descriptors: bulk-in, bulk-out, and
 * interrupt-in.
 */

struct usb_endpoint_descriptor fsg_fs_bulk_in_desc = {
	.bLength =		USB_DT_ENDPOINT_SIZE,
	.bDescriptorType =	USB_DT_ENDPOINT,

	.bEndpointAddress =	USB_DIR_IN,
	.bmAttributes =		USB_ENDPOINT_XFER_BULK,
	/* wMaxPacketSize set by autoconfiguration */
};
EXPORT_SYMBOL_GPL(fsg_fs_bulk_in_desc);

struct usb_endpoint_descriptor fsg_fs_bulk_out_desc = {
	.bLength =		USB_DT_ENDPOINT_SIZE,
	.bDescriptorType =	USB_DT_ENDPOINT,

	.bEndpointAddress =	USB_DIR_OUT,
	.bmAttributes =		USB_ENDPOINT_XFER_BULK,
	/* wMaxPacketSize set by autoconfiguration */
};
EXPORT_SYMBOL_GPL(fsg_fs_bulk_out_desc);

struct usb_descriptor_header *fsg_fs_function[] = {
	(struct usb_descriptor_header *) &fsg_intf_desc,
	(struct usb_descriptor_header *) &fsg_fs_bulk_in_desc,
	(struct usb_descriptor_header *) &fsg_fs_bulk_out_desc,
	NULL,
};
EXPORT_SYMBOL_GPL(fsg_fs_function);


/*
 * USB 2.0 devices need to expose both high speed and full speed
 * descriptors, unless they only run at full speed.
 *
 * That means alternate endpoint descriptors (bigger packets).
 */
struct usb_endpoint_descriptor fsg_hs_bulk_in_desc = {
	.bLength =		USB_DT_ENDPOINT_SIZE,
	.bDescriptorType =	USB_DT_ENDPOINT,

	/* bEndpointAddress copied from fs_bulk_in_desc during fsg_bind() */
	.bmAttributes =		USB_ENDPOINT_XFER_BULK,
	.wMaxPacketSize =	cpu_to_le16(512),
};
EXPORT_SYMBOL_GPL(fsg_hs_bulk_in_desc);

struct usb_endpoint_descriptor fsg_hs_bulk_out_desc = {
	.bLength =		USB_DT_ENDPOINT_SIZE,
	.bDescriptorType =	USB_DT_ENDPOINT,

	/* bEndpointAddress copied from fs_bulk_out_desc during fsg_bind() */
	.bmAttributes =		USB_ENDPOINT_XFER_BULK,
	.wMaxPacketSize =	cpu_to_le16(512),
	.bInterval =		1,	/* NAK every 1 uframe */
};
EXPORT_SYMBOL_GPL(fsg_hs_bulk_out_desc);


struct usb_descriptor_header *fsg_hs_function[] = {
	(struct usb_descriptor_header *) &fsg_intf_desc,
	(struct usb_descriptor_header *) &fsg_hs_bulk_in_desc,
	(struct usb_descriptor_header *) &fsg_hs_bulk_out_desc,
	NULL,
};
EXPORT_SYMBOL_GPL(fsg_hs_function);

struct usb_endpoint_descriptor fsg_ss_bulk_in_desc = {
	.bLength =		USB_DT_ENDPOINT_SIZE,
	.bDescriptorType =	USB_DT_ENDPOINT,

	/* bEndpointAddress copied from fs_bulk_in_desc during fsg_bind() */
	.bmAttributes =		USB_ENDPOINT_XFER_BULK,
	.wMaxPacketSize =	cpu_to_le16(1024),
};
EXPORT_SYMBOL_GPL(fsg_ss_bulk_in_desc);

struct usb_ss_ep_comp_descriptor fsg_ss_bulk_in_comp_desc = {
	.bLength =		sizeof(fsg_ss_bulk_in_comp_desc),
	.bDescriptorType =	USB_DT_SS_ENDPOINT_COMP,

	/*.bMaxBurst =		DYNAMIC, */
};
EXPORT_SYMBOL_GPL(fsg_ss_bulk_in_comp_desc);

struct usb_endpoint_descriptor fsg_ss_bulk_out_desc = {
	.bLength =		USB_DT_ENDPOINT_SIZE,
	.bDescriptorType =	USB_DT_ENDPOINT,

	/* bEndpointAddress copied from fs_bulk_out_desc during fsg_bind() */
	.bmAttributes =		USB_ENDPOINT_XFER_BULK,
	.wMaxPacketSize =	cpu_to_le16(1024),
};
EXPORT_SYMBOL_GPL(fsg_ss_bulk_out_desc);

struct usb_ss_ep_comp_descriptor fsg_ss_bulk_out_comp_desc = {
	.bLength =		sizeof(fsg_ss_bulk_in_comp_desc),
	.bDescriptorType =	USB_DT_SS_ENDPOINT_COMP,

	/*.bMaxBurst =		DYNAMIC, */
};
EXPORT_SYMBOL_GPL(fsg_ss_bulk_out_comp_desc);

struct usb_descriptor_header *fsg_ss_function[] = {
	(struct usb_descriptor_header *) &fsg_intf_desc,
	(struct usb_descriptor_header *) &fsg_ss_bulk_in_desc,
	(struct usb_descriptor_header *) &fsg_ss_bulk_in_comp_desc,
	(struct usb_descriptor_header *) &fsg_ss_bulk_out_desc,
	(struct usb_descriptor_header *) &fsg_ss_bulk_out_comp_desc,
	NULL,
};
EXPORT_SYMBOL_GPL(fsg_ss_function);


 /*-------------------------------------------------------------------------*/

/*
 * If the next two routines are called while the gadget is registered,
 * the caller must own fsg->filesem for writing.
 */

void fsg_lun_close(struct fsg_lun *curlun)
{
	if (curlun->filp) {
		LDBG(curlun, "close backing file\n");
		fput(curlun->filp);
		curlun->filp = NULL;
	}
}
EXPORT_SYMBOL_GPL(fsg_lun_close);

int fsg_lun_open(struct fsg_lun *curlun, const char *filename)
{
	int				ro;
	struct file			*filp = NULL;
	int				rc = -EINVAL;
	struct inode			*inode = NULL;
	loff_t				size;
	loff_t				num_sectors;
	loff_t				min_sectors;
	unsigned int			blkbits;
	unsigned int			blksize;

	/* R/W if we can, R/O if we must */
	ro = curlun->initially_ro;
	if (!ro) {
		filp = filp_open(filename, O_RDWR | O_LARGEFILE, 0);
		if (PTR_ERR(filp) == -EROFS || PTR_ERR(filp) == -EACCES)
			ro = 1;
	}
	if (ro)
		filp = filp_open(filename, O_RDONLY | O_LARGEFILE, 0);
	if (IS_ERR(filp)) {
		LINFO(curlun, "unable to open backing file: %s\n", filename);
		return PTR_ERR(filp);
	}

	if (!(filp->f_mode & FMODE_WRITE))
		ro = 1;

	inode = file_inode(filp);
	if ((!S_ISREG(inode->i_mode) && !S_ISBLK(inode->i_mode))) {
		LINFO(curlun, "invalid file type: %s\n", filename);
		goto out;
	}

	/*
	 * If we can't read the file, it's no good.
	 * If we can't write the file, use it read-only.
	 */
	if (!(filp->f_mode & FMODE_CAN_READ)) {
		LINFO(curlun, "file not readable: %s\n", filename);
		goto out;
	}
	if (!(filp->f_mode & FMODE_CAN_WRITE))
		ro = 1;

	size = i_size_read(inode->i_mapping->host);
	if (size < 0) {
		LINFO(curlun, "unable to find file size: %s\n", filename);
		rc = (int) size;
		goto out;
	}

	if (curlun->cdrom) {
		blksize = 2048;
		blkbits = 11;
	} else if (inode->i_bdev) {
		blksize = bdev_logical_block_size(inode->i_bdev);
		blkbits = blksize_bits(blksize);
	} else {
		blksize = 512;
		blkbits = 9;
	}

	num_sectors = size >> blkbits; /* File size in logic-block-size blocks */
	min_sectors = 1;
	if (curlun->cdrom) {
		min_sectors = 300;	/* Smallest track is 300 frames */
		if (num_sectors >= 256*60*75) {
			num_sectors = 256*60*75 - 1;
			LINFO(curlun, "file too big: %s\n", filename);
			LINFO(curlun, "using only first %d blocks\n",
					(int) num_sectors);
		}
	}
	if (num_sectors < min_sectors) {
		LINFO(curlun, "file too small: %s\n", filename);
		rc = -ETOOSMALL;
		goto out;
	}

	if (fsg_lun_is_open(curlun))
		fsg_lun_close(curlun);

	curlun->blksize = blksize;
	curlun->blkbits = blkbits;
	curlun->ro = ro;
	curlun->filp = filp;
	curlun->file_length = size;
	curlun->num_sectors = num_sectors;
	LDBG(curlun, "open backing file: %s\n", filename);
	return 0;

out:
	fput(filp);
	return rc;
}
EXPORT_SYMBOL_GPL(fsg_lun_open);


/*-------------------------------------------------------------------------*/

/*
 * Sync the file data, don't bother with the metadata.
 * This code was copied from fs/buffer.c:sys_fdatasync().
 */
int fsg_lun_fsync_sub(struct fsg_lun *curlun)
{
	struct file	*filp = curlun->filp;

	if (curlun->ro || !filp)
		return 0;
	return vfs_fsync(filp, 1);
}
EXPORT_SYMBOL_GPL(fsg_lun_fsync_sub);

void store_cdrom_address(u8 *dest, int msf, u32 addr)
{
	if (msf) {
		/* Convert to Minutes-Seconds-Frames */
		addr >>= 2;		/* Convert to 2048-byte frames */
		addr += 2*75;		/* Lead-in occupies 2 seconds */
		dest[3] = addr % 75;	/* Frames */
		addr /= 75;
		dest[2] = addr % 60;	/* Seconds */
		addr /= 60;
		dest[1] = addr;		/* Minutes */
		dest[0] = 0;		/* Reserved */
	} else {
		/* Absolute sector */
		put_unaligned_be32(addr, dest);
	}
}
EXPORT_SYMBOL_GPL(store_cdrom_address);

/*-------------------------------------------------------------------------*/


ssize_t fsg_show_ro(struct fsg_lun *curlun, char *buf)
{
	return sprintf(buf, "%d\n", fsg_lun_is_open(curlun)
				  ? curlun->ro
				  : curlun->initially_ro);
}
EXPORT_SYMBOL_GPL(fsg_show_ro);

ssize_t fsg_show_nofua(struct fsg_lun *curlun, char *buf)
{
	return sprintf(buf, "%u\n", curlun->nofua);
}
EXPORT_SYMBOL_GPL(fsg_show_nofua);

ssize_t fsg_show_file(struct fsg_lun *curlun, struct rw_semaphore *filesem,
		      char *buf)
{
	char		*p;
	ssize_t		rc;

	down_read(filesem);
	if (fsg_lun_is_open(curlun)) {	/* Get the complete pathname */
		p = file_path(curlun->filp, buf, PAGE_SIZE - 1);
		if (IS_ERR(p))
			rc = PTR_ERR(p);
		else {
			rc = strlen(p);
			memmove(buf, p, rc);
			buf[rc] = '\n';		/* Add a newline */
			buf[++rc] = 0;
		}
	} else {				/* No file, return 0 bytes */
		*buf = 0;
		rc = 0;
	}
	up_read(filesem);
	return rc;
}
EXPORT_SYMBOL_GPL(fsg_show_file);

ssize_t fsg_show_cdrom(struct fsg_lun *curlun, char *buf)
{
	return sprintf(buf, "%u\n", curlun->cdrom);
}
EXPORT_SYMBOL_GPL(fsg_show_cdrom);

ssize_t fsg_show_removable(struct fsg_lun *curlun, char *buf)
{
	return sprintf(buf, "%u\n", curlun->removable);
}
EXPORT_SYMBOL_GPL(fsg_show_removable);

/*
 * The caller must hold fsg->filesem for reading when calling this function.
 */
static ssize_t _fsg_store_ro(struct fsg_lun *curlun, bool ro)
{
	if (fsg_lun_is_open(curlun)) {
		LDBG(curlun, "read-only status change prevented\n");
		return -EBUSY;
	}

	curlun->ro = ro;
	curlun->initially_ro = ro;
	LDBG(curlun, "read-only status set to %d\n", curlun->ro);

	return 0;
}

ssize_t fsg_store_ro(struct fsg_lun *curlun, struct rw_semaphore *filesem,
		     const char *buf, size_t count)
{
	ssize_t		rc;
	bool		ro;

	rc = strtobool(buf, &ro);
	if (rc)
		return rc;

	/*
	 * Allow the write-enable status to change only while the
	 * backing file is closed.
	 */
	down_read(filesem);
	rc = _fsg_store_ro(curlun, ro);
	if (!rc)
		rc = count;
	up_read(filesem);

	return rc;
}
EXPORT_SYMBOL_GPL(fsg_store_ro);

ssize_t fsg_store_nofua(struct fsg_lun *curlun, const char *buf, size_t count)
{
	bool		nofua;
	int		ret;

	ret = strtobool(buf, &nofua);
	if (ret)
		return ret;

	/* Sync data when switching from async mode to sync */
	if (!nofua && curlun->nofua)
		fsg_lun_fsync_sub(curlun);

	curlun->nofua = nofua;

	return count;
}
EXPORT_SYMBOL_GPL(fsg_store_nofua);

ssize_t fsg_store_file(struct fsg_lun *curlun, struct rw_semaphore *filesem,
		       const char *buf, size_t count)
{
	int		rc = 0;

	if (curlun->prevent_medium_removal && fsg_lun_is_open(curlun)) {
		LDBG(curlun, "eject attempt prevented\n");
		return -EBUSY;				/* "Door is locked" */
	}

	/* Remove a trailing newline */
	if (count > 0 && buf[count-1] == '\n')
		((char *) buf)[count-1] = 0;		/* Ugh! */

	/* Load new medium */
	down_write(filesem);
	if (count > 0 && buf[0]) {
		/* fsg_lun_open() will close existing file if any. */
		rc = fsg_lun_open(curlun, buf);
		if (rc == 0)
			curlun->unit_attention_data =
					SS_NOT_READY_TO_READY_TRANSITION;
	} else if (fsg_lun_is_open(curlun)) {
		fsg_lun_close(curlun);
		curlun->unit_attention_data = SS_MEDIUM_NOT_PRESENT;
	}
	up_write(filesem);
	return (rc < 0 ? rc : count);
}
EXPORT_SYMBOL_GPL(fsg_store_file);

ssize_t fsg_store_cdrom(struct fsg_lun *curlun, struct rw_semaphore *filesem,
			const char *buf, size_t count)
{
	bool		cdrom;
	int		ret;

	ret = strtobool(buf, &cdrom);
	if (ret)
		return ret;

	down_read(filesem);
	ret = cdrom ? _fsg_store_ro(curlun, true) : 0;

	if (!ret) {
		curlun->cdrom = cdrom;
		ret = count;
	}
	up_read(filesem);

	return ret;
}
EXPORT_SYMBOL_GPL(fsg_store_cdrom);

ssize_t fsg_store_removable(struct fsg_lun *curlun, const char *buf,
			    size_t count)
{
	bool		removable;
	int		ret;

	ret = strtobool(buf, &removable);
	if (ret)
		return ret;

	curlun->removable = removable;

	return count;
}
EXPORT_SYMBOL_GPL(fsg_store_removable);

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