1/*
   2 * f_fs.c -- user mode file system API for USB composite function controllers
   3 *
   4 * Copyright (C) 2010 Samsung Electronics
   5 * Author: Michal Nazarewicz <mina86@mina86.com>
   6 *
   7 * Based on inode.c (GadgetFS) which was:
   8 * Copyright (C) 2003-2004 David Brownell
   9 * Copyright (C) 2003 Agilent Technologies
  10 *
  11 * This program is free software; you can redistribute it and/or modify
  12 * it under the terms of the GNU General Public License as published by
  13 * the Free Software Foundation; either version 2 of the License, or
  14 * (at your option) any later version.
  15 */
  16
  17
  18/* #define DEBUG */
  19/* #define VERBOSE_DEBUG */
  20
  21#include <linux/blkdev.h>
  22#include <linux/pagemap.h>
  23#include <linux/export.h>
 
  24#include <linux/hid.h>
 
  25#include <linux/module.h>
 
 
  26#include <linux/uio.h>
 
  27#include <asm/unaligned.h>
  28
 
  29#include <linux/usb/composite.h>
  30#include <linux/usb/functionfs.h>
  31
  32#include <linux/aio.h>
  33#include <linux/mmu_context.h>
  34#include <linux/poll.h>
  35#include <linux/eventfd.h>
  36
  37#include "u_fs.h"
  38#include "u_f.h"
  39#include "u_os_desc.h"
  40#include "configfs.h"
  41
  42#define FUNCTIONFS_MAGIC	0xa647361 /* Chosen by a honest dice roll ;) */
  43
  44/* Reference counter handling */
  45static void ffs_data_get(struct ffs_data *ffs);
  46static void ffs_data_put(struct ffs_data *ffs);
  47/* Creates new ffs_data object. */
  48static struct ffs_data *__must_check ffs_data_new(void) __attribute__((malloc));
 
  49
  50/* Opened counter handling. */
  51static void ffs_data_opened(struct ffs_data *ffs);
  52static void ffs_data_closed(struct ffs_data *ffs);
  53
  54/* Called with ffs->mutex held; take over ownership of data. */
  55static int __must_check
  56__ffs_data_got_descs(struct ffs_data *ffs, char *data, size_t len);
  57static int __must_check
  58__ffs_data_got_strings(struct ffs_data *ffs, char *data, size_t len);
  59
  60
  61/* The function structure ***************************************************/
  62
  63struct ffs_ep;
  64
  65struct ffs_function {
  66	struct usb_configuration	*conf;
  67	struct usb_gadget		*gadget;
  68	struct ffs_data			*ffs;
  69
  70	struct ffs_ep			*eps;
  71	u8				eps_revmap[16];
  72	short				*interfaces_nums;
  73
  74	struct usb_function		function;
  75};
  76
  77
  78static struct ffs_function *ffs_func_from_usb(struct usb_function *f)
  79{
  80	return container_of(f, struct ffs_function, function);
  81}
  82
  83
  84static inline enum ffs_setup_state
  85ffs_setup_state_clear_cancelled(struct ffs_data *ffs)
  86{
  87	return (enum ffs_setup_state)
  88		cmpxchg(&ffs->setup_state, FFS_SETUP_CANCELLED, FFS_NO_SETUP);
  89}
  90
  91
  92static void ffs_func_eps_disable(struct ffs_function *func);
  93static int __must_check ffs_func_eps_enable(struct ffs_function *func);
  94
  95static int ffs_func_bind(struct usb_configuration *,
  96			 struct usb_function *);
  97static int ffs_func_set_alt(struct usb_function *, unsigned, unsigned);
  98static void ffs_func_disable(struct usb_function *);
  99static int ffs_func_setup(struct usb_function *,
 100			  const struct usb_ctrlrequest *);
 
 
 
 101static void ffs_func_suspend(struct usb_function *);
 102static void ffs_func_resume(struct usb_function *);
 103
 104
 105static int ffs_func_revmap_ep(struct ffs_function *func, u8 num);
 106static int ffs_func_revmap_intf(struct ffs_function *func, u8 intf);
 107
 108
 109/* The endpoints structures *************************************************/
 110
 111struct ffs_ep {
 112	struct usb_ep			*ep;	/* P: ffs->eps_lock */
 113	struct usb_request		*req;	/* P: epfile->mutex */
 114
 115	/* [0]: full speed, [1]: high speed, [2]: super speed */
 116	struct usb_endpoint_descriptor	*descs[3];
 117
 118	u8				num;
 119
 120	int				status;	/* P: epfile->mutex */
 121};
 122
 123struct ffs_epfile {
 124	/* Protects ep->ep and ep->req. */
 125	struct mutex			mutex;
 126	wait_queue_head_t		wait;
 127
 128	struct ffs_data			*ffs;
 129	struct ffs_ep			*ep;	/* P: ffs->eps_lock */
 130
 131	struct dentry			*dentry;
 132
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 133	char				name[5];
 134
 135	unsigned char			in;	/* P: ffs->eps_lock */
 136	unsigned char			isoc;	/* P: ffs->eps_lock */
 137
 138	unsigned char			_pad;
 139};
 140
 
 
 
 
 
 
 141/*  ffs_io_data structure ***************************************************/
 142
 143struct ffs_io_data {
 144	bool aio;
 145	bool read;
 146
 147	struct kiocb *kiocb;
 148	struct iov_iter data;
 149	const void *to_free;
 150	char *buf;
 151
 152	struct mm_struct *mm;
 153	struct work_struct work;
 154
 155	struct usb_ep *ep;
 156	struct usb_request *req;
 
 
 157
 158	struct ffs_data *ffs;
 159};
 160
 161struct ffs_desc_helper {
 162	struct ffs_data *ffs;
 163	unsigned interfaces_count;
 164	unsigned eps_count;
 165};
 166
 167static int  __must_check ffs_epfiles_create(struct ffs_data *ffs);
 168static void ffs_epfiles_destroy(struct ffs_epfile *epfiles, unsigned count);
 169
 170static struct dentry *
 171ffs_sb_create_file(struct super_block *sb, const char *name, void *data,
 172		   const struct file_operations *fops);
 173
 174/* Devices management *******************************************************/
 175
 176DEFINE_MUTEX(ffs_lock);
 177EXPORT_SYMBOL_GPL(ffs_lock);
 178
 179static struct ffs_dev *_ffs_find_dev(const char *name);
 180static struct ffs_dev *_ffs_alloc_dev(void);
 181static int _ffs_name_dev(struct ffs_dev *dev, const char *name);
 182static void _ffs_free_dev(struct ffs_dev *dev);
 183static void *ffs_acquire_dev(const char *dev_name);
 184static void ffs_release_dev(struct ffs_data *ffs_data);
 185static int ffs_ready(struct ffs_data *ffs);
 186static void ffs_closed(struct ffs_data *ffs);
 187
 188/* Misc helper functions ****************************************************/
 189
 190static int ffs_mutex_lock(struct mutex *mutex, unsigned nonblock)
 191	__attribute__((warn_unused_result, nonnull));
 192static char *ffs_prepare_buffer(const char __user *buf, size_t len)
 193	__attribute__((warn_unused_result, nonnull));
 194
 195
 196/* Control file aka ep0 *****************************************************/
 197
 198static void ffs_ep0_complete(struct usb_ep *ep, struct usb_request *req)
 199{
 200	struct ffs_data *ffs = req->context;
 201
 202	complete_all(&ffs->ep0req_completion);
 203}
 204
 205static int __ffs_ep0_queue_wait(struct ffs_data *ffs, char *data, size_t len)
 
 206{
 207	struct usb_request *req = ffs->ep0req;
 208	int ret;
 209
 210	req->zero     = len < le16_to_cpu(ffs->ev.setup.wLength);
 211
 212	spin_unlock_irq(&ffs->ev.waitq.lock);
 213
 214	req->buf      = data;
 215	req->length   = len;
 216
 217	/*
 218	 * UDC layer requires to provide a buffer even for ZLP, but should
 219	 * not use it at all. Let's provide some poisoned pointer to catch
 220	 * possible bug in the driver.
 221	 */
 222	if (req->buf == NULL)
 223		req->buf = (void *)0xDEADBABE;
 224
 225	reinit_completion(&ffs->ep0req_completion);
 226
 227	ret = usb_ep_queue(ffs->gadget->ep0, req, GFP_ATOMIC);
 228	if (unlikely(ret < 0))
 229		return ret;
 230
 231	ret = wait_for_completion_interruptible(&ffs->ep0req_completion);
 232	if (unlikely(ret)) {
 233		usb_ep_dequeue(ffs->gadget->ep0, req);
 234		return -EINTR;
 235	}
 236
 237	ffs->setup_state = FFS_NO_SETUP;
 238	return req->status ? req->status : req->actual;
 239}
 240
 241static int __ffs_ep0_stall(struct ffs_data *ffs)
 242{
 243	if (ffs->ev.can_stall) {
 244		pr_vdebug("ep0 stall\n");
 245		usb_ep_set_halt(ffs->gadget->ep0);
 246		ffs->setup_state = FFS_NO_SETUP;
 247		return -EL2HLT;
 248	} else {
 249		pr_debug("bogus ep0 stall!\n");
 250		return -ESRCH;
 251	}
 252}
 253
 254static ssize_t ffs_ep0_write(struct file *file, const char __user *buf,
 255			     size_t len, loff_t *ptr)
 256{
 257	struct ffs_data *ffs = file->private_data;
 258	ssize_t ret;
 259	char *data;
 260
 261	ENTER();
 262
 263	/* Fast check if setup was canceled */
 264	if (ffs_setup_state_clear_cancelled(ffs) == FFS_SETUP_CANCELLED)
 265		return -EIDRM;
 266
 267	/* Acquire mutex */
 268	ret = ffs_mutex_lock(&ffs->mutex, file->f_flags & O_NONBLOCK);
 269	if (unlikely(ret < 0))
 270		return ret;
 271
 272	/* Check state */
 273	switch (ffs->state) {
 274	case FFS_READ_DESCRIPTORS:
 275	case FFS_READ_STRINGS:
 276		/* Copy data */
 277		if (unlikely(len < 16)) {
 278			ret = -EINVAL;
 279			break;
 280		}
 281
 282		data = ffs_prepare_buffer(buf, len);
 283		if (IS_ERR(data)) {
 284			ret = PTR_ERR(data);
 285			break;
 286		}
 287
 288		/* Handle data */
 289		if (ffs->state == FFS_READ_DESCRIPTORS) {
 290			pr_info("read descriptors\n");
 291			ret = __ffs_data_got_descs(ffs, data, len);
 292			if (unlikely(ret < 0))
 293				break;
 294
 295			ffs->state = FFS_READ_STRINGS;
 296			ret = len;
 297		} else {
 298			pr_info("read strings\n");
 299			ret = __ffs_data_got_strings(ffs, data, len);
 300			if (unlikely(ret < 0))
 301				break;
 302
 303			ret = ffs_epfiles_create(ffs);
 304			if (unlikely(ret)) {
 305				ffs->state = FFS_CLOSING;
 306				break;
 307			}
 308
 309			ffs->state = FFS_ACTIVE;
 310			mutex_unlock(&ffs->mutex);
 311
 312			ret = ffs_ready(ffs);
 313			if (unlikely(ret < 0)) {
 314				ffs->state = FFS_CLOSING;
 315				return ret;
 316			}
 317
 318			return len;
 319		}
 320		break;
 321
 322	case FFS_ACTIVE:
 323		data = NULL;
 324		/*
 325		 * We're called from user space, we can use _irq
 326		 * rather then _irqsave
 327		 */
 328		spin_lock_irq(&ffs->ev.waitq.lock);
 329		switch (ffs_setup_state_clear_cancelled(ffs)) {
 330		case FFS_SETUP_CANCELLED:
 331			ret = -EIDRM;
 332			goto done_spin;
 333
 334		case FFS_NO_SETUP:
 335			ret = -ESRCH;
 336			goto done_spin;
 337
 338		case FFS_SETUP_PENDING:
 339			break;
 340		}
 341
 342		/* FFS_SETUP_PENDING */
 343		if (!(ffs->ev.setup.bRequestType & USB_DIR_IN)) {
 344			spin_unlock_irq(&ffs->ev.waitq.lock);
 345			ret = __ffs_ep0_stall(ffs);
 346			break;
 347		}
 348
 349		/* FFS_SETUP_PENDING and not stall */
 350		len = min(len, (size_t)le16_to_cpu(ffs->ev.setup.wLength));
 351
 352		spin_unlock_irq(&ffs->ev.waitq.lock);
 353
 354		data = ffs_prepare_buffer(buf, len);
 355		if (IS_ERR(data)) {
 356			ret = PTR_ERR(data);
 357			break;
 358		}
 359
 360		spin_lock_irq(&ffs->ev.waitq.lock);
 361
 362		/*
 363		 * We are guaranteed to be still in FFS_ACTIVE state
 364		 * but the state of setup could have changed from
 365		 * FFS_SETUP_PENDING to FFS_SETUP_CANCELLED so we need
 366		 * to check for that.  If that happened we copied data
 367		 * from user space in vain but it's unlikely.
 368		 *
 369		 * For sure we are not in FFS_NO_SETUP since this is
 370		 * the only place FFS_SETUP_PENDING -> FFS_NO_SETUP
 371		 * transition can be performed and it's protected by
 372		 * mutex.
 373		 */
 374		if (ffs_setup_state_clear_cancelled(ffs) ==
 375		    FFS_SETUP_CANCELLED) {
 376			ret = -EIDRM;
 377done_spin:
 378			spin_unlock_irq(&ffs->ev.waitq.lock);
 379		} else {
 380			/* unlocks spinlock */
 381			ret = __ffs_ep0_queue_wait(ffs, data, len);
 382		}
 383		kfree(data);
 384		break;
 385
 386	default:
 387		ret = -EBADFD;
 388		break;
 389	}
 390
 391	mutex_unlock(&ffs->mutex);
 392	return ret;
 393}
 394
 395/* Called with ffs->ev.waitq.lock and ffs->mutex held, both released on exit. */
 396static ssize_t __ffs_ep0_read_events(struct ffs_data *ffs, char __user *buf,
 397				     size_t n)
 
 398{
 399	/*
 400	 * n cannot be bigger than ffs->ev.count, which cannot be bigger than
 401	 * size of ffs->ev.types array (which is four) so that's how much space
 402	 * we reserve.
 403	 */
 404	struct usb_functionfs_event events[ARRAY_SIZE(ffs->ev.types)];
 405	const size_t size = n * sizeof *events;
 406	unsigned i = 0;
 407
 408	memset(events, 0, size);
 409
 410	do {
 411		events[i].type = ffs->ev.types[i];
 412		if (events[i].type == FUNCTIONFS_SETUP) {
 413			events[i].u.setup = ffs->ev.setup;
 414			ffs->setup_state = FFS_SETUP_PENDING;
 415		}
 416	} while (++i < n);
 417
 418	ffs->ev.count -= n;
 419	if (ffs->ev.count)
 420		memmove(ffs->ev.types, ffs->ev.types + n,
 421			ffs->ev.count * sizeof *ffs->ev.types);
 422
 423	spin_unlock_irq(&ffs->ev.waitq.lock);
 424	mutex_unlock(&ffs->mutex);
 425
 426	return unlikely(copy_to_user(buf, events, size)) ? -EFAULT : size;
 427}
 428
 429static ssize_t ffs_ep0_read(struct file *file, char __user *buf,
 430			    size_t len, loff_t *ptr)
 431{
 432	struct ffs_data *ffs = file->private_data;
 433	char *data = NULL;
 434	size_t n;
 435	int ret;
 436
 437	ENTER();
 438
 439	/* Fast check if setup was canceled */
 440	if (ffs_setup_state_clear_cancelled(ffs) == FFS_SETUP_CANCELLED)
 441		return -EIDRM;
 442
 443	/* Acquire mutex */
 444	ret = ffs_mutex_lock(&ffs->mutex, file->f_flags & O_NONBLOCK);
 445	if (unlikely(ret < 0))
 446		return ret;
 447
 448	/* Check state */
 449	if (ffs->state != FFS_ACTIVE) {
 450		ret = -EBADFD;
 451		goto done_mutex;
 452	}
 453
 454	/*
 455	 * We're called from user space, we can use _irq rather then
 456	 * _irqsave
 457	 */
 458	spin_lock_irq(&ffs->ev.waitq.lock);
 459
 460	switch (ffs_setup_state_clear_cancelled(ffs)) {
 461	case FFS_SETUP_CANCELLED:
 462		ret = -EIDRM;
 463		break;
 464
 465	case FFS_NO_SETUP:
 466		n = len / sizeof(struct usb_functionfs_event);
 467		if (unlikely(!n)) {
 468			ret = -EINVAL;
 469			break;
 470		}
 471
 472		if ((file->f_flags & O_NONBLOCK) && !ffs->ev.count) {
 473			ret = -EAGAIN;
 474			break;
 475		}
 476
 477		if (wait_event_interruptible_exclusive_locked_irq(ffs->ev.waitq,
 478							ffs->ev.count)) {
 479			ret = -EINTR;
 480			break;
 481		}
 482
 
 483		return __ffs_ep0_read_events(ffs, buf,
 484					     min(n, (size_t)ffs->ev.count));
 485
 486	case FFS_SETUP_PENDING:
 487		if (ffs->ev.setup.bRequestType & USB_DIR_IN) {
 488			spin_unlock_irq(&ffs->ev.waitq.lock);
 489			ret = __ffs_ep0_stall(ffs);
 490			goto done_mutex;
 491		}
 492
 493		len = min(len, (size_t)le16_to_cpu(ffs->ev.setup.wLength));
 494
 495		spin_unlock_irq(&ffs->ev.waitq.lock);
 496
 497		if (likely(len)) {
 498			data = kmalloc(len, GFP_KERNEL);
 499			if (unlikely(!data)) {
 500				ret = -ENOMEM;
 501				goto done_mutex;
 502			}
 503		}
 504
 505		spin_lock_irq(&ffs->ev.waitq.lock);
 506
 507		/* See ffs_ep0_write() */
 508		if (ffs_setup_state_clear_cancelled(ffs) ==
 509		    FFS_SETUP_CANCELLED) {
 510			ret = -EIDRM;
 511			break;
 512		}
 513
 514		/* unlocks spinlock */
 515		ret = __ffs_ep0_queue_wait(ffs, data, len);
 516		if (likely(ret > 0) && unlikely(copy_to_user(buf, data, len)))
 517			ret = -EFAULT;
 518		goto done_mutex;
 519
 520	default:
 521		ret = -EBADFD;
 522		break;
 523	}
 524
 525	spin_unlock_irq(&ffs->ev.waitq.lock);
 526done_mutex:
 527	mutex_unlock(&ffs->mutex);
 528	kfree(data);
 529	return ret;
 530}
 531
 532static int ffs_ep0_open(struct inode *inode, struct file *file)
 533{
 534	struct ffs_data *ffs = inode->i_private;
 535
 536	ENTER();
 537
 538	if (unlikely(ffs->state == FFS_CLOSING))
 539		return -EBUSY;
 540
 541	file->private_data = ffs;
 542	ffs_data_opened(ffs);
 543
 544	return 0;
 545}
 546
 547static int ffs_ep0_release(struct inode *inode, struct file *file)
 548{
 549	struct ffs_data *ffs = file->private_data;
 550
 551	ENTER();
 552
 553	ffs_data_closed(ffs);
 554
 555	return 0;
 556}
 557
 558static long ffs_ep0_ioctl(struct file *file, unsigned code, unsigned long value)
 559{
 560	struct ffs_data *ffs = file->private_data;
 561	struct usb_gadget *gadget = ffs->gadget;
 562	long ret;
 563
 564	ENTER();
 565
 566	if (code == FUNCTIONFS_INTERFACE_REVMAP) {
 567		struct ffs_function *func = ffs->func;
 568		ret = func ? ffs_func_revmap_intf(func, value) : -ENODEV;
 569	} else if (gadget && gadget->ops->ioctl) {
 570		ret = gadget->ops->ioctl(gadget, code, value);
 571	} else {
 572		ret = -ENOTTY;
 573	}
 574
 575	return ret;
 576}
 577
 578static unsigned int ffs_ep0_poll(struct file *file, poll_table *wait)
 579{
 580	struct ffs_data *ffs = file->private_data;
 581	unsigned int mask = POLLWRNORM;
 582	int ret;
 583
 584	poll_wait(file, &ffs->ev.waitq, wait);
 585
 586	ret = ffs_mutex_lock(&ffs->mutex, file->f_flags & O_NONBLOCK);
 587	if (unlikely(ret < 0))
 588		return mask;
 589
 590	switch (ffs->state) {
 591	case FFS_READ_DESCRIPTORS:
 592	case FFS_READ_STRINGS:
 593		mask |= POLLOUT;
 594		break;
 595
 596	case FFS_ACTIVE:
 597		switch (ffs->setup_state) {
 598		case FFS_NO_SETUP:
 599			if (ffs->ev.count)
 600				mask |= POLLIN;
 601			break;
 602
 603		case FFS_SETUP_PENDING:
 604		case FFS_SETUP_CANCELLED:
 605			mask |= (POLLIN | POLLOUT);
 606			break;
 607		}
 608	case FFS_CLOSING:
 609		break;
 610	case FFS_DEACTIVATED:
 611		break;
 612	}
 613
 614	mutex_unlock(&ffs->mutex);
 615
 616	return mask;
 617}
 618
 619static const struct file_operations ffs_ep0_operations = {
 620	.llseek =	no_llseek,
 621
 622	.open =		ffs_ep0_open,
 623	.write =	ffs_ep0_write,
 624	.read =		ffs_ep0_read,
 625	.release =	ffs_ep0_release,
 626	.unlocked_ioctl =	ffs_ep0_ioctl,
 627	.poll =		ffs_ep0_poll,
 628};
 629
 630
 631/* "Normal" endpoints operations ********************************************/
 632
 633static void ffs_epfile_io_complete(struct usb_ep *_ep, struct usb_request *req)
 634{
 635	ENTER();
 636	if (likely(req->context)) {
 637		struct ffs_ep *ep = _ep->driver_data;
 638		ep->status = req->status ? req->status : req->actual;
 639		complete(req->context);
 640	}
 641}
 642
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 643static void ffs_user_copy_worker(struct work_struct *work)
 644{
 645	struct ffs_io_data *io_data = container_of(work, struct ffs_io_data,
 646						   work);
 647	int ret = io_data->req->status ? io_data->req->status :
 648					 io_data->req->actual;
 649	bool kiocb_has_eventfd = io_data->kiocb->ki_flags & IOCB_EVENTFD;
 650
 651	if (io_data->read && ret > 0) {
 
 
 
 652		use_mm(io_data->mm);
 653		ret = copy_to_iter(io_data->buf, ret, &io_data->data);
 654		if (iov_iter_count(&io_data->data))
 655			ret = -EFAULT;
 656		unuse_mm(io_data->mm);
 
 657	}
 658
 659	io_data->kiocb->ki_complete(io_data->kiocb, ret, ret);
 660
 661	if (io_data->ffs->ffs_eventfd && !kiocb_has_eventfd)
 662		eventfd_signal(io_data->ffs->ffs_eventfd, 1);
 663
 664	usb_ep_free_request(io_data->ep, io_data->req);
 665
 666	if (io_data->read)
 667		kfree(io_data->to_free);
 668	kfree(io_data->buf);
 669	kfree(io_data);
 670}
 671
 672static void ffs_epfile_async_io_complete(struct usb_ep *_ep,
 673					 struct usb_request *req)
 674{
 675	struct ffs_io_data *io_data = req->context;
 
 676
 677	ENTER();
 678
 679	INIT_WORK(&io_data->work, ffs_user_copy_worker);
 680	schedule_work(&io_data->work);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 681}
 682
 683static ssize_t ffs_epfile_io(struct file *file, struct ffs_io_data *io_data)
 684{
 685	struct ffs_epfile *epfile = file->private_data;
 686	struct usb_request *req;
 687	struct ffs_ep *ep;
 688	char *data = NULL;
 689	ssize_t ret, data_len = -EINVAL;
 690	int halt;
 691
 692	/* Are we still active? */
 693	if (WARN_ON(epfile->ffs->state != FFS_ACTIVE))
 694		return -ENODEV;
 695
 696	/* Wait for endpoint to be enabled */
 697	ep = epfile->ep;
 698	if (!ep) {
 699		if (file->f_flags & O_NONBLOCK)
 700			return -EAGAIN;
 701
 702		ret = wait_event_interruptible(epfile->wait, (ep = epfile->ep));
 
 703		if (ret)
 704			return -EINTR;
 705	}
 706
 707	/* Do we halt? */
 708	halt = (!io_data->read == !epfile->in);
 709	if (halt && epfile->isoc)
 710		return -EINVAL;
 711
 
 
 
 
 
 712	/* Allocate & copy */
 713	if (!halt) {
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 714		/*
 715		 * if we _do_ wait above, the epfile->ffs->gadget might be NULL
 716		 * before the waiting completes, so do not assign to 'gadget'
 717		 * earlier
 718		 */
 719		struct usb_gadget *gadget = epfile->ffs->gadget;
 720		size_t copied;
 721
 722		spin_lock_irq(&epfile->ffs->eps_lock);
 723		/* In the meantime, endpoint got disabled or changed. */
 724		if (epfile->ep != ep) {
 725			spin_unlock_irq(&epfile->ffs->eps_lock);
 726			return -ESHUTDOWN;
 727		}
 728		data_len = iov_iter_count(&io_data->data);
 729		/*
 730		 * Controller may require buffer size to be aligned to
 731		 * maxpacketsize of an out endpoint.
 732		 */
 733		if (io_data->read)
 734			data_len = usb_ep_align_maybe(gadget, ep->ep, data_len);
 
 
 735		spin_unlock_irq(&epfile->ffs->eps_lock);
 736
 737		data = kmalloc(data_len, GFP_KERNEL);
 738		if (unlikely(!data))
 739			return -ENOMEM;
 740		if (!io_data->read) {
 741			copied = copy_from_iter(data, data_len, &io_data->data);
 742			if (copied != data_len) {
 743				ret = -EFAULT;
 744				goto error;
 745			}
 746		}
 747	}
 748
 749	/* We will be using request */
 750	ret = ffs_mutex_lock(&epfile->mutex, file->f_flags & O_NONBLOCK);
 751	if (unlikely(ret))
 752		goto error;
 753
 754	spin_lock_irq(&epfile->ffs->eps_lock);
 755
 756	if (epfile->ep != ep) {
 757		/* In the meantime, endpoint got disabled or changed. */
 758		ret = -ESHUTDOWN;
 759	} else if (halt) {
 760		/* Halt */
 761		if (likely(epfile->ep == ep) && !WARN_ON(!ep->ep))
 762			usb_ep_set_halt(ep->ep);
 763		ret = -EBADMSG;
 764	} else if (unlikely(data_len == -EINVAL)) {
 765		/*
 766		 * Sanity Check: even though data_len can't be used
 767		 * uninitialized at the time I write this comment, some
 768		 * compilers complain about this situation.
 769		 * In order to keep the code clean from warnings, data_len is
 770		 * being initialized to -EINVAL during its declaration, which
 771		 * means we can't rely on compiler anymore to warn no future
 772		 * changes won't result in data_len being used uninitialized.
 773		 * For such reason, we're adding this redundant sanity check
 774		 * here.
 775		 */
 776		WARN(1, "%s: data_len == -EINVAL\n", __func__);
 777		ret = -EINVAL;
 778	} else if (!io_data->aio) {
 779		DECLARE_COMPLETION_ONSTACK(done);
 780		bool interrupted = false;
 781
 782		req = ep->req;
 783		req->buf      = data;
 784		req->length   = data_len;
 
 
 
 
 
 
 
 
 785
 786		req->context  = &done;
 787		req->complete = ffs_epfile_io_complete;
 788
 789		ret = usb_ep_queue(ep->ep, req, GFP_ATOMIC);
 790		if (unlikely(ret < 0))
 791			goto error_lock;
 792
 793		spin_unlock_irq(&epfile->ffs->eps_lock);
 794
 795		if (unlikely(wait_for_completion_interruptible(&done))) {
 796			/*
 797			 * To avoid race condition with ffs_epfile_io_complete,
 798			 * dequeue the request first then check
 799			 * status. usb_ep_dequeue API should guarantee no race
 800			 * condition with req->complete callback.
 801			 */
 802			usb_ep_dequeue(ep->ep, req);
 
 803			interrupted = ep->status < 0;
 804		}
 805
 806		/*
 807		 * XXX We may end up silently droping data here.  Since data_len
 808		 * (i.e. req->length) may be bigger than len (after being
 809		 * rounded up to maxpacketsize), we may end up with more data
 810		 * then user space has space for.
 811		 */
 812		ret = interrupted ? -EINTR : ep->status;
 813		if (io_data->read && ret > 0) {
 814			ret = copy_to_iter(data, ret, &io_data->data);
 815			if (!ret)
 816				ret = -EFAULT;
 817		}
 818		goto error_mutex;
 819	} else if (!(req = usb_ep_alloc_request(ep->ep, GFP_KERNEL))) {
 820		ret = -ENOMEM;
 821	} else {
 822		req->buf      = data;
 823		req->length   = data_len;
 
 
 
 
 
 
 824
 825		io_data->buf = data;
 826		io_data->ep = ep->ep;
 827		io_data->req = req;
 828		io_data->ffs = epfile->ffs;
 829
 830		req->context  = io_data;
 831		req->complete = ffs_epfile_async_io_complete;
 832
 833		ret = usb_ep_queue(ep->ep, req, GFP_ATOMIC);
 834		if (unlikely(ret)) {
 835			usb_ep_free_request(ep->ep, req);
 836			goto error_lock;
 837		}
 838
 839		ret = -EIOCBQUEUED;
 840		/*
 841		 * Do not kfree the buffer in this function.  It will be freed
 842		 * by ffs_user_copy_worker.
 843		 */
 844		data = NULL;
 845	}
 846
 847error_lock:
 848	spin_unlock_irq(&epfile->ffs->eps_lock);
 849error_mutex:
 850	mutex_unlock(&epfile->mutex);
 851error:
 852	kfree(data);
 
 853	return ret;
 854}
 855
 856static int
 857ffs_epfile_open(struct inode *inode, struct file *file)
 858{
 859	struct ffs_epfile *epfile = inode->i_private;
 860
 861	ENTER();
 862
 863	if (WARN_ON(epfile->ffs->state != FFS_ACTIVE))
 864		return -ENODEV;
 865
 866	file->private_data = epfile;
 867	ffs_data_opened(epfile->ffs);
 868
 869	return 0;
 870}
 871
 872static int ffs_aio_cancel(struct kiocb *kiocb)
 873{
 874	struct ffs_io_data *io_data = kiocb->private;
 875	struct ffs_epfile *epfile = kiocb->ki_filp->private_data;
 876	int value;
 877
 878	ENTER();
 879
 880	spin_lock_irq(&epfile->ffs->eps_lock);
 881
 882	if (likely(io_data && io_data->ep && io_data->req))
 883		value = usb_ep_dequeue(io_data->ep, io_data->req);
 884	else
 885		value = -EINVAL;
 886
 887	spin_unlock_irq(&epfile->ffs->eps_lock);
 888
 889	return value;
 890}
 891
 892static ssize_t ffs_epfile_write_iter(struct kiocb *kiocb, struct iov_iter *from)
 893{
 894	struct ffs_io_data io_data, *p = &io_data;
 895	ssize_t res;
 896
 897	ENTER();
 898
 899	if (!is_sync_kiocb(kiocb)) {
 900		p = kmalloc(sizeof(io_data), GFP_KERNEL);
 901		if (unlikely(!p))
 902			return -ENOMEM;
 903		p->aio = true;
 904	} else {
 
 905		p->aio = false;
 906	}
 907
 908	p->read = false;
 909	p->kiocb = kiocb;
 910	p->data = *from;
 911	p->mm = current->mm;
 912
 913	kiocb->private = p;
 914
 915	if (p->aio)
 916		kiocb_set_cancel_fn(kiocb, ffs_aio_cancel);
 917
 918	res = ffs_epfile_io(kiocb->ki_filp, p);
 919	if (res == -EIOCBQUEUED)
 920		return res;
 921	if (p->aio)
 922		kfree(p);
 923	else
 924		*from = p->data;
 925	return res;
 926}
 927
 928static ssize_t ffs_epfile_read_iter(struct kiocb *kiocb, struct iov_iter *to)
 929{
 930	struct ffs_io_data io_data, *p = &io_data;
 931	ssize_t res;
 932
 933	ENTER();
 934
 935	if (!is_sync_kiocb(kiocb)) {
 936		p = kmalloc(sizeof(io_data), GFP_KERNEL);
 937		if (unlikely(!p))
 938			return -ENOMEM;
 939		p->aio = true;
 940	} else {
 
 941		p->aio = false;
 942	}
 943
 944	p->read = true;
 945	p->kiocb = kiocb;
 946	if (p->aio) {
 947		p->to_free = dup_iter(&p->data, to, GFP_KERNEL);
 948		if (!p->to_free) {
 949			kfree(p);
 950			return -ENOMEM;
 951		}
 952	} else {
 953		p->data = *to;
 954		p->to_free = NULL;
 955	}
 956	p->mm = current->mm;
 957
 958	kiocb->private = p;
 959
 960	if (p->aio)
 961		kiocb_set_cancel_fn(kiocb, ffs_aio_cancel);
 962
 963	res = ffs_epfile_io(kiocb->ki_filp, p);
 964	if (res == -EIOCBQUEUED)
 965		return res;
 966
 967	if (p->aio) {
 968		kfree(p->to_free);
 969		kfree(p);
 970	} else {
 971		*to = p->data;
 972	}
 973	return res;
 974}
 975
 976static int
 977ffs_epfile_release(struct inode *inode, struct file *file)
 978{
 979	struct ffs_epfile *epfile = inode->i_private;
 980
 981	ENTER();
 982
 
 983	ffs_data_closed(epfile->ffs);
 984
 985	return 0;
 986}
 987
 988static long ffs_epfile_ioctl(struct file *file, unsigned code,
 989			     unsigned long value)
 990{
 991	struct ffs_epfile *epfile = file->private_data;
 
 992	int ret;
 993
 994	ENTER();
 995
 996	if (WARN_ON(epfile->ffs->state != FFS_ACTIVE))
 997		return -ENODEV;
 998
 
 
 
 
 
 
 
 
 
 
 
 
 999	spin_lock_irq(&epfile->ffs->eps_lock);
1000	if (likely(epfile->ep)) {
1001		switch (code) {
1002		case FUNCTIONFS_FIFO_STATUS:
1003			ret = usb_ep_fifo_status(epfile->ep->ep);
1004			break;
1005		case FUNCTIONFS_FIFO_FLUSH:
1006			usb_ep_fifo_flush(epfile->ep->ep);
1007			ret = 0;
1008			break;
1009		case FUNCTIONFS_CLEAR_HALT:
1010			ret = usb_ep_clear_halt(epfile->ep->ep);
1011			break;
1012		case FUNCTIONFS_ENDPOINT_REVMAP:
1013			ret = epfile->ep->num;
1014			break;
1015		case FUNCTIONFS_ENDPOINT_DESC:
1016		{
1017			int desc_idx;
1018			struct usb_endpoint_descriptor *desc;
1019
1020			switch (epfile->ffs->gadget->speed) {
1021			case USB_SPEED_SUPER:
1022				desc_idx = 2;
1023				break;
1024			case USB_SPEED_HIGH:
1025				desc_idx = 1;
1026				break;
1027			default:
1028				desc_idx = 0;
1029			}
1030			desc = epfile->ep->descs[desc_idx];
1031
1032			spin_unlock_irq(&epfile->ffs->eps_lock);
1033			ret = copy_to_user((void *)value, desc, sizeof(*desc));
1034			if (ret)
1035				ret = -EFAULT;
1036			return ret;
1037		}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1038		default:
1039			ret = -ENOTTY;
1040		}
1041	} else {
1042		ret = -ENODEV;
 
 
 
 
 
 
 
 
1043	}
1044	spin_unlock_irq(&epfile->ffs->eps_lock);
1045
1046	return ret;
1047}
1048
 
 
 
 
 
 
 
 
1049static const struct file_operations ffs_epfile_operations = {
1050	.llseek =	no_llseek,
1051
1052	.open =		ffs_epfile_open,
1053	.write_iter =	ffs_epfile_write_iter,
1054	.read_iter =	ffs_epfile_read_iter,
1055	.release =	ffs_epfile_release,
1056	.unlocked_ioctl =	ffs_epfile_ioctl,
 
 
 
1057};
1058
1059
1060/* File system and super block operations ***********************************/
1061
1062/*
1063 * Mounting the file system creates a controller file, used first for
1064 * function configuration then later for event monitoring.
1065 */
1066
1067static struct inode *__must_check
1068ffs_sb_make_inode(struct super_block *sb, void *data,
1069		  const struct file_operations *fops,
1070		  const struct inode_operations *iops,
1071		  struct ffs_file_perms *perms)
1072{
1073	struct inode *inode;
1074
1075	ENTER();
1076
1077	inode = new_inode(sb);
1078
1079	if (likely(inode)) {
1080		struct timespec current_time = CURRENT_TIME;
1081
1082		inode->i_ino	 = get_next_ino();
1083		inode->i_mode    = perms->mode;
1084		inode->i_uid     = perms->uid;
1085		inode->i_gid     = perms->gid;
1086		inode->i_atime   = current_time;
1087		inode->i_mtime   = current_time;
1088		inode->i_ctime   = current_time;
1089		inode->i_private = data;
1090		if (fops)
1091			inode->i_fop = fops;
1092		if (iops)
1093			inode->i_op  = iops;
1094	}
1095
1096	return inode;
1097}
1098
1099/* Create "regular" file */
1100static struct dentry *ffs_sb_create_file(struct super_block *sb,
1101					const char *name, void *data,
1102					const struct file_operations *fops)
1103{
1104	struct ffs_data	*ffs = sb->s_fs_info;
1105	struct dentry	*dentry;
1106	struct inode	*inode;
1107
1108	ENTER();
1109
1110	dentry = d_alloc_name(sb->s_root, name);
1111	if (unlikely(!dentry))
1112		return NULL;
1113
1114	inode = ffs_sb_make_inode(sb, data, fops, NULL, &ffs->file_perms);
1115	if (unlikely(!inode)) {
1116		dput(dentry);
1117		return NULL;
1118	}
1119
1120	d_add(dentry, inode);
1121	return dentry;
1122}
1123
1124/* Super block */
1125static const struct super_operations ffs_sb_operations = {
1126	.statfs =	simple_statfs,
1127	.drop_inode =	generic_delete_inode,
1128};
1129
1130struct ffs_sb_fill_data {
1131	struct ffs_file_perms perms;
1132	umode_t root_mode;
1133	const char *dev_name;
1134	bool no_disconnect;
1135	struct ffs_data *ffs_data;
1136};
1137
1138static int ffs_sb_fill(struct super_block *sb, void *_data, int silent)
1139{
1140	struct ffs_sb_fill_data *data = _data;
1141	struct inode	*inode;
1142	struct ffs_data	*ffs = data->ffs_data;
1143
1144	ENTER();
1145
1146	ffs->sb              = sb;
1147	data->ffs_data       = NULL;
1148	sb->s_fs_info        = ffs;
1149	sb->s_blocksize      = PAGE_SIZE;
1150	sb->s_blocksize_bits = PAGE_SHIFT;
1151	sb->s_magic          = FUNCTIONFS_MAGIC;
1152	sb->s_op             = &ffs_sb_operations;
1153	sb->s_time_gran      = 1;
1154
1155	/* Root inode */
1156	data->perms.mode = data->root_mode;
1157	inode = ffs_sb_make_inode(sb, NULL,
1158				  &simple_dir_operations,
1159				  &simple_dir_inode_operations,
1160				  &data->perms);
1161	sb->s_root = d_make_root(inode);
1162	if (unlikely(!sb->s_root))
1163		return -ENOMEM;
1164
1165	/* EP0 file */
1166	if (unlikely(!ffs_sb_create_file(sb, "ep0", ffs,
1167					 &ffs_ep0_operations)))
1168		return -ENOMEM;
1169
1170	return 0;
1171}
1172
1173static int ffs_fs_parse_opts(struct ffs_sb_fill_data *data, char *opts)
1174{
1175	ENTER();
 
 
 
 
 
1176
1177	if (!opts || !*opts)
1178		return 0;
 
 
 
 
 
 
 
1179
1180	for (;;) {
1181		unsigned long value;
1182		char *eq, *comma;
 
1183
1184		/* Option limit */
1185		comma = strchr(opts, ',');
1186		if (comma)
1187			*comma = 0;
1188
1189		/* Value limit */
1190		eq = strchr(opts, '=');
1191		if (unlikely(!eq)) {
1192			pr_err("'=' missing in %s\n", opts);
1193			return -EINVAL;
1194		}
1195		*eq = 0;
1196
1197		/* Parse value */
1198		if (kstrtoul(eq + 1, 0, &value)) {
1199			pr_err("%s: invalid value: %s\n", opts, eq + 1);
1200			return -EINVAL;
1201		}
1202
1203		/* Interpret option */
1204		switch (eq - opts) {
1205		case 13:
1206			if (!memcmp(opts, "no_disconnect", 13))
1207				data->no_disconnect = !!value;
1208			else
1209				goto invalid;
1210			break;
1211		case 5:
1212			if (!memcmp(opts, "rmode", 5))
1213				data->root_mode  = (value & 0555) | S_IFDIR;
1214			else if (!memcmp(opts, "fmode", 5))
1215				data->perms.mode = (value & 0666) | S_IFREG;
1216			else
1217				goto invalid;
1218			break;
1219
1220		case 4:
1221			if (!memcmp(opts, "mode", 4)) {
1222				data->root_mode  = (value & 0555) | S_IFDIR;
1223				data->perms.mode = (value & 0666) | S_IFREG;
1224			} else {
1225				goto invalid;
1226			}
1227			break;
1228
1229		case 3:
1230			if (!memcmp(opts, "uid", 3)) {
1231				data->perms.uid = make_kuid(current_user_ns(), value);
1232				if (!uid_valid(data->perms.uid)) {
1233					pr_err("%s: unmapped value: %lu\n", opts, value);
1234					return -EINVAL;
1235				}
1236			} else if (!memcmp(opts, "gid", 3)) {
1237				data->perms.gid = make_kgid(current_user_ns(), value);
1238				if (!gid_valid(data->perms.gid)) {
1239					pr_err("%s: unmapped value: %lu\n", opts, value);
1240					return -EINVAL;
1241				}
1242			} else {
1243				goto invalid;
1244			}
1245			break;
1246
1247		default:
1248invalid:
1249			pr_err("%s: invalid option\n", opts);
1250			return -EINVAL;
1251		}
 
 
 
 
 
1252
1253		/* Next iteration */
1254		if (!comma)
1255			break;
1256		opts = comma + 1;
1257	}
1258
1259	return 0;
1260}
1261
1262/* "mount -t functionfs dev_name /dev/function" ends up here */
 
 
1263
1264static struct dentry *
1265ffs_fs_mount(struct file_system_type *t, int flags,
1266	      const char *dev_name, void *opts)
 
