Release 4.7 drivers/usb/gadget/configfs.c

Directory: drivers/usb/gadget
#include <linux/configfs.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/device.h>
#include <linux/nls.h>
#include <linux/usb/composite.h>
#include <linux/usb/gadget_configfs.h>
#include "configfs.h"
#include "u_f.h"
#include "u_os_desc.h"



int check_user_usb_string(const char *name,
		struct usb_gadget_strings *stringtab_dev)
{
	unsigned primary_lang;
	unsigned sub_lang;
	u16 num;
	int ret;

	ret = kstrtou16(name, 0, &num);
	if (ret)
		return ret;

	primary_lang = num & 0x3ff;
	sub_lang = num >> 10;

	/* simple sanity check for valid langid */
	switch (primary_lang) {
	case 0:
	case 0x62 ... 0xfe:
	case 0x100 ... 0x3ff:
		return -EINVAL;
	}
	if (!sub_lang)
		return -EINVAL;

	stringtab_dev->language = num;
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
sebastian andrzej siewior sebastian andrzej siewior 100 100.00% 1 100.00%
Total 100 100.00% 1 100.00%


#define MAX_NAME_LEN	40

#define MAX_USB_STRING_LANGS 2


static const struct usb_descriptor_header *otg_desc[2];


struct gadget_info {
	
struct config_group group;
	
struct config_group functions_group;
	
struct config_group configs_group;
	
struct config_group strings_group;
	
struct config_group os_desc_group;

	
struct mutex lock;
	
struct usb_gadget_strings *gstrings[MAX_USB_STRING_LANGS + 1];
	
struct list_head string_list;
	
struct list_head available_func;

	
struct usb_composite_driver composite;
	
struct usb_composite_dev cdev;
	
bool use_os_desc;
	
char b_vendor_code;
	
char qw_sign[OS_STRING_QW_SIGN_LEN];
};



static inline struct gadget_info *to_gadget_info(struct config_item *item)
{
	 return container_of(to_config_group(item), struct gadget_info, group);
}

Contributors
Person Tokens Prop Commits CommitProp
christoph hellwig christoph hellwig 28 100.00% 1 100.00%
Total 28 100.00% 1 100.00%


struct config_usb_cfg {
	
struct config_group group;
	
struct config_group strings_group;
	
struct list_head string_list;
	
struct usb_configuration c;
	
struct list_head func_list;
	
struct usb_gadget_strings *gstrings[MAX_USB_STRING_LANGS + 1];
};



static inline struct config_usb_cfg *to_config_usb_cfg(struct config_item *item)
{
	return container_of(to_config_group(item), struct config_usb_cfg,
			group);
}

Contributors
Person Tokens Prop Commits CommitProp
christoph hellwig christoph hellwig 28 100.00% 1 100.00%
Total 28 100.00% 1 100.00%


struct gadget_strings {
	
struct usb_gadget_strings stringtab_dev;
	
struct usb_string strings[USB_GADGET_FIRST_AVAIL_IDX];
	
char *manufacturer;
	
char *product;
	
char *serialnumber;

	
struct config_group group;
	
struct list_head list;
};


struct os_desc {
	
struct config_group group;
};


struct gadget_config_name {
	
struct usb_gadget_strings stringtab_dev;
	
struct usb_string strings;
	
char *configuration;

	
struct config_group group;
	
struct list_head list;
};



static int usb_string_copy(const char *s, char **s_copy)
{
	int ret;
	char *str;
	char *copy = *s_copy;
	ret = strlen(s);
	if (ret > 126)
		return -EOVERFLOW;

	str = kstrdup(s, GFP_KERNEL);
	if (!str)
		return -ENOMEM;
	if (str[ret - 1] == '\n')
		str[ret - 1] = '\0';
	kfree(copy);
	*s_copy = str;
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
sebastian andrzej siewior sebastian andrzej siewior 98 100.00% 1 100.00%
Total 98 100.00% 1 100.00%


#define GI_DEVICE_DESC_SIMPLE_R_u8(__name)	\
static ssize_t gadget_dev_desc_##__name##_show(struct config_item *item, \
                        char *page)     \
{       \
        return sprintf(page, "0x%02x\n", \
                to_gadget_info(item)->cdev.desc.__name); \
}


#define GI_DEVICE_DESC_SIMPLE_R_u16(__name)	\
static ssize_t gadget_dev_desc_##__name##_show(struct config_item *item, \
                        char *page)     \
{       \
        return sprintf(page, "0x%04x\n", \
                le16_to_cpup(&to_gadget_info(item)->cdev.desc.__name)); \
}



#define GI_DEVICE_DESC_SIMPLE_W_u8(_name)		\
static ssize_t gadget_dev_desc_##_name##_store(struct config_item *item, \
                const char *page, size_t len)           \
{                                                       \
        u8 val;                                         \
        int ret;                                        \
        ret = kstrtou8(page, 0, &val);                  \
        if (ret)                                        \
                return ret;                             \
        to_gadget_info(item)->cdev.desc._name = val;    \
        return len;                                     \
}


#define GI_DEVICE_DESC_SIMPLE_W_u16(_name)	\
static ssize_t gadget_dev_desc_##_name##_store(struct config_item *item, \
                const char *page, size_t len)           \
{                                                       \
        u16 val;                                        \
        int ret;                                        \
        ret = kstrtou16(page, 0, &val);                 \
        if (ret)                                        \
                return ret;                             \
        to_gadget_info(item)->cdev.desc._name = cpu_to_le16p(&val);     \
        return len;                                     \
}


#define GI_DEVICE_DESC_SIMPLE_RW(_name, _type)	\
	GI_DEVICE_DESC_SIMPLE_R_##_type(_name)  \
        GI_DEVICE_DESC_SIMPLE_W_##_type(_name)


GI_DEVICE_DESC_SIMPLE_R_u16(bcdUSB);
GI_DEVICE_DESC_SIMPLE_RW(bDeviceClass, u8);
GI_DEVICE_DESC_SIMPLE_RW(bDeviceSubClass, u8);
GI_DEVICE_DESC_SIMPLE_RW(bDeviceProtocol, u8);
GI_DEVICE_DESC_SIMPLE_RW(bMaxPacketSize0, u8);
GI_DEVICE_DESC_SIMPLE_RW(idVendor, u16);
GI_DEVICE_DESC_SIMPLE_RW(idProduct, u16);

GI_DEVICE_DESC_SIMPLE_R_u16(bcdDevice);



