![Constantine Shulyupin](/assets/img/avatar_default.png)
Previous names of init and exit functions "init" and "cleanup" are unconventional and are not friendly for source navigation with tags. New names "ccg_init" and "ccg_exit" are conveninal and source navigation friendly. Signed-off-by: Constantine Shulyupin <const@MakeLinux.com> Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
1293 lines
30 KiB
C
1293 lines
30 KiB
C
/*
|
|
* Configurable Composite Gadget
|
|
*
|
|
* Initially contributed as "Android Composite Gdaget" by:
|
|
*
|
|
* Copyright (C) 2008 Google, Inc.
|
|
* Author: Mike Lockwood <lockwood@android.com>
|
|
* Benoit Goby <benoit@android.com>
|
|
*
|
|
* Tailoring it to become a generic Configurable Composite Gadget is
|
|
*
|
|
* Copyright (C) 2012 Samsung Electronics
|
|
* Author: Andrzej Pietrasiewicz <andrzej.p@samsung.com>
|
|
*
|
|
* This software is licensed under the terms of the GNU General Public
|
|
* License version 2, as published by the Free Software Foundation, and
|
|
* may be copied, distributed, and modified under those terms.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
*/
|
|
|
|
#include <linux/init.h>
|
|
#include <linux/module.h>
|
|
#include <linux/fs.h>
|
|
#include <linux/delay.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/utsname.h>
|
|
#include <linux/platform_device.h>
|
|
|
|
#include <linux/usb/ch9.h>
|
|
#include "composite.h"
|
|
#include <linux/usb/gadget.h>
|
|
|
|
#include "gadget_chips.h"
|
|
|
|
/*
|
|
* Kbuild is not very cooperative with respect to linking separately
|
|
* compiled library objects into one module. So for now we won't use
|
|
* separate compilation ... ensuring init/exit sections work to shrink
|
|
* the runtime footprint, and giving us at least some parts of what
|
|
* a "gcc --combine ... part1.c part2.c part3.c ... " build would.
|
|
*/
|
|
#include "usbstring.c"
|
|
#include "config.c"
|
|
#include "epautoconf.c"
|
|
#include "composite.c"
|
|
|
|
#include "f_mass_storage.c"
|
|
#include "u_serial.c"
|
|
#include "f_acm.c"
|
|
#define USB_ETH_RNDIS y
|
|
#include "f_rndis.c"
|
|
#include "rndis.c"
|
|
#include "u_ether.c"
|
|
#include "f_fs.c"
|
|
|
|
MODULE_AUTHOR("Mike Lockwood, Andrzej Pietrasiewicz");
|
|
MODULE_DESCRIPTION("Configurable Composite USB Gadget");
|
|
MODULE_LICENSE("GPL");
|
|
MODULE_VERSION("1.0");
|
|
|
|
static const char longname[] = "Configurable Composite Gadget";
|
|
|
|
/* Default vendor and product IDs, overridden by userspace */
|
|
#define VENDOR_ID 0x1d6b /* Linux Foundation */
|
|
#define PRODUCT_ID 0x0107
|
|
#define GFS_MAX_DEVS 10
|
|
|
|
struct ccg_usb_function {
|
|
char *name;
|
|
void *config;
|
|
|
|
struct device *dev;
|
|
char *dev_name;
|
|
struct device_attribute **attributes;
|
|
|
|
/* for ccg_dev.enabled_functions */
|
|
struct list_head enabled_list;
|
|
|
|
/* Optional: initialization during gadget bind */
|
|
int (*init)(struct ccg_usb_function *, struct usb_composite_dev *);
|
|
/* Optional: cleanup during gadget unbind */
|
|
void (*cleanup)(struct ccg_usb_function *);
|
|
|
|
int (*bind_config)(struct ccg_usb_function *,
|
|
struct usb_configuration *);
|
|
|
|
/* Optional: called when the configuration is removed */
|
|
void (*unbind_config)(struct ccg_usb_function *,
|
|
struct usb_configuration *);
|
|
/* Optional: handle ctrl requests before the device is configured */
|
|
int (*ctrlrequest)(struct ccg_usb_function *,
|
|
struct usb_composite_dev *,
|
|
const struct usb_ctrlrequest *);
|
|
};
|
|
|
|
struct ffs_obj {
|
|
const char *name;
|
|
bool mounted;
|
|
bool desc_ready;
|
|
bool used;
|
|
struct ffs_data *ffs_data;
|
|
};
|
|
|
|
struct ccg_dev {
|
|
struct ccg_usb_function **functions;
|
|
struct list_head enabled_functions;
|
|
struct usb_composite_dev *cdev;
|
|
struct device *dev;
|
|
|
|
bool enabled;
|
|
struct mutex mutex;
|
|
bool connected;
|
|
bool sw_connected;
|
|
struct work_struct work;
|
|
|
|
unsigned int max_func_num;
|
|
unsigned int func_num;
|
|
struct ffs_obj ffs_tab[GFS_MAX_DEVS];
|
|
};
|
|
|
|
static struct class *ccg_class;
|
|
static struct ccg_dev *_ccg_dev;
|
|
static int ccg_bind_config(struct usb_configuration *c);
|
|
static void ccg_unbind_config(struct usb_configuration *c);
|
|
|
|
static char func_names_buf[256];
|
|
|
|
static struct usb_device_descriptor device_desc = {
|
|
.bLength = sizeof(device_desc),
|
|
.bDescriptorType = USB_DT_DEVICE,
|
|
.bcdUSB = __constant_cpu_to_le16(0x0200),
|
|
.bDeviceClass = USB_CLASS_PER_INTERFACE,
|
|
.idVendor = __constant_cpu_to_le16(VENDOR_ID),
|
|
.idProduct = __constant_cpu_to_le16(PRODUCT_ID),
|
|
.bcdDevice = __constant_cpu_to_le16(0xffff),
|
|
.bNumConfigurations = 1,
|
|
};
|
|
|
|
static struct usb_configuration ccg_config_driver = {
|
|
.label = "ccg",
|
|
.unbind = ccg_unbind_config,
|
|
.bConfigurationValue = 1,
|
|
.bmAttributes = USB_CONFIG_ATT_ONE | USB_CONFIG_ATT_SELFPOWER,
|
|
.bMaxPower = 0xFA, /* 500ma */
|
|
};
|
|
|
|
static void ccg_work(struct work_struct *data)
|
|
{
|
|
struct ccg_dev *dev = container_of(data, struct ccg_dev, work);
|
|
struct usb_composite_dev *cdev = dev->cdev;
|
|
static char *disconnected[2] = { "USB_STATE=DISCONNECTED", NULL };
|
|
static char *connected[2] = { "USB_STATE=CONNECTED", NULL };
|
|
static char *configured[2] = { "USB_STATE=CONFIGURED", NULL };
|
|
char **uevent_envp = NULL;
|
|
unsigned long flags;
|
|
|
|
spin_lock_irqsave(&cdev->lock, flags);
|
|
if (cdev->config)
|
|
uevent_envp = configured;
|
|
else if (dev->connected != dev->sw_connected)
|
|
uevent_envp = dev->connected ? connected : disconnected;
|
|
dev->sw_connected = dev->connected;
|
|
spin_unlock_irqrestore(&cdev->lock, flags);
|
|
|
|
if (uevent_envp) {
|
|
kobject_uevent_env(&dev->dev->kobj, KOBJ_CHANGE, uevent_envp);
|
|
pr_info("%s: sent uevent %s\n", __func__, uevent_envp[0]);
|
|
} else {
|
|
pr_info("%s: did not send uevent (%d %d %p)\n", __func__,
|
|
dev->connected, dev->sw_connected, cdev->config);
|
|
}
|
|
}
|
|
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
/* Supported functions initialization */
|
|
|
|
static struct ffs_obj *functionfs_find_dev(struct ccg_dev *dev,
|
|
const char *dev_name)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < dev->max_func_num; i++)
|
|
if (strcmp(dev->ffs_tab[i].name, dev_name) == 0)
|
|
return &dev->ffs_tab[i];
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static bool functionfs_all_ready(struct ccg_dev *dev)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < dev->max_func_num; i++)
|
|
if (dev->ffs_tab[i].used && !dev->ffs_tab[i].desc_ready)
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
static int functionfs_ready_callback(struct ffs_data *ffs)
|
|
{
|
|
struct ffs_obj *ffs_obj;
|
|
int ret;
|
|
|
|
mutex_lock(&_ccg_dev->mutex);
|
|
|
|
ffs_obj = ffs->private_data;
|
|
if (!ffs_obj) {
|
|
ret = -EINVAL;
|
|
goto done;
|
|
}
|
|
if (WARN_ON(ffs_obj->desc_ready)) {
|
|
ret = -EBUSY;
|
|
goto done;
|
|
}
|
|
ffs_obj->ffs_data = ffs;
|
|
|
|
if (functionfs_all_ready(_ccg_dev)) {
|
|
ret = -EBUSY;
|
|
goto done;
|
|
}
|
|
ffs_obj->desc_ready = true;
|
|
|
|
done:
|
|
mutex_unlock(&_ccg_dev->mutex);
|
|
return ret;
|
|
}
|
|
|
|
static void reset_usb(struct ccg_dev *dev)
|
|
{
|
|
/* Cancel pending control requests */
|
|
usb_ep_dequeue(dev->cdev->gadget->ep0, dev->cdev->req);
|
|
usb_remove_config(dev->cdev, &ccg_config_driver);
|
|
dev->enabled = false;
|
|
usb_gadget_disconnect(dev->cdev->gadget);
|
|
}
|
|
|
|
static void functionfs_closed_callback(struct ffs_data *ffs)
|
|
{
|
|
struct ffs_obj *ffs_obj;
|
|
|
|
mutex_lock(&_ccg_dev->mutex);
|
|
|
|
ffs_obj = ffs->private_data;
|
|
if (!ffs_obj)
|
|
goto done;
|
|
|
|
ffs_obj->desc_ready = false;
|
|
|
|
if (_ccg_dev->enabled)
|
|
reset_usb(_ccg_dev);
|
|
|
|
done:
|
|
mutex_unlock(&_ccg_dev->mutex);
|
|
}
|
|
|
|
static void *functionfs_acquire_dev_callback(const char *dev_name)
|
|
{
|
|
struct ffs_obj *ffs_dev;
|
|
|
|
mutex_lock(&_ccg_dev->mutex);
|
|
|
|
ffs_dev = functionfs_find_dev(_ccg_dev, dev_name);
|
|
if (!ffs_dev) {
|
|
ffs_dev = ERR_PTR(-ENODEV);
|
|
goto done;
|
|
}
|
|
|
|
if (ffs_dev->mounted) {
|
|
ffs_dev = ERR_PTR(-EBUSY);
|
|
goto done;
|
|
}
|
|
ffs_dev->mounted = true;
|
|
|
|
done:
|
|
mutex_unlock(&_ccg_dev->mutex);
|
|
return ffs_dev;
|
|
}
|
|
|
|
static void functionfs_release_dev_callback(struct ffs_data *ffs_data)
|
|
{
|
|
struct ffs_obj *ffs_dev;
|
|
|
|
mutex_lock(&_ccg_dev->mutex);
|
|
|
|
ffs_dev = ffs_data->private_data;
|
|
if (ffs_dev)
|
|
ffs_dev->mounted = false;
|
|
|
|
mutex_unlock(&_ccg_dev->mutex);
|
|
}
|
|
|
|
static int functionfs_function_init(struct ccg_usb_function *f,
|
|
struct usb_composite_dev *cdev)
|
|
{
|
|
return functionfs_init();
|
|
}
|
|
|
|
static void functionfs_function_cleanup(struct ccg_usb_function *f)
|
|
{
|
|
functionfs_cleanup();
|
|
}
|
|
|
|
static int functionfs_function_bind_config(struct ccg_usb_function *f,
|
|
struct usb_configuration *c)
|
|
{
|
|
struct ccg_dev *dev = _ccg_dev;
|
|
int i, ret;
|
|
|
|
for (i = dev->max_func_num; i--; ) {
|
|
if (!dev->ffs_tab[i].used)
|
|
continue;
|
|
ret = functionfs_bind(dev->ffs_tab[i].ffs_data, c->cdev);
|
|
if (unlikely(ret < 0)) {
|
|
while (++i < dev->max_func_num)
|
|
functionfs_unbind(dev->ffs_tab[i].ffs_data);
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
for (i = dev->max_func_num; i--; ) {
|
|
if (!dev->ffs_tab[i].used)
|
|
continue;
|
|
ret = functionfs_bind_config(c->cdev, c,
|
|
dev->ffs_tab[i].ffs_data);
|
|
if (unlikely(ret < 0))
|
|
return ret;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void functionfs_function_unbind_config(struct ccg_usb_function *f,
|
|
struct usb_configuration *c)
|
|
{
|
|
struct ccg_dev *dev = _ccg_dev;
|
|
int i;
|
|
|
|
for (i = dev->max_func_num; i--; )
|
|
if (dev->ffs_tab[i].ffs_data)
|
|
functionfs_unbind(dev->ffs_tab[i].ffs_data);
|
|
}
|
|
|
|
static ssize_t functionfs_user_functions_show(struct device *_dev,
|
|
struct device_attribute *attr,
|
|
char *buf)
|
|
{
|
|
struct ccg_dev *dev = _ccg_dev;
|
|
char *buff = buf;
|
|
int i;
|
|
|
|
mutex_lock(&dev->mutex);
|
|
|
|
for (i = 0; i < dev->max_func_num; i++)
|
|
buff += snprintf(buff, PAGE_SIZE + buf - buff, "%s,",
|
|
dev->ffs_tab[i].name);
|
|
|
|
mutex_unlock(&dev->mutex);
|
|
|
|
if (buff != buf)
|
|
*(buff - 1) = '\n';
|
|
return buff - buf;
|
|
}
|
|
|
|
static ssize_t functionfs_user_functions_store(struct device *_dev,
|
|
struct device_attribute *attr,
|
|
const char *buff, size_t size)
|
|
{
|
|
struct ccg_dev *dev = _ccg_dev;
|
|
char *name, *b;
|
|
ssize_t ret = size;
|
|
int i;
|
|
|
|
buff = skip_spaces(buff);
|
|
if (!*buff)
|
|
return -EINVAL;
|
|
|
|
mutex_lock(&dev->mutex);
|
|
|
|
if (dev->enabled) {
|
|
ret = -EBUSY;
|
|
goto end;
|
|
}
|
|
|
|
for (i = 0; i < dev->max_func_num; i++)
|
|
if (dev->ffs_tab[i].mounted) {
|
|
ret = -EBUSY;
|
|
goto end;
|
|
}
|
|
|
|
strlcpy(func_names_buf, buff, sizeof(func_names_buf));
|
|
b = strim(func_names_buf);
|
|
|
|
/* replace the list of functions */
|
|
dev->max_func_num = 0;
|
|
while (b) {
|
|
name = strsep(&b, ",");
|
|
if (dev->max_func_num == GFS_MAX_DEVS) {
|
|
ret = -ENOSPC;
|
|
goto end;
|
|
}
|
|
if (functionfs_find_dev(dev, name)) {
|
|
ret = -EEXIST;
|
|
continue;
|
|
}
|
|
dev->ffs_tab[dev->max_func_num++].name = name;
|
|
}
|
|
|
|
end:
|
|
mutex_unlock(&dev->mutex);
|
|
return ret;
|
|
}
|
|
|
|
static DEVICE_ATTR(user_functions, S_IRUGO | S_IWUSR,
|
|
functionfs_user_functions_show,
|
|
functionfs_user_functions_store);
|
|
|
|
static ssize_t functionfs_max_user_functions_show(struct device *_dev,
|
|
struct device_attribute *attr,
|
|
char *buf)
|
|
{
|
|
return sprintf(buf, "%d", GFS_MAX_DEVS);
|
|
}
|
|
|
|
static DEVICE_ATTR(max_user_functions, S_IRUGO,
|
|
functionfs_max_user_functions_show, NULL);
|
|
|
|
static struct device_attribute *functionfs_function_attributes[] = {
|
|
&dev_attr_user_functions,
|
|
&dev_attr_max_user_functions,
|
|
NULL
|
|
};
|
|
|
|
static struct ccg_usb_function functionfs_function = {
|
|
.name = "fs",
|
|
.init = functionfs_function_init,
|
|
.cleanup = functionfs_function_cleanup,
|
|
.bind_config = functionfs_function_bind_config,
|
|
.unbind_config = functionfs_function_unbind_config,
|
|
.attributes = functionfs_function_attributes,
|
|
};
|
|
|
|
#define MAX_ACM_INSTANCES 4
|
|
struct acm_function_config {
|
|
int instances;
|
|
};
|
|
|
|
static int
|
|
acm_function_init(struct ccg_usb_function *f, struct usb_composite_dev *cdev)
|
|
{
|
|
f->config = kzalloc(sizeof(struct acm_function_config), GFP_KERNEL);
|
|
if (!f->config)
|
|
return -ENOMEM;
|
|
|
|
return gserial_setup(cdev->gadget, MAX_ACM_INSTANCES);
|
|
}
|
|
|
|
static void acm_function_cleanup(struct ccg_usb_function *f)
|
|
{
|
|
gserial_cleanup();
|
|
kfree(f->config);
|
|
f->config = NULL;
|
|
}
|
|
|
|
static int
|
|
acm_function_bind_config(struct ccg_usb_function *f,
|
|
struct usb_configuration *c)
|
|
{
|
|
int i;
|
|
int ret = 0;
|
|
struct acm_function_config *config = f->config;
|
|
|
|
for (i = 0; i < config->instances; i++) {
|
|
ret = acm_bind_config(c, i);
|
|
if (ret) {
|
|
pr_err("Could not bind acm%u config\n", i);
|
|
break;
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
static ssize_t acm_instances_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
struct ccg_usb_function *f = dev_get_drvdata(dev);
|
|
struct acm_function_config *config = f->config;
|
|
return sprintf(buf, "%d\n", config->instances);
|
|
}
|
|
|
|
static ssize_t acm_instances_store(struct device *dev,
|
|
struct device_attribute *attr, const char *buf, size_t size)
|
|
{
|
|
struct ccg_usb_function *f = dev_get_drvdata(dev);
|
|
struct acm_function_config *config = f->config;
|
|
int value;
|
|
int ret = 0;
|
|
|
|
ret = kstrtoint(buf, 10, &value);
|
|
if (ret)
|
|
return ret;
|
|
|
|
if (value > MAX_ACM_INSTANCES)
|
|
return -EINVAL;
|
|
|
|
config->instances = value;
|
|
|
|
return size;
|
|
}
|
|
|
|
static DEVICE_ATTR(instances, S_IRUGO | S_IWUSR, acm_instances_show,
|
|
acm_instances_store);
|
|
static struct device_attribute *acm_function_attributes[] = {
|
|
&dev_attr_instances,
|
|
NULL
|
|
};
|
|
|
|
static struct ccg_usb_function acm_function = {
|
|
.name = "acm",
|
|
.init = acm_function_init,
|
|
.cleanup = acm_function_cleanup,
|
|
.bind_config = acm_function_bind_config,
|
|
.attributes = acm_function_attributes,
|
|
};
|
|
|
|
struct rndis_function_config {
|
|
u8 ethaddr[ETH_ALEN];
|
|
u32 vendorID;
|
|
char manufacturer[256];
|
|
/* "Wireless" RNDIS; auto-detected by Windows */
|
|
bool wceis;
|
|
};
|
|
|
|
static int rndis_function_init(struct ccg_usb_function *f,
|
|
struct usb_composite_dev *cdev)
|
|
{
|
|
f->config = kzalloc(sizeof(struct rndis_function_config), GFP_KERNEL);
|
|
if (!f->config)
|
|
return -ENOMEM;
|
|
return 0;
|
|
}
|
|
|
|
static void rndis_function_cleanup(struct ccg_usb_function *f)
|
|
{
|
|
kfree(f->config);
|
|
f->config = NULL;
|
|
}
|
|
|
|
static int rndis_function_bind_config(struct ccg_usb_function *f,
|
|
struct usb_configuration *c)
|
|
{
|
|
int ret;
|
|
struct rndis_function_config *rndis = f->config;
|
|
|
|
if (!rndis) {
|
|
pr_err("%s: rndis_pdata\n", __func__);
|
|
return -1;
|
|
}
|
|
|
|
pr_info("%s MAC: %pM\n", __func__, rndis->ethaddr);
|
|
|
|
ret = gether_setup_name(c->cdev->gadget, rndis->ethaddr, "rndis");
|
|
if (ret) {
|
|
pr_err("%s: gether_setup failed\n", __func__);
|
|
return ret;
|
|
}
|
|
|
|
if (rndis->wceis) {
|
|
/* "Wireless" RNDIS; auto-detected by Windows */
|
|
rndis_iad_descriptor.bFunctionClass =
|
|
USB_CLASS_WIRELESS_CONTROLLER;
|
|
rndis_iad_descriptor.bFunctionSubClass = 0x01;
|
|
rndis_iad_descriptor.bFunctionProtocol = 0x03;
|
|
rndis_control_intf.bInterfaceClass =
|
|
USB_CLASS_WIRELESS_CONTROLLER;
|
|
rndis_control_intf.bInterfaceSubClass = 0x01;
|
|
rndis_control_intf.bInterfaceProtocol = 0x03;
|
|
}
|
|
|
|
return rndis_bind_config_vendor(c, rndis->ethaddr, rndis->vendorID,
|
|
rndis->manufacturer);
|
|
}
|
|
|
|
static void rndis_function_unbind_config(struct ccg_usb_function *f,
|
|
struct usb_configuration *c)
|
|
{
|
|
gether_cleanup();
|
|
}
|
|
|
|
static ssize_t rndis_manufacturer_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
struct ccg_usb_function *f = dev_get_drvdata(dev);
|
|
struct rndis_function_config *config = f->config;
|
|
return sprintf(buf, "%s\n", config->manufacturer);
|
|
}
|
|
|
|
static ssize_t rndis_manufacturer_store(struct device *dev,
|
|
struct device_attribute *attr, const char *buf, size_t size)
|
|
{
|
|
struct ccg_usb_function *f = dev_get_drvdata(dev);
|
|
struct rndis_function_config *config = f->config;
|
|
|
|
if (size >= sizeof(config->manufacturer))
|
|
return -EINVAL;
|
|
memcpy(config->manufacturer, buf, size);
|
|
config->manufacturer[size] = 0;
|
|
|
|
return size;
|
|
}
|
|
|
|
static DEVICE_ATTR(manufacturer, S_IRUGO | S_IWUSR, rndis_manufacturer_show,
|
|
rndis_manufacturer_store);
|
|
|
|
static ssize_t rndis_wceis_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
struct ccg_usb_function *f = dev_get_drvdata(dev);
|
|
struct rndis_function_config *config = f->config;
|
|
return sprintf(buf, "%d\n", config->wceis);
|
|
}
|
|
|
|
static ssize_t rndis_wceis_store(struct device *dev,
|
|
struct device_attribute *attr, const char *buf, size_t size)
|
|
{
|
|
struct ccg_usb_function *f = dev_get_drvdata(dev);
|
|
struct rndis_function_config *config = f->config;
|
|
int value;
|
|
int ret;
|
|
|
|
ret = kstrtoint(buf, 10, &value);
|
|
if (ret)
|
|
return ret;
|
|
|
|
config->wceis = value;
|
|
|
|
return size;
|
|
}
|
|
|
|
static DEVICE_ATTR(wceis, S_IRUGO | S_IWUSR, rndis_wceis_show,
|
|
rndis_wceis_store);
|
|
|
|
static ssize_t rndis_ethaddr_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
struct ccg_usb_function *f = dev_get_drvdata(dev);
|
|
struct rndis_function_config *rndis = f->config;
|
|
return sprintf(buf, "%pM\n", rndis->ethaddr);
|
|
}
|
|
|
|
static ssize_t rndis_ethaddr_store(struct device *dev,
|
|
struct device_attribute *attr, const char *buf, size_t size)
|
|
{
|
|
struct ccg_usb_function *f = dev_get_drvdata(dev);
|
|
struct rndis_function_config *rndis = f->config;
|
|
unsigned char tmp[6];
|
|
|
|
if (sscanf(buf, "%hhx:%hhx:%hhx:%hhx:%hhx:%hhx",
|
|
tmp + 0, tmp + 1, tmp + 2, tmp + 3, tmp + 4, tmp + 5) !=
|
|
ETH_ALEN)
|
|
return -EINVAL;
|
|
|
|
memcpy(rndis->ethaddr, tmp, ETH_ALEN);
|
|
|
|
return ETH_ALEN;
|
|
|
|
}
|
|
|
|
static DEVICE_ATTR(ethaddr, S_IRUGO | S_IWUSR, rndis_ethaddr_show,
|
|
rndis_ethaddr_store);
|
|
|
|
static ssize_t rndis_vendorID_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
struct ccg_usb_function *f = dev_get_drvdata(dev);
|
|
struct rndis_function_config *config = f->config;
|
|
return sprintf(buf, "%04x\n", config->vendorID);
|
|
}
|
|
|
|
static ssize_t rndis_vendorID_store(struct device *dev,
|
|
struct device_attribute *attr, const char *buf, size_t size)
|
|
{
|
|
struct ccg_usb_function *f = dev_get_drvdata(dev);
|
|
struct rndis_function_config *config = f->config;
|
|
int value;
|
|
int ret;
|
|
|
|
ret = kstrtou32(buf, 16, &value);
|
|
if (ret)
|
|
return ret;
|
|
|
|
config->vendorID = value;
|
|
|
|
return size;
|
|
}
|
|
|
|
static DEVICE_ATTR(vendorID, S_IRUGO | S_IWUSR, rndis_vendorID_show,
|
|
rndis_vendorID_store);
|
|
|
|
static struct device_attribute *rndis_function_attributes[] = {
|
|
&dev_attr_manufacturer,
|
|
&dev_attr_wceis,
|
|
&dev_attr_ethaddr,
|
|
&dev_attr_vendorID,
|
|
NULL
|
|
};
|
|
|
|
static struct ccg_usb_function rndis_function = {
|
|
.name = "rndis",
|
|
.init = rndis_function_init,
|
|
.cleanup = rndis_function_cleanup,
|
|
.bind_config = rndis_function_bind_config,
|
|
.unbind_config = rndis_function_unbind_config,
|
|
.attributes = rndis_function_attributes,
|
|
};
|
|
|
|
static int mass_storage_function_init(struct ccg_usb_function *f,
|
|
struct usb_composite_dev *cdev)
|
|
{
|
|
struct fsg_config fsg;
|
|
struct fsg_common *common;
|
|
int err;
|
|
|
|
memset(&fsg, 0, sizeof(fsg));
|
|
fsg.nluns = 1;
|
|
fsg.luns[0].removable = 1;
|
|
fsg.vendor_name = iManufacturer;
|
|
fsg.product_name = iProduct;
|
|
|
|
common = fsg_common_init(NULL, cdev, &fsg);
|
|
if (IS_ERR(common))
|
|
return PTR_ERR(common);
|
|
|
|
err = sysfs_create_link(&f->dev->kobj,
|
|
&common->luns[0].dev.kobj,
|
|
"lun");
|
|
if (err) {
|
|
fsg_common_put(common);
|
|
return err;
|
|
}
|
|
|
|
f->config = common;
|
|
return 0;
|
|
}
|
|
|
|
static void mass_storage_function_cleanup(struct ccg_usb_function *f)
|
|
{
|
|
fsg_common_put(f->config);
|
|
f->config = NULL;
|
|
}
|
|
|
|
static int mass_storage_function_bind_config(struct ccg_usb_function *f,
|
|
struct usb_configuration *c)
|
|
{
|
|
struct fsg_common *common = f->config;
|
|
return fsg_bind_config(c->cdev, c, common);
|
|
}
|
|
|
|
static struct ccg_usb_function mass_storage_function = {
|
|
.name = "mass_storage",
|
|
.init = mass_storage_function_init,
|
|
.cleanup = mass_storage_function_cleanup,
|
|
.bind_config = mass_storage_function_bind_config,
|
|
};
|
|
|
|
static struct ccg_usb_function *supported_functions[] = {
|
|
&functionfs_function,
|
|
&acm_function,
|
|
&rndis_function,
|
|
&mass_storage_function,
|
|
NULL
|
|
};
|
|
|
|
|
|
static int ccg_init_functions(struct ccg_usb_function **functions,
|
|
struct usb_composite_dev *cdev)
|
|
{
|
|
struct ccg_dev *dev = _ccg_dev;
|
|
struct ccg_usb_function *f;
|
|
struct device_attribute **attrs;
|
|
struct device_attribute *attr;
|
|
int err;
|
|
int index = 0;
|
|
|
|
for (; (f = *functions++); index++) {
|
|
f->dev_name = kasprintf(GFP_KERNEL, "f_%s", f->name);
|
|
if (!f->dev_name) {
|
|
pr_err("%s: Failed to alloc name %s", __func__,
|
|
f->name);
|
|
err = -ENOMEM;
|
|
goto err_alloc;
|
|
}
|
|
f->dev = device_create(ccg_class, dev->dev,
|
|
MKDEV(0, index), f, f->dev_name);
|
|
if (IS_ERR(f->dev)) {
|
|
pr_err("%s: Failed to create dev %s", __func__,
|
|
f->dev_name);
|
|
err = PTR_ERR(f->dev);
|
|
f->dev = NULL;
|
|
goto err_create;
|
|
}
|
|
|
|
if (f->init) {
|
|
err = f->init(f, cdev);
|
|
if (err) {
|
|
pr_err("%s: Failed to init %s", __func__,
|
|
f->name);
|
|
goto err_out;
|
|
}
|
|
}
|
|
|
|
attrs = f->attributes;
|
|
if (attrs) {
|
|
while ((attr = *attrs++) && !err)
|
|
err = device_create_file(f->dev, attr);
|
|
}
|
|
if (err) {
|
|
pr_err("%s: Failed to create function %s attributes",
|
|
__func__, f->name);
|
|
goto err_uninit;
|
|
}
|
|
}
|
|
return 0;
|
|
|
|
err_uninit:
|
|
if (f->cleanup)
|
|
f->cleanup(f);
|
|
err_out:
|
|
device_destroy(ccg_class, f->dev->devt);
|
|
f->dev = NULL;
|
|
err_create:
|
|
kfree(f->dev_name);
|
|
err_alloc:
|
|
return err;
|
|
}
|
|
|
|
static void ccg_cleanup_functions(struct ccg_usb_function **functions)
|
|
{
|
|
struct ccg_usb_function *f;
|
|
|
|
while (*functions) {
|
|
f = *functions++;
|
|
|
|
if (f->dev) {
|
|
if (f->cleanup)
|
|
f->cleanup(f);
|
|
device_destroy(ccg_class, f->dev->devt);
|
|
kfree(f->dev_name);
|
|
}
|
|
}
|
|
}
|
|
|
|
static int ccg_bind_enabled_functions(struct ccg_dev *dev,
|
|
struct usb_configuration *c)
|
|
{
|
|
struct ccg_usb_function *f;
|
|
int ret;
|
|
|
|
list_for_each_entry(f, &dev->enabled_functions, enabled_list) {
|
|
ret = f->bind_config(f, c);
|
|
if (ret) {
|
|
pr_err("%s: %s failed", __func__, f->name);
|
|
return ret;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static void ccg_unbind_enabled_functions(struct ccg_dev *dev,
|
|
struct usb_configuration *c)
|
|
{
|
|
struct ccg_usb_function *f;
|
|
|
|
list_for_each_entry(f, &dev->enabled_functions, enabled_list)
|
|
if (f->unbind_config)
|
|
f->unbind_config(f, c);
|
|
}
|
|
|
|
static int ccg_enable_function(struct ccg_dev *dev, char *name)
|
|
{
|
|
struct ccg_usb_function **functions = dev->functions;
|
|
struct ccg_usb_function *f;
|
|
while ((f = *functions++)) {
|
|
if (!strcmp(name, f->name)) {
|
|
list_add_tail(&f->enabled_list,
|
|
&dev->enabled_functions);
|
|
return 0;
|
|
}
|
|
}
|
|
return -EINVAL;
|
|
}
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
/* /sys/class/ccg_usb/ccg%d/ interface */
|
|
|
|
static ssize_t
|
|
functions_show(struct device *pdev, struct device_attribute *attr, char *buf)
|
|
{
|
|
struct ccg_dev *dev = dev_get_drvdata(pdev);
|
|
struct ccg_usb_function *f;
|
|
char *buff = buf;
|
|
int i;
|
|
|
|
mutex_lock(&dev->mutex);
|
|
|
|
list_for_each_entry(f, &dev->enabled_functions, enabled_list)
|
|
buff += sprintf(buff, "%s,", f->name);
|
|
for (i = 0; i < dev->max_func_num; i++)
|
|
if (dev->ffs_tab[i].used)
|
|
buff += sprintf(buff, "%s", dev->ffs_tab[i].name);
|
|
|
|
mutex_unlock(&dev->mutex);
|
|
|
|
if (buff != buf)
|
|
*(buff-1) = '\n';
|
|
return buff - buf;
|
|
}
|
|
|
|
static ssize_t
|
|
functions_store(struct device *pdev, struct device_attribute *attr,
|
|
const char *buff, size_t size)
|
|
{
|
|
struct ccg_dev *dev = dev_get_drvdata(pdev);
|
|
char *name;
|
|
char buf[256], *b;
|
|
int err, i;
|
|
bool functionfs_enabled;
|
|
|
|
buff = skip_spaces(buff);
|
|
if (!*buff)
|
|
return -EINVAL;
|
|
|
|
mutex_lock(&dev->mutex);
|
|
|
|
if (dev->enabled) {
|
|
mutex_unlock(&dev->mutex);
|
|
return -EBUSY;
|
|
}
|
|
|
|
INIT_LIST_HEAD(&dev->enabled_functions);
|
|
functionfs_enabled = false;
|
|
for (i = 0; i < dev->max_func_num; i++)
|
|
dev->ffs_tab[i].used = false;
|
|
|
|
strlcpy(buf, buff, sizeof(buf));
|
|
b = strim(buf);
|
|
|
|
while (b) {
|
|
struct ffs_obj *user_func;
|
|
|
|
name = strsep(&b, ",");
|
|
/* handle FunctionFS implicitly */
|
|
if (!strcmp(name, functionfs_function.name)) {
|
|
pr_err("ccg_usb: Cannot explicitly enable '%s'", name);
|
|
continue;
|
|
}
|
|
user_func = functionfs_find_dev(dev, name);
|
|
if (user_func)
|
|
name = functionfs_function.name;
|
|
err = 0;
|
|
if (!user_func || !functionfs_enabled)
|
|
err = ccg_enable_function(dev, name);
|
|
if (err)
|
|
pr_err("ccg_usb: Cannot enable '%s'", name);
|
|
else if (user_func) {
|
|
user_func->used = true;
|
|
dev->func_num++;
|
|
functionfs_enabled = true;
|
|
}
|
|
}
|
|
|
|
mutex_unlock(&dev->mutex);
|
|
|
|
return size;
|
|
}
|
|
|
|
static ssize_t enable_show(struct device *pdev, struct device_attribute *attr,
|
|
char *buf)
|
|
{
|
|
struct ccg_dev *dev = dev_get_drvdata(pdev);
|
|
return sprintf(buf, "%d\n", dev->enabled);
|
|
}
|
|
|
|
static ssize_t enable_store(struct device *pdev, struct device_attribute *attr,
|
|
const char *buff, size_t size)
|
|
{
|
|
struct ccg_dev *dev = dev_get_drvdata(pdev);
|
|
struct usb_composite_dev *cdev = dev->cdev;
|
|
int enabled = 0;
|
|
|
|
mutex_lock(&dev->mutex);
|
|
sscanf(buff, "%d", &enabled);
|
|
if (enabled && dev->func_num && !functionfs_all_ready(dev)) {
|
|
mutex_unlock(&dev->mutex);
|
|
return -ENODEV;
|
|
}
|
|
|
|
if (enabled && !dev->enabled) {
|
|
int ret;
|
|
|
|
cdev->next_string_id = 0;
|
|
/*
|
|
* Update values in composite driver's copy of
|
|
* device descriptor.
|
|
*/
|
|
cdev->desc.bDeviceClass = device_desc.bDeviceClass;
|
|
cdev->desc.bDeviceSubClass = device_desc.bDeviceSubClass;
|
|
cdev->desc.bDeviceProtocol = device_desc.bDeviceProtocol;
|
|
cdev->desc.idVendor = idVendor;
|
|
cdev->desc.idProduct = idProduct;
|
|
cdev->desc.bcdDevice = bcdDevice;
|
|
|
|
usb_add_config(cdev, &ccg_config_driver, ccg_bind_config);
|
|
dev->enabled = true;
|
|
ret = usb_gadget_connect(cdev->gadget);
|
|
if (ret) {
|
|
dev->enabled = false;
|
|
usb_remove_config(cdev, &ccg_config_driver);
|
|
}
|
|
} else if (!enabled && dev->enabled) {
|
|
reset_usb(dev);
|
|
} else {
|
|
pr_err("ccg_usb: already %s\n",
|
|
dev->enabled ? "enabled" : "disabled");
|
|
}
|
|
|
|
mutex_unlock(&dev->mutex);
|
|
return size;
|
|
}
|
|
|
|
static ssize_t state_show(struct device *pdev, struct device_attribute *attr,
|
|
char *buf)
|
|
{
|
|
struct ccg_dev *dev = dev_get_drvdata(pdev);
|
|
struct usb_composite_dev *cdev = dev->cdev;
|
|
char *state = "DISCONNECTED";
|
|
unsigned long flags;
|
|
|
|
if (!cdev)
|
|
goto out;
|
|
|
|
spin_lock_irqsave(&cdev->lock, flags);
|
|
if (cdev->config)
|
|
state = "CONFIGURED";
|
|
else if (dev->connected)
|
|
state = "CONNECTED";
|
|
spin_unlock_irqrestore(&cdev->lock, flags);
|
|
out:
|
|
return sprintf(buf, "%s\n", state);
|
|
}
|
|
|
|
#define DESCRIPTOR_ATTR(field, format_string) \
|
|
static ssize_t \
|
|
field ## _show(struct device *dev, struct device_attribute *attr, \
|
|
char *buf) \
|
|
{ \
|
|
return sprintf(buf, format_string, device_desc.field); \
|
|
} \
|
|
static ssize_t \
|
|
field ## _store(struct device *dev, struct device_attribute *attr, \
|
|
const char *buf, size_t size) \
|
|
{ \
|
|
int value; \
|
|
if (sscanf(buf, format_string, &value) == 1) { \
|
|
device_desc.field = value; \
|
|
return size; \
|
|
} \
|
|
return -1; \
|
|
} \
|
|
static DEVICE_ATTR(field, S_IRUGO | S_IWUSR, field ## _show, field ## _store);
|
|
|
|
DESCRIPTOR_ATTR(bDeviceClass, "%d\n")
|
|
DESCRIPTOR_ATTR(bDeviceSubClass, "%d\n")
|
|
DESCRIPTOR_ATTR(bDeviceProtocol, "%d\n")
|
|
|
|
static DEVICE_ATTR(functions, S_IRUGO | S_IWUSR, functions_show,
|
|
functions_store);
|
|
static DEVICE_ATTR(enable, S_IRUGO | S_IWUSR, enable_show, enable_store);
|
|
static DEVICE_ATTR(state, S_IRUGO, state_show, NULL);
|
|
|
|
static struct device_attribute *ccg_usb_attributes[] = {
|
|
&dev_attr_bDeviceClass,
|
|
&dev_attr_bDeviceSubClass,
|
|
&dev_attr_bDeviceProtocol,
|
|
&dev_attr_functions,
|
|
&dev_attr_enable,
|
|
&dev_attr_state,
|
|
NULL
|
|
};
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
/* Composite driver */
|
|
|
|
static int ccg_bind_config(struct usb_configuration *c)
|
|
{
|
|
struct ccg_dev *dev = _ccg_dev;
|
|
return ccg_bind_enabled_functions(dev, c);
|
|
}
|
|
|
|
static void ccg_unbind_config(struct usb_configuration *c)
|
|
{
|
|
struct ccg_dev *dev = _ccg_dev;
|
|
|
|
ccg_unbind_enabled_functions(dev, c);
|
|
|
|
usb_ep_autoconfig_reset(dev->cdev->gadget);
|
|
}
|
|
|
|
static int ccg_bind(struct usb_composite_dev *cdev)
|
|
{
|
|
struct ccg_dev *dev = _ccg_dev;
|
|
struct usb_gadget *gadget = cdev->gadget;
|
|
int gcnum, ret;
|
|
|
|
/*
|
|
* Start disconnected. Userspace will connect the gadget once
|
|
* it is done configuring the functions.
|
|
*/
|
|
usb_gadget_disconnect(gadget);
|
|
|
|
ret = ccg_init_functions(dev->functions, cdev);
|
|
if (ret)
|
|
return ret;
|
|
|
|
gcnum = usb_gadget_controller_number(gadget);
|
|
if (gcnum >= 0)
|
|
device_desc.bcdDevice = cpu_to_le16(0x0200 + gcnum);
|
|
else {
|
|
pr_warn("%s: controller '%s' not recognized\n",
|
|
longname, gadget->name);
|
|
device_desc.bcdDevice = __constant_cpu_to_le16(0x9999);
|
|
}
|
|
|
|
usb_gadget_set_selfpowered(gadget);
|
|
dev->cdev = cdev;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int ccg_usb_unbind(struct usb_composite_dev *cdev)
|
|
{
|
|
struct ccg_dev *dev = _ccg_dev;
|
|
|
|
cancel_work_sync(&dev->work);
|
|
ccg_cleanup_functions(dev->functions);
|
|
return 0;
|
|
}
|
|
|
|
static struct usb_composite_driver ccg_usb_driver = {
|
|
.name = "configurable_usb",
|
|
.dev = &device_desc,
|
|
.bind = ccg_bind,
|
|
.unbind = ccg_usb_unbind,
|
|
.needs_serial = true,
|
|
.iManufacturer = "Linux Foundation",
|
|
.iProduct = longname,
|
|
.iSerialNumber = "1234567890123456",
|
|
};
|
|
|
|
static int ccg_setup(struct usb_gadget *gadget, const struct usb_ctrlrequest *c)
|
|
{
|
|
struct ccg_dev *dev = _ccg_dev;
|
|
struct usb_composite_dev *cdev = get_gadget_data(gadget);
|
|
struct usb_request *req = cdev->req;
|
|
struct ccg_usb_function *f;
|
|
int value = -EOPNOTSUPP;
|
|
unsigned long flags;
|
|
|
|
req->zero = 0;
|
|
req->complete = composite_setup_complete;
|
|
req->length = 0;
|
|
gadget->ep0->driver_data = cdev;
|
|
|
|
list_for_each_entry(f, &dev->enabled_functions, enabled_list) {
|
|
if (f->ctrlrequest) {
|
|
value = f->ctrlrequest(f, cdev, c);
|
|
if (value >= 0)
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (value < 0)
|
|
value = composite_setup(gadget, c);
|
|
|
|
spin_lock_irqsave(&cdev->lock, flags);
|
|
if (!dev->connected) {
|
|
dev->connected = 1;
|
|
schedule_work(&dev->work);
|
|
} else if (c->bRequest == USB_REQ_SET_CONFIGURATION &&
|
|
cdev->config) {
|
|
schedule_work(&dev->work);
|
|
}
|
|
spin_unlock_irqrestore(&cdev->lock, flags);
|
|
|
|
return value;
|
|
}
|
|
|
|
static void ccg_disconnect(struct usb_gadget *gadget)
|
|
{
|
|
struct ccg_dev *dev = _ccg_dev;
|
|
struct usb_composite_dev *cdev = get_gadget_data(gadget);
|
|
unsigned long flags;
|
|
|
|
composite_disconnect(gadget);
|
|
|
|
spin_lock_irqsave(&cdev->lock, flags);
|
|
dev->connected = 0;
|
|
schedule_work(&dev->work);
|
|
spin_unlock_irqrestore(&cdev->lock, flags);
|
|
}
|
|
|
|
static int ccg_create_device(struct ccg_dev *dev)
|
|
{
|
|
struct device_attribute **attrs = ccg_usb_attributes;
|
|
struct device_attribute *attr;
|
|
int err;
|
|
|
|
dev->dev = device_create(ccg_class, NULL, MKDEV(0, 0), NULL, "ccg0");
|
|
if (IS_ERR(dev->dev))
|
|
return PTR_ERR(dev->dev);
|
|
|
|
dev_set_drvdata(dev->dev, dev);
|
|
|
|
while ((attr = *attrs++)) {
|
|
err = device_create_file(dev->dev, attr);
|
|
if (err) {
|
|
device_destroy(ccg_class, dev->dev->devt);
|
|
return err;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
static int __init ccg_init(void)
|
|
{
|
|
struct ccg_dev *dev;
|
|
int err;
|
|
|
|
ccg_class = class_create(THIS_MODULE, "ccg_usb");
|
|
if (IS_ERR(ccg_class))
|
|
return PTR_ERR(ccg_class);
|
|
|
|
dev = kzalloc(sizeof(*dev), GFP_KERNEL);
|
|
if (!dev) {
|
|
class_destroy(ccg_class);
|
|
return -ENOMEM;
|
|
}
|
|
|
|
dev->functions = supported_functions;
|
|
INIT_LIST_HEAD(&dev->enabled_functions);
|
|
INIT_WORK(&dev->work, ccg_work);
|
|
mutex_init(&dev->mutex);
|
|
|
|
err = ccg_create_device(dev);
|
|
if (err) {
|
|
class_destroy(ccg_class);
|
|
kfree(dev);
|
|
return err;
|
|
}
|
|
|
|
_ccg_dev = dev;
|
|
|
|
/* Override composite driver functions */
|
|
composite_driver.setup = ccg_setup;
|
|
composite_driver.disconnect = ccg_disconnect;
|
|
|
|
err = usb_composite_probe(&ccg_usb_driver);
|
|
if (err) {
|
|
class_destroy(ccg_class);
|
|
kfree(dev);
|
|
}
|
|
|
|
return err;
|
|
}
|
|
module_init(ccg_init);
|
|
|
|
static void __exit ccg_exit(void)
|
|
{
|
|
usb_composite_unregister(&ccg_usb_driver);
|
|
class_destroy(ccg_class);
|
|
kfree(_ccg_dev);
|
|
_ccg_dev = NULL;
|
|
}
|
|
module_exit(ccg_exit);
|