[PATCH] HSET tool for the MUSB Controler

[Felipe Balbi <felipebalbi@users.sourceforge.net>]

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