summaryrefslogtreecommitdiff
path: root/drivers
diff options
context:
space:
mode:
Diffstat (limited to 'drivers')
-rw-r--r--drivers/i2c/busses/i2c-imx.c12
-rw-r--r--drivers/mtd/devices/m25p80.c1
-rw-r--r--drivers/usb/core/hub.c74
-rw-r--r--drivers/usb/gadget/file_storage.c6
-rw-r--r--drivers/usb/gadget/storage_common.c4
-rwxr-xr-xdrivers/usb/host/Kconfig7
-rw-r--r--drivers/usb/host/Makefile1
-rw-r--r--drivers/usb/host/arc_hset.c468
-rw-r--r--drivers/usb/host/ehci-hcd.c31
-rw-r--r--drivers/usb/host/ehci-q.c181
-rw-r--r--drivers/usb/misc/Kconfig7
-rw-r--r--drivers/usb/misc/Makefile1
-rw-r--r--drivers/usb/misc/otg-eh-test.c241
13 files changed, 1023 insertions, 11 deletions
diff --git a/drivers/i2c/busses/i2c-imx.c b/drivers/i2c/busses/i2c-imx.c
index e13e020cab2e..bd5269165aa0 100644
--- a/drivers/i2c/busses/i2c-imx.c
+++ b/drivers/i2c/busses/i2c-imx.c
@@ -125,6 +125,7 @@ static u16 __initdata i2c_clk_div[60][2] = {
};
static MVF_SEMA4* sema4;
+static int i2c_sema4_assigned = 0;
#else
static u16 __initdata i2c_clk_div[50][2] = {
{ 22, 0x20 }, { 24, 0x21 }, { 26, 0x22 }, { 28, 0x23 },
@@ -621,9 +622,14 @@ static int __init i2c_imx_probe(struct platform_device *pdev)
#ifdef CONFIG_ARCH_MVF
// for makeing sure not in use by MQX concurrently
- if(mvf_sema4_assign(MVF_I2C_SEMAPHORE_NUMBER, &sema4)) {
- dev_err(&pdev->dev, "could not assign MQX semaphore %d\n", MVF_I2C_SEMAPHORE_NUMBER);
- goto fail5;
+ if(!i2c_sema4_assigned)
+ {
+ if(mvf_sema4_assign(MVF_I2C_SEMAPHORE_NUMBER, &sema4)) {
+ dev_err(&pdev->dev, "could not assign MQX semaphore %d\n", MVF_I2C_SEMAPHORE_NUMBER);
+ goto fail5;
+ }
+ // mark the semaphore as assigned
+ i2c_sema4_assigned = 1;
}
#endif
diff --git a/drivers/mtd/devices/m25p80.c b/drivers/mtd/devices/m25p80.c
index 4c6b4f68239c..6d2f4ef3b16c 100644
--- a/drivers/mtd/devices/m25p80.c
+++ b/drivers/mtd/devices/m25p80.c
@@ -932,6 +932,7 @@ static int __devinit m25p_probe(struct spi_device *spi)
flash->mtd.dev.parent = &spi->dev;
flash->page_size = info->page_size;
+ flash->mtd.writebufsize = flash->page_size;
if (info->addr_width)
flash->addr_width = info->addr_width;
diff --git a/drivers/usb/core/hub.c b/drivers/usb/core/hub.c
index 694476ea22ac..ea6cd7feea01 100644
--- a/drivers/usb/core/hub.c
+++ b/drivers/usb/core/hub.c
@@ -165,7 +165,50 @@ EXPORT_SYMBOL_GPL(ehci_cf_port_reset_rwsem);
#define HUB_DEBOUNCE_STEP 25
#define HUB_DEBOUNCE_STABLE 100
+#ifdef CONFIG_FSL_USB_TEST_MODE
+static u8 usb_device_white_list[] = {
+ USB_CLASS_HID,
+ USB_CLASS_HUB,
+ USB_CLASS_MASS_STORAGE
+};
+
+static inline int in_white_list(u8 interfaceclass)
+{
+ int i;
+ for (i = 0; i < sizeof(usb_device_white_list); i++) {
+ if (interfaceclass == usb_device_white_list[i])
+ return 1;
+ }
+ return 0;
+}
+
+static inline int device_in_white_list(struct usb_device *udev)
+{
+ int i;
+ int num_configs;
+ struct usb_host_config *c;
+
+ /* for test fixture, we always return 1 */
+ if (udev->descriptor.idVendor == 0x1A0A)
+ return 1;
+
+ c = udev->config;
+ num_configs = udev->descriptor.bNumConfigurations;
+ for (i = 0; i < num_configs; (i++, c++)) {
+ struct usb_interface_descriptor *desc = NULL;
+
+ /* It's possible that a config has no interfaces! */
+ if (c->desc.bNumInterfaces > 0)
+ desc = &c->intf_cache[0]->altsetting->desc;
+
+ if (desc && !in_white_list((u8)desc->bInterfaceClass))
+ continue;
+ return 1;
+ }
+ return 0;
+}
+#endif
static int usb_reset_and_verify_device(struct usb_device *udev);
static inline char *portspeed(struct usb_hub *hub, int portstatus)
@@ -1696,7 +1739,18 @@ void usb_disconnect(struct usb_device **pdev)
* for de-configuring the device and invoking the remove-device
* notifier chain (used by usbfs and possibly others).
*/
- device_del(&udev->dev);
+/* device_del(&udev->dev); */
+ /* If error occur during enumeration, maybe the device_add
+ * will not call at all, so we need to identify whether this
+ * device has been added or not, here we use dev.driver to
+ * tell it
+ */
+ if (udev->dev.driver) {
+ device_del(&udev->dev);
+ printk(KERN_DEBUG "device_del called\n");
+ } else {
+ printk(KERN_DEBUG "device_del not need to call\n");
+ }
/* Free the device number and delete the parent's children[]
* (or root_hub) pointer.
@@ -1914,6 +1968,14 @@ int usb_new_device(struct usb_device *udev)
udev->dev.devt = MKDEV(USB_DEVICE_MAJOR,
(((udev->bus->busnum-1) * 128) + (udev->devnum-1)));
+#ifdef CONFIG_FSL_USB_TEST_MODE
+ if (!device_in_white_list(udev)) {
+ printk(KERN_ERR "unsupported device: not in white list\n");
+ goto fail;
+ } else {
+ printk(KERN_DEBUG "supported device\n");
+ }
+#endif
/* Tell the world! */
announce_device(udev);
@@ -2645,7 +2707,7 @@ static int hub_suspend(struct usb_interface *intf, pm_message_t msg)
struct usb_device *udev;
udev = hdev->children [port1-1];
- if (udev && udev->can_submit) {
+ if (udev && udev->can_submit && udev->dev.driver) {
dev_warn(&intf->dev, "port %d nyet suspended\n", port1);
if (msg.event & PM_EVENT_AUTO)
return -EBUSY;
@@ -3300,6 +3362,10 @@ static void hub_port_connect_change(struct usb_hub *hub, int port1,
usb_set_device_state(udev, USB_STATE_POWERED);
udev->bus_mA = hub->mA_per_port;
udev->level = hdev->level + 1;
+#ifdef CONFIG_FSL_USB_TEST_MODE
+ printk(KERN_INFO "+++ %s:udev->level :%d", __func__,
+ udev->level);
+#endif
udev->wusb = hub_is_wusb(hub);
/* Only USB 3.0 devices are connected to SuperSpeed hubs. */
@@ -3518,6 +3584,10 @@ static void hub_events(void)
if (ret < 0)
continue;
+#ifdef CONFIG_FSL_USB_TEST_MODE
+ if (portstatus & USB_PORT_STAT_TEST)
+ continue;
+#endif
if (portchange & USB_PORT_STAT_C_CONNECTION) {
clear_port_feature(hdev, i,
USB_PORT_FEAT_C_CONNECTION);
diff --git a/drivers/usb/gadget/file_storage.c b/drivers/usb/gadget/file_storage.c
index 390d43b0e2a1..b226412b926d 100644
--- a/drivers/usb/gadget/file_storage.c
+++ b/drivers/usb/gadget/file_storage.c
@@ -280,7 +280,7 @@ static const char fsg_string_product[] = DRIVER_DESC;
static const char fsg_string_config[] = "Self-powered";
static const char fsg_string_interface[] = "Mass Storage";
-
+#define FSG_NO_OTG 1 1
#include "storage_common.c"
@@ -3491,8 +3491,8 @@ static int __ref fsg_bind(struct usb_gadget *gadget)
fsg_fs_intr_in_desc.bEndpointAddress;
}
- if (gadget_is_otg(gadget))
- fsg_otg_desc.bmAttributes |= USB_OTG_HNP;
+// if (gadget_is_otg(gadget))
+// fsg_otg_desc.bmAttributes |= USB_OTG_HNP;
rc = -ENOMEM;
diff --git a/drivers/usb/gadget/storage_common.c b/drivers/usb/gadget/storage_common.c
index 1fa4f705b0b4..70658fe21bd7 100644
--- a/drivers/usb/gadget/storage_common.c
+++ b/drivers/usb/gadget/storage_common.c
@@ -64,8 +64,8 @@
* DO NOT REUSE THESE IDs with any other driver!! Ever!!
* Instead: allocate your own, using normal USB-IF procedures.
*/
-#define FSG_VENDOR_ID 0x0525 /* NetChip */
-#define FSG_PRODUCT_ID 0xa4a5 /* Linux-USB File-backed Storage Gadget */
+#define FSG_VENDOR_ID 0x15a2 /* NetChip:0x0525 */
+#define FSG_PRODUCT_ID 0x78 /* Linux-USB File-backed Storage Gadget: a4a5*/
/*-------------------------------------------------------------------------*/
diff --git a/drivers/usb/host/Kconfig b/drivers/usb/host/Kconfig
index 9e99765ee61c..c9f9a658e384 100755
--- a/drivers/usb/host/Kconfig
+++ b/drivers/usb/host/Kconfig
@@ -59,6 +59,13 @@ config USB_EHCI_HCD
To compile this driver as a module, choose M here: the
module will be called ehci-hcd.
+config FSL_USB_TEST_MODE
+ bool "FSL High-speed Electrical Test Mode Support"
+ depends on USB_EHCI_ARC
+ default n
+ ---help---
+ enable freescale test mode
+
config USB_EHCI_ARC
bool "Support for Freescale controller"
depends on USB_EHCI_HCD && (ARCH_MXC || ARCH_STMP3XXX || ARCH_MXS)
diff --git a/drivers/usb/host/Makefile b/drivers/usb/host/Makefile
index 624a362f2fee..0bcc66555507 100644
--- a/drivers/usb/host/Makefile
+++ b/drivers/usb/host/Makefile
@@ -35,3 +35,4 @@ obj-$(CONFIG_USB_HWA_HCD) += hwa-hc.o
obj-$(CONFIG_USB_IMX21_HCD) += imx21-hcd.o
obj-$(CONFIG_USB_FSL_MPH_DR_OF) += fsl-mph-dr-of.o
obj-$(CONFIG_USB_OCTEON2_COMMON) += octeon2-common.o
+obj-$(CONFIG_FSL_USB_TEST_MODE) += arc_hset.o
diff --git a/drivers/usb/host/arc_hset.c b/drivers/usb/host/arc_hset.c
new file mode 100644
index 000000000000..2ec9055c317e
--- /dev/null
+++ b/drivers/usb/host/arc_hset.c
@@ -0,0 +1,468 @@
+/*
+ * HS USB Host-mode HSET driver for ARC USB controller
+ * Copyright 2011-2013 Freescale Semiconductor, Inc. All Rights Reserved.
+ * Zhang Yan <jasper.zhang@freescale.com>
+ * Peter Chen <peter.chen@freescale.com> */
+
+#include <linux/kernel.h>
+#include <linux/errno.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/module.h>
+#include <linux/delay.h>
+#include <linux/usb.h>
+#include <linux/proc_fs.h>
+#include <linux/seq_file.h>
+
+#define EHCI_IAA_MSECS 10 /* arbitrary */
+#include <linux/usb/hcd.h>
+#include "../core/usb.h"
+#include "ehci-fsl.h"
+#include <linux/uaccess.h>
+#include <linux/io.h>
+#include <mach/arc_otg.h>
+#include "ehci.h"
+
+#define rh_level 1
+#define SINGLE_STEP_SLEEP_COUNT 15000
+#define USB_HIGH_SPEED 0x01
+#define USB_FULL_SPEED 0x02
+#define USB_LOW_SPEED 0x03
+
+/* ARC port test mode */
+#define PORTSC_PTC_TEST_MODE_DISABLE 0x00
+#define PORTSC_PTC_TEST_J 0x01
+#define PORTSC_PTC_TEST_K 0x02
+#define PORTSC_PTC_SE0_NAK 0x03
+#define PORTSC_PTC_TEST_PACKET 0x04
+#define PORTSC_PTC_FORCE_ENABLE_HS 0x05
+#define PORTSC_PTC_FORCE_ENABLE_FS 0x06
+#define PORTSC_PTC_FORCE_ENABLE_LS 0x07
+
+/* Other test */
+#define HSET_TEST_SUSPEND_RESUME 0x08
+#define HSET_TEST_GET_DEV_DESC 0x09
+#define HSET_TEST_GET_DEV_DESC_DATA 0x0A
+
+
+#define TEST_DEVICE_VID 0x1A0A
+static struct usb_device_id archset_table[] = {
+ { USB_DEVICE(TEST_DEVICE_VID, 0x0101) }, /* Test_SE0_NAK */
+ { USB_DEVICE(TEST_DEVICE_VID, 0x0102) }, /* Test_J */
+ { USB_DEVICE(TEST_DEVICE_VID, 0x0103) }, /* Test_K */
+ { USB_DEVICE(TEST_DEVICE_VID, 0x0104) }, /* Test_Packet */
+ { USB_DEVICE(TEST_DEVICE_VID, 0x0105) }, /* Force enable */
+ { USB_DEVICE(TEST_DEVICE_VID, 0x0106) }, /* HS_HOST_PORT_SUSPEND_RESUME */
+ { USB_DEVICE(TEST_DEVICE_VID, 0x0107) }, /* SINGLE_STEP_GET_DEV_DESC */
+ { USB_DEVICE(TEST_DEVICE_VID, 0x0108) }, /* SINGLE_STEP_GET_DEV_DESC_DATA */
+ { } /* Terminating entry */
+};
+MODULE_DEVICE_TABLE(usb, archset_table);
+
+/* Private data */
+struct usb_archset {
+ struct usb_device *udev; /* the usb device for this device */
+ struct usb_interface *interface; /* the interface for this device */
+ struct kref kref;
+ struct ehci_hcd *ehci; /* the usb controller */
+ char ptcname[24];
+};
+
+ void set_single_step_desc_data_on(void);
+ void clear_single_step_desc_data_on(void);
+
+static void arc_kill_per_sched(struct ehci_hcd *ehci)
+{
+ u32 command = 0;
+ command = ehci_readl(ehci, &ehci->regs->command);
+ command &= ~(CMD_PSE);
+ ehci_writel(ehci, command, &ehci->regs->command);
+ printk(KERN_INFO "+++ %s: Periodic Schedule Stopped", __func__);
+}
+
+static void arc_hset_test(struct ehci_hcd *ehci, int mode)
+{
+ u32 portsc = 0;
+
+ portsc = ehci_readl(ehci, &ehci->regs->port_status[0]);
+ portsc &= ~(0xf << 16);
+ portsc |= (mode << 16);
+ ehci_writel(ehci, portsc, &ehci->regs->port_status[0]);
+}
+
+static inline void hub_set_testmode(struct usb_device *udev, u8
+ test_mode)
+{
+ struct usb_device *hub_dev;
+ int i;
+ int max_port;
+ int status;
+ u8 level = udev->level;
+
+ if (level == 0)
+ return;
+ else {
+ printk(KERN_INFO "run %s at tie %d hub\n", __func__, level);
+ /* get the port number of parent */
+ if (udev->parent != NULL) {
+ hub_dev = udev->parent;
+ max_port = hub_dev->maxchild;
+ } else {
+ printk(KERN_INFO "device don't have parent hub\n");
+ return;
+ }
+
+ for (i = 0; i < max_port; i++) {
+ status = usb_control_msg(hub_dev, usb_sndctrlpipe(udev, 0),
+ USB_REQ_SET_FEATURE, USB_RT_PORT,
+ USB_PORT_FEAT_SUSPEND, i+1,
+ NULL, 0, 1000);
+ if (status >= 0)
+ printk(KERN_INFO "send port_suspend to port %d\n", i+1);
+ else {
+ printk(KERN_INFO "send port_suspend error %d to port %d\n",
+ status, i+1);
+ continue;
+ }
+ }
+ msleep(1000);
+ status = usb_control_msg(hub_dev, usb_sndctrlpipe(udev, 0),
+ USB_REQ_SET_FEATURE/*USB_REQ_CLEAR_FEATURE*/, USB_RT_PORT,
+ USB_PORT_FEAT_TEST, (__u16) ((test_mode << 8) | udev->portnum),
+ NULL, 0, 1000);
+ if (status >= 0)
+ printk(KERN_INFO "send cmd %d to port %d\n", test_mode, udev->portnum);
+ else
+ printk(KERN_INFO "send cmd %d error %d to port %d\n", test_mode, status, udev->portnum);
+ }
+}
+
+static inline void test_j(struct usb_archset *hset)
+{
+ struct usb_device *udev = hset->udev;
+ u8 level = udev->level;
+ if (level == rh_level) {
+ printk(KERN_INFO "%s at tie %d hub\n", __func__, level);
+ arc_hset_test(hset->ehci, PORTSC_PTC_TEST_J);
+ } else
+ hub_set_testmode(udev, PORTSC_PTC_TEST_J);
+}
+
+static inline void test_k(struct usb_archset *hset)
+{
+ struct usb_device *udev = hset->udev;
+ u8 level = udev->level;
+ printk(KERN_INFO "%s at tie %d hub\n", __func__, level);
+ if (level == rh_level)
+ arc_hset_test(hset->ehci, PORTSC_PTC_TEST_K);
+ else
+ hub_set_testmode(udev, PORTSC_PTC_TEST_K);
+}
+
+static inline void test_se0_nak(struct usb_archset *hset)
+{
+ struct usb_device *udev = hset->udev;
+ u8 level = udev->level;
+ printk(KERN_INFO "%s at tie %d hub\n", __func__, level);
+ if (level == rh_level)
+ arc_hset_test(hset->ehci, PORTSC_PTC_SE0_NAK);
+ else
+ hub_set_testmode(udev, PORTSC_PTC_SE0_NAK);
+}
+
+static inline void test_packet(struct usb_archset *hset)
+{
+ struct usb_device *udev = hset->udev;
+ u8 level = udev->level;
+ printk(KERN_INFO "%s at tie %d hub\n", __func__, level);
+ if (level == rh_level)
+ arc_hset_test(hset->ehci, PORTSC_PTC_TEST_PACKET);
+ else
+ hub_set_testmode(udev, PORTSC_PTC_TEST_PACKET);
+}
+
+static inline void test_force_enable(struct usb_archset *hset, int
+ forcemode)
+{
+ struct usb_device *udev = hset->udev;
+ u8 level = udev->level;
+ int ptc_fmode = 0;
+ printk(KERN_INFO "%s at tie %d hub\n", __func__, level);
+ if (level == 0) {
+ switch (forcemode) {
+ case USB_HIGH_SPEED:
+ ptc_fmode = PORTSC_PTC_FORCE_ENABLE_HS;
+ break;
+ case USB_FULL_SPEED:
+ ptc_fmode = PORTSC_PTC_FORCE_ENABLE_FS;
+ break;
+ case USB_LOW_SPEED:
+ ptc_fmode = PORTSC_PTC_FORCE_ENABLE_LS;
+ break;
+ default:
+ printk(KERN_ERR "unknown speed mode %d\n", forcemode);
+ return;
+ }
+ arc_hset_test(hset->ehci, ptc_fmode);
+ } else
+ hub_set_testmode(udev, PORTSC_PTC_FORCE_ENABLE_HS);
+}
+
+static void suspend(struct usb_archset *hset)
+{
+ struct ehci_hcd *ehci = hset->ehci;
+ u32 portsc = 0;
+
+ portsc = ehci_readl(ehci, &ehci->regs->port_status[0]);
+ portsc |= PORT_SUSPEND; /* Set suspend */
+ ehci_writel(ehci, portsc, &ehci->regs->port_status[0]);
+}
+
+
+static void resume(struct usb_archset *hset)
+{
+ struct ehci_hcd *ehci = hset->ehci;
+ u32 portsc = 0;
+
+ portsc = ehci_readl(ehci, &ehci->regs->port_status[0]);
+ portsc |= PORT_RESUME;
+ ehci_writel(ehci, portsc, &ehci->regs->port_status[0]);
+}
+
+static void test_suspend_resume(struct usb_archset *hset)
+{
+ printk(KERN_INFO "%s\n", __func__);
+
+ suspend(hset);
+ msleep(15000); /* Wait for 15s */
+ resume(hset);
+}
+
+static void test_single_step_get_dev_desc(struct usb_archset *hset)
+{
+ struct ehci_hcd *ehci = hset->ehci;
+ struct usb_bus *bus = hcd_to_bus(ehci_to_hcd(ehci));
+ struct usb_device *udev = hset->udev;
+ int result;
+
+ if (!ehci || !bus || !bus->root_hub) {
+ printk(KERN_ERR "Host controller not ready!\n");
+ return;
+ }
+
+ if (!udev) {
+ printk(KERN_ERR "No device connected.\n");
+ return;
+ }
+
+ /* Stop Periodic schedule to prevent polling of hubs */
+ arc_kill_per_sched(hset->ehci);
+
+ msleep(SINGLE_STEP_SLEEP_COUNT); /* SOF for 15s */
+
+ result = usb_get_device_descriptor(udev, sizeof(struct usb_device_descriptor));
+ if (result < 0 && result != -ETIMEDOUT)
+ printk(KERN_ERR "usb_get_device_descriptor failed %d\n", result);
+ else
+ printk(KERN_INFO "usb_get_device_descriptor passed\n");
+}
+static void test_single_step_get_dev_desc_data(struct usb_archset *hset)
+{
+ struct usb_device *udev = hset->udev;
+ struct usb_device_descriptor *desc;
+ int result;
+ unsigned int size = sizeof(struct usb_device_descriptor);
+ printk(KERN_INFO "%s size = %d\n", __func__, size);
+ desc = kmalloc(sizeof(*desc), GFP_NOIO);
+ if (!desc) {
+ printk(KERN_ERR "alloc desc failed\n");
+ return ;
+ }
+
+ set_single_step_desc_data_on();
+
+ result = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
+ USB_REQ_GET_DESCRIPTOR, USB_DIR_IN,
+ (0x01 << 8) + 0, 0, desc, size, USB_CTRL_GET_TIMEOUT);
+ if (result < 0 && result != -ETIMEDOUT)
+ printk(KERN_ERR "the setup transaction failed %d\n", result);
+ else
+ printk(KERN_INFO "the setup transaction passed\n");
+
+
+ /* Stop Periodic schedule to prevent polling of hubs */
+ arc_kill_per_sched(hset->ehci);
+
+ msleep(SINGLE_STEP_SLEEP_COUNT);
+
+ result = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
+ USB_REQ_GET_DESCRIPTOR, USB_DIR_IN,
+ (0x01 << 8) + 0, 0, desc, size, USB_CTRL_GET_TIMEOUT);
+ if (result <= 0 && result != -ETIMEDOUT)
+ printk(KERN_ERR "the data transaction failed %d\n", result);
+ else
+ printk(KERN_INFO "the data transaction passed\n");
+
+ result = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
+ USB_REQ_GET_DESCRIPTOR, USB_DIR_IN,
+ (0x01 << 8) + 0, 0, desc, size, USB_CTRL_GET_TIMEOUT);
+ if (result < 0 && result != -ETIMEDOUT)
+ printk(KERN_ERR "the status transaction failed %d\n", result);
+ else
+ printk(KERN_INFO "the status transaction passed\n");
+
+ clear_single_step_desc_data_on();
+
+ kfree(desc);
+
+ msleep(SINGLE_STEP_SLEEP_COUNT); /* SOF for 15s */
+ printk(KERN_INFO "test_single_step_get_dev_desc_data finished\n");
+}
+
+
+void test_single_step_set_feature(struct usb_archset *hset)
+{
+ struct ehci_hcd *ehci = hset->ehci;
+ struct usb_bus *bus = hcd_to_bus(ehci_to_hcd(ehci));
+ struct usb_device *udev;
+
+ if (!ehci || !bus || !bus->root_hub) {
+ printk(KERN_ERR "Host controller not ready!\n");
+ return;
+ }
+ udev = bus->root_hub->children[0];
+ if (!udev) {
+ printk(KERN_ERR "No device connected.\n");
+ return;
+ }
+ usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
+ USB_REQ_SET_FEATURE, 0, 0, 0,
+ NULL, 0, USB_CTRL_SET_TIMEOUT);
+}
+
+static struct usb_archset *the_hset[4];
+static struct usb_archset *init_hset_dev(void *controller)
+{
+ struct ehci_hcd *ehci = (struct ehci_hcd *)controller;
+ struct usb_archset *hset = NULL;
+ int ctrid = 0;
+
+ ctrid = ehci_to_hcd(ehci)->self.busnum-1;
+ if (the_hset[ctrid]) {
+ kref_get(&the_hset[ctrid]->kref);
+ return the_hset[ctrid];
+ }
+
+ hset = kzalloc(sizeof(struct usb_archset), GFP_KERNEL);
+ if (hset == NULL) {
+ printk(KERN_ERR "Out of memory!\n");
+ return NULL;
+ }
+ hset->ehci = (struct ehci_hcd *)controller;
+ kref_init(&hset->kref);
+ the_hset[ctrid] = hset;
+
+ return hset;
+}
+
+
+static void hset_delete(struct kref *kref)
+{
+ struct usb_archset *hset = container_of(kref, struct usb_archset,
+ kref);
+
+ kfree(hset);
+}
+
+static int archset_probe(struct usb_interface *iface,
+ const struct usb_device_id *id)
+{
+ struct usb_archset *hset;
+ struct usb_device *udev;
+ struct usb_hcd *hcd;
+
+ udev = usb_get_dev(interface_to_usbdev(iface));
+ hcd = bus_to_hcd(udev->bus);
+ hset = init_hset_dev((void *)hcd_to_ehci(hcd));
+ if (hset == NULL)
+ return -ENOMEM;
+
+ hset->udev = udev;
+ usb_set_intfdata(iface, hset);
+ switch (id->idProduct) {
+ case 0x0101:
+ test_se0_nak(hset);
+ break;
+ case 0x0102:
+ test_j(hset);
+ break;
+ case 0x0103:
+ test_k(hset);
+ break;
+ case 0x0104:
+ test_packet(hset);
+ break;
+ case 0x0105:
+ printk(KERN_INFO "Force FS/FS/LS ?\n");
+ test_force_enable(hset, USB_HIGH_SPEED);
+ break;
+ case 0x0106:
+ test_suspend_resume(hset);
+ break;
+ case 0x0107:
+ printk(KERN_INFO "Begin SINGLE_STEP_GET_DEVICE_DESCRIPTOR\n");
+ test_single_step_get_dev_desc(hset);
+ break;
+ case 0x0108:
+ printk(KERN_INFO "Begin SINGLE_STEP_GET_DEVICE_DESCRIPTOR_DATA\n");
+ test_single_step_get_dev_desc_data(hset);
+ break;
+ }
+
+ return 0;
+}
+
+static void archset_disconnect(struct usb_interface *iface)
+{
+ struct usb_archset *hset;
+
+ hset = usb_get_intfdata(iface);
+ usb_set_intfdata(iface, NULL);
+
+ usb_put_dev(hset->udev);
+ kref_put(&hset->kref, hset_delete);
+}
+
+
+static struct usb_driver archset_driver = {
+ .name = "arc hset",
+ .probe = archset_probe,
+ .disconnect = archset_disconnect,
+ .id_table = archset_table,
+};
+
+static int __init usb_hset_init(void)
+{
+ int ret = 0;
+ printk(KERN_ERR "usb register error with %d\n", ret);
+ /* register driver to usb subsystem */
+ ret = usb_register(&archset_driver);
+ if (ret)
+ printk(KERN_ERR "usb register error with %d\n", ret);
+ else
+ printk(KERN_INFO "usb hset init succeed\n");
+
+ return ret;
+}
+
+static void __exit usb_hset_exit(void)
+{
+ usb_deregister(&archset_driver);
+}
+
+module_init(usb_hset_init);
+module_exit(usb_hset_exit);
+MODULE_DESCRIPTION("Freescale USB Host Test Mode Driver");
+MODULE_AUTHOR("Jasper Zhang");
+MODULE_LICENSE("GPL");
+
diff --git a/drivers/usb/host/ehci-hcd.c b/drivers/usb/host/ehci-hcd.c
index ffc22bf1d825..c486480ab982 100644
--- a/drivers/usb/host/ehci-hcd.c
+++ b/drivers/usb/host/ehci-hcd.c
@@ -48,6 +48,21 @@
#include <asm/system.h>
#include <asm/unaligned.h>
+
+#ifdef CONFIG_FSL_USB_TEST_MODE
+static u32 single_step_desc_data_on;
+void set_single_step_desc_data_on(void)
+{
+ single_step_desc_data_on = 1;
+}
+EXPORT_SYMBOL_GPL(set_single_step_desc_data_on);
+
+void clear_single_step_desc_data_on(void)
+{
+ single_step_desc_data_on = 0;
+}
+EXPORT_SYMBOL_GPL(clear_single_step_desc_data_on);
+#endif
/*-------------------------------------------------------------------------*/
/*
@@ -959,8 +974,22 @@ static int ehci_urb_enqueue (
/* FALLTHROUGH */
/* case PIPE_BULK: */
default:
- if (!qh_urb_transaction (ehci, urb, &qtd_list, mem_flags))
+#ifdef CONFIG_FSL_USB_TEST_MODE
+ if (!single_step_desc_data_on) {
+ printk(KERN_DEBUG "in test mode, but single step NOT on\n");
+ if (!qh_urb_transaction(ehci, urb, &qtd_list,
+ mem_flags))
+ return -ENOMEM;
+ } else {
+ printk(KERN_DEBUG "in test mode, single step on\n");
+ if (!single_step_qh_urb_transaction(ehci, urb,
+ &qtd_list, mem_flags))
+ return -ENOMEM;
+ }
+#else
+ if (!qh_urb_transaction(ehci, urb, &qtd_list, mem_flags))
return -ENOMEM;
+#endif
return submit_async(ehci, urb, &qtd_list, mem_flags);
case PIPE_INTERRUPT:
diff --git a/drivers/usb/host/ehci-q.c b/drivers/usb/host/ehci-q.c
index 271987952e33..f8fac3aca850 100644
--- a/drivers/usb/host/ehci-q.c
+++ b/drivers/usb/host/ehci-q.c
@@ -592,6 +592,187 @@ static void qtd_list_free (
}
}
+#ifdef CONFIG_FSL_USB_TEST_MODE
+/*
+ * create a list of filled qtds for this URB; won't link into qh.
+ */
+static struct list_head *
+single_step_qh_urb_transaction(
+ struct ehci_hcd *ehci,
+ struct urb *urb,
+ struct list_head *head,
+ gfp_t flags
+) {
+ struct ehci_qtd *qtd, *qtd_prev;
+ dma_addr_t buf;
+ int len, this_sg_len, maxpacket;
+ int is_input;
+ u32 token;
+ int i;
+ struct scatterlist *sg;
+#define SINGLE_STEP_PHASE_SETUP 0
+#define SINGLE_STEP_PHASE_DATA 1
+#define SINGLE_STEP_PHASE_STATUS 2
+#define SINGLE_STEP_PHASE_NONE 0xFF
+ static u32 phase_state = SINGLE_STEP_PHASE_NONE;
+
+ /*
+ * URBs map to sequences of QTDs: one logical transaction
+ */
+ qtd = ehci_qtd_alloc(ehci, flags);
+ if (unlikely(!qtd))
+ return NULL;
+ list_add_tail(&qtd->qtd_list, head);
+ qtd->urb = urb;
+
+ token = QTD_STS_ACTIVE;
+ token |= (EHCI_TUNE_CERR << 10);
+ /* for split transactions, SplitXState initialized to zero */
+ len = urb->transfer_buffer_length;
+ is_input = usb_pipein(urb->pipe);
+ if (!is_input) {
+ printk(KERN_INFO "single step can only send IN\n");
+ return NULL;
+ }
+
+ if (!usb_pipecontrol(urb->pipe)) {
+ printk(KERN_INFO "single step can only send control pipe\n");
+ return NULL;
+ }
+
+ if (phase_state == SINGLE_STEP_PHASE_NONE) {
+ /*
+ * SETUP pid
+ * we use transfer_buffer_length to identfiy whether it
+ * is in setup phase or data phase
+ */
+ qtd_fill(ehci, qtd, urb->setup_dma,
+ sizeof(struct usb_ctrlrequest),
+ token | (2 /* "setup" */ << 8), 8);
+
+ /* ... and always at least one more pid */
+ qtd->urb = urb;
+ phase_state = SINGLE_STEP_PHASE_SETUP;
+ }
+ /*
+ * data transfer stage: buffer setup
+ */
+ else
+ if (phase_state == SINGLE_STEP_PHASE_SETUP &&
+ len != 0) {
+ i = urb->num_sgs;
+ if (len > 0 && i > 0) {
+ sg = urb->sg;
+ buf = sg_dma_address(sg);
+
+ /* urb->transfer_buffer_length may be smaller than the
+ * size of the scatterlist (or vice versa)
+ */
+ this_sg_len = min_t(int, sg_dma_len(sg), len);
+ } else {
+ sg = NULL;
+ buf = urb->transfer_dma;
+ this_sg_len = len;
+ }
+
+ if (is_input)
+ token |= (1 /* "in" */ << 8);
+ /* else it's already initted to "out" pid (0 << 8) */
+ maxpacket = max_packet(usb_maxpacket(urb->dev,
+ urb->pipe, !is_input));
+ /* for the first data qtd, the toggle should be 1 */
+ token ^= QTD_TOGGLE;
+
+ /*
+ * buffer gets wrapped in one or more qtds;
+ * last one may be "short" (including zero len)
+ * and may serve as a control status ack
+ */
+ for (;;) {
+ int this_qtd_len;
+
+ this_qtd_len = qtd_fill(ehci, qtd, buf, this_sg_len,
+ token, maxpacket);
+ this_sg_len -= this_qtd_len;
+ len -= this_qtd_len;
+ buf += this_qtd_len;
+
+ /*
+ * short reads advance to a "magic" dummy instead of
+ * the next qtd ... that forces the queue to stop, for
+ * manual cleanup. (will usually be overridden later.)
+ */
+ if (is_input)
+ qtd->hw_alt_next = ehci->async->hw->hw_alt_next;
+
+ /* qh makes control packets use qtd toggle; switch it*/
+ if ((maxpacket & (this_qtd_len + (maxpacket - 1))) == 0)
+ token ^= QTD_TOGGLE;
+
+ if (likely(this_sg_len <= 0)) {
+ if (--i <= 0 || len <= 0)
+ break;
+ sg = sg_next(sg);
+ buf = sg_dma_address(sg);
+ this_sg_len = min_t(int, sg_dma_len(sg), len);
+ }
+
+ qtd_prev = qtd;
+ qtd = ehci_qtd_alloc(ehci, flags);
+ if (unlikely(!qtd))
+ goto cleanup;
+ qtd->urb = urb;
+ qtd_prev->hw_next = QTD_NEXT(ehci, qtd->qtd_dma);
+ list_add_tail(&qtd->qtd_list, head);
+ }
+
+ phase_state = SINGLE_STEP_PHASE_DATA;
+
+ /*
+ * unless the caller requires manual cleanup after short reads,
+ * have the alt_next mechanism keep the queue running after the
+ * last data qtd (the only one, for control and other cases).
+ */
+ if (likely((urb->transfer_flags & URB_SHORT_NOT_OK) == 0
+ || usb_pipecontrol(urb->pipe)))
+ qtd->hw_alt_next = EHCI_LIST_END(ehci);
+ }
+
+ /*
+ * control requests may need a terminating data "status" ack;
+ * bulk ones may need a terminating short packet (zero length).
+ */
+ else
+ if (phase_state == SINGLE_STEP_PHASE_DATA) {
+ int one_more = 0;
+ if (usb_pipecontrol(urb->pipe)) {
+ one_more = 1;
+ /* for single step, it always be out here */
+ token &= ~(3 << 8);
+ token |= QTD_TOGGLE; /* force DATA1 */
+ } else if (usb_pipebulk(urb->pipe)
+ && (urb->transfer_flags & URB_ZERO_PACKET)
+ && !(urb->transfer_buffer_length % maxpacket)) {
+ one_more = 1;
+ }
+ if (one_more) {
+ /* never any data in such packets */
+ qtd_fill(ehci, qtd, 0, 0, token, 0);
+ }
+ }
+
+ /* by default, enable interrupt on urb completion */
+ if (likely(!(urb->transfer_flags & URB_NO_INTERRUPT)))
+ qtd->hw_token |= cpu_to_hc32(ehci, QTD_IOC);
+ return head;
+
+cleanup:
+ qtd_list_free(ehci, urb, head);
+ phase_state = SINGLE_STEP_PHASE_NONE;
+ return NULL;
+}
+#endif
+
/*
* create a list of filled qtds for this URB; won't link into qh.
*/
diff --git a/drivers/usb/misc/Kconfig b/drivers/usb/misc/Kconfig
index 1bfcd02ebeb5..de8933e5e78b 100644
--- a/drivers/usb/misc/Kconfig
+++ b/drivers/usb/misc/Kconfig
@@ -218,6 +218,13 @@ config USB_TEST
See <http://www.linux-usb.org/usbtest/> for more information,
including sample test device firmware and "how to use it".
+config USB_OTG_EH_TEST
+ tristate "USB OTG & EH Test Mode Support driver"
+ depends on USB && USB_SUSPEND
+ help
+ This driver is for running tests define on OTG & Embedded Host
+ Specification.
+
config USB_ISIGHTFW
tristate "iSight firmware loading support"
depends on USB
diff --git a/drivers/usb/misc/Makefile b/drivers/usb/misc/Makefile
index 796ce7ebccc8..6b17e8c64e45 100644
--- a/drivers/usb/misc/Makefile
+++ b/drivers/usb/misc/Makefile
@@ -21,6 +21,7 @@ obj-$(CONFIG_USB_LED) += usbled.o
obj-$(CONFIG_USB_LEGOTOWER) += legousbtower.o
obj-$(CONFIG_USB_RIO500) += rio500.o
obj-$(CONFIG_USB_TEST) += usbtest.o
+obj-$(CONFIG_USB_OTG_EH_TEST) += otg-eh-test.o
obj-$(CONFIG_USB_TRANCEVIBRATOR) += trancevibrator.o
obj-$(CONFIG_USB_USS720) += uss720.o
obj-$(CONFIG_USB_SEVSEG) += usbsevseg.o
diff --git a/drivers/usb/misc/otg-eh-test.c b/drivers/usb/misc/otg-eh-test.c
new file mode 100644
index 000000000000..d638149d809f
--- /dev/null
+++ b/drivers/usb/misc/otg-eh-test.c
@@ -0,0 +1,241 @@
+/**
+ * otg-eh-test.c - OTG & Embedded Host Test Support Driver
+ *
+ * Copyright (C) 2012 Texas Instruments Incorporated - http://www.ti.com
+ *
+ * Author: Felipe Balbi <balbi@ti.com>
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 as published by
+ * the Free Software Foundation.
+ *
+ * ALTERNATIVELY, this software may be distributed under the terms of the
+ * GNU General Public License ("GPL") version 2, as published by the Free
+ * Software Foundation.
+ *
+ * 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.
+ * 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/module.h>
+#include <linux/kernel.h>
+#include <linux/delay.h>
+#include <linux/usb.h>
+
+#include <linux/usb/ch11.h>
+#include <linux/usb/ch9.h>
+
+#define USB_IF_TEST_VID 0x1a0a
+
+#define USB_IF_TEST_SE0_NAK 0x0101
+#define USB_IF_TEST_J 0x0102
+#define USB_IF_TEST_K 0x0103
+#define USB_IF_TEST_PACKET 0x0104
+#define USB_IF_HS_HOST_PORT_SUSPEND_RESUME 0x0106
+#define USB_IF_SINGLE_STEP_GET_DEV_DESC 0x0107
+#define USB_IF_SINGLE_STEP_GET_DEV_DESC_DATA 0x0108
+
+#define USB_IF_PROTOCOL_OTG_ELECTRICAL_TEST 0x0200
+
+static int usb_set_hub_port_test(struct usb_device *udev, int test)
+{
+ struct usb_device *hub = udev->parent;
+ int port = udev->portnum;
+
+ return usb_control_msg(hub, usb_sndctrlpipe(hub, 0),
+ USB_REQ_SET_FEATURE, USB_RT_PORT, USB_PORT_FEAT_TEST,
+ (test << 8) | port, NULL, 0, 1000);
+}
+
+static int otg_eh_probe(struct usb_interface *intf,
+ const struct usb_device_id *id)
+{
+ struct usb_device_descriptor desc;
+ struct usb_device *udev;
+ int ret;
+
+ udev = interface_to_usbdev(intf);
+
+ usb_enable_autosuspend(udev);
+ usb_autopm_get_interface(intf);
+
+ switch (id->idProduct) {
+ case USB_IF_TEST_SE0_NAK:
+ /*
+ * Upon enumerating VID 0x1A0A/PID 0x0101, the host’s
+ * downstream port shall enter a high-speed receive mode as
+ * described in Section 7.1.20 [USB2.0] and drives an SE0 until
+ * the controller is reset.
+ */
+ usb_set_hub_port_test(udev, TEST_SE0_NAK);
+ break;
+ case USB_IF_TEST_J:
+ /*
+ * Upon enumerating VID 0x1A0A/PID 0x0102, the host’s
+ * downstream port shall enter a high-speed J state as
+ * described in Section 7.1.20 of [USB2.0] until the host
+ * controller is reset.
+ */
+ usb_set_hub_port_test(udev, TEST_J);
+ break;
+ case USB_IF_TEST_K:
+ /*
+ * Upon enumerating VID 0x1A0A/PID 0x0103, the host’s
+ * downstream port shall enter a high-speed K state as
+ * described in Section 7.1.20 of [USB2.0] until the host
+ * controller is reset.
+ */
+ usb_set_hub_port_test(udev, TEST_K);
+ break;
+ case USB_IF_TEST_PACKET:
+ /*
+ * Upon enumerating VID 0x1A0A/PID 0x0104, the host shall begin
+ * sending test packets as described in Section 7.1.20 of
+ * [USB2.0] until the host controller is reset.
+ */
+ usb_set_hub_port_test(udev, TEST_PACKET);
+ break;
+ case USB_IF_HS_HOST_PORT_SUSPEND_RESUME:
+ /*
+ * Upon enumerating VID:0x1A0A/PID 0x0106, the host shall
+ * continue sending SOFs for 15 seconds, then suspend the
+ * downstream port under test per Section 7.1.7.6.1 of
+ * [USB2.0]. After 15 seconds has elapsed, the host shall issue
+ * a ResumeK state on the bus, then continue sending SOFs.
+ */
+ msleep(15000);
+ usb_autopm_put_interface(intf);
+ msleep(15000);
+ usb_autopm_get_interface(intf);
+ break;
+ case USB_IF_SINGLE_STEP_GET_DEV_DESC:
+ /*
+ * When the host discovers a device with VID:0x1A0A/PID 0x0107,
+ * the following steps are executed by the host and the device.
+ *
+ * 1. The host enumerates the test device, reads VID:0x1A0A/PID
+ * 0x0107, then completes its enumeration procedure.
+ *
+ * 2. The host issues SOFs for 15 seconds allowing the test
+ * engineer to raise the scope trigger just above the SOF
+ * voltage level.
+ *
+ * 3. The host sends a complete GetDescriptor(Device) transfer
+ *
+ * 4. The device ACKs the request, triggering the scope. (Note:
+ * SOFs continue.)
+ */
+ msleep(15000);
+ ret = usb_get_descriptor(udev, USB_DT_DEVICE, 0, &desc, USB_DT_DEVICE_SIZE);
+ if (ret < 0)
+ dev_err(&intf->dev, "failed to get device descriptor\n");
+
+ break;
+ case USB_IF_SINGLE_STEP_GET_DEV_DESC_DATA:
+ /*
+ * When the host discovers a device with VID:0x1A0A/PID 0x0108,
+ * the following steps are executed by the host and the device.
+ *
+ * 1. The host enumerates the test device and reads
+ * VID:0x1A0A/PID 0x0108, then completes its enumeration
+ * procedure
+ *
+ * 2. After enumerating the device, the host sends
+ * GetDescriptor(Device)
+ *
+ * 3. The device ACKs the request
+ *
+ * 4. The host issues SOFs for 15 seconds allowing the test
+ * engineer to raise the scope trigger just above the SOF
+ * voltage level
+ *
+ * 5. The host sends an IN packet
+ *
+ * 6. The device sends data in response to the IN packet,
+ * triggering the scope
+ *
+ * 7. The host sends an ACK in response to the data. (Note:
+ * SOFs may follow the IN transaction).
+ */
+ ret = usb_get_descriptor(udev, USB_DT_DEVICE, 0, &desc, USB_DT_DEVICE_SIZE);
+ if (ret < 0)
+ dev_err(&intf->dev, "failed to get device descriptor\n");
+ msleep(15000);
+ break;
+ case USB_IF_PROTOCOL_OTG_ELECTRICAL_TEST:
+ /* OTG-A Device */
+ if (udev->bus->otg_port == udev->portnum) {
+ ret = usb_driver_set_configuration(udev, 1);
+ if (ret < 0)
+ dev_err(&intf->dev, "unable to set configuration #1\n");
+ } else if (udev->bus->is_b_host) {
+ /* configuration -1 means "unconfigured" */
+ ret = usb_driver_set_configuration(udev, -1);
+ if (ret < 0)
+ dev_err(&intf->dev, "unable to unconfigure device\n");
+
+ /* forcefully suspend */
+ usb_autopm_put_interface(intf);
+ }
+
+ break;
+ default:
+ dev_err(&intf->dev, "Unsupported device\n");
+ }
+
+ usb_disable_autosuspend(udev);
+
+ return 0;
+}
+
+static void otg_eh_disconnect(struct usb_interface *intf)
+{
+ struct usb_device *udev;
+
+ udev = interface_to_usbdev(intf);
+
+ usb_lock_device_for_reset(udev, intf);
+ usb_reset_device(udev);
+ usb_unlock_device(udev);
+}
+
+static const struct usb_device_id otg_eh_id_table[] __devinitconst = {
+ { USB_DEVICE(USB_IF_TEST_VID, USB_IF_TEST_SE0_NAK), },
+ { USB_DEVICE(USB_IF_TEST_VID, USB_IF_TEST_J), },
+ { USB_DEVICE(USB_IF_TEST_VID, USB_IF_TEST_K), },
+ { USB_DEVICE(USB_IF_TEST_VID, USB_IF_TEST_PACKET), },
+ { USB_DEVICE(USB_IF_TEST_VID, USB_IF_HS_HOST_PORT_SUSPEND_RESUME), },
+ { USB_DEVICE(USB_IF_TEST_VID, USB_IF_SINGLE_STEP_GET_DEV_DESC), },
+ { USB_DEVICE(USB_IF_TEST_VID, USB_IF_SINGLE_STEP_GET_DEV_DESC_DATA), },
+ { USB_DEVICE(USB_IF_TEST_VID, USB_IF_PROTOCOL_OTG_ELECTRICAL_TEST), },
+
+ { } /* Terminating Entry */
+};
+MODULE_DEVICE_TABLE(usb, otg_eh_id_table);
+
+static struct usb_driver otg_eh_driver = {
+ .name = "otg-eh-test",
+ .probe = otg_eh_probe,
+ .disconnect = otg_eh_disconnect,
+ .id_table = otg_eh_id_table,
+ .supports_autosuspend = true,
+};
+
+module_usb_driver(otg_eh_driver);
+
+MODULE_AUTHOR("Felipe Balbi <balbi@ti.com>");
+MODULE_LICENSE("GPL v2");
+MODULE_DESCRIPTION("USB OTG & EH Test Driver");
generated by cgit v1.2.3 (git 2.0.4) at 2024-11-15 22:18:23 +0000