linux/drivers/usb/gadget/configfs.c
<<
>>
Prefs
   1// SPDX-License-Identifier: GPL-2.0
   2#include <linux/configfs.h>
   3#include <linux/module.h>
   4#include <linux/slab.h>
   5#include <linux/device.h>
   6#include <linux/nls.h>
   7#include <linux/usb/composite.h>
   8#include <linux/usb/gadget_configfs.h>
   9#include "configfs.h"
  10#include "u_f.h"
  11#include "u_os_desc.h"
  12
  13int check_user_usb_string(const char *name,
  14                struct usb_gadget_strings *stringtab_dev)
  15{
  16        u16 num;
  17        int ret;
  18
  19        ret = kstrtou16(name, 0, &num);
  20        if (ret)
  21                return ret;
  22
  23        if (!usb_validate_langid(num))
  24                return -EINVAL;
  25
  26        stringtab_dev->language = num;
  27        return 0;
  28}
  29
  30#define MAX_NAME_LEN    40
  31#define MAX_USB_STRING_LANGS 2
  32
  33static const struct usb_descriptor_header *otg_desc[2];
  34
  35struct gadget_info {
  36        struct config_group group;
  37        struct config_group functions_group;
  38        struct config_group configs_group;
  39        struct config_group strings_group;
  40        struct config_group os_desc_group;
  41
  42        struct mutex lock;
  43        struct usb_gadget_strings *gstrings[MAX_USB_STRING_LANGS + 1];
  44        struct list_head string_list;
  45        struct list_head available_func;
  46
  47        struct usb_composite_driver composite;
  48        struct usb_composite_dev cdev;
  49        bool use_os_desc;
  50        char b_vendor_code;
  51        char qw_sign[OS_STRING_QW_SIGN_LEN];
  52        spinlock_t spinlock;
  53        bool unbind;
  54};
  55
  56static inline struct gadget_info *to_gadget_info(struct config_item *item)
  57{
  58         return container_of(to_config_group(item), struct gadget_info, group);
  59}
  60
  61struct config_usb_cfg {
  62        struct config_group group;
  63        struct config_group strings_group;
  64        struct list_head string_list;
  65        struct usb_configuration c;
  66        struct list_head func_list;
  67        struct usb_gadget_strings *gstrings[MAX_USB_STRING_LANGS + 1];
  68};
  69
  70static inline struct config_usb_cfg *to_config_usb_cfg(struct config_item *item)
  71{
  72        return container_of(to_config_group(item), struct config_usb_cfg,
  73                        group);
  74}
  75
  76struct gadget_strings {
  77        struct usb_gadget_strings stringtab_dev;
  78        struct usb_string strings[USB_GADGET_FIRST_AVAIL_IDX];
  79        char *manufacturer;
  80        char *product;
  81        char *serialnumber;
  82
  83        struct config_group group;
  84        struct list_head list;
  85};
  86
  87struct os_desc {
  88        struct config_group group;
  89};
  90
  91struct gadget_config_name {
  92        struct usb_gadget_strings stringtab_dev;
  93        struct usb_string strings;
  94        char *configuration;
  95
  96        struct config_group group;
  97        struct list_head list;
  98};
  99
 100#define USB_MAX_STRING_WITH_NULL_LEN    (USB_MAX_STRING_LEN+1)
 101
 102static int usb_string_copy(const char *s, char **s_copy)
 103{
 104        int ret;
 105        char *str;
 106        char *copy = *s_copy;
 107        ret = strlen(s);
 108        if (ret > USB_MAX_STRING_LEN)
 109                return -EOVERFLOW;
 110
 111        if (copy) {
 112                str = copy;
 113        } else {
 114                str = kmalloc(USB_MAX_STRING_WITH_NULL_LEN, GFP_KERNEL);
 115                if (!str)
 116                        return -ENOMEM;
 117        }
 118        strcpy(str, s);
 119        if (str[ret - 1] == '\n')
 120                str[ret - 1] = '\0';
 121        *s_copy = str;
 122        return 0;
 123}
 124
 125#define GI_DEVICE_DESC_SIMPLE_R_u8(__name)      \
 126static ssize_t gadget_dev_desc_##__name##_show(struct config_item *item, \
 127                        char *page)     \
 128{       \
 129        return sprintf(page, "0x%02x\n", \
 130                to_gadget_info(item)->cdev.desc.__name); \
 131}
 132
 133#define GI_DEVICE_DESC_SIMPLE_R_u16(__name)     \
 134static ssize_t gadget_dev_desc_##__name##_show(struct config_item *item, \
 135                        char *page)     \
 136{       \
 137        return sprintf(page, "0x%04x\n", \
 138                le16_to_cpup(&to_gadget_info(item)->cdev.desc.__name)); \
 139}
 140
 141
 142#define GI_DEVICE_DESC_SIMPLE_W_u8(_name)               \
 143static ssize_t gadget_dev_desc_##_name##_store(struct config_item *item, \
 144                const char *page, size_t len)           \
 145{                                                       \
 146        u8 val;                                         \
 147        int ret;                                        \
 148        ret = kstrtou8(page, 0, &val);                  \
 149        if (ret)                                        \
 150                return ret;                             \
 151        to_gadget_info(item)->cdev.desc._name = val;    \
 152        return len;                                     \
 153}
 154
 155#define GI_DEVICE_DESC_SIMPLE_W_u16(_name)      \
 156static ssize_t gadget_dev_desc_##_name##_store(struct config_item *item, \
 157                const char *page, size_t len)           \
 158{                                                       \
 159        u16 val;                                        \
 160        int ret;                                        \
 161        ret = kstrtou16(page, 0, &val);                 \
 162        if (ret)                                        \
 163                return ret;                             \
 164        to_gadget_info(item)->cdev.desc._name = cpu_to_le16p(&val);     \
 165        return len;                                     \
 166}
 167
 168#define GI_DEVICE_DESC_SIMPLE_RW(_name, _type)  \
 169        GI_DEVICE_DESC_SIMPLE_R_##_type(_name)  \
 170        GI_DEVICE_DESC_SIMPLE_W_##_type(_name)
 171
 172GI_DEVICE_DESC_SIMPLE_R_u16(bcdUSB);
 173GI_DEVICE_DESC_SIMPLE_RW(bDeviceClass, u8);
 174GI_DEVICE_DESC_SIMPLE_RW(bDeviceSubClass, u8);
 175GI_DEVICE_DESC_SIMPLE_RW(bDeviceProtocol, u8);
 176GI_DEVICE_DESC_SIMPLE_RW(bMaxPacketSize0, u8);
 177GI_DEVICE_DESC_SIMPLE_RW(idVendor, u16);
 178GI_DEVICE_DESC_SIMPLE_RW(idProduct, u16);
 179GI_DEVICE_DESC_SIMPLE_R_u16(bcdDevice);
 180
 181static ssize_t is_valid_bcd(u16 bcd_val)
 182{
 183        if ((bcd_val & 0xf) > 9)
 184                return -EINVAL;
 185        if (((bcd_val >> 4) & 0xf) > 9)
 186                return -EINVAL;
 187        if (((bcd_val >> 8) & 0xf) > 9)
 188                return -EINVAL;
 189        if (((bcd_val >> 12) & 0xf) > 9)
 190                return -EINVAL;
 191        return 0;
 192}
 193
 194static ssize_t gadget_dev_desc_bcdDevice_store(struct config_item *item,
 195                const char *page, size_t len)
 196{
 197        u16 bcdDevice;
 198        int ret;
 199
 200        ret = kstrtou16(page, 0, &bcdDevice);
 201        if (ret)
 202                return ret;
 203        ret = is_valid_bcd(bcdDevice);
 204        if (ret)
 205                return ret;
 206
 207        to_gadget_info(item)->cdev.desc.bcdDevice = cpu_to_le16(bcdDevice);
 208        return len;
 209}
 210
 211static ssize_t gadget_dev_desc_bcdUSB_store(struct config_item *item,
 212                const char *page, size_t len)
 213{
 214        u16 bcdUSB;
 215        int ret;
 216
 217        ret = kstrtou16(page, 0, &bcdUSB);
 218        if (ret)
 219                return ret;
 220        ret = is_valid_bcd(bcdUSB);
 221        if (ret)
 222                return ret;
 223
 224        to_gadget_info(item)->cdev.desc.bcdUSB = cpu_to_le16(bcdUSB);
 225        return len;
 226}
 227
 228static ssize_t gadget_dev_desc_UDC_show(struct config_item *item, char *page)
 229{
 230        struct gadget_info *gi = to_gadget_info(item);
 231        char *udc_name;
 232        int ret;
 233
 234        mutex_lock(&gi->lock);
 235        udc_name = gi->composite.gadget_driver.udc_name;
 236        ret = sprintf(page, "%s\n", udc_name ?: "");
 237        mutex_unlock(&gi->lock);
 238
 239        return ret;
 240}
 241
 242static int unregister_gadget(struct gadget_info *gi)
 243{
 244        int ret;
 245
 246        if (!gi->composite.gadget_driver.udc_name)
 247                return -ENODEV;
 248
 249        ret = usb_gadget_unregister_driver(&gi->composite.gadget_driver);
 250        if (ret)
 251                return ret;
 252        kfree(gi->composite.gadget_driver.udc_name);
 253        gi->composite.gadget_driver.udc_name = NULL;
 254        return 0;
 255}
 256
 257static ssize_t gadget_dev_desc_UDC_store(struct config_item *item,
 258                const char *page, size_t len)
 259{
 260        struct gadget_info *gi = to_gadget_info(item);
 261        char *name;
 262        int ret;
 263
 264        if (strlen(page) < len)
 265                return -EOVERFLOW;
 266
 267        name = kstrdup(page, GFP_KERNEL);
 268        if (!name)
 269                return -ENOMEM;
 270        if (name[len - 1] == '\n')
 271                name[len - 1] = '\0';
 272
 273        mutex_lock(&gi->lock);
 274
 275        if (!strlen(name)) {
 276                ret = unregister_gadget(gi);
 277                if (ret)
 278                        goto err;
 279                kfree(name);
 280        } else {
 281                if (gi->composite.gadget_driver.udc_name) {
 282                        ret = -EBUSY;
 283                        goto err;
 284                }
 285                gi->composite.gadget_driver.udc_name = name;
 286                ret = usb_gadget_probe_driver(&gi->composite.gadget_driver);
 287                if (ret) {
 288                        gi->composite.gadget_driver.udc_name = NULL;
 289                        goto err;
 290                }
 291        }
 292        mutex_unlock(&gi->lock);
 293        return len;
 294err:
 295        kfree(name);
 296        mutex_unlock(&gi->lock);
 297        return ret;
 298}
 299
 300static ssize_t gadget_dev_desc_max_speed_show(struct config_item *item,
 301                                              char *page)
 302{
 303        enum usb_device_speed speed = to_gadget_info(item)->composite.max_speed;
 304
 305        return sprintf(page, "%s\n", usb_speed_string(speed));
 306}
 307
 308static ssize_t gadget_dev_desc_max_speed_store(struct config_item *item,
 309                                               const char *page, size_t len)
 310{
 311        struct gadget_info *gi = to_gadget_info(item);
 312
 313        mutex_lock(&gi->lock);
 314
 315        /* Prevent changing of max_speed after the driver is binded */
 316        if (gi->composite.gadget_driver.udc_name)
 317                goto err;
 318
 319        if (strncmp(page, "super-speed-plus", 16) == 0)
 320                gi->composite.max_speed = USB_SPEED_SUPER_PLUS;
 321        else if (strncmp(page, "super-speed", 11) == 0)
 322                gi->composite.max_speed = USB_SPEED_SUPER;
 323        else if (strncmp(page, "high-speed", 10) == 0)
 324                gi->composite.max_speed = USB_SPEED_HIGH;
 325        else if (strncmp(page, "full-speed", 10) == 0)
 326                gi->composite.max_speed = USB_SPEED_FULL;
 327        else if (strncmp(page, "low-speed", 9) == 0)
 328                gi->composite.max_speed = USB_SPEED_LOW;
 329        else
 330                goto err;
 331
 332        gi->composite.gadget_driver.max_speed = gi->composite.max_speed;
 333
 334        mutex_unlock(&gi->lock);
 335        return len;
 336err:
 337        mutex_unlock(&gi->lock);
 338        return -EINVAL;
 339}
 340
 341CONFIGFS_ATTR(gadget_dev_desc_, bDeviceClass);
 342CONFIGFS_ATTR(gadget_dev_desc_, bDeviceSubClass);
 343CONFIGFS_ATTR(gadget_dev_desc_, bDeviceProtocol);
 344CONFIGFS_ATTR(gadget_dev_desc_, bMaxPacketSize0);
 345CONFIGFS_ATTR(gadget_dev_desc_, idVendor);
 346CONFIGFS_ATTR(gadget_dev_desc_, idProduct);
 347CONFIGFS_ATTR(gadget_dev_desc_, bcdDevice);
 348CONFIGFS_ATTR(gadget_dev_desc_, bcdUSB);
 349CONFIGFS_ATTR(gadget_dev_desc_, UDC);
 350CONFIGFS_ATTR(gadget_dev_desc_, max_speed);
 351
 352static struct configfs_attribute *gadget_root_attrs[] = {
 353        &gadget_dev_desc_attr_bDeviceClass,
 354        &gadget_dev_desc_attr_bDeviceSubClass,
 355        &gadget_dev_desc_attr_bDeviceProtocol,
 356        &gadget_dev_desc_attr_bMaxPacketSize0,
 357        &gadget_dev_desc_attr_idVendor,
 358        &gadget_dev_desc_attr_idProduct,
 359        &gadget_dev_desc_attr_bcdDevice,
 360        &gadget_dev_desc_attr_bcdUSB,
 361        &gadget_dev_desc_attr_UDC,
 362        &gadget_dev_desc_attr_max_speed,
 363        NULL,
 364};
 365
 366static inline struct gadget_strings *to_gadget_strings(struct config_item *item)
 367{
 368         return container_of(to_config_group(item), struct gadget_strings,
 369                         group);
 370}
 371
 372static inline struct gadget_config_name *to_gadget_config_name(
 373                struct config_item *item)
 374{
 375         return container_of(to_config_group(item), struct gadget_config_name,
 376                         group);
 377}
 378
 379static inline struct usb_function_instance *to_usb_function_instance(
 380                struct config_item *item)
 381{
 382         return container_of(to_config_group(item),
 383                         struct usb_function_instance, group);
 384}
 385
 386static void gadget_info_attr_release(struct config_item *item)
 387{
 388        struct gadget_info *gi = to_gadget_info(item);
 389
 390        WARN_ON(!list_empty(&gi->cdev.configs));
 391        WARN_ON(!list_empty(&gi->string_list));
 392        WARN_ON(!list_empty(&gi->available_func));
 393        kfree(gi->composite.gadget_driver.function);
 394        kfree(gi);
 395}
 396
 397static struct configfs_item_operations gadget_root_item_ops = {
 398        .release                = gadget_info_attr_release,
 399};
 400
 401static void gadget_config_attr_release(struct config_item *item)
 402{
 403        struct config_usb_cfg *cfg = to_config_usb_cfg(item);
 404
 405        WARN_ON(!list_empty(&cfg->c.functions));
 406        list_del(&cfg->c.list);
 407        kfree(cfg->c.label);
 408        kfree(cfg);
 409}
 410
 411static int config_usb_cfg_link(
 412        struct config_item *usb_cfg_ci,
 413        struct config_item *usb_func_ci)
 414{
 415        struct config_usb_cfg *cfg = to_config_usb_cfg(usb_cfg_ci);
 416        struct usb_composite_dev *cdev = cfg->c.cdev;
 417        struct gadget_info *gi = container_of(cdev, struct gadget_info, cdev);
 418
 419        struct config_group *group = to_config_group(usb_func_ci);
 420        struct usb_function_instance *fi = container_of(group,
 421                        struct usb_function_instance, group);
 422        struct usb_function_instance *a_fi;
 423        struct usb_function *f;
 424        int ret;
 425
 426        mutex_lock(&gi->lock);
 427        /*
 428         * Make sure this function is from within our _this_ gadget and not
 429         * from another gadget or a random directory.
 430         * Also a function instance can only be linked once.
 431         */
 432        list_for_each_entry(a_fi, &gi->available_func, cfs_list) {
 433                if (a_fi == fi)
 434                        break;
 435        }
 436        if (a_fi != fi) {
 437                ret = -EINVAL;
 438                goto out;
 439        }
 440
 441        list_for_each_entry(f, &cfg->func_list, list) {
 442                if (f->fi == fi) {
 443                        ret = -EEXIST;
 444                        goto out;
 445                }
 446        }
 447
 448        f = usb_get_function(fi);
 449        if (IS_ERR(f)) {
 450                ret = PTR_ERR(f);
 451                goto out;
 452        }
 453
 454        /* stash the function until we bind it to the gadget */
 455        list_add_tail(&f->list, &cfg->func_list);
 456        ret = 0;
 457out:
 458        mutex_unlock(&gi->lock);
 459        return ret;
 460}
 461
 462static void config_usb_cfg_unlink(
 463        struct config_item *usb_cfg_ci,
 464        struct config_item *usb_func_ci)
 465{
 466        struct config_usb_cfg *cfg = to_config_usb_cfg(usb_cfg_ci);
 467        struct usb_composite_dev *cdev = cfg->c.cdev;
 468        struct gadget_info *gi = container_of(cdev, struct gadget_info, cdev);
 469
 470        struct config_group *group = to_config_group(usb_func_ci);
 471        struct usb_function_instance *fi = container_of(group,
 472                        struct usb_function_instance, group);
 473        struct usb_function *f;
 474
 475        /*
 476         * ideally I would like to forbid to unlink functions while a gadget is
 477         * bound to an UDC. Since this isn't possible at the moment, we simply
 478         * force an unbind, the function is available here and then we can
 479         * remove the function.
 480         */
 481        mutex_lock(&gi->lock);
 482        if (gi->composite.gadget_driver.udc_name)
 483                unregister_gadget(gi);
 484        WARN_ON(gi->composite.gadget_driver.udc_name);
 485
 486        list_for_each_entry(f, &cfg->func_list, list) {
 487                if (f->fi == fi) {
 488                        list_del(&f->list);
 489                        usb_put_function(f);
 490                        mutex_unlock(&gi->lock);
 491                        return;
 492                }
 493        }
 494        mutex_unlock(&gi->lock);
 495        WARN(1, "Unable to locate function to unbind\n");
 496}
 497
 498static struct configfs_item_operations gadget_config_item_ops = {
 499        .release                = gadget_config_attr_release,
 500        .allow_link             = config_usb_cfg_link,
 501        .drop_link              = config_usb_cfg_unlink,
 502};
 503
 504
 505static ssize_t gadget_config_desc_MaxPower_show(struct config_item *item,
 506                char *page)
 507{
 508        return sprintf(page, "%u\n", to_config_usb_cfg(item)->c.MaxPower);
 509}
 510
 511static ssize_t gadget_config_desc_MaxPower_store(struct config_item *item,
 512                const char *page, size_t len)
 513{
 514        u16 val;
 515        int ret;
 516        ret = kstrtou16(page, 0, &val);
 517        if (ret)
 518                return ret;
 519        if (DIV_ROUND_UP(val, 8) > 0xff)
 520                return -ERANGE;
 521        to_config_usb_cfg(item)->c.MaxPower = val;
 522        return len;
 523}
 524
 525static ssize_t gadget_config_desc_bmAttributes_show(struct config_item *item,
 526                char *page)
 527{
 528        return sprintf(page, "0x%02x\n",
 529                to_config_usb_cfg(item)->c.bmAttributes);
 530}
 531
 532static ssize_t gadget_config_desc_bmAttributes_store(struct config_item *item,
 533                const char *page, size_t len)
 534{
 535        u8 val;
 536        int ret;
 537        ret = kstrtou8(page, 0, &val);
 538        if (ret)
 539                return ret;
 540        if (!(val & USB_CONFIG_ATT_ONE))
 541                return -EINVAL;
 542        if (val & ~(USB_CONFIG_ATT_ONE | USB_CONFIG_ATT_SELFPOWER |
 543                                USB_CONFIG_ATT_WAKEUP))
 544                return -EINVAL;
 545        to_config_usb_cfg(item)->c.bmAttributes = val;
 546        return len;
 547}
 548
 549CONFIGFS_ATTR(gadget_config_desc_, MaxPower);
 550CONFIGFS_ATTR(gadget_config_desc_, bmAttributes);
 551
 552static struct configfs_attribute *gadget_config_attrs[] = {
 553        &gadget_config_desc_attr_MaxPower,
 554        &gadget_config_desc_attr_bmAttributes,
 555        NULL,
 556};
 557
 558static const struct config_item_type gadget_config_type = {
 559        .ct_item_ops    = &gadget_config_item_ops,
 560        .ct_attrs       = gadget_config_attrs,
 561        .ct_owner       = THIS_MODULE,
 562};
 563
 564static const struct config_item_type gadget_root_type = {
 565        .ct_item_ops    = &gadget_root_item_ops,
 566        .ct_attrs       = gadget_root_attrs,
 567        .ct_owner       = THIS_MODULE,
 568};
 569
 570static void composite_init_dev(struct usb_composite_dev *cdev)
 571{
 572        spin_lock_init(&cdev->lock);
 573        INIT_LIST_HEAD(&cdev->configs);
 574        INIT_LIST_HEAD(&cdev->gstrings);
 575}
 576
 577static struct config_group *function_make(
 578                struct config_group *group,
 579                const char *name)
 580{
 581        struct gadget_info *gi;
 582        struct usb_function_instance *fi;
 583        char buf[MAX_NAME_LEN];
 584        char *func_name;
 585        char *instance_name;
 586        int ret;
 587
 588        ret = snprintf(buf, MAX_NAME_LEN, "%s", name);
 589        if (ret >= MAX_NAME_LEN)
 590                return ERR_PTR(-ENAMETOOLONG);
 591
 592        func_name = buf;
 593        instance_name = strchr(func_name, '.');
 594        if (!instance_name) {
 595                pr_err("Unable to locate . in FUNC.INSTANCE\n");
 596                return ERR_PTR(-EINVAL);
 597        }
 598        *instance_name = '\0';
 599        instance_name++;
 600
 601        fi = usb_get_function_instance(func_name);
 602        if (IS_ERR(fi))
 603                return ERR_CAST(fi);
 604
 605        ret = config_item_set_name(&fi->group.cg_item, "%s", name);
 606        if (ret) {
 607                usb_put_function_instance(fi);
 608                return ERR_PTR(ret);
 609        }
 610        if (fi->set_inst_name) {
 611                ret = fi->set_inst_name(fi, instance_name);
 612                if (ret) {
 613                        usb_put_function_instance(fi);
 614                        return ERR_PTR(ret);
 615                }
 616        }
 617
 618        gi = container_of(group, struct gadget_info, functions_group);
 619
 620        mutex_lock(&gi->lock);
 621        list_add_tail(&fi->cfs_list, &gi->available_func);
 622        mutex_unlock(&gi->lock);
 623        return &fi->group;
 624}
 625
 626static void function_drop(
 627                struct config_group *group,
 628                struct config_item *item)
 629{
 630        struct usb_function_instance *fi = to_usb_function_instance(item);
 631        struct gadget_info *gi;
 632
 633        gi = container_of(group, struct gadget_info, functions_group);
 634
 635        mutex_lock(&gi->lock);
 636        list_del(&fi->cfs_list);
 637        mutex_unlock(&gi->lock);
 638        config_item_put(item);
 639}
 640
 641static struct configfs_group_operations functions_ops = {
 642        .make_group     = &function_make,
 643        .drop_item      = &function_drop,
 644};
 645
 646static const struct config_item_type functions_type = {
 647        .ct_group_ops   = &functions_ops,
 648        .ct_owner       = THIS_MODULE,
 649};
 650
 651GS_STRINGS_RW(gadget_config_name, configuration);
 652
 653static struct configfs_attribute *gadget_config_name_langid_attrs[] = {
 654        &gadget_config_name_attr_configuration,
 655        NULL,
 656};
 657
 658static void gadget_config_name_attr_release(struct config_item *item)
 659{
 660        struct gadget_config_name *cn = to_gadget_config_name(item);
 661
 662        kfree(cn->configuration);
 663
 664        list_del(&cn->list);
 665        kfree(cn);
 666}
 667
 668USB_CONFIG_STRING_RW_OPS(gadget_config_name);
 669USB_CONFIG_STRINGS_LANG(gadget_config_name, config_usb_cfg);
 670
 671static struct config_group *config_desc_make(
 672                struct config_group *group,
 673                const char *name)
 674{
 675        struct gadget_info *gi;
 676        struct config_usb_cfg *cfg;
 677        char buf[MAX_NAME_LEN];
 678        char *num_str;
 679        u8 num;
 680        int ret;
 681
 682        gi = container_of(group, struct gadget_info, configs_group);
 683        ret = snprintf(buf, MAX_NAME_LEN, "%s", name);
 684        if (ret >= MAX_NAME_LEN)
 685                return ERR_PTR(-ENAMETOOLONG);
 686
 687        num_str = strchr(buf, '.');
 688        if (!num_str) {
 689                pr_err("Unable to locate . in name.bConfigurationValue\n");
 690                return ERR_PTR(-EINVAL);
 691        }
 692
 693        *num_str = '\0';
 694        num_str++;
 695
 696        if (!strlen(buf))
 697                return ERR_PTR(-EINVAL);
 698
 699        ret = kstrtou8(num_str, 0, &num);
 700        if (ret)
 701                return ERR_PTR(ret);
 702
 703        cfg = kzalloc(sizeof(*cfg), GFP_KERNEL);
 704        if (!cfg)
 705                return ERR_PTR(-ENOMEM);
 706        cfg->c.label = kstrdup(buf, GFP_KERNEL);
 707        if (!cfg->c.label) {
 708                ret = -ENOMEM;
 709                goto err;
 710        }
 711        cfg->c.bConfigurationValue = num;
 712        cfg->c.MaxPower = CONFIG_USB_GADGET_VBUS_DRAW;
 713        cfg->c.bmAttributes = USB_CONFIG_ATT_ONE;
 714        INIT_LIST_HEAD(&cfg->string_list);
 715        INIT_LIST_HEAD(&cfg->func_list);
 716
 717        config_group_init_type_name(&cfg->group, name,
 718                                &gadget_config_type);
 719
 720        config_group_init_type_name(&cfg->strings_group, "strings",
 721                        &gadget_config_name_strings_type);
 722        configfs_add_default_group(&cfg->strings_group, &cfg->group);
 723
 724        ret = usb_add_config_only(&gi->cdev, &cfg->c);
 725        if (ret)
 726                goto err;
 727
 728        return &cfg->group;
 729err:
 730        kfree(cfg->c.label);
 731        kfree(cfg);
 732        return ERR_PTR(ret);
 733}
 734
 735static void config_desc_drop(
 736                struct config_group *group,
 737                struct config_item *item)
 738{
 739        config_item_put(item);
 740}
 741
 742static struct configfs_group_operations config_desc_ops = {
 743        .make_group     = &config_desc_make,
 744        .drop_item      = &config_desc_drop,
 745};
 746
 747static const struct config_item_type config_desc_type = {
 748        .ct_group_ops   = &config_desc_ops,
 749        .ct_owner       = THIS_MODULE,
 750};
 751
 752GS_STRINGS_RW(gadget_strings, manufacturer);
 753GS_STRINGS_RW(gadget_strings, product);
 754GS_STRINGS_RW(gadget_strings, serialnumber);
 755
 756static struct configfs_attribute *gadget_strings_langid_attrs[] = {
 757        &gadget_strings_attr_manufacturer,
 758        &gadget_strings_attr_product,
 759        &gadget_strings_attr_serialnumber,
 760        NULL,
 761};
 762
 763static void gadget_strings_attr_release(struct config_item *item)
 764{
 765        struct gadget_strings *gs = to_gadget_strings(item);
 766
 767        kfree(gs->manufacturer);
 768        kfree(gs->product);
 769        kfree(gs->serialnumber);
 770
 771        list_del(&gs->list);
 772        kfree(gs);
 773}
 774
 775USB_CONFIG_STRING_RW_OPS(gadget_strings);
 776USB_CONFIG_STRINGS_LANG(gadget_strings, gadget_info);
 777
 778static inline struct os_desc *to_os_desc(struct config_item *item)
 779{
 780        return container_of(to_config_group(item), struct os_desc, group);
 781}
 782
 783static inline struct gadget_info *os_desc_item_to_gadget_info(
 784                struct config_item *item)
 785{
 786        return to_gadget_info(to_os_desc(item)->group.cg_item.ci_parent);
 787}
 788
 789static ssize_t os_desc_use_show(struct config_item *item, char *page)
 790{
 791        return sprintf(page, "%d\n",
 792                        os_desc_item_to_gadget_info(item)->use_os_desc);
 793}
 794
 795static ssize_t os_desc_use_store(struct config_item *item, const char *page,
 796                                 size_t len)
 797{
 798        struct gadget_info *gi = os_desc_item_to_gadget_info(item);
 799        int ret;
 800        bool use;
 801
 802        mutex_lock(&gi->lock);
 803        ret = strtobool(page, &use);
 804        if (!ret) {
 805                gi->use_os_desc = use;
 806                ret = len;
 807        }
 808        mutex_unlock(&gi->lock);
 809
 810        return ret;
 811}
 812
 813static ssize_t os_desc_b_vendor_code_show(struct config_item *item, char *page)
 814{
 815        return sprintf(page, "0x%02x\n",
 816                        os_desc_item_to_gadget_info(item)->b_vendor_code);
 817}
 818
 819static ssize_t os_desc_b_vendor_code_store(struct config_item *item,
 820                                           const char *page, size_t len)
 821{
 822        struct gadget_info *gi = os_desc_item_to_gadget_info(item);
 823        int ret;
 824        u8 b_vendor_code;
 825
 826        mutex_lock(&gi->lock);
 827        ret = kstrtou8(page, 0, &b_vendor_code);
 828        if (!ret) {
 829                gi->b_vendor_code = b_vendor_code;
 830                ret = len;
 831        }
 832        mutex_unlock(&gi->lock);
 833
 834        return ret;
 835}
 836
 837static ssize_t os_desc_qw_sign_show(struct config_item *item, char *page)
 838{
 839        struct gadget_info *gi = os_desc_item_to_gadget_info(item);
 840        int res;
 841
 842        res = utf16s_to_utf8s((wchar_t *) gi->qw_sign, OS_STRING_QW_SIGN_LEN,
 843                              UTF16_LITTLE_ENDIAN, page, PAGE_SIZE - 1);
 844        page[res++] = '\n';
 845
 846        return res;
 847}
 848
 849static ssize_t os_desc_qw_sign_store(struct config_item *item, const char *page,
 850                                     size_t len)
 851{
 852        struct gadget_info *gi = os_desc_item_to_gadget_info(item);
 853        int res, l;
 854
 855        l = min((int)len, OS_STRING_QW_SIGN_LEN >> 1);
 856        if (page[l - 1] == '\n')
 857                --l;
 858
 859        mutex_lock(&gi->lock);
 860        res = utf8s_to_utf16s(page, l,
 861                              UTF16_LITTLE_ENDIAN, (wchar_t *) gi->qw_sign,
 862                              OS_STRING_QW_SIGN_LEN);
 863        if (res > 0)
 864                res = len;
 865        mutex_unlock(&gi->lock);
 866
 867        return res;
 868}
 869
 870CONFIGFS_ATTR(os_desc_, use);
 871CONFIGFS_ATTR(os_desc_, b_vendor_code);
 872CONFIGFS_ATTR(os_desc_, qw_sign);
 873
 874static struct configfs_attribute *os_desc_attrs[] = {
 875        &os_desc_attr_use,
 876        &os_desc_attr_b_vendor_code,
 877        &os_desc_attr_qw_sign,
 878        NULL,
 879};
 880
 881static void os_desc_attr_release(struct config_item *item)
 882{
 883        struct os_desc *os_desc = to_os_desc(item);
 884        kfree(os_desc);
 885}
 886
 887static int os_desc_link(struct config_item *os_desc_ci,
 888                        struct config_item *usb_cfg_ci)
 889{
 890        struct gadget_info *gi = container_of(to_config_group(os_desc_ci),
 891                                        struct gadget_info, os_desc_group);
 892        struct usb_composite_dev *cdev = &gi->cdev;
 893        struct config_usb_cfg *c_target =
 894                container_of(to_config_group(usb_cfg_ci),
 895                             struct config_usb_cfg, group);
 896        struct usb_configuration *c;
 897        int ret;
 898
 899        mutex_lock(&gi->lock);
 900        list_for_each_entry(c, &cdev->configs, list) {
 901                if (c == &c_target->c)
 902                        break;
 903        }
 904        if (c != &c_target->c) {
 905                ret = -EINVAL;
 906                goto out;
 907        }
 908
 909        if (cdev->os_desc_config) {
 910                ret = -EBUSY;
 911                goto out;
 912        }
 913
 914        cdev->os_desc_config = &c_target->c;
 915        ret = 0;
 916
 917out:
 918        mutex_unlock(&gi->lock);
 919        return ret;
 920}
 921
 922static void os_desc_unlink(struct config_item *os_desc_ci,
 923                          struct config_item *usb_cfg_ci)
 924{
 925        struct gadget_info *gi = container_of(to_config_group(os_desc_ci),
 926                                        struct gadget_info, os_desc_group);
 927        struct usb_composite_dev *cdev = &gi->cdev;
 928
 929        mutex_lock(&gi->lock);
 930        if (gi->composite.gadget_driver.udc_name)
 931                unregister_gadget(gi);
 932        cdev->os_desc_config = NULL;
 933        WARN_ON(gi->composite.gadget_driver.udc_name);
 934        mutex_unlock(&gi->lock);
 935}
 936
 937static struct configfs_item_operations os_desc_ops = {
 938        .release                = os_desc_attr_release,
 939        .allow_link             = os_desc_link,
 940        .drop_link              = os_desc_unlink,
 941};
 942
 943static struct config_item_type os_desc_type = {
 944        .ct_item_ops    = &os_desc_ops,
 945        .ct_attrs       = os_desc_attrs,
 946        .ct_owner       = THIS_MODULE,
 947};
 948
 949static inline struct usb_os_desc_ext_prop
 950*to_usb_os_desc_ext_prop(struct config_item *item)
 951{
 952        return container_of(item, struct usb_os_desc_ext_prop, item);
 953}
 954
 955static ssize_t ext_prop_type_show(struct config_item *item, char *page)
 956{
 957        return sprintf(page, "%d\n", to_usb_os_desc_ext_prop(item)->type);
 958}
 959
 960static ssize_t ext_prop_type_store(struct config_item *item,
 961                                   const char *page, size_t len)
 962{
 963        struct usb_os_desc_ext_prop *ext_prop = to_usb_os_desc_ext_prop(item);
 964        struct usb_os_desc *desc = to_usb_os_desc(ext_prop->item.ci_parent);
 965        u8 type;
 966        int ret;
 967
 968        if (desc->opts_mutex)
 969                mutex_lock(desc->opts_mutex);
 970        ret = kstrtou8(page, 0, &type);
 971        if (ret)
 972                goto end;
 973        if (type < USB_EXT_PROP_UNICODE || type > USB_EXT_PROP_UNICODE_MULTI) {
 974                ret = -EINVAL;
 975                goto end;
 976        }
 977
 978        if ((ext_prop->type == USB_EXT_PROP_BINARY ||
 979            ext_prop->type == USB_EXT_PROP_LE32 ||
 980            ext_prop->type == USB_EXT_PROP_BE32) &&
 981            (type == USB_EXT_PROP_UNICODE ||
 982            type == USB_EXT_PROP_UNICODE_ENV ||
 983            type == USB_EXT_PROP_UNICODE_LINK))
 984                ext_prop->data_len <<= 1;
 985        else if ((ext_prop->type == USB_EXT_PROP_UNICODE ||
 986                   ext_prop->type == USB_EXT_PROP_UNICODE_ENV ||
 987                   ext_prop->type == USB_EXT_PROP_UNICODE_LINK) &&
 988                   (type == USB_EXT_PROP_BINARY ||
 989                   type == USB_EXT_PROP_LE32 ||
 990                   type == USB_EXT_PROP_BE32))
 991                ext_prop->data_len >>= 1;
 992        ext_prop->type = type;
 993        ret = len;
 994
 995end:
 996        if (desc->opts_mutex)
 997                mutex_unlock(desc->opts_mutex);
 998        return ret;
 999}
