configfs.c

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