projects / linux-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge tag 'x86_cpu_for_v6.11_rc1' of git://git.kernel.org/pub/scm/linux/kernel/git...
[linux-block.git] / drivers / usb / gadget / configfs.c
CommitLineData
5fd54ace 1// SPDX-License-Identifier: GPL-2.0
88af8bbe
SAS		 2#include <linux/configfs.h>
3#include <linux/module.h>
4#include <linux/slab.h>
5#include <linux/device.h>
a8bc8cc1 6#include <linux/kstrtox.h>
87213d38 7#include <linux/nls.h>
88af8bbe
SAS		 8#include <linux/usb/composite.h>
9#include <linux/usb/gadget_configfs.h>
93c47394 10#include <linux/usb/webusb.h>
0009e99a 11#include "configfs.h"
da424314 12#include "u_f.h"
7419485f 13#include "u_os_desc.h"
88af8bbe
SAS		 14
15int check_user_usb_string(const char *name,
16 struct usb_gadget_strings *stringtab_dev)
17{
88af8bbe
SAS		 18 u16 num;
19 int ret;
20
21 ret = kstrtou16(name, 0, &num);
22 if (ret)
23 return ret;
24
17309a6a 25 if (!usb_validate_langid(num))
88af8bbe
SAS		 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
41ce84c8
LJ		 35static const struct usb_descriptor_header *otg_desc[2];
36
88af8bbe
SAS		 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;
87213d38 42 struct config_group os_desc_group;
93c47394 43 struct config_group webusb_group;
88af8bbe
SAS		 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
88af8bbe
SAS		 50 struct usb_composite_driver composite;
51 struct usb_composite_dev cdev;
87213d38
AP		 52 bool use_os_desc;
53 char b_vendor_code;
54 char qw_sign[OS_STRING_QW_SIGN_LEN];
93c47394
JÁB		 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
1a1c851b
PC		 60 spinlock_t spinlock;
61 bool unbind;
88af8bbe
SAS		 62};
63
45b6a73f
CH		 64static inline struct gadget_info *to_gadget_info(struct config_item *item)
65{
9311a531 66 return container_of(to_config_group(item), struct gadget_info, group);
45b6a73f
CH		 67}
68
88af8bbe
SAS		 69struct config_usb_cfg {
70 struct config_group group;
71 struct config_group strings_group;
88af8bbe
SAS		 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
45b6a73f
CH		 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
260d88b7
LY		 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
6e2a512d 89struct gadget_language {
88af8bbe
SAS		 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;
15a7cf8c
DS		 98 struct list_head gadget_strings;
99 unsigned int nstrings;
88af8bbe
SAS		 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
98f153a1
JL		 111#define USB_MAX_STRING_WITH_NULL_LEN (USB_MAX_STRING_LEN+1)
112
88af8bbe
SAS		 113static int usb_string_copy(const char *s, char **s_copy)
114{
115 int ret;
116 char *str;
117 char *copy = *s_copy;
6d3c721e 118
88af8bbe 119 ret = strlen(s);
81c74628 120 if (ret > USB_MAX_STRING_LEN)
88af8bbe 121 return -EOVERFLOW;
6d3c721e
LJ		 122 if (ret < 1)
123 return -EINVAL;
88af8bbe 124
98f153a1
JL		 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);
88af8bbe
SAS		 133 if (str[ret - 1] == '\n')
134 str[ret - 1] = '\0';
88af8bbe
SAS		 135 *s_copy = str;
136 return 0;
137}
138
88af8bbe 139#define GI_DEVICE_DESC_SIMPLE_R_u8(__name) \
45b6a73f 140static ssize_t gadget_dev_desc_##__name##_show(struct config_item *item, \
88af8bbe
SAS		 141 char *page) \
142{ \
45b6a73f
CH		 143 return sprintf(page, "0x%02x\n", \
144 to_gadget_info(item)->cdev.desc.__name); \
88af8bbe
SAS		 145}
146
147#define GI_DEVICE_DESC_SIMPLE_R_u16(__name) \
45b6a73f 148static ssize_t gadget_dev_desc_##__name##_show(struct config_item *item, \
88af8bbe
SAS		 149 char *page) \
150{ \
45b6a73f
CH		 151 return sprintf(page, "0x%04x\n", \
152 le16_to_cpup(&to_gadget_info(item)->cdev.desc.__name)); \
88af8bbe
SAS		 153}
154
155
156#define GI_DEVICE_DESC_SIMPLE_W_u8(_name) \
45b6a73f 157static ssize_t gadget_dev_desc_##_name##_store(struct config_item *item, \
88af8bbe
SAS		 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; \
45b6a73f 165 to_gadget_info(item)->cdev.desc._name = val; \
88af8bbe
SAS		 166 return len; \
167}
168
169#define GI_DEVICE_DESC_SIMPLE_W_u16(_name) \
45b6a73f 170static ssize_t gadget_dev_desc_##_name##_store(struct config_item *item, \
88af8bbe
SAS		 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; \
45b6a73f 178 to_gadget_info(item)->cdev.desc._name = cpu_to_le16p(&val); \
88af8bbe
SAS		 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
45b6a73f 208static ssize_t gadget_dev_desc_bcdDevice_store(struct config_item *item,
88af8bbe
SAS		 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
45b6a73f 221 to_gadget_info(item)->cdev.desc.bcdDevice = cpu_to_le16(bcdDevice);
88af8bbe
SAS		 222 return len;
223}
224
45b6a73f 225static ssize_t gadget_dev_desc_bcdUSB_store(struct config_item *item,
88af8bbe
SAS		 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
45b6a73f 238 to_gadget_info(item)->cdev.desc.bcdUSB = cpu_to_le16(bcdUSB);
88af8bbe
SAS		 239 return len;
240}
241
45b6a73f 242static ssize_t gadget_dev_desc_UDC_show(struct config_item *item, char *page)
88af8bbe 243{
64e6bbff
EH		 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);
afdaadc3 252
64e6bbff 253 return ret;
88af8bbe
SAS		 254}
255
256static int unregister_gadget(struct gadget_info *gi)
257{
258 int ret;
259
afdaadc3 260 if (!gi->composite.gadget_driver.udc_name)
88af8bbe
SAS		 261 return -ENODEV;
262
263 ret = usb_gadget_unregister_driver(&gi->composite.gadget_driver);
264 if (ret)
265 return ret;
afdaadc3
RB		 266 kfree(gi->composite.gadget_driver.udc_name);
267 gi->composite.gadget_driver.udc_name = NULL;
88af8bbe
SAS		 268 return 0;
269}
270
45b6a73f 271static ssize_t gadget_dev_desc_UDC_store(struct config_item *item,
88af8bbe
SAS		 272 const char *page, size_t len)
273{
45b6a73f 274 struct gadget_info *gi = to_gadget_info(item);
88af8bbe
SAS		 275 char *name;
276 int ret;
277
15753588
KK		 278 if (strlen(page) < len)
279 return -EOVERFLOW;
280
88af8bbe
SAS		 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;
38355b2a 293 kfree(name);
88af8bbe 294 } else {
afdaadc3 295 if (gi->composite.gadget_driver.udc_name) {
88af8bbe
SAS		 296 ret = -EBUSY;
297 goto err;
298 }
afdaadc3 299 gi->composite.gadget_driver.udc_name = name;
af1969a2 300 ret = usb_gadget_register_driver(&gi->composite.gadget_driver);
afdaadc3
RB		 301 if (ret) {
302 gi->composite.gadget_driver.udc_name = NULL;
88af8bbe 303 goto err;
afdaadc3 304 }
88af8bbe
SAS		 305 }
306 mutex_unlock(&gi->lock);
307 return len;
308err:
309 kfree(name);
310 mutex_unlock(&gi->lock);
311 return ret;
312}
313
a0249703
TN		 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(page, "%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(&gi->lock);
349 return len;
350err:
351 mutex_unlock(&gi->lock);
352 return -EINVAL;
353}
354
45b6a73f
CH		 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);
a0249703 364CONFIGFS_ATTR(gadget_dev_desc_, max_speed);
88af8bbe
SAS		 365
366static struct configfs_attribute *gadget_root_attrs[] = {
45b6a73f
CH		 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,
a0249703 376 &gadget_dev_desc_attr_max_speed,
88af8bbe
SAS		 377 NULL,
378};
379
6e2a512d 380static inline struct gadget_language *to_gadget_language(struct config_item *item)
88af8bbe 381{
6e2a512d 382 return container_of(to_config_group(item), struct gadget_language,
88af8bbe
SAS		 383 group);
384}
385
386static inline struct gadget_config_name *to_gadget_config_name(
387 struct config_item *item)
388{
9311a531 389 return container_of(to_config_group(item), struct gadget_config_name,
88af8bbe
SAS		 390 group);
391}
392
88af8bbe
SAS		 393static inline struct usb_function_instance *to_usb_function_instance(
394 struct config_item *item)
395{
9311a531 396 return container_of(to_config_group(item),
88af8bbe
SAS		 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(gi->composite.gadget_driver.function);
7c075538 408 kfree(gi->composite.gadget_driver.driver.name);
88af8bbe
SAS		 409 kfree(gi);
410}
411
88af8bbe
SAS		 412static struct configfs_item_operations gadget_root_item_ops = {
413 .release = gadget_info_attr_release,
88af8bbe
SAS		 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(&cfg->c.list);
422 kfree(cfg->c.label);
423 kfree(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(usb_cfg_ci);
260d88b7 431 struct gadget_info *gi = cfg_to_gadget_info(cfg);
88af8bbe 432
5284accc
LY		 433 struct usb_function_instance *fi =
434 to_usb_function_instance(usb_func_ci);
36f4c25c 435 struct usb_function_instance *a_fi = NULL, *iter;
88af8bbe
SAS		 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 */
89e7252d
UG		 445
446 if (gi->composite.gadget_driver.udc_name) {
447 ret = -EINVAL;
448 goto out;
449 }
450
36f4c25c
JK		 451 list_for_each_entry(iter, &gi->available_func, cfs_list) {
452 if (iter != fi)
453 continue;
454 a_fi = iter;
455 break;
88af8bbe 456 }
36f4c25c 457 if (!a_fi) {
88af8bbe
SAS		 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;
478out:
479 mutex_unlock(&gi->lock);
480 return ret;
481}
482
e16769d4 483static void config_usb_cfg_unlink(
88af8bbe
SAS		 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);
260d88b7 488 struct gadget_info *gi = cfg_to_gadget_info(cfg);
88af8bbe 489
5284accc
LY		 490 struct usb_function_instance *fi =
491 to_usb_function_instance(usb_func_ci);
88af8bbe
SAS		 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);
afdaadc3 501 if (gi->composite.gadget_driver.udc_name)
88af8bbe 502 unregister_gadget(gi);
afdaadc3 503 WARN_ON(gi->composite.gadget_driver.udc_name);
88af8bbe
SAS		 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);
e16769d4 510 return;
88af8bbe
SAS		 511 }
512 }
513 mutex_unlock(&gi->lock);
75bfe23a 514 WARN(1, "Unable to locate function to unbind\n");
88af8bbe
SAS		 515}
516
88af8bbe
SAS		 517static struct configfs_item_operations gadget_config_item_ops = {
518 .release = gadget_config_attr_release,
88af8bbe
SAS		 519 .allow_link = config_usb_cfg_link,
520 .drop_link = config_usb_cfg_unlink,
521};
522
523
45b6a73f 524static ssize_t gadget_config_desc_MaxPower_show(struct config_item *item,
88af8bbe
SAS		 525 char *page)
526{
c26f1c10
LY		 527 struct config_usb_cfg *cfg = to_config_usb_cfg(item);
528
529 return sprintf(page, "%u\n", cfg->c.MaxPower);
88af8bbe
SAS		 530}
531
45b6a73f 532static ssize_t gadget_config_desc_MaxPower_store(struct config_item *item,
88af8bbe
SAS		 533 const char *page, size_t len)
534{
c26f1c10 535 struct config_usb_cfg *cfg = to_config_usb_cfg(item);
88af8bbe
SAS		 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;
c26f1c10 543 cfg->c.MaxPower = val;
88af8bbe
SAS		 544 return len;
545}
546
45b6a73f 547static ssize_t gadget_config_desc_bmAttributes_show(struct config_item *item,
88af8bbe
SAS		 548 char *page)
549{
c26f1c10
LY		 550 struct config_usb_cfg *cfg = to_config_usb_cfg(item);
551
552 return sprintf(page, "0x%02x\n", cfg->c.bmAttributes);
88af8bbe
SAS		 553}
554
45b6a73f 555static ssize_t gadget_config_desc_bmAttributes_store(struct config_item *item,
88af8bbe
SAS		 556 const char *page, size_t len)
557{
c26f1c10 558 struct config_usb_cfg *cfg = to_config_usb_cfg(item);
88af8bbe
SAS		 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;
c26f1c10 569 cfg->c.bmAttributes = val;
88af8bbe
SAS		 570 return len;
571}
572
45b6a73f
CH		 573CONFIGFS_ATTR(gadget_config_desc_, MaxPower);
574CONFIGFS_ATTR(gadget_config_desc_, bmAttributes);
88af8bbe
SAS		 575
576static struct configfs_attribute *gadget_config_attrs[] = {
45b6a73f
CH		 577 &gadget_config_desc_attr_MaxPower,
578 &gadget_config_desc_attr_bmAttributes,
88af8bbe
SAS		 579 NULL,
580};
581
4ad01412 582static const struct config_item_type gadget_config_type = {
88af8bbe
SAS		 583 .ct_item_ops = &gadget_config_item_ops,
584 .ct_attrs = gadget_config_attrs,
585 .ct_owner = THIS_MODULE,
586};
587
4ad01412 588static const struct config_item_type gadget_root_type = {
88af8bbe
SAS		 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(&cdev->configs);
598 INIT_LIST_HEAD(&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
0466e7e6 612 if (strlen(name) >= MAX_NAME_LEN)
88af8bbe
SAS		 613 return ERR_PTR(-ENAMETOOLONG);
614
0466e7e6
LJ		 615 scnprintf(buf, MAX_NAME_LEN, "%s", name);
616
88af8bbe
SAS		 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))
a3469411 628 return ERR_CAST(fi);
88af8bbe 629
3958b792 630 ret = config_item_set_name(&fi->group.cg_item, "%s", name);
88af8bbe
SAS		 631 if (ret) {
632 usb_put_function_instance(fi);
633 return ERR_PTR(ret);
634 }
1933861d
AP		 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 }
88af8bbe
SAS		 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
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(&fi->cfs_list);
662 mutex_unlock(&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
4ad01412 671static const struct config_item_type functions_type = {
88af8bbe
SAS		 672 .ct_group_ops = &functions_ops,
673 .ct_owner = THIS_MODULE,
674};
675
88af8bbe
SAS		 676GS_STRINGS_RW(gadget_config_name, configuration);
677
678static struct configfs_attribute *gadget_config_name_langid_attrs[] = {
45b6a73f 679 &gadget_config_name_attr_configuration,
88af8bbe
SAS		 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(cn->configuration);
688
689 list_del(&cn->list);
690 kfree(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);
0466e7e6
LJ		 708
709 if (strlen(name) >= MAX_NAME_LEN)
88af8bbe
SAS		 710 return ERR_PTR(-ENAMETOOLONG);
711
0466e7e6
LJ		 712 scnprintf(buf, MAX_NAME_LEN, "%s", name);
713
88af8bbe
SAS		 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
88af8bbe
SAS		 744 config_group_init_type_name(&cfg->group, name,
745 &gadget_config_type);
1ae1602d 746
88af8bbe
SAS		 747 config_group_init_type_name(&cfg->strings_group, "strings",
748 &gadget_config_name_strings_type);
1ae1602d 749 configfs_add_default_group(&cfg->strings_group, &cfg->group);
88af8bbe
SAS		 750
751 ret = usb_add_config_only(&gi->cdev, &cfg->c);
752 if (ret)
753 goto err;
754
755 return &cfg->group;
756err:
757 kfree(cfg->c.label);
758 kfree(cfg);
759 return ERR_PTR(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
4ad01412 774static const struct config_item_type config_desc_type = {
88af8bbe
SAS		 775 .ct_group_ops = &config_desc_ops,
776 .ct_owner = THIS_MODULE,
777};
778
6e2a512d
DS		 779GS_STRINGS_RW(gadget_language, manufacturer);
780GS_STRINGS_RW(gadget_language, product);
781GS_STRINGS_RW(gadget_language, serialnumber);
88af8bbe 782
6e2a512d
DS		 783static struct configfs_attribute *gadget_language_langid_attrs[] = {
784 &gadget_language_attr_manufacturer,
785 &gadget_language_attr_product,
786 &gadget_language_attr_serialnumber,
88af8bbe
SAS		 787 NULL,
788};
789
6e2a512d 790static void gadget_language_attr_release(struct config_item *item)
88af8bbe 791{
6e2a512d 792 struct gadget_language *gs = to_gadget_language(item);
88af8bbe
SAS		 793
794 kfree(gs->manufacturer);
795 kfree(gs->product);
796 kfree(gs->serialnumber);
797
798 list_del(&gs->list);
799 kfree(gs);
800}
801
15a7cf8c
DS		 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(page, "%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
38168e2d 821 ret = sysfs_emit(page, "%s\n", string->string);
15a7cf8c
DS		 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);
15a7cf8c
DS		 830
831 if (len > USB_MAX_STRING_LEN)
832 return -EINVAL;
833
8488a831 834 return strscpy(string->string, page, size);
15a7cf8c
DS		 835}
836CONFIGFS_ATTR(gadget_string_, s);
837
838static struct configfs_attribute *gadget_string_attrs[] = {
839 &gadget_string_attr_id,
840 &gadget_string_attr_s,
841 NULL,
842};
843
844static void gadget_string_release(struct config_item *item)
845{
846 struct gadget_string *string = to_gadget_string(item);
847
848 kfree(string);
849}
850
851static struct configfs_item_operations gadget_string_item_ops = {
852 .release = gadget_string_release,
853};
854
855static 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
861static 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
882static 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
900static 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
905static 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
912static 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;
948err:
949 kfree(new);
950 return ERR_PTR(ret);
951}
952
953static void gadget_language_drop(struct config_group *group,
954 struct config_item *item)
955{
956 config_item_put(item);
957}
958
959static struct configfs_group_operations gadget_language_group_ops = {
960 .make_group = &gadget_language_make,
961 .drop_item = &gadget_language_drop,
962};
963
964static struct config_item_type gadget_language_strings_type = {
965 .ct_group_ops = &gadget_language_group_ops,
966 .ct_owner = THIS_MODULE,
967};
88af8bbe 968
93c47394
JÁB		 969static 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
976static 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
982static 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
93c47394 989 ret = kstrtobool(page, &use);
6f7fb48d
AS		 990 if (ret)
991 return ret;
992
993 mutex_lock(&gi->lock);
994 gi->use_webusb = use;
93c47394
JÁB		 995 mutex_unlock(&gi->lock);
996
6f7fb48d 997 return len;
93c47394
JÁB		 998}
999
1000static 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
1006static 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
93c47394
JÁB		 1013 ret = kstrtou16(page, 0, &bcdVersion);
1014 if (ret)
6f7fb48d
AS		 1015 return ret;
1016
93c47394
JÁB		 1017 ret = is_valid_bcd(bcdVersion);
1018 if (ret)
582cef43 1019 return ret;
93c47394 1020
582cef43 1021 mutex_lock(&gi->lock);
93c47394 1022 gi->bcd_webusb_version = bcdVersion;
93c47394
JÁB		 1023 mutex_unlock(&gi->lock);
1024
582cef43 1025 return len;
93c47394
JÁB		 1026}
1027
1028static 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
1034static 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
93c47394 1041 ret = kstrtou8(page, 0, &b_vendor_code);
6f7fb48d
AS		 1042 if (ret)
1043 return ret;
1044
1045 mutex_lock(&gi->lock);
1046 gi->b_webusb_vendor_code = b_vendor_code;
93c47394
JÁB		 1047 mutex_unlock(&gi->lock);
1048
6f7fb48d 1049 return len;
93c47394
JÁB		 1050}
1051
1052static 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
1057static 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.
9c0e6fbd 1090 memcpy_and_pad(gi->landing_page, sizeof(gi->landing_page), page, l, 0);
93c47394
JÁB		 1091 mutex_unlock(&gi->lock);
1092
1093 return len;
1094}
1095
1096CONFIGFS_ATTR(webusb_, use);
1097CONFIGFS_ATTR(webusb_, bVendorCode);
1098CONFIGFS_ATTR(webusb_, bcdVersion);
1099CONFIGFS_ATTR(webusb_, landingPage);
1100
1101static 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
1109static struct config_item_type webusb_type = {
1110 .ct_attrs = webusb_attrs,
1111 .ct_owner = THIS_MODULE,
1112};
1113
45b6a73f
CH		 1114static inline struct gadget_info *os_desc_item_to_gadget_info(
1115 struct config_item *item)
87213d38 1116{
167a799c
LY		 1117 return container_of(to_config_group(item),
1118 struct gadget_info, os_desc_group);
45b6a73f 1119}
87213d38 1120
45b6a73f
CH		 1121static ssize_t os_desc_use_show(struct config_item *item, char *page)
1122{
e800e8cb 1123 return sprintf(page, "%d\n",
45b6a73f 1124 os_desc_item_to_gadget_info(item)->use_os_desc);
87213d38
AP		 1125}
1126
45b6a73f 1127static ssize_t os_desc_use_store(struct config_item *item, const char *page,
87213d38
AP		 1128 size_t len)
1129{
45b6a73f 1130 struct gadget_info *gi = os_desc_item_to_gadget_info(item);
87213d38
AP		 1131 int ret;
1132 bool use;
1133
a8bc8cc1 1134 ret = kstrtobool(page, &use);
6f7fb48d
AS		 1135 if (ret)
1136 return ret;
1137
1138 mutex_lock(&gi->lock);
1139 gi->use_os_desc = use;
87213d38
AP		 1140 mutex_unlock(&gi->lock);
1141
6f7fb48d 1142 return len;
87213d38
AP		 1143}
1144
45b6a73f 1145static ssize_t os_desc_b_vendor_code_show(struct config_item *item, char *page)
87213d38 1146{
e800e8cb 1147 return sprintf(page, "0x%02x\n",
45b6a73f 1148 os_desc_item_to_gadget_info(item)->b_vendor_code);
87213d38
AP		 1149}
1150
45b6a73f 1151static ssize_t os_desc_b_vendor_code_store(struct config_item *item,
87213d38
AP		 1152 const char *page, size_t len)
1153{
45b6a73f 1154 struct gadget_info *gi = os_desc_item_to_gadget_info(item);
87213d38
AP		 1155 int ret;
1156 u8 b_vendor_code;
1157
87213d38 1158 ret = kstrtou8(page, 0, &b_vendor_code);
6f7fb48d
AS		 1159 if (ret)
1160 return ret;
1161
1162 mutex_lock(&gi->lock);
1163 gi->b_vendor_code = b_vendor_code;
87213d38
AP		 1164 mutex_unlock(&gi->lock);
1165
6f7fb48d 1166 return len;
87213d38
AP		 1167}
1168
45b6a73f 1169static ssize_t os_desc_qw_sign_show(struct config_item *item, char *page)
87213d38 1170{
45b6a73f 1171 struct gadget_info *gi = os_desc_item_to_gadget_info(item);
76180d71 1172 int res;
87213d38 1173
76180d71
SA		 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;
87213d38
AP		 1179}
1180
45b6a73f 1181static ssize_t os_desc_qw_sign_store(struct config_item *item, const char *page,
87213d38
AP		 1182 size_t len)
1183{
45b6a73f 1184 struct gadget_info *gi = os_desc_item_to_gadget_info(item);
87213d38
AP		 1185 int res, l;
1186
87213d38
AP		 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
45b6a73f
CH		 1202CONFIGFS_ATTR(os_desc_, use);
1203CONFIGFS_ATTR(os_desc_, b_vendor_code);
1204CONFIGFS_ATTR(os_desc_, qw_sign);
87213d38
AP		 1205
1206static struct configfs_attribute *os_desc_attrs[] = {
45b6a73f
CH		 1207 &os_desc_attr_use,
1208 &os_desc_attr_b_vendor_code,
1209 &os_desc_attr_qw_sign,
87213d38
AP		 1210 NULL,
1211};
1212
da424314
AP		 1213static int os_desc_link(struct config_item *os_desc_ci,
1214 struct config_item *usb_cfg_ci)
1215{
167a799c 1216 struct gadget_info *gi = os_desc_item_to_gadget_info(os_desc_ci);
da424314 1217 struct usb_composite_dev *cdev = &gi->cdev;
5d143ec4 1218 struct config_usb_cfg *c_target = to_config_usb_cfg(usb_cfg_ci);
36f4c25c 1219 struct usb_configuration *c = NULL, *iter;
da424314
AP		 1220 int ret;
1221
1222 mutex_lock(&gi->lock);
36f4c25c
JK		 1223 list_for_each_entry(iter, &cdev->configs, list) {
1224 if (iter != &c_target->c)
1225 continue;
1226 c = iter;
1227 break;
da424314 1228 }
36f4c25c 1229 if (!c) {
da424314
AP		 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
1242out:
1243 mutex_unlock(&gi->lock);
1244 return ret;
1245}
1246
e16769d4 1247static void os_desc_unlink(struct config_item *os_desc_ci,
da424314
AP		 1248 struct config_item *usb_cfg_ci)
1249{
167a799c 1250 struct gadget_info *gi = os_desc_item_to_gadget_info(os_desc_ci);
da424314
AP		 1251 struct usb_composite_dev *cdev = &gi->cdev;
1252
1253 mutex_lock(&gi->lock);
afdaadc3 1254 if (gi->composite.gadget_driver.udc_name)
da424314
AP		 1255 unregister_gadget(gi);
1256 cdev->os_desc_config = NULL;
afdaadc3 1257 WARN_ON(gi->composite.gadget_driver.udc_name);
da424314 1258 mutex_unlock(&gi->lock);
da424314
AP		 1259}
1260
87213d38 1261static struct configfs_item_operations os_desc_ops = {
da424314
AP		 1262 .allow_link = os_desc_link,
1263 .drop_link = os_desc_unlink,
87213d38
AP		 1264};
1265
1266static 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
7419485f
AP		 1272static inline struct usb_os_desc_ext_prop
1273*to_usb_os_desc_ext_prop(struct config_item *item)
1274{
1275 return container_of(item, struct usb_os_desc_ext_prop, item);
1276}
1277
45b6a73f 1278static ssize_t ext_prop_type_show(struct config_item *item, char *page)
7419485f 1279{
e800e8cb 1280 return sprintf(page, "%d\n", to_usb_os_desc_ext_prop(item)->type);
7419485f
AP		 1281}
1282
45b6a73f 1283static ssize_t ext_prop_type_store(struct config_item *item,
7419485f
AP		 1284 const char *page, size_t len)
1285{
45b6a73f 1286 struct usb_os_desc_ext_prop *ext_prop = to_usb_os_desc_ext_prop(item);
7419485f
AP		 1287 struct usb_os_desc *desc = to_usb_os_desc(ext_prop->item.ci_parent);
1288 u8 type;
1289 int ret;
1290
7419485f
AP		 1291 ret = kstrtou8(page, 0, &type);
1292 if (ret)
6f7fb48d
AS		 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);
7419485f
AP		 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;
7419485f 1316
7419485f
AP		 1317 if (desc->opts_mutex)
1318 mutex_unlock(desc->opts_mutex);
6f7fb48d 1319 return len;
7419485f
AP		 1320}
1321
45b6a73f 1322static ssize_t ext_prop_data_show(struct config_item *item, char *page)
7419485f 1323{
45b6a73f 1324 struct usb_os_desc_ext_prop *ext_prop = to_usb_os_desc_ext_prop(item);
7419485f
AP		 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
45b6a73f 1336static ssize_t ext_prop_data_store(struct config_item *item,
7419485f
AP		 1337 const char *page, size_t len)
1338{
45b6a73f 1339 struct usb_os_desc_ext_prop *ext_prop = to_usb_os_desc_ext_prop(item);
7419485f
AP		 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;
58b949e0 1346 new_data = kmemdup(page, len, GFP_KERNEL);
7419485f
AP		 1347 if (!new_data)
1348 return -ENOMEM;
1349
7419485f
AP		 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
45b6a73f
CH		 1370CONFIGFS_ATTR(ext_prop_, type);
1371CONFIGFS_ATTR(ext_prop_, data);
7419485f
AP		 1372
1373static struct configfs_attribute *ext_prop_attrs[] = {
45b6a73f
CH		 1374 &ext_prop_attr_type,
1375 &ext_prop_attr_data,
7419485f
AP		 1376 NULL,
1377};
1378
1379static 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
1386static struct configfs_item_operations ext_prop_ops = {
1387 .release = usb_os_desc_ext_prop_release,
7419485f
AP		 1388};
1389
1390static 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
1435static 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
1451static struct configfs_group_operations interf_grp_ops = {
1452 .make_item = &ext_prop_make,
1453 .drop_item = &ext_prop_drop,
1454};
1455
45b6a73f 1456static ssize_t interf_grp_compatible_id_show(struct config_item *item,
fe00b138 1457 char *page)
da424314 1458{
45b6a73f 1459 memcpy(page, to_usb_os_desc(item)->ext_compat_id, 8);
da424314
AP		 1460 return 8;
1461}
1462
45b6a73f 1463static ssize_t interf_grp_compatible_id_store(struct config_item *item,
fe00b138 1464 const char *page, size_t len)
da424314 1465{
45b6a73f 1466 struct usb_os_desc *desc = to_usb_os_desc(item);
da424314
AP		 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);
da424314
AP		 1475
1476 if (desc->opts_mutex)
1477 mutex_unlock(desc->opts_mutex);
1478
1479 return len;
1480}
1481
45b6a73f 1482static ssize_t interf_grp_sub_compatible_id_show(struct config_item *item,
fe00b138 1483 char *page)
da424314 1484{
45b6a73f 1485 memcpy(page, to_usb_os_desc(item)->ext_compat_id + 8, 8);
da424314
AP		 1486 return 8;
1487}
1488
45b6a73f 1489static ssize_t interf_grp_sub_compatible_id_store(struct config_item *item,
fe00b138 1490 const char *page, size_t len)
da424314 1491{
45b6a73f 1492 struct usb_os_desc *desc = to_usb_os_desc(item);
da424314
AP		 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);
da424314
AP		 1501
1502 if (desc->opts_mutex)
1503 mutex_unlock(desc->opts_mutex);
1504
1505 return len;
1506}
1507
45b6a73f
CH		 1508CONFIGFS_ATTR(interf_grp_, compatible_id);
1509CONFIGFS_ATTR(interf_grp_, sub_compatible_id);
da424314
AP		 1510
1511static struct configfs_attribute *interf_grp_attrs[] = {
45b6a73f
CH		 1512 &interf_grp_attr_compatible_id,
1513 &interf_grp_attr_sub_compatible_id,
da424314
AP		 1514 NULL
1515};
1516
ff74745e
AG		 1517struct 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)
da424314 1523{
1ae1602d 1524 struct config_group *os_desc_group;
da424314
AP		 1525 struct config_item_type *os_desc_type, *interface_type;
1526
1527 vla_group(data_chunk);
da424314 1528 vla_item(data_chunk, struct config_group, os_desc_group, 1);
da424314
AP		 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)
ff74745e 1534 return ERR_PTR(-ENOMEM);
da424314 1535
da424314
AP		 1536 os_desc_group = vla_ptr(vlabuf, data_chunk, os_desc_group);
1537 os_desc_type = vla_ptr(vlabuf, data_chunk, os_desc_type);
da424314
AP		 1538 interface_type = vla_ptr(vlabuf, data_chunk, interface_type);
1539
da424314
AP		 1540 os_desc_type->ct_owner = owner;
1541 config_group_init_type_name(os_desc_group, "os_desc", os_desc_type);
1ae1602d 1542 configfs_add_default_group(os_desc_group, parent);
da424314 1543
7419485f 1544 interface_type->ct_group_ops = &interf_grp_ops;
da424314
AP		 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];
7419485f 1552 d->owner = owner;
da424314 1553 config_group_init_type_name(&d->group, "", interface_type);
14574b54
AP		 1554 config_item_set_name(&d->group.cg_item, "interface.%s",
1555 names[n_interf]);
1ae1602d 1556 configfs_add_default_group(&d->group, os_desc_group);
da424314
AP		 1557 }
1558
ff74745e 1559 return os_desc_group;
da424314
AP		 1560}
1561EXPORT_SYMBOL(usb_os_desc_prepare_interf_dir);
1562
88af8bbe
SAS		 1563static int configfs_do_nothing(struct usb_composite_dev *cdev)
1564{
75bfe23a 1565 WARN_ON(1);
88af8bbe
SAS		 1566 return -EINVAL;
1567}
1568
1569int composite_dev_prepare(struct usb_composite_driver *composite,
1570 struct usb_composite_dev *dev);
1571
da424314
AP		 1572int composite_os_desc_req_prepare(struct usb_composite_dev *cdev,
1573 struct usb_ep *ep0);
1574
88af8bbe
SAS		 1575static 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
6cd0fe91 1585 list_for_each_entry_safe_reverse(f, tmp, &c->functions, list) {
88af8bbe 1586
6cd0fe91 1587 list_move(&f->list, &cfg->func_list);
88af8bbe 1588 if (f->unbind) {
da7b895d 1589 dev_dbg(&gi->cdev.gadget->dev,
ad22a666
PS		 1590 "unbind function '%s'/%p\n",
1591 f->name, f);
88af8bbe
SAS		 1592 f->unbind(c, f);
1593 }
1594 }
1595 c->next_interface_id = 0;
903124fe 1596 memset(c->interface, 0, sizeof(c->interface));
554eead5 1597 c->superspeed_plus = 0;
88af8bbe
SAS		 1598 c->superspeed = 0;
1599 c->highspeed = 0;
1600 c->fullspeed = 0;
1601 }
1602}
1603
c0335632
DS		 1604static struct usb_string *
1605configfs_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
1667cleanup:
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
88af8bbe
SAS		 1678static 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 */
1a1c851b 1691 gi->unbind = 0;
88af8bbe
SAS		 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)) {
4d9f872c 1701 pr_err("Need at least one configuration in %s.\n",
88af8bbe
SAS		 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)) {
4d9f872c 1712 pr_err("Config %s/%d of %s needs at least one function.\n",
88af8bbe
SAS		 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)) {
c0335632 1721 s = configfs_attach_gadget_strings(gi);
fea77077
WY		 1722 if (IS_ERR(s)) {
1723 ret = PTR_ERR(s);
88af8bbe 1724 goto err_comp_cleanup;
fea77077 1725 }
88af8bbe
SAS		 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;
c0335632
DS		 1730
1731 gi->cdev.usb_strings = s;
88af8bbe
SAS		 1732 }
1733
93c47394
JÁB		 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
87213d38
AP		 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
41ce84c8
LJ		 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
88af8bbe
SAS		 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
41ce84c8
LJ		 1767 if (gadget_is_otg(gadget))
1768 c->descriptors = otg_desc;
1769
b93c2a68
ERS		 1770 /* Properly configure the bmAttributes wakeup bit */
1771 check_remote_wakeup_config(gadget, c);
1772
88af8bbe
SAS		 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);
fea77077
WY		 1784 if (IS_ERR(s)) {
1785 ret = PTR_ERR(s);
88af8bbe 1786 goto err_comp_cleanup;
fea77077 1787 }
88af8bbe
SAS		 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);
5a68e9b5
AP		 1794 if (ret) {
1795 list_add(&f->list, &cfg->func_list);
88af8bbe 1796 goto err_purge_funcs;
5a68e9b5 1797 }
88af8bbe 1798 }
7adf9e3a
WC		 1799 ret = usb_gadget_check_config(cdev->gadget);
1800 if (ret)
1801 goto err_purge_funcs;
1802
88af8bbe
SAS		 1803 usb_ep_autoconfig_reset(cdev->gadget);
1804 }
da424314
AP		 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
88af8bbe
SAS		 1811 usb_ep_autoconfig_reset(cdev->gadget);
1812 return 0;
1813
1814err_purge_funcs:
1815 purge_configs_funcs(gi);
1816err_comp_cleanup:
1817 composite_dev_cleanup(cdev);
1818 return ret;
1819}
1820
1821static void configfs_composite_unbind(struct usb_gadget *gadget)
1822{
1823 struct usb_composite_dev *cdev;
1824 struct gadget_info *gi;
1a1c851b 1825 unsigned long flags;
88af8bbe
SAS		 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);
1a1c851b
PC		 1831 spin_lock_irqsave(&gi->spinlock, flags);
1832 gi->unbind = 1;
1833 spin_unlock_irqrestore(&gi->spinlock, flags);
88af8bbe 1834
41ce84c8
LJ		 1835 kfree(otg_desc[0]);
1836 otg_desc[0] = NULL;
88af8bbe
SAS		 1837 purge_configs_funcs(gi);
1838 composite_dev_cleanup(cdev);
1839 usb_ep_autoconfig_reset(cdev->gadget);
1a1c851b 1840 spin_lock_irqsave(&gi->spinlock, flags);
88af8bbe 1841 cdev->gadget = NULL;
bf95c4d4
VV		 1842 cdev->deactivations = 0;
1843 gadget->deactivated = false;
88af8bbe 1844 set_gadget_data(gadget, NULL);
1a1c851b
PC		 1845 spin_unlock_irqrestore(&gi->spinlock, flags);
1846}
1847
1848static 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
1873static 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
4d7aae9f
WC		 1895static 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
1a1c851b
PC		 1917static 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
1939static 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);
88af8bbe
SAS		 1959}
1960
1961static const struct usb_gadget_driver configfs_driver_template = {
1962 .bind = configfs_composite_bind,
1963 .unbind = configfs_composite_unbind,
1964
1a1c851b 1965 .setup = configfs_composite_setup,
4d7aae9f 1966 .reset = configfs_composite_reset,
1a1c851b 1967 .disconnect = configfs_composite_disconnect,
88af8bbe 1968
1a1c851b
PC		 1969 .suspend = configfs_composite_suspend,
1970 .resume = configfs_composite_resume,
3a571870 1971
e2459108 1972 .max_speed = USB_SPEED_SUPER_PLUS,
88af8bbe
SAS		 1973 .driver = {
1974 .owner = THIS_MODULE,
88af8bbe 1975 },
f1bddbb3 1976 .match_existing_only = 1,
88af8bbe
SAS		 1977};
1978
1979static 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
1ae1602d 1989 config_group_init_type_name(&gi->group, name, &gadget_root_type);
88af8bbe
SAS		 1990
1991 config_group_init_type_name(&gi->functions_group, "functions",
1992 &functions_type);
1ae1602d
CH		 1993 configfs_add_default_group(&gi->functions_group, &gi->group);
1994
88af8bbe
SAS		 1995 config_group_init_type_name(&gi->configs_group, "configs",
1996 &config_desc_type);
1ae1602d
CH		 1997 configfs_add_default_group(&gi->configs_group, &gi->group);
1998
88af8bbe 1999 config_group_init_type_name(&gi->strings_group, "strings",
6e2a512d 2000 &gadget_language_strings_type);
1ae1602d
CH		 2001 configfs_add_default_group(&gi->strings_group, &gi->group);
2002
87213d38
AP		 2003 config_group_init_type_name(&gi->os_desc_group, "os_desc",
2004 &os_desc_type);
1ae1602d 2005 configfs_add_default_group(&gi->os_desc_group, &gi->group);
88af8bbe 2006
93c47394
JÁB		 2007 config_group_init_type_name(&gi->webusb_group, "webusb",
2008 &webusb_type);
2009 configfs_add_default_group(&gi->webusb_group, &gi->group);
2010
88af8bbe
SAS		 2011 gi->composite.bind = configfs_do_nothing;
2012 gi->composite.unbind = configfs_do_nothing;
2013 gi->composite.suspend = NULL;
2014 gi->composite.resume = NULL;
e2459108 2015 gi->composite.max_speed = USB_SPEED_SUPER_PLUS;
88af8bbe 2016
093edc2b 2017 spin_lock_init(&gi->spinlock);
88af8bbe
SAS		 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
7c075538
CN		 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
88af8bbe
SAS		 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)
7c075538 2038 goto out_free_driver_name;
88af8bbe 2039
88af8bbe 2040 return &gi->group;
7c075538
CN		 2041
2042out_free_driver_name:
2043 kfree(gi->composite.gadget_driver.driver.name);
88af8bbe
SAS		 2044err:
2045 kfree(gi);
2046 return ERR_PTR(-ENOMEM);
2047}
2048
2049static void gadgets_drop(struct config_group *group, struct config_item *item)
2050{
2051 config_item_put(item);
2052}
2053
2054static struct configfs_group_operations gadgets_ops = {
2055 .make_group = &gadgets_make,
2056 .drop_item = &gadgets_drop,
2057};
2058
4ad01412 2059static const struct config_item_type gadgets_type = {
88af8bbe
SAS		 2060 .ct_group_ops = &gadgets_ops,
2061 .ct_owner = THIS_MODULE,
2062};
2063
2064static 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
092a4bd0
AP		 2074void unregister_gadget_item(struct config_item *item)
2075{
2076 struct gadget_info *gi = to_gadget_info(item);
2077
cee51c33 2078 mutex_lock(&gi->lock);
092a4bd0 2079 unregister_gadget(gi);
cee51c33 2080 mutex_unlock(&gi->lock);
092a4bd0 2081}
0700faaf 2082EXPORT_SYMBOL_GPL(unregister_gadget_item);
092a4bd0 2083
88af8bbe
SAS		 2084static 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}
2093module_init(gadget_cfs_init);
2094
2095static void __exit gadget_cfs_exit(void)
2096{
2097 configfs_unregister_subsystem(&gadget_subsys);
2098}
2099module_exit(gadget_cfs_exit);
Linux 6.x block layer and io_uring tree(s)