drivers/usb/gadget/configfs.c

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