[PATCH] HSET tool for the MUSB Controler

Felipe Balbi
2007-05-29T12:02:39Z

From: Vikram Pandita <vikram.pandita@ti.com>

This patch was took from linux-usb-devel mailing list.

It will help us until I finish developing a userspace application
such as USBHSET.exe tool from usb.org/developer/tools.

We need to provide such tool for the USB Certification Lab.

Signed-off-by: Felipe Balbi <felipe.lima@indt.org.br>
---

Index: linux-omap-2.6/drivers/usb/musb/Makefile
===================================================================
--- linux-omap-2.6.orig/drivers/usb/musb/Makefile 2007-05-09 14:38:23.000000000 +0300
+++ linux-omap-2.6/drivers/usb/musb/Makefile 2007-05-25 14:17:05.000000000 +0300
@@ -23,7 +23,7 @@
endif

ifeq ($(CONFIG_USB_MUSB_HDRC_HCD),y)
- musb_hdrc-objs += virthub.o musb_host.o
+ musb_hdrc-objs += virthub.o musb_host.o musb_hset.o
endif

# the kconfig must guarantee that only one of the
Index: linux-omap-2.6/drivers/usb/musb/musb_hset.c
===================================================================
--- /dev/null 1970-01-01 00:00:00.000000000 +0000
+++ linux-omap-2.6/drivers/usb/musb/musb_hset.c 2007-05-25 14:17:05.000000000 +0300
@@ -0,0 +1,597 @@
+/*
+ * HS USB Host-mode HSET driver for Mentor USB Controller
+ *
+ * Copyright (C) 2005 Mentor Graphics Corporation
+ * Copyright (C) 2007 Texas Instruments, Inc.
+ * Nishant Kamat <nskamat@ti.com>
+ * Vikram Pandita <vikram.pandita@ti.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation, version 2.
+ *
+ * This driver is based on the USB Skeleton driver-2.0
+ * (drivers/usb/usb-skeleton.c) written by Greg Kroah-Hartman (greg@kroah.com)
+ *
+ * Notes:
+ * There are 2 ways this driver can be used:
+ * 1 - By attaching a HS OPT (OTG Protocol Tester) card.
+ * The OPT test application contains scripts to test each mode.
+ * Each script attaches the OPT with a distinct VID/PID. Depending on
+ * the VID/PID this driver go into a particular test mode.
+ * 2 - Through /proc/drivers/musb_HSET interface.
+ * This is a forceful method, and rather more useful.
+ * Any USB device can be attached to the Host.
+ */
+
+#include <linux/kernel.h>
+#include <linux/errno.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/module.h>
+#include <linux/kref.h>
+#include <linux/usb.h>
+#include <linux/timer.h>
+#include <linux/proc_fs.h>
+#include <linux/seq_file.h>
+#include <asm/uaccess.h>
+#include <linux/workqueue.h>
+#include "../core/usb.h"
+#include "musbdefs.h"
+
+
+
+/* ULPI pass-through */
+#define MGC_O_HDRC_ULPI_VBUSCTL 0x70
+#define MGC_O_HDRC_ULPI_REGDATA 0x74
+#define MGC_O_HDRC_ULPI_REGADDR 0x75
+#define MGC_O_HDRC_ULPI_REGCTL 0x76
+
+/* extended config & PHY control */
+#define MGC_O_HDRC_ENDCOUNT 0x78
+#define MGC_O_HDRC_DMARAMCFG 0x79
+#define MGC_O_HDRC_PHYWAIT 0x7A
+#define MGC_O_HDRC_PHYVPLEN 0x7B /* units of 546.1 us */
+#define MGC_O_HDRC_HSEOF1 0x7C /* units of 133.3 ns */
+#define MGC_O_HDRC_FSEOF1 0x7D /* units of 533.3 ns */
+#define MGC_O_HDRC_LSEOF1 0x7E /* units of 1.067 us */
+
+/* Added in HDRC 1.9(?) & MHDRC 1.4 */
+/* ULPI */
+#define MGC_M_ULPI_VBUSCTL_USEEXTVBUSIND 0x02
+#define MGC_M_ULPI_VBUSCTL_USEEXTVBUS 0x01
+#define MGC_M_ULPI_REGCTL_INT_ENABLE 0x08
+#define MGC_M_ULPI_REGCTL_READNOTWRITE 0x04
+#define MGC_M_ULPI_REGCTL_COMPLETE 0x02
+#define MGC_M_ULPI_REGCTL_REG 0x01
+/* extended config & PHY control */
+#define MGC_M_ENDCOUNT_TXENDS 0x0f
+#define MGC_S_ENDCOUNT_TXENDS 0
+#define MGC_M_ENDCOUNT_RXENDS 0xf0
+#define MGC_S_ENDCOUNT_RXENDS 4
+#define MGC_M_DMARAMCFG_RAMBITS 0x0f /* RAMBITS-1 */
+#define MGC_S_DMARAMCFG_RAMBITS 0
+#define MGC_M_DMARAMCFG_DMACHS 0xf0
+#define MGC_S_DMARAMCFG_DMACHS 4
+#define MGC_M_PHYWAIT_WAITID 0x0f /* units of 4.369 ms */
+#define MGC_S_PHYWAIT_WAITID 0
+#define MGC_M_PHYWAIT_WAITCON 0xf0 /* units of 533.3 ns */
+#define MGC_S_PHYWAIT_WAITCON 4
+
+/*---------------------------------------------------------------------------*/
+/* This is the list of VID/PID that the HS OPT card will use. */
+static struct usb_device_id hset_table [] = {
+ { USB_DEVICE(6666, 0x0101) }, /* TEST_SE0_NAK */
+ { USB_DEVICE(6666, 0x0102) }, /* TEST_J */
+ { USB_DEVICE(6666, 0x0103) }, /* TEST_K */
+ { USB_DEVICE(6666, 0x0104) }, /* TEST_PACKET */
+ { USB_DEVICE(6666, 0x0105) }, /* TEST_FORCE_ENABLE */
+ { USB_DEVICE(6666, 0x0106) }, /* HS_HOST_PORT_SUSPEND_RESUME */
+ { USB_DEVICE(6666, 0x0107) }, /* SINGLE_STEP_GET_DEV_DESC */
+ { USB_DEVICE(6666, 0x0108) }, /* SINGLE_STEP_SET_FEATURE */
+ { } /* Terminating entry */
+};
+MODULE_DEVICE_TABLE (usb, hset_table);
+
+/* Structure to hold all of our device specific stuff */
+struct usb_hset {
+ struct usb_device * udev; /* the usb device for this device */
+ struct usb_interface * interface; /* the interface for this device */
+ struct kref kref;
+ struct musb * musb; /* the controller */
+ struct proc_dir_entry* pde;
+};
+#define to_hset_dev(d) container_of(d, struct usb_hset, kref)
+
+static struct usb_hset *the_hset;
+static struct usb_driver hset_driver;
+static struct proc_dir_entry *
+ hset_proc_create(char *name, struct usb_hset *hset);
+static void hset_proc_delete(char *name, struct usb_hset *hset);
+
+/*---------------------------------------------------------------------------*/
+/* Test routines */
+
+static int musb_write_ulpi_reg(struct musb *musb, u8 address, u8 value);
+static void test_musb(struct musb *musb, u8 mode)
+{
+ void __iomem *pBase = musb->pRegs;
+
+ if (mode == MGC_M_TEST_J || mode == MGC_M_TEST_K)
+ /* write 0x50 to Function Control Register (@ 0x04) of the PHY
+ * 0x50 => OpMode = 10b => Disable bit-stuff and NRZI encoding
+ * SuspendM = 1b => Powered
+ */
+ musb_write_ulpi_reg(musb, 0x04, 0x50);
+
+ if (mode == MGC_M_TEST_PACKET) {
+ MGC_SelectEnd(pBase, 0);
+ musb_writew(musb->aLocalEnd[0].regs, MGC_O_HDRC_CSR0, 0);
+ musb_write_fifo(&musb->aLocalEnd[0], sizeof(musb_test_packet),
+ musb_test_packet);
+ /* need to set test mode before enabling FIFO, as otherwise
+ * the packet goes out and the FIFO empties before the test
+ * mode is set
+ */
+ musb_writeb(pBase, MGC_O_HDRC_TESTMODE, mode);
+ musb_writew(musb->aLocalEnd[0].regs, MGC_O_HDRC_CSR0,
+ MGC_M_CSR0_TXPKTRDY);
+ } else
+ musb_writeb(pBase, MGC_O_HDRC_TESTMODE, mode);
+}
+
+static inline void test_se0_nak(struct usb_hset *hset)
+{
+ printk(KERN_INFO "%s\n", __FUNCTION__);
+ test_musb(hset->musb, MGC_M_TEST_SE0_NAK);
+}
+
+static inline void test_j(struct usb_hset *hset)
+{
+ printk(KERN_INFO "%s\n", __FUNCTION__);
+ test_musb(hset->musb, MGC_M_TEST_J);
+}
+
+static inline void test_k(struct usb_hset *hset)
+{
+ printk(KERN_INFO "%s\n", __FUNCTION__);
+ test_musb(hset->musb, MGC_M_TEST_K);
+}
+
+static inline void test_packet(struct usb_hset *hset)
+{
+ printk(KERN_INFO "%s\n", __FUNCTION__);
+ test_musb(hset->musb, MGC_M_TEST_PACKET);
+}
+
+static inline void test_force_enable(struct usb_hset *hset)
+{
+ printk(KERN_INFO "%s\n", __FUNCTION__);
+ test_musb(hset->musb, MGC_M_TEST_FORCE_HOST);
+}
+
+static void suspend(struct usb_hset *hset)
+{
+ struct musb *musb = hset->musb;
+ void __iomem *pBase = musb->pRegs;
+ u8 power;
+
+ printk(KERN_INFO "%s\n", __FUNCTION__);
+ power = musb_readb(pBase, MGC_O_HDRC_POWER);
+ musb_writeb(pBase, MGC_O_HDRC_POWER, power | MGC_M_POWER_SUSPENDM);
+}
+
+static void resume(struct usb_hset *hset)
+{
+ struct musb *musb = hset->musb;
+ void __iomem *pBase = musb->pRegs;
+ u8 power;
+
+ printk(KERN_INFO "%s\n", __FUNCTION__);
+ power = musb_readb(pBase, MGC_O_HDRC_POWER);
+ if (power & MGC_M_POWER_SUSPENDM) {
+ power &= ~(MGC_M_POWER_SUSPENDM | MGC_M_POWER_RESUME);
+ musb_writeb(pBase, MGC_O_HDRC_POWER, power | MGC_M_POWER_RESUME);
+ msleep(20);
+ power = musb_readb(pBase, MGC_O_HDRC_POWER);
+ musb_writeb(pBase, MGC_O_HDRC_POWER, power & ~MGC_M_POWER_RESUME);
+ } else
+ printk(KERN_DEBUG "not suspended??\n");
+}
+
+static void test_suspend_resume(struct usb_hset *hset)
+{
+ printk(KERN_INFO "%s\n", __FUNCTION__);
+ suspend(hset);
+ msleep(15000); /* Wait for 15 sec */
+ resume(hset);
+}
+
+static void test_single_step_get_dev_desc(struct usb_hset *hset)
+{
+ struct musb *musb = hset->musb;
+ struct usb_device *udev;
+ struct usb_bus *bus = hcd_to_bus(musb_to_hcd(musb));
+
+ printk(KERN_INFO "%s\n", __FUNCTION__);
+ if (!musb || !bus || !bus->root_hub) {
+ printk(KERN_ERR "Host controller not ready!\n");
+ return;
+ }
+ udev = bus->root_hub->children[0];
+ if (!udev) {
+ printk(KERN_DEBUG "No device connected.\n");
+ return;
+ }
+ usb_get_device_descriptor(udev, sizeof(struct usb_device_descriptor));
+}
+
+static void test_single_step_set_feature(struct usb_hset *hset)
+{
+ struct musb *musb = hset->musb;
+ struct usb_device *udev;
+ struct usb_bus *bus = hcd_to_bus(musb_to_hcd(musb));
+
+ printk(KERN_INFO "%s\n", __FUNCTION__);
+ if (!musb || !bus || !bus->root_hub) {
+ printk(KERN_ERR "Host controller not ready!\n");
+ return;
+ }
+
+ udev = bus->root_hub->children[0];
+ if (!udev) {
+ printk(KERN_DEBUG "No device connected.\n");
+ return;
+ }
+ usb_control_msg(udev,
+ usb_sndctrlpipe(udev, 0),
+ USB_REQ_SET_FEATURE, 0, 0,
+ 0, NULL, 0, HZ * USB_CTRL_SET_TIMEOUT);
+}
+
+static void enumerate_bus(struct work_struct *ignored)
+{
+ struct usb_hset *hset = the_hset;
+ struct musb *musb = hset->musb;
+ struct usb_device *udev;
+ struct usb_bus *bus = hcd_to_bus(musb_to_hcd(musb));
+
+ printk(KERN_INFO "%s\n", __FUNCTION__);
+ if (!musb || !bus || !bus->root_hub) {
+ printk(KERN_ERR "Host controller not ready!\n");
+ return;
+ }
+ udev = bus->root_hub->children[0];
+ if (udev)
+ usb_reset_device(udev);
+}
+
+DECLARE_WORK(enumerate, enumerate_bus);
+
+/*---------------------------------------------------------------------------*/
+
+/* This function can be called either by musb_init_hset() or usb_hset_probe().
+ * musb_init_hset() is called by the controller driver during its init(),
+ * while usb_hset_probe() is called when an OPT is attached. We take care not
+ * to allocate the usb_hset structure twice.
+ */
+static struct usb_hset* init_hset_dev(void *controller)
+{
+ struct usb_hset *hset = NULL;
+
+ /* if already allocated, just increment use count and return */
+ if (the_hset) {
+ kref_get(&the_hset->kref);
+ return the_hset;
+ }
+
+ hset = kmalloc(sizeof(*hset), GFP_KERNEL);
+ if (hset == NULL) {
+ err("Out of memory");
+ return NULL;
+ }
+ memset(hset, 0x00, sizeof(*hset));
+ hset->musb = (struct musb *)(controller);
+
+ kref_init(&hset->kref);
+ the_hset = hset;
+ return hset;
+}
+
+static void hset_delete(struct kref *kref)
+{
+ struct usb_hset *dev = to_hset_dev(kref);
+
+ kfree (dev);
+}
+/*---------------------------------------------------------------------------*/
+/* Usage of HS OPT */
+
+static inline struct musb *dev_to_musb(struct device *dev)
+{
+#ifdef CONFIG_USB_MUSB_HDRC_HCD
+ /* usbcore insists dev->driver_data is a "struct hcd *" */
+ return hcd_to_musb(dev_get_drvdata(dev));
+#else
+ return dev_get_drvdata(dev);
+#endif
+}
+
+/* Called when the HS OPT is attached as a device */
+static int hset_probe(struct usb_interface *interface,
+ const struct usb_device_id *id)
+{
+ struct usb_hset *hset;
+ struct usb_device *udev;
+ struct usb_hcd *hcd;
+ int retval = -ENOMEM;
+
+ udev = usb_get_dev(interface_to_usbdev(interface));
+ hcd = udev->bus->controller->driver_data;
+ hset = init_hset_dev(hcd->hcd_priv);
+ if (!hset)
+ return retval;
+
+ hset->udev = udev;
+ hset->interface = interface;
+ usb_set_intfdata(interface, 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:
+ test_force_enable(hset);
+ break;
+ case 0x0106:
+ test_suspend_resume(hset);
+ break;
+ case 0x0107:
+ msleep(15000); /* SOFs for 15 sec */
+ test_single_step_get_dev_desc(hset);
+ break;
+ case 0x0108:
+ test_single_step_get_dev_desc(hset);
+ msleep(15000); /* SOFs for 15 sec */
+ test_single_step_set_feature(hset);
+ break;
+ };
+ return 0;
+}
+
+static void hset_disconnect(struct usb_interface *interface)
+{
+ struct usb_hset *hset;
+
+ /* prevent hset_open() from racing hset_disconnect() */
+ lock_kernel();
+ hset = usb_get_intfdata(interface);
+ usb_set_intfdata(interface, NULL);
+ unlock_kernel();
+
+ usb_put_dev(hset->udev);
+ kref_put(&hset->kref, hset_delete);
+}
+
+static struct usb_driver hset_driver = {
+// .owner = THIS_MODULE,
+ .name = "hset",
+ .probe = hset_probe,
+ .disconnect = hset_disconnect,
+ .id_table = hset_table,
+};
+
+static int __init usb_hset_init(void)
+{
+ int result;
+
+ /* register this driver with the USB subsystem */
+ result = usb_register(&hset_driver);
+ if (result)
+ err("usb_register failed. Error number %d", result);
+
+ return result;
+}
+
+static void __exit usb_hset_exit(void)
+{
+ /* deregister this driver with the USB subsystem */
+ usb_deregister(&hset_driver);
+}
+
+module_init (usb_hset_init);
+module_exit (usb_hset_exit);
+
+MODULE_LICENSE("GPL");
+
+/*---------------------------------------------------------------------------*/
+/* Usage of /proc/drivers/musb_hset interface */
+
+void musb_init_hset(char *name, struct musb *musb)
+{
+ struct usb_hset *hset;
+ hset = init_hset_dev((void *)musb);
+ hset_proc_create(name, hset);
+}
+
+void musb_exit_hset(char *name, struct musb *musb)
+{
+ struct usb_hset *hset = the_hset;
+
+ if (!hset) {
+ printk(KERN_DEBUG "No hset device!\n");
+ return;
+ }
+ hset_proc_delete(name, hset);
+ kref_put(&hset->kref, hset_delete);
+}
+
+static int dump_menu(char *buffer)
+{
+ int count = 0;
+
+ *buffer = 0;
+ count = sprintf(buffer, "HOST-side high-speed electrical test modes:\n"
+ "J: Test_J\n"
+ "K: Test_K\n"
+ "S: Test_SE0_NAK\n"
+ "P: Test_PACKET\n"
+ "H: Test_FORCE_ENABLE\n"
+ "U: Test_SUSPEND_RESUME\n"
+ "G: Test_SINGLE_STEP_GET_DESC\n"
+ "F: Test_SINGLE_STEP_SET_FEATURE\n"
+ "E: Enumerate bus\n"
+ "D: Suspend bus\n"
+ "R: Resume bus\n"
+ "?: help menu\n");
+ if (count < 0)
+ return count;
+ buffer += count;
+ return count;
+}
+
+static int hset_proc_write(struct file *file, const char __user *buffer,
+ unsigned long count, void *data)
+{
+ char cmd;
+ struct usb_hset *hset = (struct usb_hset *)data;
+ char help[500];
+ /* MOD_INC_USE_COUNT; */
+ //if (hset->musb->asleep)
+ // return EBUSY;
+
+ if(copy_from_user(&cmd, buffer, 1))
+ return -EFAULT;
+ switch (cmd) {
+ case 'S':
+ test_se0_nak(hset);
+ break;
+ case 'J':
+ test_j(hset);
+ break;
+ case 'K':
+ test_k(hset);
+ break;
+ case 'P':
+ test_packet(hset);
+ break;
+ case 'H':
+ test_force_enable(hset);
+ break;
+ case 'U':
+ test_suspend_resume(hset);
+ break;
+ case 'G':
+ test_single_step_get_dev_desc(hset);
+ break;
+ case 'F':
+ test_single_step_set_feature(hset);
+ break;
+ case 'E':
+ schedule_work(&enumerate);
+ break;
+ case 'D':
+ suspend(hset);
+ break;
+ case 'R':
+ resume(hset);
+ break;
+ case '?':
+ dump_menu(help);
+ printk(KERN_INFO "%s", help);
+ break;
+ default:
+ printk(KERN_ERR "Command %c not implemented\n", cmd);
+ break;
+ }
+
+ return count;
+}
+
+static int hset_proc_read(char *page, char **start,
+ off_t off, int count, int *eof, void *data)
+{
+ char *buffer = page;
+ int code = 0;
+
+ count -= off;
+ count -= 1; /* for NUL at end */
+ if (count < 0)
+ return -EINVAL;
+
+ code = dump_menu(buffer);
+ if (code > 0) {
+ buffer += code;
+ count -= code;
+ }
+
+ *eof = 1;
+ return (buffer - page) - off;
+}
+
+void hset_proc_delete(char *name, struct usb_hset *hset)
+{
+ if (hset->pde)
+ remove_proc_entry(name, NULL);
+}
+
+struct proc_dir_entry *hset_proc_create(char *name, struct usb_hset *hset)
+{
+ struct proc_dir_entry *pde;
+
+ /* FIXME convert everything to seq_file; then later, debugfs */
+
+ if (!name || !hset)
+ return NULL;
+
+ hset->pde = pde = create_proc_entry(name,
+ S_IFREG | S_IRUGO | S_IWUSR, NULL);
+ if (pde) {
+ pde->data = (void *)hset;
+ // pde->owner = THIS_MODULE;
+
+ pde->read_proc = hset_proc_read;
+ pde->write_proc = hset_proc_write;
+
+ pde->size = 0;
+
+ pr_debug("Registered /proc/%s\n", name);
+ } else {
+ pr_debug("Cannot create a valid proc file entry");
+ }
+
+ return pde;
+}
+
+static int musb_write_ulpi_reg(struct musb* musb, u8 address, u8 value)
+{
+ u8 ctl = 0;
+ u8* pBase = musb->pRegs;
+
+ /* ensure not powered down */
+ if(musb_readb(pBase, MGC_O_HDRC_POWER) & MGC_M_POWER_ENSUSPEND) {
+ return -ENODEV;
+ }
+
+ /* polled */
+ musb_writeb(pBase, MGC_O_HDRC_ULPI_REGADDR, address);
+ musb_writeb(pBase, MGC_O_HDRC_ULPI_REGDATA, value);
+ musb_writeb(pBase, MGC_O_HDRC_ULPI_REGCTL, MGC_M_ULPI_REGCTL_REG);
+
+ while(!(MGC_M_ULPI_REGCTL_COMPLETE & ctl)) {
+ ctl = musb_readb(pBase, MGC_O_HDRC_ULPI_REGCTL);
+ }
+
+ musb_writeb(pBase, MGC_O_HDRC_ULPI_REGCTL, 0);
+
+ return 0;
+}
Index: linux-omap-2.6/drivers/usb/musb/musbdefs.h
===================================================================
--- linux-omap-2.6.orig/drivers/usb/musb/musbdefs.h 2007-05-25 14:16:59.000000000 +0300
+++ linux-omap-2.6/drivers/usb/musb/musbdefs.h 2007-05-25 14:17:05.000000000 +0300
@@ -489,6 +489,16 @@
}
#endif

