usb: gadget: FunctionFS: fix typos and coding style

/*

 * f_fs.c -- user mode filesystem api for usb composite funtcion controllers

 * f_fs.c -- user mode file system API for USB composite function controllers

 *

 * Copyright (C) 2010 Samsung Electronics

 * Author: Michal Nazarewicz <m.nazarewicz@samsung.com>

 *

 * Based on inode.c (GadgetFS):

 * Based on inode.c (GadgetFS) which was:

 * Copyright (C) 2003-2004 David Brownell

 * Copyright (C) 2003 Agilent Technologies

 *

#define FUNCTIONFS_MAGIC	0xa647361 /* Chosen by a honest dice roll ;) */

/* Debuging *****************************************************************/

/* Debugging ****************************************************************/

#define ffs_printk(level, fmt, args...) printk(level "f_fs: " fmt "\n", ## args)

/* The data structure and setup file ****************************************/

enum ffs_state {

	/* Waiting for descriptors and strings. */

	/* In this state no open(2), read(2) or write(2) on epfiles

	/*

	 * Waiting for descriptors and strings.

	 *

	 * In this state no open(2), read(2) or write(2) on epfiles

	 * may succeed (which should not be the problem as there

	 * should be no such files opened in the firts place). */

	 * should be no such files opened in the first place).

	 */

	FFS_READ_DESCRIPTORS,

	FFS_READ_STRINGS,

	/* We've got descriptors and strings.  We are or have called

	/*

	 * We've got descriptors and strings.  We are or have called

	 * functionfs_ready_callback().  functionfs_bind() may have

	 * been called but we don't know. */

	/* This is the only state in which operations on epfiles may

	 * succeed. */

	 * been called but we don't know.

	 *

	 * This is the only state in which operations on epfiles may

	 * succeed.

	 */

	FFS_ACTIVE,

	/* All endpoints have been closed.  This state is also set if

	/*

	 * All endpoints have been closed.  This state is also set if

	 * we encounter an unrecoverable error.  The only

	 * unrecoverable error is situation when after reading strings

	 * from user space we fail to initialise EP files or

	 * functionfs_ready_callback() returns with error (<0). */

	/* In this state no open(2), read(2) or write(2) (both on ep0

	 * from user space we fail to initialise epfiles or

	 * functionfs_ready_callback() returns with error (<0).

	 *

	 * In this state no open(2), read(2) or write(2) (both on ep0

	 * as well as epfile) may succeed (at this point epfiles are

	 * unlinked and all closed so this is not a problem; ep0 is

	 * also closed but ep0 file exists and so open(2) on ep0 must

	 * fail). */

	 * fail).

	 */

	FFS_CLOSING

};

enum ffs_setup_state {

	/* There is no setup request pending. */

	FFS_NO_SETUP,

	/* User has read events and there was a setup request event

	/*

	 * User has read events and there was a setup request event

	 * there.  The next read/write on ep0 will handle the

	 * request. */

	 * request.

	 */

	FFS_SETUP_PENDING,

	/* There was event pending but before user space handled it

	/*

	 * There was event pending but before user space handled it

	 * some other event was introduced which canceled existing

	 * setup.  If this state is set read/write on ep0 return

	 * -EIDRM.  This state is only set when adding event. */

	 * -EIDRM.  This state is only set when adding event.

	 */

	FFS_SETUP_CANCELED

};

struct ffs_data {

	struct usb_gadget		*gadget;

	/* Protect access read/write operations, only one read/write

	/*

	 * Protect access read/write operations, only one read/write

	 * at a time.  As a consequence protects ep0req and company.

	 * While setup request is being processed (queued) this is

	 * held. */

	 * held.

	 */

	struct mutex			mutex;

	/* Protect access to enpoint related structures (basically

	/*

	 * Protect access to endpoint related structures (basically

	 * usb_ep_queue(), usb_ep_dequeue(), etc. calls) except for

	 * endpint zero. */

