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
15static 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(s: name, base: 0, res: &num);
22 if (ret)
23 return ret;
24
25 if (!usb_validate_langid(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
35static const struct usb_descriptor_header *otg_desc[2];
36
37struct 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
64static 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
69struct 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
78static 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
84static 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
89struct 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
102struct 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
113static 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(p: str, q: 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) \
140static 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) \
148static 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) \
157static 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) \
170static 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
186GI_DEVICE_DESC_SIMPLE_R_u16(bcdUSB);
187GI_DEVICE_DESC_SIMPLE_RW(bDeviceClass, u8);
188GI_DEVICE_DESC_SIMPLE_RW(bDeviceSubClass, u8);
189GI_DEVICE_DESC_SIMPLE_RW(bDeviceProtocol, u8);
190GI_DEVICE_DESC_SIMPLE_RW(bMaxPacketSize0, u8);
191GI_DEVICE_DESC_SIMPLE_RW(idVendor, u16);
192GI_DEVICE_DESC_SIMPLE_RW(idProduct, u16);
193GI_DEVICE_DESC_SIMPLE_R_u16(bcdDevice);
194
195static 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
208static 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(s: page, base: 0, res: &bcdDevice);
215 if (ret)
216 return ret;
217 ret = is_valid_bcd(bcd_val: 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
225static 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(s: page, base: 0, res: &bcdUSB);
232 if (ret)
233 return ret;
234 ret = is_valid_bcd(bcd_val: 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
242static 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(buf: page, fmt: "%s\n", udc_name ?: "");
251 mutex_unlock(lock: &gi->lock);
252
253 return ret;
254}
255
256static 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(driver: &gi->composite.gadget_driver);
264 if (ret)
265 return ret;
266 kfree(objp: gi->composite.gadget_driver.udc_name);
267 gi->composite.gadget_driver.udc_name = NULL;
268 return 0;
269}
270
271static 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(s: 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(objp: 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(lock: &gi->lock);
307 return len;
308err:
309 kfree(objp: name);
310 mutex_unlock(lock: &gi->lock);
311 return ret;
312}
313
314static 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(buf: page, fmt: "%s\n", usb_speed_string(speed));
320}
321
322static 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(lock: &gi->lock);
349 return len;
350err:
351 mutex_unlock(lock: &gi->lock);
352 return -EINVAL;
353}
354
355CONFIGFS_ATTR(gadget_dev_desc_, bDeviceClass);
356CONFIGFS_ATTR(gadget_dev_desc_, bDeviceSubClass);
357CONFIGFS_ATTR(gadget_dev_desc_, bDeviceProtocol);
358CONFIGFS_ATTR(gadget_dev_desc_, bMaxPacketSize0);
359CONFIGFS_ATTR(gadget_dev_desc_, idVendor);
360CONFIGFS_ATTR(gadget_dev_desc_, idProduct);
361CONFIGFS_ATTR(gadget_dev_desc_, bcdDevice);
362CONFIGFS_ATTR(gadget_dev_desc_, bcdUSB);
363CONFIGFS_ATTR(gadget_dev_desc_, UDC);
364CONFIGFS_ATTR(gadget_dev_desc_, max_speed);
365
366static 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
380static 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
386static 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
393static 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
400static 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(objp: gi->composite.gadget_driver.function);
408 kfree(objp: gi->composite.gadget_driver.driver.name);
409 kfree(objp: gi);
410}
411
412static struct configfs_item_operations gadget_root_item_ops = {
413 .release = gadget_info_attr_release,
414};
415
416static 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(entry: &cfg->c.list);
422 kfree(objp: cfg->c.label);
423 kfree(objp: cfg);
424}
425
426static 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(item: 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(item: 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(ptr: f)) {
471 ret = PTR_ERR(ptr: f);
472 goto out;
473 }
474
475 /* stash the function until we bind it to the gadget */
476 list_add_tail(new: &f->list, head: &cfg->func_list);
477 ret = 0;
478out:
479 mutex_unlock(lock: &gi->lock);
480 return ret;
481}
482
483static 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(item: 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(item: 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(entry: &f->list);
508 usb_put_function(f);
509 mutex_unlock(lock: &gi->lock);
510 return;
511 }
512 }
513 mutex_unlock(lock: &gi->lock);
514 WARN(1, "Unable to locate function to unbind\n");
515}
516
517static 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
524static 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(buf: page, fmt: "%u\n", cfg->c.MaxPower);
530}
531
532static 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(s: page, base: 0, res: &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
547static 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(buf: page, fmt: "0x%02x\n", cfg->c.bmAttributes);
553}
554
555static 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(s: page, base: 0, res: &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
573CONFIGFS_ATTR(gadget_config_desc_, MaxPower);
574CONFIGFS_ATTR(gadget_config_desc_, bmAttributes);
575
576static struct configfs_attribute *gadget_config_attrs[] = {
577 &gadget_config_desc_attr_MaxPower,
578 &gadget_config_desc_attr_bmAttributes,
579 NULL,
580};
581
582static 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
588static 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
594static void composite_init_dev(struct usb_composite_dev *cdev)
595{
596 spin_lock_init(&cdev->lock);
597 INIT_LIST_HEAD(list: &cdev->configs);
598 INIT_LIST_HEAD(list: &cdev->gstrings);
599}
600
601static 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(error: -ENAMETOOLONG);
614
615 scnprintf(buf, MAX_NAME_LEN, fmt: "%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(error: -EINVAL);
622 }
623 *instance_name = '\0';
624 instance_name++;
625
626 fi = usb_get_function_instance(name: func_name);
627 if (IS_ERR(ptr: fi))
628 return ERR_CAST(ptr: 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(error: 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(error: ret);
640 }
641 }
642
643 gi = container_of(group, struct gadget_info, functions_group);
644
645 mutex_lock(&gi->lock);
646 list_add_tail(new: &fi->cfs_list, head: &gi->available_func);
647 mutex_unlock(lock: &gi->lock);
648 return &fi->group;
649}
650
651static 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(entry: &fi->cfs_list);
662 mutex_unlock(lock: &gi->lock);
663 config_item_put(item);
664}
665
666static struct configfs_group_operations functions_ops = {
667 .make_group = &function_make,
668 .drop_item = &function_drop,
669};
670
671static const struct config_item_type functions_type = {
672 .ct_group_ops = &functions_ops,
673 .ct_owner = THIS_MODULE,
674};
675
676GS_STRINGS_RW(gadget_config_name, configuration);
677
678static struct configfs_attribute *gadget_config_name_langid_attrs[] = {
679 &gadget_config_name_attr_configuration,
680 NULL,
681};
682
683static 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(objp: cn->configuration);
688
689 list_del(entry: &cn->list);
690 kfree(objp: cn);
691}
692
693USB_CONFIG_STRING_RW_OPS(gadget_config_name);
694USB_CONFIG_STRINGS_LANG(gadget_config_name, config_usb_cfg);
695
696static 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(error: -ENAMETOOLONG);
711
712 scnprintf(buf, MAX_NAME_LEN, fmt: "%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(error: -EINVAL);
718 }
719
720 *num_str = '\0';
721 num_str++;
722
723 if (!strlen(buf))
724 return ERR_PTR(error: -EINVAL);
725
726 ret = kstrtou8(s: num_str, base: 0, res: &num);
727 if (ret)
728 return ERR_PTR(error: ret);
729
730 cfg = kzalloc(sizeof(*cfg), GFP_KERNEL);
731 if (!cfg)
732 return ERR_PTR(error: -ENOMEM);
733 cfg->c.label = kstrdup(s: 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(list: &cfg->string_list);
742 INIT_LIST_HEAD(list: &cfg->func_list);
743
744 config_group_init_type_name(group: &cfg->group, name,
745 type: &gadget_config_type);
746
747 config_group_init_type_name(group: &cfg->strings_group, name: "strings",
748 type: &gadget_config_name_strings_type);
749 configfs_add_default_group(new_group: &cfg->strings_group, group: &cfg->group);
750
751 ret = usb_add_config_only(cdev: &gi->cdev, config: &cfg->c);
752 if (ret)
753 goto err;
754
755 return &cfg->group;
756err:
757 kfree(objp: cfg->c.label);
758 kfree(objp: cfg);
759 return ERR_PTR(error: ret);
760}
761
762static void config_desc_drop(
763 struct config_group *group,
764 struct config_item *item)
765{
766 config_item_put(item);
767}
768
769static struct configfs_group_operations config_desc_ops = {
770 .make_group = &config_desc_make,
771 .drop_item = &config_desc_drop,
772};
773
774static const struct config_item_type config_desc_type = {
775 .ct_group_ops = &config_desc_ops,
776 .ct_owner = THIS_MODULE,
777};
778
779GS_STRINGS_RW(gadget_language, manufacturer);
780GS_STRINGS_RW(gadget_language, product);
781GS_STRINGS_RW(gadget_language, serialnumber);
782
783static 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
790static void gadget_language_attr_release(struct config_item *item)
791{
792 struct gadget_language *gs = to_gadget_language(item);
793
794 kfree(objp: gs->manufacturer);
795 kfree(objp: gs->product);
796 kfree(objp: gs->serialnumber);
797
798 list_del(entry: &gs->list);
799 kfree(objp: gs);
800}
801
802static struct configfs_item_operations gadget_language_langid_item_ops = {
803 .release = gadget_language_attr_release,
804};
805
806static 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(buf: page, fmt: "%u\n", string->usb_string.id);
812 return ret;
813}
814CONFIGFS_ATTR_RO(gadget_string_, id);
815
816static 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(buf: page, fmt: "%s\n", string->string);
822 return ret;
823}
824
825static 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 ssize_t cpy_len;
831
832 if (len > USB_MAX_STRING_LEN)
833 return -EINVAL;
834
835 cpy_len = strscpy(string->string, page, size);
836 if (cpy_len > 0 && string->string[cpy_len - 1] == '\n')
837 string->string[cpy_len - 1] = 0;
838 return len;
839}
840CONFIGFS_ATTR(gadget_string_, s);
841
842static struct configfs_attribute *gadget_string_attrs[] = {
843 &gadget_string_attr_id,
844 &gadget_string_attr_s,
845 NULL,
846};
847
848static void gadget_string_release(struct config_item *item)
849{
850 struct gadget_string *string = to_gadget_string(item);
851
852 kfree(objp: string);
853}
854
855static struct configfs_item_operations gadget_string_item_ops = {
856 .release = gadget_string_release,
857};
858
859static const struct config_item_type gadget_string_type = {
860 .ct_item_ops = &gadget_string_item_ops,
861 .ct_attrs = gadget_string_attrs,
862 .ct_owner = THIS_MODULE,
863};
864
865static struct config_item *gadget_language_string_make(struct config_group *group,
866 const char *name)
867{
868 struct gadget_language *language;
869 struct gadget_string *string;
870
871 language = to_gadget_language(item: &group->cg_item);
872
873 string = kzalloc(sizeof(*string), GFP_KERNEL);
874 if (!string)
875 return ERR_PTR(error: -ENOMEM);
876
877 string->usb_string.id = language->nstrings++;
878 string->usb_string.s = string->string;
879 list_add_tail(new: &string->list, head: &language->gadget_strings);
880
881 config_item_init_type_name(item: &string->item, name, type: &gadget_string_type);
882
883 return &string->item;
884}
885
886static void gadget_language_string_drop(struct config_group *group,
887 struct config_item *item)
888{
889 struct gadget_language *language;
890 struct gadget_string *string;
891 unsigned int i = USB_GADGET_FIRST_AVAIL_IDX;
892
893 language = to_gadget_language(item: &group->cg_item);
894 string = to_gadget_string(item);
895
896 list_del(entry: &string->list);
897 language->nstrings--;
898
899 /* Reset the ids for the language's strings to guarantee a continuous set */
900 list_for_each_entry(string, &language->gadget_strings, list)
901 string->usb_string.id = i++;
902}
903
904static struct configfs_group_operations gadget_language_langid_group_ops = {
905 .make_item = gadget_language_string_make,
906 .drop_item = gadget_language_string_drop,
907};
908
909static const struct config_item_type gadget_language_type = {
910 .ct_item_ops = &gadget_language_langid_item_ops,
911 .ct_group_ops = &gadget_language_langid_group_ops,
912 .ct_attrs = gadget_language_langid_attrs,
913 .ct_owner = THIS_MODULE,
914};
915
916static struct config_group *gadget_language_make(struct config_group *group,
917 const char *name)
918{
919 struct gadget_info *gi;
920 struct gadget_language *gs;
921 struct gadget_language *new;
922 int langs = 0;
923 int ret;
924
925 new = kzalloc(sizeof(*new), GFP_KERNEL);
926 if (!new)
927 return ERR_PTR(error: -ENOMEM);
928
929 ret = check_user_usb_string(name, stringtab_dev: &new->stringtab_dev);
930 if (ret)
931 goto err;
932 config_group_init_type_name(group: &new->group, name,
933 type: &gadget_language_type);
934
935 gi = container_of(group, struct gadget_info, strings_group);
936 ret = -EEXIST;
937 list_for_each_entry(gs, &gi->string_list, list) {
938 if (gs->stringtab_dev.language == new->stringtab_dev.language)
939 goto err;
940 langs++;
941 }
942 ret = -EOVERFLOW;
943 if (langs >= MAX_USB_STRING_LANGS)
944 goto err;
945
946 list_add_tail(new: &new->list, head: &gi->string_list);
947 INIT_LIST_HEAD(list: &new->gadget_strings);
948
949 /* We have the default manufacturer, product and serialnumber strings */
950 new->nstrings = 3;
951 return &new->group;
952err:
953 kfree(objp: new);
954 return ERR_PTR(error: ret);
955}
956
957static void gadget_language_drop(struct config_group *group,
958 struct config_item *item)
959{
960 config_item_put(item);
961}
962
963static struct configfs_group_operations gadget_language_group_ops = {
964 .make_group = &gadget_language_make,
965 .drop_item = &gadget_language_drop,
966};
967
968static const struct config_item_type gadget_language_strings_type = {
969 .ct_group_ops = &gadget_language_group_ops,
970 .ct_owner = THIS_MODULE,
971};
972
973static inline struct gadget_info *webusb_item_to_gadget_info(
974 struct config_item *item)
975{
976 return container_of(to_config_group(item),
977 struct gadget_info, webusb_group);
978}
979
980static ssize_t webusb_use_show(struct config_item *item, char *page)
981{
982 return sysfs_emit(buf: page, fmt: "%d\n",
983 webusb_item_to_gadget_info(item)->use_webusb);
984}
985
986static ssize_t webusb_use_store(struct config_item *item, const char *page,
987 size_t len)
988{
989 struct gadget_info *gi = webusb_item_to_gadget_info(item);
990 int ret;
991 bool use;
992
993 ret = kstrtobool(s: page, res: &use);
994 if (ret)
995 return ret;
996
997 mutex_lock(&gi->lock);
998 gi->use_webusb = use;
999 mutex_unlock(lock: &gi->lock);
1000
1001 return len;
1002}
1003
1004static ssize_t webusb_bcdVersion_show(struct config_item *item, char *page)
1005{
1006 return sysfs_emit(buf: page, fmt: "0x%04x\n",
1007 webusb_item_to_gadget_info(item)->bcd_webusb_version);
1008}
1009
1010static ssize_t webusb_bcdVersion_store(struct config_item *item,
1011 const char *page, size_t len)
1012{
1013 struct gadget_info *gi = webusb_item_to_gadget_info(item);
1014 u16 bcdVersion;
1015 int ret;
1016
1017 ret = kstrtou16(s: page, base: 0, res: &bcdVersion);
1018 if (ret)
1019 return ret;
1020
1021 ret = is_valid_bcd(bcd_val: bcdVersion);
1022 if (ret)
1023 return ret;
1024
1025 mutex_lock(&gi->lock);
1026 gi->bcd_webusb_version = bcdVersion;
1027 mutex_unlock(lock: &gi->lock);
1028
1029 return len;
1030}
1031
1032static ssize_t webusb_bVendorCode_show(struct config_item *item, char *page)
1033{
1034 return sysfs_emit(buf: page, fmt: "0x%02x\n",
1035 webusb_item_to_gadget_info(item)->b_webusb_vendor_code);
1036}
1037
1038static ssize_t webusb_bVendorCode_store(struct config_item *item,
1039 const char *page, size_t len)
1040{
1041 struct gadget_info *gi = webusb_item_to_gadget_info(item);
1042 int ret;
1043 u8 b_vendor_code;
1044
1045 ret = kstrtou8(s: page, base: 0, res: &b_vendor_code);
1046 if (ret)
1047 return ret;
1048
1049 mutex_lock(&gi->lock);
1050 gi->b_webusb_vendor_code = b_vendor_code;
1051 mutex_unlock(lock: &gi->lock);
1052
1053 return len;
1054}
1055
1056static ssize_t webusb_landingPage_show(struct config_item *item, char *page)
1057{
1058 return sysfs_emit(buf: page, fmt: "%s\n", webusb_item_to_gadget_info(item)->landing_page);
1059}
1060
1061static ssize_t webusb_landingPage_store(struct config_item *item, const char *page,
1062 size_t len)
1063{
1064 struct gadget_info *gi = webusb_item_to_gadget_info(item);
1065 unsigned int bytes_to_strip = 0;
1066 int l = len;
1067
1068 if (!len)
1069 return len;
1070 if (page[l - 1] == '\n') {
1071 --l;
1072 ++bytes_to_strip;
1073 }
1074
1075 if (l > sizeof(gi->landing_page)) {
1076 pr_err("webusb: landingPage URL too long\n");
1077 return -EINVAL;
1078 }
1079
1080 // validation
1081 if (strncasecmp(s1: page, s2: "https://", n: 8) == 0)
1082 bytes_to_strip = 8;
1083 else if (strncasecmp(s1: page, s2: "http://", n: 7) == 0)
1084 bytes_to_strip = 7;
1085 else
1086 bytes_to_strip = 0;
1087
1088 if (l > U8_MAX - WEBUSB_URL_DESCRIPTOR_HEADER_LENGTH + bytes_to_strip) {
1089 pr_err("webusb: landingPage URL %d bytes too long for given URL scheme\n",
1090 l - U8_MAX + WEBUSB_URL_DESCRIPTOR_HEADER_LENGTH - bytes_to_strip);
1091 return -EINVAL;
1092 }
1093
1094 mutex_lock(&gi->lock);
1095 // ensure 0 bytes are set, in case the new landing page is shorter then the old one.
1096 memcpy_and_pad(dest: gi->landing_page, dest_len: sizeof(gi->landing_page), src: page, count: l, pad: 0);
1097 mutex_unlock(lock: &gi->lock);
1098
1099 return len;
1100}
1101
1102CONFIGFS_ATTR(webusb_, use);
1103CONFIGFS_ATTR(webusb_, bVendorCode);
1104CONFIGFS_ATTR(webusb_, bcdVersion);
1105CONFIGFS_ATTR(webusb_, landingPage);
1106
1107static struct configfs_attribute *webusb_attrs[] = {
1108 &webusb_attr_use,
1109 &webusb_attr_bcdVersion,
1110 &webusb_attr_bVendorCode,
1111 &webusb_attr_landingPage,
1112 NULL,
1113};
1114
1115static const struct config_item_type webusb_type = {
1116 .ct_attrs = webusb_attrs,
1117 .ct_owner = THIS_MODULE,
1118};
1119
1120static inline struct gadget_info *os_desc_item_to_gadget_info(
1121 struct config_item *item)
1122{
1123 return container_of(to_config_group(item),
1124 struct gadget_info, os_desc_group);
1125}
1126
1127static ssize_t os_desc_use_show(struct config_item *item, char *page)
1128{
1129 return sprintf(buf: page, fmt: "%d\n",
1130 os_desc_item_to_gadget_info(item)->use_os_desc);
1131}
1132
1133static ssize_t os_desc_use_store(struct config_item *item, const char *page,
1134 size_t len)
1135{
1136 struct gadget_info *gi = os_desc_item_to_gadget_info(item);
1137 int ret;
1138 bool use;
1139
1140 ret = kstrtobool(s: page, res: &use);
1141 if (ret)
1142 return ret;
1143
1144 mutex_lock(&gi->lock);
1145 gi->use_os_desc = use;
1146 mutex_unlock(lock: &gi->lock);
1147
1148 return len;
1149}
1150
1151static ssize_t os_desc_b_vendor_code_show(struct config_item *item, char *page)
1152{
1153 return sprintf(buf: page, fmt: "0x%02x\n",
1154 os_desc_item_to_gadget_info(item)->b_vendor_code);
1155}
1156
1157static ssize_t os_desc_b_vendor_code_store(struct config_item *item,
1158 const char *page, size_t len)
1159{
1160 struct gadget_info *gi = os_desc_item_to_gadget_info(item);
1161 int ret;
1162 u8 b_vendor_code;
1163
1164 ret = kstrtou8(s: page, base: 0, res: &b_vendor_code);
1165 if (ret)
1166 return ret;
1167
1168 mutex_lock(&gi->lock);
1169 gi->b_vendor_code = b_vendor_code;
1170 mutex_unlock(lock: &gi->lock);
1171
1172 return len;
1173}
1174
1175static ssize_t os_desc_qw_sign_show(struct config_item *item, char *page)
1176{
1177 struct gadget_info *gi = os_desc_item_to_gadget_info(item);
1178 int res;
1179
1180 res = utf16s_to_utf8s(pwcs: (wchar_t *) gi->qw_sign, OS_STRING_QW_SIGN_LEN,
1181 endian: UTF16_LITTLE_ENDIAN, s: page, PAGE_SIZE - 1);
1182 page[res++] = '\n';
1183
1184 return res;
1185}
1186
1187static ssize_t os_desc_qw_sign_store(struct config_item *item, const char *page,
1188 size_t len)
1189{
1190 struct gadget_info *gi = os_desc_item_to_gadget_info(item);
1191 int res, l;
1192
1193 if (!len)
1194 return len;
1195 l = min_t(int, len, OS_STRING_QW_SIGN_LEN >> 1);
1196 if (page[l - 1] == '\n')
1197 --l;
1198
1199 mutex_lock(&gi->lock);
1200 res = utf8s_to_utf16s(s: page, len: l,
1201 endian: UTF16_LITTLE_ENDIAN, pwcs: (wchar_t *) gi->qw_sign,
1202 OS_STRING_QW_SIGN_LEN);
1203 if (res > 0)
1204 res = len;
1205 mutex_unlock(lock: &gi->lock);
1206
1207 return res;
1208}
1209
1210CONFIGFS_ATTR(os_desc_, use);
1211CONFIGFS_ATTR(os_desc_, b_vendor_code);
1212CONFIGFS_ATTR(os_desc_, qw_sign);
1213
1214static struct configfs_attribute *os_desc_attrs[] = {
1215 &os_desc_attr_use,
1216 &os_desc_attr_b_vendor_code,
1217 &os_desc_attr_qw_sign,
1218 NULL,
1219};
1220
1221static int os_desc_link(struct config_item *os_desc_ci,
1222 struct config_item *usb_cfg_ci)
1223{
1224 struct gadget_info *gi = os_desc_item_to_gadget_info(item: os_desc_ci);
1225 struct usb_composite_dev *cdev = &gi->cdev;
1226 struct config_usb_cfg *c_target = to_config_usb_cfg(item: usb_cfg_ci);
1227 struct usb_configuration *c = NULL, *iter;
1228 int ret;
1229
1230 mutex_lock(&gi->lock);
1231 list_for_each_entry(iter, &cdev->configs, list) {
1232 if (iter != &c_target->c)
1233 continue;
1234 c = iter;
1235 break;
1236 }
1237 if (!c) {
1238 ret = -EINVAL;
1239 goto out;
1240 }
1241
1242 if (cdev->os_desc_config) {
1243 ret = -EBUSY;
1244 goto out;
1245 }
1246
1247 cdev->os_desc_config = &c_target->c;
1248 ret = 0;
1249
1250out:
1251 mutex_unlock(lock: &gi->lock);
1252 return ret;
1253}
1254
1255static void os_desc_unlink(struct config_item *os_desc_ci,
1256 struct config_item *usb_cfg_ci)
1257{
1258 struct gadget_info *gi = os_desc_item_to_gadget_info(item: os_desc_ci);
1259 struct usb_composite_dev *cdev = &gi->cdev;
1260
1261 mutex_lock(&gi->lock);
1262 if (gi->composite.gadget_driver.udc_name)
1263 unregister_gadget(gi);
1264 cdev->os_desc_config = NULL;
1265 WARN_ON(gi->composite.gadget_driver.udc_name);
1266 mutex_unlock(lock: &gi->lock);
1267}
1268
1269static struct configfs_item_operations os_desc_ops = {
1270 .allow_link = os_desc_link,
1271 .drop_link = os_desc_unlink,
1272};
1273
1274static const struct config_item_type os_desc_type = {
1275 .ct_item_ops = &os_desc_ops,
1276 .ct_attrs = os_desc_attrs,
1277 .ct_owner = THIS_MODULE,
1278};
1279
1280static inline struct usb_os_desc_ext_prop
1281*to_usb_os_desc_ext_prop(struct config_item *item)
1282{
1283 return container_of(item, struct usb_os_desc_ext_prop, item);
1284}
1285
1286static ssize_t ext_prop_type_show(struct config_item *item, char *page)
1287{
1288 return sprintf(buf: page, fmt: "%d\n", to_usb_os_desc_ext_prop(item)->type);
1289}
1290
1291static ssize_t ext_prop_type_store(struct config_item *item,
1292 const char *page, size_t len)
1293{
1294 struct usb_os_desc_ext_prop *ext_prop = to_usb_os_desc_ext_prop(item);
1295 struct usb_os_desc *desc = to_usb_os_desc(item: ext_prop->item.ci_parent);
1296 u8 type;
1297 int ret;
1298
1299 ret = kstrtou8(s: page, base: 0, res: &type);
1300 if (ret)
1301 return ret;
1302
1303 if (type < USB_EXT_PROP_UNICODE || type > USB_EXT_PROP_UNICODE_MULTI)
1304 return -EINVAL;
1305
1306 if (desc->opts_mutex)
1307 mutex_lock(desc->opts_mutex);
1308
1309 if ((ext_prop->type == USB_EXT_PROP_BINARY ||
1310 ext_prop->type == USB_EXT_PROP_LE32 ||
1311 ext_prop->type == USB_EXT_PROP_BE32) &&
1312 (type == USB_EXT_PROP_UNICODE ||
1313 type == USB_EXT_PROP_UNICODE_ENV ||
1314 type == USB_EXT_PROP_UNICODE_LINK))
1315 ext_prop->data_len <<= 1;
1316 else if ((ext_prop->type == USB_EXT_PROP_UNICODE ||
1317 ext_prop->type == USB_EXT_PROP_UNICODE_ENV ||
1318 ext_prop->type == USB_EXT_PROP_UNICODE_LINK) &&
1319 (type == USB_EXT_PROP_BINARY ||
1320 type == USB_EXT_PROP_LE32 ||
1321 type == USB_EXT_PROP_BE32))
1322 ext_prop->data_len >>= 1;
1323 ext_prop->type = type;
1324
1325 if (desc->opts_mutex)
1326 mutex_unlock(lock: desc->opts_mutex);
1327 return len;
1328}
1329
1330static ssize_t ext_prop_data_show(struct config_item *item, char *page)
1331{
1332 struct usb_os_desc_ext_prop *ext_prop = to_usb_os_desc_ext_prop(item);
1333 int len = ext_prop->data_len;
1334
1335 if (ext_prop->type == USB_EXT_PROP_UNICODE ||
1336 ext_prop->type == USB_EXT_PROP_UNICODE_ENV ||
1337 ext_prop->type == USB_EXT_PROP_UNICODE_LINK)
1338 len >>= 1;
1339 memcpy(page, ext_prop->data, len);
1340
1341 return len;
1342}
1343
1344static ssize_t ext_prop_data_store(struct config_item *item,
1345 const char *page, size_t len)
1346{
1347 struct usb_os_desc_ext_prop *ext_prop = to_usb_os_desc_ext_prop(item);
1348 struct usb_os_desc *desc = to_usb_os_desc(item: ext_prop->item.ci_parent);
1349 char *new_data;
1350 size_t ret_len = len;
1351
1352 if (page[len - 1] == '\n' || page[len - 1] == '\0')
1353 --len;
1354 new_data = kmemdup(page, len, GFP_KERNEL);
1355 if (!new_data)
1356 return -ENOMEM;
1357
1358 if (desc->opts_mutex)
1359 mutex_lock(desc->opts_mutex);
1360 kfree(objp: ext_prop->data);
1361 ext_prop->data = new_data;
1362 desc->ext_prop_len -= ext_prop->data_len;
1363 ext_prop->data_len = len;
1364 desc->ext_prop_len += ext_prop->data_len;
1365 if (ext_prop->type == USB_EXT_PROP_UNICODE ||
1366 ext_prop->type == USB_EXT_PROP_UNICODE_ENV ||
1367 ext_prop->type == USB_EXT_PROP_UNICODE_LINK) {
1368 desc->ext_prop_len -= ext_prop->data_len;
1369 ext_prop->data_len <<= 1;
1370 ext_prop->data_len += 2;
1371 desc->ext_prop_len += ext_prop->data_len;
1372 }
1373 if (desc->opts_mutex)
1374 mutex_unlock(lock: desc->opts_mutex);
1375 return ret_len;
1376}
1377
1378CONFIGFS_ATTR(ext_prop_, type);
1379CONFIGFS_ATTR(ext_prop_, data);
1380
1381static struct configfs_attribute *ext_prop_attrs[] = {
1382 &ext_prop_attr_type,
1383 &ext_prop_attr_data,
1384 NULL,
1385};
1386
1387static void usb_os_desc_ext_prop_release(struct config_item *item)
1388{
1389 struct usb_os_desc_ext_prop *ext_prop = to_usb_os_desc_ext_prop(item);
1390
1391 kfree(objp: ext_prop); /* frees a whole chunk */
1392}
1393
1394static struct configfs_item_operations ext_prop_ops = {
1395 .release = usb_os_desc_ext_prop_release,
1396};
1397
1398static struct config_item *ext_prop_make(
1399 struct config_group *group,
1400 const char *name)
1401{
1402 struct usb_os_desc_ext_prop *ext_prop;
1403 struct config_item_type *ext_prop_type;
1404 struct usb_os_desc *desc;
1405 char *vlabuf;
1406
1407 vla_group(data_chunk);
1408 vla_item(data_chunk, struct usb_os_desc_ext_prop, ext_prop, 1);
1409 vla_item(data_chunk, struct config_item_type, ext_prop_type, 1);
1410
1411 vlabuf = kzalloc(vla_group_size(data_chunk), GFP_KERNEL);
1412 if (!vlabuf)
1413 return ERR_PTR(error: -ENOMEM);
1414
1415 ext_prop = vla_ptr(vlabuf, data_chunk, ext_prop);
1416 ext_prop_type = vla_ptr(vlabuf, data_chunk, ext_prop_type);
1417
1418 desc = container_of(group, struct usb_os_desc, group);
1419 ext_prop_type->ct_item_ops = &ext_prop_ops;
1420 ext_prop_type->ct_attrs = ext_prop_attrs;
1421 ext_prop_type->ct_owner = desc->owner;
1422
1423 config_item_init_type_name(item: &ext_prop->item, name, type: ext_prop_type);
1424
1425 ext_prop->name = kstrdup(s: name, GFP_KERNEL);
1426 if (!ext_prop->name) {
1427 kfree(objp: vlabuf);
1428 return ERR_PTR(error: -ENOMEM);
1429 }
1430 desc->ext_prop_len += 14;
1431 ext_prop->name_len = 2 * strlen(ext_prop->name) + 2;
1432 if (desc->opts_mutex)
1433 mutex_lock(desc->opts_mutex);
1434 desc->ext_prop_len += ext_prop->name_len;
1435 list_add_tail(new: &ext_prop->entry, head: &desc->ext_prop);
1436 ++desc->ext_prop_count;
1437 if (desc->opts_mutex)
1438 mutex_unlock(lock: desc->opts_mutex);
1439
1440 return &ext_prop->item;
1441}
1442
1443static void ext_prop_drop(struct config_group *group, struct config_item *item)
1444{
1445 struct usb_os_desc_ext_prop *ext_prop = to_usb_os_desc_ext_prop(item);
1446 struct usb_os_desc *desc = to_usb_os_desc(item: &group->cg_item);
1447
1448 if (desc->opts_mutex)
1449 mutex_lock(desc->opts_mutex);
1450 list_del(entry: &ext_prop->entry);
1451 --desc->ext_prop_count;
1452 kfree(objp: ext_prop->name);
1453 desc->ext_prop_len -= (ext_prop->name_len + ext_prop->data_len + 14);
1454 if (desc->opts_mutex)
1455 mutex_unlock(lock: desc->opts_mutex);
1456 config_item_put(item);
1457}
1458
1459static struct configfs_group_operations interf_grp_ops = {
1460 .make_item = &ext_prop_make,
1461 .drop_item = &ext_prop_drop,
1462};
1463
1464static ssize_t interf_grp_compatible_id_show(struct config_item *item,
1465 char *page)
1466{
1467 memcpy(page, to_usb_os_desc(item)->ext_compat_id, 8);
1468 return 8;
1469}
1470
1471static ssize_t interf_grp_compatible_id_store(struct config_item *item,
1472 const char *page, size_t len)
1473{
1474 struct usb_os_desc *desc = to_usb_os_desc(item);
1475 int l;
1476
1477 l = min_t(int, 8, len);
1478 if (page[l - 1] == '\n')
1479 --l;
1480 if (desc->opts_mutex)
1481 mutex_lock(desc->opts_mutex);
1482 memcpy(desc->ext_compat_id, page, l);
1483
1484 if (desc->opts_mutex)
1485 mutex_unlock(lock: desc->opts_mutex);
1486
1487 return len;
1488}
1489
1490static ssize_t interf_grp_sub_compatible_id_show(struct config_item *item,
1491 char *page)
1492{
1493 memcpy(page, to_usb_os_desc(item)->ext_compat_id + 8, 8);
1494 return 8;
1495}
1496
1497static ssize_t interf_grp_sub_compatible_id_store(struct config_item *item,
1498 const char *page, size_t len)
1499{
1500 struct usb_os_desc *desc = to_usb_os_desc(item);
1501 int l;
1502
1503 l = min_t(int, 8, len);
1504 if (page[l - 1] == '\n')
1505 --l;
1506 if (desc->opts_mutex)
1507 mutex_lock(desc->opts_mutex);
1508 memcpy(desc->ext_compat_id + 8, page, l);
1509
1510 if (desc->opts_mutex)
1511 mutex_unlock(lock: desc->opts_mutex);
1512
1513 return len;
1514}
1515
1516CONFIGFS_ATTR(interf_grp_, compatible_id);
1517CONFIGFS_ATTR(interf_grp_, sub_compatible_id);
1518
1519static struct configfs_attribute *interf_grp_attrs[] = {
1520 &interf_grp_attr_compatible_id,
1521 &interf_grp_attr_sub_compatible_id,
1522 NULL
1523};
1524
1525struct config_group *usb_os_desc_prepare_interf_dir(
1526 struct config_group *parent,
1527 int n_interf,
1528 struct usb_os_desc **desc,
1529 char **names,
1530 struct module *owner)
1531{
1532 struct config_group *os_desc_group;
1533 struct config_item_type *os_desc_type, *interface_type;
1534
1535 vla_group(data_chunk);
1536 vla_item(data_chunk, struct config_group, os_desc_group, 1);
1537 vla_item(data_chunk, struct config_item_type, os_desc_type, 1);
1538 vla_item(data_chunk, struct config_item_type, interface_type, 1);
1539
1540 char *vlabuf = kzalloc(vla_group_size(data_chunk), GFP_KERNEL);
1541 if (!vlabuf)
1542 return ERR_PTR(error: -ENOMEM);
1543
1544 os_desc_group = vla_ptr(vlabuf, data_chunk, os_desc_group);
1545 os_desc_type = vla_ptr(vlabuf, data_chunk, os_desc_type);
1546 interface_type = vla_ptr(vlabuf, data_chunk, interface_type);
1547
1548 os_desc_type->ct_owner = owner;
1549 config_group_init_type_name(group: os_desc_group, name: "os_desc", type: os_desc_type);
1550 configfs_add_default_group(new_group: os_desc_group, group: parent);
1551
1552 interface_type->ct_group_ops = &interf_grp_ops;
1553 interface_type->ct_attrs = interf_grp_attrs;
1554 interface_type->ct_owner = owner;
1555
1556 while (n_interf--) {
1557 struct usb_os_desc *d;
1558
1559 d = desc[n_interf];
1560 d->owner = owner;
1561 config_group_init_type_name(group: &d->group, name: "", type: interface_type);
1562 config_item_set_name(&d->group.cg_item, "interface.%s",
1563 names[n_interf]);
1564 configfs_add_default_group(new_group: &d->group, group: os_desc_group);
1565 }
1566
1567 return os_desc_group;
1568}
1569EXPORT_SYMBOL(usb_os_desc_prepare_interf_dir);
1570
1571static int configfs_do_nothing(struct usb_composite_dev *cdev)
1572{
1573 WARN_ON(1);
1574 return -EINVAL;
1575}
1576
1577int composite_dev_prepare(struct usb_composite_driver *composite,
1578 struct usb_composite_dev *dev);
1579
1580int composite_os_desc_req_prepare(struct usb_composite_dev *cdev,
1581 struct usb_ep *ep0);
1582
1583static void purge_configs_funcs(struct gadget_info *gi)
1584{
1585 struct usb_configuration *c;
1586
1587 list_for_each_entry(c, &gi->cdev.configs, list) {
1588 struct usb_function *f, *tmp;
1589 struct config_usb_cfg *cfg;
1590
1591 cfg = container_of(c, struct config_usb_cfg, c);
1592
1593 list_for_each_entry_safe_reverse(f, tmp, &c->functions, list) {
1594
1595 list_move(list: &f->list, head: &cfg->func_list);
1596 if (f->unbind) {
1597 dev_dbg(&gi->cdev.gadget->dev,
1598 "unbind function '%s'/%p\n",
1599 f->name, f);
1600 f->unbind(c, f);
1601 }
1602 }
1603 c->next_interface_id = 0;
1604 memset(c->interface, 0, sizeof(c->interface));
1605 c->superspeed_plus = 0;
1606 c->superspeed = 0;
1607 c->highspeed = 0;
1608 c->fullspeed = 0;
1609 }
1610}
1611
1612static struct usb_string *
1613configfs_attach_gadget_strings(struct gadget_info *gi)
1614{
1615 struct usb_gadget_strings **gadget_strings;
1616 struct gadget_language *language;
1617 struct gadget_string *string;
1618 unsigned int nlangs = 0;
1619 struct list_head *iter;
1620 struct usb_string *us;
1621 unsigned int i = 0;
1622 int nstrings = -1;
1623 unsigned int j;
1624
1625 list_for_each(iter, &gi->string_list)
1626 nlangs++;
1627
1628 /* Bail out early if no languages are configured */
1629 if (!nlangs)
1630 return NULL;
1631
1632 gadget_strings = kcalloc(nlangs + 1, /* including NULL terminator */
1633 sizeof(struct usb_gadget_strings *), GFP_KERNEL);
1634 if (!gadget_strings)
1635 return ERR_PTR(error: -ENOMEM);
1636
1637 list_for_each_entry(language, &gi->string_list, list) {
1638 struct usb_string *stringtab;
1639
1640 if (nstrings == -1) {
1641 nstrings = language->nstrings;
1642 } else if (nstrings != language->nstrings) {
1643 pr_err("languages must contain the same number of strings\n");
1644 us = ERR_PTR(error: -EINVAL);
1645 goto cleanup;
1646 }
1647
1648 stringtab = kcalloc(language->nstrings + 1, sizeof(struct usb_string),
1649 GFP_KERNEL);
1650 if (!stringtab) {
1651 us = ERR_PTR(error: -ENOMEM);
1652 goto cleanup;
1653 }
1654
1655 stringtab[USB_GADGET_MANUFACTURER_IDX].id = USB_GADGET_MANUFACTURER_IDX;
1656 stringtab[USB_GADGET_MANUFACTURER_IDX].s = language->manufacturer;
1657 stringtab[USB_GADGET_PRODUCT_IDX].id = USB_GADGET_PRODUCT_IDX;
1658 stringtab[USB_GADGET_PRODUCT_IDX].s = language->product;
1659 stringtab[USB_GADGET_SERIAL_IDX].id = USB_GADGET_SERIAL_IDX;
1660 stringtab[USB_GADGET_SERIAL_IDX].s = language->serialnumber;
1661
1662 j = USB_GADGET_FIRST_AVAIL_IDX;
1663 list_for_each_entry(string, &language->gadget_strings, list) {
1664 memcpy(&stringtab[j], &string->usb_string, sizeof(struct usb_string));
1665 j++;
1666 }
1667
1668 language->stringtab_dev.strings = stringtab;
1669 gadget_strings[i] = &language->stringtab_dev;
1670 i++;
1671 }
1672
1673 us = usb_gstrings_attach(cdev: &gi->cdev, sp: gadget_strings, n_strings: nstrings);
1674
1675cleanup:
1676 list_for_each_entry(language, &gi->string_list, list) {
1677 kfree(objp: language->stringtab_dev.strings);
1678 language->stringtab_dev.strings = NULL;
1679 }
1680
1681 kfree(objp: gadget_strings);
1682
1683 return us;
1684}
1685
1686static int configfs_composite_bind(struct usb_gadget *gadget,
1687 struct usb_gadget_driver *gdriver)
1688{
1689 struct usb_composite_driver *composite = to_cdriver(gdrv: gdriver);
1690 struct gadget_info *gi = container_of(composite,
1691 struct gadget_info, composite);
1692 struct usb_composite_dev *cdev = &gi->cdev;
1693 struct usb_configuration *c;
1694 struct usb_string *s;
1695 unsigned i;
1696 int ret;
1697
1698 /* the gi->lock is hold by the caller */
1699 gi->unbind = 0;
1700 cdev->gadget = gadget;
1701 set_gadget_data(gadget, data: cdev);
1702 ret = composite_dev_prepare(composite, dev: cdev);
1703 if (ret)
1704 return ret;
1705 /* and now the gadget bind */
1706 ret = -EINVAL;
1707
1708 if (list_empty(head: &gi->cdev.configs)) {
1709 pr_err("Need at least one configuration in %s.\n",
1710 gi->composite.name);
1711 goto err_comp_cleanup;
1712 }
1713
1714
1715 list_for_each_entry(c, &gi->cdev.configs, list) {
1716 struct config_usb_cfg *cfg;
1717
1718 cfg = container_of(c, struct config_usb_cfg, c);
1719 if (list_empty(head: &cfg->func_list)) {
1720 pr_err("Config %s/%d of %s needs at least one function.\n",
1721 c->label, c->bConfigurationValue,
1722 gi->composite.name);
1723 goto err_comp_cleanup;
1724 }
1725 }
1726
1727 /* init all strings */
1728 if (!list_empty(head: &gi->string_list)) {
1729 s = configfs_attach_gadget_strings(gi);
1730 if (IS_ERR(ptr: s)) {
1731 ret = PTR_ERR(ptr: s);
1732 goto err_comp_cleanup;
1733 }
1734
1735 gi->cdev.desc.iManufacturer = s[USB_GADGET_MANUFACTURER_IDX].id;
1736 gi->cdev.desc.iProduct = s[USB_GADGET_PRODUCT_IDX].id;
1737 gi->cdev.desc.iSerialNumber = s[USB_GADGET_SERIAL_IDX].id;
1738
1739 gi->cdev.usb_strings = s;
1740 }
1741
1742 if (gi->use_webusb) {
1743 cdev->use_webusb = true;
1744 cdev->bcd_webusb_version = gi->bcd_webusb_version;
1745 cdev->b_webusb_vendor_code = gi->b_webusb_vendor_code;
1746 memcpy(cdev->landing_page, gi->landing_page, WEBUSB_URL_RAW_MAX_LENGTH);
1747 }
1748
1749 if (gi->use_os_desc) {
1750 cdev->use_os_string = true;
1751 cdev->b_vendor_code = gi->b_vendor_code;
1752 memcpy(cdev->qw_sign, gi->qw_sign, OS_STRING_QW_SIGN_LEN);
1753 } else {
1754 cdev->use_os_string = false;
1755 }
1756
1757 if (gadget_is_otg(g: gadget) && !otg_desc[0]) {
1758 struct usb_descriptor_header *usb_desc;
1759
1760 usb_desc = usb_otg_descriptor_alloc(gadget);
1761 if (!usb_desc) {
1762 ret = -ENOMEM;
1763 goto err_comp_cleanup;
1764 }
1765 usb_otg_descriptor_init(gadget, otg_desc: usb_desc);
1766 otg_desc[0] = usb_desc;
1767 otg_desc[1] = NULL;
1768 }
1769
1770 /* Go through all configs, attach all functions */
1771 list_for_each_entry(c, &gi->cdev.configs, list) {
1772 struct config_usb_cfg *cfg;
1773 struct usb_function *f;
1774 struct usb_function *tmp;
1775 struct gadget_config_name *cn;
1776
1777 if (gadget_is_otg(g: gadget))
1778 c->descriptors = otg_desc;
1779
1780 /* Properly configure the bmAttributes wakeup bit */
1781 check_remote_wakeup_config(g: gadget, c);
1782
1783 cfg = container_of(c, struct config_usb_cfg, c);
1784 if (!list_empty(head: &cfg->string_list)) {
1785 i = 0;
1786 list_for_each_entry(cn, &cfg->string_list, list) {
1787 cfg->gstrings[i] = &cn->stringtab_dev;
1788 cn->stringtab_dev.strings = &cn->strings;
1789 cn->strings.s = cn->configuration;
1790 i++;
1791 }
1792 cfg->gstrings[i] = NULL;
1793 s = usb_gstrings_attach(cdev: &gi->cdev, sp: cfg->gstrings, n_strings: 1);
1794 if (IS_ERR(ptr: s)) {
1795 ret = PTR_ERR(ptr: s);
1796 goto err_comp_cleanup;
1797 }
1798 c->iConfiguration = s[0].id;
1799 }
1800
1801 list_for_each_entry_safe(f, tmp, &cfg->func_list, list) {
1802 list_del(entry: &f->list);
1803 ret = usb_add_function(c, f);
1804 if (ret) {
1805 list_add(new: &f->list, head: &cfg->func_list);
1806 goto err_purge_funcs;
1807 }
1808 }
1809 ret = usb_gadget_check_config(gadget: cdev->gadget);
1810 if (ret)
1811 goto err_purge_funcs;
1812
1813 usb_ep_autoconfig_reset(cdev->gadget);
1814 }
1815 if (cdev->use_os_string) {
1816 ret = composite_os_desc_req_prepare(cdev, ep0: gadget->ep0);
1817 if (ret)
1818 goto err_purge_funcs;
1819 }
1820
1821 usb_ep_autoconfig_reset(cdev->gadget);
1822 return 0;
1823
1824err_purge_funcs:
1825 purge_configs_funcs(gi);
1826err_comp_cleanup:
1827 composite_dev_cleanup(cdev);
1828 return ret;
1829}
1830
1831static void configfs_composite_unbind(struct usb_gadget *gadget)
1832{
1833 struct usb_composite_dev *cdev;
1834 struct gadget_info *gi;
1835 unsigned long flags;
1836
1837 /* the gi->lock is hold by the caller */
1838
1839 cdev = get_gadget_data(gadget);
1840 gi = container_of(cdev, struct gadget_info, cdev);
1841 spin_lock_irqsave(&gi->spinlock, flags);
1842 gi->unbind = 1;
1843 spin_unlock_irqrestore(lock: &gi->spinlock, flags);
1844
1845 kfree(objp: otg_desc[0]);
1846 otg_desc[0] = NULL;
1847 purge_configs_funcs(gi);
1848 composite_dev_cleanup(cdev);
1849 usb_ep_autoconfig_reset(cdev->gadget);
1850 spin_lock_irqsave(&gi->spinlock, flags);
1851 cdev->gadget = NULL;
1852 cdev->deactivations = 0;
1853 gadget->deactivated = false;
1854 set_gadget_data(gadget, NULL);
1855 spin_unlock_irqrestore(lock: &gi->spinlock, flags);
1856}
1857
1858static int configfs_composite_setup(struct usb_gadget *gadget,
1859 const struct usb_ctrlrequest *ctrl)
1860{
1861 struct usb_composite_dev *cdev;
1862 struct gadget_info *gi;
1863 unsigned long flags;
1864 int ret;
1865
1866 cdev = get_gadget_data(gadget);
1867 if (!cdev)
1868 return 0;
1869
1870 gi = container_of(cdev, struct gadget_info, cdev);
1871 spin_lock_irqsave(&gi->spinlock, flags);
1872 cdev = get_gadget_data(gadget);
1873 if (!cdev || gi->unbind) {
1874 spin_unlock_irqrestore(lock: &gi->spinlock, flags);
1875 return 0;
1876 }
1877
1878 ret = composite_setup(gadget, ctrl);
1879 spin_unlock_irqrestore(lock: &gi->spinlock, flags);
1880 return ret;
1881}
1882
1883static void configfs_composite_disconnect(struct usb_gadget *gadget)
1884{
1885 struct usb_composite_dev *cdev;
1886 struct gadget_info *gi;
1887 unsigned long flags;
1888
1889 cdev = get_gadget_data(gadget);
1890 if (!cdev)
1891 return;
1892
1893 gi = container_of(cdev, struct gadget_info, cdev);
1894 spin_lock_irqsave(&gi->spinlock, flags);
1895 cdev = get_gadget_data(gadget);
1896 if (!cdev || gi->unbind) {
1897 spin_unlock_irqrestore(lock: &gi->spinlock, flags);
1898 return;
1899 }
1900
1901 composite_disconnect(gadget);
1902 spin_unlock_irqrestore(lock: &gi->spinlock, flags);
1903}
1904
1905static void configfs_composite_reset(struct usb_gadget *gadget)
1906{
1907 struct usb_composite_dev *cdev;
1908 struct gadget_info *gi;
1909 unsigned long flags;
1910
1911 cdev = get_gadget_data(gadget);
1912 if (!cdev)
1913 return;
1914
1915 gi = container_of(cdev, struct gadget_info, cdev);
1916 spin_lock_irqsave(&gi->spinlock, flags);
1917 cdev = get_gadget_data(gadget);
1918 if (!cdev || gi->unbind) {
1919 spin_unlock_irqrestore(lock: &gi->spinlock, flags);
1920 return;
1921 }
1922
1923 composite_reset(gadget);
1924 spin_unlock_irqrestore(lock: &gi->spinlock, flags);
1925}
1926
1927static void configfs_composite_suspend(struct usb_gadget *gadget)
1928{
1929 struct usb_composite_dev *cdev;
1930 struct gadget_info *gi;
1931 unsigned long flags;
1932
1933 cdev = get_gadget_data(gadget);
1934 if (!cdev)
1935 return;
1936
1937 gi = container_of(cdev, struct gadget_info, cdev);
1938 spin_lock_irqsave(&gi->spinlock, flags);
1939 cdev = get_gadget_data(gadget);
1940 if (!cdev || gi->unbind) {
1941 spin_unlock_irqrestore(lock: &gi->spinlock, flags);
1942 return;
1943 }
1944
1945 composite_suspend(gadget);
1946 spin_unlock_irqrestore(lock: &gi->spinlock, flags);
1947}
1948
1949static void configfs_composite_resume(struct usb_gadget *gadget)
1950{
1951 struct usb_composite_dev *cdev;
1952 struct gadget_info *gi;
1953 unsigned long flags;
1954
1955 cdev = get_gadget_data(gadget);
1956 if (!cdev)
1957 return;
1958
1959 gi = container_of(cdev, struct gadget_info, cdev);
1960 spin_lock_irqsave(&gi->spinlock, flags);
1961 cdev = get_gadget_data(gadget);
1962 if (!cdev || gi->unbind) {
1963 spin_unlock_irqrestore(lock: &gi->spinlock, flags);
1964 return;
1965 }
1966
1967 composite_resume(gadget);
1968 spin_unlock_irqrestore(lock: &gi->spinlock, flags);
1969}
1970
1971static const struct usb_gadget_driver configfs_driver_template = {
1972 .bind = configfs_composite_bind,
1973 .unbind = configfs_composite_unbind,
1974
1975 .setup = configfs_composite_setup,
1976 .reset = configfs_composite_reset,
1977 .disconnect = configfs_composite_disconnect,
1978
1979 .suspend = configfs_composite_suspend,
1980 .resume = configfs_composite_resume,
1981
1982 .max_speed = USB_SPEED_SUPER_PLUS,
1983 .driver = {
1984 .owner = THIS_MODULE,
1985 },
1986 .match_existing_only = 1,
1987};
1988
1989static struct config_group *gadgets_make(
1990 struct config_group *group,
1991 const char *name)
1992{
1993 struct gadget_info *gi;
1994
1995 gi = kzalloc(sizeof(*gi), GFP_KERNEL);
1996 if (!gi)
1997 return ERR_PTR(error: -ENOMEM);
1998
1999 config_group_init_type_name(group: &gi->group, name, type: &gadget_root_type);
2000
2001 config_group_init_type_name(group: &gi->functions_group, name: "functions",
2002 type: &functions_type);
2003 configfs_add_default_group(new_group: &gi->functions_group, group: &gi->group);
2004
2005 config_group_init_type_name(group: &gi->configs_group, name: "configs",
2006 type: &config_desc_type);
2007 configfs_add_default_group(new_group: &gi->configs_group, group: &gi->group);
2008
2009 config_group_init_type_name(group: &gi->strings_group, name: "strings",
2010 type: &gadget_language_strings_type);
2011 configfs_add_default_group(new_group: &gi->strings_group, group: &gi->group);
2012
2013 config_group_init_type_name(group: &gi->os_desc_group, name: "os_desc",
2014 type: &os_desc_type);
2015 configfs_add_default_group(new_group: &gi->os_desc_group, group: &gi->group);
2016
2017 config_group_init_type_name(group: &gi->webusb_group, name: "webusb",
2018 type: &webusb_type);
2019 configfs_add_default_group(new_group: &gi->webusb_group, group: &gi->group);
2020
2021 gi->composite.bind = configfs_do_nothing;
2022 gi->composite.unbind = configfs_do_nothing;
2023 gi->composite.suspend = NULL;
2024 gi->composite.resume = NULL;
2025 gi->composite.max_speed = USB_SPEED_SUPER_PLUS;
2026
2027 spin_lock_init(&gi->spinlock);
2028 mutex_init(&gi->lock);
2029 INIT_LIST_HEAD(list: &gi->string_list);
2030 INIT_LIST_HEAD(list: &gi->available_func);
2031
2032 composite_init_dev(cdev: &gi->cdev);
2033 gi->cdev.desc.bLength = USB_DT_DEVICE_SIZE;
2034 gi->cdev.desc.bDescriptorType = USB_DT_DEVICE;
2035 gi->cdev.desc.bcdDevice = cpu_to_le16(get_default_bcdDevice());
2036
2037 gi->composite.gadget_driver = configfs_driver_template;
2038
2039 gi->composite.gadget_driver.driver.name = kasprintf(GFP_KERNEL,
2040 fmt: "configfs-gadget.%s", name);
2041 if (!gi->composite.gadget_driver.driver.name)
2042 goto err;
2043
2044 gi->composite.gadget_driver.function = kstrdup(s: name, GFP_KERNEL);
2045 gi->composite.name = gi->composite.gadget_driver.function;
2046
2047 if (!gi->composite.gadget_driver.function)
2048 goto out_free_driver_name;
2049
2050 return &gi->group;
2051
2052out_free_driver_name:
2053 kfree(objp: gi->composite.gadget_driver.driver.name);
2054err:
2055 kfree(objp: gi);
2056 return ERR_PTR(error: -ENOMEM);
2057}
2058
2059static void gadgets_drop(struct config_group *group, struct config_item *item)
2060{
2061 config_item_put(item);
2062}
2063
2064static struct configfs_group_operations gadgets_ops = {
2065 .make_group = &gadgets_make,
2066 .drop_item = &gadgets_drop,
2067};
2068
2069static const struct config_item_type gadgets_type = {
2070 .ct_group_ops = &gadgets_ops,
2071 .ct_owner = THIS_MODULE,
2072};
2073
2074static struct configfs_subsystem gadget_subsys = {
2075 .su_group = {
2076 .cg_item = {
2077 .ci_namebuf = "usb_gadget",
2078 .ci_type = &gadgets_type,
2079 },
2080 },
2081 .su_mutex = __MUTEX_INITIALIZER(gadget_subsys.su_mutex),
2082};
2083
2084void unregister_gadget_item(struct config_item *item)
2085{
2086 struct gadget_info *gi = to_gadget_info(item);
2087
2088 mutex_lock(&gi->lock);
2089 unregister_gadget(gi);
2090 mutex_unlock(lock: &gi->lock);
2091}
2092EXPORT_SYMBOL_GPL(unregister_gadget_item);
2093
2094static int __init gadget_cfs_init(void)
2095{
2096 int ret;
2097
2098 config_group_init(group: &gadget_subsys.su_group);
2099
2100 ret = configfs_register_subsystem(subsys: &gadget_subsys);
2101 return ret;
2102}
2103module_init(gadget_cfs_init);
2104
2105static void __exit gadget_cfs_exit(void)
2106{
2107 configfs_unregister_subsystem(subsys: &gadget_subsys);
2108}
2109module_exit(gadget_cfs_exit);
2110

source code of linux/drivers/usb/gadget/configfs.c