which includes sample code for accessing the device file.
config USB_ANDROID
- boolean "Android Gadget"
+ tristate "Android Gadget"
depends on SWITCH
help
- The Android gadget driver supports multiple USB functions.
- The functions can be configured via a board file and may be
- enabled and disabled dynamically.
+ The Android gadget provides mass storage and adb transport.
-config USB_ANDROID_ACM
- boolean "Android gadget ACM function"
- depends on USB_ANDROID
- help
- Provides adb function for adb gadget driver.
-
-config USB_ANDROID_ADB
- boolean "Android gadget adb function"
- depends on USB_ANDROID
- help
- Provides adb function for adb gadget driver.
-
-config USB_ANDROID_MASS_STORAGE
- boolean "Android gadget mass storage function"
- depends on USB_ANDROID && SWITCH
- help
- Provides USB mass storage function for adb gadget driver.
+ Say "y" to link the driver statically, or "m" to build a
+ dynamically linked module called "g_android".
config USB_CDC_COMPOSITE
tristate "CDC Composite Device (Ethernet and ACM)"
g_file_storage-objs := file_storage.o
g_printer-objs := printer.o
g_cdc-objs := cdc2.o
+g_android-objs := android.o f_adb.o f_mass_storage.o
obj-$(CONFIG_USB_ZERO) += g_zero.o
obj-$(CONFIG_USB_AUDIO) += g_audio.o
obj-$(CONFIG_USB_G_PRINTER) += g_printer.o
obj-$(CONFIG_USB_MIDI_GADGET) += g_midi.o
obj-$(CONFIG_USB_CDC_COMPOSITE) += g_cdc.o
-obj-$(CONFIG_USB_ANDROID) += android.o
-obj-$(CONFIG_USB_ANDROID_ACM) += f_acm.o u_serial.o
-obj-$(CONFIG_USB_ANDROID_ADB) += f_adb.o
-obj-$(CONFIG_USB_ANDROID_MASS_STORAGE) += f_mass_storage.o
+obj-$(CONFIG_USB_ANDROID) += g_android.o
#include <linux/delay.h>
#include <linux/kernel.h>
#include <linux/utsname.h>
+#include <linux/miscdevice.h>
#include <linux/platform_device.h>
-#include <linux/usb/android_composite.h>
+#include <linux/usb/android.h>
#include <linux/usb/ch9.h>
#include <linux/usb/composite.h>
#include <linux/usb/gadget.h>
+#include "f_mass_storage.h"
+#include "f_adb.h"
+
#include "gadget_chips.h"
/*
/* Default vendor and product IDs, overridden by platform data */
#define VENDOR_ID 0x18D1
#define PRODUCT_ID 0x0001
+#define ADB_PRODUCT_ID 0x0002
struct android_dev {
struct usb_composite_dev *cdev;
- struct usb_configuration *config;
- int num_products;
- struct android_usb_product *products;
- int num_functions;
- char **functions;
int product_id;
+ int adb_product_id;
int version;
+
+ int adb_enabled;
+ int nluns;
};
+static atomic_t adb_enable_excl;
static struct android_dev *_android_dev;
/* string IDs are assigned dynamically */
.bNumConfigurations = 1,
};
-static struct list_head _functions = LIST_HEAD_INIT(_functions);
-static int _registered_function_count = 0;
-
void android_usb_set_connected(int connected)
{
if (_android_dev && _android_dev->cdev && _android_dev->cdev->gadget) {
}
}
-static struct android_usb_function *get_function(const char *name)
-{
- struct android_usb_function *f;
- list_for_each_entry(f, &_functions, list) {
- if (!strcmp(name, f->name))
- return f;
- }
- return 0;
-}
-
-static void bind_functions(struct android_dev *dev)
-{
- struct android_usb_function *f;
- char **functions = dev->functions;
- int i;
-
- for (i = 0; i < dev->num_functions; i++) {
- char *name = *functions++;
- f = get_function(name);
- if (f)
- f->bind_config(dev->config);
- else
- printk(KERN_ERR "function %s not found in bind_functions\n", name);
- }
-}
-
static int __init android_bind_config(struct usb_configuration *c)
{
struct android_dev *dev = _android_dev;
-
+ int ret;
printk(KERN_DEBUG "android_bind_config\n");
- dev->config = c;
-
- /* bind our functions if they have all registered */
- if (_registered_function_count == dev->num_functions)
- bind_functions(dev);
- return 0;
+ ret = mass_storage_function_add(dev->cdev, c, dev->nluns);
+ if (ret)
+ return ret;
+ return adb_function_add(dev->cdev, c);
}
-static int android_setup_config(struct usb_configuration *c,
- const struct usb_ctrlrequest *ctrl);
-
static struct usb_configuration android_config_driver = {
.label = "android",
.bind = android_bind_config,
- .setup = android_setup_config,
.bConfigurationValue = 1,
.bmAttributes = USB_CONFIG_ATT_ONE | USB_CONFIG_ATT_SELFPOWER,
.bMaxPower = 0xFA, /* 500ma */
};
-static int android_setup_config(struct usb_configuration *c,
- const struct usb_ctrlrequest *ctrl)
-{
- int i;
- int ret = -EOPNOTSUPP;
-
- for (i = 0; i < android_config_driver.next_interface_id; i++) {
- if (android_config_driver.interface[i]->setup) {
- ret = android_config_driver.interface[i]->setup(
- android_config_driver.interface[i], ctrl);
- if (ret >= 0)
- return ret;
- }
- }
- return ret;
-}
-
-static int product_has_function(struct android_usb_product *p,
- struct usb_function *f)
-{
- char **functions = p->functions;
- int count = p->num_functions;
- const char *name = f->name;
- int i;
-
- for (i = 0; i < count; i++) {
- if (!strcmp(name, *functions++))
- return 1;
- }
- return 0;
-}
-
-static int product_matches_functions(struct android_usb_product *p)
-{
- struct usb_function *f;
- list_for_each_entry(f, &android_config_driver.functions, list) {
- if (product_has_function(p, f) == !!f->hidden)
- return 0;
- }
- return 1;
-}
-
-static int get_product_id(struct android_dev *dev)
-{
- struct android_usb_product *p = dev->products;
- int count = dev->num_products;
- int i;
-
- if (p) {
- for (i = 0; i < count; i++, p++) {
- if (product_matches_functions(p))
- return p->product_id;
- }
- }
- /* use default product ID */
- return dev->product_id;
-}
-
static int __init android_bind(struct usb_composite_dev *cdev)
{
struct android_dev *dev = _android_dev;
struct usb_gadget *gadget = cdev->gadget;
- int gcnum, id, product_id, ret;
+ int gcnum;
+ int id;
+ int ret;
printk(KERN_INFO "android_bind\n");
strings_dev[STRING_SERIAL_IDX].id = id;
device_desc.iSerialNumber = id;
- if (gadget->ops->wakeup)
- android_config_driver.bmAttributes |= USB_CONFIG_ATT_WAKEUP;
-
/* register our configuration */
ret = usb_add_config(cdev, &android_config_driver);
if (ret) {
usb_gadget_set_selfpowered(gadget);
dev->cdev = cdev;
- product_id = get_product_id(dev);
- device_desc.idProduct = __constant_cpu_to_le16(product_id);
- cdev->desc.idProduct = device_desc.idProduct;
return 0;
}
.bind = android_bind,
};
-void android_register_function(struct android_usb_function *f)
+static void enable_adb(struct android_dev *dev, int enable)
{
- struct android_dev *dev = _android_dev;
-
- printk(KERN_INFO "android_register_function\n");
- list_add_tail(&f->list, &_functions);
- _registered_function_count++;
-
- /* bind our functions if they have all registered
- * and the main driver has bound.
- */
- if (dev->config && _registered_function_count == dev->num_functions)
- bind_functions(dev);
-}
+ if (enable != dev->adb_enabled) {
+ dev->adb_enabled = enable;
+ adb_function_enable(enable);
-void android_enable_function(struct usb_function *f, int enable)
-{
- struct android_dev *dev = _android_dev;
- int disable = !enable;
- int product_id;
-
- if (!!f->hidden != disable) {
- f->hidden = disable;
- product_id = get_product_id(dev);
- device_desc.idProduct = __constant_cpu_to_le16(product_id);
+ /* set product ID to the appropriate value */
+ if (enable)
+ device_desc.idProduct =
+ __constant_cpu_to_le16(dev->adb_product_id);
+ else
+ device_desc.idProduct =
+ __constant_cpu_to_le16(dev->product_id);
if (dev->cdev)
dev->cdev->desc.idProduct = device_desc.idProduct;
}
}
+static int adb_enable_open(struct inode *ip, struct file *fp)
+{
+ if (atomic_inc_return(&adb_enable_excl) != 1) {
+ atomic_dec(&adb_enable_excl);
+ return -EBUSY;
+ }
+
+ printk(KERN_INFO "enabling adb\n");
+ enable_adb(_android_dev, 1);
+
+ return 0;
+}
+
+static int adb_enable_release(struct inode *ip, struct file *fp)
+{
+ printk(KERN_INFO "disabling adb\n");
+ enable_adb(_android_dev, 0);
+ atomic_dec(&adb_enable_excl);
+ return 0;
+}
+
+static const struct file_operations adb_enable_fops = {
+ .owner = THIS_MODULE,
+ .open = adb_enable_open,
+ .release = adb_enable_release,
+};
+
+static struct miscdevice adb_enable_device = {
+ .minor = MISC_DYNAMIC_MINOR,
+ .name = "android_adb_enable",
+ .fops = &adb_enable_fops,
+};
+
static int __init android_probe(struct platform_device *pdev)
{
struct android_usb_platform_data *pdata = pdev->dev.platform_data;
printk(KERN_INFO "android_probe pdata: %p\n", pdata);
if (pdata) {
- dev->products = pdata->products;
- dev->num_products = pdata->num_products;
- dev->functions = pdata->functions;
- dev->num_functions = pdata->num_functions;
if (pdata->vendor_id)
device_desc.idVendor =
__constant_cpu_to_le16(pdata->vendor_id);
device_desc.idProduct =
__constant_cpu_to_le16(pdata->product_id);
}
+ if (pdata->adb_product_id)
+ dev->adb_product_id = pdata->adb_product_id;
if (pdata->version)
dev->version = pdata->version;
pdata->manufacturer_name;
if (pdata->serial_number)
strings_dev[STRING_SERIAL_IDX].s = pdata->serial_number;
+ dev->nluns = pdata->nluns;
}
- return usb_composite_register(&android_usb_driver);
+ return 0;
}
static struct platform_driver android_platform_driver = {
static int __init init(void)
{
struct android_dev *dev;
+ int ret;
printk(KERN_INFO "android init\n");
/* set default values, which should be overridden by platform data */
dev->product_id = PRODUCT_ID;
+ dev->adb_product_id = ADB_PRODUCT_ID;
_android_dev = dev;
- return platform_driver_register(&android_platform_driver);
+ ret = platform_driver_register(&android_platform_driver);
+ if (ret)
+ return ret;
+ ret = misc_register(&adb_enable_device);
+ if (ret) {
+ platform_driver_unregister(&android_platform_driver);
+ return ret;
+ }
+ ret = usb_composite_register(&android_usb_driver);
+ if (ret) {
+ misc_deregister(&adb_enable_device);
+ platform_driver_unregister(&android_platform_driver);
+ }
+ return ret;
}
module_init(init);
static void __exit cleanup(void)
{
usb_composite_unregister(&android_usb_driver);
+ misc_deregister(&adb_enable_device);
platform_driver_unregister(&android_platform_driver);
kfree(_android_dev);
_android_dev = NULL;
#include "u_serial.h"
#include "gadget_chips.h"
-#include "linux/usb/android_composite.h"
/*
return status;
}
-int acm_function_bind_config(struct usb_configuration *c)
+int __init acm_function_add(struct usb_composite_dev *cdev,
+ struct usb_configuration *c)
{
int ret = acm_bind_config(c, 0);
if (ret == 0)
gserial_setup(c->cdev->gadget, 1);
return ret;
}
-
-static struct android_usb_function acm_function = {
- .name = "acm",
- .bind_config = acm_function_bind_config,
-};
-
-static int __init init(void)
-{
- android_register_function(&acm_function);
- return 0;
-}
-module_init(init);
--- /dev/null
+/*
+ * Gadget Driver for Android ACM
+ *
+ * Copyright (C) 2009 Motorola, Inc.
+ * Author:
+ *
+ * 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.
+ *
+ */
+
+#ifndef __F_ACM_H
+#define __F_ACM_H
+
+int acm_function_add(struct usb_composite_dev *cdev,
+ struct usb_configuration *c);
+
+#endif /* __F_ACM_H */
#include <linux/device.h>
#include <linux/miscdevice.h>
-#include <linux/usb/android_composite.h>
+#include <linux/usb/ch9.h>
+#include <linux/usb/composite.h>
+#include <linux/usb/gadget.h>
+
+#include "f_adb.h"
#define BULK_BUFFER_SIZE 4096
NULL,
};
+/* used when adb function is disabled */
+static struct usb_descriptor_header *null_adb_descs[] = {
+ NULL,
+};
+
/* temporary variable used between adb_open() and adb_gadget_bind() */
static struct adb_dev *_adb_dev;
-static atomic_t adb_enable_excl;
-
static inline struct adb_dev *func_to_dev(struct usb_function *f)
{
return container_of(f, struct adb_dev, function);
.fops = &adb_fops,
};
-static int adb_enable_open(struct inode *ip, struct file *fp)
-{
- if (atomic_inc_return(&adb_enable_excl) != 1) {
- atomic_dec(&adb_enable_excl);
- return -EBUSY;
- }
-
- printk(KERN_INFO "enabling adb\n");
- android_enable_function(&_adb_dev->function, 1);
-
- return 0;
-}
-
-static int adb_enable_release(struct inode *ip, struct file *fp)
-{
- printk(KERN_INFO "disabling adb\n");
- android_enable_function(&_adb_dev->function, 0);
- atomic_dec(&adb_enable_excl);
- return 0;
-}
-
-static const struct file_operations adb_enable_fops = {
- .owner = THIS_MODULE,
- .open = adb_enable_open,
- .release = adb_enable_release,
-};
-
-static struct miscdevice adb_enable_device = {
- .minor = MISC_DYNAMIC_MINOR,
- .name = "android_adb_enable",
- .fops = &adb_enable_fops,
-};
-
-static int
+static int __init
adb_function_bind(struct usb_configuration *c, struct usb_function *f)
{
struct usb_composite_dev *cdev = c->cdev;
spin_unlock_irq(&dev->lock);
misc_deregister(&adb_device);
- misc_deregister(&adb_enable_device);
kfree(_adb_dev);
_adb_dev = NULL;
}
VDBG(cdev, "%s disabled\n", dev->function.name);
}
-static int adb_bind_config(struct usb_configuration *c)
+int __init adb_function_add(struct usb_composite_dev *cdev,
+ struct usb_configuration *c)
{
struct adb_dev *dev;
int ret;
- printk(KERN_INFO "adb_bind_config\n");
+ printk(KERN_INFO "adb_function_add\n");
dev = kzalloc(sizeof(*dev), GFP_KERNEL);
if (!dev)
INIT_LIST_HEAD(&dev->rx_done);
INIT_LIST_HEAD(&dev->tx_idle);
- dev->cdev = c->cdev;
+ dev->cdev = cdev;
dev->function.name = "adb";
- dev->function.descriptors = fs_adb_descs;
- dev->function.hs_descriptors = hs_adb_descs;
+ dev->function.descriptors = null_adb_descs;
+ dev->function.hs_descriptors = null_adb_descs;
dev->function.bind = adb_function_bind;
dev->function.unbind = adb_function_unbind;
dev->function.set_alt = adb_function_set_alt;
dev->function.disable = adb_function_disable;
- /* start disabled */
- dev->function.hidden = 0;
-
/* _adb_dev must be set before calling usb_gadget_register_driver */
_adb_dev = dev;
ret = misc_register(&adb_device);
if (ret)
goto err1;
- ret = misc_register(&adb_enable_device);
- if (ret)
- goto err2;
-
ret = usb_add_function(c, &dev->function);
if (ret)
- goto err3;
+ goto err2;
return 0;
-err3:
- misc_deregister(&adb_enable_device);
err2:
misc_deregister(&adb_device);
err1:
return ret;
}
-static struct android_usb_function adb_function = {
- .name = "adb",
- .bind_config = adb_bind_config,
-};
-
-static int __init init(void)
+void adb_function_enable(int enable)
{
- printk(KERN_INFO "f_adb init\n");
- android_register_function(&adb_function);
- return 0;
+ struct adb_dev *dev = _adb_dev;
+
+ if (dev) {
+ DBG(dev->cdev, "adb_function_enable(%s)\n",
+ enable ? "true" : "false");
+
+ if (enable) {
+ dev->function.descriptors = fs_adb_descs;
+ dev->function.hs_descriptors = hs_adb_descs;
+ } else {
+ dev->function.descriptors = null_adb_descs;
+ dev->function.hs_descriptors = null_adb_descs;
+ }
+ }
}
-module_init(init);
+
--- /dev/null
+/*
+ * Gadget Driver for Android ADB
+ *
+ * Copyright (C) 2008 Google, Inc.
+ * Author: Mike Lockwood <lockwood@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.
+ *
+ */
+
+#ifndef __F_ADB_H
+#define __F_ADB_H
+
+int adb_function_add(struct usb_composite_dev *cdev,
+ struct usb_configuration *c);
+void adb_function_enable(int enable);
+
+#endif /* __F_ADB_H */
#include <linux/usb/ch9.h>
#include <linux/usb/composite.h>
#include <linux/usb/gadget.h>
-#include <linux/usb/android_composite.h>
+#include <linux/usb/android.h>
+#include "f_mass_storage.h"
#include "gadget_chips.h"
switch_dev_unregister(&fsg->sdev);
}
-static int
+static int __init
fsg_function_bind(struct usb_configuration *c, struct usb_function *f)
{
struct usb_composite_dev *cdev = c->cdev;
if (pdata->release)
fsg->release = pdata->release;
- fsg->nluns = pdata->nluns;
}
return 0;
.probe = fsg_probe,
};
-int mass_storage_bind_config(struct usb_configuration *c)
+int __init mass_storage_function_add(struct usb_composite_dev *cdev,
+ struct usb_configuration *c, int nluns)
{
int rc;
struct fsg_dev *fsg;
- printk(KERN_INFO "mass_storage_bind_config\n");
+ printk(KERN_INFO "mass_storage_function_add\n");
rc = fsg_alloc();
if (rc)
return rc;
fsg = the_fsg;
+ fsg->nluns = nluns;
spin_lock_init(&fsg->lock);
init_rwsem(&fsg->filesem);
wake_lock_init(&the_fsg->wake_lock, WAKE_LOCK_SUSPEND,
"usb_mass_storage");
- fsg->cdev = c->cdev;
+ fsg->cdev = cdev;
fsg->function.name = shortname;
fsg->function.descriptors = fs_function;
fsg->function.bind = fsg_function_bind;
return rc;
}
-static struct android_usb_function mass_storage_function = {
- .name = "usb_mass_storage",
- .bind_config = mass_storage_bind_config,
-};
-
-static int __init init(void)
-{
- printk(KERN_INFO "f_mass_storage init\n");
- android_register_function(&mass_storage_function);
- return 0;
-}
-module_init(init);
--- /dev/null
+/*
+ * drivers/usb/gadget/f_mass_storage.h
+ *
+ * Function Driver for USB Mass Storage
+ *
+ * Copyright (C) 2008 Google, Inc.
+ * Author: Mike Lockwood <lockwood@android.com>
+ *
+ * Based heavily on the file_storage gadget driver in
+ * drivers/usb/gadget/file_storage.c and licensed under the same terms:
+ *
+ * Copyright (C) 2003-2007 Alan Stern
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions, and the following disclaimer,
+ * without modification.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. The names of the above-listed copyright holders may not be used
+ * to endorse or promote products derived from this software without
+ * specific prior written permission.
+ *
+ * ALTERNATIVELY, this software may be distributed under the terms of the
+ * GNU General Public License ("GPL") as published by the Free Software
+ * Foundation, either version 2 of that License or (at your option) any
+ * later version.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+ * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __F_MASS_STORAGE_H
+#define __F_MASS_STORAGE_H
+
+int mass_storage_function_add(struct usb_composite_dev *cdev,
+ struct usb_configuration *c, int nluns);
+
+#endif /* __F_MASS_STORAGE_H */
--- /dev/null
+/*
+ * Platform data for Android USB
+ *
+ * Copyright (C) 2008 Google, Inc.
+ * Author: Mike Lockwood <lockwood@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.
+ *
+ */
+#ifndef __LINUX_USB_ANDROID_H
+#define __LINUX_USB_ANDROID_H
+
+struct android_usb_platform_data {
+ /* USB device descriptor fields */
+ __u16 vendor_id;
+
+ /* Default product ID. */
+ __u16 product_id;
+
+ /* Product ID when adb is enabled. */
+ __u16 adb_product_id;
+
+ __u16 version;
+
+ char *product_name;
+ char *manufacturer_name;
+ char *serial_number;
+
+ /* number of LUNS for mass storage function */
+ int nluns;
+};
+
+/* Platform data for "usb_mass_storage" driver.
+ * Contains values for the SC_INQUIRY SCSI command. */
+struct usb_mass_storage_platform_data {
+ char *vendor;
+ char *product;
+ int release;
+};
+
+extern void android_usb_set_connected(int on);
+
+#endif /* __LINUX_USB_ANDROID_H */
+++ /dev/null
-/*
- * Platform data for Android USB
- *
- * Copyright (C) 2008 Google, Inc.
- * Author: Mike Lockwood <lockwood@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.
- *
- */
-#ifndef __LINUX_USB_ANDROID_H
-#define __LINUX_USB_ANDROID_H
-
-#include <linux/usb/composite.h>
-
-struct android_usb_function {
- struct list_head list;
- char *name;
- int (*bind_config)(struct usb_configuration *c);
-};
-
-struct android_usb_product {
- /* Default product ID. */
- __u16 product_id;
-
- /* List of function names associated with this product.
- * This is used to compute the USB product ID dynamically
- * based on which functions are enabled.
- */
- int num_functions;
- char **functions;
-};
-
-struct android_usb_platform_data {
- /* USB device descriptor fields */
- __u16 vendor_id;
-
- /* Default product ID. */
- __u16 product_id;
-
- __u16 version;
-
- char *product_name;
- char *manufacturer_name;
- char *serial_number;
-
- /* List of available USB products.
- * This is used to compute the USB product ID dynamically
- * based on which functions are enabled.
- * if num_products is zero or no match can be found,
- * we use the default product ID
- */
- int num_products;
- struct android_usb_product *products;
-
- /* List of all supported USB functions.
- * This list is used to define the order in which
- * the functions appear in the configuration's list of USB interfaces.
- * This is necessary to avoid depending upon the order in which
- * the individual function drivers are initialized.
- */
- int num_functions;
- char **functions;
-};
-
-/* Platform data for "usb_mass_storage" driver. */
-struct usb_mass_storage_platform_data {
- /* Contains values for the SC_INQUIRY SCSI command. */
- char *vendor;
- char *product;
- int release;
-
- /* number of LUNS */
- int nluns;
-};
-
-extern void android_usb_set_connected(int on);
-
-extern void android_register_function(struct android_usb_function *f);
-
-extern void android_enable_function(struct usb_function *f, int enable);
-
-
-#endif /* __LINUX_USB_ANDROID_H */
projects / firefly-linux-kernel-4.4.55.git / commitdiff