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