3 files changed, 1413 insertions, 0 deletions

diff --git a/Documentation/DocBook/gadget.tmpl b/Documentation/DocBook/gadget.tmpl
index 5a8ffa761e09..478bfe16a19d 100644
--- a/Documentation/DocBook/gadget.tmpl
+++ b/Documentation/DocBook/gadget.tmpl
@@ -524,6 +524,41 @@ These utilities include endpoint autoconfiguration.
 <!-- !Edrivers/usb/gadget/epautoconf.c -->
 </sect1>
 
+<sect1 id="composite"><title>Composite Device Framework</title>
+
+<para>The core API is sufficient for writing drivers for composite
+USB devices (with more than one function in a given configuration),
+and also multi-configuration devices (also more than one function,
+but not necessarily sharing a given configuration).
+There is however an optional framework which makes it easier to
+reuse and combine functions.
+</para>
+
+<para>Devices using this framework provide a <emphasis>struct
+usb_composite_driver</emphasis>, which in turn provides one or
+more <emphasis>struct usb_configuration</emphasis> instances.
+Each such configuration includes at least one
+<emphasis>struct usb_function</emphasis>, which packages a user
+visible role such as "network link" or "mass storage device".
+Management functions may also exist, such as "Device Firmware
+Upgrade".
+</para>
+
+!Iinclude/linux/usb/composite.h
+!Edrivers/usb/gadget/composite.c
+
+</sect1>
+
+<sect1 id="functions"><title>Composite Device Functions</title>
+
+<para>At this writing, a few of the current gadget drivers have
+been converted to this framework.
+Near-term plans include converting all of them, except for "gadgetfs".
+</para>
+
+</sect1>
+
+
 </chapter>
 
 <chapter id="controllers"><title>Peripheral Controller Drivers</title>