	 * endpoint zero.

	 */

	spinlock_t			eps_lock;

	/* XXX REVISIT do we need our own request? Since we are not

	 * handling setup requests immidiatelly user space may be so

	/*

	 * XXX REVISIT do we need our own request? Since we are not

	 * handling setup requests immediately user space may be so

	 * slow that another setup will be sent to the gadget but this

	 * time not to us but another function and then there could be

	 * a race.  Is that the case? Or maybe we can use cdev->req

	 * after all, maybe we just need some spinlock for that? */

	 * after all, maybe we just need some spinlock for that?

	 */

	struct usb_request		*ep0req;		/* P: mutex */

	struct completion		ep0req_completion;	/* P: mutex */

	int				ep0req_status;		/* P: mutex */

	enum ffs_state			state;

	/*

	 * Possible transations:

	 * Possible transitions:

	 * + FFS_NO_SETUP       -> FFS_SETUP_PENDING  -- P: ev.waitq.lock

	 *               happens only in ep0 read which is P: mutex

	 * + FFS_SETUP_PENDING  -> FFS_NO_SETUP       -- P: ev.waitq.lock

	/* Active function */

	struct ffs_function		*func;

	/* Device name, write once when file system is mounted.

	 * Intendet for user to read if she wants. */

	/*

	 * Device name, write once when file system is mounted.

	 * Intended for user to read if she wants.

	 */

	const char			*dev_name;

	/* Private data for our user (ie. gadget).  Managed by

	 * user. */

	/* Private data for our user (ie. gadget).  Managed by user. */

	void				*private_data;

	/* filled by __ffs_data_got_descs() */

	/* real descriptors are 16 bytes after raw_descs (so you need

	/*

	 * Real descriptors are 16 bytes after raw_descs (so you need

	 * to skip 16 bytes (ie. ffs->raw_descs + 16) to get to the

	 * first full speed descriptor).  raw_descs_length and

	 * raw_fs_descs_length do not have those 16 bytes added. */

	 * raw_fs_descs_length do not have those 16 bytes added.

	 */

	const void			*raw_descs;

	unsigned			raw_descs_length;

	unsigned			raw_fs_descs_length;

	const void			*raw_strings;

	struct usb_gadget_strings	**stringtabs;

	/* File system's super block, write once when file system is mounted. */

	/*

	 * File system's super block, write once when file system is

	 * mounted.

	 */

	struct super_block		*sb;

	/* File permissions, written once when fs is mounted */

		gid_t				gid;

	}				file_perms;

	/* The endpoint files, filled by ffs_epfiles_create(),

	 * destroyed by ffs_epfiles_destroy(). */

	/*

	 * The endpoint files, filled by ffs_epfiles_create(),

	 * destroyed by ffs_epfiles_destroy().

	 */

	struct ffs_epfile		*epfiles;

};

static void ffs_data_opened(struct ffs_data *ffs);

static void ffs_data_closed(struct ffs_data *ffs);

/* Called with ffs->mutex held; take over ownerrship of data. */

/* Called with ffs->mutex held; take over ownership of data. */

static int __must_check

__ffs_data_got_descs(struct ffs_data *ffs, char *data, size_t len);

static int __must_check

static void ffs_func_free(struct ffs_function *func);

static void ffs_func_eps_disable(struct ffs_function *func);

static int __must_check ffs_func_eps_enable(struct ffs_function *func);

static int ffs_func_bind(struct usb_configuration *,

			 struct usb_function *);

static void ffs_func_unbind(struct usb_configuration *,

static int ffs_func_revmap_intf(struct ffs_function *func, u8 intf);

/* The endpoints structures *************************************************/

struct ffs_ep {

	unsigned char			_pad;

};

static int  __must_check ffs_epfiles_create(struct ffs_data *ffs);

static void ffs_epfiles_destroy(struct ffs_epfile *epfiles, unsigned count);

	complete_all(&ffs->ep0req_completion);

}

