source: src/linux/universal/linux-3.18/drivers/usb/gadget/function/f_fs.c @ 31869

Last change on this file since 31869 was 31869, checked in by brainslayer, 6 weeks ago

update

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