static ssize_t is_valid_bcd(u16 bcd_val)
{
	if ((bcd_val & 0xf) > 9)
		return -EINVAL;
	if (((bcd_val >> 4) & 0xf) > 9)
		return -EINVAL;
	if (((bcd_val >> 8) & 0xf) > 9)
		return -EINVAL;
	if (((bcd_val >> 12) & 0xf) > 9)
		return -EINVAL;
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
sebastian andrzej siewior sebastian andrzej siewior 80 100.00% 1 100.00%
Total 80 100.00% 1 100.00%



static ssize_t gadget_dev_desc_bcdDevice_store(struct config_item *item,
		const char *page, size_t len)
{
	u16 bcdDevice;
	int ret;

	ret = kstrtou16(page, 0, &bcdDevice);
	if (ret)
		return ret;
	ret = is_valid_bcd(bcdDevice);
	if (ret)
		return ret;

	to_gadget_info(item)->cdev.desc.bcdDevice = cpu_to_le16(bcdDevice);
	return len;
}

Contributors
Person Tokens Prop Commits CommitProp
sebastian andrzej siewior sebastian andrzej siewior 71 92.21% 1 50.00%
christoph hellwig christoph hellwig 6 7.79% 1 50.00%
Total 77 100.00% 2 100.00%



static ssize_t gadget_dev_desc_bcdUSB_store(struct config_item *item,
		const char *page, size_t len)
{
	u16 bcdUSB;
	int ret;

	ret = kstrtou16(page, 0, &bcdUSB);
	if (ret)
		return ret;
	ret = is_valid_bcd(bcdUSB);
	if (ret)
		return ret;

	to_gadget_info(item)->cdev.desc.bcdUSB = cpu_to_le16(bcdUSB);
	return len;
}

Contributors
Person Tokens Prop Commits CommitProp
sebastian andrzej siewior sebastian andrzej siewior 71 92.21% 1 50.00%
christoph hellwig christoph hellwig 6 7.79% 1 50.00%
Total 77 100.00% 2 100.00%



static ssize_t gadget_dev_desc_UDC_show(struct config_item *item, char *page)
{
	char *udc_name = to_gadget_info(item)->composite.gadget_driver.udc_name;

	return sprintf(page, "%s\n", udc_name ?: "");
}

Contributors
Person Tokens Prop Commits CommitProp
sebastian andrzej siewior sebastian andrzej siewior 26 60.47% 1 33.33%
ruslan bilovol ruslan bilovol 15 34.88% 1 33.33%
christoph hellwig christoph hellwig 2 4.65% 1 33.33%
Total 43 100.00% 3 100.00%



static int unregister_gadget(struct gadget_info *gi)
{
	int ret;

	if (!gi->composite.gadget_driver.udc_name)
		return -ENODEV;

	ret = usb_gadget_unregister_driver(&gi->composite.gadget_driver);
	if (ret)
		return ret;
	kfree(gi->composite.gadget_driver.udc_name);
	gi->composite.gadget_driver.udc_name = NULL;
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
sebastian andrzej siewior sebastian andrzej siewior 60 83.33% 1 50.00%
ruslan bilovol ruslan bilovol 12 16.67% 1 50.00%
Total 72 100.00% 2 100.00%



static ssize_t gadget_dev_desc_UDC_store(struct config_item *item,
		const char *page, size_t len)
{
	struct gadget_info *gi = to_gadget_info(item);
	char *name;
	int ret;

	name = kstrdup(page, GFP_KERNEL);
	if (!name)
		return -ENOMEM;
	if (name[len - 1] == '\n')
		name[len - 1] = '\0';

	mutex_lock(&gi->lock);

	if (!strlen(name)) {
		ret = unregister_gadget(gi);
		if (ret)
			goto err;
	} else {
		if (gi->composite.gadget_driver.udc_name) {
			ret = -EBUSY;
			goto err;
		}
		gi->composite.gadget_driver.udc_name = name;
		ret = usb_gadget_probe_driver(&gi->composite.gadget_driver);
		if (ret) {
			gi->composite.gadget_driver.udc_name = NULL;
			goto err;
		}
	}
	mutex_unlock(&gi->lock);
	return len;
err:
	kfree(name);
	mutex_unlock(&gi->lock);
	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
sebastian andrzej siewior sebastian andrzej siewior 162 81.41% 1 33.33%
ruslan bilovol ruslan bilovol 25 12.56% 1 33.33%
christoph hellwig christoph hellwig 12 6.03% 1 33.33%
Total 199 100.00% 3 100.00%

CONFIGFS_ATTR(gadget_dev_desc_, bDeviceClass);
CONFIGFS_ATTR(gadget_dev_desc_, bDeviceSubClass);
CONFIGFS_ATTR(gadget_dev_desc_, bDeviceProtocol);
CONFIGFS_ATTR(gadget_dev_desc_, bMaxPacketSize0);
CONFIGFS_ATTR(gadget_dev_desc_, idVendor);
CONFIGFS_ATTR(gadget_dev_desc_, idProduct);
CONFIGFS_ATTR(gadget_dev_desc_, bcdDevice);
CONFIGFS_ATTR(gadget_dev_desc_, bcdUSB);
CONFIGFS_ATTR(gadget_dev_desc_, UDC);


static struct configfs_attribute *gadget_root_attrs[] = {
	&gadget_dev_desc_attr_bDeviceClass,
	&gadget_dev_desc_attr_bDeviceSubClass,
	&gadget_dev_desc_attr_bDeviceProtocol,
	&gadget_dev_desc_attr_bMaxPacketSize0,
	&gadget_dev_desc_attr_idVendor,
	&gadget_dev_desc_attr_idProduct,
	&gadget_dev_desc_attr_bcdDevice,
	&gadget_dev_desc_attr_bcdUSB,
	&gadget_dev_desc_attr_UDC,
	NULL,
};



static inline struct gadget_strings *to_gadget_strings(struct config_item *item)
{
	 return container_of(to_config_group(item), struct gadget_strings,
			 group);
}

Contributors
Person Tokens Prop Commits CommitProp
sebastian andrzej siewior sebastian andrzej siewior 28 100.00% 1 100.00%
Total 28 100.00% 1 100.00%



static inline struct gadget_config_name *to_gadget_config_name(
		struct config_item *item)
{
	 return container_of(to_config_group(item), struct gadget_config_name,
			 group);
}

Contributors
Person Tokens Prop Commits CommitProp
sebastian andrzej siewior sebastian andrzej siewior 28 100.00% 1 100.00%
Total 28 100.00% 1 100.00%



static inline struct usb_function_instance *to_usb_function_instance(
		struct config_item *item)
{
	 return container_of(to_config_group(item),
			 struct usb_function_instance, group);
}

Contributors
Person Tokens Prop Commits CommitProp
sebastian andrzej siewior sebastian andrzej siewior 28 100.00% 1 100.00%
Total 28 100.00% 1 100.00%



static void gadget_info_attr_release(struct config_item *item)
{
	struct gadget_info *gi = to_gadget_info(item);

	WARN_ON(!list_empty(&gi->cdev.configs));
	WARN_ON(!list_empty(&gi->string_list));
	WARN_ON(!list_empty(&gi->available_func));
	kfree(gi->composite.gadget_driver.function);
	kfree(gi);
}

Contributors
Person Tokens Prop Commits CommitProp
sebastian andrzej siewior sebastian andrzej siewior 75 100.00% 1 100.00%
Total 75 100.00% 1 100.00%


static struct configfs_item_operations gadget_root_item_ops = {
	.release                = gadget_info_attr_release,
};



static void gadget_config_attr_release(struct config_item *item)
{
	struct config_usb_cfg *cfg = to_config_usb_cfg(item);

	WARN_ON(!list_empty(&cfg->c.functions));
	list_del(&cfg->c.list);
	kfree(cfg->c.label);
	kfree(cfg);
}

Contributors
Person Tokens Prop Commits CommitProp
sebastian andrzej siewior sebastian andrzej siewior 59 100.00% 1 100.00%
Total 59 100.00% 1 100.00%



static int config_usb_cfg_link(
	struct config_item *usb_cfg_ci,
	struct config_item *usb_func_ci)
{
	struct config_usb_cfg *cfg = to_config_usb_cfg(usb_cfg_ci);
	struct usb_composite_dev *cdev = cfg->c.cdev;
	struct gadget_info *gi = container_of(cdev, struct gadget_info, cdev);

	struct config_group *group = to_config_group(usb_func_ci);
	struct usb_function_instance *fi = container_of(group,
			struct usb_function_instance, group);
	struct usb_function_instance *a_fi;
	struct usb_function *f;
	int ret;

	mutex_lock(&gi->lock);
	/*
         * Make sure this function is from within our _this_ gadget and not
         * from another gadget or a random directory.
         * Also a function instance can only be linked once.
         */
	list_for_each_entry(a_fi, &gi->available_func, cfs_list) {
		if (a_fi == fi)
			break;
	}
	if (a_fi != fi) {
		ret = -EINVAL;
		goto out;
	}

	list_for_each_entry(f, &cfg->func_list, list) {
		if (f->fi == fi) {
			ret = -EEXIST;
			goto out;
		}
	}

	f = usb_get_function(fi);
	if (IS_ERR(f)) {
		ret = PTR_ERR(f);
		goto out;
	}

	/* stash the function until we bind it to the gadget */
	list_add_tail(&f->list, &cfg->func_list);
	ret = 0;
out:
	mutex_unlock(&gi->lock);
	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
sebastian andrzej siewior sebastian andrzej siewior 217 100.00% 1 100.00%
Total 217 100.00% 1 100.00%



static int config_usb_cfg_unlink(
	struct config_item *usb_cfg_ci,
	struct config_item *usb_func_ci)
{
	struct config_usb_cfg *cfg = to_config_usb_cfg(usb_cfg_ci);
	struct usb_composite_dev *cdev = cfg->c.cdev;
	struct gadget_info *gi = container_of(cdev, struct gadget_info, cdev);

	struct config_group *group = to_config_group(usb_func_ci);
	struct usb_function_instance *fi = container_of(group,
			struct usb_function_instance, group);
	struct usb_function *f;

	/*
         * ideally I would like to forbid to unlink functions while a gadget is
         * bound to an UDC. Since this isn't possible at the moment, we simply
         * force an unbind, the function is available here and then we can
         * remove the function.
         */
	mutex_lock(&gi->lock);
	if (gi->composite.gadget_driver.udc_name)
		unregister_gadget(gi);
	WARN_ON(gi->composite.gadget_driver.udc_name);

	list_for_each_entry(f, &cfg->func_list, list) {
		if (f->fi == fi) {
			list_del(&f->list);
			usb_put_function(f);
			mutex_unlock(&gi->lock);
			return 0;
		}
	}
	mutex_unlock(&gi->lock);
	WARN(1, "Unable to locate function to unbind\n");
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
sebastian andrzej siewior sebastian andrzej siewior 168 93.85% 1 33.33%
ruslan bilovol ruslan bilovol 8 4.47% 1 33.33%
david rientjes david rientjes 3 1.68% 1 33.33%
Total 179 100.00% 3 100.00%


static struct configfs_item_operations gadget_config_item_ops = {
	.release                = gadget_config_attr_release,
	.allow_link             = config_usb_cfg_link,
	.drop_link              = config_usb_cfg_unlink,
};




static ssize_t gadget_config_desc_MaxPower_show(struct config_item *item,
		char *page)
{
	return sprintf(page, "%u\n", to_config_usb_cfg(item)->c.MaxPower);
}

Contributors
Person Tokens Prop Commits CommitProp
sebastian andrzej siewior sebastian andrzej siewior 26 81.25% 1 50.00%
christoph hellwig christoph hellwig 6 18.75% 1 50.00%
Total 32 100.00% 2 100.00%



static ssize_t gadget_config_desc_MaxPower_store(struct config_item *item,
		const char *page, size_t len)
{
	u16 val;
	int ret;
	ret = kstrtou16(page, 0, &val);
	if (ret)
		return ret;
	if (DIV_ROUND_UP(val, 8) > 0xff)
		return -ERANGE;
	to_config_usb_cfg(item)->c.MaxPower = val;
	return len;
}

Contributors
Person Tokens Prop Commits CommitProp
sebastian andrzej siewior sebastian andrzej siewior 67 91.78% 1 50.00%
christoph hellwig christoph hellwig 6 8.22% 1 50.00%
Total 73 100.00% 2 100.00%



static ssize_t gadget_config_desc_bmAttributes_show(struct config_item *item,
		char *page)
{
	return sprintf(page, "0x%02x\n",
		to_config_usb_cfg(item)->c.bmAttributes);
}

Contributors
Person Tokens Prop Commits CommitProp
sebastian andrzej siewior sebastian andrzej siewior 26 81.25% 1 50.00%
christoph hellwig christoph hellwig 6 18.75% 1 50.00%
Total 32 100.00% 2 100.00%



static ssize_t gadget_config_desc_bmAttributes_store(struct config_item *item,
		const char *page, size_t len)
{
	u8 val;
	int ret;
	ret = kstrtou8(page, 0, &val);
	if (ret)
		return ret;
	if (!(val & USB_CONFIG_ATT_ONE))
		return -EINVAL;
	if (val & ~(USB_CONFIG_ATT_ONE | USB_CONFIG_ATT_SELFPOWER |
				USB_CONFIG_ATT_WAKEUP))
		return -EINVAL;
	to_config_usb_cfg(item)->c.bmAttributes = val;
	return len;
}

Contributors
Person Tokens Prop Commits CommitProp
sebastian andrzej siewior sebastian andrzej siewior 82 93.18% 1 50.00%
christoph hellwig christoph hellwig 6 6.82% 1 50.00%
Total 88 100.00% 2 100.00%

CONFIGFS_ATTR(gadget_config_desc_, MaxPower);
CONFIGFS_ATTR(gadget_config_desc_, bmAttributes);


static struct configfs_attribute *gadget_config_attrs[] = {
	&gadget_config_desc_attr_MaxPower,
	&gadget_config_desc_attr_bmAttributes,
	NULL,
};


static struct config_item_type gadget_config_type = {
	.ct_item_ops	= &gadget_config_item_ops,
	.ct_attrs	= gadget_config_attrs,
	.ct_owner	= THIS_MODULE,
};


static struct config_item_type gadget_root_type = {
	.ct_item_ops	= &gadget_root_item_ops,
	.ct_attrs	= gadget_root_attrs,
	.ct_owner	= THIS_MODULE,
};



static void composite_init_dev(struct usb_composite_dev *cdev)
{
	spin_lock_init(&cdev->lock);
	INIT_LIST_HEAD(&cdev->configs);
	INIT_LIST_HEAD(&cdev->gstrings);
}

Contributors
Person Tokens Prop Commits CommitProp
sebastian andrzej siewior sebastian andrzej siewior 35 100.00% 1 100.00%
Total 35 100.00% 1 100.00%



static struct config_group *function_make(
		struct config_group *group,
		const char *name)
{
	struct gadget_info *gi;
	struct usb_function_instance *fi;
	char buf[MAX_NAME_LEN];
	char *func_name;
	char *instance_name;
	int ret;

	ret = snprintf(buf, MAX_NAME_LEN, "%s", name);
	if (ret >= MAX_NAME_LEN)
		return ERR_PTR(-ENAMETOOLONG);

	func_name = buf;
	instance_name = strchr(func_name, '.');
	if (!instance_name) {
		pr_err("Unable to locate . in FUNC.INSTANCE\n");
		return ERR_PTR(-EINVAL);
	}
	*instance_name = '\0';
	instance_name++;

	fi = usb_get_function_instance(func_name);
	if (IS_ERR(fi))
		return ERR_CAST(fi);

	ret = config_item_set_name(&fi->group.cg_item, "%s", name);
	if (ret) {
		usb_put_function_instance(fi);
		return ERR_PTR(ret);
	}
	if (fi->set_inst_name) {
		ret = fi->set_inst_name(fi, instance_name);
		if (ret) {
			usb_put_function_instance(fi);
			return ERR_PTR(ret);
		}
	}

	gi = container_of(group, struct gadget_info, functions_group);

	mutex_lock(&gi->lock);
	list_add_tail(&fi->cfs_list, &gi->available_func);
	mutex_unlock(&gi->lock);
	return &fi->group;
}

Contributors
Person Tokens Prop Commits CommitProp
sebastian andrzej siewior sebastian andrzej siewior 208 84.21% 1 25.00%
andrzej pietrasiewicz andrzej pietrasiewicz 36 14.57% 1 25.00%
nicolas iooss nicolas iooss 2 0.81% 1 25.00%
duan jiong duan jiong 1 0.40% 1 25.00%
Total 247 100.00% 4 100.00%



static void function_drop(
		struct config_group *group,
		struct config_item *item)
{
	struct usb_function_instance *fi = to_usb_function_instance(item);
	struct gadget_info *gi;

	gi = container_of(group, struct gadget_info, functions_group);

	mutex_lock(&gi->lock);
	list_del(&fi->cfs_list);
	mutex_unlock(&gi->lock);
	config_item_put(item);
}

Contributors
Person Tokens Prop Commits CommitProp
sebastian andrzej siewior sebastian andrzej siewior 72 100.00% 1 100.00%
Total 72 100.00% 1 100.00%


static struct configfs_group_operations functions_ops = {
	.make_group     = &function_make,
	.drop_item      = &function_drop,
};


static struct config_item_type functions_type = {
	.ct_group_ops   = &functions_ops,
	.ct_owner       = THIS_MODULE,
};

GS_STRINGS_RW(gadget_config_name, configuration);


static struct configfs_attribute *gadget_config_name_langid_attrs[] = {
	&gadget_config_name_attr_configuration,
	NULL,
};



static void gadget_config_name_attr_release(struct config_item *item)
{
	struct gadget_config_name *cn = to_gadget_config_name(item);

	kfree(cn->configuration);

	list_del(&cn->list);
	kfree(cn);
}

Contributors
Person Tokens Prop Commits CommitProp
sebastian andrzej siewior sebastian andrzej siewior 41 100.00% 1 100.00%
Total 41 100.00% 1 100.00%


USB_CONFIG_STRING_RW_OPS(gadget_config_name);
USB_CONFIG_STRINGS_LANG(gadget_config_name, config_usb_cfg);



static struct config_group *config_desc_make(
		struct config_group *group,
		const char *name)
{
	struct gadget_info *gi;
	struct config_usb_cfg *cfg;
	char buf[MAX_NAME_LEN];
	char *num_str;
	u8 num;
	int ret;

	gi = container_of(group, struct gadget_info, configs_group);
	ret = snprintf(buf, MAX_NAME_LEN, "%s", name);
	if (ret >= MAX_NAME_LEN)
		return ERR_PTR(-ENAMETOOLONG);

	num_str = strchr(buf, '.');
	if (!num_str) {
		pr_err("Unable to locate . in name.bConfigurationValue\n");
		return ERR_PTR(-EINVAL);
	}

	*num_str = '\0';
	num_str++;

	if (!strlen(buf))
		return ERR_PTR(-EINVAL);

	ret = kstrtou8(num_str, 0, &num);
	if (ret)
		return ERR_PTR(ret);

	cfg = kzalloc(sizeof(*cfg), GFP_KERNEL);
	if (!cfg)
		return ERR_PTR(-ENOMEM);
	cfg->c.label = kstrdup(buf, GFP_KERNEL);
	if (!cfg->c.label) {
		ret = -ENOMEM;
		goto err;
	}
	cfg->c.bConfigurationValue = num;
	cfg->c.MaxPower = CONFIG_USB_GADGET_VBUS_DRAW;
	cfg->c.bmAttributes = USB_CONFIG_ATT_ONE;
	INIT_LIST_HEAD(&cfg->string_list);
	INIT_LIST_HEAD(&cfg->func_list);

	config_group_init_type_name(&cfg->group, name,
				&gadget_config_type);

	config_group_init_type_name(&cfg->strings_group, "strings",
			&gadget_config_name_strings_type);
	configfs_add_default_group(&cfg->strings_group, &cfg->group);

	ret = usb_add_config_only(&gi->cdev, &cfg->c);
	if (ret)
		goto err;

	return &cfg->group;
err:
	kfree(cfg->c.label);
	kfree(cfg);
	return ERR_PTR(ret);
}

Contributors
Person Tokens Prop Commits CommitProp
sebastian andrzej siewior sebastian andrzej siewior 328 96.19% 1 50.00%
christoph hellwig christoph hellwig 13 3.81% 1 50.00%
Total 341 100.00% 2 100.00%



static void config_desc_drop(
		struct config_group *group,
		struct config_item *item)
{
	config_item_put(item);
}

Contributors
Person Tokens Prop Commits CommitProp
sebastian andrzej siewior sebastian andrzej siewior 21 100.00% 1 100.00%
Total 21 100.00% 1 100.00%


static struct configfs_group_operations config_desc_ops = {
	.make_group     = &config_desc_make,
	.drop_item      = &config_desc_drop,
};


static struct config_item_type config_desc_type = {
	.ct_group_ops   = &config_desc_ops,
	.ct_owner       = THIS_MODULE,
};

GS_STRINGS_RW(gadget_strings, manufacturer);
GS_STRINGS_RW(gadget_strings, product);
GS_STRINGS_RW(gadget_strings, serialnumber);


static struct configfs_attribute *gadget_strings_langid_attrs[] = {
	&gadget_strings_attr_manufacturer,
	&gadget_strings_attr_product,
	&gadget_strings_attr_serialnumber,
	NULL,
};



static void gadget_strings_attr_release(struct config_item *item)
{
	struct gadget_strings *gs = to_gadget_strings(item);

	kfree(gs->manufacturer);
	kfree(gs->product);
	kfree(gs->serialnumber);

	list_del(&gs->list);
	kfree(gs);
}

Contributors
Person Tokens Prop Commits CommitProp
sebastian andrzej siewior sebastian andrzej siewior 55 100.00% 1 100.00%
Total 55 100.00% 1 100.00%


USB_CONFIG_STRING_RW_OPS(gadget_strings);
USB_CONFIG_STRINGS_LANG(gadget_strings, gadget_info);



static inline struct os_desc *to_os_desc(struct config_item *item)
{
	return container_of(to_config_group(item), struct os_desc, group);
}

Contributors
Person Tokens Prop Commits CommitProp
andrzej pietrasiewicz andrzej pietrasiewicz 18 64.29% 1 33.33%
sebastian andrzej siewior sebastian andrzej siewior 8 28.57% 1 33.33%
david rientjes david rientjes 2 7.14% 1 33.33%
Total 28 100.00% 3 100.00%



static inline struct gadget_info *os_desc_item_to_gadget_info(
		struct config_item *item)
{
	return to_gadget_info(to_os_desc(item)->group.cg_item.ci_parent);
}

Contributors
Person Tokens Prop Commits CommitProp
christoph hellwig christoph hellwig 26 89.66% 1 50.00%
andrzej pietrasiewicz andrzej pietrasiewicz 3 10.34% 1 50.00%
Total 29 100.00% 2 100.00%



static ssize_t os_desc_use_show(struct config_item *item, char *page)
{
	return sprintf(page, "%d",
			os_desc_item_to_gadget_info(item)->use_os_desc);
}

Contributors
Person Tokens Prop Commits CommitProp
andrzej pietrasiewicz andrzej pietrasiewicz 15 50.00% 1 33.33%
sebastian andrzej siewior sebastian andrzej siewior 9 30.00% 1 33.33%
christoph hellwig christoph hellwig 6 20.00% 1 33.33%
Total 30 100.00% 3 100.00%



static ssize_t os_desc_use_store(struct config_item *item, const char *page,
				 size_t len)
{
	struct gadget_info *gi = os_desc_item_to_gadget_info(item);
	int ret;
	bool use;

	mutex_lock(&gi->lock);
	ret = strtobool(page, &use);
	if (!ret) {
		gi->use_os_desc = use;
		ret = len;
	}
	mutex_unlock(&gi->lock);

	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
andrzej pietrasiewicz andrzej pietrasiewicz 48 59.26% 1 33.33%
sebastian andrzej siewior sebastian andrzej siewior 26 32.10% 1 33.33%
christoph hellwig christoph hellwig 7 8.64% 1 33.33%
Total 81 100.00% 3 100.00%



static ssize_t os_desc_b_vendor_code_show(struct config_item *item, char *page)
{
	return sprintf(page, "%d",
			os_desc_item_to_gadget_info(item)->b_vendor_code);
}

Contributors
Person Tokens Prop Commits CommitProp
andrzej pietrasiewicz andrzej pietrasiewicz 24 80.00% 1 50.00%
christoph hellwig christoph hellwig 6 20.00% 1 50.00%
Total 30 100.00% 2 100.00%



static ssize_t os_desc_b_vendor_code_store(struct config_item *item,
					   const char *page, size_t len)
{
	struct gadget_info *gi = os_desc_item_to_gadget_info(item);
	int ret;
	u8 b_vendor_code;

	mutex_lock(&gi->lock);
	ret = kstrtou8(page, 0, &b_vendor_code);
	if (!ret) {
		gi->b_vendor_code = b_vendor_code;
		ret = len;
	}
	mutex_unlock(&gi->lock);

	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
andrzej pietrasiewicz andrzej pietrasiewicz 76 91.57% 1 50.00%
christoph hellwig christoph hellwig 7 8.43% 1 50.00%
Total 83 100.00% 2 100.00%



static ssize_t os_desc_qw_sign_show(struct config_item *item, char *page)
{
	struct gadget_info *gi = os_desc_item_to_gadget_info(item);

	memcpy(page, gi->qw_sign, OS_STRING_QW_SIGN_LEN);
	return OS_STRING_QW_SIGN_LEN;
}

Contributors
Person Tokens Prop Commits CommitProp
andrzej pietrasiewicz andrzej pietrasiewicz 33 84.62% 1 50.00%
christoph hellwig christoph hellwig 6 15.38% 1 50.00%
Total 39 100.00% 2 100.00%



static ssize_t os_desc_qw_sign_store(struct config_item *item, const char *page,
				     size_t len)
{
	struct gadget_info *gi = os_desc_item_to_gadget_info(item);
	int res, l;

	l = min((int)len, OS_STRING_QW_SIGN_LEN >> 1);
	if (page[l - 1] == '\n')
		--l;

	mutex_lock(&gi->lock);
	res = utf8s_to_utf16s(page, l,
			      UTF16_LITTLE_ENDIAN, (wchar_t *) gi->qw_sign,
			      OS_STRING_QW_SIGN_LEN);
	if (res > 0)
		res = len;
	mutex_unlock(&gi->lock);

	return res;
}

Contributors
Person Tokens Prop Commits CommitProp
andrzej pietrasiewicz andrzej pietrasiewicz 104 92.86% 1 50.00%
christoph hellwig christoph hellwig 8 7.14% 1 50.00%
Total 112 100.00% 2 100.00%

CONFIGFS_ATTR(os_desc_, use);
CONFIGFS_ATTR(os_desc_, b_vendor_code);
CONFIGFS_ATTR(os_desc_, qw_sign);


static struct configfs_attribute *os_desc_attrs[] = {
	&os_desc_attr_use,
	&os_desc_attr_b_vendor_code,
	&os_desc_attr_qw_sign,
	NULL,
};



static void os_desc_attr_release(struct config_item *item)
{
	struct os_desc *os_desc = to_os_desc(item);
	kfree(os_desc);
}

Contributors
Person Tokens Prop Commits CommitProp
andrzej pietrasiewicz andrzej pietrasiewicz 26 100.00% 1 100.00%
Total 26 100.00% 1 100.00%



static int os_desc_link(struct config_item *os_desc_ci,
			struct config_item *usb_cfg_ci)
{
	struct gadget_info *gi = container_of(to_config_group(os_desc_ci),
					struct gadget_info, os_desc_group);
	struct usb_composite_dev *cdev = &gi->cdev;
	struct config_usb_cfg *c_target =
		container_of(to_config_group(usb_cfg_ci),
			     struct config_usb_cfg, group);
	struct usb_configuration *c;
	int ret;

	mutex_lock(&gi->lock);
	list_for_each_entry(c, &cdev->configs, list) {
		if (c == &c_target->c)
			break;
	}
	if (c != &c_target->c) {
		ret = -EINVAL;
		goto out;
	}

	if (cdev->os_desc_config) {
		ret = -EBUSY;
		goto out;
	}

	cdev->os_desc_config = &c_target->c;
	ret = 0;

out:
	mutex_unlock(&gi->lock);
	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
andrzej pietrasiewicz andrzej pietrasiewicz 159 100.00% 2 100.00%
Total 159 100.00% 2 100.00%



static int os_desc_unlink(struct config_item *os_desc_ci,
			  struct config_item *usb_cfg_ci)
{
	struct gadget_info *gi = container_of(to_config_group(os_desc_ci),
					struct gadget_info, os_desc_group);
	struct usb_composite_dev *cdev = &gi->cdev;

	mutex_lock(&gi->lock);
	if (gi->composite.gadget_driver.udc_name)
		unregister_gadget(gi);
	cdev->os_desc_config = NULL;
	WARN_ON(gi->composite.gadget_driver.udc_name);
	mutex_unlock(&gi->lock);
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
andrzej pietrasiewicz andrzej pietrasiewicz 87 91.58% 1 50.00%
ruslan bilovol ruslan bilovol 8 8.42% 1 50.00%
Total 95 100.00% 2 100.00%


static struct configfs_item_operations os_desc_ops = {
	.release                = os_desc_attr_release,
	.allow_link		= os_desc_link,
	.drop_link		= os_desc_unlink,
};


static struct config_item_type os_desc_type = {
	.ct_item_ops	= &os_desc_ops,
	.ct_attrs	= os_desc_attrs,
	.ct_owner	= THIS_MODULE,
};


static inline struct usb_os_desc_ext_prop

*to_usb_os_desc_ext_prop(struct config_item *item)
{
	return container_of(item, struct usb_os_desc_ext_prop, item);
}

Contributors
Person Tokens Prop Commits CommitProp
andrzej pietrasiewicz andrzej pietrasiewicz 25 100.00% 2 100.00%
Total 25 100.00% 2 100.00%



static ssize_t ext_prop_type_show(struct config_item *item, char *page)
{
	return sprintf(page, "%d", to_usb_os_desc_ext_prop(item)->type);
}

Contributors
Person Tokens Prop Commits CommitProp
andrzej pietrasiewicz andrzej pietrasiewicz 24 80.00% 2 66.67%
christoph hellwig christoph hellwig 6 20.00% 1 33.33%
Total 30 100.00% 3 100.00%



static ssize_t ext_prop_type_store(struct config_item *item,
				   const char *page, size_t len)
{
	struct usb_os_desc_ext_prop *ext_prop = to_usb_os_desc_ext_prop(item);
	struct usb_os_desc *desc = to_usb_os_desc(ext_prop->item.ci_parent);
	u8 type;
	int ret;

	if (desc->opts_mutex)
		mutex_lock(desc->opts_mutex);
	ret = kstrtou8(page, 0, &type);
	if (ret)
		goto end;
	if (type < USB_EXT_PROP_UNICODE || type > USB_EXT_PROP_UNICODE_MULTI) {
		ret = -EINVAL;
		goto end;
	}

	if ((ext_prop->type == USB_EXT_PROP_BINARY ||
	    ext_prop->type == USB_EXT_PROP_LE32 ||
	    ext_prop->type == USB_EXT_PROP_BE32) &&
	    (type == USB_EXT_PROP_UNICODE ||
	    type == USB_EXT_PROP_UNICODE_ENV ||
	    type == USB_EXT_PROP_UNICODE_LINK))
		ext_prop->data_len <<= 1;
	else if ((ext_prop->type == USB_EXT_PROP_UNICODE ||
		   ext_prop->type == USB_EXT_PROP_UNICODE_ENV ||
		   ext_prop->type == USB_EXT_PROP_UNICODE_LINK) &&
		   (type == USB_EXT_PROP_BINARY ||
		   type == USB_EXT_PROP_LE32 ||
		   type == USB_EXT_PROP_BE32))
		ext_prop->data_len >>= 1;
	ext_prop->type = type;
	ret = len;

end:
	if (desc->opts_mutex)
		mutex_unlock(desc->opts_mutex);
	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
andrzej pietrasiewicz andrzej pietrasiewicz 202 94.39% 2 66.67%
christoph hellwig christoph hellwig 12 5.61% 1 33.33%
Total 214 100.00% 3 100.00%



static ssize_t ext_prop_data_show(struct config_item *item, char *page)
{
	struct usb_os_desc_ext_prop *ext_prop = to_usb_os_desc_ext_prop(item);
	int len = ext_prop->data_len;

	if (ext_prop->type == USB_EXT_PROP_UNICODE ||
	    ext_prop->type == USB_EXT_PROP_UNICODE_ENV ||
	    ext_prop->type == USB_EXT_PROP_UNICODE_LINK)
		len >>= 1;
	memcpy(page, ext_prop->data, len);

	return len;
}

Contributors
Person Tokens Prop Commits CommitProp
andrzej pietrasiewicz andrzej pietrasiewicz 58 82.86% 2 66.67%
christoph hellwig christoph hellwig 12 17.14% 1 33.33%
Total 70 100.00% 3 100.00%



static ssize_t ext_prop_data_store(struct config_item *item,
				   const char *page, size_t len)
{
	struct usb_os_desc_ext_prop *ext_prop = to_usb_os_desc_ext_prop(item);
	struct usb_os_desc *desc = to_usb_os_desc(ext_prop->item.ci_parent);
	char *new_data;
	size_t ret_len = len;

	if (page[len - 1] == '\n' || page[len - 1] == '\0')
		--len;
	new_data = kmemdup(page, len, GFP_KERNEL);
	if (!new_data)
		return -ENOMEM;

	if (desc->opts_mutex)
		mutex_lock(desc->opts_mutex);
	kfree(ext_prop->data);
	ext_prop->data = new_data;
	desc->ext_prop_len -= ext_prop->data_len;
	ext_prop->data_len = len;
	desc->ext_prop_len += ext_prop->data_len;
	if (ext_prop->type == USB_EXT_PROP_UNICODE ||
	    ext_prop->type == USB_EXT_PROP_UNICODE_ENV ||
	    ext_prop->type == USB_EXT_PROP_UNICODE_LINK) {
		desc->ext_prop_len -= ext_prop->data_len;
		ext_prop->data_len <<= 1;
		ext_prop->data_len += 2;
		desc->ext_prop_len += ext_prop->data_len;
	}
	if (desc->opts_mutex)
		mutex_unlock(desc->opts_mutex);
	return ret_len;
}

Contributors
Person Tokens Prop Commits CommitProp
andrzej pietrasiewicz andrzej pietrasiewicz 194 92.82% 2 50.00%
christoph hellwig christoph hellwig 12 5.74% 1 25.00%
benoit taine benoit taine 3 1.44% 1 25.00%
Total 209 100.00% 4 100.00%

CONFIGFS_ATTR(ext_prop_, type);
CONFIGFS_ATTR(ext_prop_, data);


static struct configfs_attribute *ext_prop_attrs[] = {
	&ext_prop_attr_type,
	&ext_prop_attr_data,
	NULL,
};



static void usb_os_desc_ext_prop_release(struct config_item *item)
{
	struct usb_os_desc_ext_prop *ext_prop = to_usb_os_desc_ext_prop(item);

	kfree(ext_prop); /* frees a whole chunk */
}

Contributors
Person Tokens Prop Commits CommitProp
andrzej pietrasiewicz andrzej pietrasiewicz 27 100.00% 1 100.00%
Total 27 100.00% 1 100.00%


static struct configfs_item_operations ext_prop_ops = {
	.release		= usb_os_desc_ext_prop_release,
};



static struct config_item *ext_prop_make(
		struct config_group *group,
		const char *name)
{
	struct usb_os_desc_ext_prop *ext_prop;
	struct config_item_type *ext_prop_type;
	struct usb_os_desc *desc;
	char *vlabuf;

	vla_group(data_chunk);
	vla_item(data_chunk, struct usb_os_desc_ext_prop, ext_prop, 1);
	vla_item(data_chunk, struct config_item_type, ext_prop_type, 1);

	vlabuf = kzalloc(vla_group_size(data_chunk), GFP_KERNEL);
	if (!vlabuf)
		return ERR_PTR(-ENOMEM);

	ext_prop = vla_ptr(vlabuf, data_chunk, ext_prop);
	ext_prop_type = vla_ptr(vlabuf, data_chunk, ext_prop_type);

	desc = container_of(group, struct usb_os_desc, group);
	ext_prop_type->ct_item_ops = &ext_prop_ops;
	ext_prop_type->ct_attrs = ext_prop_attrs;
	ext_prop_type->ct_owner = desc->owner;

	config_item_init_type_name(&ext_prop->item, name, ext_prop_type);

	ext_prop->name = kstrdup(name, GFP_KERNEL);
	if (!ext_prop->name) {
		kfree(vlabuf);
		return ERR_PTR(-ENOMEM);
	}
	desc->ext_prop_len += 14;
	ext_prop->name_len = 2 * strlen(ext_prop->name) + 2;
	if (desc->opts_mutex)
		mutex_lock(desc->opts_mutex);
	desc->ext_prop_len += ext_prop->name_len;
	list_add_tail(&ext_prop->entry, &desc->ext_prop);
	++desc->ext_prop_count;
	if (desc->opts_mutex)
		mutex_unlock(desc->opts_mutex);

	return &ext_prop->item;
}

Contributors
Person Tokens Prop Commits CommitProp
andrzej pietrasiewicz andrzej pietrasiewicz 268 100.00% 1 100.00%
Total 268 100.00% 1 100.00%



static void ext_prop_drop(struct config_group *group, struct config_item *item)
{
	struct usb_os_desc_ext_prop *ext_prop = to_usb_os_desc_ext_prop(item);
	struct usb_os_desc *desc = to_usb_os_desc(&group->cg_item);

	if (desc->opts_mutex)
		mutex_lock(desc->opts_mutex);
	list_del(&ext_prop->entry);
	--desc->ext_prop_count;
	kfree(ext_prop->name);
	desc->ext_prop_len -= (ext_prop->name_len + ext_prop->data_len + 14);
	if (desc->opts_mutex)
		mutex_unlock(desc->opts_mutex);
	config_item_put(item);
}

Contributors
Person Tokens Prop Commits CommitProp
andrzej pietrasiewicz andrzej pietrasiewicz 106 100.00% 1 100.00%
Total 106 100.00% 1 100.00%


static struct configfs_group_operations interf_grp_ops = {
	.make_item	= &ext_prop_make,
	.drop_item	= &ext_prop_drop,
};



static ssize_t interf_grp_compatible_id_show(struct config_item *item,
					     char *page)
{
	memcpy(page, to_usb_os_desc(item)->ext_compat_id, 8);
	return 8;
}

Contributors
Person Tokens Prop Commits CommitProp
andrzej pietrasiewicz andrzej pietrasiewicz 26 81.25% 2 66.67%
christoph hellwig christoph hellwig 6 18.75% 1 33.33%
Total 32 100.00% 3 100.00%



static ssize_t interf_grp_compatible_id_store(struct config_item *item,
					      const char *page, size_t len)
{
	struct usb_os_desc *desc = to_usb_os_desc(item);
	int l;

	l = min_t(int, 8, len);
	if (page[l - 1] == '\n')
		--l;
	if (desc->opts_mutex)
		mutex_lock(desc->opts_mutex);
	memcpy(desc->ext_compat_id, page, l);

	if (desc->opts_mutex)
		mutex_unlock(desc->opts_mutex);

	return len;
}

Contributors
Person Tokens Prop Commits CommitProp
andrzej pietrasiewicz andrzej pietrasiewicz 85 87.63% 2 66.67%
christoph hellwig christoph hellwig 12 12.37% 1 33.33%
Total 97 100.00% 3 100.00%



static ssize_t interf_grp_sub_compatible_id_show(struct config_item *item,
						 char *page)
{
	memcpy(page, to_usb_os_desc(item)->ext_compat_id + 8, 8);
	return 8;
}

Contributors
Person Tokens Prop Commits CommitProp
andrzej pietrasiewicz andrzej pietrasiewicz 28 82.35% 2 66.67%
christoph hellwig christoph hellwig 6 17.65% 1 33.33%
Total 34 100.00% 3 100.00%



static ssize_t interf_grp_sub_compatible_id_store(struct config_item *item,
						  const char *page, size_t len)
{
	struct usb_os_desc *desc = to_usb_os_desc(item);
	int l;

	l = min_t(int, 8, len);
	if (page[l - 1] == '\n')
		--l;
	if (desc->opts_mutex)
		mutex_lock(desc->opts_mutex);
	memcpy(desc->ext_compat_id + 8, page, l);

	if (desc->opts_mutex)
		mutex_unlock(desc->opts_mutex);

	return len;
}

Contributors
Person Tokens Prop Commits CommitProp
andrzej pietrasiewicz andrzej pietrasiewicz 87 87.88% 3 75.00%
christoph hellwig christoph hellwig 12 12.12% 1 25.00%
Total 99 100.00% 4 100.00%

CONFIGFS_ATTR(interf_grp_, compatible_id);
CONFIGFS_ATTR(interf_grp_, sub_compatible_id);


static struct configfs_attribute *interf_grp_attrs[] = {
	&interf_grp_attr_compatible_id,
	&interf_grp_attr_sub_compatible_id,
	NULL
};



int usb_os_desc_prepare_interf_dir(struct config_group *parent,
				   int n_interf,
				   struct usb_os_desc **desc,
				   char **names,
				   struct module *owner)
{
	struct config_group *os_desc_group;
	struct config_item_type *os_desc_type, *interface_type;

	vla_group(data_chunk);
	vla_item(data_chunk, struct config_group, os_desc_group, 1);
	vla_item(data_chunk, struct config_item_type, os_desc_type, 1);
	vla_item(data_chunk, struct config_item_type, interface_type, 1);

	char *vlabuf = kzalloc(vla_group_size(data_chunk), GFP_KERNEL);
	if (!vlabuf)
		return -ENOMEM;

	os_desc_group = vla_ptr(vlabuf, data_chunk, os_desc_group);
	os_desc_type = vla_ptr(vlabuf, data_chunk, os_desc_type);
	interface_type = vla_ptr(vlabuf, data_chunk, interface_type);

	os_desc_type->ct_owner = owner;
	config_group_init_type_name(os_desc_group, "os_desc", os_desc_type);
	configfs_add_default_group(os_desc_group, parent);

	interface_type->ct_group_ops = &interf_grp_ops;
	interface_type->ct_attrs = interf_grp_attrs;
	interface_type->ct_owner = owner;

	while (n_interf--) {
		struct usb_os_desc *d;

		d = desc[n_interf];
		d->owner = owner;
		config_group_init_type_name(&d->group, "", interface_type);
		config_item_set_name(&d->group.cg_item, "interface.%s",
				     names[n_interf]);
		configfs_add_default_group(&d->group, os_desc_group);
	}

	return 0;
}
Contributors
Person Tokens Prop Commits CommitProp
andrzej pietrasiewicz andrzej pietrasiewicz 237 95.95% 3 75.00%
christoph hellwig christoph hellwig 10 4.05% 1 25.00%
Total 247 100.00% 4 100.00%


EXPORT_SYMBOL(usb_os_desc_prepare_interf_dir);



static int configfs_do_nothing(struct usb_composite_dev *cdev)
{
	WARN_ON(1);
	return -EINVAL;
}

Contributors
Person Tokens Prop Commits CommitProp
andrzej pietrasiewicz andrzej pietrasiewicz 20 100.00% 1 100.00%
Total 20 100.00% 1 100.00%

int composite_dev_prepare(struct usb_composite_driver *composite,
		struct usb_composite_dev *dev);

int composite_os_desc_req_prepare(struct usb_composite_dev *cdev,
				  struct usb_ep *ep0);



static void purge_configs_funcs(struct gadget_info *gi)
{
	struct usb_configuration	*c;

	list_for_each_entry(c, &gi->cdev.configs, list) {
		struct usb_function *f, *tmp;
		struct config_usb_cfg *cfg;

		cfg = container_of(c, struct config_usb_cfg, c);

		list_for_each_entry_safe(f, tmp, &c->functions, list) {

			list_move_tail(&f->list, &cfg->func_list);
			if (f->unbind) {
				dev_err(&gi->cdev.gadget->dev, "unbind function"
						" '%s'/%p\n", f->name, f);
				f->unbind(c, f);
			}
		}
		c->next_interface_id = 0;
		memset(c->interface, 0, sizeof(c->interface));
		c->superspeed_plus = 0;
		c->superspeed = 0;
		c->highspeed = 0;
		c->fullspeed = 0;
	}
}

Contributors
Person Tokens Prop Commits CommitProp
andrzej pietrasiewicz andrzej pietrasiewicz 138 86.25% 1 33.33%
krzysztof opasiak krzysztof opasiak 16 10.00% 1 33.33%
john youn john youn 6 3.75% 1 33.33%
Total 160 100.00% 3 100.00%



static int configfs_composite_bind(struct usb_gadget *gadget,
		struct usb_gadget_driver *gdriver)
{
	struct usb_composite_driver     *composite = to_cdriver(gdriver);
	struct gadget_info		*gi = container_of(composite,
						struct gadget_info, composite);
	struct usb_composite_dev	*cdev = &gi->cdev;
	struct usb_configuration	*c;
	struct usb_string		*s;
	unsigned			i;
	int				ret;

	/* the gi->lock is hold by the caller */
	cdev->gadget = gadget;
	set_gadget_data(gadget, cdev);
	ret = composite_dev_prepare(composite, cdev);
	if (ret)
		return ret;
	/* and now the gadget bind */
	ret = -EINVAL;

	if (list_empty(&gi->cdev.configs)) {
		pr_err("Need at least one configuration in %s.\n",
				gi->composite.name);
		goto err_comp_cleanup;
	}


	list_for_each_entry(c, &gi->cdev.configs, list) {
		struct config_usb_cfg *cfg;

		cfg = container_of(c, struct config_usb_cfg, c);
		if (list_empty(&cfg->func_list)) {
			pr_err("Config %s/%d of %s needs at least one function.\n",
			      c->label, c->bConfigurationValue,
			      gi->composite.name);
			goto err_comp_cleanup;
		}
	}

	/* init all strings */
	if (!list_empty(&gi->string_list)) {
		struct gadget_strings *gs;

		i = 0;
		list_for_each_entry(gs, &gi->string_list, list) {

			gi->gstrings[i] = &gs->stringtab_dev;
			gs->stringtab_dev.strings = gs->strings;
			gs->strings[USB_GADGET_MANUFACTURER_IDX].s =
				gs->manufacturer;
			gs->strings[USB_GADGET_PRODUCT_IDX].s = gs->product;
			gs->strings[USB_GADGET_SERIAL_IDX].s = gs->serialnumber;
			i++;
		}
		gi->gstrings[i] = NULL;
		s = usb_gstrings_attach(&gi->cdev, gi->gstrings,
				USB_GADGET_FIRST_AVAIL_IDX);
		if (IS_ERR(s)) {
			ret = PTR_ERR(s);
			goto err_comp_cleanup;
		}

		gi->cdev.desc.iManufacturer = s[USB_GADGET_MANUFACTURER_IDX].id;
		gi->cdev.desc.iProduct = s[USB_GADGET_PRODUCT_IDX].id;
		gi->cdev.desc.iSerialNumber = s[USB_GADGET_SERIAL_IDX].id;
	}

	if (gi->use_os_desc) {
		cdev->use_os_string = true;
		cdev->b_vendor_code = gi->b_vendor_code;
		memcpy(cdev->qw_sign, gi->qw_sign, OS_STRING_QW_SIGN_LEN);
	}

	if (gadget_is_otg(gadget) && !otg_desc[0]) {
		struct usb_descriptor_header *usb_desc;

		usb_desc = usb_otg_descriptor_alloc(gadget);
		if (!usb_desc) {
			ret = -ENOMEM;
			goto err_comp_cleanup;
		}
		usb_otg_descriptor_init(gadget, usb_desc);
		otg_desc[0] = usb_desc;
		otg_desc[1] = NULL;
	}

	/* Go through all configs, attach all functions */
	list_for_each_entry(c, &gi->cdev.configs, list) {
		struct config_usb_cfg *cfg;
		struct usb_function *f;
		struct usb_function *tmp;
		struct gadget_config_name *cn;

		if (gadget_is_otg(gadget))
			c->descriptors = otg_desc;

		cfg = container_of(c, struct config_usb_cfg, c);
		if (!list_empty(&cfg->string_list)) {
			i = 0;
			list_for_each_entry(cn, &cfg->string_list, list) {
				cfg->gstrings[i] = &cn->stringtab_dev;
				cn->stringtab_dev.strings = &cn->strings;
				cn->strings.s = cn->configuration;
				i++;
			}
			cfg->gstrings[i] = NULL;
			s = usb_gstrings_attach(&gi->cdev, cfg->gstrings, 1);
			if (IS_ERR(s)) {
				ret = PTR_ERR(s);
				goto err_comp_cleanup;
			}
			c->iConfiguration = s[0].id;
		}

		list_for_each_entry_safe(f, tmp, &cfg->func_list, list) {
			list_del(&f->list);
			ret = usb_add_function(c, f);
			if (ret) {
				list_add(&f->list, &cfg->func_list);
				goto err_purge_funcs;
			}
		}
		usb_ep_autoconfig_reset(cdev->gadget);
	}
	if (cdev->use_os_string) {
		ret = composite_os_desc_req_prepare(cdev, gadget->ep0);
		if (ret)
			goto err_purge_funcs;
	}

	usb_ep_autoconfig_reset(cdev->gadget);
	return 0;

err_purge_funcs:
	purge_configs_funcs(gi);
err_comp_cleanup:
	composite_dev_cleanup(cdev);
	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
sebastian andrzej siewior sebastian andrzej siewior 583 76.61% 1 14.29%
andrzej pietrasiewicz andrzej pietrasiewicz 82 10.78% 3 42.86%
li jun li jun 76 9.99% 1 14.29%
wei yongjun wei yongjun 18 2.37% 1 14.29%
peter chen peter chen 2 0.26% 1 14.29%
Total 761 100.00% 7 100.00%



static void configfs_composite_unbind(struct usb_gadget *gadget)
{
	struct usb_composite_dev	*cdev;
	struct gadget_info		*gi;

	/* the gi->lock is hold by the caller */

	cdev = get_gadget_data(gadget);
	gi = container_of(cdev, struct gadget_info, cdev);

	kfree(otg_desc[0]);
	otg_desc[0] = NULL;
	purge_configs_funcs(gi);
	composite_dev_cleanup(cdev);
	usb_ep_autoconfig_reset(cdev->gadget);
	cdev->gadget = NULL;
	set_gadget_data(gadget, NULL);
}

Contributors
Person Tokens Prop Commits CommitProp
sebastian andrzej siewior sebastian andrzej siewior 71 82.56% 1 50.00%
li jun li jun 15 17.44% 1 50.00%
Total 86 100.00% 2 100.00%


static const struct usb_gadget_driver configfs_driver_template = {
	.bind           = configfs_composite_bind,
	.unbind         = configfs_composite_unbind,

	.setup          = composite_setup,
	.reset          = composite_disconnect,
	.disconnect     = composite_disconnect,

	.suspend	= composite_suspend,
	.resume		= composite_resume,

	.max_speed	= USB_SPEED_SUPER,
	.driver = {
		.owner          = THIS_MODULE,
		.name		= "configfs-gadget",
        },
	.match_existing_only = 1,
};



static struct config_group *gadgets_make(
		struct config_group *group,
		const char *name)
{
	struct gadget_info *gi;

	gi = kzalloc(sizeof(*gi), GFP_KERNEL);
	if (!gi)
		return ERR_PTR(-ENOMEM);

	config_group_init_type_name(&gi->group, name, &gadget_root_type);

	config_group_init_type_name(&gi->functions_group, "functions",
			&functions_type);
	configfs_add_default_group(&gi->functions_group, &gi->group);

	config_group_init_type_name(&gi->configs_group, "configs",
			&config_desc_type);
	configfs_add_default_group(&gi->configs_group, &gi->group);

	config_group_init_type_name(&gi->strings_group, "strings",
			&gadget_strings_strings_type);
	configfs_add_default_group(&gi->strings_group, &gi->group);

	config_group_init_type_name(&gi->os_desc_group, "os_desc",
			&os_desc_type);
	configfs_add_default_group(&gi->os_desc_group, &gi->group);

	gi->composite.bind = configfs_do_nothing;
	gi->composite.unbind = configfs_do_nothing;
	gi->composite.suspend = NULL;
	gi->composite.resume = NULL;
	gi->composite.max_speed = USB_SPEED_SUPER;

	mutex_init(&gi->lock);
	INIT_LIST_HEAD(&gi->string_list);
	INIT_LIST_HEAD(&gi->available_func);

	composite_init_dev(&gi->cdev);
	gi->cdev.desc.bLength = USB_DT_DEVICE_SIZE;
	gi->cdev.desc.bDescriptorType = USB_DT_DEVICE;
	gi->cdev.desc.bcdDevice = cpu_to_le16(get_default_bcdDevice());

	gi->composite.gadget_driver = configfs_driver_template;

	gi->composite.gadget_driver.function = kstrdup(name, GFP_KERNEL);
	gi->composite.name = gi->composite.gadget_driver.function;

	if (!gi->composite.gadget_driver.function)
		goto err;

	return &gi->group;
err:
	kfree(gi);
	return ERR_PTR(-ENOMEM);
}

Contributors
Person Tokens Prop Commits CommitProp
sebastian andrzej siewior sebastian andrzej siewior 270 78.95% 1 33.33%
christoph hellwig christoph hellwig 55 16.08% 1 33.33%
andrzej pietrasiewicz andrzej pietrasiewicz 17 4.97% 1 33.33%
Total 342 100.00% 3 100.00%



static void gadgets_drop(struct config_group *group, struct config_item *item)
{
	config_item_put(item);
}

Contributors
Person Tokens Prop Commits CommitProp
sebastian andrzej siewior sebastian andrzej siewior 21 100.00% 1 100.00%
Total 21 100.00% 1 100.00%


static struct configfs_group_operations gadgets_ops = {
	.make_group     = &gadgets_make,
	.drop_item      = &gadgets_drop,
};


static struct config_item_type gadgets_type = {
	.ct_group_ops   = &gadgets_ops,
	.ct_owner       = THIS_MODULE,
};


static struct configfs_subsystem gadget_subsys = {
	.su_group = {
		.cg_item = {
			.ci_namebuf = "usb_gadget",
			.ci_type = &gadgets_type,
                },
        },
	.su_mutex = __MUTEX_INITIALIZER(gadget_subsys.su_mutex),
};



void unregister_gadget_item(struct config_item *item)
{
	struct gadget_info *gi = to_gadget_info(item);

	unregister_gadget(gi);
}
Contributors
Person Tokens Prop Commits CommitProp
andrzej pietrasiewicz andrzej pietrasiewicz 25 100.00% 1 100.00%
Total 25 100.00% 1 100.00%


EXPORT_SYMBOL_GPL(unregister_gadget_item);



static int __init gadget_cfs_init(void)
{
	int ret;

	config_group_init(&gadget_subsys.su_group);

	ret = configfs_register_subsystem(&gadget_subsys);
	return ret;
}
Contributors
Person Tokens Prop Commits CommitProp
sebastian andrzej siewior sebastian andrzej siewior 31 100.00% 1 100.00%
Total 31 100.00% 1 100.00%


module_init(gadget_cfs_init);



static void __exit gadget_cfs_exit(void)
{
	configfs_unregister_subsystem(&gadget_subsys);
}
Contributors
Person Tokens Prop Commits CommitProp
sebastian andrzej siewior sebastian andrzej siewior 15 100.00% 1 100.00%
Total 15 100.00% 1 100.00%


module_exit(gadget_cfs_exit);
Overall Contributors
Person Tokens Prop Commits CommitProp
sebastian andrzej siewior sebastian andrzej siewior 3986 55.83% 1 3.85%
andrzej pietrasiewicz andrzej pietrasiewicz 2499 35.00% 9 34.62%
christoph hellwig christoph hellwig 419 5.87% 2 7.69%
li jun li jun 101 1.41% 1 3.85%
ruslan bilovol ruslan bilovol 68 0.95% 1 3.85%
krzysztof opasiak krzysztof opasiak 21 0.29% 2 7.69%
wei yongjun wei yongjun 18 0.25% 1 3.85%
peter chen peter chen 7 0.10% 2 7.69%
john youn john youn 6 0.08% 1 3.85%
david rientjes david rientjes 5 0.07% 1 3.85%
benoit taine benoit taine 3 0.04% 1 3.85%
rashika kheria rashika kheria 3 0.04% 1 3.85%
nicolas iooss nicolas iooss 2 0.03% 1 3.85%
duan jiong duan jiong 1 0.01% 1 3.85%
felipe balbi felipe balbi 1 0.01% 1 3.85%
Total 7140 100.00% 26 100.00%
  Directory: drivers/usb/gadget

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
	Person	Tokens	Prop	Commits	CommitProp
sebastian andrzej siewior	sebastian andrzej siewior	100	100.00%	1	100.00%
	Total	100	100.00%	1	100.00%
cregit-Linux how code gets into the kernel

Release 4.7 drivers/usb/gadget/configfs.c

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Overall Contributors