static int __ffs_ep0_queue_wait(struct ffs_data *ffs, char *data, size_t len)

{

	struct usb_request *req = ffs->ep0req;

	}

}

static ssize_t ffs_ep0_write(struct file *file, const char __user *buf,

			     size_t len, loff_t *ptr)

{

	if (unlikely(ret < 0))

		return ret;

	/* Check state */

	switch (ffs->state) {

	case FFS_READ_DESCRIPTORS:

		}

		break;

	case FFS_ACTIVE:

		data = NULL;

		/* We're called from user space, we can use _irq

		 * rather then _irqsave */

		/*

		 * We're called from user space, we can use _irq

		 * rather then _irqsave

		 */

		spin_lock_irq(&ffs->ev.waitq.lock);

		switch (FFS_SETUP_STATE(ffs)) {

		case FFS_SETUP_CANCELED:

		spin_lock_irq(&ffs->ev.waitq.lock);

		/* We are guaranteed to be still in FFS_ACTIVE state

		/*

		 * We are guaranteed to be still in FFS_ACTIVE state

		 * but the state of setup could have changed from

		 * FFS_SETUP_PENDING to FFS_SETUP_CANCELED so we need

		 * to check for that.  If that happened we copied data

		 * from user space in vain but it's unlikely. */

		/* For sure we are not in FFS_NO_SETUP since this is

		 * from user space in vain but it's unlikely.

		 *

		 * For sure we are not in FFS_NO_SETUP since this is

		 * the only place FFS_SETUP_PENDING -> FFS_NO_SETUP

		 * transition can be performed and it's protected by

		 * mutex. */

		 * mutex.

		 */

		if (FFS_SETUP_STATE(ffs) == FFS_SETUP_CANCELED) {

			ret = -EIDRM;

done_spin:

		kfree(data);

		break;

	default:

		ret = -EBADFD;

		break;

	}

	mutex_unlock(&ffs->mutex);

	return ret;

}

static ssize_t __ffs_ep0_read_events(struct ffs_data *ffs, char __user *buf,

				     size_t n)

{

	/* We are holding ffs->ev.waitq.lock and ffs->mutex and we need

	 * to release them. */

	/*

	 * We are holding ffs->ev.waitq.lock and ffs->mutex and we need

	 * to release them.

	 */

	struct usb_functionfs_event events[n];

	unsigned i = 0;

		? -EFAULT : sizeof events;

}

static ssize_t ffs_ep0_read(struct file *file, char __user *buf,

			    size_t len, loff_t *ptr)

{

	if (unlikely(ret < 0))

		return ret;

	/* Check state */

	if (ffs->state != FFS_ACTIVE) {

		ret = -EBADFD;

		goto done_mutex;

	}

	/* We're called from user space, we can use _irq rather then

	 * _irqsave */

	/*

	 * We're called from user space, we can use _irq rather then

	 * _irqsave

	 */

	spin_lock_irq(&ffs->ev.waitq.lock);

	switch (FFS_SETUP_STATE(ffs)) {

			break;

		}

		if (unlikely(wait_event_interruptible_exclusive_locked_irq(ffs->ev.waitq, ffs->ev.count))) {

		if (wait_event_interruptible_exclusive_locked_irq(ffs->ev.waitq,

							ffs->ev.count)) {

			ret = -EINTR;

			break;

		}

		return __ffs_ep0_read_events(ffs, buf,

					     min(n, (size_t)ffs->ev.count));

	case FFS_SETUP_PENDING:

		if (ffs->ev.setup.bRequestType & USB_DIR_IN) {

			spin_unlock_irq(&ffs->ev.waitq.lock);

	return ret;

}

static int ffs_ep0_open(struct inode *inode, struct file *file)

{

	struct ffs_data *ffs = inode->i_private;

	return 0;

}

static int ffs_ep0_release(struct inode *inode, struct file *file)

{

	struct ffs_data *ffs = file->private_data;

	return 0;

}

static long ffs_ep0_ioctl(struct file *file, unsigned code, unsigned long value)

{

	struct ffs_data *ffs = file->private_data;

	return ret;

}

static const struct file_operations ffs_ep0_operations = {

	.owner =	THIS_MODULE,

	.llseek =	no_llseek,

/* "Normal" endpoints operations ********************************************/

static void ffs_epfile_io_complete(struct usb_ep *_ep, struct usb_request *req)

{

	ENTER();

	}

}

static ssize_t ffs_epfile_io(struct file *file,

			     char __user *buf, size_t len, int read)

{

				goto error;

			}

			if (unlikely(wait_event_interruptible

				     (epfile->wait, (ep = epfile->ep)))) {

			if (wait_event_interruptible(epfile->wait,

						     (ep = epfile->ep))) {

				ret = -EINTR;

				goto error;

			}

		if (unlikely(ret))

			goto error;

		/* We're called from user space, we can use _irq rather then

		 * _irqsave */

		/*

		 * We're called from user space, we can use _irq rather then

		 * _irqsave

		 */

		spin_lock_irq(&epfile->ffs->eps_lock);

		/* While we were acquiring mutex endpoint got disabled

		 * or changed? */

		/*

		 * While we were acquiring mutex endpoint got disabled

		 * or changed?

		 */

	} while (unlikely(epfile->ep != ep));

	/* Halt */

	return ret;

}

static ssize_t

ffs_epfile_write(struct file *file, const char __user *buf, size_t len,

		 loff_t *ptr)

	return 0;

}

static long ffs_epfile_ioctl(struct file *file, unsigned code,

			     unsigned long value)

{

	return ret;

}

static const struct file_operations ffs_epfile_operations = {

	.owner =	THIS_MODULE,

	.llseek =	no_llseek,

};

/* File system and super block operations ***********************************/

/*

 * function configuration then later for event monitoring.

 */

static struct inode *__must_check

ffs_sb_make_inode(struct super_block *sb, void *data,

		  const struct file_operations *fops,

	return inode;

}

/* Create "regular" file */

static struct inode *ffs_sb_create_file(struct super_block *sb,

					const char *name, void *data,

					const struct file_operations *fops,

	return inode;

}

/* Super block */

static const struct super_operations ffs_sb_operations = {

	.statfs =	simple_statfs,

	.drop_inode =	generic_delete_inode,

	ENTER();

	/* Initialize data */

	/* Initialise data */

	ffs = ffs_data_new();

	if (unlikely(!ffs))

		goto enomem0;

	return -ENOMEM;

}

static int ffs_fs_parse_opts(struct ffs_sb_fill_data *data, char *opts)

{

	ENTER();

	return 0;

}

/* "mount -t functionfs dev_name /dev/function" ends up here */

static struct dentry *

};

