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