|# modprobe dummy_hcd num=2
|# find /sys/kernel/config/ -ls
| 557 0 drwxr-xr-x 3 root root 0 Nov 29 17:26
/sys/kernel/config/
| 558 0 drwxr-xr-x 5 root root 0 Nov 29 17:26
/sys/kernel/config/usb_gadget
| 561 0 drwxr-xr-x 4 root root 0 Nov 29 17:26
/sys/kernel/config/usb_gadget/udcs
| 569 0 drwxr-xr-x 2 root root 0 Nov 29 17:26
/sys/kernel/config/usb_gadget/udcs/dummy_udc.1
| 568 0 drwxr-xr-x 2 root root 0 Nov 29 17:26
/sys/kernel/config/usb_gadget/udcs/dummy_udc.0
| 560 0 drwxr-xr-x 2 root root 0 Nov 29 17:26
/sys/kernel/config/usb_gadget/gadgets
| 559 0 drwxr-xr-x 2 root root 0 Nov 29 17:26
/sys/kernel/config/usb_gadget/functions
| # lsmod
| Module Size Used by
| dummy_hcd 20287 0
| udc 10219 1 dummy_hcd
|# mkdir /sys/kernel/config/usb_gadget/functions/acm.one
| # lsmod
| Module Size Used by
| f_acm 5306 0
| u_serial 9644 1 f_acm
| libcomposite 17052 1 f_acm
| dummy_hcd 20287 0
| udc 10219 3 f_acm,dummy_hcd,libcomposite
|# mkdir /sys/kernel/config/usb_gadget/gadgets/oha
|# find /sys/kernel/config/usb_gadget/gadgets/oha
|/sys/kernel/config/usb_gadget/gadgets/oha/
|/sys/kernel/config/usb_gadget/gadgets/oha/sSerialNumber
|/sys/kernel/config/usb_gadget/gadgets/oha/sProduct
|/sys/kernel/config/usb_gadget/gadgets/oha/sManufacturer
|/sys/kernel/config/usb_gadget/gadgets/oha/bcdUSB
|/sys/kernel/config/usb_gadget/gadgets/oha/idProduct
|/sys/kernel/config/usb_gadget/gadgets/oha/idVendor
|/sys/kernel/config/usb_gadget/gadgets/oha/bMaxPacketSize0
|/sys/kernel/config/usb_gadget/gadgets/oha/bDeviceProtocol
|/sys/kernel/config/usb_gadget/gadgets/oha/bDeviceSubClass
|/sys/kernel/config/usb_gadget/gadgets/oha/bDeviceClass
|# cd /sys/kernel/config/usb_gadget/gadgets/oha
|oha# echo basilimi > sProduct
|oha# cat sProduct
|basilimi
|oha# echo 0xdada >
|bcdUSB
|-bash: echo: write error: Invalid argument
|oha# echo 0x1234 >
|bcdUSB
|oha# cat bcdUSB
|0x1234
|#
|# oha# mkdir default.0
|mkdir: cannot create directory `default.0': Invalid argument
|oha# mkdir default.1
|oha# mkdir default.2
|oha# mkdir another.2
|mkdir: cannot create directory `another.2': File exists
v2âŠv3
- replaced one ifndef by ifdef as suggested by MicahaÅ
- strstr()/strchr() function_make as suggested by MicahÅ
- replace [iSerialNumber|iProduct|iManufacturer] with
[sSerialNumber|sProduct|sManufacturer] as suggested by Alan
- added creation of config descriptors
v1âŠv2
- moved gadgets from configfs' root directory into /udcs/ within our
"usb_gadget" folder. Requested by Andrzej & MichaÅ
- use a dot as a delimiter between function's name and its instance's name
as suggested by MichaÅ
- renamed all config_item_type, configfs_group_operations, make_group,
drop_item as suggested by suggested by Andrzej to remain consisten
within this file and within other configfs users
- Since configfs.c and functions.c are now part of the udc-core module,
the module itself is now called udc. Also added a tiny ifdef around
init code becuase udc-core is subsys init and this is too early for
configfs in the built-in case. In the module case, we can only have
one init function.
Signed-off-by: Sebastian Andrzej Siewior <bige...@linutronix.de>
---
drivers/usb/gadget/Makefile | 5 +-
drivers/usb/gadget/configfs.c | 517 +++++++++++++++++++++++++++++++++++++++++
drivers/usb/gadget/udc-core.c | 24 ++
include/linux/usb/gadget.h | 5 +
4 files changed, 549 insertions(+), 2 deletions(-)
create mode 100644 drivers/usb/gadget/configfs.c
diff --git a/drivers/usb/gadget/Makefile b/drivers/usb/gadget/Makefile
index 97a13c3..8171093 100644
--- a/drivers/usb/gadget/Makefile
+++ b/drivers/usb/gadget/Makefile
@@ -3,10 +3,11 @@
#
ccflags-$(CONFIG_USB_GADGET_DEBUG) := -DDEBUG
-obj-$(CONFIG_USB_GADGET) += udc-core.o
+obj-$(CONFIG_USB_GADGET) += udc.o
+udc-y += udc-core.o configfs.o functions.o
obj-$(CONFIG_USB_LIBCOMPOSITE) += libcomposite.o
libcomposite-y := usbstring.o config.o epautoconf.o
-libcomposite-y += composite.o functions.o
+libcomposite-y += composite.o
obj-$(CONFIG_USB_DUMMY_HCD) += dummy_hcd.o
obj-$(CONFIG_USB_NET2272) += net2272.o
obj-$(CONFIG_USB_NET2280) += net2280.o
diff --git a/drivers/usb/gadget/configfs.c b/drivers/usb/gadget/configfs.c
new file mode 100644
index 0000000..8580ae5
--- /dev/null
+++ b/drivers/usb/gadget/configfs.c
@@ -0,0 +1,517 @@
+#include <linux/configfs.h>
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/device.h>
+#include <linux/usb/composite.h>
+
+#define MAX_NAME_LEN 40
+
+static struct config_group *gadget_core_make(
+ struct config_group *group,
+ const char *name)
+{
+ pr_err("%s() %s\n", __func__, name);
+ return ERR_PTR(-EINVAL);
+}
+
+static void gadget_core_drop(
+ struct config_group *group,
+ struct config_item *item)
+{
+ pr_err("%s()\n", __func__);
+}
+
+static struct configfs_group_operations gadget_core_group_ops = {
+ .make_group = &gadget_core_make,
+ .drop_item = &gadget_core_drop,
+};
+
+static struct config_item_type gadget_core_type = {
+ .ct_group_ops = &gadget_core_group_ops,
+ .ct_owner = THIS_MODULE,
+};
+
+static struct config_item_type udc_type = {
+ .ct_owner = THIS_MODULE,
+};
+
+static struct config_group udc_group = {
+ .cg_item = {
+ .ci_namebuf = "udcs",
+ .ci_type = &udc_type,
+ },
+};
+
+struct gadget_info {
+ struct config_group group;
+ struct usb_device_descriptor device_desc;
+ char *sManufacturer;
+ char *sProduct;
+ char *sSerialNumber;
+
+ struct usb_composite_driver driver;
+#ifdef CONFIG_USB_OTG
+ struct usb_otg_descriptor otg;
+#endif
+ struct usb_composite_driver composite;
+ struct usb_composite_dev cdev;
+};
+
+struct config_usb_cfg {
+ struct config_group group;
+ struct usb_configuration c;
+};
+
+CONFIGFS_ATTR_STRUCT(gadget_info);
+
+#define GI_DEVICE_DESC_ITEM_ATTR(name) \
+ static struct gadget_info_attribute gadget_device_desc_##name = \
+ __CONFIGFS_ATTR(name, S_IRUGO | S_IWUSR, \
+ gadget_dev_desc_##name##_show, \
+ gadget_dev_desc_##name##_store)
+
+#define GI_DEVICE_DESC_SIMPLE_R_u8(__name) \
+ static ssize_t gadget_dev_desc_##__name##_show(struct gadget_info *gi,
char *page) \
+{ \
+ return sprintf(page, "0x%02x\n", gi->device_desc.__name); \
+}
+
+#define GI_DEVICE_DESC_SIMPLE_R_u16(__name) \
+ static ssize_t gadget_dev_desc_##__name##_show(struct gadget_info *gi,
char *page) \
+{ \
+ return sprintf(page, "0x%04x\n",
le16_to_cpup(&gi->device_desc.__name)); \
+}
+
+#define GI_DEVICE_DESC_SIMPLE_R_charp(__name) \
+ static ssize_t gadget_dev_desc_##__name##_show(struct gadget_info *gi,
char *page) \
+{ \
+ return sprintf(page, "%s\n", gi->__name); \
+}
+
+#define GI_DEVICE_DESC_SIMPLE_W_u8(_name) \
+ static ssize_t gadget_dev_desc_##_name##_store(struct gadget_info *gi, \
+ const char *page, size_t len) \
+{ \
+ u8 val; \
+ int ret; \
+ ret = kstrtou8(page, 0, &val); \
+ if (ret) \
+ return ret; \
+ gi->device_desc._name = val; \
+ return len; \
+}
+
+#define GI_DEVICE_DESC_SIMPLE_W_u16(_name) \
+ static ssize_t gadget_dev_desc_##_name##_store(struct gadget_info *gi, \
+ const char *page, size_t len) \
+{ \
+ u16 val; \
+ int ret; \
+ ret = kstrtou16(page, 0, &val); \
+ if (ret) \
+ return ret; \
+ gi->device_desc._name = cpu_to_le16p(&val); \
+ return len; \
+}
+
+#define GI_DEVICE_DESC_SIMPLE_W_charp(_name) \
+ static ssize_t gadget_dev_desc_##_name##_store(struct gadget_info *gi, \
+ const char *page, size_t len) \
+{ \
+ int ret; \
+ char *str; \
+ \
+ ret = strlen(page); \
+ if (ret > 126) \
+ return -EOVERFLOW; \
+ str = kstrdup(page, GFP_KERNEL); \
+ if (!str) \
+ return -ENOMEM; \
+ if (str[ret - 1] == '\n') \
+ str[ret - 1] = '\0'; \
+ kfree(gi->_name); \
+ gi->_name = str; \
+ 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_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(bcdUSB);
+
+static ssize_t gadget_dev_desc_bcdUSB_store(struct gadget_info *gi,
+ const char *page, size_t len)
+{
+ u16 bcdUSB;
+ int ret;
+
+ ret = kstrtou16(page, 0, &bcdUSB);
+ if (ret)
+ return ret;
+ if ((bcdUSB & 0xf) > 9)
+ return -EINVAL;
+ if (((bcdUSB >> 4) & 0xf) > 9)
+ return -EINVAL;
+ if (((bcdUSB >> 8) & 0xf) > 9)
+ return -EINVAL;
+ if (((bcdUSB >> 12) & 0xf) > 9)
+ return -EINVAL;
+
+ gi->device_desc.bcdUSB = cpu_to_le16(bcdUSB);
+ return len;
+}
+
+GI_DEVICE_DESC_SIMPLE_RW(sManufacturer, charp);
+GI_DEVICE_DESC_SIMPLE_RW(sProduct, charp);
+GI_DEVICE_DESC_SIMPLE_RW(sSerialNumber, charp);
+
+GI_DEVICE_DESC_ITEM_ATTR(bDeviceClass);
+GI_DEVICE_DESC_ITEM_ATTR(bDeviceSubClass);
+GI_DEVICE_DESC_ITEM_ATTR(bDeviceProtocol);
+GI_DEVICE_DESC_ITEM_ATTR(bMaxPacketSize0);
+GI_DEVICE_DESC_ITEM_ATTR(idVendor);
+GI_DEVICE_DESC_ITEM_ATTR(idProduct);
+GI_DEVICE_DESC_ITEM_ATTR(bcdUSB);
+GI_DEVICE_DESC_ITEM_ATTR(sManufacturer);
+GI_DEVICE_DESC_ITEM_ATTR(sProduct);
+GI_DEVICE_DESC_ITEM_ATTR(sSerialNumber);
+
+static struct configfs_attribute *gadget_root_attrs[] = {
+ &gadget_device_desc_bDeviceClass.attr,
+ &gadget_device_desc_bDeviceSubClass.attr,
+ &gadget_device_desc_bDeviceProtocol.attr,
+ &gadget_device_desc_bMaxPacketSize0.attr,
+ &gadget_device_desc_idVendor.attr,
+ &gadget_device_desc_idProduct.attr,
+ &gadget_device_desc_bcdUSB.attr,
+ &gadget_device_desc_sManufacturer.attr,
+ &gadget_device_desc_sProduct.attr,
+ &gadget_device_desc_sSerialNumber.attr,
+ NULL,
+};
+
+
+static inline struct gadget_info *to_gadget_info(struct config_item *item)
+{
+ return container_of(to_config_group(item), struct gadget_info, group);
+}
+
+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);
+}
+
+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));
+
+ kfree(gi->sManufacturer);
+ kfree(gi->sProduct);
+ kfree(gi->sSerialNumber);
+ kfree(gi);
+}
+
+CONFIGFS_ATTR_OPS(gadget_info);
+
+static struct configfs_item_operations gadget_root_item_ops = {
+ .release = gadget_info_attr_release,
+ .show_attribute = gadget_info_attr_show,
+ .store_attribute = gadget_info_attr_store,
+};
+
+static void gadget_config_drop(struct config_group *group, struct config_item
*item)
+{
+ config_item_put(item);
+}
+
+static void gadget_config_attr_release(struct config_item *item)
+{
+ struct config_usb_cfg *cfg = to_config_usb_cfg(item);
+
+ kfree(cfg->c.label);
+ list_del(&cfg->c.list);
+ kfree(cfg);
+}
+
+static struct configfs_item_operations gadget_config_item_ops = {
+ .release = gadget_config_attr_release,
+// .show_attribute = gadget_config_attr_show,
+// .store_attribute = gadget_config_attr_store,
+};
+
+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_group *gadget_config_make(
+ struct config_group *group,
+ const char *name)
+{
+ struct gadget_info *gi = container_of(group, struct gadget_info, group);
+ struct usb_configuration *c;
+ struct config_usb_cfg *cfg;
+ char buf[MAX_NAME_LEN];
+ char *num_str;
+ u8 num;
+ int ret;
+
+ 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);
+
+ if (!num)
+ return ERR_PTR(-EINVAL);
+
+ list_for_each_entry(c, &gi->cdev.configs, list) {
+ if (c->bConfigurationValue == num)
+ return ERR_PTR(-EEXIST);
+ }
+
+ cfg = kzalloc(sizeof(*cfg), GFP_KERNEL);
+ if (!cfg)
+ return ERR_PTR(-ENOMEM);
+ cfg->c.label = kstrdup(buf, GFP_KERNEL);
+ if (!cfg->c.label)
+ goto err;
+ cfg->c.bConfigurationValue = num;
+
+ config_group_init_type_name(&cfg->group, name,
+ &gadget_config_type);
+
+ list_add_tail(&cfg->c.list, &gi->cdev.configs);
+
+ return &cfg->group;
+err:
+ kfree(cfg);
+ return ERR_PTR(-ENOMEM);
+}
+
+static struct configfs_group_operations gadget_root_groups_ops = {
+ .make_group = &gadget_config_make,
+ .drop_item = &gadget_config_drop,
+};
+
+static struct config_item_type gadget_root_type = {
+ .ct_item_ops = &gadget_root_item_ops,
+ .ct_group_ops = &gadget_root_groups_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);
+}
+
+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);
+
+ gi->device_desc.bLength = USB_DT_DEVICE_SIZE;
+ gi->device_desc.bDescriptorType = USB_DT_DEVICE;
+
+ gi->driver.dev = &gi->device_desc;
+ gi->driver.bind = NULL;
+ gi->driver.unbind = NULL;
+ gi->driver.suspend = NULL;
+ gi->driver.resume = NULL;
+ gi->driver.max_speed = USB_SPEED_SUPER;
+
+ composite_init_dev(&gi->cdev);
+ /* gi->composite.gadget_driver = composite_driver_template; */
+
+#ifdef CONFIG_USB_OTG
+ gi->otg.bLength = sizeof(struct usb_otg_descriptor);
+ gi->otg.bDescriptorType = USB_DT_OTG;
+ gi->otg.bmAttributes = USB_OTG_SRP | USB_OTG_HNP;
+#endif
+
+ config_group_init_type_name(&gi->group, name,
+ &gadget_root_type);
+ return &gi->group;
+}
+
+static void gadgets_drop(struct config_group *group, struct config_item *item)
+{
+ config_item_put(item);
+}
+
+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 config_group gadget_group = {
+ .cg_item = {
+ .ci_namebuf = "gadgets",
+ .ci_type = &gadgets_type,
+ },
+};
+
+static struct config_group *function_make(
+ struct config_group *group,
+ const char *name)
+{
+ struct usb_function *f;
+ 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)
+ 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++;
+
+ pr_err("%s() try to get %s for %s\n", __func__, func_name,
instance_name);
+ f = usb_get_function(func_name);
+ usb_put_function(f);
+ pr_err("%s() %s\n", __func__,
+ IS_ERR(f) ? "failed" : "good");
+ return ERR_PTR(-EINVAL);
+}
+
+static void function_drop(
+ struct config_group *group,
+ struct config_item *item)
+{
+ pr_err("%s()\n", __func__);
+}
+
+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,
+};
+
+static struct config_group func_group = {
+ .cg_item = {
+ .ci_namebuf = "functions",
+ .ci_type = &functions_type,
+ },
+};
+
+static struct config_group *root_groups[] = {
+ &func_group,
+ &gadget_group,
+ &udc_group,
+ NULL
+};
+
+static struct configfs_subsystem gadget_subsys = {
+ .su_group = {
+ .cg_item = {
+ .ci_namebuf = "usb_gadget",
+ .ci_type = &gadget_core_type,
+ },
+ .default_groups = root_groups,
+ },
+ .su_mutex = __MUTEX_INITIALIZER(gadget_subsys.su_mutex),
+};
+
+struct udc_configfs {
+ struct config_group group;
+};
+
+struct config_group *udc_add_configfs(struct device *dev)
+{
+ struct udc_configfs *udc_cfs;
+ struct config_group *group;
+ int ret;
+
+ udc_cfs = kzalloc(sizeof(struct udc_configfs), GFP_KERNEL);
+ if (!udc_cfs)
+ return ERR_PTR(-ENOMEM);
+
+ group = &udc_cfs->group;
+ config_group_init_type_name(group,
+ kobject_name(&dev->kobj),
+ &gadget_core_type);
+ ret = configfs_create_group(&udc_group, group);
+ if (ret)
+ goto err;
+ return group;
+err:
+ kfree(udc_cfs);
+ return ERR_PTR(ret);
+}
+
+void udc_del_configfs(struct config_group *group)
+{
+ struct udc_configfs *udc_cfs;
+
+ udc_cfs = container_of(group, struct udc_configfs, group);
+
+ configfs_remove_group(group);
+ kfree(udc_cfs);
+}
+
+int __init gadget_cfs_init(void)
+{
+ int ret;
+
+ config_group_init(&gadget_subsys.su_group);
+ config_group_init(&func_group);
+ config_group_init(&gadget_group);
+ config_group_init(&udc_group);
+
+ ret = configfs_register_subsystem(&gadget_subsys);
+ return ret;
+}
+
+void __exit gadget_cfs_exit(void)
+{
+ configfs_unregister_subsystem(&gadget_subsys);
+}
diff --git a/drivers/usb/gadget/udc-core.c b/drivers/usb/gadget/udc-core.c
index 4d90a80..48ca094 100644
--- a/drivers/usb/gadget/udc-core.c
+++ b/drivers/usb/gadget/udc-core.c
@@ -26,6 +26,7 @@
#include <linux/usb/ch9.h>
#include <linux/usb/gadget.h>
+#include <linux/configfs.h>
/**
* struct usb_udc - describes one usb device controller
@@ -42,6 +43,7 @@ struct usb_udc {
struct usb_gadget *gadget;
struct device dev;
struct list_head list;
+ struct config_group *group;
};
static struct class *udc_class;
@@ -231,6 +233,7 @@ int usb_add_gadget_udc(struct device *parent, struct
usb_gadget *gadget)
if (ret)
goto err3;
+ udc->group = udc_add_configfs(&udc->dev);
mutex_unlock(&udc_lock);
return 0;
@@ -305,6 +308,7 @@ void usb_del_gadget_udc(struct usb_gadget *gadget)
usb_gadget_remove_driver(udc);
kobject_uevent(&udc->dev.kobj, KOBJ_REMOVE);
+ udc_del_configfs(udc->group);
device_unregister(&udc->dev);
}
EXPORT_SYMBOL_GPL(usb_del_gadget_udc);
@@ -504,6 +508,8 @@ static int usb_udc_uevent(struct device *dev, struct
kobj_uevent_env *env)
static int __init usb_udc_init(void)
{
+ int ret __maybe_unused;
+
udc_class = class_create(THIS_MODULE, "udc");
if (IS_ERR(udc_class)) {
pr_err("failed to create udc class --> %ld\n",
@@ -512,12 +518,30 @@ static int __init usb_udc_init(void)
}
udc_class->dev_uevent = usb_udc_uevent;
+#ifdef MODULE
+ ret = gadget_cfs_init();
+ if (ret)
+ class_destroy(udc_class);
+ return ret;
+#else
return 0;
+#endif
}
subsys_initcall(usb_udc_init);
+#ifndef MODULE
+static int __init usb_udc_init_mod(void)
+{
+ if (IS_ERR(udc_class))
+ return PTR_ERR(udc_class);
+ return gadget_cfs_init();
+}
+module_init(usb_udc_init_mod);
+#endif
+
static void __exit usb_udc_exit(void)
{
+ gadget_cfs_exit();
class_destroy(udc_class);
}
module_exit(usb_udc_exit);
diff --git a/include/linux/usb/gadget.h b/include/linux/usb/gadget.h
index 0af6569..6f5fe20 100644
--- a/include/linux/usb/gadget.h
+++ b/include/linux/usb/gadget.h
@@ -883,6 +883,11 @@ extern void usb_del_gadget_udc(struct usb_gadget *gadget);
/*-------------------------------------------------------------------------*/
+struct config_group *udc_add_configfs(struct device *dev);
+void udc_del_configfs(struct config_group *group);
+int gadget_cfs_init(void);
+void __exit gadget_cfs_exit(void);
+
/* utility to simplify dealing with string descriptors */
/**
--
1.7.10.4
--
To unsubscribe from this list: send the line "unsubscribe linux-usb" in
the body of a message to majord...@vger.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