/* Driver's main init/cleanup functions *************************************/

static int functionfs_init(void)

{

	int ret;

}

/* ffs_data and ffs_function construction and destruction code **************/

static void ffs_data_clear(struct ffs_data *ffs);

static void ffs_data_reset(struct ffs_data *ffs);

static void ffs_data_get(struct ffs_data *ffs)

{

	ENTER();

	}

}

static void ffs_data_closed(struct ffs_data *ffs)

{

	ENTER();

	ffs_data_put(ffs);

}

static struct ffs_data *ffs_data_new(void)

{

	struct ffs_data *ffs = kzalloc(sizeof *ffs, GFP_KERNEL);

	return ffs;

}

static void ffs_data_clear(struct ffs_data *ffs)

{

	ENTER();

	kfree(ffs->stringtabs);

}

static void ffs_data_reset(struct ffs_data *ffs)

{

	ENTER();

	return 0;

}

static void functionfs_unbind(struct ffs_data *ffs)

{

	ENTER();

	}

}

static int ffs_epfiles_create(struct ffs_data *ffs)

{

	struct ffs_epfile *epfile, *epfiles;

	return 0;

}

static void ffs_epfiles_destroy(struct ffs_epfile *epfiles, unsigned count)

{

	struct ffs_epfile *epfile = epfiles;

	kfree(epfiles);

}