1267{
1268	struct ffs_sb_fill_data data = {
1269		.perms = {
1270			.mode = S_IFREG | 0600,
1271			.uid = GLOBAL_ROOT_UID,
1272			.gid = GLOBAL_ROOT_GID,
1273		},
1274		.root_mode = S_IFDIR | 0500,
1275		.no_disconnect = false,
1276	};
1277	struct dentry *rv;
1278	int ret;
1279	void *ffs_dev;
1280	struct ffs_data	*ffs;
1281
1282	ENTER();
1283
1284	ret = ffs_fs_parse_opts(&data, opts);
1285	if (unlikely(ret < 0))
1286		return ERR_PTR(ret);
1287
1288	ffs = ffs_data_new();
1289	if (unlikely(!ffs))
1290		return ERR_PTR(-ENOMEM);
1291	ffs->file_perms = data.perms;
1292	ffs->no_disconnect = data.no_disconnect;
1293
1294	ffs->dev_name = kstrdup(dev_name, GFP_KERNEL);
1295	if (unlikely(!ffs->dev_name)) {
1296		ffs_data_put(ffs);
1297		return ERR_PTR(-ENOMEM);
1298	}
1299
1300	ffs_dev = ffs_acquire_dev(dev_name);
1301	if (IS_ERR(ffs_dev)) {
1302		ffs_data_put(ffs);
1303		return ERR_CAST(ffs_dev);
1304	}
 
1305	ffs->private_data = ffs_dev;
1306	data.ffs_data = ffs;
 
 
 
 
 
 
1307
1308	rv = mount_nodev(t, flags, &data, ffs_sb_fill);
1309	if (IS_ERR(rv) && data.ffs_data) {
1310		ffs_release_dev(data.ffs_data);
1311		ffs_data_put(data.ffs_data);
 
 
 
1312	}
1313	return rv;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1314}
1315
1316static void
1317ffs_fs_kill_sb(struct super_block *sb)
1318{
1319	ENTER();
1320
1321	kill_litter_super(sb);
1322	if (sb->s_fs_info) {
1323		ffs_release_dev(sb->s_fs_info);
1324		ffs_data_closed(sb->s_fs_info);
1325		ffs_data_put(sb->s_fs_info);
1326	}
1327}
1328
1329static struct file_system_type ffs_fs_type = {
1330	.owner		= THIS_MODULE,
1331	.name		= "functionfs",
1332	.mount		= ffs_fs_mount,
 
1333	.kill_sb	= ffs_fs_kill_sb,
1334};
1335MODULE_ALIAS_FS("functionfs");
1336
1337
1338/* Driver's main init/cleanup functions *************************************/
1339
1340static int functionfs_init(void)
1341{
1342	int ret;
1343
1344	ENTER();
1345
1346	ret = register_filesystem(&ffs_fs_type);
1347	if (likely(!ret))
1348		pr_info("file system registered\n");
1349	else
1350		pr_err("failed registering file system (%d)\n", ret);
1351
1352	return ret;
1353}
1354
1355static void functionfs_cleanup(void)
1356{
1357	ENTER();
1358
1359	pr_info("unloading\n");
1360	unregister_filesystem(&ffs_fs_type);
1361}
1362
1363
1364/* ffs_data and ffs_function construction and destruction code **************/
1365
1366static void ffs_data_clear(struct ffs_data *ffs);
1367static void ffs_data_reset(struct ffs_data *ffs);
1368
1369static void ffs_data_get(struct ffs_data *ffs)
1370{
1371	ENTER();
1372
1373	atomic_inc(&ffs->ref);
1374}
1375
1376static void ffs_data_opened(struct ffs_data *ffs)
1377{
1378	ENTER();
1379
1380	atomic_inc(&ffs->ref);
1381	if (atomic_add_return(1, &ffs->opened) == 1 &&
1382			ffs->state == FFS_DEACTIVATED) {
1383		ffs->state = FFS_CLOSING;
1384		ffs_data_reset(ffs);
1385	}
1386}
1387
1388static void ffs_data_put(struct ffs_data *ffs)
1389{
1390	ENTER();
1391
1392	if (unlikely(atomic_dec_and_test(&ffs->ref))) {
1393		pr_info("%s(): freeing\n", __func__);
1394		ffs_data_clear(ffs);
1395		BUG_ON(waitqueue_active(&ffs->ev.waitq) ||
1396		       waitqueue_active(&ffs->ep0req_completion.wait));
 
 
1397		kfree(ffs->dev_name);
1398		kfree(ffs);
1399	}
1400}
1401
1402static void ffs_data_closed(struct ffs_data *ffs)
1403{
1404	ENTER();
1405
1406	if (atomic_dec_and_test(&ffs->opened)) {
1407		if (ffs->no_disconnect) {
1408			ffs->state = FFS_DEACTIVATED;
1409			if (ffs->epfiles) {
1410				ffs_epfiles_destroy(ffs->epfiles,
1411						   ffs->eps_count);
1412				ffs->epfiles = NULL;
1413			}
1414			if (ffs->setup_state == FFS_SETUP_PENDING)
1415				__ffs_ep0_stall(ffs);
1416		} else {
1417			ffs->state = FFS_CLOSING;
1418			ffs_data_reset(ffs);
1419		}
1420	}
1421	if (atomic_read(&ffs->opened) < 0) {
1422		ffs->state = FFS_CLOSING;
1423		ffs_data_reset(ffs);
1424	}
1425
1426	ffs_data_put(ffs);
1427}
1428
1429static struct ffs_data *ffs_data_new(void)
1430{
1431	struct ffs_data *ffs = kzalloc(sizeof *ffs, GFP_KERNEL);
1432	if (unlikely(!ffs))
1433		return NULL;
1434
1435	ENTER();
1436
1437	atomic_set(&ffs->ref, 1);
 
 
 
 
 
 
1438	atomic_set(&ffs->opened, 0);
1439	ffs->state = FFS_READ_DESCRIPTORS;
1440	mutex_init(&ffs->mutex);
1441	spin_lock_init(&ffs->eps_lock);
1442	init_waitqueue_head(&ffs->ev.waitq);
 
1443	init_completion(&ffs->ep0req_completion);
1444
1445	/* XXX REVISIT need to update it in some places, or do we? */
1446	ffs->ev.can_stall = 1;
1447
1448	return ffs;
1449}
1450
1451static void ffs_data_clear(struct ffs_data *ffs)
1452{
1453	ENTER();
1454
1455	ffs_closed(ffs);
1456
1457	BUG_ON(ffs->gadget);
1458
1459	if (ffs->epfiles)
1460		ffs_epfiles_destroy(ffs->epfiles, ffs->eps_count);
1461
1462	if (ffs->ffs_eventfd)
1463		eventfd_ctx_put(ffs->ffs_eventfd);
1464
1465	kfree(ffs->raw_descs_data);
1466	kfree(ffs->raw_strings);
1467	kfree(ffs->stringtabs);
1468}
1469
1470static void ffs_data_reset(struct ffs_data *ffs)
1471{
1472	ENTER();
1473
1474	ffs_data_clear(ffs);
1475
1476	ffs->epfiles = NULL;
1477	ffs->raw_descs_data = NULL;
1478	ffs->raw_descs = NULL;
1479	ffs->raw_strings = NULL;
1480	ffs->stringtabs = NULL;
1481
1482	ffs->raw_descs_length = 0;
1483	ffs->fs_descs_count = 0;
1484	ffs->hs_descs_count = 0;
1485	ffs->ss_descs_count = 0;
1486
1487	ffs->strings_count = 0;
1488	ffs->interfaces_count = 0;
1489	ffs->eps_count = 0;
1490
1491	ffs->ev.count = 0;
1492
1493	ffs->state = FFS_READ_DESCRIPTORS;
1494	ffs->setup_state = FFS_NO_SETUP;
1495	ffs->flags = 0;
1496}
1497
1498
1499static int functionfs_bind(struct ffs_data *ffs, struct usb_composite_dev *cdev)
1500{
1501	struct usb_gadget_strings **lang;
1502	int first_id;
1503
1504	ENTER();
1505
1506	if (WARN_ON(ffs->state != FFS_ACTIVE
1507		 || test_and_set_bit(FFS_FL_BOUND, &ffs->flags)))
1508		return -EBADFD;
1509
1510	first_id = usb_string_ids_n(cdev, ffs->strings_count);
1511	if (unlikely(first_id < 0))
1512		return first_id;
1513
1514	ffs->ep0req = usb_ep_alloc_request(cdev->gadget->ep0, GFP_KERNEL);
1515	if (unlikely(!ffs->ep0req))
1516		return -ENOMEM;
1517	ffs->ep0req->complete = ffs_ep0_complete;
1518	ffs->ep0req->context = ffs;
1519
1520	lang = ffs->stringtabs;
1521	if (lang) {
1522		for (; *lang; ++lang) {
1523			struct usb_string *str = (*lang)->strings;
1524			int id = first_id;
1525			for (; str->s; ++id, ++str)
1526				str->id = id;
1527		}
1528	}
1529
1530	ffs->gadget = cdev->gadget;
1531	ffs_data_get(ffs);
1532	return 0;
1533}
1534
1535static void functionfs_unbind(struct ffs_data *ffs)
1536{
1537	ENTER();
1538
1539	if (!WARN_ON(!ffs->gadget)) {
1540		usb_ep_free_request(ffs->gadget->ep0, ffs->ep0req);
1541		ffs->ep0req = NULL;
1542		ffs->gadget = NULL;
1543		clear_bit(FFS_FL_BOUND, &ffs->flags);
1544		ffs_data_put(ffs);
1545	}
1546}
1547
1548static int ffs_epfiles_create(struct ffs_data *ffs)
1549{
1550	struct ffs_epfile *epfile, *epfiles;
1551	unsigned i, count;
1552
1553	ENTER();
1554
1555	count = ffs->eps_count;
1556	epfiles = kcalloc(count, sizeof(*epfiles), GFP_KERNEL);
1557	if (!epfiles)
1558		return -ENOMEM;
1559
1560	epfile = epfiles;
1561	for (i = 1; i <= count; ++i, ++epfile) {
1562		epfile->ffs = ffs;
1563		mutex_init(&epfile->mutex);
1564		init_waitqueue_head(&epfile->wait);
1565		if (ffs->user_flags & FUNCTIONFS_VIRTUAL_ADDR)
1566			sprintf(epfile->name, "ep%02x", ffs->eps_addrmap[i]);
1567		else
1568			sprintf(epfile->name, "ep%u", i);
1569		epfile->dentry = ffs_sb_create_file(ffs->sb, epfile->name,
1570						 epfile,
1571						 &ffs_epfile_operations);
1572		if (unlikely(!epfile->dentry)) {
1573			ffs_epfiles_destroy(epfiles, i - 1);
1574			return -ENOMEM;
1575		}
1576	}
1577
1578	ffs->epfiles = epfiles;
1579	return 0;
1580}
1581
1582static void ffs_epfiles_destroy(struct ffs_epfile *epfiles, unsigned count)
1583{
1584	struct ffs_epfile *epfile = epfiles;
1585
1586	ENTER();
1587
1588	for (; count; --count, ++epfile) {
1589		BUG_ON(mutex_is_locked(&epfile->mutex) ||
1590		       waitqueue_active(&epfile->wait));
1591		if (epfile->dentry) {
1592			d_delete(epfile->dentry);
1593			dput(epfile->dentry);
1594			epfile->dentry = NULL;
1595		}
1596	}
1597
1598	kfree(epfiles);
1599}
1600
1601static void ffs_func_eps_disable(struct ffs_function *func)
1602{
1603	struct ffs_ep *ep         = func->eps;
1604	struct ffs_epfile *epfile = func->ffs->epfiles;
1605	unsigned count            = func->ffs->eps_count;
1606	unsigned long flags;
1607
1608	spin_lock_irqsave(&func->ffs->eps_lock, flags);
1609	do {
1610		/* pending requests get nuked */
1611		if (likely(ep->ep))
1612			usb_ep_disable(ep->ep);
1613		++ep;
1614
1615		if (epfile) {
1616			epfile->ep = NULL;
 
1617			++epfile;
1618		}
1619	} while (--count);
1620	spin_unlock_irqrestore(&func->ffs->eps_lock, flags);
1621}
1622
1623static int ffs_func_eps_enable(struct ffs_function *func)
1624{
1625	struct ffs_data *ffs      = func->ffs;
1626	struct ffs_ep *ep         = func->eps;
1627	struct ffs_epfile *epfile = ffs->epfiles;
1628	unsigned count            = ffs->eps_count;
1629	unsigned long flags;
1630	int ret = 0;
1631
1632	spin_lock_irqsave(&func->ffs->eps_lock, flags);
1633	do {
1634		struct usb_endpoint_descriptor *ds;
1635		int desc_idx;
1636
1637		if (ffs->gadget->speed == USB_SPEED_SUPER)
1638			desc_idx = 2;
1639		else if (ffs->gadget->speed == USB_SPEED_HIGH)
1640			desc_idx = 1;
1641		else
1642			desc_idx = 0;
1643
1644		/* fall-back to lower speed if desc missing for current speed */
1645		do {
1646			ds = ep->descs[desc_idx];
1647		} while (!ds && --desc_idx >= 0);
1648
1649		if (!ds) {
1650			ret = -EINVAL;
 
 
1651			break;
1652		}
1653
1654		ep->ep->driver_data = ep;
1655		ep->ep->desc = ds;
1656		ret = usb_ep_enable(ep->ep);
1657		if (likely(!ret)) {
1658			epfile->ep = ep;
1659			epfile->in = usb_endpoint_dir_in(ds);
1660			epfile->isoc = usb_endpoint_xfer_isoc(ds);
1661		} else {
1662			break;
1663		}
1664
1665		wake_up(&epfile->wait);
1666
1667		++ep;
1668		++epfile;
1669	} while (--count);
 
 
1670	spin_unlock_irqrestore(&func->ffs->eps_lock, flags);
1671
1672	return ret;
1673}
1674
1675
1676/* Parsing and building descriptors and strings *****************************/
1677
1678/*
1679 * This validates if data pointed by data is a valid USB descriptor as
1680 * well as record how many interfaces, endpoints and strings are
1681 * required by given configuration.  Returns address after the
1682 * descriptor or NULL if data is invalid.
1683 */
1684
1685enum ffs_entity_type {
1686	FFS_DESCRIPTOR, FFS_INTERFACE, FFS_STRING, FFS_ENDPOINT
1687};
1688
1689enum ffs_os_desc_type {
1690	FFS_OS_DESC, FFS_OS_DESC_EXT_COMPAT, FFS_OS_DESC_EXT_PROP
1691};
1692
1693typedef int (*ffs_entity_callback)(enum ffs_entity_type entity,
1694				   u8 *valuep,
1695				   struct usb_descriptor_header *desc,
1696				   void *priv);
1697
1698typedef int (*ffs_os_desc_callback)(enum ffs_os_desc_type entity,
1699				    struct usb_os_desc_header *h, void *data,
1700				    unsigned len, void *priv);
1701
1702static int __must_check ffs_do_single_desc(char *data, unsigned len,
1703					   ffs_entity_callback entity,
1704					   void *priv)
1705{
1706	struct usb_descriptor_header *_ds = (void *)data;
1707	u8 length;
1708	int ret;
1709
1710	ENTER();
1711
1712	/* At least two bytes are required: length and type */
1713	if (len < 2) {
1714		pr_vdebug("descriptor too short\n");
1715		return -EINVAL;
1716	}
1717
1718	/* If we have at least as many bytes as the descriptor takes? */
1719	length = _ds->bLength;
1720	if (len < length) {
1721		pr_vdebug("descriptor longer then available data\n");
1722		return -EINVAL;
1723	}
1724
1725#define __entity_check_INTERFACE(val)  1
1726#define __entity_check_STRING(val)     (val)
1727#define __entity_check_ENDPOINT(val)   ((val) & USB_ENDPOINT_NUMBER_MASK)
1728#define __entity(type, val) do {					\
1729		pr_vdebug("entity " #type "(%02x)\n", (val));		\
1730		if (unlikely(!__entity_check_ ##type(val))) {		\
1731			pr_vdebug("invalid entity's value\n");		\
1732			return -EINVAL;					\
1733		}							\
1734		ret = entity(FFS_ ##type, &val, _ds, priv);		\
1735		if (unlikely(ret < 0)) {				\
1736			pr_debug("entity " #type "(%02x); ret = %d\n",	\
1737				 (val), ret);				\
1738			return ret;					\
1739		}							\
1740	} while (0)
1741
1742	/* Parse descriptor depending on type. */
1743	switch (_ds->bDescriptorType) {
1744	case USB_DT_DEVICE:
1745	case USB_DT_CONFIG:
1746	case USB_DT_STRING:
1747	case USB_DT_DEVICE_QUALIFIER:
1748		/* function can't have any of those */
1749		pr_vdebug("descriptor reserved for gadget: %d\n",
1750		      _ds->bDescriptorType);
1751		return -EINVAL;
1752
1753	case USB_DT_INTERFACE: {
1754		struct usb_interface_descriptor *ds = (void *)_ds;
1755		pr_vdebug("interface descriptor\n");
1756		if (length != sizeof *ds)
1757			goto inv_length;
1758
1759		__entity(INTERFACE, ds->bInterfaceNumber);
1760		if (ds->iInterface)
1761			__entity(STRING, ds->iInterface);
 
1762	}
1763		break;
1764
1765	case USB_DT_ENDPOINT: {
1766		struct usb_endpoint_descriptor *ds = (void *)_ds;
1767		pr_vdebug("endpoint descriptor\n");
1768		if (length != USB_DT_ENDPOINT_SIZE &&
1769		    length != USB_DT_ENDPOINT_AUDIO_SIZE)
1770			goto inv_length;
1771		__entity(ENDPOINT, ds->bEndpointAddress);
1772	}
1773		break;
1774
1775	case HID_DT_HID:
1776		pr_vdebug("hid descriptor\n");
1777		if (length != sizeof(struct hid_descriptor))
1778			goto inv_length;
1779		break;
 
 
 
 
 
 
 
 
 
 
 
1780
1781	case USB_DT_OTG:
1782		if (length != sizeof(struct usb_otg_descriptor))
1783			goto inv_length;
1784		break;
1785
1786	case USB_DT_INTERFACE_ASSOCIATION: {
1787		struct usb_interface_assoc_descriptor *ds = (void *)_ds;
1788		pr_vdebug("interface association descriptor\n");
1789		if (length != sizeof *ds)
1790			goto inv_length;
1791		if (ds->iFunction)
1792			__entity(STRING, ds->iFunction);
1793	}
1794		break;
1795
1796	case USB_DT_SS_ENDPOINT_COMP:
1797		pr_vdebug("EP SS companion descriptor\n");
1798		if (length != sizeof(struct usb_ss_ep_comp_descriptor))
1799			goto inv_length;
1800		break;
1801
1802	case USB_DT_OTHER_SPEED_CONFIG:
1803	case USB_DT_INTERFACE_POWER:
1804	case USB_DT_DEBUG:
1805	case USB_DT_SECURITY:
1806	case USB_DT_CS_RADIO_CONTROL:
1807		/* TODO */
1808		pr_vdebug("unimplemented descriptor: %d\n", _ds->bDescriptorType);
1809		return -EINVAL;
1810
1811	default:
1812		/* We should never be here */
1813		pr_vdebug("unknown descriptor: %d\n", _ds->bDescriptorType);
1814		return -EINVAL;
1815
1816inv_length:
1817		pr_vdebug("invalid length: %d (descriptor %d)\n",
1818			  _ds->bLength, _ds->bDescriptorType);
1819		return -EINVAL;
1820	}
1821
1822#undef __entity
1823#undef __entity_check_DESCRIPTOR
1824#undef __entity_check_INTERFACE
1825#undef __entity_check_STRING
1826#undef __entity_check_ENDPOINT
1827
1828	return length;
1829}
1830
1831static int __must_check ffs_do_descs(unsigned count, char *data, unsigned len,
1832				     ffs_entity_callback entity, void *priv)
1833{
1834	const unsigned _len = len;
1835	unsigned long num = 0;
 
1836
1837	ENTER();
1838
1839	for (;;) {
1840		int ret;
1841
1842		if (num == count)
1843			data = NULL;
1844
1845		/* Record "descriptor" entity */
1846		ret = entity(FFS_DESCRIPTOR, (u8 *)num, (void *)data, priv);
1847		if (unlikely(ret < 0)) {
1848			pr_debug("entity DESCRIPTOR(%02lx); ret = %d\n",
1849				 num, ret);
1850			return ret;
1851		}
1852
1853		if (!data)
1854			return _len - len;
1855
1856		ret = ffs_do_single_desc(data, len, entity, priv);
 
1857		if (unlikely(ret < 0)) {
1858			pr_debug("%s returns %d\n", __func__, ret);
1859			return ret;
1860		}
1861
1862		len -= ret;
1863		data += ret;
1864		++num;
1865	}
1866}
1867
1868static int __ffs_data_do_entity(enum ffs_entity_type type,
1869				u8 *valuep, struct usb_descriptor_header *desc,
1870				void *priv)
1871{
1872	struct ffs_desc_helper *helper = priv;
1873	struct usb_endpoint_descriptor *d;
1874
1875	ENTER();
1876
1877	switch (type) {
1878	case FFS_DESCRIPTOR:
1879		break;
1880
1881	case FFS_INTERFACE:
1882		/*
1883		 * Interfaces are indexed from zero so if we
1884		 * encountered interface "n" then there are at least
1885		 * "n+1" interfaces.
1886		 */
1887		if (*valuep >= helper->interfaces_count)
1888			helper->interfaces_count = *valuep + 1;
1889		break;
1890
1891	case FFS_STRING:
1892		/*
1893		 * Strings are indexed from 1 (0 is magic ;) reserved
1894		 * for languages list or some such)
1895		 */
1896		if (*valuep > helper->ffs->strings_count)
1897			helper->ffs->strings_count = *valuep;
1898		break;
1899
1900	case FFS_ENDPOINT:
1901		d = (void *)desc;
1902		helper->eps_count++;
1903		if (helper->eps_count >= 15)
1904			return -EINVAL;
1905		/* Check if descriptors for any speed were already parsed */
1906		if (!helper->ffs->eps_count && !helper->ffs->interfaces_count)
1907			helper->ffs->eps_addrmap[helper->eps_count] =
1908				d->bEndpointAddress;
1909		else if (helper->ffs->eps_addrmap[helper->eps_count] !=
1910				d->bEndpointAddress)
1911			return -EINVAL;
1912		break;
1913	}
1914
1915	return 0;
1916}
1917
1918static int __ffs_do_os_desc_header(enum ffs_os_desc_type *next_type,
1919				   struct usb_os_desc_header *desc)
1920{
1921	u16 bcd_version = le16_to_cpu(desc->bcdVersion);
1922	u16 w_index = le16_to_cpu(desc->wIndex);
1923
1924	if (bcd_version != 1) {
1925		pr_vdebug("unsupported os descriptors version: %d",
1926			  bcd_version);
1927		return -EINVAL;
1928	}
1929	switch (w_index) {
1930	case 0x4:
1931		*next_type = FFS_OS_DESC_EXT_COMPAT;
1932		break;
1933	case 0x5:
1934		*next_type = FFS_OS_DESC_EXT_PROP;
1935		break;
1936	default:
1937		pr_vdebug("unsupported os descriptor type: %d", w_index);
1938		return -EINVAL;
1939	}
1940
1941	return sizeof(*desc);
1942}
1943
1944/*
1945 * Process all extended compatibility/extended property descriptors
1946 * of a feature descriptor
1947 */
1948static int __must_check ffs_do_single_os_desc(char *data, unsigned len,
1949					      enum ffs_os_desc_type type,
1950					      u16 feature_count,
1951					      ffs_os_desc_callback entity,
1952					      void *priv,
1953					      struct usb_os_desc_header *h)
1954{
1955	int ret;
1956	const unsigned _len = len;
1957
1958	ENTER();
1959
1960	/* loop over all ext compat/ext prop descriptors */
1961	while (feature_count--) {
1962		ret = entity(type, h, data, len, priv);
1963		if (unlikely(ret < 0)) {
1964			pr_debug("bad OS descriptor, type: %d\n", type);
1965			return ret;
1966		}
1967		data += ret;
1968		len -= ret;
1969	}
1970	return _len - len;
1971}
1972
1973/* Process a number of complete Feature Descriptors (Ext Compat or Ext Prop) */
1974static int __must_check ffs_do_os_descs(unsigned count,
1975					char *data, unsigned len,
1976					ffs_os_desc_callback entity, void *priv)
1977{
1978	const unsigned _len = len;
1979	unsigned long num = 0;
1980
1981	ENTER();
1982
1983	for (num = 0; num < count; ++num) {
1984		int ret;
1985		enum ffs_os_desc_type type;
1986		u16 feature_count;
1987		struct usb_os_desc_header *desc = (void *)data;
1988
1989		if (len < sizeof(*desc))
1990			return -EINVAL;
1991
1992		/*
1993		 * Record "descriptor" entity.
1994		 * Process dwLength, bcdVersion, wIndex, get b/wCount.
1995		 * Move the data pointer to the beginning of extended
1996		 * compatibilities proper or extended properties proper
1997		 * portions of the data
1998		 */
1999		if (le32_to_cpu(desc->dwLength) > len)
2000			return -EINVAL;
2001
2002		ret = __ffs_do_os_desc_header(&type, desc);
2003		if (unlikely(ret < 0)) {
2004			pr_debug("entity OS_DESCRIPTOR(%02lx); ret = %d\n",
2005				 num, ret);
2006			return ret;
2007		}
2008		/*
2009		 * 16-bit hex "?? 00" Little Endian looks like 8-bit hex "??"
2010		 */
2011		feature_count = le16_to_cpu(desc->wCount);
2012		if (type == FFS_OS_DESC_EXT_COMPAT &&
2013		    (feature_count > 255 || desc->Reserved))
2014				return -EINVAL;
2015		len -= ret;
2016		data += ret;
2017
2018		/*
2019		 * Process all function/property descriptors
2020		 * of this Feature Descriptor
2021		 */
2022		ret = ffs_do_single_os_desc(data, len, type,
2023					    feature_count, entity, priv, desc);
2024		if (unlikely(ret < 0)) {
2025			pr_debug("%s returns %d\n", __func__, ret);
2026			return ret;
2027		}
2028
2029		len -= ret;
2030		data += ret;
2031	}
2032	return _len - len;
2033}
2034
2035/**
2036 * Validate contents of the buffer from userspace related to OS descriptors.
2037 */
2038static int __ffs_data_do_os_desc(enum ffs_os_desc_type type,
2039				 struct usb_os_desc_header *h, void *data,
2040				 unsigned len, void *priv)
2041{
2042	struct ffs_data *ffs = priv;
2043	u8 length;
2044
2045	ENTER();
2046
2047	switch (type) {
2048	case FFS_OS_DESC_EXT_COMPAT: {
2049		struct usb_ext_compat_desc *d = data;
2050		int i;
2051
2052		if (len < sizeof(*d) ||
2053		    d->bFirstInterfaceNumber >= ffs->interfaces_count ||
2054		    d->Reserved1)
2055			return -EINVAL;
 
 
 
 
 
 
 
 
 
 
2056		for (i = 0; i < ARRAY_SIZE(d->Reserved2); ++i)
2057			if (d->Reserved2[i])
2058				return -EINVAL;
2059
2060		length = sizeof(struct usb_ext_compat_desc);
2061	}
2062		break;
2063	case FFS_OS_DESC_EXT_PROP: {
2064		struct usb_ext_prop_desc *d = data;
2065		u32 type, pdl;
2066		u16 pnl;
2067
2068		if (len < sizeof(*d) || h->interface >= ffs->interfaces_count)
2069			return -EINVAL;
2070		length = le32_to_cpu(d->dwSize);
 
 
2071		type = le32_to_cpu(d->dwPropertyDataType);
2072		if (type < USB_EXT_PROP_UNICODE ||
2073		    type > USB_EXT_PROP_UNICODE_MULTI) {
2074			pr_vdebug("unsupported os descriptor property type: %d",
2075				  type);
2076			return -EINVAL;
2077		}
2078		pnl = le16_to_cpu(d->wPropertyNameLength);
2079		pdl = le32_to_cpu(*(u32 *)((u8 *)data + 10 + pnl));
 
 
 
 
 
2080		if (length != 14 + pnl + pdl) {
2081			pr_vdebug("invalid os descriptor length: %d pnl:%d pdl:%d (descriptor %d)\n",
2082				  length, pnl, pdl, type);
2083			return -EINVAL;
2084		}
2085		++ffs->ms_os_descs_ext_prop_count;
2086		/* property name reported to the host as "WCHAR"s */
2087		ffs->ms_os_descs_ext_prop_name_len += pnl * 2;
2088		ffs->ms_os_descs_ext_prop_data_len += pdl;
2089	}
2090		break;
2091	default:
2092		pr_vdebug("unknown descriptor: %d\n", type);
2093		return -EINVAL;
2094	}
2095	return length;
2096}
2097
2098static int __ffs_data_got_descs(struct ffs_data *ffs,
2099				char *const _data, size_t len)
2100{
2101	char *data = _data, *raw_descs;
2102	unsigned os_descs_count = 0, counts[3], flags;
2103	int ret = -EINVAL, i;
2104	struct ffs_desc_helper helper;
2105
2106	ENTER();
2107
2108	if (get_unaligned_le32(data + 4) != len)
2109		goto error;
2110
2111	switch (get_unaligned_le32(data)) {
2112	case FUNCTIONFS_DESCRIPTORS_MAGIC:
2113		flags = FUNCTIONFS_HAS_FS_DESC | FUNCTIONFS_HAS_HS_DESC;
2114		data += 8;
2115		len  -= 8;
2116		break;
2117	case FUNCTIONFS_DESCRIPTORS_MAGIC_V2:
2118		flags = get_unaligned_le32(data + 8);
2119		ffs->user_flags = flags;
2120		if (flags & ~(FUNCTIONFS_HAS_FS_DESC |
2121			      FUNCTIONFS_HAS_HS_DESC |
2122			      FUNCTIONFS_HAS_SS_DESC |
2123			      FUNCTIONFS_HAS_MS_OS_DESC |
2124			      FUNCTIONFS_VIRTUAL_ADDR |
2125			      FUNCTIONFS_EVENTFD)) {
 
 
2126			ret = -ENOSYS;
2127			goto error;
2128		}
2129		data += 12;
2130		len  -= 12;
2131		break;
2132	default:
2133		goto error;
2134	}
2135
2136	if (flags & FUNCTIONFS_EVENTFD) {
2137		if (len < 4)
2138			goto error;
2139		ffs->ffs_eventfd =
2140			eventfd_ctx_fdget((int)get_unaligned_le32(data));
2141		if (IS_ERR(ffs->ffs_eventfd)) {
2142			ret = PTR_ERR(ffs->ffs_eventfd);
2143			ffs->ffs_eventfd = NULL;
2144			goto error;
2145		}
2146		data += 4;
2147		len  -= 4;
2148	}
2149
2150	/* Read fs_count, hs_count and ss_count (if present) */
2151	for (i = 0; i < 3; ++i) {
2152		if (!(flags & (1 << i))) {
2153			counts[i] = 0;
2154		} else if (len < 4) {
2155			goto error;
2156		} else {
2157			counts[i] = get_unaligned_le32(data);
2158			data += 4;
2159			len  -= 4;
2160		}
2161	}
2162	if (flags & (1 << i)) {
 
 
 
2163		os_descs_count = get_unaligned_le32(data);
2164		data += 4;
2165		len -= 4;
2166	};
2167
2168	/* Read descriptors */
2169	raw_descs = data;
2170	helper.ffs = ffs;
2171	for (i = 0; i < 3; ++i) {
2172		if (!counts[i])
2173			continue;
2174		helper.interfaces_count = 0;
2175		helper.eps_count = 0;
2176		ret = ffs_do_descs(counts[i], data, len,
2177				   __ffs_data_do_entity, &helper);
2178		if (ret < 0)
2179			goto error;
2180		if (!ffs->eps_count && !ffs->interfaces_count) {
2181			ffs->eps_count = helper.eps_count;
2182			ffs->interfaces_count = helper.interfaces_count;
2183		} else {
2184			if (ffs->eps_count != helper.eps_count) {
2185				ret = -EINVAL;
2186				goto error;
2187			}
2188			if (ffs->interfaces_count != helper.interfaces_count) {
2189				ret = -EINVAL;
2190				goto error;
2191			}
2192		}
2193		data += ret;
2194		len  -= ret;
2195	}
2196	if (os_descs_count) {
2197		ret = ffs_do_os_descs(os_descs_count, data, len,
2198				      __ffs_data_do_os_desc, ffs);
2199		if (ret < 0)
2200			goto error;
2201		data += ret;
2202		len -= ret;
2203	}
2204
2205	if (raw_descs == data || len) {
2206		ret = -EINVAL;
2207		goto error;
2208	}
2209
2210	ffs->raw_descs_data	= _data;
2211	ffs->raw_descs		= raw_descs;
2212	ffs->raw_descs_length	= data - raw_descs;
2213	ffs->fs_descs_count	= counts[0];
2214	ffs->hs_descs_count	= counts[1];
2215	ffs->ss_descs_count	= counts[2];
2216	ffs->ms_os_descs_count	= os_descs_count;
2217
2218	return 0;
2219
2220error:
2221	kfree(_data);
2222	return ret;
2223}
2224
2225static int __ffs_data_got_strings(struct ffs_data *ffs,
2226				  char *const _data, size_t len)
2227{
2228	u32 str_count, needed_count, lang_count;
2229	struct usb_gadget_strings **stringtabs, *t;
2230	struct usb_string *strings, *s;
2231	const char *data = _data;
 
2232
2233	ENTER();
2234
2235	if (unlikely(get_unaligned_le32(data) != FUNCTIONFS_STRINGS_MAGIC ||
 
2236		     get_unaligned_le32(data + 4) != len))
2237		goto error;
2238	str_count  = get_unaligned_le32(data + 8);
2239	lang_count = get_unaligned_le32(data + 12);
2240
2241	/* if one is zero the other must be zero */
2242	if (unlikely(!str_count != !lang_count))
2243		goto error;
2244
2245	/* Do we have at least as many strings as descriptors need? */
2246	needed_count = ffs->strings_count;
2247	if (unlikely(str_count < needed_count))
2248		goto error;
2249
2250	/*
2251	 * If we don't need any strings just return and free all
2252	 * memory.
2253	 */
2254	if (!needed_count) {
2255		kfree(_data);
2256		return 0;
2257	}
2258
2259	/* Allocate everything in one chunk so there's less maintenance. */
2260	{
2261		unsigned i = 0;
2262		vla_group(d);
2263		vla_item(d, struct usb_gadget_strings *, stringtabs,
2264			lang_count + 1);
2265		vla_item(d, struct usb_gadget_strings, stringtab, lang_count);
2266		vla_item(d, struct usb_string, strings,
2267			lang_count*(needed_count+1));
2268
2269		char *vlabuf = kmalloc(vla_group_size(d), GFP_KERNEL);
2270
2271		if (unlikely(!vlabuf)) {
2272			kfree(_data);
2273			return -ENOMEM;
2274		}
2275
2276		/* Initialize the VLA pointers */
2277		stringtabs = vla_ptr(vlabuf, d, stringtabs);
2278		t = vla_ptr(vlabuf, d, stringtab);
2279		i = lang_count;
2280		do {
2281			*stringtabs++ = t++;
2282		} while (--i);
2283		*stringtabs = NULL;
2284
2285		/* stringtabs = vlabuf = d_stringtabs for later kfree */
2286		stringtabs = vla_ptr(vlabuf, d, stringtabs);
2287		t = vla_ptr(vlabuf, d, stringtab);
2288		s = vla_ptr(vlabuf, d, strings);
2289		strings = s;
2290	}
2291
2292	/* For each language */
2293	data += 16;
2294	len -= 16;
2295
2296	do { /* lang_count > 0 so we can use do-while */
2297		unsigned needed = needed_count;
2298
2299		if (unlikely(len < 3))
2300			goto error_free;
2301		t->language = get_unaligned_le16(data);
2302		t->strings  = s;
2303		++t;
2304
2305		data += 2;
2306		len -= 2;
2307
2308		/* For each string */
2309		do { /* str_count > 0 so we can use do-while */
2310			size_t length = strnlen(data, len);
2311
2312			if (unlikely(length == len))
2313				goto error_free;
2314
2315			/*
2316			 * User may provide more strings then we need,
2317			 * if that's the case we simply ignore the
2318			 * rest
2319			 */
2320			if (likely(needed)) {
2321				/*
2322				 * s->id will be set while adding
2323				 * function to configuration so for
2324				 * now just leave garbage here.
2325				 */
2326				s->s = data;
2327				--needed;
2328				++s;
2329			}
2330
2331			data += length + 1;
2332			len -= length + 1;
2333		} while (--str_count);
2334
2335		s->id = 0;   /* terminator */
2336		s->s = NULL;
2337		++s;
2338
2339	} while (--lang_count);
2340
2341	/* Some garbage left? */
2342	if (unlikely(len))
2343		goto error_free;
2344
2345	/* Done! */
2346	ffs->stringtabs = stringtabs;
2347	ffs->raw_strings = _data;
2348
2349	return 0;
2350
2351error_free:
2352	kfree(stringtabs);
2353error:
2354	kfree(_data);
2355	return -EINVAL;
2356}
2357
2358
2359/* Events handling and management *******************************************/
2360
2361static void __ffs_event_add(struct ffs_data *ffs,
2362			    enum usb_functionfs_event_type type)
2363{
2364	enum usb_functionfs_event_type rem_type1, rem_type2 = type;
2365	int neg = 0;
2366
2367	/*
2368	 * Abort any unhandled setup
2369	 *
2370	 * We do not need to worry about some cmpxchg() changing value
2371	 * of ffs->setup_state without holding the lock because when
2372	 * state is FFS_SETUP_PENDING cmpxchg() in several places in
2373	 * the source does nothing.
2374	 */
2375	if (ffs->setup_state == FFS_SETUP_PENDING)
2376		ffs->setup_state = FFS_SETUP_CANCELLED;
2377
2378	/*
2379	 * Logic of this function guarantees that there are at most four pending
2380	 * evens on ffs->ev.types queue.  This is important because the queue
2381	 * has space for four elements only and __ffs_ep0_read_events function
2382	 * depends on that limit as well.  If more event types are added, those
2383	 * limits have to be revisited or guaranteed to still hold.
2384	 */
2385	switch (type) {
2386	case FUNCTIONFS_RESUME:
2387		rem_type2 = FUNCTIONFS_SUSPEND;
2388		/* FALL THROUGH */
2389	case FUNCTIONFS_SUSPEND:
2390	case FUNCTIONFS_SETUP:
2391		rem_type1 = type;
2392		/* Discard all similar events */
2393		break;
2394
2395	case FUNCTIONFS_BIND:
2396	case FUNCTIONFS_UNBIND:
2397	case FUNCTIONFS_DISABLE:
2398	case FUNCTIONFS_ENABLE:
2399		/* Discard everything other then power management. */
2400		rem_type1 = FUNCTIONFS_SUSPEND;
2401		rem_type2 = FUNCTIONFS_RESUME;
2402		neg = 1;
2403		break;
2404
2405	default:
2406		WARN(1, "%d: unknown event, this should not happen\n", type);
2407		return;
2408	}
2409
2410	{
2411		u8 *ev  = ffs->ev.types, *out = ev;
2412		unsigned n = ffs->ev.count;
2413		for (; n; --n, ++ev)
2414			if ((*ev == rem_type1 || *ev == rem_type2) == neg)
2415				*out++ = *ev;
2416			else
2417				pr_vdebug("purging event %d\n", *ev);
2418		ffs->ev.count = out - ffs->ev.types;
2419	}
2420
2421	pr_vdebug("adding event %d\n", type);
2422	ffs->ev.types[ffs->ev.count++] = type;
2423	wake_up_locked(&ffs->ev.waitq);
2424	if (ffs->ffs_eventfd)
2425		eventfd_signal(ffs->ffs_eventfd, 1);
2426}
2427
2428static void ffs_event_add(struct ffs_data *ffs,
2429			  enum usb_functionfs_event_type type)
2430{
2431	unsigned long flags;
2432	spin_lock_irqsave(&ffs->ev.waitq.lock, flags);
2433	__ffs_event_add(ffs, type);
2434	spin_unlock_irqrestore(&ffs->ev.waitq.lock, flags);
2435}
2436
2437/* Bind/unbind USB function hooks *******************************************/
2438
2439static int ffs_ep_addr2idx(struct ffs_data *ffs, u8 endpoint_address)
2440{
2441	int i;
2442
2443	for (i = 1; i < ARRAY_SIZE(ffs->eps_addrmap); ++i)
2444		if (ffs->eps_addrmap[i] == endpoint_address)
2445			return i;
2446	return -ENOENT;
2447}
2448
2449static int __ffs_func_bind_do_descs(enum ffs_entity_type type, u8 *valuep,
2450				    struct usb_descriptor_header *desc,
2451				    void *priv)
2452{
2453	struct usb_endpoint_descriptor *ds = (void *)desc;
2454	struct ffs_function *func = priv;
2455	struct ffs_ep *ffs_ep;
2456	unsigned ep_desc_id;
2457	int idx;
2458	static const char *speed_names[] = { "full", "high", "super" };
2459
2460	if (type != FFS_DESCRIPTOR)
2461		return 0;
2462
2463	/*
2464	 * If ss_descriptors is not NULL, we are reading super speed
2465	 * descriptors; if hs_descriptors is not NULL, we are reading high
2466	 * speed descriptors; otherwise, we are reading full speed
2467	 * descriptors.
2468	 */
2469	if (func->function.ss_descriptors) {
2470		ep_desc_id = 2;
2471		func->function.ss_descriptors[(long)valuep] = desc;
2472	} else if (func->function.hs_descriptors) {
2473		ep_desc_id = 1;
2474		func->function.hs_descriptors[(long)valuep] = desc;
2475	} else {
2476		ep_desc_id = 0;
2477		func->function.fs_descriptors[(long)valuep]    = desc;
2478	}
2479
2480	if (!desc || desc->bDescriptorType != USB_DT_ENDPOINT)
2481		return 0;
2482
2483	idx = ffs_ep_addr2idx(func->ffs, ds->bEndpointAddress) - 1;
2484	if (idx < 0)
2485		return idx;
2486
2487	ffs_ep = func->eps + idx;
2488
2489	if (unlikely(ffs_ep->descs[ep_desc_id])) {
2490		pr_err("two %sspeed descriptors for EP %d\n",
2491			  speed_names[ep_desc_id],
2492			  ds->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK);
2493		return -EINVAL;
2494	}
2495	ffs_ep->descs[ep_desc_id] = ds;
2496
2497	ffs_dump_mem(": Original  ep desc", ds, ds->bLength);
2498	if (ffs_ep->ep) {
2499		ds->bEndpointAddress = ffs_ep->descs[0]->bEndpointAddress;
2500		if (!ds->wMaxPacketSize)
2501			ds->wMaxPacketSize = ffs_ep->descs[0]->wMaxPacketSize;
2502	} else {
2503		struct usb_request *req;
2504		struct usb_ep *ep;
2505		u8 bEndpointAddress;
 
2506
2507		/*
2508		 * We back up bEndpointAddress because autoconfig overwrites
2509		 * it with physical endpoint address.
2510		 */
2511		bEndpointAddress = ds->bEndpointAddress;
 
 
 
 
 
2512		pr_vdebug("autoconfig\n");
2513		ep = usb_ep_autoconfig(func->gadget, ds);
2514		if (unlikely(!ep))
2515			return -ENOTSUPP;
2516		ep->driver_data = func->eps + idx;
2517
2518		req = usb_ep_alloc_request(ep, GFP_KERNEL);
2519		if (unlikely(!req))
2520			return -ENOMEM;
2521
2522		ffs_ep->ep  = ep;
2523		ffs_ep->req = req;
2524		func->eps_revmap[ds->bEndpointAddress &
2525				 USB_ENDPOINT_NUMBER_MASK] = idx + 1;
2526		/*
2527		 * If we use virtual address mapping, we restore
2528		 * original bEndpointAddress value.
2529		 */
2530		if (func->ffs->user_flags & FUNCTIONFS_VIRTUAL_ADDR)
2531			ds->bEndpointAddress = bEndpointAddress;
 
 
 
 
 
2532	}
2533	ffs_dump_mem(": Rewritten ep desc", ds, ds->bLength);
2534
2535	return 0;
2536}
2537
2538static int __ffs_func_bind_do_nums(enum ffs_entity_type type, u8 *valuep,
2539				   struct usb_descriptor_header *desc,
2540				   void *priv)
2541{
2542	struct ffs_function *func = priv;
2543	unsigned idx;
2544	u8 newValue;
2545
2546	switch (type) {
2547	default:
2548	case FFS_DESCRIPTOR:
2549		/* Handled in previous pass by __ffs_func_bind_do_descs() */
2550		return 0;
2551
2552	case FFS_INTERFACE:
2553		idx = *valuep;
2554		if (func->interfaces_nums[idx] < 0) {
2555			int id = usb_interface_id(func->conf, &func->function);
2556			if (unlikely(id < 0))
2557				return id;
2558			func->interfaces_nums[idx] = id;
2559		}
2560		newValue = func->interfaces_nums[idx];
2561		break;
2562
2563	case FFS_STRING:
2564		/* String' IDs are allocated when fsf_data is bound to cdev */
2565		newValue = func->ffs->stringtabs[0]->strings[*valuep - 1].id;
2566		break;
2567
2568	case FFS_ENDPOINT:
2569		/*
2570		 * USB_DT_ENDPOINT are handled in
2571		 * __ffs_func_bind_do_descs().
2572		 */
2573		if (desc->bDescriptorType == USB_DT_ENDPOINT)
2574			return 0;
2575
2576		idx = (*valuep & USB_ENDPOINT_NUMBER_MASK) - 1;
2577		if (unlikely(!func->eps[idx].ep))
2578			return -EINVAL;
2579
2580		{
2581			struct usb_endpoint_descriptor **descs;
2582			descs = func->eps[idx].descs;
2583			newValue = descs[descs[0] ? 0 : 1]->bEndpointAddress;
2584		}
2585		break;
2586	}
2587
2588	pr_vdebug("%02x -> %02x\n", *valuep, newValue);
2589	*valuep = newValue;
2590	return 0;
2591}
2592
2593static int __ffs_func_bind_do_os_desc(enum ffs_os_desc_type type,
2594				      struct usb_os_desc_header *h, void *data,
2595				      unsigned len, void *priv)
2596{
2597	struct ffs_function *func = priv;
2598	u8 length = 0;
2599
2600	switch (type) {
2601	case FFS_OS_DESC_EXT_COMPAT: {
2602		struct usb_ext_compat_desc *desc = data;
2603		struct usb_os_desc_table *t;
2604
2605		t = &func->function.os_desc_table[desc->bFirstInterfaceNumber];
2606		t->if_id = func->interfaces_nums[desc->bFirstInterfaceNumber];
2607		memcpy(t->os_desc->ext_compat_id, &desc->CompatibleID,
2608		       ARRAY_SIZE(desc->CompatibleID) +
2609		       ARRAY_SIZE(desc->SubCompatibleID));
2610		length = sizeof(*desc);
2611	}
2612		break;
2613	case FFS_OS_DESC_EXT_PROP: {
2614		struct usb_ext_prop_desc *desc = data;
2615		struct usb_os_desc_table *t;
2616		struct usb_os_desc_ext_prop *ext_prop;
2617		char *ext_prop_name;
2618		char *ext_prop_data;
2619
2620		t = &func->function.os_desc_table[h->interface];
2621		t->if_id = func->interfaces_nums[h->interface];
2622
2623		ext_prop = func->ffs->ms_os_descs_ext_prop_avail;
2624		func->ffs->ms_os_descs_ext_prop_avail += sizeof(*ext_prop);
2625
2626		ext_prop->type = le32_to_cpu(desc->dwPropertyDataType);
2627		ext_prop->name_len = le16_to_cpu(desc->wPropertyNameLength);
2628		ext_prop->data_len = le32_to_cpu(*(u32 *)
2629			usb_ext_prop_data_len_ptr(data, ext_prop->name_len));
2630		length = ext_prop->name_len + ext_prop->data_len + 14;
2631
2632		ext_prop_name = func->ffs->ms_os_descs_ext_prop_name_avail;
2633		func->ffs->ms_os_descs_ext_prop_name_avail +=
2634			ext_prop->name_len;
2635
2636		ext_prop_data = func->ffs->ms_os_descs_ext_prop_data_avail;
2637		func->ffs->ms_os_descs_ext_prop_data_avail +=
2638			ext_prop->data_len;
2639		memcpy(ext_prop_data,
2640		       usb_ext_prop_data_ptr(data, ext_prop->name_len),
2641		       ext_prop->data_len);
2642		/* unicode data reported to the host as "WCHAR"s */
2643		switch (ext_prop->type) {
2644		case USB_EXT_PROP_UNICODE:
2645		case USB_EXT_PROP_UNICODE_ENV:
2646		case USB_EXT_PROP_UNICODE_LINK:
2647		case USB_EXT_PROP_UNICODE_MULTI:
2648			ext_prop->data_len *= 2;
2649			break;
2650		}
2651		ext_prop->data = ext_prop_data;
2652
2653		memcpy(ext_prop_name, usb_ext_prop_name_ptr(data),
2654		       ext_prop->name_len);
2655		/* property name reported to the host as "WCHAR"s */
2656		ext_prop->name_len *= 2;
2657		ext_prop->name = ext_prop_name;
2658
2659		t->os_desc->ext_prop_len +=
2660			ext_prop->name_len + ext_prop->data_len + 14;
2661		++t->os_desc->ext_prop_count;
2662		list_add_tail(&ext_prop->entry, &t->os_desc->ext_prop);
2663	}
2664		break;
2665	default:
2666		pr_vdebug("unknown descriptor: %d\n", type);
2667	}
2668
2669	return length;
2670}
2671
2672static inline struct f_fs_opts *ffs_do_functionfs_bind(struct usb_function *f,
2673						struct usb_configuration *c)
2674{
2675	struct ffs_function *func = ffs_func_from_usb(f);
2676	struct f_fs_opts *ffs_opts =
2677		container_of(f->fi, struct f_fs_opts, func_inst);
2678	int ret;
2679
2680	ENTER();
2681
2682	/*
2683	 * Legacy gadget triggers binding in functionfs_ready_callback,
2684	 * which already uses locking; taking the same lock here would
2685	 * cause a deadlock.
2686	 *
2687	 * Configfs-enabled gadgets however do need ffs_dev_lock.
2688	 */
2689	if (!ffs_opts->no_configfs)
2690		ffs_dev_lock();
2691	ret = ffs_opts->dev->desc_ready ? 0 : -ENODEV;
2692	func->ffs = ffs_opts->dev->ffs_data;
2693	if (!ffs_opts->no_configfs)
2694		ffs_dev_unlock();
2695	if (ret)
2696		return ERR_PTR(ret);
2697
2698	func->conf = c;
2699	func->gadget = c->cdev->gadget;
2700
2701	/*
2702	 * in drivers/usb/gadget/configfs.c:configfs_composite_bind()
2703	 * configurations are bound in sequence with list_for_each_entry,
2704	 * in each configuration its functions are bound in sequence
2705	 * with list_for_each_entry, so we assume no race condition
2706	 * with regard to ffs_opts->bound access
2707	 */
2708	if (!ffs_opts->refcnt) {
2709		ret = functionfs_bind(func->ffs, c->cdev);
2710		if (ret)
2711			return ERR_PTR(ret);
2712	}
2713	ffs_opts->refcnt++;
2714	func->function.strings = func->ffs->stringtabs;
2715
2716	return ffs_opts;
2717}
2718
2719static int _ffs_func_bind(struct usb_configuration *c,
2720			  struct usb_function *f)
2721{
2722	struct ffs_function *func = ffs_func_from_usb(f);
2723	struct ffs_data *ffs = func->ffs;
2724
2725	const int full = !!func->ffs->fs_descs_count;
2726	const int high = gadget_is_dualspeed(func->gadget) &&
2727		func->ffs->hs_descs_count;
2728	const int super = gadget_is_superspeed(func->gadget) &&
2729		func->ffs->ss_descs_count;
2730
2731	int fs_len, hs_len, ss_len, ret, i;
 
2732
2733	/* Make it a single chunk, less management later on */
2734	vla_group(d);
2735	vla_item_with_sz(d, struct ffs_ep, eps, ffs->eps_count);
2736	vla_item_with_sz(d, struct usb_descriptor_header *, fs_descs,
2737		full ? ffs->fs_descs_count + 1 : 0);
2738	vla_item_with_sz(d, struct usb_descriptor_header *, hs_descs,
2739		high ? ffs->hs_descs_count + 1 : 0);
2740	vla_item_with_sz(d, struct usb_descriptor_header *, ss_descs,
2741		super ? ffs->ss_descs_count + 1 : 0);
2742	vla_item_with_sz(d, short, inums, ffs->interfaces_count);
2743	vla_item_with_sz(d, struct usb_os_desc_table, os_desc_table,
2744			 c->cdev->use_os_string ? ffs->interfaces_count : 0);
2745	vla_item_with_sz(d, char[16], ext_compat,
2746			 c->cdev->use_os_string ? ffs->interfaces_count : 0);
2747	vla_item_with_sz(d, struct usb_os_desc, os_desc,
2748			 c->cdev->use_os_string ? ffs->interfaces_count : 0);
2749	vla_item_with_sz(d, struct usb_os_desc_ext_prop, ext_prop,
2750			 ffs->ms_os_descs_ext_prop_count);
2751	vla_item_with_sz(d, char, ext_prop_name,
2752			 ffs->ms_os_descs_ext_prop_name_len);
2753	vla_item_with_sz(d, char, ext_prop_data,
2754			 ffs->ms_os_descs_ext_prop_data_len);
2755	vla_item_with_sz(d, char, raw_descs, ffs->raw_descs_length);
2756	char *vlabuf;
2757
2758	ENTER();
2759
2760	/* Has descriptors only for speeds gadget does not support */
2761	if (unlikely(!(full | high | super)))
2762		return -ENOTSUPP;
2763
2764	/* Allocate a single chunk, less management later on */
2765	vlabuf = kzalloc(vla_group_size(d), GFP_KERNEL);
2766	if (unlikely(!vlabuf))
2767		return -ENOMEM;
2768
2769	ffs->ms_os_descs_ext_prop_avail = vla_ptr(vlabuf, d, ext_prop);
2770	ffs->ms_os_descs_ext_prop_name_avail =
2771		vla_ptr(vlabuf, d, ext_prop_name);
2772	ffs->ms_os_descs_ext_prop_data_avail =
2773		vla_ptr(vlabuf, d, ext_prop_data);
2774
2775	/* Copy descriptors  */
2776	memcpy(vla_ptr(vlabuf, d, raw_descs), ffs->raw_descs,
2777	       ffs->raw_descs_length);
2778
2779	memset(vla_ptr(vlabuf, d, inums), 0xff, d_inums__sz);
2780	for (ret = ffs->eps_count; ret; --ret) {
2781		struct ffs_ep *ptr;
2782
2783		ptr = vla_ptr(vlabuf, d, eps);
2784		ptr[ret].num = -1;
2785	}
2786
2787	/* Save pointers
2788	 * d_eps == vlabuf, func->eps used to kfree vlabuf later
2789	*/
2790	func->eps             = vla_ptr(vlabuf, d, eps);
2791	func->interfaces_nums = vla_ptr(vlabuf, d, inums);
2792
2793	/*
2794	 * Go through all the endpoint descriptors and allocate
2795	 * endpoints first, so that later we can rewrite the endpoint
2796	 * numbers without worrying that it may be described later on.
2797	 */
2798	if (likely(full)) {
2799		func->function.fs_descriptors = vla_ptr(vlabuf, d, fs_descs);
2800		fs_len = ffs_do_descs(ffs->fs_descs_count,
2801				      vla_ptr(vlabuf, d, raw_descs),
2802				      d_raw_descs__sz,
2803				      __ffs_func_bind_do_descs, func);
2804		if (unlikely(fs_len < 0)) {
2805			ret = fs_len;
2806			goto error;
2807		}
2808	} else {
2809		fs_len = 0;
2810	}
2811
2812	if (likely(high)) {
2813		func->function.hs_descriptors = vla_ptr(vlabuf, d, hs_descs);
2814		hs_len = ffs_do_descs(ffs->hs_descs_count,
2815				      vla_ptr(vlabuf, d, raw_descs) + fs_len,
2816				      d_raw_descs__sz - fs_len,
2817				      __ffs_func_bind_do_descs, func);
2818		if (unlikely(hs_len < 0)) {
2819			ret = hs_len;
2820			goto error;
2821		}
2822	} else {
2823		hs_len = 0;
2824	}
2825
2826	if (likely(super)) {
2827		func->function.ss_descriptors = vla_ptr(vlabuf, d, ss_descs);
2828		ss_len = ffs_do_descs(ffs->ss_descs_count,
2829				vla_ptr(vlabuf, d, raw_descs) + fs_len + hs_len,
2830				d_raw_descs__sz - fs_len - hs_len,
2831				__ffs_func_bind_do_descs, func);
2832		if (unlikely(ss_len < 0)) {
2833			ret = ss_len;
2834			goto error;
2835		}
2836	} else {
2837		ss_len = 0;
2838	}
2839
2840	/*
2841	 * Now handle interface numbers allocation and interface and
2842	 * endpoint numbers rewriting.  We can do that in one go
2843	 * now.
2844	 */
2845	ret = ffs_do_descs(ffs->fs_descs_count +
2846			   (high ? ffs->hs_descs_count : 0) +
2847			   (super ? ffs->ss_descs_count : 0),
2848			   vla_ptr(vlabuf, d, raw_descs), d_raw_descs__sz,
2849			   __ffs_func_bind_do_nums, func);
2850	if (unlikely(ret < 0))
2851		goto error;
2852
2853	func->function.os_desc_table = vla_ptr(vlabuf, d, os_desc_table);
2854	if (c->cdev->use_os_string)
2855		for (i = 0; i < ffs->interfaces_count; ++i) {
2856			struct usb_os_desc *desc;
2857
2858			desc = func->function.os_desc_table[i].os_desc =
2859				vla_ptr(vlabuf, d, os_desc) +
2860				i * sizeof(struct usb_os_desc);
2861			desc->ext_compat_id =
2862				vla_ptr(vlabuf, d, ext_compat) + i * 16;
2863			INIT_LIST_HEAD(&desc->ext_prop);
2864		}
2865	ret = ffs_do_os_descs(ffs->ms_os_descs_count,
2866			      vla_ptr(vlabuf, d, raw_descs) +
2867			      fs_len + hs_len + ss_len,
2868			      d_raw_descs__sz - fs_len - hs_len - ss_len,
2869			      __ffs_func_bind_do_os_desc, func);
2870	if (unlikely(ret < 0))
2871		goto error;
 
 
2872	func->function.os_desc_n =
2873		c->cdev->use_os_string ? ffs->interfaces_count : 0;
2874
2875	/* And we're done */
2876	ffs_event_add(ffs, FUNCTIONFS_BIND);
2877	return 0;
2878
2879error:
2880	/* XXX Do we need to release all claimed endpoints here? */
2881	return ret;
2882}
2883
2884static int ffs_func_bind(struct usb_configuration *c,
2885			 struct usb_function *f)
2886{
2887	struct f_fs_opts *ffs_opts = ffs_do_functionfs_bind(f, c);
2888	struct ffs_function *func = ffs_func_from_usb(f);
2889	int ret;
2890
2891	if (IS_ERR(ffs_opts))
2892		return PTR_ERR(ffs_opts);
2893
2894	ret = _ffs_func_bind(c, f);
2895	if (ret && !--ffs_opts->refcnt)
2896		functionfs_unbind(func->ffs);
2897
2898	return ret;
2899}
2900
2901
2902/* Other USB function hooks *************************************************/
2903
2904static void ffs_reset_work(struct work_struct *work)
2905{
2906	struct ffs_data *ffs = container_of(work,
2907		struct ffs_data, reset_work);
2908	ffs_data_reset(ffs);
2909}
2910
2911static int ffs_func_set_alt(struct usb_function *f,
2912			    unsigned interface, unsigned alt)
2913{
2914	struct ffs_function *func = ffs_func_from_usb(f);
2915	struct ffs_data *ffs = func->ffs;
2916	int ret = 0, intf;
2917
2918	if (alt != (unsigned)-1) {
2919		intf = ffs_func_revmap_intf(func, interface);
2920		if (unlikely(intf < 0))
2921			return intf;
2922	}
2923
2924	if (ffs->func)
2925		ffs_func_eps_disable(ffs->func);
2926
2927	if (ffs->state == FFS_DEACTIVATED) {
2928		ffs->state = FFS_CLOSING;
2929		INIT_WORK(&ffs->reset_work, ffs_reset_work);
2930		schedule_work(&ffs->reset_work);
2931		return -ENODEV;
2932	}
2933
2934	if (ffs->state != FFS_ACTIVE)
2935		return -ENODEV;
2936
2937	if (alt == (unsigned)-1) {
2938		ffs->func = NULL;
2939		ffs_event_add(ffs, FUNCTIONFS_DISABLE);
2940		return 0;
2941	}
2942
2943	ffs->func = func;
2944	ret = ffs_func_eps_enable(func);
2945	if (likely(ret >= 0))
2946		ffs_event_add(ffs, FUNCTIONFS_ENABLE);
2947	return ret;
2948}
2949
2950static void ffs_func_disable(struct usb_function *f)
2951{
2952	ffs_func_set_alt(f, 0, (unsigned)-1);
2953}
2954
2955static int ffs_func_setup(struct usb_function *f,
2956			  const struct usb_ctrlrequest *creq)
2957{
2958	struct ffs_function *func = ffs_func_from_usb(f);
2959	struct ffs_data *ffs = func->ffs;
2960	unsigned long flags;
2961	int ret;
2962
2963	ENTER();
2964
2965	pr_vdebug("creq->bRequestType = %02x\n", creq->bRequestType);
2966	pr_vdebug("creq->bRequest     = %02x\n", creq->bRequest);
2967	pr_vdebug("creq->wValue       = %04x\n", le16_to_cpu(creq->wValue));
2968	pr_vdebug("creq->wIndex       = %04x\n", le16_to_cpu(creq->wIndex));
2969	pr_vdebug("creq->wLength      = %04x\n", le16_to_cpu(creq->wLength));
2970
2971	/*
2972	 * Most requests directed to interface go through here
2973	 * (notable exceptions are set/get interface) so we need to
2974	 * handle them.  All other either handled by composite or
2975	 * passed to usb_configuration->setup() (if one is set).  No
2976	 * matter, we will handle requests directed to endpoint here
2977	 * as well (as it's straightforward) but what to do with any
2978	 * other request?
 
2979	 */
2980	if (ffs->state != FFS_ACTIVE)
2981		return -ENODEV;
2982
2983	switch (creq->bRequestType & USB_RECIP_MASK) {
2984	case USB_RECIP_INTERFACE:
2985		ret = ffs_func_revmap_intf(func, le16_to_cpu(creq->wIndex));
2986		if (unlikely(ret < 0))
2987			return ret;
2988		break;
2989
2990	case USB_RECIP_ENDPOINT:
2991		ret = ffs_func_revmap_ep(func, le16_to_cpu(creq->wIndex));
2992		if (unlikely(ret < 0))
2993			return ret;
2994		if (func->ffs->user_flags & FUNCTIONFS_VIRTUAL_ADDR)
2995			ret = func->ffs->eps_addrmap[ret];
2996		break;
2997
2998	default:
2999		return -EOPNOTSUPP;
 
 
 
3000	}
3001
3002	spin_lock_irqsave(&ffs->ev.waitq.lock, flags);
3003	ffs->ev.setup = *creq;
3004	ffs->ev.setup.wIndex = cpu_to_le16(ret);
3005	__ffs_event_add(ffs, FUNCTIONFS_SETUP);
3006	spin_unlock_irqrestore(&ffs->ev.waitq.lock, flags);
3007
3008	return 0;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3009}
3010
3011static void ffs_func_suspend(struct usb_function *f)
3012{
3013	ENTER();
3014	ffs_event_add(ffs_func_from_usb(f)->ffs, FUNCTIONFS_SUSPEND);
3015}
3016
3017static void ffs_func_resume(struct usb_function *f)
3018{
3019	ENTER();
3020	ffs_event_add(ffs_func_from_usb(f)->ffs, FUNCTIONFS_RESUME);
3021}
3022
3023
3024/* Endpoint and interface numbers reverse mapping ***************************/
3025
3026static int ffs_func_revmap_ep(struct ffs_function *func, u8 num)
3027{
3028	num = func->eps_revmap[num & USB_ENDPOINT_NUMBER_MASK];
3029	return num ? num : -EDOM;
3030}
3031
3032static int ffs_func_revmap_intf(struct ffs_function *func, u8 intf)
3033{
3034	short *nums = func->interfaces_nums;
3035	unsigned count = func->ffs->interfaces_count;
3036
3037	for (; count; --count, ++nums) {
3038		if (*nums >= 0 && *nums == intf)
3039			return nums - func->interfaces_nums;
3040	}
3041
3042	return -EDOM;
3043}
3044
3045
3046/* Devices management *******************************************************/
3047
3048static LIST_HEAD(ffs_devices);
3049
3050static struct ffs_dev *_ffs_do_find_dev(const char *name)
3051{
3052	struct ffs_dev *dev;
3053
 
 
 
3054	list_for_each_entry(dev, &ffs_devices, entry) {
3055		if (!dev->name || !name)
3056			continue;
3057		if (strcmp(dev->name, name) == 0)
3058			return dev;
3059	}
3060
3061	return NULL;
3062}
3063
3064/*
3065 * ffs_lock must be taken by the caller of this function
3066 */
3067static struct ffs_dev *_ffs_get_single_dev(void)
3068{
3069	struct ffs_dev *dev;
3070
3071	if (list_is_singular(&ffs_devices)) {
3072		dev = list_first_entry(&ffs_devices, struct ffs_dev, entry);
3073		if (dev->single)
3074			return dev;
3075	}
3076
3077	return NULL;
3078}
3079
3080/*
3081 * ffs_lock must be taken by the caller of this function
3082 */
3083static struct ffs_dev *_ffs_find_dev(const char *name)
3084{
3085	struct ffs_dev *dev;
3086
3087	dev = _ffs_get_single_dev();
3088	if (dev)
3089		return dev;
3090
3091	return _ffs_do_find_dev(name);
3092}
3093
3094/* Configfs support *********************************************************/
3095
3096static inline struct f_fs_opts *to_ffs_opts(struct config_item *item)
3097{
3098	return container_of(to_config_group(item), struct f_fs_opts,
3099			    func_inst.group);
3100}
3101
3102static void ffs_attr_release(struct config_item *item)
3103{
3104	struct f_fs_opts *opts = to_ffs_opts(item);
3105
3106	usb_put_function_instance(&opts->func_inst);
3107}
3108
3109static struct configfs_item_operations ffs_item_ops = {
3110	.release	= ffs_attr_release,
3111};
3112
3113static struct config_item_type ffs_func_type = {
3114	.ct_item_ops	= &ffs_item_ops,
3115	.ct_owner	= THIS_MODULE,
3116};
3117
3118
3119/* Function registration interface ******************************************/
3120
3121static void ffs_free_inst(struct usb_function_instance *f)
3122{
3123	struct f_fs_opts *opts;
3124
3125	opts = to_f_fs_opts(f);
3126	ffs_dev_lock();
3127	_ffs_free_dev(opts->dev);
3128	ffs_dev_unlock();
3129	kfree(opts);
3130}
3131
3132#define MAX_INST_NAME_LEN	40
3133
3134static int ffs_set_inst_name(struct usb_function_instance *fi, const char *name)
3135{
3136	struct f_fs_opts *opts;
3137	char *ptr;
3138	const char *tmp;
3139	int name_len, ret;
3140
3141	name_len = strlen(name) + 1;
3142	if (name_len > MAX_INST_NAME_LEN)
3143		return -ENAMETOOLONG;
3144
3145	ptr = kstrndup(name, name_len, GFP_KERNEL);
3146	if (!ptr)
3147		return -ENOMEM;
3148
3149	opts = to_f_fs_opts(fi);
3150	tmp = NULL;
3151
3152	ffs_dev_lock();
3153
3154	tmp = opts->dev->name_allocated ? opts->dev->name : NULL;
3155	ret = _ffs_name_dev(opts->dev, ptr);
3156	if (ret) {
3157		kfree(ptr);
3158		ffs_dev_unlock();
3159		return ret;
3160	}
3161	opts->dev->name_allocated = true;
3162
3163	ffs_dev_unlock();
3164
3165	kfree(tmp);
3166
3167	return 0;
3168}
3169
3170static struct usb_function_instance *ffs_alloc_inst(void)
3171{
3172	struct f_fs_opts *opts;
3173	struct ffs_dev *dev;
3174
3175	opts = kzalloc(sizeof(*opts), GFP_KERNEL);
3176	if (!opts)
3177		return ERR_PTR(-ENOMEM);
3178
3179	opts->func_inst.set_inst_name = ffs_set_inst_name;
3180	opts->func_inst.free_func_inst = ffs_free_inst;
3181	ffs_dev_lock();
3182	dev = _ffs_alloc_dev();
3183	ffs_dev_unlock();
3184	if (IS_ERR(dev)) {
3185		kfree(opts);
3186		return ERR_CAST(dev);
3187	}
3188	opts->dev = dev;
3189	dev->opts = opts;
3190
3191	config_group_init_type_name(&opts->func_inst.group, "",
3192				    &ffs_func_type);
3193	return &opts->func_inst;
3194}
3195
3196static void ffs_free(struct usb_function *f)
3197{
3198	kfree(ffs_func_from_usb(f));
3199}
3200
3201static void ffs_func_unbind(struct usb_configuration *c,
3202			    struct usb_function *f)
3203{
3204	struct ffs_function *func = ffs_func_from_usb(f);
3205	struct ffs_data *ffs = func->ffs;
3206	struct f_fs_opts *opts =
3207		container_of(f->fi, struct f_fs_opts, func_inst);
3208	struct ffs_ep *ep = func->eps;
3209	unsigned count = ffs->eps_count;
3210	unsigned long flags;
3211
3212	ENTER();
3213	if (ffs->func == func) {
3214		ffs_func_eps_disable(func);
3215		ffs->func = NULL;
3216	}
3217
3218	if (!--opts->refcnt)
3219		functionfs_unbind(ffs);
3220
3221	/* cleanup after autoconfig */
3222	spin_lock_irqsave(&func->ffs->eps_lock, flags);
3223	do {
3224		if (ep->ep && ep->req)
3225			usb_ep_free_request(ep->ep, ep->req);
3226		ep->req = NULL;
3227		++ep;
3228	} while (--count);
3229	spin_unlock_irqrestore(&func->ffs->eps_lock, flags);
3230	kfree(func->eps);
3231	func->eps = NULL;
3232	/*
3233	 * eps, descriptors and interfaces_nums are allocated in the
3234	 * same chunk so only one free is required.
3235	 */
3236	func->function.fs_descriptors = NULL;
3237	func->function.hs_descriptors = NULL;
3238	func->function.ss_descriptors = NULL;
3239	func->interfaces_nums = NULL;
3240
3241	ffs_event_add(ffs, FUNCTIONFS_UNBIND);
3242}
3243
3244static struct usb_function *ffs_alloc(struct usb_function_instance *fi)
3245{
3246	struct ffs_function *func;
3247
3248	ENTER();
3249
3250	func = kzalloc(sizeof(*func), GFP_KERNEL);
3251	if (unlikely(!func))
3252		return ERR_PTR(-ENOMEM);
3253
3254	func->function.name    = "Function FS Gadget";
3255
3256	func->function.bind    = ffs_func_bind;
3257	func->function.unbind  = ffs_func_unbind;
3258	func->function.set_alt = ffs_func_set_alt;
3259	func->function.disable = ffs_func_disable;
3260	func->function.setup   = ffs_func_setup;
 
3261	func->function.suspend = ffs_func_suspend;
3262	func->function.resume  = ffs_func_resume;
3263	func->function.free_func = ffs_free;
3264
3265	return &func->function;
3266}
3267
3268/*
3269 * ffs_lock must be taken by the caller of this function
3270 */
3271static struct ffs_dev *_ffs_alloc_dev(void)
3272{
3273	struct ffs_dev *dev;
3274	int ret;
3275
3276	if (_ffs_get_single_dev())
3277			return ERR_PTR(-EBUSY);
3278
3279	dev = kzalloc(sizeof(*dev), GFP_KERNEL);
3280	if (!dev)
3281		return ERR_PTR(-ENOMEM);
3282
3283	if (list_empty(&ffs_devices)) {
3284		ret = functionfs_init();
3285		if (ret) {
3286			kfree(dev);
3287			return ERR_PTR(ret);
3288		}
3289	}
3290
3291	list_add(&dev->entry, &ffs_devices);
3292
3293	return dev;
3294}
3295
3296/*
3297 * ffs_lock must be taken by the caller of this function
3298 * The caller is responsible for "name" being available whenever f_fs needs it
3299 */
3300static int _ffs_name_dev(struct ffs_dev *dev, const char *name)
3301{
3302	struct ffs_dev *existing;
 
3303
3304	existing = _ffs_do_find_dev(name);
3305	if (existing)
3306		return -EBUSY;
3307
3308	dev->name = name;
3309
3310	return 0;
3311}
3312
3313/*
3314 * The caller is responsible for "name" being available whenever f_fs needs it
3315 */
3316int ffs_name_dev(struct ffs_dev *dev, const char *name)
3317{
3318	int ret;
3319
3320	ffs_dev_lock();
3321	ret = _ffs_name_dev(dev, name);
3322	ffs_dev_unlock();
3323
3324	return ret;
3325}
3326EXPORT_SYMBOL_GPL(ffs_name_dev);
3327
3328int ffs_single_dev(struct ffs_dev *dev)
3329{
3330	int ret;
3331
3332	ret = 0;
3333	ffs_dev_lock();
3334
3335	if (!list_is_singular(&ffs_devices))
3336		ret = -EBUSY;
3337	else
3338		dev->single = true;
3339
3340	ffs_dev_unlock();
3341	return ret;
3342}
3343EXPORT_SYMBOL_GPL(ffs_single_dev);
3344
3345/*
3346 * ffs_lock must be taken by the caller of this function
3347 */
3348static void _ffs_free_dev(struct ffs_dev *dev)
3349{
3350	list_del(&dev->entry);
3351	if (dev->name_allocated)
3352		kfree(dev->name);
 
 
 
3353	kfree(dev);
3354	if (list_empty(&ffs_devices))
3355		functionfs_cleanup();
3356}
3357
3358static void *ffs_acquire_dev(const char *dev_name)
3359{
3360	struct ffs_dev *ffs_dev;
3361
3362	ENTER();
3363	ffs_dev_lock();
3364
3365	ffs_dev = _ffs_find_dev(dev_name);
3366	if (!ffs_dev)
3367		ffs_dev = ERR_PTR(-ENOENT);
3368	else if (ffs_dev->mounted)
3369		ffs_dev = ERR_PTR(-EBUSY);
3370	else if (ffs_dev->ffs_acquire_dev_callback &&
3371	    ffs_dev->ffs_acquire_dev_callback(ffs_dev))
3372		ffs_dev = ERR_PTR(-ENOENT);
3373	else
3374		ffs_dev->mounted = true;
3375
3376	ffs_dev_unlock();
3377	return ffs_dev;
3378}
3379
3380static void ffs_release_dev(struct ffs_data *ffs_data)
3381{
3382	struct ffs_dev *ffs_dev;
3383
3384	ENTER();
3385	ffs_dev_lock();
3386
3387	ffs_dev = ffs_data->private_data;
3388	if (ffs_dev) {
3389		ffs_dev->mounted = false;
3390
3391		if (ffs_dev->ffs_release_dev_callback)
3392			ffs_dev->ffs_release_dev_callback(ffs_dev);
3393	}
3394
3395	ffs_dev_unlock();
3396}
3397
3398static int ffs_ready(struct ffs_data *ffs)
3399{
3400	struct ffs_dev *ffs_obj;
3401	int ret = 0;
3402
3403	ENTER();
3404	ffs_dev_lock();
3405
3406	ffs_obj = ffs->private_data;
3407	if (!ffs_obj) {
3408		ret = -EINVAL;
3409		goto done;
3410	}
3411	if (WARN_ON(ffs_obj->desc_ready)) {
3412		ret = -EBUSY;
3413		goto done;
3414	}
3415
3416	ffs_obj->desc_ready = true;
3417	ffs_obj->ffs_data = ffs;
3418
3419	if (ffs_obj->ffs_ready_callback) {
3420		ret = ffs_obj->ffs_ready_callback(ffs);
3421		if (ret)
3422			goto done;
3423	}
3424
3425	set_bit(FFS_FL_CALL_CLOSED_CALLBACK, &ffs->flags);
3426done:
3427	ffs_dev_unlock();
3428	return ret;
3429}
3430
3431static void ffs_closed(struct ffs_data *ffs)
3432{
3433	struct ffs_dev *ffs_obj;
3434	struct f_fs_opts *opts;
 
3435
3436	ENTER();
3437	ffs_dev_lock();
3438
3439	ffs_obj = ffs->private_data;
3440	if (!ffs_obj)
3441		goto done;
3442
3443	ffs_obj->desc_ready = false;
 
3444
3445	if (test_and_clear_bit(FFS_FL_CALL_CLOSED_CALLBACK, &ffs->flags) &&
3446	    ffs_obj->ffs_closed_callback)
3447		ffs_obj->ffs_closed_callback(ffs);
3448
3449	if (ffs_obj->opts)
3450		opts = ffs_obj->opts;
3451	else
3452		goto done;
3453
3454	if (opts->no_configfs || !opts->func_inst.group.cg_item.ci_parent
3455	    || !atomic_read(&opts->func_inst.group.cg_item.ci_kref.refcount))
3456		goto done;
3457
3458	unregister_gadget_item(ffs_obj->opts->
3459			       func_inst.group.cg_item.ci_parent->ci_parent);
 
 
 
 
3460done:
3461	ffs_dev_unlock();
3462}
3463
3464/* Misc helper functions ****************************************************/
3465
3466static int ffs_mutex_lock(struct mutex *mutex, unsigned nonblock)
3467{
3468	return nonblock
3469		? likely(mutex_trylock(mutex)) ? 0 : -EAGAIN
3470		: mutex_lock_interruptible(mutex);
3471}
3472
3473static char *ffs_prepare_buffer(const char __user *buf, size_t len)
3474{
3475	char *data;
3476
3477	if (unlikely(!len))
3478		return NULL;
3479
3480	data = kmalloc(len, GFP_KERNEL);
3481	if (unlikely(!data))
3482		return ERR_PTR(-ENOMEM);
3483
3484	if (unlikely(copy_from_user(data, buf, len))) {
3485		kfree(data);
3486		return ERR_PTR(-EFAULT);
3487	}
3488
3489	pr_vdebug("Buffer from user space:\n");
3490	ffs_dump_mem("", data, len);
3491
3492	return data;
3493}
3494
3495DECLARE_USB_FUNCTION_INIT(ffs, ffs_alloc_inst, ffs_alloc);
3496MODULE_LICENSE("GPL");
3497MODULE_AUTHOR("Michal Nazarewicz");