diff --git a/drivers/usb/gadget/composite.c b/drivers/usb/gadget/composite.c
new file mode 100644
index 000000000000..b3d302a6a081
--- /dev/null
+++ b/drivers/usb/gadget/composite.c
@@ -0,0 +1,1040 @@
+/*
+ * composite.c - infrastructure for Composite USB Gadgets
+ *
+ * Copyright (C) 2006-2008 David Brownell
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+/* #define VERBOSE_DEBUG */
+
+#include <linux/kallsyms.h>
+#include <linux/kernel.h>
+#include <linux/slab.h>
+#include <linux/device.h>
+
+#include <linux/usb/composite.h>
+
+
+/*
+ * The code in this file is utility code, used to build a gadget driver
+ * from one or more "function" drivers, one or more "configuration"
+ * objects, and a "usb_composite_driver" by gluing them together along
+ * with the relevant device-wide data.
+ */
+
+/* big enough to hold our biggest descriptor */
+#define USB_BUFSIZ      512
+
+static struct usb_composite_driver *composite;
+
+/* Some systems will need runtime overrides for the  product identifers
+ * published in the device descriptor, either numbers or strings or both.
+ * String parameters are in UTF-8 (superset of ASCII's 7 bit characters).
+ */
+
+static ushort idVendor;
+module_param(idVendor, ushort, 0);
+MODULE_PARM_DESC(idVendor, "USB Vendor ID");
+
+static ushort idProduct;
+module_param(idProduct, ushort, 0);
+MODULE_PARM_DESC(idProduct, "USB Product ID");
+
+static ushort bcdDevice;
+module_param(bcdDevice, ushort, 0);
+MODULE_PARM_DESC(bcdDevice, "USB Device version (BCD)");
+
+static char *iManufacturer;
+module_param(iManufacturer, charp, 0);
+MODULE_PARM_DESC(iManufacturer, "USB Manufacturer string");
+
+static char *iProduct;
+module_param(iProduct, charp, 0);
+MODULE_PARM_DESC(iProduct, "USB Product string");
+
+static char *iSerialNumber;
+module_param(iSerialNumber, charp, 0);
+MODULE_PARM_DESC(iSerialNumber, "SerialNumber string");
+
+/*-------------------------------------------------------------------------*/
+
+/**
+ * usb_add_function() - add a function to a configuration
+ * @config: the configuration
+ * @function: the function being added
+ * Context: single threaded during gadget setup
+ *
+ * After initialization, each configuration must have one or more
+ * functions added to it.  Adding a function involves calling its @bind()
+ * method to allocate resources such as interface and string identifiers
+ * and endpoints.
+ *
+ * This function returns the value of the function's bind(), which is
+ * zero for success else a negative errno value.
+ */
+int __init usb_add_function(struct usb_configuration *config,
+                struct usb_function *function)
+{
+        int     value = -EINVAL;
+
+        DBG(config->cdev, "adding '%s'/%p to config '%s'/%p\n",
+                        function->name, function,
+                        config->label, config);
+
+        if (!function->set_alt || !function->disable)
+                goto done;
+
+        function->config = config;
+        list_add_tail(&function->list, &config->functions);
+
+        /* REVISIT *require* function->bind? */
+        if (function->bind) {
+                value = function->bind(config, function);
+                if (value < 0) {
+                        list_del(&function->list);
+                        function->config = NULL;
+                }
+        } else
+                value = 0;
+
+        /* We allow configurations that don't work at both speeds.
+         * If we run into a lowspeed Linux system, treat it the same
+         * as full speed ... it's the function drivers that will need
+         * to avoid bulk and ISO transfers.
+         */
+        if (!config->fullspeed && function->descriptors)
+                config->fullspeed = true;
+        if (!config->highspeed && function->hs_descriptors)
+                config->highspeed = true;
+
+done:
+        if (value)
+                DBG(config->cdev, "adding '%s'/%p --> %d\n",
+                                function->name, function, value);
+        return value;
+}
+
+/**
+ * usb_interface_id() - allocate an unused interface ID
+ * @config: configuration associated with the interface
+ * @function: function handling the interface
+ * Context: single threaded during gadget setup
+ *
+ * usb_interface_id() is called from usb_function.bind() callbacks to
+ * allocate new interface IDs.  The function driver will then store that
+ * ID in interface, association, CDC union, and other descriptors.  It
+ * will also handle any control requests targetted at that interface,
+ * particularly changing its altsetting via set_alt().  There may
+ * also be class-specific or vendor-specific requests to handle.
+ *
+ * All interface identifier should be allocated using this routine, to
+ * ensure that for example different functions don't wrongly assign
+ * different meanings to the same identifier.  Note that since interface
+ * identifers are configuration-specific, functions used in more than
+ * one configuration (or more than once in a given configuration) need
+ * multiple versions of the relevant descriptors.
+ *
+ * Returns the interface ID which was allocated; or -ENODEV if no
+ * more interface IDs can be allocated.
+ */
+int __init usb_interface_id(struct usb_configuration *config,
+                struct usb_function *function)
+{
+        unsigned id = config->next_interface_id;
+
+        if (id < MAX_CONFIG_INTERFACES) {
+                config->interface[id] = function;
+                config->next_interface_id = id + 1;
+                return id;
+        }
+        return -ENODEV;
+}
+
+static int config_buf(struct usb_configuration *config,
+                enum usb_device_speed speed, void *buf, u8 type)
+{
+        struct usb_config_descriptor    *c = buf;
+        void                            *next = buf + USB_DT_CONFIG_SIZE;
+        int                             len = USB_BUFSIZ - USB_DT_CONFIG_SIZE;
+        struct usb_function             *f;
+        int                             status;
+
+        /* write the config descriptor */
+        c = buf;
+        c->bLength = USB_DT_CONFIG_SIZE;
+        c->bDescriptorType = type;
+        /* wTotalLength is written later */
+        c->bNumInterfaces = config->next_interface_id;
+        c->bConfigurationValue = config->bConfigurationValue;
+        c->iConfiguration = config->iConfiguration;
+        c->bmAttributes = USB_CONFIG_ATT_ONE | config->bmAttributes;
+        c->bMaxPower = config->bMaxPower;
+
+        /* There may be e.g. OTG descriptors */
+        if (config->descriptors) {
+                status = usb_descriptor_fillbuf(next, len,
+                                config->descriptors);
+                if (status < 0)
+                        return status;
+                len -= status;
+                next += status;
+        }
+
+        /* add each function's descriptors */
+        list_for_each_entry(f, &config->functions, list) {
+                struct usb_descriptor_header **descriptors;
+
+                if (speed == USB_SPEED_HIGH)
+                        descriptors = f->hs_descriptors;
+                else
+                        descriptors = f->descriptors;
+                if (!descriptors)
+                        continue;
+                status = usb_descriptor_fillbuf(next, len,
+                        (const struct usb_descriptor_header **) descriptors);
+                if (status < 0)
+                        return status;
+                len -= status;
+                next += status;
+        }
+
+        len = next - buf;
+        c->wTotalLength = cpu_to_le16(len);
+        return len;
+}
+
+static int config_desc(struct usb_composite_dev *cdev, unsigned w_value)
+{
+        struct usb_gadget               *gadget = cdev->gadget;
+        struct usb_configuration        *c;
+        u8                              type = w_value >> 8;
+        enum usb_device_speed           speed = USB_SPEED_UNKNOWN;
+
+        if (gadget_is_dualspeed(gadget)) {
+                int                     hs = 0;
+
+                if (gadget->speed == USB_SPEED_HIGH)
+                        hs = 1;
+                if (type == USB_DT_OTHER_SPEED_CONFIG)
+                        hs = !hs;
+                if (hs)
+                        speed = USB_SPEED_HIGH;
+
+        }
+
+        /* This is a lookup by config *INDEX* */
+        w_value &= 0xff;
+        list_for_each_entry(c, &cdev->configs, list) {
+                /* ignore configs that won't work at this speed */
+                if (speed == USB_SPEED_HIGH) {
+                        if (!c->highspeed)
+                                continue;
+                } else {
+                        if (!c->fullspeed)
+                                continue;
+                }
+                if (w_value == 0)
+                        return config_buf(c, speed, cdev->req->buf, type);
+                w_value--;
+        }
+        return -EINVAL;
+}
+
+static int count_configs(struct usb_composite_dev *cdev, unsigned type)
+{
+        struct usb_gadget               *gadget = cdev->gadget;
+        struct usb_configuration        *c;
+        unsigned                        count = 0;
+        int                             hs = 0;
+
+        if (gadget_is_dualspeed(gadget)) {
+                if (gadget->speed == USB_SPEED_HIGH)
+                        hs = 1;
+                if (type == USB_DT_DEVICE_QUALIFIER)
+                        hs = !hs;
+        }
+        list_for_each_entry(c, &cdev->configs, list) {
+                /* ignore configs that won't work at this speed */
+                if (hs) {
+                        if (!c->highspeed)
+                                continue;
+                } else {
+                        if (!c->fullspeed)
+                                continue;
+                }
+                count++;
+        }
+        return count;
+}
+
+static void device_qual(struct usb_composite_dev *cdev)
+{
+        struct usb_qualifier_descriptor *qual = cdev->req->buf;
+
+        qual->bLength = sizeof(*qual);
+        qual->bDescriptorType = USB_DT_DEVICE_QUALIFIER;
+        /* POLICY: same bcdUSB and device type info at both speeds */
+        qual->bcdUSB = cdev->desc.bcdUSB;
+        qual->bDeviceClass = cdev->desc.bDeviceClass;
+        qual->bDeviceSubClass = cdev->desc.bDeviceSubClass;
+        qual->bDeviceProtocol = cdev->desc.bDeviceProtocol;
+        /* ASSUME same EP0 fifo size at both speeds */
+        qual->bMaxPacketSize0 = cdev->desc.bMaxPacketSize0;
+        qual->bNumConfigurations = count_configs(cdev, USB_DT_DEVICE_QUALIFIER);
+}
+
+/*-------------------------------------------------------------------------*/
+
+static void reset_config(struct usb_composite_dev *cdev)
+{
+        struct usb_function             *f;
+
+        DBG(cdev, "reset config\n");
+
+        list_for_each_entry(f, &cdev->config->functions, list) {
+                if (f->disable)
+                        f->disable(f);
+        }
+        cdev->config = NULL;
+}
+
+static int set_config(struct usb_composite_dev *cdev,
+                const struct usb_ctrlrequest *ctrl, unsigned number)
+{
+        struct usb_gadget       *gadget = cdev->gadget;
+        struct usb_configuration *c = NULL;
+        int                     result = -EINVAL;
+        unsigned                power = gadget_is_otg(gadget) ? 8 : 100;
+        int                     tmp;
+
+        if (cdev->config)
+                reset_config(cdev);
+
+        if (number) {
+                list_for_each_entry(c, &cdev->configs, list) {
+                        if (c->bConfigurationValue == number) {
+                                result = 0;
+                                break;
+                        }
+                }
+                if (result < 0)
+                        goto done;
+        } else
+                result = 0;
+
+        INFO(cdev, "%s speed config #%d: %s\n",
+                ({ char *speed;
+                switch (gadget->speed) {
+                case USB_SPEED_LOW:     speed = "low"; break;
+                case USB_SPEED_FULL:    speed = "full"; break;
+                case USB_SPEED_HIGH:    speed = "high"; break;
+                default:                speed = "?"; break;
+                } ; speed; }), number, c ? c->label : "unconfigured");
+
+        if (!c)
+                goto done;
+
+        cdev->config = c;
+
+        /* Initialize all interfaces by setting them to altsetting zero. */
+        for (tmp = 0; tmp < MAX_CONFIG_INTERFACES; tmp++) {
+                struct usb_function     *f = c->interface[tmp];
+
+                if (!f)
+                        break;
+
+                result = f->set_alt(f, tmp, 0);
+                if (result < 0) {
+                        DBG(cdev, "interface %d (%s/%p) alt 0 --> %d\n",
+                                        tmp, f->name, f, result);
+
+                        reset_config(cdev);
+                        goto done;
+                }
+        }
+
+        /* when we return, be sure our power usage is valid */
+        power = 2 * c->bMaxPower;
+done:
+        usb_gadget_vbus_draw(gadget, power);
+        return result;
+}
+
+/**
+ * usb_add_config() - add a configuration to a device.
+ * @cdev: wraps the USB gadget
+ * @config: the configuration, with bConfigurationValue assigned
+ * Context: single threaded during gadget setup
+ *
+ * One of the main tasks of a composite driver's bind() routine is to
+ * add each of the configurations it supports, using this routine.
+ *
+ * This function returns the value of the configuration's bind(), which
+ * is zero for success else a negative errno value.  Binding configurations
+ * assigns global resources including string IDs, and per-configuration
+ * resources such as interface IDs and endpoints.
+ */
+int __init usb_add_config(struct usb_composite_dev *cdev,
+                struct usb_configuration *config)
+{
+        int                             status = -EINVAL;
+        struct usb_configuration        *c;
+
+        DBG(cdev, "adding config #%u '%s'/%p\n",
+                        config->bConfigurationValue,
+                        config->label, config);
+
+        if (!config->bConfigurationValue || !config->bind)
+                goto done;
+
+        /* Prevent duplicate configuration identifiers */
+        list_for_each_entry(c, &cdev->configs, list) {
+                if (c->bConfigurationValue == config->bConfigurationValue) {
+                        status = -EBUSY;
+                        goto done;
+                }
+        }
+
+        config->cdev = cdev;
+        list_add_tail(&config->list, &cdev->configs);
+
+        INIT_LIST_HEAD(&config->functions);
+        config->next_interface_id = 0;
+
+        status = config->bind(config);
+        if (status < 0) {
+                list_del(&config->list);
+                config->cdev = NULL;
+        } else {
+                unsigned        i;
+
+                DBG(cdev, "cfg %d/%p speeds:%s%s\n",
+                        config->bConfigurationValue, config,
+                        config->highspeed ? " high" : "",
+                        config->fullspeed
+                                ? (gadget_is_dualspeed(cdev->gadget)
+                                        ? " full"
+                                        : " full/low")
+                                : "");
+
+                for (i = 0; i < MAX_CONFIG_INTERFACES; i++) {
+                        struct usb_function     *f = config->interface[i];
+
+                        if (!f)
+                                continue;
+                        DBG(cdev, "  interface %d = %s/%p\n",
+                                i, f->name, f);
+                }
+        }
+
+        /* set_alt(), or next config->bind(), sets up
+         * ep->driver_data as needed.
+         */
+        usb_ep_autoconfig_reset(cdev->gadget);
+
+done:
+        if (status)
+                DBG(cdev, "added config '%s'/%u --> %d\n", config->label,
+                                config->bConfigurationValue, status);
+        return status;
+}
+
+/*-------------------------------------------------------------------------*/
+
+/* We support strings in multiple languages ... string descriptor zero
+ * says which languages are supported.  The typical case will be that
+ * only one language (probably English) is used, with I18N handled on
+ * the host side.
+ */
+
+static void collect_langs(struct usb_gadget_strings **sp, __le16 *buf)
+{
+        const struct usb_gadget_strings *s;
+        u16                             language;
+        __le16                          *tmp;
+
+        while (*sp) {
+                s = *sp;
+                language = cpu_to_le16(s->language);
+                for (tmp = buf; *tmp && tmp < &buf[126]; tmp++) {
+                        if (*tmp == language)
+                                goto repeat;
+                }
+                *tmp++ = language;
+repeat:
+                sp++;
+        }
+}
+
+static int lookup_string(
+        struct usb_gadget_strings       **sp,
+        void                            *buf,
+        u16                             language,
+        int                             id
+)
+{
+        struct usb_gadget_strings       *s;
+        int                             value;
+
+        while (*sp) {
+                s = *sp++;
+                if (s->language != language)
+                        continue;
+                value = usb_gadget_get_string(s, id, buf);
+                if (value > 0)
+                        return value;
+        }
+        return -EINVAL;
+}
+
+static int get_string(struct usb_composite_dev *cdev,
+                void *buf, u16 language, int id)
+{
+        struct usb_configuration        *c;
+        struct usb_function             *f;
+        int                             len;
+
+        /* Yes, not only is USB's I18N support probably more than most
+         * folk will ever care about ... also, it's all supported here.
+         * (Except for UTF8 support for Unicode's "Astral Planes".)
+         */
+
+        /* 0 == report all available language codes */
+        if (id == 0) {
+                struct usb_string_descriptor    *s = buf;
+                struct usb_gadget_strings       **sp;
+
+                memset(s, 0, 256);
+                s->bDescriptorType = USB_DT_STRING;
+
+                sp = composite->strings;
+                if (sp)
+                        collect_langs(sp, s->wData);
+
+                list_for_each_entry(c, &cdev->configs, list) {
+                        sp = c->strings;
+                        if (sp)
+                                collect_langs(sp, s->wData);
+
+                        list_for_each_entry(f, &c->functions, list) {
+                                sp = f->strings;
+                                if (sp)
+                                        collect_langs(sp, s->wData);
+                        }
+                }
+
+                for (len = 0; s->wData[len] && len <= 126; len++)
+                        continue;
+                if (!len)
+                        return -EINVAL;
+
+                s->bLength = 2 * (len + 1);
+                return s->bLength;
+        }
+
+        /* Otherwise, look up and return a specified string.  String IDs
+         * are device-scoped, so we look up each string table we're told
+         * about.  These lookups are infrequent; simpler-is-better here.
+         */
+        if (composite->strings) {
+                len = lookup_string(composite->strings, buf, language, id);
+                if (len > 0)
+                        return len;
+        }
+        list_for_each_entry(c, &cdev->configs, list) {
+                if (c->strings) {
+                        len = lookup_string(c->strings, buf, language, id);
+                        if (len > 0)
+                                return len;
+                }
+                list_for_each_entry(f, &c->functions, list) {
+                        if (!f->strings)
+                                continue;
+                        len = lookup_string(f->strings, buf, language, id);
+                        if (len > 0)
+                                return len;
+                }
+        }
+        return -EINVAL;
+}
+
+/**
+ * usb_string_id() - allocate an unused string ID
+ * @cdev: the device whose string descriptor IDs are being allocated
+ * Context: single threaded during gadget setup
+ *
+ * @usb_string_id() is called from bind() callbacks to allocate
+ * string IDs.  Drivers for functions, configurations, or gadgets will
+ * then store that ID in the appropriate descriptors and string table.
+ *
+ * All string identifier should be allocated using this routine, to
+ * ensure that for example different functions don't wrongly assign
+ * different meanings to the same identifier.
+ */
+int __init usb_string_id(struct usb_composite_dev *cdev)
+{
+        if (cdev->next_string_id < 254) {
+                /* string id 0 is reserved */
+                cdev->next_string_id++;
+                return cdev->next_string_id;
+        }
+        return -ENODEV;
+}
+
+/*-------------------------------------------------------------------------*/
+
+static void composite_setup_complete(struct usb_ep *ep, struct usb_request *req)
+{
+        if (req->status || req->actual != req->length)
+                DBG((struct usb_composite_dev *) ep->driver_data,
+                                "setup complete --> %d, %d/%d\n",
+                                req->status, req->actual, req->length);
+}
+
+/*
+ * The setup() callback implements all the ep0 functionality that's
+ * not handled lower down, in hardware or the hardware driver(like
+ * device and endpoint feature flags, and their status).  It's all
+ * housekeeping for the gadget function we're implementing.  Most of
+ * the work is in config and function specific setup.
+ */
+static int
+composite_setup(struct usb_gadget *gadget, const struct usb_ctrlrequest *ctrl)
+{
+        struct usb_composite_dev        *cdev = get_gadget_data(gadget);
+        struct usb_request              *req = cdev->req;
+        int                             value = -EOPNOTSUPP;
+        u16                             w_index = le16_to_cpu(ctrl->wIndex);
+        u16                             w_value = le16_to_cpu(ctrl->wValue);
+        u16                             w_length = le16_to_cpu(ctrl->wLength);
+        struct usb_function             *f = NULL;
+
+        /* partial re-init of the response message; the function or the
+         * gadget might need to intercept e.g. a control-OUT completion
+         * when we delegate to it.
+         */
+        req->zero = 0;
+        req->complete = composite_setup_complete;
+        req->length = USB_BUFSIZ;
+        gadget->ep0->driver_data = cdev;
+
+        switch (ctrl->bRequest) {
+
+        /* we handle all standard USB descriptors */
+        case USB_REQ_GET_DESCRIPTOR:
+                if (ctrl->bRequestType != USB_DIR_IN)
+                        goto unknown;
+                switch (w_value >> 8) {
+
+                case USB_DT_DEVICE:
+                        cdev->desc.bNumConfigurations =
+                                count_configs(cdev, USB_DT_DEVICE);
+                        value = min(w_length, (u16) sizeof cdev->desc);
+                        memcpy(req->buf, &cdev->desc, value);
+                        break;
+                case USB_DT_DEVICE_QUALIFIER:
+                        if (!gadget_is_dualspeed(gadget))
+                                break;
+                        device_qual(cdev);
+                        value = min_t(int, w_length,
+                                sizeof(struct usb_qualifier_descriptor));
+                        break;
+                case USB_DT_OTHER_SPEED_CONFIG:
+                        if (!gadget_is_dualspeed(gadget))
+                                break;
+                        /* FALLTHROUGH */
+                case USB_DT_CONFIG:
+                        value = config_desc(cdev, w_value);
+                        if (value >= 0)
+                                value = min(w_length, (u16) value);
+                        break;
+                case USB_DT_STRING:
+                        value = get_string(cdev, req->buf,
+                                        w_index, w_value & 0xff);
+                        if (value >= 0)
+                                value = min(w_length, (u16) value);
+                        break;
+                }
+                break;
+
+        /* any number of configs can work */
+        case USB_REQ_SET_CONFIGURATION:
+                if (ctrl->bRequestType != 0)
+                        goto unknown;
+                if (gadget_is_otg(gadget)) {
+                        if (gadget->a_hnp_support)
+                                DBG(cdev, "HNP available\n");
+                        else if (gadget->a_alt_hnp_support)
+                                DBG(cdev, "HNP on another port\n");
+                        else
+                                VDBG(cdev, "HNP inactive\n");
+                }
+                spin_lock(&cdev->lock);
+                value = set_config(cdev, ctrl, w_value);
+                spin_unlock(&cdev->lock);
+                break;
+        case USB_REQ_GET_CONFIGURATION:
+                if (ctrl->bRequestType != USB_DIR_IN)
+                        goto unknown;
+                if (cdev->config)
+                        *(u8 *)req->buf = cdev->config->bConfigurationValue;
+                else
+                        *(u8 *)req->buf = 0;
+                value = min(w_length, (u16) 1);
+                break;
+
+        /* function drivers must handle get/set altsetting; if there's
+         * no get() method, we know only altsetting zero works.
+         */
+        case USB_REQ_SET_INTERFACE:
+                if (ctrl->bRequestType != USB_RECIP_INTERFACE)
+                        goto unknown;
+                if (!cdev->config || w_index >= MAX_CONFIG_INTERFACES)
+                        break;
+                f = cdev->config->interface[w_index];
+                if (!f)
+                        break;
+                if (w_value && !f->get_alt)
+                        break;
+                value = f->set_alt(f, w_index, w_value);
+                break;
+        case USB_REQ_GET_INTERFACE:
+                if (ctrl->bRequestType != (USB_DIR_IN|USB_RECIP_INTERFACE))
+                        goto unknown;
+                if (!cdev->config || w_index >= MAX_CONFIG_INTERFACES)
+                        break;
+                f = cdev->config->interface[w_index];
+                if (!f)
+                        break;
+                /* lots of interfaces only need altsetting zero... */
+                value = f->get_alt ? f->get_alt(f, w_index) : 0;
+                if (value < 0)
+                        break;
+                *((u8 *)req->buf) = value;
+                value = min(w_length, (u16) 1);
+                break;
+        default:
+unknown:
+                VDBG(cdev,
+                        "non-core control req%02x.%02x v%04x i%04x l%d\n",
+                        ctrl->bRequestType, ctrl->bRequest,
+                        w_value, w_index, w_length);
+
+                /* functions always handle their interfaces ... punt other
+                 * recipients (endpoint, other, WUSB, ...) to the current
+                 * configuration code.
+                 *
+                 * REVISIT it could make sense to let the composite device
+                 * take such requests too, if that's ever needed:  to work
+                 * in config 0, etc.
+                 */
+                if ((ctrl->bRequestType & USB_RECIP_MASK)
+                                == USB_RECIP_INTERFACE) {
+                        f = cdev->config->interface[w_index];
+                        if (f && f->setup)
+                                value = f->setup(f, ctrl);
+                        else
+                                f = NULL;
+                }
+                if (value < 0 && !f) {
+                        struct usb_configuration        *c;
+
+                        c = cdev->config;
+                        if (c && c->setup)
+                                value = c->setup(c, ctrl);
+                }
+
+                goto done;
+        }
+
+        /* respond with data transfer before status phase? */
+        if (value >= 0) {
+                req->length = value;
+                req->zero = value < w_length;
+                value = usb_ep_queue(gadget->ep0, req, GFP_ATOMIC);
+                if (value < 0) {
+                        DBG(cdev, "ep_queue --> %d\n", value);
+                        req->status = 0;
+                        composite_setup_complete(gadget->ep0, req);
+                }
+        }
+
+done:
+        /* device either stalls (value < 0) or reports success */
+        return value;
+}
+
+static void composite_disconnect(struct usb_gadget *gadget)
+{
+        struct usb_composite_dev        *cdev = get_gadget_data(gadget);
+        unsigned long                   flags;
+
+        /* REVISIT:  should we have config and device level
+         * disconnect callbacks?
+         */
+        spin_lock_irqsave(&cdev->lock, flags);
+        if (cdev->config)
+                reset_config(cdev);
+        spin_unlock_irqrestore(&cdev->lock, flags);
+}
+
+/*-------------------------------------------------------------------------*/
+
+static void /* __init_or_exit */
+composite_unbind(struct usb_gadget *gadget)
+{
+        struct usb_composite_dev        *cdev = get_gadget_data(gadget);
+
+        /* composite_disconnect() must already have been called
+         * by the underlying peripheral controller driver!
+         * so there's no i/o concurrency that could affect the
+         * state protected by cdev->lock.
+         */
+        WARN_ON(cdev->config);
+
+        while (!list_empty(&cdev->configs)) {
+                struct usb_configuration        *c;
+
+                c = list_first_entry(&cdev->configs,
+                                struct usb_configuration, list);
+                while (!list_empty(&c->functions)) {
+                        struct usb_function             *f;
+
+                        f = list_first_entry(&c->functions,
+                                        struct usb_function, list);
+                        list_del(&f->list);
+                        if (f->unbind) {
+                                DBG(cdev, "unbind function '%s'/%p\n",
+                                                f->name, f);
+                                f->unbind(c, f);
+                                /* may free memory for "f" */
+                        }
+                }
+                list_del(&c->list);
+                if (c->unbind) {
+                        DBG(cdev, "unbind config '%s'/%p\n", c->label, c);
+                        c->unbind(c);
+                        /* may free memory for "c" */
+                }
+        }
+        if (composite->unbind)
+                composite->unbind(cdev);
+
+        if (cdev->req) {
+                kfree(cdev->req->buf);
+                usb_ep_free_request(gadget->ep0, cdev->req);
+        }
+        kfree(cdev);
+        set_gadget_data(gadget, NULL);
+        composite = NULL;
+}
+
+static void __init
+string_override_one(struct usb_gadget_strings *tab, u8 id, const char *s)
+{
+        struct usb_string               *str = tab->strings;
+
+        for (str = tab->strings; str->s; str++) {
+                if (str->id == id) {
+                        str->s = s;
+                        return;
+                }
+        }
+}
+
+static void __init
+string_override(struct usb_gadget_strings **tab, u8 id, const char *s)
+{
+        while (*tab) {
+                string_override_one(*tab, id, s);
+                tab++;
+        }
+}
+
+static int __init composite_bind(struct usb_gadget *gadget)
+{
+        struct usb_composite_dev        *cdev;
+        int                             status = -ENOMEM;
+
+        cdev = kzalloc(sizeof *cdev, GFP_KERNEL);
+        if (!cdev)
+                return status;
+
+        spin_lock_init(&cdev->lock);
+        cdev->gadget = gadget;
+        set_gadget_data(gadget, cdev);
+        INIT_LIST_HEAD(&cdev->configs);
+
+        /* preallocate control response and buffer */
+        cdev->req = usb_ep_alloc_request(gadget->ep0, GFP_KERNEL);
+        if (!cdev->req)
+                goto fail;
+        cdev->req->buf = kmalloc(USB_BUFSIZ, GFP_KERNEL);
+        if (!cdev->req->buf)
+                goto fail;
+        cdev->req->complete = composite_setup_complete;
+        gadget->ep0->driver_data = cdev;
+
+        cdev->bufsiz = USB_BUFSIZ;
+        cdev->driver = composite;
+
+        usb_gadget_set_selfpowered(gadget);
+
+        /* interface and string IDs start at zero via kzalloc.
+         * we force endpoints to start unassigned; few controller
+         * drivers will zero ep->driver_data.
+         */
+        usb_ep_autoconfig_reset(cdev->gadget);
+
+        /* composite gadget needs to assign strings for whole device (like
+         * serial number), register function drivers, potentially update
+         * power state and consumption, etc
+         */
+        status = composite->bind(cdev);
+        if (status < 0)
+                goto fail;
+
+        cdev->desc = *composite->dev;
+        cdev->desc.bMaxPacketSize0 = gadget->ep0->maxpacket;
+
+        /* standardized runtime overrides for device ID data */
+        if (idVendor)
+                cdev->desc.idVendor = cpu_to_le16(idVendor);
+        if (idProduct)
+                cdev->desc.idProduct = cpu_to_le16(idProduct);
+        if (bcdDevice)
+                cdev->desc.bcdDevice = cpu_to_le16(bcdDevice);
+
+        /* strings can't be assigned before bind() allocates the
+         * releavnt identifiers
+         */
+        if (cdev->desc.iManufacturer && iManufacturer)
+                string_override(composite->strings,
+                        cdev->desc.iManufacturer, iManufacturer);
+        if (cdev->desc.iProduct && iProduct)
+                string_override(composite->strings,
+                        cdev->desc.iProduct, iProduct);
+        if (cdev->desc.iSerialNumber && iSerialNumber)
+                string_override(composite->strings,
+                        cdev->desc.iSerialNumber, iSerialNumber);
+
+        INFO(cdev, "%s ready\n", composite->name);
+        return 0;
+
+fail:
+        composite_unbind(gadget);
+        return status;
+}
+
+/*-------------------------------------------------------------------------*/
+
+static void
+composite_suspend(struct usb_gadget *gadget)
+{
+        struct usb_composite_dev        *cdev = get_gadget_data(gadget);
+        struct usb_function             *f;
+
+        /* REVISIT:  should we have config and device level
+         * suspend/resume callbacks?
+         */
+        DBG(cdev, "suspend\n");
+        if (cdev->config) {
+                list_for_each_entry(f, &cdev->config->functions, list) {
+                        if (f->suspend)
+                                f->suspend(f);
+                }
+        }
+}
+
+static void
+composite_resume(struct usb_gadget *gadget)
+{
+        struct usb_composite_dev        *cdev = get_gadget_data(gadget);
+        struct usb_function             *f;
+
+        /* REVISIT:  should we have config and device level
+         * suspend/resume callbacks?
+         */
+        DBG(cdev, "resume\n");
+        if (cdev->config) {
+                list_for_each_entry(f, &cdev->config->functions, list) {
+                        if (f->resume)
+                                f->resume(f);
+                }
+        }
+}
+
+/*-------------------------------------------------------------------------*/
+
+static struct usb_gadget_driver composite_driver = {
+        .speed          = USB_SPEED_HIGH,
+
+        .bind           = composite_bind,
+        .unbind         = __exit_p(composite_unbind),
+
+        .setup          = composite_setup,
+        .disconnect     = composite_disconnect,
+
+        .suspend        = composite_suspend,
+        .resume         = composite_resume,
+
+        .driver = {
+                .owner          = THIS_MODULE,
+        },
+};
+
+/**
+ * usb_composite_register() - register a composite driver
+ * @driver: the driver to register
+ * Context: single threaded during gadget setup
+ *
+ * This function is used to register drivers using the composite driver
+ * framework.  The return value is zero, or a negative errno value.
+ * Those values normally come from the driver's @bind method, which does
+ * all the work of setting up the driver to match the hardware.
+ *
+ * On successful return, the gadget is ready to respond to requests from
+ * the host, unless one of its components invokes usb_gadget_disconnect()
+ * while it was binding.  That would usually be done in order to wait for
+ * some userspace participation.
+ */
+int __init usb_composite_register(struct usb_composite_driver *driver)
+{
+        if (!driver || !driver->dev || !driver->bind || composite)
+                return -EINVAL;
+
+        if (!driver->name)
+                driver->name = "composite";
+        composite_driver.function =  (char *) driver->name;
+        composite_driver.driver.name = driver->name;
+        composite = driver;
+
+        return usb_gadget_register_driver(&composite_driver);
+}
+
+/**
+ * usb_composite_unregister() - unregister a composite driver
+ * @driver: the driver to unregister
+ *
+ * This function is used to unregister drivers using the composite
+ * driver framework.
+ */
+void __exit usb_composite_unregister(struct usb_composite_driver *driver)
+{
+        if (composite != driver)
+                return;
+        usb_gadget_unregister_driver(&composite_driver);
+}
diff --git a/include/linux/usb/composite.h b/include/linux/usb/composite.h
new file mode 100644
index 000000000000..747c3a49cdc9
--- /dev/null
+++ b/include/linux/usb/composite.h
@@ -0,0 +1,338 @@
+/*
+ * composite.h -- framework for usb gadgets which are composite devices
+ *
+ * Copyright (C) 2006-2008 David Brownell
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#ifndef __LINUX_USB_COMPOSITE_H
+#define __LINUX_USB_COMPOSITE_H
+
+/*
+ * This framework is an optional layer on top of the USB Gadget interface,
+ * making it easier to build (a) Composite devices, supporting multiple
+ * functions within any single configuration, and (b) Multi-configuration
+ * devices, also supporting multiple functions but without necessarily
+ * having more than one function per configuration.
+ *
+ * Example:  a device with a single configuration supporting both network
+ * link and mass storage functions is a composite device.  Those functions
+ * might alternatively be packaged in individual configurations, but in
+ * the composite model the host can use both functions at the same time.
+ */
+
+#include <linux/usb/ch9.h>
+#include <linux/usb/gadget.h>
+
+
+struct usb_configuration;
+
+/**
+ * struct usb_function - describes one function of a configuration
+ * @name: For diagnostics, identifies the function.
+ * @strings: tables of strings, keyed by identifiers assigned during bind()
+ *      and by language IDs provided in control requests
+ * @descriptors: Table of full (or low) speed descriptors, using interface and
+ *      string identifiers assigned during @bind().  If this pointer is null,
+ *      the function will not be available at full speed (or at low speed).
+ * @hs_descriptors: Table of high speed descriptors, using interface and
+ *      string identifiers assigned during @bind().  If this pointer is null,
+ *      the function will not be available at high speed.
+ * @config: assigned when @usb_add_function() is called; this is the
+ *      configuration with which this function is associated.
+ * @bind: Before the gadget can register, all of its functions bind() to the
+ *      available resources including string and interface identifiers used
+ *      in interface or class descriptors; endpoints; I/O buffers; and so on.
+ * @unbind: Reverses @bind; called as a side effect of unregistering the
+ *      driver which added this function.
+ * @set_alt: (REQUIRED) Reconfigures altsettings; function drivers may
+ *      initialize usb_ep.driver data at this time (when it is used).
+ *      Note that setting an interface to its current altsetting resets
+ *      interface state, and that all interfaces have a disabled state.
+ * @get_alt: Returns the active altsetting.  If this is not provided,
+ *      then only altsetting zero is supported.
+ * @disable: (REQUIRED) Indicates the function should be disabled.  Reasons
+ *      include host resetting or reconfiguring the gadget, and disconnection.
+ * @setup: Used for interface-specific control requests.
+ * @suspend: Notifies functions when the host stops sending USB traffic.
+ * @resume: Notifies functions when the host restarts USB traffic.
+ *
+ * A single USB function uses one or more interfaces, and should in most
+ * cases support operation at both full and high speeds.  Each function is
+ * associated by @usb_add_function() with a one configuration; that function
+ * causes @bind() to be called so resources can be allocated as part of
+ * setting up a gadget driver.  Those resources include endpoints, which
+ * should be allocated using @usb_ep_autoconfig().
+ *
+ * To support dual speed operation, a function driver provides descriptors
+ * for both high and full speed operation.  Except in rare cases that don't
+ * involve bulk endpoints, each speed needs different endpoint descriptors.
+ *
+ * Function drivers choose their own strategies for managing instance data.
+ * The simplest strategy just declares it "static', which means the function
+ * can only be activated once.  If the function needs to be exposed in more
+ * than one configuration at a given speed, it needs to support multiple
+ * usb_function structures (one for each configuration).
+ *
+ * A more complex strategy might encapsulate a @usb_function structure inside
+ * a driver-specific instance structure to allows multiple activations.  An
+ * example of multiple activations might be a CDC ACM function that supports
+ * two or more distinct instances within the same configuration, providing
+ * several independent logical data links to a USB host.
+ */
+struct usb_function {
+        const char                      *name;
+        struct usb_gadget_strings       **strings;
+        struct usb_descriptor_header    **descriptors;
+        struct usb_descriptor_header    **hs_descriptors;
+
+        struct usb_configuration        *config;
+
+        /* REVISIT:  bind() functions can be marked __init, which
+         * makes trouble for section mismatch analysis.  See if
+         * we can't restructure things to avoid mismatching.
+         * Related:  unbind() may kfree() but bind() won't...
+         */
+
+        /* configuration management:  bind/unbind */
+        int                     (*bind)(struct usb_configuration *,
+                                        struct usb_function *);
+        void                    (*unbind)(struct usb_configuration *,
+                                        struct usb_function *);
+
+        /* runtime state management */
+        int                     (*set_alt)(struct usb_function *,
+                                        unsigned interface, unsigned alt);
+        int                     (*get_alt)(struct usb_function *,
+                                        unsigned interface);
+        void                    (*disable)(struct usb_function *);
+        int                     (*setup)(struct usb_function *,
+                                        const struct usb_ctrlrequest *);
+        void                    (*suspend)(struct usb_function *);
+        void                    (*resume)(struct usb_function *);
+
+        /* internals */
+        struct list_head                list;
+};
+
+int usb_add_function(struct usb_configuration *, struct usb_function *);
+
+int usb_interface_id(struct usb_configuration *, struct usb_function *);
+
+/**
+ * ep_choose - select descriptor endpoint at current device speed
+ * @g: gadget, connected and running at some speed
+ * @hs: descriptor to use for high speed operation
+ * @fs: descriptor to use for full or low speed operation
+ */
+static inline struct usb_endpoint_descriptor *
+ep_choose(struct usb_gadget *g, struct usb_endpoint_descriptor *hs,
+                struct usb_endpoint_descriptor *fs)
+{
+        if (gadget_is_dualspeed(g) && g->speed == USB_SPEED_HIGH)
+                return hs;
+        return fs;
+}
+
+#define MAX_CONFIG_INTERFACES           16      /* arbitrary; max 255 */
+
+/**
+ * struct usb_configuration - represents one gadget configuration
+ * @label: For diagnostics, describes the configuration.
+ * @strings: Tables of strings, keyed by identifiers assigned during @bind()
+ *      and by language IDs provided in control requests.
+ * @descriptors: Table of descriptors preceding all function descriptors.
+ *      Examples include OTG and vendor-specific descriptors.
+ * @bind: Called from @usb_add_config() to allocate resources unique to this
+ *      configuration and to call @usb_add_function() for each function used.
+ * @unbind: Reverses @bind; called as a side effect of unregistering the
+ *      driver which added this configuration.
+ * @setup: Used to delegate control requests that aren't handled by standard
+ *      device infrastructure or directed at a specific interface.
+ * @bConfigurationValue: Copied into configuration descriptor.
+ * @iConfiguration: Copied into configuration descriptor.
+ * @bmAttributes: Copied into configuration descriptor.
+ * @bMaxPower: Copied into configuration descriptor.
+ * @cdev: assigned by @usb_add_config() before calling @bind(); this is
+ *      the device associated with this configuration.
+ *
+ * Configurations are building blocks for gadget drivers structured around
+ * function drivers.  Simple USB gadgets require only one function and one
+ * configuration, and handle dual-speed hardware by always providing the same
+ * functionality.  Slightly more complex gadgets may have more than one
+ * single-function configuration at a given speed; or have configurations
+ * that only work at one speed.
+ *
+ * Composite devices are, by definition, ones with configurations which
+ * include more than one function.
+ *
+ * The lifecycle of a usb_configuration includes allocation, initialization
+ * of the fields described above, and calling @usb_add_config() to set up
+ * internal data and bind it to a specific device.  The configuration's
+ * @bind() method is then used to initialize all the functions and then
+ * call @usb_add_function() for them.
+ *
+ * Those functions would normally be independant of each other, but that's
+ * not mandatory.  CDC WMC devices are an example where functions often
+ * depend on other functions, with some functions subsidiary to others.
+ * Such interdependency may be managed in any way, so long as all of the
+ * descriptors complete by the time the composite driver returns from
+ * its bind() routine.
+ */
+struct usb_configuration {
+        const char                      *label;
+        struct usb_gadget_strings       **strings;
+        const struct usb_descriptor_header **descriptors;
+
+        /* REVISIT:  bind() functions can be marked __init, which
+         * makes trouble for section mismatch analysis.  See if
+         * we can't restructure things to avoid mismatching...
+         */
+
+        /* configuration management:  bind/unbind */
+        int                     (*bind)(struct usb_configuration *);
+        void                    (*unbind)(struct usb_configuration *);
+        int                     (*setup)(struct usb_configuration *,
+                                        const struct usb_ctrlrequest *);
+
+        /* fields in the config descriptor */
+        u8                      bConfigurationValue;
+        u8                      iConfiguration;
+        u8                      bmAttributes;
+        u8                      bMaxPower;
+
+        struct usb_composite_dev        *cdev;
+
+        /* internals */
+        struct list_head        list;
+        struct list_head        functions;
+        u8                      next_interface_id;
+        unsigned                highspeed:1;
+        unsigned                fullspeed:1;
+        struct usb_function     *interface[MAX_CONFIG_INTERFACES];
+};
+
+int usb_add_config(struct usb_composite_dev *,
+                struct usb_configuration *);
+
+/**
+ * struct usb_composite_driver - groups configurations into a gadget
+ * @name: For diagnostics, identifies the driver.
+ * @dev: Template descriptor for the device, including default device
+ *      identifiers.
+ * @strings: tables of strings, keyed by identifiers assigned during bind()
+ *      and language IDs provided in control requests
+ * @bind: (REQUIRED) Used to allocate resources that are shared across the
+ *      whole device, such as string IDs, and add its configurations using
+ *      @usb_add_config().  This may fail by returning a negative errno
+ *      value; it should return zero on successful initialization.
+ * @unbind: Reverses @bind(); called as a side effect of unregistering
+ *      this driver.
+ *
+ * Devices default to reporting self powered operation.  Devices which rely
+ * on bus powered operation should report this in their @bind() method.
+ *
+ * Before returning from @bind, various fields in the template descriptor
+ * may be overridden.  These include the idVendor/idProduct/bcdDevice values
+ * normally to bind the appropriate host side driver, and the three strings
+ * (iManufacturer, iProduct, iSerialNumber) normally used to provide user
+ * meaningful device identifiers.  (The strings will not be defined unless
+ * they are defined in @dev and @strings.)  The correct ep0 maxpacket size
+ * is also reported, as defined by the underlying controller driver.
+ */
+struct usb_composite_driver {
+        const char                              *name;
+        const struct usb_device_descriptor      *dev;
+        struct usb_gadget_strings               **strings;
+
+        /* REVISIT:  bind() functions can be marked __init, which
+         * makes trouble for section mismatch analysis.  See if
+         * we can't restructure things to avoid mismatching...
+         */
+
+        int                     (*bind)(struct usb_composite_dev *);
+        int                     (*unbind)(struct usb_composite_dev *);
+};
+
+extern int usb_composite_register(struct usb_composite_driver *);
+extern void usb_composite_unregister(struct usb_composite_driver *);
+
+
+/**
+ * struct usb_composite_device - represents one composite usb gadget
+ * @gadget: read-only, abstracts the gadget's usb peripheral controller
+ * @req: used for control responses; buffer is pre-allocated
+ * @bufsiz: size of buffer pre-allocated in @req
+ * @config: the currently active configuration
+ *
+ * One of these devices is allocated and initialized before the
+ * associated device driver's bind() is called.
+ *
+ * OPEN ISSUE:  it appears that some WUSB devices will need to be
+ * built by combining a normal (wired) gadget with a wireless one.
+ * This revision of the gadget framework should probably try to make
+ * sure doing that won't hurt too much.
+ *
+ * One notion for how to handle Wireless USB devices involves:
+ * (a) a second gadget here, discovery mechanism TBD, but likely
+ *     needing separate "register/unregister WUSB gadget" calls;
+ * (b) updates to usb_gadget to include flags "is it wireless",
+ *     "is it wired", plus (presumably in a wrapper structure)
+ *     bandgroup and PHY info;
+ * (c) presumably a wireless_ep wrapping a usb_ep, and reporting
+ *     wireless-specific parameters like maxburst and maxsequence;
+ * (d) configurations that are specific to wireless links;
+ * (e) function drivers that understand wireless configs and will
+ *     support wireless for (additional) function instances;
+ * (f) a function to support association setup (like CBAF), not
+ *     necessarily requiring a wireless adapter;
+ * (g) composite device setup that can create one or more wireless
+ *     configs, including appropriate association setup support;
+ * (h) more, TBD.
+ */
+struct usb_composite_dev {
+        struct usb_gadget               *gadget;
+        struct usb_request              *req;
+        unsigned                        bufsiz;
+
+        struct usb_configuration        *config;
+
+        /* internals */
+        struct usb_device_descriptor    desc;
+        struct list_head                configs;
+        struct usb_composite_driver     *driver;
+        u8                              next_string_id;
+
+        spinlock_t                      lock;
+
+        /* REVISIT use and existence of lock ... */
+};
+
+extern int usb_string_id(struct usb_composite_dev *c);
+
+/* messaging utils */
+#define DBG(d, fmt, args...) \
+        dev_dbg(&(d)->gadget->dev , fmt , ## args)
+#define VDBG(d, fmt, args...) \
+        dev_vdbg(&(d)->gadget->dev , fmt , ## args)
+#define ERROR(d, fmt, args...) \
+        dev_err(&(d)->gadget->dev , fmt , ## args)
+#define WARN(d, fmt, args...) \
+        dev_warn(&(d)->gadget->dev , fmt , ## args)
+#define INFO(d, fmt, args...) \
+        dev_info(&(d)->gadget->dev , fmt , ## args)
+
+#endif  /* __LINUX_USB_COMPOSITE_H */