1000
1001static ssize_t ext_prop_data_show(struct config_item *item, char *page)
1002{
1003        struct usb_os_desc_ext_prop *ext_prop = to_usb_os_desc_ext_prop(item);
1004        int len = ext_prop->data_len;
1005
1006        if (ext_prop->type == USB_EXT_PROP_UNICODE ||
1007            ext_prop->type == USB_EXT_PROP_UNICODE_ENV ||
1008            ext_prop->type == USB_EXT_PROP_UNICODE_LINK)
1009                len >>= 1;
1010        memcpy(page, ext_prop->data, len);
1011
1012        return len;
1013}
1014
1015static ssize_t ext_prop_data_store(struct config_item *item,
1016                                   const char *page, size_t len)
1017{
1018        struct usb_os_desc_ext_prop *ext_prop = to_usb_os_desc_ext_prop(item);
1019        struct usb_os_desc *desc = to_usb_os_desc(ext_prop->item.ci_parent);
1020        char *new_data;
1021        size_t ret_len = len;
1022
1023        if (page[len - 1] == '\n' || page[len - 1] == '\0')
1024                --len;
1025        new_data = kmemdup(page, len, GFP_KERNEL);
1026        if (!new_data)
1027                return -ENOMEM;
1028
1029        if (desc->opts_mutex)
1030                mutex_lock(desc->opts_mutex);
1031        kfree(ext_prop->data);
1032        ext_prop->data = new_data;
1033        desc->ext_prop_len -= ext_prop->data_len;
1034        ext_prop->data_len = len;
1035        desc->ext_prop_len += ext_prop->data_len;
1036        if (ext_prop->type == USB_EXT_PROP_UNICODE ||
1037            ext_prop->type == USB_EXT_PROP_UNICODE_ENV ||
1038            ext_prop->type == USB_EXT_PROP_UNICODE_LINK) {
1039                desc->ext_prop_len -= ext_prop->data_len;
1040                ext_prop->data_len <<= 1;
1041                ext_prop->data_len += 2;
1042                desc->ext_prop_len += ext_prop->data_len;
1043        }
1044        if (desc->opts_mutex)
1045                mutex_unlock(desc->opts_mutex);
1046        return ret_len;
1047}
1048
1049CONFIGFS_ATTR(ext_prop_, type);
1050CONFIGFS_ATTR(ext_prop_, data);
1051
1052static struct configfs_attribute *ext_prop_attrs[] = {
1053        &ext_prop_attr_type,
1054        &ext_prop_attr_data,
1055        NULL,
1056};
1057
1058static void usb_os_desc_ext_prop_release(struct config_item *item)
1059{
1060        struct usb_os_desc_ext_prop *ext_prop = to_usb_os_desc_ext_prop(item);
1061
1062        kfree(ext_prop); /* frees a whole chunk */
1063}
1064
1065static struct configfs_item_operations ext_prop_ops = {
1066        .release                = usb_os_desc_ext_prop_release,
1067};
1068
1069static struct config_item *ext_prop_make(
1070                struct config_group *group,
1071                const char *name)
1072{
1073        struct usb_os_desc_ext_prop *ext_prop;
1074        struct config_item_type *ext_prop_type;
1075        struct usb_os_desc *desc;
1076        char *vlabuf;
1077
1078        vla_group(data_chunk);
1079        vla_item(data_chunk, struct usb_os_desc_ext_prop, ext_prop, 1);
1080        vla_item(data_chunk, struct config_item_type, ext_prop_type, 1);
1081
1082        vlabuf = kzalloc(vla_group_size(data_chunk), GFP_KERNEL);
1083        if (!vlabuf)
1084                return ERR_PTR(-ENOMEM);
1085
1086        ext_prop = vla_ptr(vlabuf, data_chunk, ext_prop);
1087        ext_prop_type = vla_ptr(vlabuf, data_chunk, ext_prop_type);
1088
1089        desc = container_of(group, struct usb_os_desc, group);
1090        ext_prop_type->ct_item_ops = &ext_prop_ops;
1091        ext_prop_type->ct_attrs = ext_prop_attrs;
1092        ext_prop_type->ct_owner = desc->owner;
1093
1094        config_item_init_type_name(&ext_prop->item, name, ext_prop_type);
1095
1096        ext_prop->name = kstrdup(name, GFP_KERNEL);
1097        if (!ext_prop->name) {
1098                kfree(vlabuf);
1099                return ERR_PTR(-ENOMEM);
1100        }
1101        desc->ext_prop_len += 14;
1102        ext_prop->name_len = 2 * strlen(ext_prop->name) + 2;
1103        if (desc->opts_mutex)
1104                mutex_lock(desc->opts_mutex);
1105        desc->ext_prop_len += ext_prop->name_len;
1106        list_add_tail(&ext_prop->entry, &desc->ext_prop);
1107        ++desc->ext_prop_count;
1108        if (desc->opts_mutex)
1109                mutex_unlock(desc->opts_mutex);
1110
1111        return &ext_prop->item;
1112}
1113
1114static void ext_prop_drop(struct config_group *group, struct config_item *item)
1115{
1116        struct usb_os_desc_ext_prop *ext_prop = to_usb_os_desc_ext_prop(item);
1117        struct usb_os_desc *desc = to_usb_os_desc(&group->cg_item);
1118
1119        if (desc->opts_mutex)
1120                mutex_lock(desc->opts_mutex);
1121        list_del(&ext_prop->entry);
1122        --desc->ext_prop_count;
1123        kfree(ext_prop->name);
1124        desc->ext_prop_len -= (ext_prop->name_len + ext_prop->data_len + 14);
1125        if (desc->opts_mutex)
1126                mutex_unlock(desc->opts_mutex);
1127        config_item_put(item);
1128}
1129
1130static struct configfs_group_operations interf_grp_ops = {
1131        .make_item      = &ext_prop_make,
1132        .drop_item      = &ext_prop_drop,
1133};
1134
1135static ssize_t interf_grp_compatible_id_show(struct config_item *item,
1136                                             char *page)
1137{
1138        memcpy(page, to_usb_os_desc(item)->ext_compat_id, 8);
1139        return 8;
1140}
1141
1142static ssize_t interf_grp_compatible_id_store(struct config_item *item,
1143                                              const char *page, size_t len)
1144{
1145        struct usb_os_desc *desc = to_usb_os_desc(item);
1146        int l;
1147
1148        l = min_t(int, 8, len);
1149        if (page[l - 1] == '\n')
1150                --l;
1151        if (desc->opts_mutex)
1152                mutex_lock(desc->opts_mutex);
1153        memcpy(desc->ext_compat_id, page, l);
1154
1155        if (desc->opts_mutex)
1156                mutex_unlock(desc->opts_mutex);
1157
1158        return len;
1159}
1160
1161static ssize_t interf_grp_sub_compatible_id_show(struct config_item *item,
1162                                                 char *page)
1163{
1164        memcpy(page, to_usb_os_desc(item)->ext_compat_id + 8, 8);
1165        return 8;
1166}
1167
1168static ssize_t interf_grp_sub_compatible_id_store(struct config_item *item,
1169                                                  const char *page, size_t len)
1170{
1171        struct usb_os_desc *desc = to_usb_os_desc(item);
1172        int l;
1173
1174        l = min_t(int, 8, len);
1175        if (page[l - 1] == '\n')
1176                --l;
1177        if (desc->opts_mutex)
1178                mutex_lock(desc->opts_mutex);
1179        memcpy(desc->ext_compat_id + 8, page, l);
1180
1181        if (desc->opts_mutex)
1182                mutex_unlock(desc->opts_mutex);
1183
1184        return len;
1185}
1186
1187CONFIGFS_ATTR(interf_grp_, compatible_id);
1188CONFIGFS_ATTR(interf_grp_, sub_compatible_id);
1189
1190static struct configfs_attribute *interf_grp_attrs[] = {
1191        &interf_grp_attr_compatible_id,
1192        &interf_grp_attr_sub_compatible_id,
1193        NULL
1194};
1195
1196struct config_group *usb_os_desc_prepare_interf_dir(
1197                struct config_group *parent,
1198                int n_interf,
1199                struct usb_os_desc **desc,
1200                char **names,
1201                struct module *owner)
1202{
1203        struct config_group *os_desc_group;
1204        struct config_item_type *os_desc_type, *interface_type;
1205
1206        vla_group(data_chunk);
1207        vla_item(data_chunk, struct config_group, os_desc_group, 1);
1208        vla_item(data_chunk, struct config_item_type, os_desc_type, 1);
1209        vla_item(data_chunk, struct config_item_type, interface_type, 1);
1210
1211        char *vlabuf = kzalloc(vla_group_size(data_chunk), GFP_KERNEL);
1212        if (!vlabuf)
1213                return ERR_PTR(-ENOMEM);
1214
1215        os_desc_group = vla_ptr(vlabuf, data_chunk, os_desc_group);
1216        os_desc_type = vla_ptr(vlabuf, data_chunk, os_desc_type);
1217        interface_type = vla_ptr(vlabuf, data_chunk, interface_type);
1218
1219        os_desc_type->ct_owner = owner;
1220        config_group_init_type_name(os_desc_group, "os_desc", os_desc_type);
1221        configfs_add_default_group(os_desc_group, parent);
1222
1223        interface_type->ct_group_ops = &interf_grp_ops;
1224        interface_type->ct_attrs = interf_grp_attrs;
1225        interface_type->ct_owner = owner;
1226
1227        while (n_interf--) {
1228                struct usb_os_desc *d;
1229
1230                d = desc[n_interf];
1231                d->owner = owner;
1232                config_group_init_type_name(&d->group, "", interface_type);
1233                config_item_set_name(&d->group.cg_item, "interface.%s",
1234                                     names[n_interf]);
1235                configfs_add_default_group(&d->group, os_desc_group);
1236        }
1237
1238        return os_desc_group;
1239}
1240EXPORT_SYMBOL(usb_os_desc_prepare_interf_dir);
1241
1242static int configfs_do_nothing(struct usb_composite_dev *cdev)
1243{
1244        WARN_ON(1);
1245        return -EINVAL;
1246}
1247
1248int composite_dev_prepare(struct usb_composite_driver *composite,
1249                struct usb_composite_dev *dev);
1250
1251int composite_os_desc_req_prepare(struct usb_composite_dev *cdev,
1252                                  struct usb_ep *ep0);
1253
1254static void purge_configs_funcs(struct gadget_info *gi)
1255{
1256        struct usb_configuration        *c;
1257
1258        list_for_each_entry(c, &gi->cdev.configs, list) {
1259                struct usb_function *f, *tmp;
1260                struct config_usb_cfg *cfg;
1261
1262                cfg = container_of(c, struct config_usb_cfg, c);
1263
1264                list_for_each_entry_safe_reverse(f, tmp, &c->functions, list) {
1265
1266                        list_move(&f->list, &cfg->func_list);
1267                        if (f->unbind) {
1268                                dev_dbg(&gi->cdev.gadget->dev,
1269                                        "unbind function '%s'/%p\n",
1270                                        f->name, f);
1271                                f->unbind(c, f);
1272                        }
1273                }
1274                c->next_interface_id = 0;
1275                memset(c->interface, 0, sizeof(c->interface));
1276                c->superspeed_plus = 0;
1277                c->superspeed = 0;
1278                c->highspeed = 0;
1279                c->fullspeed = 0;
1280        }
1281}
1282
1283static int configfs_composite_bind(struct usb_gadget *gadget,
1284                struct usb_gadget_driver *gdriver)
1285{
1286        struct usb_composite_driver     *composite = to_cdriver(gdriver);
1287        struct gadget_info              *gi = container_of(composite,
1288                                                struct gadget_info, composite);
1289        struct usb_composite_dev        *cdev = &gi->cdev;
1290        struct usb_configuration        *c;
1291        struct usb_string               *s;
1292        unsigned                        i;
1293        int                             ret;
1294
1295        /* the gi->lock is hold by the caller */
1296        gi->unbind = 0;
1297        cdev->gadget = gadget;
1298        set_gadget_data(gadget, cdev);
1299        ret = composite_dev_prepare(composite, cdev);
1300        if (ret)
1301                return ret;
1302        /* and now the gadget bind */
1303        ret = -EINVAL;
1304
1305        if (list_empty(&gi->cdev.configs)) {
1306                pr_err("Need at least one configuration in %s.\n",
1307                                gi->composite.name);
1308                goto err_comp_cleanup;
1309        }
1310
1311
1312        list_for_each_entry(c, &gi->cdev.configs, list) {
1313                struct config_usb_cfg *cfg;
1314
1315                cfg = container_of(c, struct config_usb_cfg, c);
1316                if (list_empty(&cfg->func_list)) {
1317                        pr_err("Config %s/%d of %s needs at least one function.\n",
1318                              c->label, c->bConfigurationValue,
1319                              gi->composite.name);
1320                        goto err_comp_cleanup;
1321                }
1322        }
1323
1324        /* init all strings */
1325        if (!list_empty(&gi->string_list)) {
1326                struct gadget_strings *gs;
1327
1328                i = 0;
1329                list_for_each_entry(gs, &gi->string_list, list) {
1330
1331                        gi->gstrings[i] = &gs->stringtab_dev;
1332                        gs->stringtab_dev.strings = gs->strings;
1333                        gs->strings[USB_GADGET_MANUFACTURER_IDX].s =
1334                                gs->manufacturer;
1335                        gs->strings[USB_GADGET_PRODUCT_IDX].s = gs->product;
1336                        gs->strings[USB_GADGET_SERIAL_IDX].s = gs->serialnumber;
1337                        i++;
1338                }
1339                gi->gstrings[i] = NULL;
1340                s = usb_gstrings_attach(&gi->cdev, gi->gstrings,
1341                                USB_GADGET_FIRST_AVAIL_IDX);
1342                if (IS_ERR(s)) {
1343                        ret = PTR_ERR(s);
1344                        goto err_comp_cleanup;
1345                }
1346
1347                gi->cdev.desc.iManufacturer = s[USB_GADGET_MANUFACTURER_IDX].id;
1348                gi->cdev.desc.iProduct = s[USB_GADGET_PRODUCT_IDX].id;
1349                gi->cdev.desc.iSerialNumber = s[USB_GADGET_SERIAL_IDX].id;
1350        }
1351
1352        if (gi->use_os_desc) {
1353                cdev->use_os_string = true;
1354                cdev->b_vendor_code = gi->b_vendor_code;
1355                memcpy(cdev->qw_sign, gi->qw_sign, OS_STRING_QW_SIGN_LEN);
1356        }
1357
1358        if (gadget_is_otg(gadget) && !otg_desc[0]) {
1359                struct usb_descriptor_header *usb_desc;
1360
1361                usb_desc = usb_otg_descriptor_alloc(gadget);
1362                if (!usb_desc) {
1363                        ret = -ENOMEM;
1364                        goto err_comp_cleanup;
1365                }
1366                usb_otg_descriptor_init(gadget, usb_desc);
1367                otg_desc[0] = usb_desc;
1368                otg_desc[1] = NULL;
1369        }
1370
1371        /* Go through all configs, attach all functions */
1372        list_for_each_entry(c, &gi->cdev.configs, list) {
1373                struct config_usb_cfg *cfg;
1374                struct usb_function *f;
1375                struct usb_function *tmp;
1376                struct gadget_config_name *cn;
1377
1378                if (gadget_is_otg(gadget))
1379                        c->descriptors = otg_desc;
1380
1381                cfg = container_of(c, struct config_usb_cfg, c);
1382                if (!list_empty(&cfg->string_list)) {
1383                        i = 0;
1384                        list_for_each_entry(cn, &cfg->string_list, list) {
1385                                cfg->gstrings[i] = &cn->stringtab_dev;
1386                                cn->stringtab_dev.strings = &cn->strings;
1387                                cn->strings.s = cn->configuration;
1388                                i++;
1389                        }
1390                        cfg->gstrings[i] = NULL;
1391                        s = usb_gstrings_attach(&gi->cdev, cfg->gstrings, 1);
1392                        if (IS_ERR(s)) {
1393                                ret = PTR_ERR(s);
1394                                goto err_comp_cleanup;
1395                        }
1396                        c->iConfiguration = s[0].id;
1397                }
1398
1399                list_for_each_entry_safe(f, tmp, &cfg->func_list, list) {
1400                        list_del(&f->list);
1401                        ret = usb_add_function(c, f);
1402                        if (ret) {
1403                                list_add(&f->list, &cfg->func_list);
1404                                goto err_purge_funcs;
1405                        }
1406                }
1407                usb_ep_autoconfig_reset(cdev->gadget);
1408        }
1409        if (cdev->use_os_string) {
1410                ret = composite_os_desc_req_prepare(cdev, gadget->ep0);
1411                if (ret)
1412                        goto err_purge_funcs;
1413        }
1414
1415        usb_ep_autoconfig_reset(cdev->gadget);
1416        return 0;
1417
1418err_purge_funcs:
1419        purge_configs_funcs(gi);
1420err_comp_cleanup:
1421        composite_dev_cleanup(cdev);
1422        return ret;
1423}
1424
1425static void configfs_composite_unbind(struct usb_gadget *gadget)
1426{
1427        struct usb_composite_dev        *cdev;
1428        struct gadget_info              *gi;
1429        unsigned long flags;
1430
1431        /* the gi->lock is hold by the caller */
1432
1433        cdev = get_gadget_data(gadget);
1434        gi = container_of(cdev, struct gadget_info, cdev);
1435        spin_lock_irqsave(&gi->spinlock, flags);
1436        gi->unbind = 1;
1437        spin_unlock_irqrestore(&gi->spinlock, flags);
1438
1439        kfree(otg_desc[0]);
1440        otg_desc[0] = NULL;
1441        purge_configs_funcs(gi);
1442        composite_dev_cleanup(cdev);
1443        usb_ep_autoconfig_reset(cdev->gadget);
1444        spin_lock_irqsave(&gi->spinlock, flags);
1445        cdev->gadget = NULL;
1446        set_gadget_data(gadget, NULL);
1447        spin_unlock_irqrestore(&gi->spinlock, flags);
1448}
1449
1450static int configfs_composite_setup(struct usb_gadget *gadget,
1451                const struct usb_ctrlrequest *ctrl)
1452{
1453        struct usb_composite_dev *cdev;
1454        struct gadget_info *gi;
1455        unsigned long flags;
1456        int ret;
1457
1458        cdev = get_gadget_data(gadget);
1459        if (!cdev)
1460                return 0;
1461
1462        gi = container_of(cdev, struct gadget_info, cdev);
1463        spin_lock_irqsave(&gi->spinlock, flags);
1464        cdev = get_gadget_data(gadget);
1465        if (!cdev || gi->unbind) {
1466                spin_unlock_irqrestore(&gi->spinlock, flags);
1467                return 0;
1468        }
1469
1470        ret = composite_setup(gadget, ctrl);
1471        spin_unlock_irqrestore(&gi->spinlock, flags);
1472        return ret;
1473}
1474
1475static void configfs_composite_disconnect(struct usb_gadget *gadget)
1476{
1477        struct usb_composite_dev *cdev;
1478        struct gadget_info *gi;
1479        unsigned long flags;
1480
1481        cdev = get_gadget_data(gadget);
1482        if (!cdev)
1483                return;
1484
1485        gi = container_of(cdev, struct gadget_info, cdev);
1486        spin_lock_irqsave(&gi->spinlock, flags);
1487        cdev = get_gadget_data(gadget);
1488        if (!cdev || gi->unbind) {
1489                spin_unlock_irqrestore(&gi->spinlock, flags);
1490                return;
1491        }
1492
1493        composite_disconnect(gadget);
1494        spin_unlock_irqrestore(&gi->spinlock, flags);
1495}
1496
1497static void configfs_composite_reset(struct usb_gadget *gadget)
1498{
1499        struct usb_composite_dev *cdev;
1500        struct gadget_info *gi;
1501        unsigned long flags;
1502
1503        cdev = get_gadget_data(gadget);
1504        if (!cdev)
1505                return;
1506
1507        gi = container_of(cdev, struct gadget_info, cdev);
1508        spin_lock_irqsave(&gi->spinlock, flags);
1509        cdev = get_gadget_data(gadget);
1510        if (!cdev || gi->unbind) {
1511                spin_unlock_irqrestore(&gi->spinlock, flags);
1512                return;
1513        }
1514
1515        composite_reset(gadget);
1516        spin_unlock_irqrestore(&gi->spinlock, flags);
1517}
1518
1519static void configfs_composite_suspend(struct usb_gadget *gadget)
1520{
1521        struct usb_composite_dev *cdev;
1522        struct gadget_info *gi;
1523        unsigned long flags;
1524
1525        cdev = get_gadget_data(gadget);
1526        if (!cdev)
1527                return;
1528
1529        gi = container_of(cdev, struct gadget_info, cdev);
1530        spin_lock_irqsave(&gi->spinlock, flags);
1531        cdev = get_gadget_data(gadget);
1532        if (!cdev || gi->unbind) {
1533                spin_unlock_irqrestore(&gi->spinlock, flags);
1534                return;
1535        }
1536
1537        composite_suspend(gadget);
1538        spin_unlock_irqrestore(&gi->spinlock, flags);
1539}
1540
1541static void configfs_composite_resume(struct usb_gadget *gadget)
1542{
1543        struct usb_composite_dev *cdev;
1544        struct gadget_info *gi;
1545        unsigned long flags;
1546
1547        cdev = get_gadget_data(gadget);
1548        if (!cdev)
1549                return;
1550
1551        gi = container_of(cdev, struct gadget_info, cdev);
1552        spin_lock_irqsave(&gi->spinlock, flags);
1553        cdev = get_gadget_data(gadget);
1554        if (!cdev || gi->unbind) {
1555                spin_unlock_irqrestore(&gi->spinlock, flags);
1556                return;
1557        }
1558
1559        composite_resume(gadget);
1560        spin_unlock_irqrestore(&gi->spinlock, flags);
1561}
1562
1563static const struct usb_gadget_driver configfs_driver_template = {
1564        .bind           = configfs_composite_bind,
1565        .unbind         = configfs_composite_unbind,
1566
1567        .setup          = configfs_composite_setup,
1568        .reset          = configfs_composite_reset,
1569        .disconnect     = configfs_composite_disconnect,
1570
1571        .suspend        = configfs_composite_suspend,
1572        .resume         = configfs_composite_resume,
1573
1574        .max_speed      = USB_SPEED_SUPER_PLUS,
1575        .driver = {
1576                .owner          = THIS_MODULE,
1577                .name           = "configfs-gadget",
1578        },
1579        .match_existing_only = 1,
1580};
1581
1582static struct config_group *gadgets_make(
1583                struct config_group *group,
1584                const char *name)
1585{
1586        struct gadget_info *gi;
1587
1588        gi = kzalloc(sizeof(*gi), GFP_KERNEL);
1589        if (!gi)
1590                return ERR_PTR(-ENOMEM);
1591
1592        config_group_init_type_name(&gi->group, name, &gadget_root_type);
1593
1594        config_group_init_type_name(&gi->functions_group, "functions",
1595                        &functions_type);
1596        configfs_add_default_group(&gi->functions_group, &gi->group);
1597
1598        config_group_init_type_name(&gi->configs_group, "configs",
1599                        &config_desc_type);
1600        configfs_add_default_group(&gi->configs_group, &gi->group);
1601
1602        config_group_init_type_name(&gi->strings_group, "strings",
1603                        &gadget_strings_strings_type);
1604        configfs_add_default_group(&gi->strings_group, &gi->group);
1605
1606        config_group_init_type_name(&gi->os_desc_group, "os_desc",
1607                        &os_desc_type);
1608        configfs_add_default_group(&gi->os_desc_group, &gi->group);
1609
1610        gi->composite.bind = configfs_do_nothing;
1611        gi->composite.unbind = configfs_do_nothing;
1612        gi->composite.suspend = NULL;
1613        gi->composite.resume = NULL;
1614        gi->composite.max_speed = USB_SPEED_SUPER_PLUS;
1615
1616        spin_lock_init(&gi->spinlock);
1617        mutex_init(&gi->lock);
1618        INIT_LIST_HEAD(&gi->string_list);
1619        INIT_LIST_HEAD(&gi->available_func);
1620
1621        composite_init_dev(&gi->cdev);
1622        gi->cdev.desc.bLength = USB_DT_DEVICE_SIZE;
1623        gi->cdev.desc.bDescriptorType = USB_DT_DEVICE;
1624        gi->cdev.desc.bcdDevice = cpu_to_le16(get_default_bcdDevice());
1625
1626        gi->composite.gadget_driver = configfs_driver_template;
1627
1628        gi->composite.gadget_driver.function = kstrdup(name, GFP_KERNEL);
1629        gi->composite.name = gi->composite.gadget_driver.function;
1630
1631        if (!gi->composite.gadget_driver.function)
1632                goto err;
1633
1634        return &gi->group;
1635err:
1636        kfree(gi);
1637        return ERR_PTR(-ENOMEM);
1638}
1639
1640static void gadgets_drop(struct config_group *group, struct config_item *item)
1641{
1642        config_item_put(item);
1643}
1644
1645static struct configfs_group_operations gadgets_ops = {
1646        .make_group     = &gadgets_make,
1647        .drop_item      = &gadgets_drop,
1648};
1649
1650static const struct config_item_type gadgets_type = {
1651        .ct_group_ops   = &gadgets_ops,
1652        .ct_owner       = THIS_MODULE,
1653};
1654
1655static struct configfs_subsystem gadget_subsys = {
1656        .su_group = {
1657                .cg_item = {
1658                        .ci_namebuf = "usb_gadget",
1659                        .ci_type = &gadgets_type,
1660                },
1661        },
1662        .su_mutex = __MUTEX_INITIALIZER(gadget_subsys.su_mutex),
1663};
1664
1665void unregister_gadget_item(struct config_item *item)
1666{
1667        struct gadget_info *gi = to_gadget_info(item);
1668
1669        mutex_lock(&gi->lock);
1670        unregister_gadget(gi);
1671        mutex_unlock(&gi->lock);
1672}
1673EXPORT_SYMBOL_GPL(unregister_gadget_item);
1674
1675static int __init gadget_cfs_init(void)
1676{
1677        int ret;
1678
1679        config_group_init(&gadget_subsys.su_group);
1680
1681        ret = configfs_register_subsystem(&gadget_subsys);
1682        return ret;
1683}
1684module_init(gadget_cfs_init);
1685
1686static void __exit gadget_cfs_exit(void)
1687{
1688        configfs_unregister_subsystem(&gadget_subsys);
1689}
1690module_exit(gadget_cfs_exit);
1691