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 (page[l - 1] == '\n') {
1069		--l;
1070		++bytes_to_strip;
1071	}
1072
1073	if (l > sizeof(gi->landing_page)) {
1074		pr_err("webusb: landingPage URL too long\n");
1075		return -EINVAL;
1076	}
1077
1078	// validation
1079	if (strncasecmp(page, "https://",  8) == 0)
1080		bytes_to_strip = 8;
1081	else if (strncasecmp(page, "http://", 7) == 0)
1082		bytes_to_strip = 7;
1083	else
1084		bytes_to_strip = 0;
1085
1086	if (l > U8_MAX - WEBUSB_URL_DESCRIPTOR_HEADER_LENGTH + bytes_to_strip) {
1087		pr_err("webusb: landingPage URL %d bytes too long for given URL scheme\n",
1088			l - U8_MAX + WEBUSB_URL_DESCRIPTOR_HEADER_LENGTH - bytes_to_strip);
1089		return -EINVAL;
1090	}
1091
1092	mutex_lock(&gi->lock);
1093	// ensure 0 bytes are set, in case the new landing page is shorter then the old one.
1094	memcpy_and_pad(gi->landing_page, sizeof(gi->landing_page), page, l, 0);
1095	mutex_unlock(&gi->lock);
1096
1097	return len;
1098}
1099
1100CONFIGFS_ATTR(webusb_, use);
1101CONFIGFS_ATTR(webusb_, bVendorCode);
1102CONFIGFS_ATTR(webusb_, bcdVersion);
1103CONFIGFS_ATTR(webusb_, landingPage);
1104
1105static struct configfs_attribute *webusb_attrs[] = {
1106	&webusb_attr_use,
1107	&webusb_attr_bcdVersion,
1108	&webusb_attr_bVendorCode,
1109	&webusb_attr_landingPage,
1110	NULL,
1111};
1112
1113static const struct config_item_type webusb_type = {
1114	.ct_attrs	= webusb_attrs,
1115	.ct_owner	= THIS_MODULE,
1116};
1117
1118static inline struct gadget_info *os_desc_item_to_gadget_info(
1119		struct config_item *item)
1120{
1121	return container_of(to_config_group(item),
1122			struct gadget_info, os_desc_group);
1123}
1124
1125static ssize_t os_desc_use_show(struct config_item *item, char *page)
1126{
1127	return sprintf(page, "%d\n",
1128			os_desc_item_to_gadget_info(item)->use_os_desc);
1129}
1130
1131static ssize_t os_desc_use_store(struct config_item *item, const char *page,
1132				 size_t len)
1133{
1134	struct gadget_info *gi = os_desc_item_to_gadget_info(item);
1135	int ret;
1136	bool use;
1137
1138	ret = kstrtobool(page, &use);
1139	if (ret)
1140		return ret;
1141
1142	mutex_lock(&gi->lock);
1143	gi->use_os_desc = use;
 
 
 
 
1144	mutex_unlock(&gi->lock);
1145
1146	return len;
1147}
1148
1149static ssize_t os_desc_b_vendor_code_show(struct config_item *item, char *page)
1150{
1151	return sprintf(page, "0x%02x\n",
1152			os_desc_item_to_gadget_info(item)->b_vendor_code);
1153}
1154
1155static ssize_t os_desc_b_vendor_code_store(struct config_item *item,
1156					   const char *page, size_t len)
1157{
1158	struct gadget_info *gi = os_desc_item_to_gadget_info(item);
1159	int ret;
1160	u8 b_vendor_code;
1161
1162	ret = kstrtou8(page, 0, &b_vendor_code);
1163	if (ret)
1164		return ret;
1165
1166	mutex_lock(&gi->lock);
1167	gi->b_vendor_code = b_vendor_code;
 
 
 
 
1168	mutex_unlock(&gi->lock);
1169
1170	return len;
1171}
1172
1173static ssize_t os_desc_qw_sign_show(struct config_item *item, char *page)
1174{
1175	struct gadget_info *gi = os_desc_item_to_gadget_info(item);
1176	int res;
1177
1178	res = utf16s_to_utf8s((wchar_t *) gi->qw_sign, OS_STRING_QW_SIGN_LEN,
1179			      UTF16_LITTLE_ENDIAN, page, PAGE_SIZE - 1);
1180	page[res++] = '\n';
1181
1182	return res;
1183}
1184
1185static ssize_t os_desc_qw_sign_store(struct config_item *item, const char *page,
1186				     size_t len)
1187{
1188	struct gadget_info *gi = os_desc_item_to_gadget_info(item);
1189	int res, l;
1190
1191	l = min_t(int, len, OS_STRING_QW_SIGN_LEN >> 1);
1192	if (page[l - 1] == '\n')
1193		--l;
1194
1195	mutex_lock(&gi->lock);
1196	res = utf8s_to_utf16s(page, l,
1197			      UTF16_LITTLE_ENDIAN, (wchar_t *) gi->qw_sign,
1198			      OS_STRING_QW_SIGN_LEN);
1199	if (res > 0)
1200		res = len;
1201	mutex_unlock(&gi->lock);
1202
1203	return res;
1204}
1205
1206CONFIGFS_ATTR(os_desc_, use);
1207CONFIGFS_ATTR(os_desc_, b_vendor_code);
1208CONFIGFS_ATTR(os_desc_, qw_sign);
1209
1210static struct configfs_attribute *os_desc_attrs[] = {
1211	&os_desc_attr_use,
1212	&os_desc_attr_b_vendor_code,
1213	&os_desc_attr_qw_sign,
1214	NULL,
1215};
1216
 
 
 
 
 
 
1217static int os_desc_link(struct config_item *os_desc_ci,
1218			struct config_item *usb_cfg_ci)
1219{
1220	struct gadget_info *gi = os_desc_item_to_gadget_info(os_desc_ci);
 
1221	struct usb_composite_dev *cdev = &gi->cdev;
1222	struct config_usb_cfg *c_target = to_config_usb_cfg(usb_cfg_ci);
1223	struct usb_configuration *c = NULL, *iter;
 
 
1224	int ret;
1225
1226	mutex_lock(&gi->lock);
1227	list_for_each_entry(iter, &cdev->configs, list) {
1228		if (iter != &c_target->c)
1229			continue;
1230		c = iter;
1231		break;
1232	}
1233	if (!c) {
1234		ret = -EINVAL;
1235		goto out;
1236	}
1237
1238	if (cdev->os_desc_config) {
1239		ret = -EBUSY;
1240		goto out;
1241	}
1242
1243	cdev->os_desc_config = &c_target->c;
1244	ret = 0;
1245
1246out:
1247	mutex_unlock(&gi->lock);
1248	return ret;
1249}
1250
1251static void os_desc_unlink(struct config_item *os_desc_ci,
1252			  struct config_item *usb_cfg_ci)
1253{
1254	struct gadget_info *gi = os_desc_item_to_gadget_info(os_desc_ci);
 
1255	struct usb_composite_dev *cdev = &gi->cdev;
1256
1257	mutex_lock(&gi->lock);
1258	if (gi->composite.gadget_driver.udc_name)
1259		unregister_gadget(gi);
1260	cdev->os_desc_config = NULL;
1261	WARN_ON(gi->composite.gadget_driver.udc_name);
1262	mutex_unlock(&gi->lock);
1263}
1264
1265static struct configfs_item_operations os_desc_ops = {
 
1266	.allow_link		= os_desc_link,
1267	.drop_link		= os_desc_unlink,
1268};
1269
1270static const struct config_item_type os_desc_type = {
1271	.ct_item_ops	= &os_desc_ops,
1272	.ct_attrs	= os_desc_attrs,
1273	.ct_owner	= THIS_MODULE,
1274};
1275
1276static inline struct usb_os_desc_ext_prop
1277*to_usb_os_desc_ext_prop(struct config_item *item)
1278{
1279	return container_of(item, struct usb_os_desc_ext_prop, item);
1280}
1281
1282static ssize_t ext_prop_type_show(struct config_item *item, char *page)
1283{
1284	return sprintf(page, "%d\n", to_usb_os_desc_ext_prop(item)->type);
1285}
1286
1287static ssize_t ext_prop_type_store(struct config_item *item,
1288				   const char *page, size_t len)
1289{
1290	struct usb_os_desc_ext_prop *ext_prop = to_usb_os_desc_ext_prop(item);
1291	struct usb_os_desc *desc = to_usb_os_desc(ext_prop->item.ci_parent);
1292	u8 type;
1293	int ret;
1294
1295	ret = kstrtou8(page, 0, &type);
1296	if (ret)
1297		return ret;
1298
1299	if (type < USB_EXT_PROP_UNICODE || type > USB_EXT_PROP_UNICODE_MULTI)
1300		return -EINVAL;
1301
1302	if (desc->opts_mutex)
1303		mutex_lock(desc->opts_mutex);
 
 
 
 
 
 
 
1304
1305	if ((ext_prop->type == USB_EXT_PROP_BINARY ||
1306	    ext_prop->type == USB_EXT_PROP_LE32 ||
1307	    ext_prop->type == USB_EXT_PROP_BE32) &&
1308	    (type == USB_EXT_PROP_UNICODE ||
1309	    type == USB_EXT_PROP_UNICODE_ENV ||
1310	    type == USB_EXT_PROP_UNICODE_LINK))
1311		ext_prop->data_len <<= 1;
1312	else if ((ext_prop->type == USB_EXT_PROP_UNICODE ||
1313		   ext_prop->type == USB_EXT_PROP_UNICODE_ENV ||
1314		   ext_prop->type == USB_EXT_PROP_UNICODE_LINK) &&
1315		   (type == USB_EXT_PROP_BINARY ||
1316		   type == USB_EXT_PROP_LE32 ||
1317		   type == USB_EXT_PROP_BE32))
1318		ext_prop->data_len >>= 1;
1319	ext_prop->type = type;
 
1320
 
1321	if (desc->opts_mutex)
1322		mutex_unlock(desc->opts_mutex);
1323	return len;
1324}
1325
1326static ssize_t ext_prop_data_show(struct config_item *item, char *page)
1327{
1328	struct usb_os_desc_ext_prop *ext_prop = to_usb_os_desc_ext_prop(item);
1329	int len = ext_prop->data_len;
1330
1331	if (ext_prop->type == USB_EXT_PROP_UNICODE ||
1332	    ext_prop->type == USB_EXT_PROP_UNICODE_ENV ||
1333	    ext_prop->type == USB_EXT_PROP_UNICODE_LINK)
1334		len >>= 1;
1335	memcpy(page, ext_prop->data, len);
1336
1337	return len;
1338}
1339
1340static ssize_t ext_prop_data_store(struct config_item *item,
1341				   const char *page, size_t len)
1342{
1343	struct usb_os_desc_ext_prop *ext_prop = to_usb_os_desc_ext_prop(item);
1344	struct usb_os_desc *desc = to_usb_os_desc(ext_prop->item.ci_parent);
1345	char *new_data;
1346	size_t ret_len = len;
1347
1348	if (page[len - 1] == '\n' || page[len - 1] == '\0')
1349		--len;
1350	new_data = kmemdup(page, len, GFP_KERNEL);
1351	if (!new_data)
1352		return -ENOMEM;
1353
1354	if (desc->opts_mutex)
1355		mutex_lock(desc->opts_mutex);
1356	kfree(ext_prop->data);
1357	ext_prop->data = new_data;
1358	desc->ext_prop_len -= ext_prop->data_len;
1359	ext_prop->data_len = len;
1360	desc->ext_prop_len += ext_prop->data_len;
1361	if (ext_prop->type == USB_EXT_PROP_UNICODE ||
1362	    ext_prop->type == USB_EXT_PROP_UNICODE_ENV ||
1363	    ext_prop->type == USB_EXT_PROP_UNICODE_LINK) {
1364		desc->ext_prop_len -= ext_prop->data_len;
1365		ext_prop->data_len <<= 1;
1366		ext_prop->data_len += 2;
1367		desc->ext_prop_len += ext_prop->data_len;
1368	}
1369	if (desc->opts_mutex)
1370		mutex_unlock(desc->opts_mutex);
1371	return ret_len;
1372}
1373
1374CONFIGFS_ATTR(ext_prop_, type);
1375CONFIGFS_ATTR(ext_prop_, data);
1376
1377static struct configfs_attribute *ext_prop_attrs[] = {
1378	&ext_prop_attr_type,
1379	&ext_prop_attr_data,
1380	NULL,
1381};
1382
1383static void usb_os_desc_ext_prop_release(struct config_item *item)
1384{
1385	struct usb_os_desc_ext_prop *ext_prop = to_usb_os_desc_ext_prop(item);
1386
1387	kfree(ext_prop); /* frees a whole chunk */
1388}
1389
1390static struct configfs_item_operations ext_prop_ops = {
1391	.release		= usb_os_desc_ext_prop_release,
1392};
1393
1394static struct config_item *ext_prop_make(
1395		struct config_group *group,
1396		const char *name)
1397{
1398	struct usb_os_desc_ext_prop *ext_prop;
1399	struct config_item_type *ext_prop_type;
1400	struct usb_os_desc *desc;
1401	char *vlabuf;
1402
1403	vla_group(data_chunk);
1404	vla_item(data_chunk, struct usb_os_desc_ext_prop, ext_prop, 1);
1405	vla_item(data_chunk, struct config_item_type, ext_prop_type, 1);
1406
1407	vlabuf = kzalloc(vla_group_size(data_chunk), GFP_KERNEL);
1408	if (!vlabuf)
1409		return ERR_PTR(-ENOMEM);
1410
1411	ext_prop = vla_ptr(vlabuf, data_chunk, ext_prop);
1412	ext_prop_type = vla_ptr(vlabuf, data_chunk, ext_prop_type);
1413
1414	desc = container_of(group, struct usb_os_desc, group);
1415	ext_prop_type->ct_item_ops = &ext_prop_ops;
1416	ext_prop_type->ct_attrs = ext_prop_attrs;
1417	ext_prop_type->ct_owner = desc->owner;
1418
1419	config_item_init_type_name(&ext_prop->item, name, ext_prop_type);
1420
1421	ext_prop->name = kstrdup(name, GFP_KERNEL);
1422	if (!ext_prop->name) {
1423		kfree(vlabuf);
1424		return ERR_PTR(-ENOMEM);
1425	}
1426	desc->ext_prop_len += 14;
1427	ext_prop->name_len = 2 * strlen(ext_prop->name) + 2;
1428	if (desc->opts_mutex)
1429		mutex_lock(desc->opts_mutex);
1430	desc->ext_prop_len += ext_prop->name_len;
1431	list_add_tail(&ext_prop->entry, &desc->ext_prop);
1432	++desc->ext_prop_count;
1433	if (desc->opts_mutex)
1434		mutex_unlock(desc->opts_mutex);
1435
1436	return &ext_prop->item;
1437}
1438
1439static void ext_prop_drop(struct config_group *group, struct config_item *item)
1440{
1441	struct usb_os_desc_ext_prop *ext_prop = to_usb_os_desc_ext_prop(item);
1442	struct usb_os_desc *desc = to_usb_os_desc(&group->cg_item);
1443
1444	if (desc->opts_mutex)
1445		mutex_lock(desc->opts_mutex);
1446	list_del(&ext_prop->entry);
1447	--desc->ext_prop_count;
1448	kfree(ext_prop->name);
1449	desc->ext_prop_len -= (ext_prop->name_len + ext_prop->data_len + 14);
1450	if (desc->opts_mutex)
1451		mutex_unlock(desc->opts_mutex);
1452	config_item_put(item);
1453}
1454
1455static struct configfs_group_operations interf_grp_ops = {
1456	.make_item	= &ext_prop_make,
1457	.drop_item	= &ext_prop_drop,
1458};
1459
1460static ssize_t interf_grp_compatible_id_show(struct config_item *item,
1461					     char *page)
1462{
1463	memcpy(page, to_usb_os_desc(item)->ext_compat_id, 8);
1464	return 8;
1465}
1466
1467static ssize_t interf_grp_compatible_id_store(struct config_item *item,
1468					      const char *page, size_t len)
1469{
1470	struct usb_os_desc *desc = to_usb_os_desc(item);
1471	int l;
1472
1473	l = min_t(int, 8, len);
1474	if (page[l - 1] == '\n')
1475		--l;
1476	if (desc->opts_mutex)
1477		mutex_lock(desc->opts_mutex);
1478	memcpy(desc->ext_compat_id, page, l);
1479
1480	if (desc->opts_mutex)
1481		mutex_unlock(desc->opts_mutex);
1482
1483	return len;
1484}
1485
1486static ssize_t interf_grp_sub_compatible_id_show(struct config_item *item,
1487						 char *page)
1488{
1489	memcpy(page, to_usb_os_desc(item)->ext_compat_id + 8, 8);
1490	return 8;
1491}
1492
1493static ssize_t interf_grp_sub_compatible_id_store(struct config_item *item,
1494						  const char *page, size_t len)
1495{
1496	struct usb_os_desc *desc = to_usb_os_desc(item);
1497	int l;
1498
1499	l = min_t(int, 8, len);
1500	if (page[l - 1] == '\n')
1501		--l;
1502	if (desc->opts_mutex)
1503		mutex_lock(desc->opts_mutex);
1504	memcpy(desc->ext_compat_id + 8, page, l);
1505
1506	if (desc->opts_mutex)
1507		mutex_unlock(desc->opts_mutex);
1508
1509	return len;
1510}
1511
1512CONFIGFS_ATTR(interf_grp_, compatible_id);
1513CONFIGFS_ATTR(interf_grp_, sub_compatible_id);
1514
1515static struct configfs_attribute *interf_grp_attrs[] = {
1516	&interf_grp_attr_compatible_id,
1517	&interf_grp_attr_sub_compatible_id,
1518	NULL
1519};
1520
1521struct config_group *usb_os_desc_prepare_interf_dir(
1522		struct config_group *parent,
1523		int n_interf,
1524		struct usb_os_desc **desc,
1525		char **names,
1526		struct module *owner)
1527{
1528	struct config_group *os_desc_group;
1529	struct config_item_type *os_desc_type, *interface_type;
1530
1531	vla_group(data_chunk);
1532	vla_item(data_chunk, struct config_group, os_desc_group, 1);
1533	vla_item(data_chunk, struct config_item_type, os_desc_type, 1);
1534	vla_item(data_chunk, struct config_item_type, interface_type, 1);
1535
1536	char *vlabuf = kzalloc(vla_group_size(data_chunk), GFP_KERNEL);
1537	if (!vlabuf)
1538		return ERR_PTR(-ENOMEM);
1539
1540	os_desc_group = vla_ptr(vlabuf, data_chunk, os_desc_group);
1541	os_desc_type = vla_ptr(vlabuf, data_chunk, os_desc_type);
1542	interface_type = vla_ptr(vlabuf, data_chunk, interface_type);
1543
1544	os_desc_type->ct_owner = owner;
1545	config_group_init_type_name(os_desc_group, "os_desc", os_desc_type);
1546	configfs_add_default_group(os_desc_group, parent);
1547
1548	interface_type->ct_group_ops = &interf_grp_ops;
1549	interface_type->ct_attrs = interf_grp_attrs;
1550	interface_type->ct_owner = owner;
1551
1552	while (n_interf--) {
1553		struct usb_os_desc *d;
1554
1555		d = desc[n_interf];
1556		d->owner = owner;
1557		config_group_init_type_name(&d->group, "", interface_type);
1558		config_item_set_name(&d->group.cg_item, "interface.%s",
1559				     names[n_interf]);
1560		configfs_add_default_group(&d->group, os_desc_group);
1561	}
1562
1563	return os_desc_group;
1564}
1565EXPORT_SYMBOL(usb_os_desc_prepare_interf_dir);
1566
1567static int configfs_do_nothing(struct usb_composite_dev *cdev)
1568{
1569	WARN_ON(1);
1570	return -EINVAL;
1571}
1572
1573int composite_dev_prepare(struct usb_composite_driver *composite,
1574		struct usb_composite_dev *dev);
1575
1576int composite_os_desc_req_prepare(struct usb_composite_dev *cdev,
1577				  struct usb_ep *ep0);
1578
1579static void purge_configs_funcs(struct gadget_info *gi)
1580{
1581	struct usb_configuration	*c;
1582
1583	list_for_each_entry(c, &gi->cdev.configs, list) {
1584		struct usb_function *f, *tmp;
1585		struct config_usb_cfg *cfg;
1586
1587		cfg = container_of(c, struct config_usb_cfg, c);
1588
1589		list_for_each_entry_safe_reverse(f, tmp, &c->functions, list) {
1590
1591			list_move(&f->list, &cfg->func_list);
1592			if (f->unbind) {
1593				dev_dbg(&gi->cdev.gadget->dev,
1594					"unbind function '%s'/%p\n",
1595					f->name, f);
1596				f->unbind(c, f);
1597			}
1598		}
1599		c->next_interface_id = 0;
1600		memset(c->interface, 0, sizeof(c->interface));
1601		c->superspeed_plus = 0;
1602		c->superspeed = 0;
1603		c->highspeed = 0;
1604		c->fullspeed = 0;
1605	}
1606}
1607
1608static struct usb_string *
1609configfs_attach_gadget_strings(struct gadget_info *gi)
1610{
1611	struct usb_gadget_strings **gadget_strings;
1612	struct gadget_language *language;
1613	struct gadget_string *string;
1614	unsigned int nlangs = 0;
1615	struct list_head *iter;
1616	struct usb_string *us;
1617	unsigned int i = 0;
1618	int nstrings = -1;
1619	unsigned int j;
1620
1621	list_for_each(iter, &gi->string_list)
1622		nlangs++;
1623
1624	/* Bail out early if no languages are configured */
1625	if (!nlangs)
1626		return NULL;
1627
1628	gadget_strings = kcalloc(nlangs + 1, /* including NULL terminator */
1629				 sizeof(struct usb_gadget_strings *), GFP_KERNEL);
1630	if (!gadget_strings)
1631		return ERR_PTR(-ENOMEM);
1632
1633	list_for_each_entry(language, &gi->string_list, list) {
1634		struct usb_string *stringtab;
1635
1636		if (nstrings == -1) {
1637			nstrings = language->nstrings;
1638		} else if (nstrings != language->nstrings) {
1639			pr_err("languages must contain the same number of strings\n");
1640			us = ERR_PTR(-EINVAL);
1641			goto cleanup;
1642		}
1643
1644		stringtab = kcalloc(language->nstrings + 1, sizeof(struct usb_string),
1645				    GFP_KERNEL);
1646		if (!stringtab) {
1647			us = ERR_PTR(-ENOMEM);
1648			goto cleanup;
1649		}
1650
1651		stringtab[USB_GADGET_MANUFACTURER_IDX].id = USB_GADGET_MANUFACTURER_IDX;
1652		stringtab[USB_GADGET_MANUFACTURER_IDX].s = language->manufacturer;
1653		stringtab[USB_GADGET_PRODUCT_IDX].id = USB_GADGET_PRODUCT_IDX;
1654		stringtab[USB_GADGET_PRODUCT_IDX].s = language->product;
1655		stringtab[USB_GADGET_SERIAL_IDX].id = USB_GADGET_SERIAL_IDX;
1656		stringtab[USB_GADGET_SERIAL_IDX].s = language->serialnumber;
1657
1658		j = USB_GADGET_FIRST_AVAIL_IDX;
1659		list_for_each_entry(string, &language->gadget_strings, list) {
1660			memcpy(&stringtab[j], &string->usb_string, sizeof(struct usb_string));
1661			j++;
1662		}
1663
1664		language->stringtab_dev.strings = stringtab;
1665		gadget_strings[i] = &language->stringtab_dev;
1666		i++;
1667	}
1668
1669	us = usb_gstrings_attach(&gi->cdev, gadget_strings, nstrings);
1670
1671cleanup:
1672	list_for_each_entry(language, &gi->string_list, list) {
1673		kfree(language->stringtab_dev.strings);
1674		language->stringtab_dev.strings = NULL;
1675	}
1676
1677	kfree(gadget_strings);
1678
1679	return us;
1680}
1681
1682static int configfs_composite_bind(struct usb_gadget *gadget,
1683		struct usb_gadget_driver *gdriver)
1684{
1685	struct usb_composite_driver     *composite = to_cdriver(gdriver);
1686	struct gadget_info		*gi = container_of(composite,
1687						struct gadget_info, composite);
1688	struct usb_composite_dev	*cdev = &gi->cdev;
1689	struct usb_configuration	*c;
1690	struct usb_string		*s;
1691	unsigned			i;
1692	int				ret;
1693
1694	/* the gi->lock is hold by the caller */
1695	gi->unbind = 0;
1696	cdev->gadget = gadget;
1697	set_gadget_data(gadget, cdev);
1698	ret = composite_dev_prepare(composite, cdev);
1699	if (ret)
1700		return ret;
1701	/* and now the gadget bind */
1702	ret = -EINVAL;
1703
1704	if (list_empty(&gi->cdev.configs)) {
1705		pr_err("Need at least one configuration in %s.\n",
1706				gi->composite.name);
1707		goto err_comp_cleanup;
1708	}
1709
1710
1711	list_for_each_entry(c, &gi->cdev.configs, list) {
1712		struct config_usb_cfg *cfg;
1713
1714		cfg = container_of(c, struct config_usb_cfg, c);
1715		if (list_empty(&cfg->func_list)) {
1716			pr_err("Config %s/%d of %s needs at least one function.\n",
1717			      c->label, c->bConfigurationValue,
1718			      gi->composite.name);
1719			goto err_comp_cleanup;
1720		}
1721	}
1722
1723	/* init all strings */
1724	if (!list_empty(&gi->string_list)) {
1725		s = configfs_attach_gadget_strings(gi);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1726		if (IS_ERR(s)) {
1727			ret = PTR_ERR(s);
1728			goto err_comp_cleanup;
1729		}
1730
1731		gi->cdev.desc.iManufacturer = s[USB_GADGET_MANUFACTURER_IDX].id;
1732		gi->cdev.desc.iProduct = s[USB_GADGET_PRODUCT_IDX].id;
1733		gi->cdev.desc.iSerialNumber = s[USB_GADGET_SERIAL_IDX].id;
1734
1735		gi->cdev.usb_strings = s;
1736	}
1737
1738	if (gi->use_webusb) {
1739		cdev->use_webusb = true;
1740		cdev->bcd_webusb_version = gi->bcd_webusb_version;
1741		cdev->b_webusb_vendor_code = gi->b_webusb_vendor_code;
1742		memcpy(cdev->landing_page, gi->landing_page, WEBUSB_URL_RAW_MAX_LENGTH);
1743	}
1744
1745	if (gi->use_os_desc) {
1746		cdev->use_os_string = true;
1747		cdev->b_vendor_code = gi->b_vendor_code;
1748		memcpy(cdev->qw_sign, gi->qw_sign, OS_STRING_QW_SIGN_LEN);
1749	}
1750
1751	if (gadget_is_otg(gadget) && !otg_desc[0]) {
1752		struct usb_descriptor_header *usb_desc;
1753
1754		usb_desc = usb_otg_descriptor_alloc(gadget);
1755		if (!usb_desc) {
1756			ret = -ENOMEM;
1757			goto err_comp_cleanup;
1758		}
1759		usb_otg_descriptor_init(gadget, usb_desc);
1760		otg_desc[0] = usb_desc;
1761		otg_desc[1] = NULL;
1762	}
1763
1764	/* Go through all configs, attach all functions */
1765	list_for_each_entry(c, &gi->cdev.configs, list) {
1766		struct config_usb_cfg *cfg;
1767		struct usb_function *f;
1768		struct usb_function *tmp;
1769		struct gadget_config_name *cn;
1770
1771		if (gadget_is_otg(gadget))
1772			c->descriptors = otg_desc;
1773
1774		/* Properly configure the bmAttributes wakeup bit */
1775		check_remote_wakeup_config(gadget, c);
1776
1777		cfg = container_of(c, struct config_usb_cfg, c);
1778		if (!list_empty(&cfg->string_list)) {
1779			i = 0;
1780			list_for_each_entry(cn, &cfg->string_list, list) {
1781				cfg->gstrings[i] = &cn->stringtab_dev;
1782				cn->stringtab_dev.strings = &cn->strings;
1783				cn->strings.s = cn->configuration;
1784				i++;
1785			}
1786			cfg->gstrings[i] = NULL;
1787			s = usb_gstrings_attach(&gi->cdev, cfg->gstrings, 1);
1788			if (IS_ERR(s)) {
1789				ret = PTR_ERR(s);
1790				goto err_comp_cleanup;
1791			}
1792			c->iConfiguration = s[0].id;
1793		}
1794
1795		list_for_each_entry_safe(f, tmp, &cfg->func_list, list) {
1796			list_del(&f->list);
1797			ret = usb_add_function(c, f);
1798			if (ret) {
1799				list_add(&f->list, &cfg->func_list);
1800				goto err_purge_funcs;
1801			}
1802		}
1803		ret = usb_gadget_check_config(cdev->gadget);
1804		if (ret)
1805			goto err_purge_funcs;
1806
1807		usb_ep_autoconfig_reset(cdev->gadget);
1808	}
1809	if (cdev->use_os_string) {
1810		ret = composite_os_desc_req_prepare(cdev, gadget->ep0);
1811		if (ret)
1812			goto err_purge_funcs;
1813	}
1814
1815	usb_ep_autoconfig_reset(cdev->gadget);
1816	return 0;
1817
1818err_purge_funcs:
1819	purge_configs_funcs(gi);
1820err_comp_cleanup:
1821	composite_dev_cleanup(cdev);
1822	return ret;
1823}
1824
1825static void configfs_composite_unbind(struct usb_gadget *gadget)
1826{
1827	struct usb_composite_dev	*cdev;
1828	struct gadget_info		*gi;
1829	unsigned long flags;
1830
1831	/* the gi->lock is hold by the caller */
1832
1833	cdev = get_gadget_data(gadget);
1834	gi = container_of(cdev, struct gadget_info, cdev);
1835	spin_lock_irqsave(&gi->spinlock, flags);
1836	gi->unbind = 1;
1837	spin_unlock_irqrestore(&gi->spinlock, flags);
1838
1839	kfree(otg_desc[0]);
1840	otg_desc[0] = NULL;
1841	purge_configs_funcs(gi);
1842	composite_dev_cleanup(cdev);
1843	usb_ep_autoconfig_reset(cdev->gadget);
1844	spin_lock_irqsave(&gi->spinlock, flags);
1845	cdev->gadget = NULL;
1846	cdev->deactivations = 0;
1847	gadget->deactivated = false;
1848	set_gadget_data(gadget, NULL);
1849	spin_unlock_irqrestore(&gi->spinlock, flags);
1850}
1851
1852static int configfs_composite_setup(struct usb_gadget *gadget,
1853		const struct usb_ctrlrequest *ctrl)
1854{
1855	struct usb_composite_dev *cdev;
1856	struct gadget_info *gi;
1857	unsigned long flags;
1858	int ret;
1859
1860	cdev = get_gadget_data(gadget);
1861	if (!cdev)
1862		return 0;
1863
1864	gi = container_of(cdev, struct gadget_info, cdev);
1865	spin_lock_irqsave(&gi->spinlock, flags);
1866	cdev = get_gadget_data(gadget);
1867	if (!cdev || gi->unbind) {
1868		spin_unlock_irqrestore(&gi->spinlock, flags);
1869		return 0;
1870	}
1871
1872	ret = composite_setup(gadget, ctrl);
1873	spin_unlock_irqrestore(&gi->spinlock, flags);
1874	return ret;
1875}
1876
1877static void configfs_composite_disconnect(struct usb_gadget *gadget)
1878{
1879	struct usb_composite_dev *cdev;
1880	struct gadget_info *gi;
1881	unsigned long flags;
1882
1883	cdev = get_gadget_data(gadget);
1884	if (!cdev)
1885		return;
1886
1887	gi = container_of(cdev, struct gadget_info, cdev);
1888	spin_lock_irqsave(&gi->spinlock, flags);
1889	cdev = get_gadget_data(gadget);
1890	if (!cdev || gi->unbind) {
1891		spin_unlock_irqrestore(&gi->spinlock, flags);
1892		return;
1893	}
1894
1895	composite_disconnect(gadget);
1896	spin_unlock_irqrestore(&gi->spinlock, flags);
1897}
1898
1899static void configfs_composite_reset(struct usb_gadget *gadget)
1900{
1901	struct usb_composite_dev *cdev;
1902	struct gadget_info *gi;
1903	unsigned long flags;
1904
1905	cdev = get_gadget_data(gadget);
1906	if (!cdev)
1907		return;
1908
1909	gi = container_of(cdev, struct gadget_info, cdev);
1910	spin_lock_irqsave(&gi->spinlock, flags);
1911	cdev = get_gadget_data(gadget);
1912	if (!cdev || gi->unbind) {
1913		spin_unlock_irqrestore(&gi->spinlock, flags);
1914		return;
1915	}
1916
1917	composite_reset(gadget);
1918	spin_unlock_irqrestore(&gi->spinlock, flags);
1919}
1920
1921static void configfs_composite_suspend(struct usb_gadget *gadget)
1922{
1923	struct usb_composite_dev *cdev;
1924	struct gadget_info *gi;
1925	unsigned long flags;
1926
1927	cdev = get_gadget_data(gadget);
1928	if (!cdev)
1929		return;
1930
1931	gi = container_of(cdev, struct gadget_info, cdev);
1932	spin_lock_irqsave(&gi->spinlock, flags);
1933	cdev = get_gadget_data(gadget);
1934	if (!cdev || gi->unbind) {
1935		spin_unlock_irqrestore(&gi->spinlock, flags);
1936		return;
1937	}
1938
1939	composite_suspend(gadget);
1940	spin_unlock_irqrestore(&gi->spinlock, flags);
1941}
1942
1943static void configfs_composite_resume(struct usb_gadget *gadget)
1944{
1945	struct usb_composite_dev *cdev;
1946	struct gadget_info *gi;
1947	unsigned long flags;
1948
1949	cdev = get_gadget_data(gadget);
1950	if (!cdev)
1951		return;
1952
1953	gi = container_of(cdev, struct gadget_info, cdev);
1954	spin_lock_irqsave(&gi->spinlock, flags);
1955	cdev = get_gadget_data(gadget);
1956	if (!cdev || gi->unbind) {
1957		spin_unlock_irqrestore(&gi->spinlock, flags);
1958		return;
1959	}
1960
1961	composite_resume(gadget);
1962	spin_unlock_irqrestore(&gi->spinlock, flags);
1963}
1964
1965static const struct usb_gadget_driver configfs_driver_template = {
1966	.bind           = configfs_composite_bind,
1967	.unbind         = configfs_composite_unbind,
1968
1969	.setup          = configfs_composite_setup,
1970	.reset          = configfs_composite_reset,
1971	.disconnect     = configfs_composite_disconnect,
1972
1973	.suspend	= configfs_composite_suspend,
1974	.resume		= configfs_composite_resume,
1975
1976	.max_speed	= USB_SPEED_SUPER_PLUS,
1977	.driver = {
1978		.owner          = THIS_MODULE,
 
1979	},
1980	.match_existing_only = 1,
1981};
1982
1983static struct config_group *gadgets_make(
1984		struct config_group *group,
1985		const char *name)
1986{
1987	struct gadget_info *gi;
1988
1989	gi = kzalloc(sizeof(*gi), GFP_KERNEL);
1990	if (!gi)
1991		return ERR_PTR(-ENOMEM);
1992
1993	config_group_init_type_name(&gi->group, name, &gadget_root_type);
1994
1995	config_group_init_type_name(&gi->functions_group, "functions",
1996			&functions_type);
1997	configfs_add_default_group(&gi->functions_group, &gi->group);
1998
1999	config_group_init_type_name(&gi->configs_group, "configs",
2000			&config_desc_type);
2001	configfs_add_default_group(&gi->configs_group, &gi->group);
2002
2003	config_group_init_type_name(&gi->strings_group, "strings",
2004			&gadget_language_strings_type);
2005	configfs_add_default_group(&gi->strings_group, &gi->group);
2006
2007	config_group_init_type_name(&gi->os_desc_group, "os_desc",
2008			&os_desc_type);
2009	configfs_add_default_group(&gi->os_desc_group, &gi->group);
2010
2011	config_group_init_type_name(&gi->webusb_group, "webusb",
2012			&webusb_type);
2013	configfs_add_default_group(&gi->webusb_group, &gi->group);
2014
2015	gi->composite.bind = configfs_do_nothing;
2016	gi->composite.unbind = configfs_do_nothing;
2017	gi->composite.suspend = NULL;
2018	gi->composite.resume = NULL;
2019	gi->composite.max_speed = USB_SPEED_SUPER_PLUS;
2020
2021	spin_lock_init(&gi->spinlock);
2022	mutex_init(&gi->lock);
2023	INIT_LIST_HEAD(&gi->string_list);
2024	INIT_LIST_HEAD(&gi->available_func);
2025
2026	composite_init_dev(&gi->cdev);
2027	gi->cdev.desc.bLength = USB_DT_DEVICE_SIZE;
2028	gi->cdev.desc.bDescriptorType = USB_DT_DEVICE;
2029	gi->cdev.desc.bcdDevice = cpu_to_le16(get_default_bcdDevice());
2030
2031	gi->composite.gadget_driver = configfs_driver_template;
2032
2033	gi->composite.gadget_driver.driver.name = kasprintf(GFP_KERNEL,
2034							    "configfs-gadget.%s", name);
2035	if (!gi->composite.gadget_driver.driver.name)
2036		goto err;
2037
2038	gi->composite.gadget_driver.function = kstrdup(name, GFP_KERNEL);
2039	gi->composite.name = gi->composite.gadget_driver.function;
2040
2041	if (!gi->composite.gadget_driver.function)
2042		goto out_free_driver_name;
2043
2044	return &gi->group;
2045
2046out_free_driver_name:
2047	kfree(gi->composite.gadget_driver.driver.name);
2048err:
2049	kfree(gi);
2050	return ERR_PTR(-ENOMEM);
2051}
2052
2053static void gadgets_drop(struct config_group *group, struct config_item *item)
2054{
2055	config_item_put(item);
2056}
2057
2058static struct configfs_group_operations gadgets_ops = {
2059	.make_group     = &gadgets_make,
2060	.drop_item      = &gadgets_drop,
2061};
2062
2063static const struct config_item_type gadgets_type = {
2064	.ct_group_ops   = &gadgets_ops,
2065	.ct_owner       = THIS_MODULE,
2066};
2067
2068static struct configfs_subsystem gadget_subsys = {
2069	.su_group = {
2070		.cg_item = {
2071			.ci_namebuf = "usb_gadget",
2072			.ci_type = &gadgets_type,
2073		},
2074	},
2075	.su_mutex = __MUTEX_INITIALIZER(gadget_subsys.su_mutex),
2076};
2077
2078void unregister_gadget_item(struct config_item *item)
2079{
2080	struct gadget_info *gi = to_gadget_info(item);
2081
2082	mutex_lock(&gi->lock);
2083	unregister_gadget(gi);
2084	mutex_unlock(&gi->lock);
2085}
2086EXPORT_SYMBOL_GPL(unregister_gadget_item);
2087
2088static int __init gadget_cfs_init(void)
2089{
2090	int ret;
2091
2092	config_group_init(&gadget_subsys.su_group);
2093
2094	ret = configfs_register_subsystem(&gadget_subsys);
2095	return ret;
2096}
2097module_init(gadget_cfs_init);
2098
2099static void __exit gadget_cfs_exit(void)
2100{
2101	configfs_unregister_subsystem(&gadget_subsys);
2102}
2103module_exit(gadget_cfs_exit);