+/* for high speed test mode; see USB 2.0 spec */
+static const u8 musb_test_packet[53] = {
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
+ 0xaa, 0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0xee,
+ 0xee, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f, 0xbf, 0xdf,
+ 0xef, 0xf7, 0xfb, 0xfd, 0xfc, 0x7e, 0xbf, 0xdf,
+ 0xef, 0xf7, 0xfb, 0xfd, 0x7e
+};

/***************************** Glue it together *****************************/

@@ -532,7 +542,8 @@
extern struct proc_dir_entry *musb_debug_create(char *name,
struct musb *data);
extern void musb_debug_delete(char *name, struct musb *data);
-
+extern void musb_init_hset(char *name, struct musb *musb);
+extern void musb_exit_hset(char *name, struct musb *musb);
#else
static inline struct proc_dir_entry *musb_debug_create(char *name,
struct musb *data)
@@ -542,6 +553,12 @@
static inline void musb_debug_delete(char *name, struct musb *data)
{
}
+static inline void musb_init_hset(char *name, struct musb *musb)
+{
+}
+static inline void musb_exit_hset(char *name, struct musb *musb)
+{
+}
#endif

#endif /* __MUSB_MUSBDEFS_H__ */
Index: linux-omap-2.6/drivers/usb/musb/plat_uds.c
===================================================================
--- linux-omap-2.6.orig/drivers/usb/musb/plat_uds.c 2007-05-25 14:16:59.000000000 +0300
+++ linux-omap-2.6/drivers/usb/musb/plat_uds.c 2007-05-25 14:17:05.000000000 +0300
@@ -248,27 +248,6 @@

