ASR_BASE
Change-Id: Icf3719cc0afe3eeb3edc7fa80a2eb5199ca9dda1
diff --git a/marvell/linux/drivers/usb/gadget/android.c b/marvell/linux/drivers/usb/gadget/android.c
new file mode 100644
index 0000000..c70e793
--- /dev/null
+++ b/marvell/linux/drivers/usb/gadget/android.c
@@ -0,0 +1,3269 @@
+/*
+ * 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/usb/ch9.h>
+#include <linux/usb/composite.h>
+#include <linux/usb/gadget.h>
+#include <linux/completion.h>
+#include "./function/gadget_chips.h"
+
+#include "./function/f_adb.c"
+
+#ifndef CONFIG_USB_TELEPHONY
+#include "./function/pxa910_u_serial.c"
+#include "./function/pxa910_f_diag.c"
+#include "./function/pxa910_f_modem.c"
+#endif
+
+#if !defined(CONFIG_CPU_ASR18XX) && !defined(CONFIG_CPU_ASR1901)
+#include "./function/f_fs.c"
+#endif
+
+#ifndef CONFIG_USB_TELEPHONY
+#include "./function/pxa182x_serial_debug.c"
+#include "./function/pxa182x_acm_debug.c"
+#endif
+
+#if !defined(CONFIG_CPU_ASR18XX) && !defined(CONFIG_CPU_ASR1901)
+#include "./function/f_midi.c"
+#include "./function/f_audio_source.c"
+#include "./function/f_accessory.c"
+#endif
+
+#define DEF_CDROM_PATH "/etc/cdrom/CDROM.iso"
+#define APPLE_CDROM_PATH "/etc/cdrom/CDROM.iso"
+#define LINUX_CDROM_PATH "/etc/cdrom/CDROM.iso"
+#define WIN_CDROM_PATH "/etc/cdrom/CDROM.iso"
+
+#include "./function/f_mass_storage.c"
+
+#if !defined(CONFIG_CPU_ASR18XX) && !defined(CONFIG_CPU_ASR1901)
+#include "./function/f_mtp.c"
+#endif
+
+#define USB_ETH_RNDIS y
+#include "./function/f_rndis.c"
+#include "./function/rndis.c"
+#if defined(CONFIG_CPU_ASR18XX) || defined(CONFIG_CPU_ASR1901)
+#include "./function/f_ecm.c"
+#endif
+
+#if defined(CONFIG_USB_ETH_RNDIS_ECM)
+#include "./function/u_ether_rndis_ecm.c"
+#elif defined(CONFIG_ASR_TOE)
+#include "./function/u_ether_toe.c"
+#else
+#include "./function/u_ether.c"
+#endif
+
+#if defined (CONFIG_USB_G_MBIM)
+#include "./function/f_mbim.c"
+#endif
+
+#if defined (CONFIG_USB_TELEPHONY)
+#include "f_usbtel.c"
+#endif
+
+#if defined (CONFIG_ASR_UAC1)
+#include "./function/u_asr_uac1.c"
+#endif
+
+MODULE_AUTHOR("Mike Lockwood");
+MODULE_DESCRIPTION("Android Composite USB Driver");
+MODULE_LICENSE("GPL");
+MODULE_VERSION("1.0");
+
+
+static const char longname[] = "Gadget Android";
+
+#if defined (CONFIG_USB_G_MBIM)
+static bool mbim_enabled = 0;
+#endif
+
+/* Default vendor and product IDs, overridden by userspace */
+#define VENDOR_ID 0x18D1
+#define PRODUCT_ID 0x0001
+
+#if !defined(CONFIG_CPU_ASR18XX) && !defined(CONFIG_CPU_ASR1901)
+/* f_midi configuration */
+#define MIDI_INPUT_PORTS 1
+#define MIDI_OUTPUT_PORTS 1
+#define MIDI_BUFFER_SIZE 256
+#define MIDI_QUEUE_LENGTH 32
+#endif
+
+struct android_usb_function {
+ char *name;
+ void *config;
+
+ struct device *dev;
+ char *dev_name;
+ struct device_attribute **attributes;
+
+ /* for android_dev.enabled_functions */
+ struct list_head enabled_list;
+
+ /* 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 *);
+};
+#ifdef CONFIG_USB_ANDROID_DETECT_HOST_OS
+struct acm_dev_paramter {
+ int instances;
+};
+struct uac1_dev_paramter {
+ int instances;
+};
+struct rndis_dev_paramter {
+ u32 vendorID;
+ char manufacturer[256];
+ bool wceis;
+};
+struct gser_dev_paramter {
+ int instances;
+};
+#endif
+struct android_dev {
+ struct android_usb_function **functions;
+ struct list_head enabled_functions;
+ struct usb_composite_dev *cdev;
+ struct device *dev;
+
+ void (*setup_complete)(struct usb_ep *ep,
+ struct usb_request *req);
+
+ bool enabled;
+ int disable_depth;
+ struct mutex mutex;
+ bool connected;
+ bool sw_connected;
+ struct work_struct work;
+ char ffs_aliases[256];
+#ifdef CONFIG_USB_ANDROID_DETECT_HOST_OS
+ struct acm_dev_paramter acm_paramter;
+#ifdef CONFIG_ASR_UAC1
+ struct uac1_dev_paramter uac1_paramter;
+#endif
+ struct rndis_dev_paramter rndis_paramter;
+ struct gser_dev_paramter gser_paramter;
+#endif
+#ifdef CONFIG_USB_REMOTE_WAKEUP
+ bool remote_wakeup_enable;
+ #if defined(CONFIG_CPU_ASR18XX) || defined(CONFIG_CPU_ASR1901)
+ char ethaddr[32];
+ #endif
+ struct list_head evt_list;
+#endif
+};
+
+enum {
+ USB_DEV_DISCONNECT,
+ USB_DEV_CONNECT,
+ USB_DEV_CONFIGURE,
+ NR_USB_DEV_EVENT,
+};
+
+struct android_dev_event {
+ struct list_head list;
+ u32 event_code;
+};
+
+static struct class *android_class;
+static struct android_dev *_android_dev;
+static int android_bind_config(struct usb_configuration *c);
+static void android_unbind_config(struct usb_configuration *c);
+
+/* 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_MISC /* 0xEF */,
+ .bDeviceSubClass = 2,
+ .bDeviceProtocol = 1,
+ .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 android_config_driver = {
+ .label = "android",
+ .unbind = android_unbind_config,
+ .bConfigurationValue = 1,
+};
+
+#ifdef CONFIG_USB_ETH_RNDIS_ECM
+static bool is_rndis_enabled = false;
+#endif
+
+static struct android_dev_event *create_dev_evt(u32 evt_code)
+{
+ struct android_dev_event *evt;
+
+ evt = kzalloc(sizeof(*evt), GFP_ATOMIC);
+ if (unlikely(!evt)) {
+ pr_err("%s: failed to alloc dev evt\n", __func__);
+ return NULL;
+ }
+
+ evt->event_code = evt_code;
+ return evt;
+}
+
+#if defined(CONFIG_CPU_ASR18XX) || defined(CONFIG_CPU_ASR1901)
+static void save_net_mac(char *hostaddr)
+{
+ struct android_dev *dev = _android_dev;
+ sprintf(dev->ethaddr , "USB_MAC=%pM" , hostaddr);
+}
+#endif
+
+static void _android_work(struct android_dev *dev, u32 evt_code)
+{
+ struct usb_composite_dev *cdev = dev->cdev;
+ char *disconnected[2] = { "USB_STATE=DISCONNECTED", NULL };
+ char *connected[2] = { "USB_STATE=CONNECTED", NULL };
+ #if defined(CONFIG_CPU_ASR18XX) || defined(CONFIG_CPU_ASR1901)
+ char *configured[3] = { "USB_STATE=CONFIGURED", dev->ethaddr , NULL };
+ #else
+ char *configured[2] = { "USB_STATE=CONFIGURED", NULL };
+ #endif
+ char **uevent_envp = NULL;
+
+ if (!cdev) {
+ pr_err("comp dev is NULL\n");
+ return;
+ }
+
+ if (USB_DEV_CONFIGURE == evt_code) {
+ uevent_envp = configured;
+ dev->sw_connected = true;
+ } else if (USB_DEV_DISCONNECT == evt_code) {
+ uevent_envp = disconnected;
+ dev->sw_connected = false;
+ } else {
+ uevent_envp = connected;
+ dev->sw_connected = true;
+ }
+
+ if (uevent_envp) {
+#ifndef CONFIG_USB_TELEPHONY
+ kobject_uevent_env(&dev->dev->kobj, KOBJ_CHANGE, uevent_envp);
+ pr_info("%s:%d: sent uevent %s %d:%p\n",
+ __func__, evt_code, uevent_envp[0],
+ dev->connected, cdev->config);
+ if (USB_DEV_DISCONNECT == evt_code)
+ msleep(100);
+#endif
+ } else {
+ pr_info("%s: did not send uevent (%d %d %p)\n", __func__,
+ dev->connected, dev->sw_connected, cdev->config);
+ }
+}
+
+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;
+ unsigned long flags;
+ struct android_dev_event *evt;
+
+ if (!cdev)
+ return;
+
+ spin_lock_irqsave(&cdev->lock, flags);
+ while (!list_empty(&dev->evt_list)) {
+ evt = list_entry(dev->evt_list.next, struct android_dev_event, list);
+ list_del_init(&evt->list);
+ spin_unlock_irqrestore(&cdev->lock, flags);
+ _android_work(dev, evt->event_code);
+ kfree(evt);
+ spin_lock_irqsave(&cdev->lock, flags);
+ }
+ spin_unlock_irqrestore(&cdev->lock, flags);
+}
+
+static void android_enable(struct android_dev *dev)
+{
+ struct usb_composite_dev *cdev = dev->cdev;
+
+ if (WARN_ON(!dev->disable_depth))
+ return;
+ pr_err("USB_Debug Enter android_enable:%d\n", dev->disable_depth);
+ if (--dev->disable_depth == 0) {
+ usb_add_config(cdev, &android_config_driver,
+ android_bind_config);
+ usb_gadget_connect(cdev->gadget);
+ }
+ pr_debug("USB_Debug Exit android_enable:%d\n", dev->disable_depth);
+}
+
+extern bool dwc3_hwsulog_is_on(void);
+#ifdef CONFIG_DWC3_HWSULOG
+static void android_disconnect(struct usb_composite_dev *cdev);
+#endif
+
+static void android_disable(struct android_dev *dev)
+{
+ struct usb_composite_dev *cdev = dev->cdev;
+ pr_err("USB_Debug Enter android_disable:%d\n", dev->disable_depth);
+ if (dev->disable_depth++ == 0) {
+#ifdef CONFIG_DWC3_HWSULOG
+ if (dwc3_hwsulog_is_on()) {
+ android_disconnect(cdev);
+ mutex_unlock(&dev->mutex);
+ msleep(2000);
+ pr_err("hwsulog stop done\n");
+ mutex_lock(&dev->mutex);
+ pr_err("usb stop\n");
+ }
+#endif
+ usb_gadget_disconnect(cdev->gadget);
+ /* Cancel pending control requests */
+ usb_ep_dequeue(cdev->gadget->ep0, cdev->req);
+ usb_remove_config(cdev, &android_config_driver);
+ }
+ pr_debug("USB_Debug Exit android_disable:%d\n", dev->disable_depth);
+}
+
+/*-------------------------------------------------------------------------*/
+/* Supported functions initialization */
+struct adb_data {
+ bool opened;
+ bool enabled;
+};
+
+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)
+{
+ int ret;
+ pr_debug("USB_Debug Enter adb_function_bind_config.\n");
+ ret = adb_bind_config(c);
+ pr_debug("USB_Debug Exit adb_function_bind_config.\n");
+ return ret;
+}
+
+static void adb_android_function_enable(struct android_usb_function *f)
+{
+#if !defined(CONFIG_CPU_ASR18XX) && !defined(CONFIG_CPU_ASR1901)
+ struct android_dev *dev = _android_dev;
+#endif
+ struct adb_data *data = f->config;
+ pr_debug("USB_Debug Enter adb_android_function_enable.\n");
+
+ data->enabled = true;
+#if !defined(CONFIG_CPU_ASR18XX) && !defined(CONFIG_CPU_ASR1901)
+ /* Disable the gadget until adbd is ready */
+ if (!data->opened)
+ android_disable(dev);
+#endif
+ pr_debug("USB_Debug Exit adb_android_function_enable.\n");
+
+}
+
+static void adb_android_function_disable(struct android_usb_function *f)
+{
+#if !defined(CONFIG_CPU_ASR18XX) && !defined(CONFIG_CPU_ASR1901)
+ struct android_dev *dev = _android_dev;
+#endif
+ struct adb_data *data = f->config;
+
+ data->enabled = false;
+
+#if !defined(CONFIG_CPU_ASR18XX) && !defined(CONFIG_CPU_ASR1901)
+ /* Balance the disable that was called in closed_callback */
+ if (!data->opened)
+ android_enable(dev);
+#endif
+}
+
+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 = _android_dev;
+ struct adb_data *data = adb_function.config;
+
+ mutex_lock(&dev->mutex);
+
+ data->opened = true;
+#if !defined(CONFIG_CPU_ASR18XX) && !defined(CONFIG_CPU_ASR1901)
+ if (data->enabled)
+ android_enable(dev);
+#endif
+ mutex_unlock(&dev->mutex);
+}
+
+static void adb_closed_callback(void)
+{
+ struct android_dev *dev = _android_dev;
+ struct adb_data *data = adb_function.config;
+
+ mutex_lock(&dev->mutex);
+
+ data->opened = false;
+#if !defined(CONFIG_CPU_ASR18XX) && !defined(CONFIG_CPU_ASR1901)
+ if (data->enabled)
+ android_disable(dev);
+#endif
+ mutex_unlock(&dev->mutex);
+}
+
+#ifdef CONFIG_USB_GADGET_CHARGE_ONLY
+static int charge_only_function_bind_config(struct android_usb_function *f,
+ struct usb_configuration *c)
+{
+ return 0;
+}
+
+static struct android_usb_function charge_only_function = {
+ .name = "charge_only",
+ .bind_config = charge_only_function_bind_config,
+};
+
+static int charge_only_connected;
+static int charge_only_configured;
+static int charge_only_disconnected;
+void charge_only_send_uevent(int event)
+{
+ struct android_dev *dev = _android_dev;
+ char *disconnected[2] = { "USB_STATE=DISCONNECTED", NULL };
+ char *connected[2] = { "USB_STATE=CONNECTED", NULL };
+ char *configured[2] = { "USB_STATE=CONFIGURED", NULL };
+
+ if (!dev)
+ return;
+
+ switch (event) {
+ case 1:
+ kobject_uevent_env(&dev->dev->kobj, KOBJ_CHANGE, connected);
+ charge_only_connected = 1;
+ charge_only_configured = 0;
+ charge_only_disconnected = 0;
+ break;
+ case 2:
+ kobject_uevent_env(&dev->dev->kobj, KOBJ_CHANGE, configured);
+ charge_only_connected = 1;
+ charge_only_configured = 1;
+ charge_only_disconnected = 0;
+ break;
+ case 3:
+ kobject_uevent_env(&dev->dev->kobj, KOBJ_CHANGE, disconnected);
+ charge_only_connected = 0;
+ charge_only_configured = 0;
+ charge_only_disconnected = 1;
+ break;
+ default:
+ charge_only_connected = 0;
+ charge_only_configured = 0;
+ charge_only_disconnected = 0;
+ break;
+ }
+}
+
+static int charge_only_mode;
+int is_charge_only_mode(void)
+{
+ return charge_only_mode;
+}
+#endif /* CONFIG_USB_GADGET_CHARGE_ONLY */
+
+#ifndef CONFIG_USB_TELEPHONY
+/* Marvell modem function initialization */
+static int marvell_modem_function_init(struct android_usb_function *f,
+ struct usb_composite_dev *cdev)
+{
+ return pxa910_modem_gserial_setup(cdev->gadget, 1);
+}
+
+static void marvell_modem_function_cleanup(struct android_usb_function *f)
+{
+ pxa910_modem_gserial_cleanup();
+}
+
+int marvell_modem_function_bind_config(struct android_usb_function *f,
+ struct usb_configuration *c)
+{
+ int ret;
+ pr_debug("USB_Debug Enter marvell_modem_function_bind_config.\n");
+ ret = pxa910_acm_bind_config(c, 0);
+ pr_debug("USB_Debug Exit marvell_modem_function_bind_config.\n");
+ return ret;
+}
+
+static struct android_usb_function marvell_modem_function = {
+ .name = "marvell_modem",
+ .init = marvell_modem_function_init,
+ .cleanup = marvell_modem_function_cleanup,
+ .bind_config = marvell_modem_function_bind_config,
+};
+
+/* Marvell diag function initialization */
+static int marvell_diag_function_init(struct android_usb_function *f,
+ struct usb_composite_dev *cdev)
+{
+ return pxa910_diag_gserial_setup(cdev->gadget, 1);
+}
+
+static void marvell_diag_function_cleanup(struct android_usb_function *f)
+{
+ pxa910_diag_gserial_cleanup();
+}
+
+int marvell_diag_function_bind_config(struct android_usb_function *f,
+ struct usb_configuration *c)
+{
+ int ret;
+ pr_debug("USB_Debug Enter marvell_diag_function_bind_config.\n");
+ ret = pxa910_diag_bind_config(c, 1);
+ pr_debug("USB_Debug Exit marvell_diag_function_bind_config:%d.\n", ret);
+ return ret;
+}
+
+static struct android_usb_function marvell_diag_function = {
+ .name = "marvell_diag",
+ .init = marvell_diag_function_init,
+ .cleanup = marvell_diag_function_cleanup,
+ .bind_config = marvell_diag_function_bind_config,
+};
+#endif
+
+#if !defined(CONFIG_CPU_ASR18XX) && !defined(CONFIG_CPU_ASR1901)
+struct functionfs_config {
+ bool opened;
+ bool enabled;
+ struct ffs_data *data;
+};
+
+static int ffs_function_init(struct android_usb_function *f,
+ struct usb_composite_dev *cdev)
+{
+ f->config = kzalloc(sizeof(struct functionfs_config), GFP_KERNEL);
+ if (!f->config)
+ return -ENOMEM;
+
+ return functionfs_init();
+}
+
+static void ffs_function_cleanup(struct android_usb_function *f)
+{
+ functionfs_cleanup();
+ kfree(f->config);
+}
+
+static void ffs_function_enable(struct android_usb_function *f)
+{
+ struct android_dev *dev = _android_dev;
+ struct functionfs_config *config = f->config;
+ pr_debug("USB_Debug Enter ffs_function_enable.\n");
+
+ config->enabled = true;
+
+ /* Disable the gadget until the function is ready */
+ if (!config->opened)
+ android_disable(dev);
+ pr_debug("USB_Debug Exit ffs_function_enable.\n");
+}
+
+static void ffs_function_disable(struct android_usb_function *f)
+{
+ struct android_dev *dev = _android_dev;
+ struct functionfs_config *config = f->config;
+
+ config->enabled = false;
+
+ /* Balance the disable that was called in closed_callback */
+ if (!config->opened)
+ android_enable(dev);
+}
+
+static int ffs_function_bind_config(struct android_usb_function *f,
+ struct usb_configuration *c)
+{
+ struct functionfs_config *config = f->config;
+ int ret;
+ pr_debug("USB_Debug Enter ffs_function_bind_config.\n");
+ ret = functionfs_bind_config(c->cdev, c, config->data);
+ pr_debug("USB_Debug Exit ffs_function_bind_config:%d.\n", ret);
+ return ret;
+}
+
+static ssize_t
+ffs_aliases_show(struct device *pdev, struct device_attribute *attr, char *buf)
+{
+ struct android_dev *dev = _android_dev;
+ int ret;
+
+ mutex_lock(&dev->mutex);
+ ret = sprintf(buf, "%s\n", dev->ffs_aliases);
+ mutex_unlock(&dev->mutex);
+
+ return ret;
+}
+
+static ssize_t
+ffs_aliases_store(struct device *pdev, struct device_attribute *attr,
+ const char *buf, size_t size)
+{
+ struct android_dev *dev = _android_dev;
+ char buff[256];
+
+ mutex_lock(&dev->mutex);
+
+ if (dev->enabled) {
+ mutex_unlock(&dev->mutex);
+ return -EBUSY;
+ }
+
+ strlcpy(buff, buf, sizeof(buff));
+ strlcpy(dev->ffs_aliases, strim(buff), sizeof(dev->ffs_aliases));
+
+ mutex_unlock(&dev->mutex);
+
+ return size;
+}
+
+static DEVICE_ATTR(aliases, S_IRUGO | S_IWUSR, ffs_aliases_show,
+ ffs_aliases_store);
+static struct device_attribute *ffs_function_attributes[] = {
+ &dev_attr_aliases,
+ NULL
+};
+
+static struct android_usb_function ffs_function = {
+ .name = "ffs",
+ .init = ffs_function_init,
+ .enable = ffs_function_enable,
+ .disable = ffs_function_disable,
+ .cleanup = ffs_function_cleanup,
+ .bind_config = ffs_function_bind_config,
+ .attributes = ffs_function_attributes,
+};
+
+static int functionfs_ready_callback(struct ffs_data *ffs)
+{
+ struct android_dev *dev = _android_dev;
+ struct functionfs_config *config = ffs_function.config;
+ int ret = 0;
+
+ mutex_lock(&dev->mutex);
+
+ ret = functionfs_bind(ffs, dev->cdev);
+ if (ret)
+ goto err;
+
+ config->data = ffs;
+ config->opened = true;
+
+ if (config->enabled)
+ android_enable(dev);
+
+err:
+ mutex_unlock(&dev->mutex);
+ return ret;
+}
+
+static void functionfs_closed_callback(struct ffs_data *ffs)
+{
+ struct android_dev *dev = _android_dev;
+ struct functionfs_config *config = ffs_function.config;
+
+ mutex_lock(&dev->mutex);
+
+ if (config->enabled)
+ android_disable(dev);
+
+ config->opened = false;
+ config->data = NULL;
+
+ functionfs_unbind(ffs);
+
+ mutex_unlock(&dev->mutex);
+}
+
+static void *functionfs_acquire_dev_callback(const char *dev_name)
+{
+ return 0;
+}
+
+static void functionfs_release_dev_callback(struct ffs_data *ffs_data)
+{
+}
+#endif
+
+#ifdef CONFIG_USB_MV_HSIC_UDC
+#define MAX_ACM_INSTANCES 2
+#else
+#define MAX_ACM_INSTANCES 2
+#endif
+
+struct acm_function_config {
+ int instances;
+ int instances_on;
+ struct usb_function *f_acm[MAX_ACM_INSTANCES];
+ struct usb_function_instance *f_acm_inst[MAX_ACM_INSTANCES];
+};
+
+static int
+acm_function_init(struct android_usb_function *f,
+ struct usb_composite_dev *cdev)
+{
+ int i;
+ int ret;
+ struct acm_function_config *config;
+
+ config = kzalloc(sizeof(struct acm_function_config), GFP_KERNEL);
+ if (!config)
+ return -ENOMEM;
+ f->config = config;
+
+ for (i = 0; i < MAX_ACM_INSTANCES; i++) {
+ config->f_acm_inst[i] = usb_get_function_instance("acm");
+ if (IS_ERR(config->f_acm_inst[i])) {
+ ret = PTR_ERR(config->f_acm_inst[i]);
+ goto err_usb_get_function_instance;
+ }
+ config->f_acm[i] = usb_get_function(config->f_acm_inst[i]);
+ if (IS_ERR(config->f_acm[i])) {
+ ret = PTR_ERR(config->f_acm[i]);
+ goto err_usb_get_function;
+ }
+ }
+ return 0;
+err_usb_get_function_instance:
+ while (i-- > 0) {
+ usb_put_function(config->f_acm[i]);
+err_usb_get_function:
+ usb_put_function_instance(config->f_acm_inst[i]);
+ }
+ return ret;
+}
+
+static void acm_function_cleanup(struct android_usb_function *f)
+{
+ int i;
+ struct acm_function_config *config = f->config;
+
+ for (i = 0; i < MAX_ACM_INSTANCES; i++) {
+ usb_put_function(config->f_acm[i]);
+ usb_put_function_instance(config->f_acm_inst[i]);
+ }
+ kfree(f->config);
+ f->config = NULL;
+}
+
+static int
+acm_function_bind_config(struct android_usb_function *f,
+ struct usb_configuration *c)
+{
+ int i;
+ int ret = 0;
+ struct acm_function_config *config = f->config;
+#ifdef CONFIG_USB_ANDROID_DETECT_HOST_OS
+ struct android_dev *dev = _android_dev;
+
+ if (dev->acm_paramter.instances)
+ config->instances = dev->acm_paramter.instances;
+#endif
+ pr_debug("USB_Debug Enter acm_function_bind_config.\n");
+ config->instances_on = config->instances;
+ for (i = 0; i < config->instances_on; i++) {
+ ret = usb_add_function(c, config->f_acm[i]);
+ if (ret) {
+ pr_err("Could not bind acm%u config\n", i);
+ goto err_usb_add_function;
+ }
+ }
+ pr_debug("USB_Debug Exit acm_function_bind_config.\n");
+ return 0;
+
+err_usb_add_function:
+ while (i-- > 0)
+ usb_remove_function(c, config->f_acm[i]);
+ pr_debug("USB_Debug Exit acm_function_bind_config:%d.\n", ret);
+ return ret;
+}
+
+static ssize_t acm_instances_show(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ struct android_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 android_usb_function *f = dev_get_drvdata(dev);
+ struct acm_function_config *config = f->config;
+#ifdef CONFIG_USB_ANDROID_DETECT_HOST_OS
+ struct android_dev *_dev = _android_dev;
+#endif
+ int value;
+
+ sscanf(buf, "%d", &value);
+ if (value > MAX_ACM_INSTANCES)
+ value = MAX_ACM_INSTANCES;
+ config->instances = value;
+#ifdef CONFIG_USB_ANDROID_DETECT_HOST_OS
+ _dev->acm_paramter.instances = value;
+#endif
+ 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 android_usb_function acm_function = {
+ .name = "acm",
+ .init = acm_function_init,
+ .cleanup = acm_function_cleanup,
+ .bind_config = acm_function_bind_config,
+ .attributes = acm_function_attributes,
+};
+
+#ifndef CONFIG_USB_TELEPHONY
+/* Marvell debug function initialization */
+static int marvell_debug_function_init(struct android_usb_function *f,
+ struct usb_composite_dev *cdev)
+{
+ return pxa182x_debug_gserial_setup(cdev->gadget, 1);
+}
+
+static void marvell_debug_function_cleanup(struct android_usb_function *f)
+{
+ pxa182x_debug_gserial_cleanup();
+}
+
+int marvell_debug_function_bind_config(struct android_usb_function *f,
+ struct usb_configuration *c)
+{
+ int ret;
+ pr_debug("USB_Debug Enter marvell_debug_function_bind_config\n");
+ ret = pxa182x_debug_bind_config(c, 1);
+ pr_debug("USB_Debug Exit marvell_debug_function_bind_config:%d\n", ret);
+ return ret;
+}
+
+static struct android_usb_function marvell_debug_function = {
+ .name = "marvell_debug",
+ .init = marvell_debug_function_init,
+ .cleanup = marvell_debug_function_cleanup,
+ .bind_config = marvell_debug_function_bind_config,
+};
+#endif
+
+#if !defined(CONFIG_CPU_ASR18XX) && !defined(CONFIG_CPU_ASR1901)
+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)
+{
+ int ret;
+ pr_debug("USB_Debug Enter mtp_function_bind_config.\n");
+ ret = mtp_bind_config(c, false);
+ pr_debug("USB_Debug Exit mtp_function_bind_config:%d.\n", ret);
+ return ret;
+}
+
+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)
+{
+ int ret;
+ pr_debug("USB_Debug Enter ptp_function_bind_config.\n");
+ ret = mtp_bind_config(c, true);
+ pr_debug("USB_Debug Exit ptp_function_bind_config:%d.\n", ret);
+ return ret;
+}
+
+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 int ptp_function_ctrlrequest(struct android_usb_function *f,
+ struct usb_composite_dev *cdev,
+ const struct usb_ctrlrequest *c)
+{
+ return ptp_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,
+ .ctrlrequest = ptp_function_ctrlrequest,
+};
+#endif
+
+#if defined(CONFIG_CPU_ASR18XX) || defined(CONFIG_CPU_ASR1901)
+struct ecm_function_config {
+ char ethaddr[ETH_ALEN];
+ struct eth_dev *dev;
+};
+
+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 struct device_attribute *ecm_function_attributes[] = {
+ &dev_attr_ecm_ethaddr,
+ NULL
+};
+
+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_function_bind_config(struct android_usb_function *f,
+ struct usb_configuration *c)
+{
+ int ret;
+ struct eth_dev *dev;
+ struct ecm_function_config *ecm = f->config;
+
+ if (!ecm) {
+ pr_err("%s: ecm_pdata\n", __func__);
+ return -EINVAL;
+ }
+ pr_debug("USB_Debug Enter ecm_function_bind_config.\n");
+ 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]);
+
+#ifdef CONFIG_USB_ETH_RNDIS_ECM
+ pr_info("%s: is_rndis_eanabled: %d\n", __func__, is_rndis_enabled);
+ save_ecm_usbnet_host_ethaddr(ecm->ethaddr);
+ if (is_rndis_enabled)
+ dev = gether_setup_name_ecm(c->cdev->gadget, ecm->ethaddr, "usbnet");
+ else
+ dev = gether_setup_name(c->cdev->gadget, ecm->ethaddr, "usbnet");
+#else
+ save_usbnet_host_ethaddr(ecm->ethaddr);
+ dev = gether_setup_name(c->cdev->gadget, ecm->ethaddr, "usbnet");
+#endif
+
+ if (IS_ERR(dev)) {
+ ret = PTR_ERR(dev);
+ pr_err("%s: gether_setup failed\n", __func__);
+ return ret;
+ }
+
+ ecm->dev = dev;
+
+ ret = ecm_bind_config(c, ecm->ethaddr, dev);
+ if (ret) {
+ pr_err("%s:ecm_bind_config failed\n", __func__);
+ gether_cleanup(ecm->dev);
+ }
+ #if defined(CONFIG_CPU_ASR18XX) || defined(CONFIG_CPU_ASR1901)
+ save_net_mac(ecm->ethaddr);
+ #endif
+ pr_debug("USB_Debug Exit ecm_function_bind_config:%d.\n", ret);
+ return ret;
+}
+
+static void ecm_function_unbind_config(struct android_usb_function *f,
+ struct usb_configuration *c)
+{
+ struct ecm_function_config *ecm = f->config;
+ gether_cleanup(ecm->dev);
+}
+
+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,
+};
+
+#endif
+
+#if defined(CONFIG_CPU_ASR18XX) && defined(CONFIG_USB_TELEPHONY)
+struct usbtel_function_config {
+ /*
+ * TODO: ADD needed params here
+ */
+ int data;
+};
+
+static int
+usbtel_function_init(struct android_usb_function *f,
+ struct usb_composite_dev *cdev)
+{
+ f->config = kzalloc(sizeof(struct usbtel_function_config), GFP_KERNEL);
+ if (!f->config)
+ return -ENOMEM;
+ return 0;
+}
+
+static void
+usbtel_function_cleanup(struct android_usb_function *f)
+{
+ kfree(f->config);
+ f->config = NULL;
+}
+
+static int
+usbtel_function_bind_config(struct android_usb_function *f,
+ struct usb_configuration *c)
+{
+ int ret;
+ struct usbtel_function_config *usbtel = f->config;
+
+ if (!usbtel) {
+ pr_err("%s: usbtel_pdata\n", __func__);
+ return -EINVAL;
+ }
+ pr_info("USB_Debug Enter usbtel_function_bind_config.\n");
+
+ ret = usbtel_bind_config(c);
+ if (ret) {
+ pr_err("%s:usbtel_bind_config failed\n", __func__);
+ }
+ pr_debug("USB_Debug Exit usbtel_function_bind_config:%d.\n", ret);
+ return ret;
+}
+
+static void usbtel_function_unbind_config(struct android_usb_function *f,
+ struct usb_configuration *c)
+{
+ /* TODO */
+ return;
+}
+
+static struct android_usb_function usbtel_function = {
+ .name = "usbtel",
+ .init = usbtel_function_init,
+ .cleanup = usbtel_function_cleanup,
+ .bind_config = usbtel_function_bind_config,
+ .unbind_config = usbtel_function_unbind_config,
+};
+#endif
+
+#if defined(CONFIG_CPU_ASR18XX) && defined(CONFIG_ASR_UAC1)
+#define MAX_UAC1_INSTANCES 1
+struct uac1_function_config {
+ int instances;
+ int instances_on;
+ struct usb_function *f_uac1[MAX_UAC1_INSTANCES];
+ struct usb_function_instance *f_uac1_inst[MAX_UAC1_INSTANCES];
+};
+
+static int
+uac1_function_init(struct android_usb_function *f,
+ struct usb_composite_dev *cdev)
+{
+ int i;
+ int ret;
+ struct uac1_function_config *config;
+
+ config = kzalloc(sizeof(struct uac1_function_config), GFP_KERNEL);
+ if (!config)
+ return -ENOMEM;
+ f->config = config;
+
+ for (i = 0; i < MAX_UAC1_INSTANCES; i++) {
+ config->f_uac1_inst[i] = usb_get_function_instance("uac1");
+ if (IS_ERR(config->f_uac1_inst[i])) {
+ ret = PTR_ERR(config->f_uac1_inst[i]);
+ goto err_usb_get_function_instance;
+ }
+ config->f_uac1[i] = usb_get_function(config->f_uac1_inst[i]);
+ if (IS_ERR(config->f_uac1[i])) {
+ ret = PTR_ERR(config->f_uac1[i]);
+ goto err_usb_get_function;
+ }
+ }
+ return 0;
+err_usb_get_function_instance:
+ while (i-- > 0) {
+ usb_put_function(config->f_uac1[i]);
+err_usb_get_function:
+ usb_put_function_instance(config->f_uac1_inst[i]);
+ }
+ return ret;
+}
+
+static void uac1_function_cleanup(struct android_usb_function *f)
+{
+ int i;
+ struct uac1_function_config *config = f->config;
+
+ for (i = 0; i < MAX_UAC1_INSTANCES; i++) {
+ usb_put_function(config->f_uac1[i]);
+ usb_put_function_instance(config->f_uac1_inst[i]);
+ }
+ kfree(f->config);
+ f->config = NULL;
+}
+
+static int
+uac1_function_bind_config(struct android_usb_function *f,
+ struct usb_configuration *c)
+{
+ int i;
+ int ret = 0;
+ struct uac1_function_config *config = f->config;
+#ifdef CONFIG_USB_ANDROID_DETECT_HOST_OS
+ struct android_dev *dev = _android_dev;
+
+ if (dev->uac1_paramter.instances)
+ config->instances = dev->uac1_paramter.instances;
+ config->instances = MAX_UAC1_INSTANCES; //dev->uac1_paramter.instances;
+#endif
+ pr_debug("USB_Debug Enter uac1_function_bind_config.\n");
+ config->instances_on = config->instances;
+ for (i = 0; i < config->instances_on; i++) {
+ ret = usb_add_function(c, config->f_uac1[i]);
+ if (ret) {
+ pr_err("Could not bind uac1_%u config\n", i);
+ goto err_usb_add_function;
+ }
+ }
+ pr_debug("USB_Debug Exit uac1_function_bind_config.\n");
+ return 0;
+
+err_usb_add_function:
+ while (i-- > 0)
+ usb_remove_function(c, config->f_uac1[i]);
+ pr_debug("USB_Debug Exit uac1_function_bind_config:%d.\n", ret);
+ return ret;
+}
+
+static ssize_t uac1_instances_show(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ struct android_usb_function *f = dev_get_drvdata(dev);
+ struct uac1_function_config *config = f->config;
+ return sprintf(buf, "%d\n", config->instances);
+}
+
+static ssize_t uac1_instances_store(struct device *dev,
+ struct device_attribute *attr, const char *buf, size_t size)
+{
+ struct android_usb_function *f = dev_get_drvdata(dev);
+ struct uac1_function_config *config = f->config;
+#ifdef CONFIG_USB_ANDROID_DETECT_HOST_OS
+ struct android_dev *_dev = _android_dev;
+#endif
+ int value;
+
+ sscanf(buf, "%d", &value);
+ if (value > MAX_UAC1_INSTANCES)
+ value = MAX_UAC1_INSTANCES;
+ config->instances = value;
+#ifdef CONFIG_USB_ANDROID_DETECT_HOST_OS
+ _dev->uac1_paramter.instances = value;
+#endif
+ return size;
+}
+
+static DEVICE_ATTR(uacinstances, S_IRUGO | S_IWUSR, uac1_instances_show,
+ uac1_instances_store);
+static struct device_attribute *uac1_function_attributes[] = {
+ &dev_attr_uacinstances,
+ NULL
+};
+
+static struct android_usb_function uac1_function = {
+ .name = "uac1",
+ .init = uac1_function_init,
+ .cleanup = uac1_function_cleanup,
+ .bind_config = uac1_function_bind_config,
+ .attributes = uac1_function_attributes,
+};
+#endif
+
+#if defined(CONFIG_USB_F_SERIAL)
+#define MAX_GSER_INSTANCES 2
+struct gser_function_config {
+ int instances;
+ int instances_on;
+ struct usb_function *f_gser[MAX_GSER_INSTANCES];
+ struct usb_function_instance *f_gser_inst[MAX_GSER_INSTANCES];
+};
+
+static int
+gser_function_init(struct android_usb_function *f,
+ struct usb_composite_dev *cdev)
+{
+ int i;
+ int ret;
+ struct gser_function_config *config;
+
+ config = kzalloc(sizeof(struct gser_function_config), GFP_KERNEL);
+ if (!config)
+ return -ENOMEM;
+ f->config = config;
+
+ for (i = 0; i < MAX_GSER_INSTANCES; i++) {
+ config->f_gser_inst[i] = usb_get_function_instance("gser");
+ if (IS_ERR(config->f_gser_inst[i])) {
+ ret = PTR_ERR(config->f_gser_inst[i]);
+ goto err_usb_get_function_instance;
+ }
+ config->f_gser[i] = usb_get_function(config->f_gser_inst[i]);
+ if (IS_ERR(config->f_gser[i])) {
+ ret = PTR_ERR(config->f_gser[i]);
+ goto err_usb_get_function;
+ }
+ }
+ return 0;
+err_usb_get_function_instance:
+ while (i-- > 0) {
+ usb_put_function(config->f_gser[i]);
+err_usb_get_function:
+ usb_put_function_instance(config->f_gser_inst[i]);
+ }
+ return ret;
+}
+
+static void gser_function_cleanup(struct android_usb_function *f)
+{
+ int i;
+ struct gser_function_config *config = f->config;
+
+ for (i = 0; i < MAX_GSER_INSTANCES; i++) {
+ usb_put_function(config->f_gser[i]);
+ usb_put_function_instance(config->f_gser_inst[i]);
+ }
+ kfree(f->config);
+ f->config = NULL;
+}
+
+static int
+gser_function_bind_config(struct android_usb_function *f,
+ struct usb_configuration *c)
+{
+ int i;
+ int ret = 0;
+ struct gser_function_config *config = f->config;
+#ifdef CONFIG_USB_ANDROID_DETECT_HOST_OS
+ struct android_dev *dev = _android_dev;
+
+ if (dev->gser_paramter.instances)
+ config->instances = dev->gser_paramter.instances;
+#endif
+ pr_debug("USB_Debug Enter gser_function_bind_config.\n");
+ config->instances_on = config->instances;
+ for (i = 0; i < config->instances_on; i++) {
+ ret = usb_add_function(c, config->f_gser[i]);
+ if (ret) {
+ pr_err("Could not bind gser%u config\n", i);
+ goto err_usb_add_function;
+ }
+ }
+ pr_debug("USB_Debug Exit gser_function_bind_config.\n");
+ return 0;
+
+err_usb_add_function:
+ while (i-- > 0)
+ usb_remove_function(c, config->f_gser[i]);
+ pr_debug("USB_Debug Exit gser_function_bind_config:%d.\n", ret);
+ return ret;
+}
+
+static ssize_t gser_instances_show(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ struct android_usb_function *f = dev_get_drvdata(dev);
+ struct gser_function_config *config = f->config;
+ return sprintf(buf, "%d\n", config->instances);
+}
+
+static ssize_t gser_instances_store(struct device *dev,
+ struct device_attribute *attr, const char *buf, size_t size)
+{
+ struct android_usb_function *f = dev_get_drvdata(dev);
+ struct gser_function_config *config = f->config;
+#ifdef CONFIG_USB_ANDROID_DETECT_HOST_OS
+ struct android_dev *_dev = _android_dev;
+#endif
+ int value;
+
+ sscanf(buf, "%d", &value);
+ if (value > MAX_GSER_INSTANCES)
+ value = MAX_GSER_INSTANCES;
+ config->instances = value;
+#ifdef CONFIG_USB_ANDROID_DETECT_HOST_OS
+ _dev->gser_paramter.instances = value;
+#endif
+ return size;
+}
+
+static DEVICE_ATTR(gser_instances, S_IRUGO | S_IWUSR, gser_instances_show,
+ gser_instances_store);
+static struct device_attribute *gser_function_attributes[] = {
+ &dev_attr_gser_instances,
+ NULL
+};
+
+static struct android_usb_function gser_function = {
+ .name = "gser",
+ .init = gser_function_init,
+ .cleanup = gser_function_cleanup,
+ .bind_config = gser_function_bind_config,
+ .attributes = gser_function_attributes,
+};
+#endif /* end of CONFIG_USB_F_SERIAL */
+
+struct rndis_function_config {
+ u8 ethaddr[ETH_ALEN];
+ u32 vendorID;
+ char manufacturer[256];
+ /* "Wireless" RNDIS; auto-detected by Windows */
+ bool wceis;
+ struct eth_dev *dev;
+};
+
+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_function_bind_config(struct android_usb_function *f,
+ struct usb_configuration *c)
+{
+ int ret;
+ struct eth_dev *dev;
+ struct rndis_function_config *rndis = f->config;
+ #ifdef CONFIG_USB_ANDROID_DETECT_HOST_OS
+ struct android_dev *_dev = _android_dev;
+ #endif
+ if (!rndis) {
+ pr_err("%s: rndis_pdata\n", __func__);
+ return -1;
+ }
+ pr_debug("USB_Debug Enter rndis_function_bind_config.\n");
+ 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]);
+
+ save_usbnet_host_ethaddr(rndis->ethaddr);
+ if (rndis->ethaddr[0])
+ dev = gether_setup_name(c->cdev->gadget, NULL, "usbnet");
+ else
+ dev = gether_setup_name(c->cdev->gadget, rndis->ethaddr,
+ "usbnet");
+#ifdef CONFIG_USB_ETH_RNDIS_ECM
+ is_rndis_enabled = true;
+#endif
+ if (IS_ERR(dev)) {
+ ret = PTR_ERR(dev);
+ pr_err("%s: gether_setup failed\n", __func__);
+ return ret;
+ }
+ rndis->dev = dev;
+ #ifdef CONFIG_USB_ANDROID_DETECT_HOST_OS
+ strlcpy(rndis->manufacturer, _dev->rndis_paramter.manufacturer,
+ sizeof(_dev->rndis_paramter.manufacturer));
+ rndis->wceis = _dev->rndis_paramter.wceis;
+ rndis->vendorID = _dev->rndis_paramter.vendorID;
+ #if defined(CONFIG_CPU_ASR18XX) || defined(CONFIG_CPU_ASR1901)
+ save_net_mac(rndis->ethaddr);
+ #endif
+ #endif
+ 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;
+ }
+ ret = rndis_bind_config_vendor(c, rndis->ethaddr, rndis->vendorID,
+ rndis->manufacturer, rndis->dev);
+ pr_debug("USB_Debug Exit rndis_function_bind_config:%d.\n", ret);
+ return ret;
+}
+
+static void rndis_function_unbind_config(struct android_usb_function *f,
+ struct usb_configuration *c)
+{
+ struct rndis_function_config *rndis = f->config;
+ gether_cleanup(rndis->dev);
+#ifdef CONFIG_USB_ETH_RNDIS_ECM
+ is_rndis_enabled = false;
+#endif
+}
+
+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 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 android_usb_function *f = dev_get_drvdata(dev);
+ struct rndis_function_config *config = f->config;
+ #ifdef CONFIG_USB_ANDROID_DETECT_HOST_OS
+ struct android_dev *_dev = _android_dev;
+ #endif
+
+ if (size >= sizeof(config->manufacturer))
+ return -EINVAL;
+ if (sscanf(buf, "%s", config->manufacturer) == 1) {
+ #ifdef CONFIG_USB_ANDROID_DETECT_HOST_OS
+ memset(_dev->rndis_paramter.manufacturer, 0,
+ sizeof(_dev->rndis_paramter.manufacturer));
+ strlcpy(_dev->rndis_paramter.manufacturer,
+ config->manufacturer , size);
+ #endif
+ 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 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 android_usb_function *f = dev_get_drvdata(dev);
+ struct rndis_function_config *config = f->config;
+ int value;
+ #ifdef CONFIG_USB_ANDROID_DETECT_HOST_OS
+ struct android_dev *_dev = _android_dev;
+ #endif
+
+ if (sscanf(buf, "%d", &value) == 1) {
+ #ifdef CONFIG_USB_ANDROID_DETECT_HOST_OS
+ _dev->rndis_paramter.wceis = value;
+ #endif
+ 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 sprintf(buf, "%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 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 android_usb_function *f = dev_get_drvdata(dev);
+ struct rndis_function_config *config = f->config;
+ int value;
+ #ifdef CONFIG_USB_ANDROID_DETECT_HOST_OS
+ struct android_dev *_dev = _android_dev;
+ #endif
+
+ if (sscanf(buf, "%04x", &value) == 1) {
+ #ifdef CONFIG_USB_ANDROID_DETECT_HOST_OS
+ _dev->rndis_paramter.vendorID = value;
+ #endif
+ config->vendorID = value;
+ return size;
+ }
+ return -EINVAL;
+}
+
+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 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,
+};
+
+#if defined (CONFIG_USB_G_MBIM)
+
+struct mbim_function_config {
+ u8 ethaddr[ETH_ALEN];
+ u32 vendorID;
+ char manufacturer[256];
+ struct eth_dev *dev;
+ enum ncm_mbim_mode mode;
+};
+
+static int
+mbim_function_init(struct android_usb_function *f,
+ struct usb_composite_dev *cdev)
+{
+ f->config = kzalloc(sizeof(struct mbim_function_config), GFP_KERNEL);
+ if (!f->config)
+ return -ENOMEM;
+ return mbim_init(1);
+}
+
+static int
+ncm_function_init(struct android_usb_function *f,
+ struct usb_composite_dev *cdev)
+{
+ f->config = kzalloc(sizeof(struct mbim_function_config), GFP_KERNEL);
+ if (!f->config)
+ return -ENOMEM;
+ return 0;
+}
+
+static int
+ncm_mbim_function_init(struct android_usb_function *f,
+ struct usb_composite_dev *cdev)
+{
+ f->config = kzalloc(sizeof(struct mbim_function_config), GFP_KERNEL);
+ if (!f->config)
+ return -ENOMEM;
+ return 0;
+}
+
+static int
+mbim_handle_function_bind_config(struct android_usb_function *f,
+ struct usb_configuration *c);
+static int
+ncm_function_bind_config(struct android_usb_function *f,
+ struct usb_configuration *c)
+{
+ struct mbim_function_config *ncm = f->config;
+ int ret;
+
+ if (!ncm) {
+ pr_err("%s: ncm_pdata\n", __func__);
+ return -1;
+ }
+ pr_debug("USB_Debug Enter ncm_function_bind_config.\n");
+ ncm->mode = MODE_NCM;
+ ret = mbim_handle_function_bind_config(f, c);
+ pr_debug("USB_Debug Exit ncm_function_bind_config:%d.\n", ret);
+ return ret;
+}
+
+static int
+ncm_mbim_function_bind_config(struct android_usb_function *f,
+ struct usb_configuration *c)
+{
+ struct mbim_function_config *ncm_mbim = f->config;
+ int ret;
+
+ if (!ncm_mbim) {
+ pr_err("%s: ncm_mbim_pdata\n", __func__);
+ return -1;
+ }
+ pr_debug("USB_Debug Enter ncm_mbim_function_bind_config.\n");
+ ncm_mbim->mode = MODE_NCM_MBIM;
+ ret = mbim_handle_function_bind_config(f, c);
+ pr_debug("USB_Debug Exit ncm_mbim_function_bind_config:%d.\n", ret);
+ return ret;
+}
+
+static void ncm_function_cleanup(struct android_usb_function *f)
+{
+ kfree(f->config);
+ f->config = NULL;
+}
+
+static void ncm_mbim_function_cleanup(struct android_usb_function *f)
+{
+ kfree(f->config);
+ f->config = NULL;
+}
+
+static void mbim_function_cleanup(struct android_usb_function *f)
+{
+ fmbim_cleanup();
+ kfree(f->config);
+ f->config = NULL;
+}
+
+static int
+mbim_handle_function_bind_config(struct android_usb_function *f,
+ struct usb_configuration *c)
+{
+ int ret;
+ struct eth_dev *dev;
+ struct mbim_function_config *mbim = f->config;
+
+ if (!mbim) {
+ pr_err("%s: mbim_pdata\n", __func__);
+ return -1;
+ }
+
+ pr_info("%s MAC: %02X:%02X:%02X:%02X:%02X:%02X\n", __func__,
+ mbim->ethaddr[0], mbim->ethaddr[1], mbim->ethaddr[2],
+ mbim->ethaddr[3], mbim->ethaddr[4], mbim->ethaddr[5]);
+
+ save_usbnet_host_ethaddr(mbim->ethaddr);
+ if (mbim->ethaddr[0])
+ dev = gether_setup_name(c->cdev->gadget, NULL, "usbnet");
+ else
+ dev = gether_setup_name(c->cdev->gadget, mbim->ethaddr,
+ "usbnet");
+ if (IS_ERR(dev)) {
+ ret = PTR_ERR(dev);
+ pr_err("%s: gether_setup failed\n", __func__);
+ return ret;
+ }
+ mbim->dev = dev;
+ #if defined(CONFIG_CPU_ASR18XX) || defined(CONFIG_CPU_ASR1901)
+ save_net_mac(mbim->ethaddr);
+ #endif
+ return mbim_bind_config(c, mbim->ethaddr, dev, mbim->mode);
+}
+
+static int
+mbim_function_bind_config(struct android_usb_function *f,
+ struct usb_configuration *c)
+{
+ struct mbim_function_config *mbim = f->config;
+ int ret;
+
+ if (!mbim) {
+ pr_err("%s: mbim_pdata\n", __func__);
+ return -1;
+ }
+ pr_debug("USB_Debug Enter mbim_function_bind_config.\n");
+ mbim->mode = MODE_MBIM;
+ ret = mbim_handle_function_bind_config(f, c);
+ pr_debug("USB_Debug Exit mbim_function_bind_config:%d.\n", ret);
+ return ret;
+}
+
+static void mbim_function_unbind_config(struct android_usb_function *f,
+ struct usb_configuration *c)
+{
+ struct mbim_function_config *mbim = f->config;
+ gether_cleanup(mbim->dev);
+}
+
+static ssize_t mbim_manufacturer_show(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ struct android_usb_function *f = dev_get_drvdata(dev);
+ struct mbim_function_config *config = f->config;
+ return sprintf(buf, "%s\n", config->manufacturer);
+}
+
+static ssize_t mbim_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 mbim_function_config *config = f->config;
+
+ if (size >= sizeof(config->manufacturer))
+ return -EINVAL;
+ if (sscanf(buf, "%s", config->manufacturer) == 1)
+ return size;
+ return -1;
+}
+
+static DEVICE_ATTR(mbim_manufacturer, S_IRUGO | S_IWUSR, mbim_manufacturer_show,
+ mbim_manufacturer_store);
+
+static ssize_t mbim_ethaddr_show(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ struct android_usb_function *f = dev_get_drvdata(dev);
+ struct mbim_function_config *mbim = f->config;
+ return sprintf(buf, "%02x:%02x:%02x:%02x:%02x:%02x\n",
+ mbim->ethaddr[0], mbim->ethaddr[1], mbim->ethaddr[2],
+ mbim->ethaddr[3], mbim->ethaddr[4], mbim->ethaddr[5]);
+}
+
+static ssize_t mbim_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 mbim_function_config *mbim = f->config;
+
+ if (sscanf(buf, "%02x:%02x:%02x:%02x:%02x:%02x\n",
+ (int *)&mbim->ethaddr[0], (int *)&mbim->ethaddr[1],
+ (int *)&mbim->ethaddr[2], (int *)&mbim->ethaddr[3],
+ (int *)&mbim->ethaddr[4], (int *)&mbim->ethaddr[5]) == 6)
+ return size;
+ return -EINVAL;
+}
+
+static DEVICE_ATTR(mbim_ethaddr, S_IRUGO | S_IWUSR, mbim_ethaddr_show,
+ mbim_ethaddr_store);
+
+static ssize_t mbim_vendorID_show(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ struct android_usb_function *f = dev_get_drvdata(dev);
+ struct mbim_function_config *config = f->config;
+ return sprintf(buf, "%04x\n", config->vendorID);
+}
+
+static ssize_t mbim_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 mbim_function_config *config = f->config;
+ int value;
+
+ if (sscanf(buf, "%04x", &value) == 1) {
+ config->vendorID = value;
+ return size;
+ }
+ return -EINVAL;
+}
+
+static DEVICE_ATTR(mbim_vendorID, S_IRUGO | S_IWUSR, mbim_vendorID_show,
+ mbim_vendorID_store);
+
+static struct device_attribute *mbim_function_attributes[] = {
+ &dev_attr_mbim_manufacturer,
+ &dev_attr_mbim_ethaddr,
+ &dev_attr_mbim_vendorID,
+ NULL
+};
+
+static struct android_usb_function mbim_function = {
+ .name = "mbim",
+ .init = mbim_function_init,
+ .cleanup = mbim_function_cleanup,
+ .bind_config = mbim_function_bind_config,
+ .unbind_config = mbim_function_unbind_config,
+ .attributes = mbim_function_attributes,
+};
+
+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 = mbim_function_unbind_config,
+ .attributes = NULL,
+};
+
+static struct android_usb_function ncm_mbim_function = {
+ .name = "ncm_mbim",
+ .init = ncm_mbim_function_init,
+ .cleanup = ncm_mbim_function_cleanup,
+ .bind_config = ncm_mbim_function_bind_config,
+ .unbind_config = mbim_function_unbind_config,
+ .attributes = NULL,
+};
+
+#endif
+
+#define MASS_STORAGE_INSTANCES 1
+
+struct mass_storage_function_config {
+ int instances_on;
+ struct usb_function *f_mass_storage[MASS_STORAGE_INSTANCES];
+ struct usb_function_instance *f_mass_storage_inst[MASS_STORAGE_INSTANCES];
+};
+
+static int
+mass_storage_function_init(struct android_usb_function *f,
+ struct usb_composite_dev *cdev)
+{
+ int i;
+ int ret;
+ struct mass_storage_function_config *config;
+
+ config = kzalloc(sizeof(struct mass_storage_function_config), GFP_KERNEL);
+ if (!config)
+ return -ENOMEM;
+ f->config = config;
+
+ for (i = 0; i < MASS_STORAGE_INSTANCES; i++) {
+ config->f_mass_storage_inst[i] = usb_get_function_instance("mass_storage");
+ if (IS_ERR(config->f_mass_storage_inst[i])) {
+ ret = PTR_ERR(config->f_mass_storage_inst[i]);
+ goto err_usb_get_function_instance;
+ }
+ config->f_mass_storage[i] = usb_get_function(config->f_mass_storage_inst[i]);
+ if (IS_ERR(config->f_mass_storage[i])) {
+ ret = PTR_ERR(config->f_mass_storage[i]);
+ goto err_usb_get_function;
+ }
+ }
+ return 0;
+err_usb_get_function_instance:
+ while (i-- > 0) {
+ usb_put_function(config->f_mass_storage[i]);
+err_usb_get_function:
+ usb_put_function_instance(config->f_mass_storage_inst[i]);
+ }
+ return ret;
+}
+
+static void mass_storage_function_cleanup(struct android_usb_function *f)
+{
+ int i;
+ struct mass_storage_function_config *config = f->config;
+
+ for (i = 0; i < MASS_STORAGE_INSTANCES; i++) {
+ usb_put_function(config->f_mass_storage[i]);
+ usb_put_function_instance(config->f_mass_storage_inst[i]);
+ }
+ kfree(f->config);
+ f->config = NULL;
+}
+
+static int
+mass_storage_function_bind_config(struct android_usb_function *f,
+ struct usb_configuration *c)
+{
+ int i;
+ int ret = 0;
+ struct mass_storage_function_config *config = f->config;
+
+ pr_info("USB_Debug Enter mass_storage_function_bind_config.\n");
+ config->instances_on = MASS_STORAGE_INSTANCES;
+ for (i = 0; i < config->instances_on; i++) {
+ ret = usb_add_function(c, config->f_mass_storage[i]);
+ if (ret) {
+ pr_err("Could not bind mass_storage%u config\n", i);
+ goto err_usb_add_function;
+ }
+ }
+ pr_info("USB_Debug Exit mass_storage_function_bind_config.\n");
+ return 0;
+
+err_usb_add_function:
+ while (i-- > 0)
+ usb_remove_function(c, config->f_mass_storage[i]);
+ pr_debug("USB_Debug Exit mass_storage_function_bind_config:%d.\n", ret);
+ return ret;
+}
+
+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,
+};
+
+#if !defined(CONFIG_CPU_ASR18XX) && !defined(CONFIG_CPU_ASR1901)
+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)
+{
+ int ret;
+ pr_debug("USB_Debug Enter accessory_function_bind_config.\n");
+ ret = acc_bind_config(c);
+ pr_debug("USB_Debug Exit accessory_function_bind_config:%d.\n", ret);
+ return ret;
+}
+
+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,
+};
+
+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;
+ int ret;
+ pr_debug("USB_Debug Enter audio_source_function_bind_config.\n");
+ ret = audio_source_bind_config(c, config);
+ pr_debug("USB_Debug Exit audio_source_function_bind_config:%d\n", ret);
+ return ret;
+}
+
+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, 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,
+};
+
+#define CD_ROM_PATH0 "/system/pcsuite/pcsuite.iso"
+
+struct pcsuite_function_config {
+ struct fsg_config fsg;
+ struct fsg_common *common;
+ int nluns;
+};
+
+static int pcsuite_fsg_init(struct usb_composite_dev *cdev,
+ struct android_usb_function *f,
+ struct pcsuite_function_config *config)
+{
+ struct fsg_common *common;
+ int nluns = config->nluns;
+ char *name;
+ int i, ret;
+
+ config->fsg.nluns = nluns;
+ for (i = 0; i < nluns; i++) {
+ config->fsg.luns[i].removable = 1;
+ config->fsg.luns[i].cdrom = 1;
+ }
+
+ common = fsg_common_init(NULL, cdev, &config->fsg);
+ if (IS_ERR(common))
+ return PTR_ERR(common);
+
+ /* Create symlinks */
+ for (i = 0; i < nluns; i++) {
+ name = get_lun_name(i, nluns);
+ ret = sysfs_create_link(&f->dev->kobj,
+ &common->luns[i].dev.kobj, name);
+ if (ret) {
+ while (i-- > 0) {
+ name = get_lun_name(i, nluns);
+ sysfs_remove_link(&f->dev->kobj, name);
+ }
+ goto err_create_symlink;
+ }
+ }
+
+ config->common = common;
+ return 0;
+
+err_create_symlink:
+ fsg_common_release(&common->ref);
+ return ret;
+}
+
+static void pcsuite_fsg_release(struct android_usb_function *f)
+{
+ struct pcsuite_function_config *config = f->config;
+ struct fsg_common *common = config->common;
+ int nluns = config->fsg.nluns;
+ char *name;
+ int i;
+
+ if (nluns < 1)
+ return;
+ /* Remove symlinks */
+ i = nluns - 1;
+ while (i >= 0) {
+ name = get_lun_name(i, nluns);
+ sysfs_remove_link(&f->dev->kobj, name);
+ i--;
+ }
+
+ fsg_common_release(&common->ref);
+}
+
+static int pcsuite_function_init(struct android_usb_function *f,
+ struct usb_composite_dev *cdev)
+{
+ struct pcsuite_function_config *config;
+
+ config = kzalloc(sizeof(struct pcsuite_function_config), GFP_KERNEL);
+ if (!config)
+ return -ENOMEM;
+
+ /* Init nluns=1 by default */
+ config->nluns = 1;
+ config->fsg.luns[0].filename = CD_ROM_PATH0;
+
+ f->config = config;
+ return 0;
+}
+
+static void pcsuite_function_cleanup(struct android_usb_function *f)
+{
+ pcsuite_fsg_release(f);
+ kfree(f->config);
+ f->config = NULL;
+}
+
+static int pcsuite_function_bind_config(struct android_usb_function *f,
+ struct usb_configuration *c)
+{
+ struct pcsuite_function_config *config = f->config;
+ int ret;
+ static int pcsuite_inited = 0;
+
+ printk("%s, filename is %s\n", __func__, config->fsg.luns[0].filename);
+
+ if (pcsuite_inited == 0) {
+ ret = pcsuite_fsg_init(c->cdev, f, config);
+ if (ret)
+ return ret;
+ pcsuite_inited = 1;
+ }
+
+ return fsg_bind_config(c->cdev, c, config->common);
+}
+
+static struct android_usb_function pcsuite_function = {
+ .name = "pcsuite",
+ .init = pcsuite_function_init,
+ .cleanup = pcsuite_function_cleanup,
+ .bind_config = pcsuite_function_bind_config,
+};
+
+static int midi_function_init(struct android_usb_function *f,
+ struct usb_composite_dev *cdev)
+{
+ struct midi_alsa_config *config;
+
+ config = kzalloc(sizeof(struct midi_alsa_config), GFP_KERNEL);
+ f->config = config;
+ if (!config)
+ return -ENOMEM;
+ config->card = -1;
+ config->device = -1;
+ return 0;
+}
+
+static void midi_function_cleanup(struct android_usb_function *f)
+{
+ kfree(f->config);
+}
+
+tatic int midi_function_bind_config(struct android_usb_function *f,
+ struct usb_configuration *c)
+{
+ struct midi_alsa_config *config = f->config;
+
+ return f_midi_bind_config(c, SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1,
+ MIDI_INPUT_PORTS, MIDI_OUTPUT_PORTS, MIDI_BUFFER_SIZE,
+ MIDI_QUEUE_LENGTH, config);
+}
+
+static ssize_t midi_alsa_show(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ struct android_usb_function *f = dev_get_drvdata(dev);
+ struct midi_alsa_config *config = f->config;
+
+ /* print ALSA card and device numbers */
+ return sprintf(buf, "%d %d\n", config->card, config->device);
+}
+
+static DEVICE_ATTR(alsa, S_IRUGO, midi_alsa_show, NULL);
+
+static struct device_attribute *midi_function_attributes[] = {
+ &dev_attr_alsa,
+ NULL
+};
+
+static struct android_usb_function midi_function = {
+ .name = "midi",
+ .init = midi_function_init,
+ .cleanup = midi_function_cleanup,
+ .bind_config = midi_function_bind_config,
+ .attributes = midi_function_attributes,
+};
+
+#endif /* ifndef CONFIG_CPU_ASR18XX */
+
+static struct android_usb_function *supported_functions[] = {
+ &adb_function,
+#ifndef CONFIG_USB_TELEPHONY
+ &marvell_modem_function,
+ &marvell_diag_function,
+#endif
+#if !defined(CONFIG_CPU_ASR18XX) && !defined(CONFIG_CPU_ASR1901)
+ &ffs_function,
+#endif
+ &acm_function,
+#if !defined(CONFIG_CPU_ASR18XX) && !defined(CONFIG_CPU_ASR1901)
+ &mtp_function,
+ &ptp_function,
+#endif
+ &rndis_function,
+#ifndef CONFIG_USB_TELEPHONY
+ &marvell_debug_function,
+#endif
+#if defined (CONFIG_USB_G_MBIM)
+ &mbim_function,
+ &ncm_function,
+ &ncm_mbim_function,
+#endif
+ &mass_storage_function,
+#if !defined(CONFIG_CPU_ASR18XX) && !defined(CONFIG_CPU_ASR1901)
+ &accessory_function,
+ &pcsuite_function,
+ &audio_source_function,
+ &midi_function,
+#endif
+
+#if defined(CONFIG_CPU_ASR18XX) || defined(CONFIG_CPU_ASR1901)
+ &ecm_function,
+#if defined(CONFIG_USB_TELEPHONY)
+ &usbtel_function,
+#endif
+
+#if defined(CONFIG_ASR_UAC1)
+ &uac1_function,
+#endif
+
+#ifdef CONFIG_USB_F_SERIAL
+ &gser_function,
+#endif
+
+#endif
+#ifdef CONFIG_USB_GADGET_CHARGE_ONLY
+ &charge_only_function,
+#endif /* CONFIG_USB_GADGET_CHARGE_ONLY */
+ NULL
+};
+
+
+static int android_init_functions(struct android_usb_function **functions,
+ struct usb_composite_dev *cdev)
+{
+ struct android_dev *dev = _android_dev;
+ struct android_usb_function *f;
+ struct device_attribute **attrs;
+ struct device_attribute *attr;
+ int err;
+ // This index should be 1, not 0
+ int index = 1;
+
+ for (; (f = *functions++); index++) {
+ f->dev_name = kasprintf(GFP_KERNEL, "f_%s", f->name);
+ 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);
+ 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_out;
+ }
+ }
+ return 0;
+
+err_out:
+ device_destroy(android_class, f->dev->devt);
+err_create:
+ kfree(f->dev_name);
+ return err;
+}
+
+static void android_cleanup_functions(struct android_usb_function **functions)
+{
+ struct android_usb_function *f;
+
+ while (*functions) {
+ f = *functions++;
+ /* NOTE: must clean up first, then device_destroy */
+ if (f->cleanup)
+ f->cleanup(f);
+ if (f->dev) {
+ device_destroy(android_class, f->dev->devt);
+ kfree(f->dev_name);
+ }
+ }
+}
+
+static int
+android_bind_enabled_functions(struct android_dev *dev,
+ struct usb_configuration *c)
+{
+ struct android_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
+android_unbind_enabled_functions(struct android_dev *dev,
+ struct usb_configuration *c)
+{
+ struct android_usb_function *f;
+ list_for_each_entry(f, &dev->enabled_functions, enabled_list) {
+ if (f->unbind_config)
+ f->unbind_config(f, c);
+ }
+}
+
+static int android_enable_function(struct android_dev *dev, char *name)
+{
+ struct android_usb_function **functions = dev->functions;
+ struct android_usb_function *f;
+ while ((f = *functions++)) {
+ if (!strcmp(name, f->name)) {
+#if defined (CONFIG_USB_G_MBIM)
+ if (f == &mbim_function)
+ mbim_enabled = 1;
+#endif
+ list_add_tail(&f->enabled_list,
+ &dev->enabled_functions);
+ return 0;
+ }
+ }
+ return -EINVAL;
+}
+
+/*-------------------------------------------------------------------------*/
+/* /sys/class/android_usb/android%d/ interface */
+
+static ssize_t
+functions_show(struct device *pdev, struct device_attribute *attr, char *buf)
+{
+ struct android_dev *dev = dev_get_drvdata(pdev);
+ struct android_usb_function *f;
+ char *buff = buf;
+
+ mutex_lock(&dev->mutex);
+
+ list_for_each_entry(f, &dev->enabled_functions, enabled_list)
+ buff += sprintf(buff, "%s,", 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);
+ char *name;
+ char buf[256], *b;
+ char aliases[256], *a;
+ int err;
+ int is_ffs;
+ int ffs_enabled = 0;
+
+ mutex_lock(&dev->mutex);
+
+ if (dev->enabled) {
+ mutex_unlock(&dev->mutex);
+ return -EBUSY;
+ }
+
+ INIT_LIST_HEAD(&dev->enabled_functions);
+
+ strlcpy(buf, buff, sizeof(buf));
+ b = strim(buf);
+ pr_info("enabled functions: %s\n", b);
+#if defined (CONFIG_USB_G_MBIM)
+ mbim_enabled = 0;
+#endif
+ while (b) {
+ name = strsep(&b, ",");
+ if (!name)
+ continue;
+
+ is_ffs = 0;
+ strlcpy(aliases, dev->ffs_aliases, sizeof(aliases));
+ a = aliases;
+
+ while (a) {
+ char *alias = strsep(&a, ",");
+ if (alias && !strcmp(name, alias)) {
+ is_ffs = 1;
+ break;
+ }
+ }
+
+ if (is_ffs) {
+ if (ffs_enabled)
+ continue;
+ err = android_enable_function(dev, "ffs");
+ if (err)
+ pr_err("android_usb: Cannot enable ffs (%d)",
+ err);
+ else
+ ffs_enabled = 1;
+ continue;
+ }
+
+ err = android_enable_function(dev, name);
+ if (err)
+ pr_err("android_usb: Cannot enable '%s' (%d)",
+ name, err);
+ }
+
+ 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 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 android_dev *dev = dev_get_drvdata(pdev);
+ struct usb_composite_dev *cdev = dev->cdev;
+ struct android_usb_function *f;
+ int enabled = 0;
+
+
+ if (!cdev)
+ return -ENODEV;
+
+ mutex_lock(&dev->mutex);
+
+ sscanf(buff, "%d", &enabled);
+
+#ifdef CONFIG_USB_GADGET_CHARGE_ONLY
+ list_for_each_entry(f, &dev->enabled_functions, enabled_list) {
+ if (strcmp(f->name, "charge_only") == 0) {
+ charge_only_mode = 1;
+
+ if (dev->enabled)
+ usb_gadget_disconnect(cdev->gadget);
+
+ if (enabled) {
+ dev->enabled = true;
+ usb_gadget_vbus_connect(cdev->gadget);
+ } else {
+ dev->enabled = false;
+ usb_gadget_vbus_disconnect(cdev->gadget);
+ }
+
+ pr_info("android_usb: charge_only mode %s\n",
+ enabled ? "enabled" : "disabled");
+
+ mutex_unlock(&dev->mutex);
+ return size;
+ }
+ }
+ charge_only_mode = 0;
+#endif /* CONFIG_USB_GADGET_CHARGE_ONLY */
+
+ 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;
+ list_for_each_entry(f, &dev->enabled_functions, enabled_list) {
+ if (f->enable)
+ f->enable(f);
+ }
+ android_enable(dev);
+ dev->enabled = true;
+ } else if (!enabled && dev->enabled) {
+ android_disable(dev);
+ list_for_each_entry(f, &dev->enabled_functions, enabled_list) {
+ if (f->disable)
+ f->disable(f);
+ }
+ dev->enabled = false;
+ } else {
+ pr_err("android_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 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);
+#ifdef CONFIG_USB_GADGET_CHARGE_ONLY
+ if (!charge_only_mode) {
+ if (cdev->config)
+ state = "CONFIGURED";
+ else if (dev->connected)
+ state = "CONNECTED";
+ } else {
+ if (charge_only_configured)
+ state = "CONFIGURED";
+ else if (charge_only_connected)
+ state = "CONNECTED";
+ }
+#else
+ if (cdev->config)
+ state = "CONFIGURED";
+ else if (dev->connected)
+ state = "CONNECTED";
+#endif
+ 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);
+
+#define DESCRIPTOR_STRING_ATTR(field, buffer) \
+static ssize_t \
+field ## _show(struct device *dev, struct device_attribute *attr, \
+ char *buf) \
+{ \
+ return sprintf(buf, "%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; \
+ memset(buffer, 0, sizeof(buffer));\
+ /* @size is equal to the length of @buf
+ * NOTE: the string in @buf contains \n at last
+ * And we must remove the \n, otherwise Win8 will
+ * treat the string as illegal and will cause
+ * enumeration fail.
+ */\
+ strncpy(buffer, buf, size - 1);\
+ 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(state, S_IRUGO, state_show, NULL);
+
+#ifdef CONFIG_USB_REMOTE_WAKEUP
+static struct usb_otg_descriptor otg_descriptor = {
+ .bLength = sizeof(otg_descriptor),
+ .bDescriptorType = USB_DT_OTG,
+
+ /* REVISIT SRP-only hardware is possible, although
+ * it would not be called "OTG" ...
+ */
+ .bmAttributes = USB_OTG_SRP | USB_OTG_HNP,
+};
+
+static const struct usb_descriptor_header __maybe_unused *otg_desc[] = {
+ (struct usb_descriptor_header *) &otg_descriptor,
+ NULL,
+};
+
+static ssize_t
+wakeup_enable_show(struct device *pdev,
+ struct device_attribute *attr, char *buf)
+{
+ struct android_dev *dev = dev_get_drvdata(pdev);
+ return sprintf(buf , "%d\n" , dev->remote_wakeup_enable);
+
+}
+
+static ssize_t
+wakeup_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;
+ int enabled;
+ mutex_lock(&dev->mutex);
+ sscanf(buff , "%d" , &enabled);
+ dev->remote_wakeup_enable = enabled;
+ if (enabled)
+ usb_gadget_wakeup(cdev->gadget);
+
+ mutex_unlock(&dev->mutex);
+
+ return size;
+}
+static DEVICE_ATTR(wakeup, S_IRUGO | S_IWUSR,
+ wakeup_enable_show, wakeup_enable_store);
+#endif
+#if defined(CONFIG_CPU_ASR18XX) || defined(CONFIG_CPU_ASR1901)
+
+static ssize_t hostEthaddr_show(struct device *pdev,
+ struct device_attribute *attr , char *buf)
+{
+ struct android_dev *dev = dev_get_drvdata(pdev);
+ return sprintf(buf , "%s\n" , dev->ethaddr);
+}
+
+static DEVICE_ATTR(hostEthaddr , S_IRUGO, hostEthaddr_show , NULL);
+#endif
+#if defined(CONFIG_CPU_ASR18XX) || defined(CONFIG_CPU_ASR1901)
+static int force_usb_disconnect;
+void enable_force_usb_disconnect(void)
+{
+ force_usb_disconnect = 1;
+}
+
+void disable_force_usb_disconnect(void)
+{
+ force_usb_disconnect = 0;
+}
+
+void force_send_usb_dis_event(struct android_dev *dev)
+{
+ char *disconnected[2] = { "USB_STATE=DISCONNECTED", NULL };
+
+ if (force_usb_disconnect)
+ kobject_uevent_env(&dev->dev->kobj, KOBJ_CHANGE, disconnected);
+}
+
+void android_dev_enable(uint8_t enabled)
+{
+ struct android_dev *dev = _android_dev;
+ struct usb_composite_dev *cdev = dev->cdev;
+ struct android_usb_function *f;
+
+ if (!cdev) {
+ pr_info("cdev is null\n");
+ return;
+ }
+
+ /* send disconnect event to APP to close the file handle */
+ force_send_usb_dis_event(dev);
+
+ pr_err("USB_Debug Enter android_dev_enable:%d.\n", enabled);
+ mutex_lock(&dev->mutex);
+
+ 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;
+ list_for_each_entry(f, &dev->enabled_functions, enabled_list) {
+ if (f->enable)
+ f->enable(f);
+ }
+ android_enable(dev);
+ dev->enabled = true;
+ mutex_unlock(&dev->mutex);
+ } else if (!enabled && dev->enabled) {
+ /*
+ * check the netifd status before usb plug out instead of after
+ * plug in to avoid the corner case netifd is initiating itself
+ * while usb plug happens and confict with each other, here we
+ * we can wait for netifd init done and exec the plug routine
+ */
+#ifndef CONFIG_USB_TELEPHONY
+ wait_usbnet_br_up_and_brigded();
+#endif
+ android_disable(dev);
+ list_for_each_entry(f, &dev->enabled_functions, enabled_list) {
+ if (f->disable)
+ f->disable(f);
+ }
+ dev->enabled = false;
+ mutex_unlock(&dev->mutex);
+ /*
+ * wait until usbnet IFF_DOWN is set when usb plugout routine
+ * finishes, together with wait_usbnet_br_up_and_brigded we
+ * garrantee following sequence,
+ * usb_plug_in->usbnet_up->usb_plug_out->usbnet_down->....
+ */
+#ifndef CONFIG_USB_TELEPHONY
+ wait_usbnet_if_down();
+#endif
+ } else {
+ pr_err("android_usb: already %s\n",
+ dev->enabled ? "enabled" : "disabled");
+ mutex_unlock(&dev->mutex);
+ }
+
+ pr_err("USB_Debug Exit android_dev_enable:%d.\n", enabled);
+}
+#endif
+
+#ifdef CONFIG_USB_ANDROID_DETECT_HOST_OS
+#include "os_detect.c"
+#endif
+
+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_state,
+#ifdef CONFIG_USB_ANDROID_DETECT_HOST_OS
+ &dev_attr_win7,
+ &dev_attr_win8,
+ &dev_attr_apple,
+ &dev_attr_olinux,
+ &dev_attr_os,
+ &dev_attr_win7_s2,
+ &dev_attr_win8_s2,
+ &dev_attr_apple_s2,
+ &dev_attr_olinux_s2,
+#endif
+#ifdef CONFIG_USB_REMOTE_WAKEUP
+ &dev_attr_wakeup,
+#endif
+#if defined(CONFIG_CPU_ASR18XX) || defined(CONFIG_CPU_ASR1901)
+ &dev_attr_hostEthaddr,
+#endif
+ NULL
+};
+
+/*-------------------------------------------------------------------------*/
+/* Composite driver */
+
+static int android_bind_config(struct usb_configuration *c)
+{
+ struct android_dev *dev = _android_dev;
+ int ret = 0;
+#ifdef CONFIG_USB_REMOTE_WAKEUP
+ c->bmAttributes |= USB_CONFIG_ATT_WAKEUP;
+#endif
+ 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 = _android_dev;
+
+ android_unbind_enabled_functions(dev, c);
+}
+
+static int android_bind(struct usb_composite_dev *cdev)
+{
+ struct android_dev *dev = _android_dev;
+ struct usb_gadget *gadget = cdev->gadget;
+ int id, ret;
+
+ /* Save the default handler */
+ dev->setup_complete = cdev->req->complete;
+
+ /*
+ * Start disconnected. Userspace will connect the gadget once
+ * it is done configuring the functions.
+ */
+ usb_gadget_disconnect(gadget);
+
+ 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 */
+#if 0
+ strncpy(manufacturer_string, "Android", sizeof(manufacturer_string)-1);
+ strncpy(product_string, "Android", sizeof(product_string) - 1);
+ strncpy(serial_string, "0123456789ABCDEF", sizeof(serial_string) - 1);
+#endif
+ id = usb_string_id(cdev);
+ if (id < 0)
+ return id;
+ strings_dev[STRING_SERIAL_IDX].id = id;
+ device_desc.iSerialNumber = id;
+
+ dev->cdev = cdev;
+
+ return 0;
+}
+
+static int android_usb_unbind(struct usb_composite_dev *cdev)
+{
+ struct android_dev *dev = _android_dev;
+
+ cancel_work_sync(&dev->work);
+ dev->cdev = NULL;
+ android_cleanup_functions(dev->functions);
+ return 0;
+}
+
+/* HACK: android needs to override setup for accessory to work */
+static int (*composite_setup_func)(struct usb_gadget *gadget, const struct usb_ctrlrequest *c);
+
+static int
+android_setup(struct usb_gadget *gadget, const struct usb_ctrlrequest *c)
+{
+ struct android_dev *dev = _android_dev;
+ struct usb_composite_dev *cdev = get_gadget_data(gadget);
+ struct usb_request *req = cdev->req;
+ struct android_usb_function *f;
+ int value = -EOPNOTSUPP;
+ unsigned long flags;
+ struct android_dev_event *evt;
+
+ req->zero = 0;
+ req->length = 0;
+ req->complete = dev->setup_complete;
+ 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;
+ }
+ }
+
+ /* Special case the accessory function.
+ * It needs to handle control requests before it is enabled.
+ */
+#if !defined(CONFIG_CPU_ASR18XX) && !defined(CONFIG_CPU_ASR1901)
+ if (value < 0)
+ value = acc_ctrlrequest(cdev, c);
+#endif
+
+ if (value < 0)
+ value = composite_setup_func(gadget, c);
+
+ spin_lock_irqsave(&cdev->lock, flags);
+ if (!dev->connected) {
+ dev->connected = true;
+ evt = create_dev_evt(USB_DEV_CONNECT);
+ /*spin lock is held */
+ if (likely(evt))
+ list_add_tail(&evt->list, &dev->evt_list);
+ schedule_work(&dev->work);
+ } else if (c->bRequest == USB_REQ_SET_CONFIGURATION &&
+ c->wValue && cdev->config) {
+ evt = create_dev_evt(USB_DEV_CONFIGURE);
+ /* spin lock is held */
+ if (likely(evt))
+ list_add_tail(&evt->list, &dev->evt_list);
+ schedule_work(&dev->work);
+ } else if (c->bRequest == USB_REQ_SET_CONFIGURATION &&
+ (!c->wValue)) {
+ evt = create_dev_evt(USB_DEV_DISCONNECT);
+ /* spin lock is held */
+ if (likely(evt))
+ list_add_tail(&evt->list, &dev->evt_list);
+ schedule_work(&dev->work);
+ }
+ spin_unlock_irqrestore(&cdev->lock, flags);
+
+ return value;
+}
+
+static void android_disconnect(struct usb_composite_dev *cdev)
+{
+ struct android_dev *dev = _android_dev;
+ struct android_dev_event *evt;
+
+ /* accessory HID support can be active while the
+ accessory function is not actually enabled,
+ so we need to inform it when we are disconnected.
+ */
+#if !defined(CONFIG_CPU_ASR18XX) && !defined(CONFIG_CPU_ASR1901)
+ acc_disconnect();
+#endif
+ if (!in_interrupt()) {
+ pr_info("+preempt disable\n");
+ preempt_disable();
+ }
+
+ evt = create_dev_evt(USB_DEV_DISCONNECT);
+ /* spin lock is held */
+ if (likely(evt))
+ list_add_tail(&evt->list, &dev->evt_list);
+ if (!in_interrupt()) {
+ pr_info("-preempt enable\n");
+ preempt_enable();
+ }
+
+ dev->connected = false;
+ schedule_work(&dev->work);
+}
+
+static struct usb_composite_driver android_usb_driver = {
+#ifdef CONFIG_USB_TELEPHONY
+ .name = "android_usbtel",
+#else
+ .name = "android_usb",
+#endif
+ .dev = &device_desc,
+ .strings = dev_strings,
+ .bind = android_bind,
+ .unbind = android_usb_unbind,
+ .disconnect = android_disconnect,
+#if defined(CONFIG_CPU_ASR1901)
+ .max_speed = USB_SPEED_SUPER_PLUS,
+#elif defined(CONFIG_CPU_ASR18XX)
+ .max_speed = USB_SPEED_SUPER,
+#else
+ .max_speed = USB_SPEED_HIGH,
+#endif
+};
+
+static int android_create_device(struct android_dev *dev)
+{
+ struct device_attribute **attrs = android_usb_attributes;
+ struct device_attribute *attr;
+ int err;
+
+ dev->dev = device_create(android_class, NULL,
+ MKDEV(0, 0), NULL, "android0");
+ 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 int __init init(void)
+{
+ struct android_dev *dev;
+ int err;
+
+#ifdef CONFIG_CPU_ASR18XX
+ if (cpu_is_asr1803())
+ android_usb_driver.max_speed = USB_SPEED_HIGH;
+#endif
+
+#ifdef CONFIG_USB_TELEPHONY
+ android_class = class_create(THIS_MODULE, "android_usbtel");
+#else
+ android_class = class_create(THIS_MODULE, "android_usb");
+#endif
+ if (IS_ERR(android_class))
+ return PTR_ERR(android_class);
+
+ dev = kzalloc(sizeof(*dev), GFP_KERNEL);
+ if (!dev) {
+ err = -ENOMEM;
+ goto err_dev;
+ }
+
+ dev->disable_depth = 1;
+ dev->functions = supported_functions;
+ INIT_LIST_HEAD(&dev->enabled_functions);
+ INIT_WORK(&dev->work, android_work);
+ mutex_init(&dev->mutex);
+
+ err = android_create_device(dev);
+ if (err) {
+ pr_err("%s: failed to create android device %d", __func__, err);
+ goto err_create;
+ }
+
+ _android_dev = dev;
+ INIT_LIST_HEAD(&_android_dev->evt_list);
+#ifdef CONFIG_USB_ANDROID_DETECT_HOST_OS
+ usb_os_detect_init();
+#endif
+
+ err = usb_composite_probe(&android_usb_driver);
+ if (err) {
+ pr_err("%s: failed to probe driver %d", __func__, err);
+ goto err_probe;
+ }
+
+ /* HACK: exchange composite's setup with ours */
+ composite_setup_func = android_usb_driver.gadget_driver.setup;
+ android_usb_driver.gadget_driver.setup = android_setup;
+
+ return 0;
+
+err_probe:
+ device_destroy(android_class, dev->dev->devt);
+err_create:
+ kfree(dev);
+err_dev:
+ class_destroy(android_class);
+ return err;
+}
+late_initcall(init);
+
+static void __exit cleanup(void)
+{
+ usb_composite_unregister(&android_usb_driver);
+ class_destroy(android_class);
+ kfree(_android_dev);
+ _android_dev = NULL;
+}
+module_exit(cleanup);