static int functionfs_bind_config(struct usb_composite_dev *cdev,

				  struct usb_configuration *c,

				  struct ffs_data *ffs)

	func->function.bind    = ffs_func_bind;

	func->function.unbind  = ffs_func_unbind;

	func->function.set_alt = ffs_func_set_alt;

	/*func->function.get_alt = ffs_func_get_alt;*/

	func->function.disable = ffs_func_disable;

	func->function.setup   = ffs_func_setup;

	func->function.suspend = ffs_func_suspend;

	ffs_data_put(func->ffs);

	kfree(func->eps);

	/* eps and interfaces_nums are allocated in the same chunk so

	/*

	 * eps and interfaces_nums are allocated in the same chunk so

	 * only one free is required.  Descriptors are also allocated

	 * in the same chunk. */

	 * in the same chunk.

	 */

	kfree(func);

}

static void ffs_func_eps_disable(struct ffs_function *func)

{

	struct ffs_ep *ep         = func->eps;

/* Parsing and building descriptors and strings *****************************/

/* This validates if data pointed by data is a valid USB descriptor as

/*

 * This validates if data pointed by data is a valid USB descriptor as

 * well as record how many interfaces, endpoints and strings are

 * required by given configuration.  Returns address afther the

 * descriptor or NULL if data is invalid. */

 * required by given configuration.  Returns address after the

 * descriptor or NULL if data is invalid.

 */

enum ffs_entity_type {

	FFS_DESCRIPTOR, FFS_INTERFACE, FFS_STRING, FFS_ENDPOINT

	case USB_DT_STRING:

	case USB_DT_DEVICE_QUALIFIER:

		/* function can't have any of those */

		FVDBG("descriptor reserved for gadget: %d", _ds->bDescriptorType);

		FVDBG("descriptor reserved for gadget: %d",

		      _ds->bDescriptorType);

		return -EINVAL;

	case USB_DT_INTERFACE: {

	return length;

}

static int __must_check ffs_do_descs(unsigned count, char *data, unsigned len,

				     ffs_entity_callback entity, void *priv)

{

		if (num == count)

			data = NULL;

		/* Record "descriptor" entitny */

		/* Record "descriptor" entity */

		ret = entity(FFS_DESCRIPTOR, (u8 *)num, (void *)data, priv);

		if (unlikely(ret < 0)) {

			FDBG("entity DESCRIPTOR(%02lx); ret = %d", num, ret);

	}

}

static int __ffs_data_do_entity(enum ffs_entity_type type,

				u8 *valuep, struct usb_descriptor_header *desc,

				void *priv)

		break;

	case FFS_INTERFACE:

		/* Interfaces are indexed from zero so if we

		/*

		 * Interfaces are indexed from zero so if we

		 * encountered interface "n" then there are at least

		 * "n+1" interfaces. */

		 * "n+1" interfaces.

		 */

		if (*valuep >= ffs->interfaces_count)

			ffs->interfaces_count = *valuep + 1;

		break;

	case FFS_STRING:

		/* Strings are indexed from 1 (0 is magic ;) reserved

		 * for languages list or some such) */

		/*

		 * Strings are indexed from 1 (0 is magic ;) reserved

		 * for languages list or some such)

		 */

		if (*valuep > ffs->strings_count)

			ffs->strings_count = *valuep;

		break;

	return 0;

}

static int __ffs_data_got_descs(struct ffs_data *ffs,

				char *const _data, size_t len)

{

	return ret;