/*-------------------------------------------------------------------------*/
-
-/* for high speed test mode; see USB 2.0 spec 7.1.20 */
-static const u8 musb_test_packet[53] = {
- /* implicit SYNC then DATA0 to start */
-
- /* JKJKJKJK x9 */
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- /* JJKKJJKK x8 */
- 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
- /* JJJJKKKK x8 */
- 0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0xee,
- /* JJJJJJJKKKKKKK x8 */
- 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- /* JJJJJJJK x8 */
- 0x7f, 0xbf, 0xdf, 0xef, 0xf7, 0xfb, 0xfd,
- /* JKKKKKKK x10, JK */
- 0xfc, 0x7e, 0xbf, 0xdf, 0xef, 0xf7, 0xfb, 0xfd, 0x7e
-
- /* implicit CRC16 then EOP to end */
-};
-
void musb_load_testpacket(struct musb *musb)
{
void __iomem *regs = musb->aLocalEnd[0].regs;
@@ -2084,8 +2063,13 @@

}

- if (status == 0)
+ if (status == 0) {
musb_debug_create("driver/musb_hdrc", pThis);
+#ifdef CONFIG_USB_MUSB_HDRC_HCD
+ musb_init_hset("driver/musb_HSET", pThis);
+#endif
+
+ }
else {
fail:
if (pThis->clock)
@@ -2162,6 +2146,7 @@
musb_shutdown(pdev);
musb_debug_delete("driver/musb_hdrc", musb);
#ifdef CONFIG_USB_MUSB_HDRC_HCD
+ musb_exit_hset("driver/musb_HSET", musb);
if (musb->board_mode == MUSB_HOST)
usb_remove_hcd(musb_to_hcd(musb));
#endif