1 files changed, 274 insertions, 90 deletions

diff --git a/drivers/usb/gadget/function/f_midi.c b/drivers/usb/gadget/function/f_midi.c
index 807b31c0edc3..a90440300735 100644
--- a/drivers/usb/gadget/function/f_midi.c
+++ b/drivers/usb/gadget/function/f_midi.c
@@ -20,6 +20,7 @@
  */
 
 #include <linux/kernel.h>
+#include <linux/module.h>
 #include <linux/slab.h>
 #include <linux/device.h>
 
@@ -33,6 +34,7 @@
 #include <linux/usb/midi.h>
 
 #include "u_f.h"
+#include "u_midi.h"
 
 MODULE_AUTHOR("Ben Williamson");
 MODULE_LICENSE("GPL v2");
@@ -99,7 +101,7 @@ DECLARE_USB_MIDI_OUT_JACK_DESCRIPTOR(1);
 DECLARE_USB_MS_ENDPOINT_DESCRIPTOR(16);
 
 /* B.3.1  Standard AC Interface Descriptor */
-static struct usb_interface_descriptor ac_interface_desc __initdata = {
+static struct usb_interface_descriptor ac_interface_desc = {
         .bLength =              USB_DT_INTERFACE_SIZE,
         .bDescriptorType =      USB_DT_INTERFACE,
         /* .bInterfaceNumber =  DYNAMIC */
@@ -110,7 +112,7 @@ static struct usb_interface_descriptor ac_interface_desc __initdata = {
 };
 
 /* B.3.2  Class-Specific AC Interface Descriptor */
-static struct uac1_ac_header_descriptor_1 ac_header_desc __initdata = {
+static struct uac1_ac_header_descriptor_1 ac_header_desc = {
         .bLength =              UAC_DT_AC_HEADER_SIZE(1),
         .bDescriptorType =      USB_DT_CS_INTERFACE,
         .bDescriptorSubtype =   USB_MS_HEADER,
@@ -121,7 +123,7 @@ static struct uac1_ac_header_descriptor_1 ac_header_desc __initdata = {
 };
 
 /* B.4.1  Standard MS Interface Descriptor */
-static struct usb_interface_descriptor ms_interface_desc __initdata = {
+static struct usb_interface_descriptor ms_interface_desc = {
         .bLength =              USB_DT_INTERFACE_SIZE,
         .bDescriptorType =      USB_DT_INTERFACE,
         /* .bInterfaceNumber =  DYNAMIC */
@@ -132,7 +134,7 @@ static struct usb_interface_descriptor ms_interface_desc __initdata = {
 };
 
 /* B.4.2  Class-Specific MS Interface Descriptor */
-static struct usb_ms_header_descriptor ms_header_desc __initdata = {
+static struct usb_ms_header_descriptor ms_header_desc = {
         .bLength =              USB_DT_MS_HEADER_SIZE,
         .bDescriptorType =      USB_DT_CS_INTERFACE,
         .bDescriptorSubtype =   USB_MS_HEADER,
@@ -387,29 +389,6 @@ static void f_midi_disable(struct usb_function *f)
         usb_ep_disable(midi->out_ep);
 }
 
-static void f_midi_unbind(struct usb_configuration *c, struct usb_function *f)
-{
-        struct usb_composite_dev *cdev = f->config->cdev;
-        struct f_midi *midi = func_to_midi(f);
-        struct snd_card *card;
-
-        DBG(cdev, "unbind\n");
-
-        /* just to be sure */
-        f_midi_disable(f);
-
-        card = midi->card;
-        midi->card = NULL;
-        if (card)
-                snd_card_free(card);
-
-        kfree(midi->id);
-        midi->id = NULL;
-
-        usb_free_all_descriptors(f);
-        kfree(midi);
-}
-
 static int f_midi_snd_free(struct snd_device *device)
 {
         return 0;
@@ -654,6 +633,14 @@ static struct snd_rawmidi_ops gmidi_out_ops = {
         .trigger = f_midi_out_trigger
 };
 
+static inline void f_midi_unregister_card(struct f_midi *midi)
+{
+        if (midi->card) {
+                snd_card_free(midi->card);
+                midi->card = NULL;
+        }
+}
+
 /* register as a sound "card" */
 static int f_midi_register_card(struct f_midi *midi)
 {
@@ -715,17 +702,13 @@ static int f_midi_register_card(struct f_midi *midi)
         return 0;
 
 fail:
-        if (midi->card) {
-                snd_card_free(midi->card);
-                midi->card = NULL;
-        }
+        f_midi_unregister_card(midi);
         return err;
 }
 
 /* MIDI function driver setup/binding */
 
-static int __init
-f_midi_bind(struct usb_configuration *c, struct usb_function *f)
+static int f_midi_bind(struct usb_configuration *c, struct usb_function *f)
 {
         struct usb_descriptor_header **midi_function;
         struct usb_midi_in_jack_descriptor jack_in_ext_desc[MAX_PORTS];
@@ -734,15 +717,23 @@ f_midi_bind(struct usb_configuration *c, struct usb_function *f)
         struct usb_midi_out_jack_descriptor_1 jack_out_emb_desc[MAX_PORTS];
         struct usb_composite_dev *cdev = c->cdev;
         struct f_midi *midi = func_to_midi(f);
+        struct usb_string *us;
         int status, n, jack = 1, i = 0;
 
+        midi->gadget = cdev->gadget;
+        tasklet_init(&midi->tasklet, f_midi_in_tasklet, (unsigned long) midi);
+        status = f_midi_register_card(midi);
+        if (status < 0)
+                goto fail_register;
+
         /* maybe allocate device-global string ID */
-        if (midi_string_defs[0].id == 0) {
-                status = usb_string_id(c->cdev);
-                if (status < 0)
-                        goto fail;
-                midi_string_defs[0].id = status;
+        us = usb_gstrings_attach(c->cdev, midi_strings,
+                                 ARRAY_SIZE(midi_string_defs));
+        if (IS_ERR(us)) {
+                status = PTR_ERR(us);
+                goto fail;
         }
+        ac_interface_desc.iInterface = us[STRING_FUNC_IDX].id;
 
         /* We have two interfaces, AudioControl and MIDIStreaming */
         status = usb_interface_id(c, f);
@@ -892,6 +883,8 @@ fail_f_midi:
         kfree(midi_function);
         usb_free_descriptors(f->hs_descriptors);
 fail:
+        f_midi_unregister_card(midi);
+fail_register:
         /* we might as well release our claims on endpoints */
         if (midi->out_ep)
                 midi->out_ep->driver_data = NULL;
@@ -903,42 +896,235 @@ fail:
         return status;
 }
 
-/**
- * f_midi_bind_config - add USB MIDI function to a configuration
- * @c: the configuration to supcard the USB audio function
- * @index: the soundcard index to use for the ALSA device creation
- * @id: the soundcard id to use for the ALSA device creation
- * @buflen: the buffer length to use
- * @qlen the number of read requests to pre-allocate
- * Context: single threaded during gadget setup
- *
- * Returns zero on success, else negative errno.
- */
-int __init f_midi_bind_config(struct usb_configuration *c,
-                              int index, char *id,
-                              unsigned int in_ports,
-                              unsigned int out_ports,
-                              unsigned int buflen,
-                              unsigned int qlen)
+static inline struct f_midi_opts *to_f_midi_opts(struct config_item *item)
+{
+        return container_of(to_config_group(item), struct f_midi_opts,
+                            func_inst.group);
+}
+
+CONFIGFS_ATTR_STRUCT(f_midi_opts);
+CONFIGFS_ATTR_OPS(f_midi_opts);
+
+static void midi_attr_release(struct config_item *item)
+{
+        struct f_midi_opts *opts = to_f_midi_opts(item);
+
+        usb_put_function_instance(&opts->func_inst);
+}
+
+static struct configfs_item_operations midi_item_ops = {
+        .release        = midi_attr_release,
+        .show_attribute = f_midi_opts_attr_show,
+        .store_attribute = f_midi_opts_attr_store,
+};
+
+#define F_MIDI_OPT(name, test_limit, limit)                             \
+static ssize_t f_midi_opts_##name##_show(struct f_midi_opts *opts, char *page) \
+{                                                                       \
+        int result;                                                     \
+                                                                        \
+        mutex_lock(&opts->lock);                                        \
+        result = sprintf(page, "%d\n", opts->name);                     \
+        mutex_unlock(&opts->lock);                                      \
+                                                                        \
+        return result;                                                  \
+}                                                                       \
+                                                                        \
+static ssize_t f_midi_opts_##name##_store(struct f_midi_opts *opts,     \
+                                         const char *page, size_t len)  \
+{                                                                       \
+        int ret;                                                        \
+        u32 num;                                                        \
+                                                                        \
+        mutex_lock(&opts->lock);                                        \
+        if (opts->refcnt) {                                             \
+                ret = -EBUSY;                                           \
+                goto end;                                               \
+        }                                                               \
+                                                                        \
+        ret = kstrtou32(page, 0, &num);                                 \
+        if (ret)                                                        \
+                goto end;                                               \
+                                                                        \
+        if (test_limit && num > limit) {                                \
+                ret = -EINVAL;                                          \
+                goto end;                                               \
+        }                                                               \
+        opts->name = num;                                               \
+        ret = len;                                                      \
+                                                                        \
+end:                                                                    \
+        mutex_unlock(&opts->lock);                                      \
+        return ret;                                                     \
+}                                                                       \
+                                                                        \
+static struct f_midi_opts_attribute f_midi_opts_##name =                \
+        __CONFIGFS_ATTR(name, S_IRUGO | S_IWUSR, f_midi_opts_##name##_show, \
+                        f_midi_opts_##name##_store)
+
+F_MIDI_OPT(index, true, SNDRV_CARDS);
+F_MIDI_OPT(buflen, false, 0);
+F_MIDI_OPT(qlen, false, 0);
+F_MIDI_OPT(in_ports, true, MAX_PORTS);
+F_MIDI_OPT(out_ports, true, MAX_PORTS);
+
+static ssize_t f_midi_opts_id_show(struct f_midi_opts *opts, char *page)
+{
+        int result;
+
+        mutex_lock(&opts->lock);
+        result = strlcpy(page, opts->id, PAGE_SIZE);
+        mutex_unlock(&opts->lock);
+
+        return result;
+}
+
+static ssize_t f_midi_opts_id_store(struct f_midi_opts *opts,
+                                    const char *page, size_t len)
+{
+        int ret;
+        char *c;
+
+        mutex_lock(&opts->lock);
+        if (opts->refcnt) {
+                ret = -EBUSY;
+                goto end;
+        }
+
+        c = kstrndup(page, len, GFP_KERNEL);
+        if (!c) {
+                ret = -ENOMEM;
+                goto end;
+        }
+        if (opts->id_allocated)
+                kfree(opts->id);
+        opts->id = c;
+        opts->id_allocated = true;
+        ret = len;
+end:
+        mutex_unlock(&opts->lock);
+        return ret;
+}
+
+static struct f_midi_opts_attribute f_midi_opts_id =
+        __CONFIGFS_ATTR(id, S_IRUGO | S_IWUSR, f_midi_opts_id_show,
+                        f_midi_opts_id_store);
+
+static struct configfs_attribute *midi_attrs[] = {
+        &f_midi_opts_index.attr,
+        &f_midi_opts_buflen.attr,
+        &f_midi_opts_qlen.attr,
+        &f_midi_opts_in_ports.attr,
+        &f_midi_opts_out_ports.attr,
+        &f_midi_opts_id.attr,
+        NULL,
+};
+
+static struct config_item_type midi_func_type = {
+        .ct_item_ops    = &midi_item_ops,
+        .ct_attrs       = midi_attrs,
+        .ct_owner       = THIS_MODULE,
+};
+
+static void f_midi_free_inst(struct usb_function_instance *f)
+{
+        struct f_midi_opts *opts;
+
+        opts = container_of(f, struct f_midi_opts, func_inst);
+
+        if (opts->id_allocated)
+                kfree(opts->id);
+
+        kfree(opts);
+}
+
+static struct usb_function_instance *f_midi_alloc_inst(void)
+{
+        struct f_midi_opts *opts;
+
+        opts = kzalloc(sizeof(*opts), GFP_KERNEL);
+        if (!opts)
+                return ERR_PTR(-ENOMEM);
+
+        mutex_init(&opts->lock);
+        opts->func_inst.free_func_inst = f_midi_free_inst;
+        opts->index = SNDRV_DEFAULT_IDX1;
+        opts->id = SNDRV_DEFAULT_STR1;
+        opts->buflen = 256;
+        opts->qlen = 32;
+        opts->in_ports = 1;
+        opts->out_ports = 1;
+
+        config_group_init_type_name(&opts->func_inst.group, "",
+                                    &midi_func_type);
+
+        return &opts->func_inst;
+}
+
+static void f_midi_free(struct usb_function *f)
+{
+        struct f_midi *midi;
+        struct f_midi_opts *opts;
+        int i;
+
+        midi = func_to_midi(f);
+        opts = container_of(f->fi, struct f_midi_opts, func_inst);
+        kfree(midi->id);
+        mutex_lock(&opts->lock);
+        for (i = opts->in_ports - 1; i >= 0; --i)
+                kfree(midi->in_port[i]);
+        kfree(midi);
+        --opts->refcnt;
+        mutex_unlock(&opts->lock);
+}
+
+static void f_midi_unbind(struct usb_configuration *c, struct usb_function *f)
+{
+        struct usb_composite_dev *cdev = f->config->cdev;
+        struct f_midi *midi = func_to_midi(f);
+        struct snd_card *card;
+
+        DBG(cdev, "unbind\n");
+
+        /* just to be sure */
+        f_midi_disable(f);
+
+        card = midi->card;
+        midi->card = NULL;
+        if (card)
+                snd_card_free(card);
+
+        usb_free_all_descriptors(f);
+}
+
+static struct usb_function *f_midi_alloc(struct usb_function_instance *fi)
 {
         struct f_midi *midi;
+        struct f_midi_opts *opts;
         int status, i;
 
+        opts = container_of(fi, struct f_midi_opts, func_inst);
+
+        mutex_lock(&opts->lock);
         /* sanity check */
-        if (in_ports > MAX_PORTS || out_ports > MAX_PORTS)
-                return -EINVAL;
+        if (opts->in_ports > MAX_PORTS || opts->out_ports > MAX_PORTS) {
+                mutex_unlock(&opts->lock);
+                return ERR_PTR(-EINVAL);
+        }
 
         /* allocate and initialize one new instance */
-        midi = kzalloc(sizeof *midi, GFP_KERNEL);
+        midi = kzalloc(sizeof(*midi), GFP_KERNEL);
         if (!midi) {
-                status = -ENOMEM;
-                goto fail;
+                mutex_unlock(&opts->lock);
+                return ERR_PTR(-ENOMEM);
         }
 
-        for (i = 0; i < in_ports; i++) {
+        for (i = 0; i < opts->in_ports; i++) {
                 struct gmidi_in_port *port = kzalloc(sizeof(*port), GFP_KERNEL);
+
                 if (!port) {
                         status = -ENOMEM;
+                        mutex_unlock(&opts->lock);
                         goto setup_fail;
                 }
 
@@ -948,39 +1134,37 @@ int __init f_midi_bind_config(struct usb_configuration *c,
                 midi->in_port[i] = port;
         }
 
-        midi->gadget = c->cdev->gadget;
-        tasklet_init(&midi->tasklet, f_midi_in_tasklet, (unsigned long) midi);
-
         /* set up ALSA midi devices */
-        midi->in_ports = in_ports;
-        midi->out_ports = out_ports;
-        status = f_midi_register_card(midi);
-        if (status < 0)
-                goto setup_fail;
-
-        midi->func.name        = "gmidi function";
-        midi->func.strings     = midi_strings;
-        midi->func.bind        = f_midi_bind;
-        midi->func.unbind      = f_midi_unbind;
-        midi->func.set_alt     = f_midi_set_alt;
-        midi->func.disable     = f_midi_disable;
-
-        midi->id = kstrdup(id, GFP_KERNEL);
-        midi->index = index;
-        midi->buflen = buflen;
-        midi->qlen = qlen;
-
-        status = usb_add_function(c, &midi->func);
-        if (status)
-                goto setup_fail;
-
-        return 0;
-
+        midi->id = kstrdup(opts->id, GFP_KERNEL);
+        if (opts->id && !midi->id) {
+                status = -ENOMEM;
+                mutex_unlock(&opts->lock);
+                goto kstrdup_fail;
+        }
+        midi->in_ports = opts->in_ports;
+        midi->out_ports = opts->out_ports;
+        midi->index = opts->index;
+        midi->buflen = opts->buflen;
+        midi->qlen = opts->qlen;
+        ++opts->refcnt;
+        mutex_unlock(&opts->lock);
+
+        midi->func.name         = "gmidi function";
+        midi->func.bind         = f_midi_bind;
+        midi->func.unbind       = f_midi_unbind;
+        midi->func.set_alt      = f_midi_set_alt;
+        midi->func.disable      = f_midi_disable;
+        midi->func.free_func    = f_midi_free;
+
+        return &midi->func;
+
+kstrdup_fail:
+        f_midi_unregister_card(midi);
 setup_fail:
         for (--i; i >= 0; i--)
                 kfree(midi->in_port[i]);
         kfree(midi);
-fail:
-        return status;
+        return ERR_PTR(status);
 }
 
+DECLARE_USB_FUNCTION_INIT(midi, f_midi_alloc_inst, f_midi_alloc);