tobi/M7350
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
f9cc65cfda
M7350/kernel/drivers/usb/gadget/android.c

3085 lines
78 KiB
C
Raw Normal View History

M7350v1_en_gpl
2024-09-09 08:52:07 +00:00
/*
* Gadget Driver for Android
*
* Copyright (C) 2008 Google, Inc.
* Author: Mike Lockwood <lockwood@android.com>
* Benoit Goby <benoit@android.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/pm_qos.h>
#include <linux/of.h>
#include <linux/usb/ch9.h>
#include <linux/usb/composite.h>
#include <linux/usb/gadget.h>
#include <linux/usb/android.h>
#include <mach/diag_dload.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_diag.c"
#include "f_qdss.c"
#include "f_rmnet_smd.c"
#include "f_rmnet_sdio.c"
#include "f_rmnet_smd_sdio.c"
#include "f_rmnet.c"
#include "f_gps.c"
#ifdef CONFIG_SND_PCM
#include "f_audio_source.c"
#endif
#include "f_mass_storage.c"
#include "u_serial.c"
#include "u_sdio.c"
#include "u_smd.c"
#include "u_bam.c"
#include "u_rmnet_ctrl_smd.c"
#include "u_rmnet_ctrl_qti.c"
#include "u_ctrl_hsic.c"
#include "u_data_hsic.c"
#include "u_ctrl_hsuart.c"
#include "u_data_hsuart.c"
#include "f_serial.c"
#include "f_acm.c"
#include "f_adb.c"
#include "f_ccid.c"
#include "f_mtp.c"
#include "f_accessory.c"
#define USB_ETH_RNDIS y
#include "f_rndis.c"
#include "rndis.c"
#include "f_qc_ecm.c"
#include "f_mbim.c"
#include "u_bam_data.c"
#include "f_ecm.c"
#include "f_qc_rndis.c"
#include "u_ether.c"
#include "u_qc_ether.c"
#ifdef CONFIG_TARGET_CORE
#include "f_tcm.c"
#endif
#ifdef CONFIG_SND_PCM
#include "u_uac1.c"
#include "f_uac1.c"
#endif
#include "f_ncm.c"
MODULE_AUTHOR("Mike Lockwood");
MODULE_DESCRIPTION("Android Composite USB Driver");
MODULE_LICENSE("GPL");
MODULE_VERSION("1.0");
static const char longname[] = "Gadget Android";
/* Default vendor and product IDs, overridden by userspace */
#define VENDOR_ID 0x18D1
#define PRODUCT_ID 0x0001
#define ANDROID_DEVICE_NODE_NAME_LENGTH 11
struct android_usb_function {
char *name;
void *config;
struct device *dev;
char *dev_name;
struct device_attribute **attributes;
struct android_dev *android_dev;
/* Optional: initialization during gadget bind */
int (*init)(struct android_usb_function *, struct usb_composite_dev *);
/* Optional: cleanup during gadget unbind */
void (*cleanup)(struct android_usb_function *);
/* Optional: called when the function is added the list of
* enabled functions */
void (*enable)(struct android_usb_function *);
/* Optional: called when it is removed */
void (*disable)(struct android_usb_function *);
int (*bind_config)(struct android_usb_function *,
struct usb_configuration *);
/* Optional: called when the configuration is removed */
void (*unbind_config)(struct android_usb_function *,
struct usb_configuration *);
/* Optional: handle ctrl requests before the device is configured */
int (*ctrlrequest)(struct android_usb_function *,
struct usb_composite_dev *,
const struct usb_ctrlrequest *);
};
struct android_usb_function_holder {
struct android_usb_function *f;
/* for android_conf.enabled_functions */
struct list_head enabled_list;
};
/**
* struct android_dev - represents android USB gadget device
* @name: device name.
* @functions: an array of all the supported USB function
* drivers that this gadget support but not necessarily
* added to one of the gadget configurations.
* @cdev: The internal composite device. Android gadget device
* is a composite device, such that it can support configurations
* with more than one function driver.
* @dev: The kernel device that represents this android device.
* @enabled: True if the android gadget is enabled, means all
* the configurations were set and all function drivers were
* bind and ready for USB enumeration.
* @disable_depth: Number of times the device was disabled, after
* symmetrical number of enables the device willl be enabled.
* Used for controlling ADB userspace disable/enable requests.
* @mutex: Internal mutex for protecting device member fields.
* @pdata: Platform data fetched from the kernel device platfrom data.
* @connected: True if got connect notification from the gadget UDC.
* False if got disconnect notification from the gadget UDC.
* @sw_connected: Equal to 'connected' only after the connect
* notification was handled by the android gadget work function.
* @suspended: True if got suspend notification from the gadget UDC.
* False if got resume notification from the gadget UDC.
* @sw_suspended: Equal to 'suspended' only after the susped
* notification was handled by the android gadget work function.
* @pm_qos: An attribute string that can be set by user space in order to
* determine pm_qos policy. Set to 'high' for always demand pm_qos
* when USB bus is connected and resumed. Set to 'low' for disable
* any setting of pm_qos by this driver. Default = 'high'.
* @work: workqueue used for handling notifications from the gadget UDC.
* @configs: List of configurations currently configured into the device.
* The android gadget supports more than one configuration. The host
* may choose one configuration from the suggested.
* @configs_num: Number of configurations currently configured and existing
* in the configs list.
* @list_item: This driver supports more than one android gadget device (for
* example in order to support multiple USB cores), therefore this is
* a item in a linked list of android devices.
*/
struct android_dev {
const char *name;
struct android_usb_function **functions;
struct usb_composite_dev *cdev;
struct device *dev;
bool enabled;
int disable_depth;
struct mutex mutex;
struct android_usb_platform_data *pdata;
bool connected;
bool sw_connected;
bool suspended;
bool sw_suspended;
char pm_qos[5];
struct pm_qos_request pm_qos_req_dma;
struct work_struct work;
/* A list of struct android_configuration */
struct list_head configs;
int configs_num;
/* A list node inside the android_dev_list */
struct list_head list_item;
};
struct android_configuration {
struct usb_configuration usb_config;
/* A list of the functions supported by this config */
struct list_head enabled_functions;
/* A list node inside the struct android_dev.configs list */
struct list_head list_item;
};
struct dload_struct __iomem *diag_dload;
static struct class *android_class;
static struct list_head android_dev_list;
static int android_dev_count;
static int android_bind_config(struct usb_configuration *c);
static void android_unbind_config(struct usb_configuration *c);
static struct android_dev *cdev_to_android_dev(struct usb_composite_dev *cdev);
static struct android_configuration *alloc_android_config
(struct android_dev *dev);
static void free_android_config(struct android_dev *dev,
struct android_configuration *conf);
static int usb_diag_update_pid_and_serial_num(uint32_t pid, const char *snum);
/* string IDs are assigned dynamically */
#define STRING_MANUFACTURER_IDX 0
#define STRING_PRODUCT_IDX 1
#define STRING_SERIAL_IDX 2
static char manufacturer_string[256];
static char product_string[256];
static char serial_string[256];
/* String Table */
static struct usb_string strings_dev[] = {
[STRING_MANUFACTURER_IDX].s = manufacturer_string,
[STRING_PRODUCT_IDX].s = product_string,
[STRING_SERIAL_IDX].s = serial_string,
{ } /* end of list */
};
static struct usb_gadget_strings stringtab_dev = {
.language = 0x0409, /* en-us */
.strings = strings_dev,
};
static struct usb_gadget_strings *dev_strings[] = {
&stringtab_dev,
NULL,
};
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_otg_descriptor otg_descriptor = {
.bLength = sizeof otg_descriptor,
.bDescriptorType = USB_DT_OTG,
.bmAttributes = USB_OTG_SRP | USB_OTG_HNP,
.bcdOTG = __constant_cpu_to_le16(0x0200),
};
static const struct usb_descriptor_header *otg_desc[] = {
(struct usb_descriptor_header *) &otg_descriptor,
NULL,
};
enum android_device_state {
USB_DISCONNECTED,
USB_CONNECTED,
USB_CONFIGURED,
USB_SUSPENDED,
USB_RESUMED
};
static void android_pm_qos_update_latency(struct android_dev *dev, int vote)
{
struct android_usb_platform_data *pdata = dev->pdata;
u32 swfi_latency = 0;
static int last_vote = -1;
if (!pdata || vote == last_vote
|| !pdata->swfi_latency)
return;
swfi_latency = pdata->swfi_latency + 1;
if (vote)
pm_qos_update_request(&dev->pm_qos_req_dma,
swfi_latency);
else
pm_qos_update_request(&dev->pm_qos_req_dma,
PM_QOS_DEFAULT_VALUE);
last_vote = vote;
}
static void android_work(struct work_struct *data)
{
struct android_dev *dev = container_of(data, struct android_dev, work);
struct usb_composite_dev *cdev = dev->cdev;
char *disconnected[2] = { "USB_STATE=DISCONNECTED", NULL };
char *connected[2] = { "USB_STATE=CONNECTED", NULL };
char *configured[2] = { "USB_STATE=CONFIGURED", NULL };
char *suspended[2] = { "USB_STATE=SUSPENDED", NULL };
char *resumed[2] = { "USB_STATE=RESUMED", NULL };
char **uevent_envp = NULL;
static enum android_device_state last_uevent, next_state;
unsigned long flags;
int pm_qos_vote = -1;
spin_lock_irqsave(&cdev->lock, flags);
if (dev->suspended != dev->sw_suspended && cdev->config) {
if (strncmp(dev->pm_qos, "low", 3))
pm_qos_vote = dev->suspended ? 0 : 1;
next_state = dev->suspended ? USB_SUSPENDED : USB_RESUMED;
uevent_envp = dev->suspended ? suspended : resumed;
} else if (cdev->config) {
uevent_envp = configured;
next_state = USB_CONFIGURED;
} else if (dev->connected != dev->sw_connected) {
uevent_envp = dev->connected ? connected : disconnected;
next_state = dev->connected ? USB_CONNECTED : USB_DISCONNECTED;
if (dev->connected && strncmp(dev->pm_qos, "low", 3))
pm_qos_vote = 1;
else if (!dev->connected || !strncmp(dev->pm_qos, "low", 3))
pm_qos_vote = 0;
}
dev->sw_connected = dev->connected;
dev->sw_suspended = dev->suspended;
spin_unlock_irqrestore(&cdev->lock, flags);
if (pm_qos_vote != -1)
android_pm_qos_update_latency(dev, pm_qos_vote);
if (uevent_envp) {
/*
* Some userspace modules, e.g. MTP, work correctly only if
* CONFIGURED uevent is preceded by DISCONNECT uevent.
* Check if we missed sending out a DISCONNECT uevent. This can
* happen if host PC resets and configures device really quick.
*/
if (((uevent_envp == connected) &&
(last_uevent != USB_DISCONNECTED)) ||
((uevent_envp == configured) &&
(last_uevent == USB_CONFIGURED))) {
pr_info("%s: sent missed DISCONNECT event\n", __func__);
kobject_uevent_env(&dev->dev->kobj, KOBJ_CHANGE,
disconnected);
msleep(20);
}
/*
* Before sending out CONFIGURED uevent give function drivers
* a chance to wakeup userspace threads and notify disconnect
*/
if (uevent_envp == configured)
msleep(50);
/* Do not notify on suspend / resume */
if (next_state != USB_SUSPENDED && next_state != USB_RESUMED) {
kobject_uevent_env(&dev->dev->kobj, KOBJ_CHANGE,
uevent_envp);
last_uevent = next_state;
}
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);
}
}
static int android_enable(struct android_dev *dev)
{
struct usb_composite_dev *cdev = dev->cdev;
struct android_configuration *conf;
int err = 0;
if (WARN_ON(!dev->disable_depth))
return err;
if (--dev->disable_depth == 0) {
list_for_each_entry(conf, &dev->configs, list_item) {
err = usb_add_config(cdev, &conf->usb_config,
android_bind_config);
if (err < 0) {
pr_err("%s: usb_add_config failed : err: %d\n",
__func__, err);
return err;
}
}
usb_gadget_connect(cdev->gadget);
}
return err;
}
static void android_disable(struct android_dev *dev)
{
struct usb_composite_dev *cdev = dev->cdev;
struct android_configuration *conf;
if (dev->disable_depth++ == 0) {
usb_gadget_disconnect(cdev->gadget);
/* Cancel pending control requests */
usb_ep_dequeue(cdev->gadget->ep0, cdev->req);
list_for_each_entry(conf, &dev->configs, list_item)
usb_remove_config(cdev, &conf->usb_config);
}
}
/*-------------------------------------------------------------------------*/
/* Supported functions initialization */
struct adb_data {
bool opened;
bool enabled;
struct android_dev *dev;
};
static int
adb_function_init(struct android_usb_function *f,
struct usb_composite_dev *cdev)
{
f->config = kzalloc(sizeof(struct adb_data), GFP_KERNEL);
if (!f->config)
return -ENOMEM;
return adb_setup();
}
static void adb_function_cleanup(struct android_usb_function *f)
{
adb_cleanup();
kfree(f->config);
}
static int
adb_function_bind_config(struct android_usb_function *f,
struct usb_configuration *c)
{
return adb_bind_config(c);
}
static void adb_android_function_enable(struct android_usb_function *f)
{
struct android_dev *dev = f->android_dev;
struct adb_data *data = f->config;
data->enabled = true;
/* Disable the gadget until adbd is ready */
if (!data->opened)
android_disable(dev);
}
static void adb_android_function_disable(struct android_usb_function *f)
{
struct android_dev *dev = f->android_dev;
struct adb_data *data = f->config;
data->enabled = false;
/* Balance the disable that was called in closed_callback */
if (!data->opened)
android_enable(dev);
}
static struct android_usb_function adb_function = {
.name = "adb",
.enable = adb_android_function_enable,
.disable = adb_android_function_disable,
.init = adb_function_init,
.cleanup = adb_function_cleanup,
.bind_config = adb_function_bind_config,
};
static void adb_ready_callback(void)
{
struct android_dev *dev = adb_function.android_dev;
struct adb_data *data = adb_function.config;
/* dev is null in case ADB is not in the composition */
if (dev)
mutex_lock(&dev->mutex);
/* Save dev in case the adb function will get disabled */
data->dev = dev;
data->opened = true;
if (data->enabled && dev)
android_enable(dev);
if (dev)
mutex_unlock(&dev->mutex);
}
static void adb_closed_callback(void)
{
struct adb_data *data = adb_function.config;
struct android_dev *dev = adb_function.android_dev;
/* In case new composition is without ADB, use saved one */
if (!dev)
dev = data->dev;
if (!dev)
pr_err("adb_closed_callback: data->dev is NULL");
if (dev)
mutex_lock(&dev->mutex);
data->opened = false;
if (data->enabled && dev)
android_disable(dev);
data->dev = NULL;
if (dev)
mutex_unlock(&dev->mutex);
}
/*-------------------------------------------------------------------------*/
/* Supported functions initialization */
/* ACM */
static char acm_transports[32]; /*enabled ACM ports - "tty[,sdio]"*/
static ssize_t acm_transports_store(
struct device *device, struct device_attribute *attr,
const char *buff, size_t size)
{
strlcpy(acm_transports, buff, sizeof(acm_transports));
return size;
}
static DEVICE_ATTR(acm_transports, S_IWUSR, NULL, acm_transports_store);
static struct device_attribute *acm_function_attributes[] = {
&dev_attr_acm_transports,
NULL
};
static void acm_function_cleanup(struct android_usb_function *f)
{
gserial_cleanup();
}
static int
acm_function_bind_config(struct android_usb_function *f,
struct usb_configuration *c)
{
char *name;
char buf[32], *b;
int err = -1, i;
static int acm_initialized, ports;
if (acm_initialized)
goto bind_config;
acm_initialized = 1;
strlcpy(buf, acm_transports, sizeof(buf));
b = strim(buf);
while (b) {
name = strsep(&b, ",");
if (name) {
err = acm_init_port(ports, name);
if (err) {
pr_err("acm: Cannot open port '%s'", name);
goto out;
}
ports++;
}
}
err = acm_port_setup(c);
if (err) {
pr_err("acm: Cannot setup transports");
goto out;
}
bind_config:
for (i = 0; i < ports; i++) {
err = acm_bind_config(c, i);
if (err) {
pr_err("acm: bind_config failed for port %d", i);
goto out;
}
}
out:
return err;
}
static struct android_usb_function acm_function = {
.name = "acm",
.cleanup = acm_function_cleanup,
.bind_config = acm_function_bind_config,
.attributes = acm_function_attributes,
};
/* RMNET_SMD */
static int rmnet_smd_function_bind_config(struct android_usb_function *f,
struct usb_configuration *c)
{
return rmnet_smd_bind_config(c);
}
static struct android_usb_function rmnet_smd_function = {
.name = "rmnet_smd",
.bind_config = rmnet_smd_function_bind_config,
};
/* RMNET_SDIO */
static int rmnet_sdio_function_bind_config(struct android_usb_function *f,
struct usb_configuration *c)
{
return rmnet_sdio_function_add(c);
}
static struct android_usb_function rmnet_sdio_function = {
.name = "rmnet_sdio",
.bind_config = rmnet_sdio_function_bind_config,
};
/* RMNET_SMD_SDIO */
static int rmnet_smd_sdio_function_init(struct android_usb_function *f,
struct usb_composite_dev *cdev)
{
return rmnet_smd_sdio_init();
}
static void rmnet_smd_sdio_function_cleanup(struct android_usb_function *f)
{
rmnet_smd_sdio_cleanup();
}
static int rmnet_smd_sdio_bind_config(struct android_usb_function *f,
struct usb_configuration *c)
{
return rmnet_smd_sdio_function_add(c);
}
static struct device_attribute *rmnet_smd_sdio_attributes[] = {
&dev_attr_transport, NULL };
static struct android_usb_function rmnet_smd_sdio_function = {
.name = "rmnet_smd_sdio",
.init = rmnet_smd_sdio_function_init,
.cleanup = rmnet_smd_sdio_function_cleanup,
.bind_config = rmnet_smd_sdio_bind_config,
.attributes = rmnet_smd_sdio_attributes,
};
/*rmnet transport string format(per port):"ctrl0,data0,ctrl1,data1..." */
#define MAX_XPORT_STR_LEN 50
static char rmnet_transports[MAX_XPORT_STR_LEN];
static void rmnet_function_cleanup(struct android_usb_function *f)
{
frmnet_cleanup();
}
static int rmnet_function_bind_config(struct android_usb_function *f,
struct usb_configuration *c)
{
int i;
int err = 0;
char *ctrl_name;
char *data_name;
char buf[MAX_XPORT_STR_LEN], *b;
static int rmnet_initialized, ports;
if (!rmnet_initialized) {
rmnet_initialized = 1;
strlcpy(buf, rmnet_transports, sizeof(buf));
b = strim(buf);
while (b) {
ctrl_name = strsep(&b, ",");
data_name = strsep(&b, ",");
if (ctrl_name && data_name) {
err = frmnet_init_port(ctrl_name, data_name);
if (err) {
pr_err("rmnet: Cannot open ctrl port:"
"'%s' data port:'%s'\n",
ctrl_name, data_name);
goto out;
}
ports++;
}
}
err = rmnet_gport_setup();
if (err) {
pr_err("rmnet: Cannot setup transports");
goto out;
}
}
for (i = 0; i < ports; i++) {
err = frmnet_bind_config(c, i);
if (err) {
pr_err("Could not bind rmnet%u config\n", i);
break;
}
}
out:
return err;
}
static ssize_t rmnet_transports_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
return snprintf(buf, PAGE_SIZE, "%s\n", rmnet_transports);
}
static ssize_t rmnet_transports_store(
struct device *device, struct device_attribute *attr,
const char *buff, size_t size)
{
strlcpy(rmnet_transports, buff, sizeof(rmnet_transports));
return size;
}
static struct device_attribute dev_attr_rmnet_transports =
__ATTR(transports, S_IRUGO | S_IWUSR,
rmnet_transports_show,
rmnet_transports_store);
static struct device_attribute *rmnet_function_attributes[] = {
&dev_attr_rmnet_transports,
NULL };
static struct android_usb_function rmnet_function = {
.name = "rmnet",
.cleanup = rmnet_function_cleanup,
.bind_config = rmnet_function_bind_config,
.attributes = rmnet_function_attributes,
};
static void gps_function_cleanup(struct android_usb_function *f)
{
gps_cleanup();
}
static int gps_function_bind_config(struct android_usb_function *f,
struct usb_configuration *c)
{
int err;
static int gps_initialized;
if (!gps_initialized) {
gps_initialized = 1;
err = gps_init_port();
if (err) {
pr_err("gps: Cannot init gps port");
return err;
}
}
err = gps_gport_setup();
if (err) {
pr_err("gps: Cannot setup transports");
return err;
}
err = gps_bind_config(c);
if (err) {
pr_err("Could not bind gps config\n");
return err;
}
return 0;
}
static struct android_usb_function gps_function = {
.name = "gps",
.cleanup = gps_function_cleanup,
.bind_config = gps_function_bind_config,
};
/* ncm */
struct ncm_function_config {
u8 ethaddr[ETH_ALEN];
};
static int
ncm_function_init(struct android_usb_function *f, struct usb_composite_dev *c)
{
f->config = kzalloc(sizeof(struct ncm_function_config), GFP_KERNEL);
if (!f->config)
return -ENOMEM;
return 0;
}
static void ncm_function_cleanup(struct android_usb_function *f)
{
kfree(f->config);
f->config = NULL;
}
static int
ncm_function_bind_config(struct android_usb_function *f,
struct usb_configuration *c)
{
struct ncm_function_config *ncm = f->config;
int ret;
if (!ncm) {
pr_err("%s: ncm config is null\n", __func__);
return -EINVAL;
}
pr_info("%s MAC: %02X:%02X:%02X:%02X:%02X:%02X\n", __func__,
ncm->ethaddr[0], ncm->ethaddr[1], ncm->ethaddr[2],
ncm->ethaddr[3], ncm->ethaddr[4], ncm->ethaddr[5]);
ret = gether_setup_name(c->cdev->gadget, ncm->ethaddr, "ncm");
if (ret) {
pr_err("%s: gether setup failed err:%d\n", __func__, ret);
return ret;
}
ret = ncm_bind_config(c, ncm->ethaddr);
if (ret) {
pr_err("%s: ncm bind config failed err:%d", __func__, ret);
gether_cleanup();
return ret;
}
return ret;
}
static void ncm_function_unbind_config(struct android_usb_function *f,
struct usb_configuration *c)
{
gether_cleanup();
}
static ssize_t ncm_ethaddr_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct android_usb_function *f = dev_get_drvdata(dev);
struct ncm_function_config *ncm = f->config;
return snprintf(buf, PAGE_SIZE, "%02x:%02x:%02x:%02x:%02x:%02x\n",
ncm->ethaddr[0], ncm->ethaddr[1], ncm->ethaddr[2],
ncm->ethaddr[3], ncm->ethaddr[4], ncm->ethaddr[5]);
}
static ssize_t ncm_ethaddr_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t size)
{
struct android_usb_function *f = dev_get_drvdata(dev);
struct ncm_function_config *ncm = f->config;
if (sscanf(buf, "%02x:%02x:%02x:%02x:%02x:%02x\n",
(int *)&ncm->ethaddr[0], (int *)&ncm->ethaddr[1],
(int *)&ncm->ethaddr[2], (int *)&ncm->ethaddr[3],
(int *)&ncm->ethaddr[4], (int *)&ncm->ethaddr[5]) == 6)
return size;
return -EINVAL;
}
static DEVICE_ATTR(ncm_ethaddr, S_IRUGO | S_IWUSR, ncm_ethaddr_show,
ncm_ethaddr_store);
static struct device_attribute *ncm_function_attributes[] = {
&dev_attr_ncm_ethaddr,
NULL
};
static struct android_usb_function ncm_function = {
.name = "ncm",
.init = ncm_function_init,
.cleanup = ncm_function_cleanup,
.bind_config = ncm_function_bind_config,
.unbind_config = ncm_function_unbind_config,
.attributes = ncm_function_attributes,
};
/* ecm transport string */
static char ecm_transports[MAX_XPORT_STR_LEN];
struct ecm_function_config {
u8 ethaddr[ETH_ALEN];
};
static int ecm_function_init(struct android_usb_function *f,
struct usb_composite_dev *cdev)
{
f->config = kzalloc(sizeof(struct ecm_function_config), GFP_KERNEL);
if (!f->config)
return -ENOMEM;
return 0;
}
static void ecm_function_cleanup(struct android_usb_function *f)
{
kfree(f->config);
f->config = NULL;
}
static int ecm_qc_function_bind_config(struct android_usb_function *f,
struct usb_configuration *c)
{
int ret;
char *trans;
struct ecm_function_config *ecm = f->config;
if (!ecm) {
pr_err("%s: ecm_pdata\n", __func__);
return -EINVAL;
}
pr_info("%s MAC: %02X:%02X:%02X:%02X:%02X:%02X\n", __func__,
ecm->ethaddr[0], ecm->ethaddr[1], ecm->ethaddr[2],
ecm->ethaddr[3], ecm->ethaddr[4], ecm->ethaddr[5]);
pr_debug("%s: ecm_transport is %s", __func__, ecm_transports);
trans = strim(ecm_transports);
if (strcmp("BAM2BAM_IPA", trans)) {
ret = gether_qc_setup_name(c->cdev->gadget,
ecm->ethaddr, "ecm");
if (ret) {
pr_err("%s: gether_setup failed\n", __func__);
return ret;
}
}
return ecm_qc_bind_config(c, ecm->ethaddr, trans);
}
static void ecm_qc_function_unbind_config(struct android_usb_function *f,
struct usb_configuration *c)
{
char *trans = strim(ecm_transports);
if (strcmp("BAM2BAM_IPA", trans))
gether_qc_cleanup_name("ecm0");
}
static ssize_t ecm_ethaddr_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct android_usb_function *f = dev_get_drvdata(dev);
struct ecm_function_config *ecm = f->config;
return snprintf(buf, PAGE_SIZE, "%02x:%02x:%02x:%02x:%02x:%02x\n",
ecm->ethaddr[0], ecm->ethaddr[1], ecm->ethaddr[2],
ecm->ethaddr[3], ecm->ethaddr[4], ecm->ethaddr[5]);
}
static ssize_t ecm_ethaddr_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t size)
{
struct android_usb_function *f = dev_get_drvdata(dev);
struct ecm_function_config *ecm = f->config;
if (sscanf(buf, "%02x:%02x:%02x:%02x:%02x:%02x\n",
(int *)&ecm->ethaddr[0], (int *)&ecm->ethaddr[1],
(int *)&ecm->ethaddr[2], (int *)&ecm->ethaddr[3],
(int *)&ecm->ethaddr[4], (int *)&ecm->ethaddr[5]) == 6)
return size;
return -EINVAL;
}
static DEVICE_ATTR(ecm_ethaddr, S_IRUGO | S_IWUSR, ecm_ethaddr_show,
ecm_ethaddr_store);
static ssize_t ecm_transports_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
return snprintf(buf, PAGE_SIZE, "%s\n", ecm_transports);
}
static ssize_t ecm_transports_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t size)
{
strlcpy(ecm_transports, buf, sizeof(ecm_transports));
return size;
}
static DEVICE_ATTR(ecm_transports, S_IRUGO | S_IWUSR, ecm_transports_show,
ecm_transports_store);
static struct device_attribute *ecm_function_attributes[] = {
&dev_attr_ecm_transports,
&dev_attr_ecm_ethaddr,
NULL
};
static struct android_usb_function ecm_qc_function = {
.name = "ecm_qc",
.init = ecm_function_init,
.cleanup = ecm_function_cleanup,
.bind_config = ecm_qc_function_bind_config,
.unbind_config = ecm_qc_function_unbind_config,
.attributes = ecm_function_attributes,
};
/* MBIM - used with BAM */
#define MAX_MBIM_INSTANCES 1
static int mbim_function_init(struct android_usb_function *f,
struct usb_composite_dev *cdev)
{
return mbim_init(MAX_MBIM_INSTANCES);
}
static void mbim_function_cleanup(struct android_usb_function *f)
{
fmbim_cleanup();
}
/* mbim transport string */
static char mbim_transports[MAX_XPORT_STR_LEN];
static int mbim_function_bind_config(struct android_usb_function *f,
struct usb_configuration *c)
{
char *trans;
pr_debug("%s: mbim transport is %s", __func__, mbim_transports);
trans = strim(mbim_transports);
return mbim_bind_config(c, 0, trans);
}
static int mbim_function_ctrlrequest(struct android_usb_function *f,
struct usb_composite_dev *cdev,
const struct usb_ctrlrequest *c)
{
return mbim_ctrlrequest(cdev, c);
}
static ssize_t mbim_transports_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
return snprintf(buf, PAGE_SIZE, "%s\n", mbim_transports);
}
static ssize_t mbim_transports_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t size)
{
strlcpy(mbim_transports, buf, sizeof(mbim_transports));
return size;
}
static DEVICE_ATTR(mbim_transports, S_IRUGO | S_IWUSR, mbim_transports_show,
mbim_transports_store);
static ssize_t wMTU_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
return snprintf(buf, PAGE_SIZE, "%d\n", ext_mbb_desc.wMTU);
}
static ssize_t wMTU_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t size)
{
int value;
if (sscanf(buf, "%d", &value) == 1) {
if (value < 0 || value > USHRT_MAX)
pr_err("illegal MTU %d, enter unsigned 16 bits\n",
value);
else
ext_mbb_desc.wMTU = cpu_to_le16(value);
return size;
}
return -EINVAL;
}
static DEVICE_ATTR(wMTU, S_IRUGO | S_IWUSR, wMTU_show,
wMTU_store);
static struct device_attribute *mbim_function_attributes[] = {
&dev_attr_mbim_transports,
&dev_attr_wMTU,
NULL
};
static struct android_usb_function mbim_function = {
.name = "usb_mbim",
.cleanup = mbim_function_cleanup,
.bind_config = mbim_function_bind_config,
.init = mbim_function_init,
.ctrlrequest = mbim_function_ctrlrequest,
.attributes = mbim_function_attributes,
};
#ifdef CONFIG_SND_PCM
/* PERIPHERAL AUDIO */
static int audio_function_bind_config(struct android_usb_function *f,
struct usb_configuration *c)
{
return audio_bind_config(c);
}
static struct android_usb_function audio_function = {
.name = "audio",
.bind_config = audio_function_bind_config,
};
#endif
/* DIAG */
static char diag_clients[32]; /*enabled DIAG clients- "diag[,diag_mdm]" */
static ssize_t clients_store(
struct device *device, struct device_attribute *attr,
const char *buff, size_t size)
{
strlcpy(diag_clients, buff, sizeof(diag_clients));
return size;
}
static DEVICE_ATTR(clients, S_IWUSR, NULL, clients_store);
static struct device_attribute *diag_function_attributes[] =
{ &dev_attr_clients, NULL };
static int diag_function_init(struct android_usb_function *f,
struct usb_composite_dev *cdev)
{
return diag_setup();
}
static void diag_function_cleanup(struct android_usb_function *f)
{
diag_cleanup();
}
static int diag_function_bind_config(struct android_usb_function *f,
struct usb_configuration *c)
{
char *name;
char buf[32], *b;
int once = 0, err = -1;
int (*notify)(uint32_t, const char *);
struct android_dev *dev = cdev_to_android_dev(c->cdev);
strlcpy(buf, diag_clients, sizeof(buf));
b = strim(buf);
while (b) {
notify = NULL;
name = strsep(&b, ",");
/* Allow only first diag channel to update pid and serial no */
if (!once++) {
if (dev->pdata && dev->pdata->update_pid_and_serial_num)
notify = dev->pdata->update_pid_and_serial_num;
else
notify = usb_diag_update_pid_and_serial_num;
}
if (name) {
err = diag_function_add(c, name, notify);
if (err)
pr_err("diag: Cannot open channel '%s'", name);
}
}
return err;
}
static struct android_usb_function diag_function = {
.name = "diag",
.init = diag_function_init,
.cleanup = diag_function_cleanup,
.bind_config = diag_function_bind_config,
.attributes = diag_function_attributes,
};
/* DEBUG */
static int qdss_function_init(struct android_usb_function *f,
struct usb_composite_dev *cdev)
{
return qdss_setup();
}
static void qdss_function_cleanup(struct android_usb_function *f)
{
qdss_cleanup();
}
static int qdss_function_bind_config(struct android_usb_function *f,
struct usb_configuration *c)
{
int err = -1;
err = qdss_bind_config(c, "qdss");
if (err)
pr_err("qdss: Cannot open channel qdss");
return err;
}
static struct android_usb_function qdss_function = {
.name = "qdss",
.init = qdss_function_init,
.cleanup = qdss_function_cleanup,
.bind_config = qdss_function_bind_config,
};
/* SERIAL */
static char serial_transports[32]; /*enabled FSERIAL ports - "tty[,sdio]"*/
static ssize_t serial_transports_store(
struct device *device, struct device_attribute *attr,
const char *buff, size_t size)
{
strlcpy(serial_transports, buff, sizeof(serial_transports));
return size;
}
static DEVICE_ATTR(transports, S_IWUSR, NULL, serial_transports_store);
static struct device_attribute *serial_function_attributes[] =
{ &dev_attr_transports, NULL };
static void serial_function_cleanup(struct android_usb_function *f)
{
gserial_cleanup();
}
static int serial_function_bind_config(struct android_usb_function *f,
struct usb_configuration *c)
{
char *name;
char buf[32], *b;
int err = -1, i;
static int serial_initialized = 0, ports = 0;
if (serial_initialized)
goto bind_config;
serial_initialized = 1;
strlcpy(buf, serial_transports, sizeof(buf));
b = strim(buf);
while (b) {
name = strsep(&b, ",");
if (name) {
err = gserial_init_port(ports, name);
if (err) {
pr_err("serial: Cannot open port '%s'", name);
goto out;
}
ports++;
}
}
err = gport_setup(c);
if (err) {
pr_err("serial: Cannot setup transports");
goto out;
}
bind_config:
for (i = 0; i < ports; i++) {
err = gser_bind_config(c, i);
if (err) {
pr_err("serial: bind_config failed for port %d", i);
goto out;
}
}
out:
return err;
}
static struct android_usb_function serial_function = {
.name = "serial",
.cleanup = serial_function_cleanup,
.bind_config = serial_function_bind_config,
.attributes = serial_function_attributes,
};
/* CCID */
static int ccid_function_init(struct android_usb_function *f,
struct usb_composite_dev *cdev)
{
return ccid_setup();
}
static void ccid_function_cleanup(struct android_usb_function *f)
{
ccid_cleanup();
}
static int ccid_function_bind_config(struct android_usb_function *f,
struct usb_configuration *c)
{
return ccid_bind_config(c);
}
static struct android_usb_function ccid_function = {
.name = "ccid",
.init = ccid_function_init,
.cleanup = ccid_function_cleanup,
.bind_config = ccid_function_bind_config,
};
static int
mtp_function_init(struct android_usb_function *f,
struct usb_composite_dev *cdev)
{
return mtp_setup();
}
static void mtp_function_cleanup(struct android_usb_function *f)
{
mtp_cleanup();
}
static int
mtp_function_bind_config(struct android_usb_function *f,
struct usb_configuration *c)
{
return mtp_bind_config(c, false);
}
static int
ptp_function_init(struct android_usb_function *f,
struct usb_composite_dev *cdev)
{
/* nothing to do - initialization is handled by mtp_function_init */
return 0;
}
static void ptp_function_cleanup(struct android_usb_function *f)
{
/* nothing to do - cleanup is handled by mtp_function_cleanup */
}
static int
ptp_function_bind_config(struct android_usb_function *f,
struct usb_configuration *c)
{
return mtp_bind_config(c, true);
}
static int mtp_function_ctrlrequest(struct android_usb_function *f,
struct usb_composite_dev *cdev,
const struct usb_ctrlrequest *c)
{
return mtp_ctrlrequest(cdev, c);
}
static struct android_usb_function mtp_function = {
.name = "mtp",
.init = mtp_function_init,
.cleanup = mtp_function_cleanup,
.bind_config = mtp_function_bind_config,
.ctrlrequest = mtp_function_ctrlrequest,
};
/* PTP function is same as MTP with slightly different interface descriptor */
static struct android_usb_function ptp_function = {
.name = "ptp",
.init = ptp_function_init,
.cleanup = ptp_function_cleanup,
.bind_config = ptp_function_bind_config,
};
struct rndis_function_config {
u8 ethaddr[ETH_ALEN];
u32 vendorID;
u8 max_pkt_per_xfer;
char manufacturer[256];
/* "Wireless" RNDIS; auto-detected by Windows */
bool wceis;
};
static int
rndis_function_init(struct android_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 android_usb_function *f)
{
kfree(f->config);
f->config = NULL;
}
static int rndis_qc_function_init(struct android_usb_function *f,
struct usb_composite_dev *cdev)
{
f->config = kzalloc(sizeof(struct rndis_function_config), GFP_KERNEL);
if (!f->config)
return -ENOMEM;
return rndis_qc_init();
}
static void rndis_qc_function_cleanup(struct android_usb_function *f)
{
rndis_qc_cleanup();
kfree(f->config);
}
static int
rndis_function_bind_config(struct android_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: %02X:%02X:%02X:%02X:%02X:%02X\n", __func__,
rndis->ethaddr[0], rndis->ethaddr[1], rndis->ethaddr[2],
rndis->ethaddr[3], rndis->ethaddr[4], rndis->ethaddr[5]);
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 int rndis_qc_function_bind_config(struct android_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 -EINVAL;
}
pr_info("%s MAC: %02X:%02X:%02X:%02X:%02X:%02X\n", __func__,
rndis->ethaddr[0], rndis->ethaddr[1], rndis->ethaddr[2],
rndis->ethaddr[3], rndis->ethaddr[4], rndis->ethaddr[5]);
ret = gether_qc_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_qc_iad_descriptor.bFunctionClass =
USB_CLASS_WIRELESS_CONTROLLER;
rndis_qc_iad_descriptor.bFunctionSubClass = 0x01;
rndis_qc_iad_descriptor.bFunctionProtocol = 0x03;
rndis_qc_control_intf.bInterfaceClass =
USB_CLASS_WIRELESS_CONTROLLER;
rndis_qc_control_intf.bInterfaceSubClass = 0x01;
rndis_qc_control_intf.bInterfaceProtocol = 0x03;
}
return rndis_qc_bind_config_vendor(c, rndis->ethaddr, rndis->vendorID,
rndis->manufacturer,
rndis->max_pkt_per_xfer);
}
static void rndis_function_unbind_config(struct android_usb_function *f,
struct usb_configuration *c)
{
gether_cleanup();
}
static void rndis_qc_function_unbind_config(struct android_usb_function *f,
struct usb_configuration *c)
{
gether_qc_cleanup_name("rndis0");
}
static ssize_t rndis_manufacturer_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct android_usb_function *f = dev_get_drvdata(dev);
struct rndis_function_config *config = f->config;
return snprintf(buf, PAGE_SIZE, "%s\n", config->manufacturer);
}
static ssize_t rndis_manufacturer_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t size)
{
struct android_usb_function *f = dev_get_drvdata(dev);
struct rndis_function_config *config = f->config;
if (size >= sizeof(config->manufacturer))
return -EINVAL;
if (sscanf(buf, "%255s", config->manufacturer) == 1)
return size;
return -1;
}
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 android_usb_function *f = dev_get_drvdata(dev);
struct rndis_function_config *config = f->config;
return snprintf(buf, PAGE_SIZE, "%d\n", config->wceis);
}
static ssize_t rndis_wceis_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t size)
{
struct android_usb_function *f = dev_get_drvdata(dev);
struct rndis_function_config *config = f->config;
int value;
if (sscanf(buf, "%d", &value) == 1) {
config->wceis = value;
return size;
}
return -EINVAL;
}
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 android_usb_function *f = dev_get_drvdata(dev);
struct rndis_function_config *rndis = f->config;
return snprintf(buf, PAGE_SIZE, "%02x:%02x:%02x:%02x:%02x:%02x\n",
rndis->ethaddr[0], rndis->ethaddr[1], rndis->ethaddr[2],
rndis->ethaddr[3], rndis->ethaddr[4], rndis->ethaddr[5]);
}
static ssize_t rndis_ethaddr_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t size)
{
struct android_usb_function *f = dev_get_drvdata(dev);
struct rndis_function_config *rndis = f->config;
if (sscanf(buf, "%02x:%02x:%02x:%02x:%02x:%02x\n",
(int *)&rndis->ethaddr[0], (int *)&rndis->ethaddr[1],
(int *)&rndis->ethaddr[2], (int *)&rndis->ethaddr[3],
(int *)&rndis->ethaddr[4], (int *)&rndis->ethaddr[5]) == 6)
return size;
return -EINVAL;
}
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 android_usb_function *f = dev_get_drvdata(dev);
struct rndis_function_config *config = f->config;
return snprintf(buf, PAGE_SIZE, "%04x\n", config->vendorID);
}
static ssize_t rndis_vendorID_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t size)
{
struct android_usb_function *f = dev_get_drvdata(dev);
struct rndis_function_config *config = f->config;
int value;
if (sscanf(buf, "%04x", &value) == 1) {
config->vendorID = value;
return size;
}
return -EINVAL;
}
static DEVICE_ATTR(vendorID, S_IRUGO | S_IWUSR, rndis_vendorID_show,
rndis_vendorID_store);
static ssize_t rndis_max_pkt_per_xfer_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct android_usb_function *f = dev_get_drvdata(dev);
struct rndis_function_config *config = f->config;
return snprintf(buf, PAGE_SIZE, "%d\n", config->max_pkt_per_xfer);
}
static ssize_t rndis_max_pkt_per_xfer_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t size)
{
struct android_usb_function *f = dev_get_drvdata(dev);
struct rndis_function_config *config = f->config;
int value;
if (sscanf(buf, "%d", &value) == 1) {
config->max_pkt_per_xfer = value;
return size;
}
return -EINVAL;
}
static DEVICE_ATTR(max_pkt_per_xfer, S_IRUGO | S_IWUSR,
rndis_max_pkt_per_xfer_show,
rndis_max_pkt_per_xfer_store);
static ssize_t rndis_rx_trigger_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t size)
{
int value;
if (sscanf(buf, "%d", &value) == 1) {
rndis_rx_trigger();
return size;
}
return -EINVAL;
}
static DEVICE_ATTR(rx_trigger, S_IWUSR, NULL,
rndis_rx_trigger_store);
static struct device_attribute *rndis_function_attributes[] = {
&dev_attr_manufacturer,
&dev_attr_wceis,
&dev_attr_ethaddr,
&dev_attr_vendorID,
&dev_attr_max_pkt_per_xfer,
&dev_attr_rx_trigger,
NULL
};
static struct android_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 struct android_usb_function rndis_qc_function = {
.name = "rndis_qc",
.init = rndis_qc_function_init,
.cleanup = rndis_qc_function_cleanup,
.bind_config = rndis_qc_function_bind_config,
.unbind_config = rndis_qc_function_unbind_config,
.attributes = rndis_function_attributes,
};
static int ecm_function_bind_config(struct android_usb_function *f,
struct usb_configuration *c)
{
int ret;
struct ecm_function_config *ecm = f->config;
if (!ecm) {
pr_err("%s: ecm_pdata\n", __func__);
return -EINVAL;
}
pr_info("%s MAC: %02X:%02X:%02X:%02X:%02X:%02X\n", __func__,
ecm->ethaddr[0], ecm->ethaddr[1], ecm->ethaddr[2],
ecm->ethaddr[3], ecm->ethaddr[4], ecm->ethaddr[5]);
ret = gether_setup_name(c->cdev->gadget, ecm->ethaddr, "ecm");
if (ret) {
pr_err("%s: gether_setup failed\n", __func__);
return ret;
}
ret = ecm_bind_config(c, ecm->ethaddr);
if (ret) {
pr_err("%s: ecm_bind_config failed\n", __func__);
gether_cleanup();
}
return ret;
}
static void ecm_function_unbind_config(struct android_usb_function *f,
struct usb_configuration *c)
{
gether_cleanup();
}
static struct android_usb_function ecm_function = {
.name = "ecm",
.init = ecm_function_init,
.cleanup = ecm_function_cleanup,
.bind_config = ecm_function_bind_config,
.unbind_config = ecm_function_unbind_config,
.attributes = ecm_function_attributes,
};
struct mass_storage_function_config {
struct fsg_config fsg;
struct fsg_common *common;
};
static int mass_storage_function_init(struct android_usb_function *f,
struct usb_composite_dev *cdev)
{
struct android_dev *dev = cdev_to_android_dev(cdev);
struct mass_storage_function_config *config;
struct fsg_common *common;
int err;
int i;
const char *name[2];
config = kzalloc(sizeof(struct mass_storage_function_config),
GFP_KERNEL);
if (!config)
return -ENOMEM;
config->fsg.nluns = 1;
name[0] = "lun";
if (dev->pdata && dev->pdata->cdrom) {
config->fsg.nluns = 2;
config->fsg.luns[1].cdrom = 1;
config->fsg.luns[1].ro = 1;
config->fsg.luns[1].removable = 1;
name[1] = "lun0";
}
config->fsg.luns[0].removable = 1;
common = fsg_common_init(NULL, cdev, &config->fsg);
if (IS_ERR(common)) {
kfree(config);
return PTR_ERR(common);
}
for (i = 0; i < config->fsg.nluns; i++) {
err = sysfs_create_link(&f->dev->kobj,
&common->luns[i].dev.kobj,
name[i]);
if (err)
goto error;
}
config->common = common;
f->config = config;
return 0;
error:
for (; i > 0 ; i--)
sysfs_remove_link(&f->dev->kobj, name[i-1]);
fsg_common_release(&common->ref);
kfree(config);
return err;
}
static void mass_storage_function_cleanup(struct android_usb_function *f)
{
kfree(f->config);
f->config = NULL;
}
static int mass_storage_function_bind_config(struct android_usb_function *f,
struct usb_configuration *c)
{
struct mass_storage_function_config *config = f->config;
return fsg_bind_config(c->cdev, c, config->common);
}
static ssize_t mass_storage_inquiry_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct android_usb_function *f = dev_get_drvdata(dev);
struct mass_storage_function_config *config = f->config;
return snprintf(buf, PAGE_SIZE, "%s\n", config->common->inquiry_string);
}
static ssize_t mass_storage_inquiry_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t size)
{
struct android_usb_function *f = dev_get_drvdata(dev);
struct mass_storage_function_config *config = f->config;
if (size >= sizeof(config->common->inquiry_string))
return -EINVAL;
if (sscanf(buf, "%28s", config->common->inquiry_string) != 1)
return -EINVAL;
return size;
}
static DEVICE_ATTR(inquiry_string, S_IRUGO | S_IWUSR,
mass_storage_inquiry_show,
mass_storage_inquiry_store);
//[yanghuaying start] export whether mass storage is connect to pc
static int in_suspend_mode = 0;
static ssize_t mass_storage_connect2pc_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct android_usb_function *f = dev_get_drvdata(dev);
struct mass_storage_function_config *config = f->config;
int available = 0;
if(config->common->new_fsg != NULL && !in_suspend_mode)
available = 1;
pr_info("in_suspend_mode = %d\n", in_suspend_mode);
return snprintf(buf, PAGE_SIZE, "%d\n", available);
}
static DEVICE_ATTR(connect2pc, 0444,
mass_storage_connect2pc_show,
NULL);
//[yanghuaying end]
static struct device_attribute *mass_storage_function_attributes[] = {
&dev_attr_inquiry_string,
&dev_attr_connect2pc,
NULL
};
static struct android_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,
.attributes = mass_storage_function_attributes,
};
static int accessory_function_init(struct android_usb_function *f,
struct usb_composite_dev *cdev)
{
return acc_setup();
}
static void accessory_function_cleanup(struct android_usb_function *f)
{
acc_cleanup();
}
static int accessory_function_bind_config(struct android_usb_function *f,
struct usb_configuration *c)
{
return acc_bind_config(c);
}
static int accessory_function_ctrlrequest(struct android_usb_function *f,
struct usb_composite_dev *cdev,
const struct usb_ctrlrequest *c)
{
return acc_ctrlrequest(cdev, c);
}
static struct android_usb_function accessory_function = {
.name = "accessory",
.init = accessory_function_init,
.cleanup = accessory_function_cleanup,
.bind_config = accessory_function_bind_config,
.ctrlrequest = accessory_function_ctrlrequest,
};
#ifdef CONFIG_SND_PCM
static int audio_source_function_init(struct android_usb_function *f,
struct usb_composite_dev *cdev)
{
struct audio_source_config *config;
config = kzalloc(sizeof(struct audio_source_config), GFP_KERNEL);
if (!config)
return -ENOMEM;
config->card = -1;
config->device = -1;
f->config = config;
return 0;
}
static void audio_source_function_cleanup(struct android_usb_function *f)
{
kfree(f->config);
}
static int audio_source_function_bind_config(struct android_usb_function *f,
struct usb_configuration *c)
{
struct audio_source_config *config = f->config;
return audio_source_bind_config(c, config);
}
static void audio_source_function_unbind_config(struct android_usb_function *f,
struct usb_configuration *c)
{
struct audio_source_config *config = f->config;
config->card = -1;
config->device = -1;
}
static ssize_t audio_source_pcm_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct android_usb_function *f = dev_get_drvdata(dev);
struct audio_source_config *config = f->config;
/* print PCM card and device numbers */
return sprintf(buf, "%d %d\n", config->card, config->device);
}
static DEVICE_ATTR(pcm, S_IRUGO | S_IWUSR, audio_source_pcm_show, NULL);
static struct device_attribute *audio_source_function_attributes[] = {
&dev_attr_pcm,
NULL
};
static struct android_usb_function audio_source_function = {
.name = "audio_source",
.init = audio_source_function_init,
.cleanup = audio_source_function_cleanup,
.bind_config = audio_source_function_bind_config,
.unbind_config = audio_source_function_unbind_config,
.attributes = audio_source_function_attributes,
};
#endif
static int android_uasp_connect_cb(bool connect)
{
/*
* TODO
* We may have to disable gadget till UASP configfs nodes
* are configured which includes mapping LUN with the
* backing file. It is a fundamental difference between
* f_mass_storage and f_tcp. That means UASP can not be
* in default composition.
*
* For now, assume that UASP configfs nodes are configured
* before enabling android gadget. Or cable should be
* reconnected after mapping the LUN.
*
* Also consider making UASP to respond to Host requests when
* Lun is not mapped.
*/
pr_debug("UASP %s\n", connect ? "connect" : "disconnect");
return 0;
}
static int uasp_function_init(struct android_usb_function *f,
struct usb_composite_dev *cdev)
{
return f_tcm_init(&android_uasp_connect_cb);
}
static void uasp_function_cleanup(struct android_usb_function *f)
{
f_tcm_exit();
}
static int uasp_function_bind_config(struct android_usb_function *f,
struct usb_configuration *c)
{
return tcm_bind_config(c);
}
static struct android_usb_function uasp_function = {
.name = "uasp",
.init = uasp_function_init,
.cleanup = uasp_function_cleanup,
.bind_config = uasp_function_bind_config,
};
static struct android_usb_function *supported_functions[] = {
&mbim_function,
&ecm_qc_function,
#ifdef CONFIG_SND_PCM
&audio_function,
#endif
&rmnet_smd_function,
&rmnet_sdio_function,
&rmnet_smd_sdio_function,
&rmnet_function,
&gps_function,
&diag_function,
&qdss_function,
&serial_function,
&adb_function,
&ccid_function,
&acm_function,
&mtp_function,
&ptp_function,
&rndis_function,
&rndis_qc_function,
&ecm_function,
&ncm_function,
&mass_storage_function,
&accessory_function,
#ifdef CONFIG_SND_PCM
&audio_source_function,
#endif
&uasp_function,
NULL
};
static void android_cleanup_functions(struct android_usb_function **functions)
{
struct android_usb_function *f;
struct device_attribute **attrs;
struct device_attribute *attr;
while (*functions) {
f = *functions++;
if (f->dev) {
device_destroy(android_class, f->dev->devt);
kfree(f->dev_name);
} else
continue;
if (f->cleanup)
f->cleanup(f);
attrs = f->attributes;
if (attrs) {
while ((attr = *attrs++))
device_remove_file(f->dev, attr);
}
}
}
static int android_init_functions(struct android_usb_function **functions,
struct usb_composite_dev *cdev)
{
struct android_dev *dev = cdev_to_android_dev(cdev);
struct android_usb_function *f;
struct device_attribute **attrs;
struct device_attribute *attr;
int err = 0;
int index = 1; /* index 0 is for android0 device */
for (; (f = *functions++); index++) {
f->dev_name = kasprintf(GFP_KERNEL, "f_%s", f->name);
f->android_dev = NULL;
if (!f->dev_name) {
err = -ENOMEM;
goto err_out;
}
f->dev = device_create(android_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_init;
}
}
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_attrs;
}
}
return 0;
err_attrs:
for (attr = *(attrs -= 2); attrs != f->attributes; attr = *(attrs--))
device_remove_file(f->dev, attr);
if (f->cleanup)
f->cleanup(f);
err_init:
device_destroy(android_class, f->dev->devt);
err_create:
f->dev = NULL;
kfree(f->dev_name);
err_out:
android_cleanup_functions(dev->functions);
return err;
}
static int
android_bind_enabled_functions(struct android_dev *dev,
struct usb_configuration *c)
{
struct android_usb_function_holder *f_holder;
struct android_configuration *conf =
container_of(c, struct android_configuration, usb_config);
int ret;
list_for_each_entry(f_holder, &conf->enabled_functions, enabled_list) {
ret = f_holder->f->bind_config(f_holder->f, c);
if (ret) {
pr_err("%s: %s failed\n", __func__, f_holder->f->name);
while (!list_empty(&c->functions)) {
struct usb_function *f;
f = list_first_entry(&c->functions,
struct usb_function, list);
list_del(&f->list);
if (f->unbind)
f->unbind(c, f);
}
if (c->unbind)
c->unbind(c);
return ret;
}
}
return 0;
}
static void
android_unbind_enabled_functions(struct android_dev *dev,
struct usb_configuration *c)
{
struct android_usb_function_holder *f_holder;
struct android_configuration *conf =
container_of(c, struct android_configuration, usb_config);
list_for_each_entry(f_holder, &conf->enabled_functions, enabled_list) {
if (f_holder->f->unbind_config)
f_holder->f->unbind_config(f_holder->f, c);
}
}
static int android_enable_function(struct android_dev *dev,
struct android_configuration *conf,
char *name)
{
struct android_usb_function **functions = dev->functions;
struct android_usb_function *f;
struct android_usb_function_holder *f_holder;
while ((f = *functions++)) {
if (!strcmp(name, f->name)) {
if (f->android_dev && f->android_dev != dev)
pr_err("%s is enabled in other device\n",
f->name);
else {
f_holder = kzalloc(sizeof(*f_holder),
GFP_KERNEL);
if (!f_holder) {
pr_err("Failed to alloc f_holder\n");
return -ENOMEM;
}
f->android_dev = dev;
f_holder->f = f;
list_add_tail(&f_holder->enabled_list,
&conf->enabled_functions);
return 0;
}
}
}
return -EINVAL;
}
/*-------------------------------------------------------------------------*/
/* /sys/class/android_usb/android%d/ interface */
static ssize_t remote_wakeup_show(struct device *pdev,
struct device_attribute *attr, char *buf)
{
struct android_dev *dev = dev_get_drvdata(pdev);
struct android_configuration *conf;
/*
* Show the wakeup attribute of the first configuration,
* since all configurations have the same wakeup attribute
*/
if (dev->configs_num == 0)
return 0;
conf = list_entry(dev->configs.next,
struct android_configuration,
list_item);
return snprintf(buf, PAGE_SIZE, "%d\n",
!!(conf->usb_config.bmAttributes &
USB_CONFIG_ATT_WAKEUP));
}
static ssize_t remote_wakeup_store(struct device *pdev,
struct device_attribute *attr, const char *buff, size_t size)
{
struct android_dev *dev = dev_get_drvdata(pdev);
struct android_configuration *conf;
int enable = 0;
sscanf(buff, "%d", &enable);
pr_debug("android_usb: %s remote wakeup\n",
enable ? "enabling" : "disabling");
list_for_each_entry(conf, &dev->configs, list_item)
if (enable)
conf->usb_config.bmAttributes |=
USB_CONFIG_ATT_WAKEUP;
else
conf->usb_config.bmAttributes &=
~USB_CONFIG_ATT_WAKEUP;
return size;
}
static ssize_t
functions_show(struct device *pdev, struct device_attribute *attr, char *buf)
{
struct android_dev *dev = dev_get_drvdata(pdev);
struct android_configuration *conf;
struct android_usb_function_holder *f_holder;
char *buff = buf;
mutex_lock(&dev->mutex);
list_for_each_entry(conf, &dev->configs, list_item) {
if (buff != buf)
*(buff-1) = ':';
list_for_each_entry(f_holder, &conf->enabled_functions,
enabled_list)
buff += snprintf(buff, PAGE_SIZE, "%s,",
f_holder->f->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 android_dev *dev = dev_get_drvdata(pdev);
struct list_head *curr_conf = &dev->configs;
struct android_configuration *conf;
char *conf_str;
struct android_usb_function_holder *f_holder;
char *name;
char buf[256], *b;
int err;
mutex_lock(&dev->mutex);
if (dev->enabled) {
mutex_unlock(&dev->mutex);
return -EBUSY;
}
/* Clear previous enabled list */
list_for_each_entry(conf, &dev->configs, list_item) {
while (conf->enabled_functions.next !=
&conf->enabled_functions) {
f_holder = list_entry(conf->enabled_functions.next,
typeof(*f_holder),
enabled_list);
f_holder->f->android_dev = NULL;
list_del(&f_holder->enabled_list);
kfree(f_holder);
}
INIT_LIST_HEAD(&conf->enabled_functions);
}
strlcpy(buf, buff, sizeof(buf));
b = strim(buf);
while (b) {
conf_str = strsep(&b, ":");
if (conf_str) {
/* If the next not equal to the head, take it */
if (curr_conf->next != &dev->configs)
conf = list_entry(curr_conf->next,
struct android_configuration,
list_item);
else
conf = alloc_android_config(dev);
curr_conf = curr_conf->next;
}
while (conf_str) {
name = strsep(&conf_str, ",");
if (name) {
err = android_enable_function(dev, conf, name);
if (err)
pr_err("android_usb: Cannot enable %s",
name);
}
}
}
/* Free uneeded configurations if exists */
while (curr_conf->next != &dev->configs) {
conf = list_entry(curr_conf->next,
struct android_configuration, list_item);
free_android_config(dev, conf);
}
mutex_unlock(&dev->mutex);
return size;
}
static ssize_t enable_show(struct device *pdev, struct device_attribute *attr,
char *buf)
{
struct android_dev *dev = dev_get_drvdata(pdev);
return snprintf(buf, PAGE_SIZE, "%d\n", dev->enabled);
}
static ssize_t enable_store(struct device *pdev, struct device_attribute *attr,
const char *buff, size_t size)
{
struct android_dev *dev = dev_get_drvdata(pdev);
struct usb_composite_dev *cdev = dev->cdev;
struct android_usb_function_holder *f_holder;
struct android_configuration *conf;
int enabled = 0;
bool audio_enabled = false;
static DEFINE_RATELIMIT_STATE(rl, 10*HZ, 1);
int err = 0;
if (!cdev)
return -ENODEV;
mutex_lock(&dev->mutex);
sscanf(buff, "%d", &enabled);
if (enabled && !dev->enabled) {
/*
* Update values in composite driver's copy of
* device descriptor.
*/
cdev->desc.idVendor = device_desc.idVendor;
cdev->desc.idProduct = device_desc.idProduct;
cdev->desc.bcdDevice = device_desc.bcdDevice;
cdev->desc.bDeviceClass = device_desc.bDeviceClass;
cdev->desc.bDeviceSubClass = device_desc.bDeviceSubClass;
cdev->desc.bDeviceProtocol = device_desc.bDeviceProtocol;
/* Audio dock accessory is unable to enumerate device if
* pull-up is enabled immediately. The enumeration is
* reliable with 100 msec delay.
*/
list_for_each_entry(conf, &dev->configs, list_item)
list_for_each_entry(f_holder, &conf->enabled_functions,
enabled_list) {
if (f_holder->f->enable)
f_holder->f->enable(f_holder->f);
if (!strncmp(f_holder->f->name,
"audio_source", 12))
audio_enabled = true;
}
if (audio_enabled)
msleep(100);
err = android_enable(dev);
if (err < 0) {
pr_err("%s: android_enable failed\n", __func__);
dev->connected = 0;
dev->enabled = false;
mutex_unlock(&dev->mutex);
return size;
}
dev->enabled = true;
} else if (!enabled && dev->enabled) {
android_disable(dev);
list_for_each_entry(conf, &dev->configs, list_item)
list_for_each_entry(f_holder, &conf->enabled_functions,
enabled_list) {
if (f_holder->f->disable)
f_holder->f->disable(f_holder->f);
}
dev->enabled = false;
} else if (__ratelimit(&rl)) {
pr_err("android_usb: already %s\n",
dev->enabled ? "enabled" : "disabled");
}
mutex_unlock(&dev->mutex);
return size;
}
static ssize_t pm_qos_show(struct device *pdev,
struct device_attribute *attr, char *buf)
{
struct android_dev *dev = dev_get_drvdata(pdev);
return snprintf(buf, PAGE_SIZE, "%s\n", dev->pm_qos);
}
static ssize_t pm_qos_store(struct device *pdev,
struct device_attribute *attr,
const char *buff, size_t size)
{
struct android_dev *dev = dev_get_drvdata(pdev);
strlcpy(dev->pm_qos, buff, sizeof(dev->pm_qos));
return size;
}
static ssize_t state_show(struct device *pdev, struct device_attribute *attr,
char *buf)
{
struct android_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 snprintf(buf, PAGE_SIZE, "%s\n", state);
}
#define DESCRIPTOR_ATTR(field, format_string) \
static ssize_t \
field ## _show(struct device *dev, struct device_attribute *attr, \
char *buf) \
{ \
return snprintf(buf, PAGE_SIZE, \
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);
#define DESCRIPTOR_STRING_ATTR(field, buffer) \
static ssize_t \
field ## _show(struct device *dev, struct device_attribute *attr, \
char *buf) \
{ \
return snprintf(buf, PAGE_SIZE, "%s", buffer); \
} \
static ssize_t \
field ## _store(struct device *dev, struct device_attribute *attr, \
const char *buf, size_t size) \
{ \
if (size >= sizeof(buffer)) \
return -EINVAL; \
strlcpy(buffer, buf, sizeof(buffer)); \
strim(buffer); \
return size; \
} \
static DEVICE_ATTR(field, S_IRUGO | S_IWUSR, field ## _show, field ## _store);
DESCRIPTOR_ATTR(idVendor, "%04x\n")
DESCRIPTOR_ATTR(idProduct, "%04x\n")
DESCRIPTOR_ATTR(bcdDevice, "%04x\n")
DESCRIPTOR_ATTR(bDeviceClass, "%d\n")
DESCRIPTOR_ATTR(bDeviceSubClass, "%d\n")
DESCRIPTOR_ATTR(bDeviceProtocol, "%d\n")
DESCRIPTOR_STRING_ATTR(iManufacturer, manufacturer_string)
DESCRIPTOR_STRING_ATTR(iProduct, product_string)
DESCRIPTOR_STRING_ATTR(iSerial, serial_string)
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(pm_qos, S_IRUGO | S_IWUSR,
pm_qos_show, pm_qos_store);
static DEVICE_ATTR(state, S_IRUGO, state_show, NULL);
static DEVICE_ATTR(remote_wakeup, S_IRUGO | S_IWUSR,
remote_wakeup_show, remote_wakeup_store);
static struct device_attribute *android_usb_attributes[] = {
&dev_attr_idVendor,
&dev_attr_idProduct,
&dev_attr_bcdDevice,
&dev_attr_bDeviceClass,
&dev_attr_bDeviceSubClass,
&dev_attr_bDeviceProtocol,
&dev_attr_iManufacturer,
&dev_attr_iProduct,
&dev_attr_iSerial,
&dev_attr_functions,
&dev_attr_enable,
&dev_attr_pm_qos,
&dev_attr_state,
&dev_attr_remote_wakeup,
NULL
};
/*-------------------------------------------------------------------------*/
/* Composite driver */
static int android_bind_config(struct usb_configuration *c)
{
struct android_dev *dev = cdev_to_android_dev(c->cdev);
int ret = 0;
ret = android_bind_enabled_functions(dev, c);
if (ret)
return ret;
return 0;
}
static void android_unbind_config(struct usb_configuration *c)
{
struct android_dev *dev = cdev_to_android_dev(c->cdev);
android_unbind_enabled_functions(dev, c);
}
static int android_bind(struct usb_composite_dev *cdev)
{
struct android_dev *dev;
struct usb_gadget *gadget = cdev->gadget;
struct android_configuration *conf;
int gcnum, id, ret;
/* Bind to the last android_dev that was probed */
dev = list_entry(android_dev_list.prev, struct android_dev, list_item);
dev->cdev = cdev;
/*
* Start disconnected. Userspace will connect the gadget once
* it is done configuring the functions.
*/
usb_gadget_disconnect(gadget);
/* Init the supported functions only once, on the first android_dev */
if (android_dev_count == 1) {
ret = android_init_functions(dev->functions, cdev);
if (ret)
return ret;
}
/* Allocate string descriptor numbers ... note that string
* contents can be overridden by the composite_dev glue.
*/
id = usb_string_id(cdev);
if (id < 0)
return id;
strings_dev[STRING_MANUFACTURER_IDX].id = id;
device_desc.iManufacturer = id;
id = usb_string_id(cdev);
if (id < 0)
return id;
strings_dev[STRING_PRODUCT_IDX].id = id;
device_desc.iProduct = id;
/* Default strings - should be updated by userspace */
strlcpy(manufacturer_string, "Android",
sizeof(manufacturer_string) - 1);
strlcpy(product_string, "Android", sizeof(product_string) - 1);
strlcpy(serial_string, "0123456789ABCDEF", sizeof(serial_string) - 1);
id = usb_string_id(cdev);
if (id < 0)
return id;
strings_dev[STRING_SERIAL_IDX].id = id;
device_desc.iSerialNumber = id;
if (gadget_is_otg(cdev->gadget))
list_for_each_entry(conf, &dev->configs, list_item)
conf->usb_config.descriptors = otg_desc;
gcnum = usb_gadget_controller_number(gadget);
if (gcnum >= 0)
device_desc.bcdDevice = cpu_to_le16(0x0200 + gcnum);
else {
pr_warning("%s: controller '%s' not recognized\n",
longname, gadget->name);
device_desc.bcdDevice = __constant_cpu_to_le16(0x9999);
}
return 0;
}
static int android_usb_unbind(struct usb_composite_dev *cdev)
{
struct android_dev *dev = cdev_to_android_dev(cdev);
manufacturer_string[0] = '\0';
product_string[0] = '\0';
serial_string[0] = '0';
cancel_work_sync(&dev->work);
android_cleanup_functions(dev->functions);
return 0;
}
static struct usb_composite_driver android_usb_driver = {
.name = "android_usb",
.dev = &device_desc,
.strings = dev_strings,
.unbind = android_usb_unbind,
.max_speed = USB_SPEED_SUPER
};
static int
android_setup(struct usb_gadget *gadget, const struct usb_ctrlrequest *c)
{
struct usb_composite_dev *cdev = get_gadget_data(gadget);
struct android_dev *dev = cdev_to_android_dev(cdev);
struct usb_request *req = cdev->req;
struct android_usb_function *f;
struct android_usb_function_holder *f_holder;
struct android_configuration *conf;
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(conf, &dev->configs, list_item)
list_for_each_entry(f_holder,
&conf->enabled_functions,
enabled_list) {
f = f_holder->f;
if (f->ctrlrequest) {
value = f->ctrlrequest(f, cdev, c);
if (value >= 0)
break;
}
}
/* Special case the accessory function.
* It needs to handle control requests before it is enabled.
*/
if (value < 0)
value = acc_ctrlrequest(cdev, c);
if (value < 0)
value = composite_setup(gadget, c);
/*[yanghuaying] when device discnnect from pc, it will first receive a
suspend event,but when reconnect to pc,may not receive corresponding
resume event(may just receive a connect event), now reinit in_suspend_mode*/
in_suspend_mode = 0;
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 android_disconnect(struct usb_gadget *gadget)
{
struct usb_composite_dev *cdev = get_gadget_data(gadget);
struct android_dev *dev = cdev_to_android_dev(cdev);
unsigned long flags;
composite_disconnect(gadget);
/* accessory HID support can be active while the
accessory function is not actually enabled,
so we need to inform it when we are disconnected.
*/
acc_disconnect();
spin_lock_irqsave(&cdev->lock, flags);
dev->connected = 0;
schedule_work(&dev->work);
spin_unlock_irqrestore(&cdev->lock, flags);
}
static void android_suspend(struct usb_gadget *gadget)
{
struct usb_composite_dev *cdev = get_gadget_data(gadget);
struct android_dev *dev = cdev_to_android_dev(cdev);
unsigned long flags;
/*[yanghuaying] when device connect to pc by hub, afetr hub disconnect
from pc,device will go into suspend mode(a suspend event,not a
disconnect event),mass storage function is unusable*/
in_suspend_mode = 1;
spin_lock_irqsave(&cdev->lock, flags);
dev->suspended = 1;
schedule_work(&dev->work);
spin_unlock_irqrestore(&cdev->lock, flags);
composite_suspend(gadget);
}
static void android_resume(struct usb_gadget *gadget)
{
struct usb_composite_dev *cdev = get_gadget_data(gadget);
struct android_dev *dev = cdev_to_android_dev(cdev);
unsigned long flags;
/*[yanghuaying] when device connect to pc by hub, afetr hub reconnect to pc
device will leave suspend mode,mass storage function is usable again*/
in_suspend_mode = 0;
spin_lock_irqsave(&cdev->lock, flags);
dev->suspended = 0;
schedule_work(&dev->work);
spin_unlock_irqrestore(&cdev->lock, flags);
composite_resume(gadget);
}
static int android_create_device(struct android_dev *dev, u8 usb_core_id)
{
struct device_attribute **attrs = android_usb_attributes;
struct device_attribute *attr;
char device_node_name[ANDROID_DEVICE_NODE_NAME_LENGTH];
int err;
/*
* The primary usb core should always have usb_core_id=0, since
* Android user space is currently interested in android0 events.
*/
snprintf(device_node_name, ANDROID_DEVICE_NODE_NAME_LENGTH,
"android%d", usb_core_id);
dev->dev = device_create(android_class, NULL,
MKDEV(0, 0), NULL, device_node_name);
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(android_class, dev->dev->devt);
return err;
}
}
return 0;
}
static void android_destroy_device(struct android_dev *dev)
{
struct device_attribute **attrs = android_usb_attributes;
struct device_attribute *attr;
while ((attr = *attrs++))
device_remove_file(dev->dev, attr);
device_destroy(android_class, dev->dev->devt);
}
static struct android_dev *cdev_to_android_dev(struct usb_composite_dev *cdev)
{
struct android_dev *dev = NULL;
/* Find the android dev from the list */
list_for_each_entry(dev, &android_dev_list, list_item) {
if (dev->cdev == cdev)
break;
}
return dev;
}
static struct android_configuration *alloc_android_config
(struct android_dev *dev)
{
struct android_configuration *conf;
conf = kzalloc(sizeof(*conf), GFP_KERNEL);
if (!conf) {
pr_err("%s(): Failed to alloc memory for android conf\n",
__func__);
return ERR_PTR(-ENOMEM);
}
dev->configs_num++;
conf->usb_config.label = dev->name;
conf->usb_config.unbind = android_unbind_config;
conf->usb_config.bConfigurationValue = dev->configs_num;
INIT_LIST_HEAD(&conf->enabled_functions);
list_add_tail(&conf->list_item, &dev->configs);
return conf;
}
static void free_android_config(struct android_dev *dev,
struct android_configuration *conf)
{
list_del(&conf->list_item);
dev->configs_num--;
kfree(conf);
}
static int usb_diag_update_pid_and_serial_num(u32 pid, const char *snum)
{
struct dload_struct local_diag_dload = { 0 };
int *src, *dst, i;
if (!diag_dload) {
pr_debug("%s: unable to update PID and serial_no\n", __func__);
return -ENODEV;
}
pr_debug("%s: dload:%p pid:%x serial_num:%s\n",
__func__, diag_dload, pid, snum);
/* update pid */
local_diag_dload.magic_struct.pid = PID_MAGIC_ID;
local_diag_dload.pid = pid;
/* update serial number */
if (!snum) {
local_diag_dload.magic_struct.serial_num = 0;
memset(&local_diag_dload.serial_number, 0,
SERIAL_NUMBER_LENGTH);
} else {
local_diag_dload.magic_struct.serial_num = SERIAL_NUM_MAGIC_ID;
strlcpy((char *)&local_diag_dload.serial_number, snum,
SERIAL_NUMBER_LENGTH);
}
/* Copy to shared struct (accesses need to be 32 bit aligned) */
src = (int *)&local_diag_dload;
dst = (int *)diag_dload;
for (i = 0; i < sizeof(*diag_dload) / 4; i++)
*dst++ = *src++;
return 0;
}
static int __devinit android_probe(struct platform_device *pdev)
{
struct android_usb_platform_data *pdata;
struct android_dev *android_dev;
struct resource *res;
int ret = 0;
if (pdev->dev.of_node) {
dev_dbg(&pdev->dev, "device tree enabled\n");
pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
if (!pdata) {
pr_err("unable to allocate platform data\n");
return -ENOMEM;
}
of_property_read_u32(pdev->dev.of_node,
"qcom,android-usb-swfi-latency",
&pdata->swfi_latency);
pdata->cdrom = of_property_read_bool(pdev->dev.of_node,
"qcom,android-usb-cdrom");
} else {
pdata = pdev->dev.platform_data;
}
if (!android_class) {
android_class = class_create(THIS_MODULE, "android_usb");
if (IS_ERR(android_class))
return PTR_ERR(android_class);
}
android_dev = kzalloc(sizeof(*android_dev), GFP_KERNEL);
if (!android_dev) {
pr_err("%s(): Failed to alloc memory for android_dev\n",
__func__);
ret = -ENOMEM;
goto err_alloc;
}
android_dev->name = pdev->name;
android_dev->disable_depth = 1;
android_dev->functions = supported_functions;
android_dev->configs_num = 0;
INIT_LIST_HEAD(&android_dev->configs);
INIT_WORK(&android_dev->work, android_work);
mutex_init(&android_dev->mutex);
android_dev->pdata = pdata;
list_add_tail(&android_dev->list_item, &android_dev_list);
android_dev_count++;
if (pdata)
composite_driver.usb_core_id = pdata->usb_core_id;
else
composite_driver.usb_core_id = 0; /*To backward compatibility*/
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (res) {
diag_dload = devm_ioremap(&pdev->dev, res->start,
resource_size(res));
if (!diag_dload) {
dev_err(&pdev->dev, "ioremap failed\n");
ret = -ENOMEM;
goto err_dev;
}
} else {
dev_dbg(&pdev->dev, "failed to get mem resource\n");
}
ret = android_create_device(android_dev, composite_driver.usb_core_id);
if (ret) {
pr_err("%s(): android_create_device failed\n", __func__);
goto err_dev;
}
ret = usb_composite_probe(&android_usb_driver, android_bind);
if (ret) {
pr_err("%s(): Failed to register android "
"composite driver\n", __func__);
goto err_probe;
}
/* pm qos request to prevent apps idle power collapse */
if (pdata && pdata->swfi_latency)
pm_qos_add_request(&android_dev->pm_qos_req_dma,
PM_QOS_CPU_DMA_LATENCY, PM_QOS_DEFAULT_VALUE);
strlcpy(android_dev->pm_qos, "high", sizeof(android_dev->pm_qos));
return ret;
err_probe:
android_destroy_device(android_dev);
err_dev:
list_del(&android_dev->list_item);
android_dev_count--;
kfree(android_dev);
err_alloc:
if (list_empty(&android_dev_list)) {
class_destroy(android_class);
android_class = NULL;
}
return ret;
}
static int android_remove(struct platform_device *pdev)
{
struct android_dev *dev = NULL;
struct android_usb_platform_data *pdata = pdev->dev.platform_data;
int usb_core_id = 0;
if (pdata)
usb_core_id = pdata->usb_core_id;
/* Find the android dev from the list */
list_for_each_entry(dev, &android_dev_list, list_item) {
if (!dev->pdata)
break; /*To backward compatibility*/
if (dev->pdata->usb_core_id == usb_core_id)
break;
}
if (dev) {
android_destroy_device(dev);
if (pdata && pdata->swfi_latency)
pm_qos_remove_request(&dev->pm_qos_req_dma);
list_del(&dev->list_item);
android_dev_count--;
kfree(dev);
}
if (list_empty(&android_dev_list)) {
class_destroy(android_class);
android_class = NULL;
usb_composite_unregister(&android_usb_driver);
}
return 0;
}
static const struct platform_device_id android_id_table[] __devinitconst = {
{
.name = "android_usb",
},
{
.name = "android_usb_hsic",
},
};
static struct of_device_id usb_android_dt_match[] = {
{ .compatible = "qcom,android-usb",
},
{}
};
static struct platform_driver android_platform_driver = {
.driver = {
.name = "android_usb",
.of_match_table = usb_android_dt_match,
},
.probe = android_probe,
.remove = android_remove,
.id_table = android_id_table,
};
static int __init init(void)
{
int ret;
/* Override composite driver functions */
composite_driver.setup = android_setup;
composite_driver.disconnect = android_disconnect;
composite_driver.suspend = android_suspend;
composite_driver.resume = android_resume;
INIT_LIST_HEAD(&android_dev_list);
android_dev_count = 0;
ret = platform_driver_register(&android_platform_driver);
if (ret) {
pr_err("%s(): Failed to register android"
"platform driver\n", __func__);
}
return ret;
}
module_init(init);
static void __exit cleanup(void)
{
platform_driver_unregister(&android_platform_driver);
}
module_exit(cleanup);
Reference in New Issue Copy Permalink