Skip to contentSkip to conversation

usb host: Faraday FUSBH200 HCD driver.

PATCH Superseded Yuan-Hsin Chen 4 participants 25 messages Feb 6, 2013 – May 17, 2013

Subsystems (2)
lore
Share & tools
lore
#0 lore raw

PATCH 1/1 usb host: Faraday FUSBH200 HCD driver.

From: Yuan-Hsin Chen <[email protected]>

USB2.0 HCD driver for Faraday FUSBH200

---
 drivers/usb/Makefile            |    2 +-
 drivers/usb/host/Kconfig        |    7 +
 drivers/usb/host/Makefile       |    2 +
 drivers/usb/host/fusbh200-hcd.c | 6830 +++++++++++++++++++++++++++++++++++++++
 drivers/usb/host/fusbh200.h     |  907 ++++++
 5 files changed, 7747 insertions(+), 1 deletions(-)
 create mode 100644 drivers/usb/host/fusbh200-hcd.c
 create mode 100644 drivers/usb/host/fusbh200.h
drivers/usb/Makefile +1 -1
index f5ed3d7..a9f450a 100644
@@ -3,7 +3,6 @@
 #
 
 # Object files in subdirectories
-
 obj-$(CONFIG_USB)		+= core/
 
 obj-$(CONFIG_USB_OTG_UTILS)	+= otg/
@@ -27,6 +26,7 @@ obj-$(CONFIG_USB_HWA_HCD)	+= host/
 obj-$(CONFIG_USB_ISP1760_HCD)	+= host/
 obj-$(CONFIG_USB_IMX21_HCD)	+= host/
 obj-$(CONFIG_USB_FSL_MPH_DR_OF)	+= host/
+obj-$(CONFIG_USB_FUSBH200_HCD)	+= host/
 
 obj-$(CONFIG_USB_C67X00_HCD)	+= c67x00/
 
drivers/usb/host/Kconfig +7 -0
index 3f1431d..7e72131 100644
@@ -675,3 +675,10 @@ config USB_HCD_SSB
 	  for ehci and ohci.
 
 	  If unsure, say N.
+
+config USB_FUSBH200_HCD
+	tristate "Faraday FUSBH200 HCD support"
+	depends on USB
+	---help---
+	  The USB HCD Driver of Faraday FUSBH200 is designed to
+	  meet USB2.0 EHCI specification with minor modification
drivers/usb/host/Makefile +2 -0
index 9e0a89c..404207e 100644
@@ -24,6 +24,7 @@ obj-$(CONFIG_USB_WHCI_HCD)	+= whci/
 obj-$(CONFIG_PCI)		+= pci-quirks.o
 
 obj-$(CONFIG_USB_EHCI_HCD)	+= ehci-hcd.o
+
 obj-$(CONFIG_USB_OXU210HP_HCD)	+= oxu210hp-hcd.o
 obj-$(CONFIG_USB_ISP116X_HCD)	+= isp116x-hcd.o
 obj-$(CONFIG_USB_ISP1362_HCD)	+= isp1362-hcd.o
@@ -43,3 +44,4 @@ obj-$(CONFIG_USB_OCTEON2_COMMON) += octeon2-common.o
 obj-$(CONFIG_MIPS_ALCHEMY)	+= alchemy-common.o
 obj-$(CONFIG_USB_HCD_BCMA)	+= bcma-hcd.o
 obj-$(CONFIG_USB_HCD_SSB)	+= ssb-hcd.o
+obj-$(CONFIG_USB_FUSBH200_HCD)	+= fusbh200-hcd.o
drivers/usb/host/fusbh200-hcd.c new file +6830 -0

2,965 lines not on this page · raw message

drivers/usb/host/fusbh200.h new file +907 -0

907 lines not on this page · raw message

The rest of this diff is not shown. View the raw message.

Signature · 1 line
1.7.4.1

Part of the diff is not shown here. View the raw message.

maintainer
#1 lore raw
Quoted 3 lines · Yuan-Hsin Chen

From: Yuan-Hsin Chen <[email protected]>

USB2.0 HCD driver for Faraday FUSBH200

In what way is this driver different from the existing ehci-hcd driver? It looks like almost all of the code is identical. We don't need to have two copies of the same code in the kernel.

Alan Stern

#4 lore raw

Hi,

I tried to modify fusbh200 hcd driver following ehci-platform.c. However, the register definition of fusbh200 is partially incompatible to ehci. For fusbh200, only the elements between "command" and "async_next" in struct ehci_regs are consistent with ehci which means it would cause copious modification and duplication of ehci hcd driver. For example, there is no "configured_flag" register in fusbh200 controller, yet, ehci hcd driver accesses "configured_flag" in function ehci_run which would cause compile errors. Therefore, maybe my first patch which refers to oxu210hp-hcd is a better solution?

Thanks for your time.

Yuan-Hsin

Quoted 16 lines · Yuan-Hsin Chen
Quoted 11 lines · Felipe Balbi
Quoted 5 lines · Yuan-Hsin Chen

From: Yuan-Hsin Chen <[email protected]>

USB2.0 HCD driver for Faraday FUSBH200

just use ehci-platform.c and avoid the duplication

--
balbi

Thanks for your advice. I will modify and re-submit it later.

Yuan-Hsin

#5 lore raw

Hi,

(don't top-post)

Quoted 12 lines · Yuan-Hsin Chen

Hi,

I tried to modify fusbh200 hcd driver following ehci-platform.c. However, the register definition of fusbh200 is partially incompatible to ehci. For fusbh200, only the elements between "command" and "async_next" in struct ehci_regs are consistent with ehci which means it would cause copious modification and duplication of ehci hcd driver. For example, there is no "configured_flag" register in fusbh200 controller, yet, ehci hcd driver accesses "configured_flag" in function ehci_run which would cause compile errors. Therefore, maybe my first patch which refers to oxu210hp-hcd is a better solution?

why don't you just add a quirk flag to ehci struct so that it knows it shouldn't access CONFIGFLAG register when that's non-existent ?

There are only 5 uses of configured_flag in ehci-hcd.c, so it should be easy to wrap that around a flag check.

Alan, would you have a better idea ? Looks like this is a non-standard EHCI implementation.

Signature · 1 line
balbi
maintainer
#6 lore raw
Quoted 7 lines · Felipe Balbi
Quoted 6 lines · Yuan-Hsin Chen

Hi,

I tried to modify fusbh200 hcd driver following ehci-platform.c. However, the register definition of fusbh200 is partially incompatible to ehci. For fusbh200, only the elements between "command" and "async_next" in struct ehci_regs are consistent with ehci which means

What about the port_status registers? They're not between command and async_next. If they aren't consistent with EHCI, it makes things a lot more complicated.

Quoted 7 lines
Quoted 6 lines

it would cause copious modification and duplication of ehci hcd driver. For example, there is no "configured_flag" register in fusbh200 controller, yet, ehci hcd driver accesses "configured_flag" in function ehci_run which would cause compile errors. Therefore, maybe my first patch which refers to oxu210hp-hcd is a better solution?

Quoted 5 lines

why don't you just add a quirk flag to ehci struct so that it knows it shouldn't access CONFIGFLAG register when that's non-existent ?

There are only 5 uses of configured_flag in ehci-hcd.c, so it should be easy to wrap that around a flag check.

Two of those uses turn configured_flag on and two of them turn it off. However, one of the uses tests its value (the first one in ehci_resume). How would that be handled if configured_flag doesn't exist?

Quoted 2 lines

Alan, would you have a better idea ? Looks like this is a non-standard EHCI implementation.

Yes, it does. If all we need is to protect four or five accesses with a quirk flag, that's okay with me.

Alan Stern

#7 lore raw

Hi,

Quoted 10 lines · Alan Stern
Quoted 10 lines
Quoted 6 lines

it would cause copious modification and duplication of ehci hcd driver. For example, there is no "configured_flag" register in fusbh200 controller, yet, ehci hcd driver accesses "configured_flag" in function ehci_run which would cause compile errors. Therefore, maybe my first patch which refers to oxu210hp-hcd is a better solution?

why don't you just add a quirk flag to ehci struct so that it knows it shouldn't access CONFIGFLAG register when that's non-existent ?

Quoted 7 lines
Quoted 2 lines

There are only 5 uses of configured_flag in ehci-hcd.c, so it should be easy to wrap that around a flag check.

Two of those uses turn configured_flag on and two of them turn it off. However, one of the uses tests its value (the first one in ehci_resume). How would that be handled if configured_flag doesn't exist?

perhaps they don't use it because they have a root-hub TT ? In that case you assume EHCI *always* owns the port. Would that work ?

Signature · 1 line
balbi
maintainer
#8 lore raw
Quoted 16 lines · Felipe Balbi

Hi,

Quoted 13 lines · Alan Stern
Quoted 12 lines
Quoted 6 lines

it would cause copious modification and duplication of ehci hcd driver. For example, there is no "configured_flag" register in fusbh200 controller, yet, ehci hcd driver accesses "configured_flag" in function ehci_run which would cause compile errors. Therefore, maybe my first patch which refers to oxu210hp-hcd is a better solution?

why don't you just add a quirk flag to ehci struct so that it knows it shouldn't access CONFIGFLAG register when that's non-existent ?

There are only 5 uses of configured_flag in ehci-hcd.c, so it should be easy to wrap that around a flag check.

Quoted 7 lines
Quoted 4 lines

Two of those uses turn configured_flag on and two of them turn it off. However, one of the uses tests its value (the first one in ehci_resume). How would that be handled if configured_flag doesn't exist?

perhaps they don't use it because they have a root-hub TT ? In that case you assume EHCI *always* owns the port. Would that work ?

The usage in ehci_resume is meant for checking whether power was lost while the controller was suspended. This probably isn't an issue during runtime suspend; it's likely to come up only during system suspend. If Yuan-Hsin's platform doesn't support system suspend then we don't have to worry about it.

Alan Stern

#9 lore raw
In reply to Alan Stern

Hi,

Quoted 5 lines · Alan Stern
Quoted 3 lines · Felipe Balbi
Quoted 2 lines · Yuan-Hsin Chen

Hi,

Quoted 8 lines
Quoted 4 lines
Quoted 4 lines

I tried to modify fusbh200 hcd driver following ehci-platform.c. However, the register definition of fusbh200 is partially incompatible to ehci. For fusbh200, only the elements between "command" and "async_next" in struct ehci_regs are consistent with ehci which means

What about the port_status registers? They're not between command and async_next. If they aren't consistent with EHCI, it makes things a lot more complicated.

fusbh200 has only one port_status register with different offset, 0x30, and the position of some bits are different from EHCI.

Quoted 10 lines
Quoted 10 lines
Quoted 7 lines

it would cause copious modification and duplication of ehci hcd driver. For example, there is no "configured_flag" register in fusbh200 controller, yet, ehci hcd driver accesses "configured_flag" in function ehci_run which would cause compile errors. Therefore, maybe my first patch which refers to oxu210hp-hcd is a better solution?

why don't you just add a quirk flag to ehci struct so that it knows it shouldn't access CONFIGFLAG register when that's non-existent ?

Also, usbmode_ex, hostpc, and txfill_tuning other than configured_flag are non-existent in fusbh200. They are used in both ehci-hcd.c and ehci-hub.c for several times.

Quoted 9 lines
Quoted 3 lines

There are only 5 uses of configured_flag in ehci-hcd.c, so it should be easy to wrap that around a flag check.

Two of those uses turn configured_flag on and two of them turn it off. However, one of the uses tests its value (the first one in ehci_resume). How would that be handled if configured_flag doesn't exist?

Quoted 5 lines
Quoted 2 lines

Alan, would you have a better idea ? Looks like this is a non-standard EHCI implementation.

Yes, it does. If all we need is to protect four or five accesses with a quirk flag, that's okay with me.

Thanks for your time.

Quoted 3 lines

Alan Stern

maintainer
#10 lore raw
Quoted 6 lines · Yuan-Hsin Chen
Quoted 3 lines

What about the port_status registers? They're not between command and async_next. If they aren't consistent with EHCI, it makes things a lot more complicated.

fusbh200 has only one port_status register with different offset, 0x30, and the position of some bits are different from EHCI.

That's pretty nasty. Integrating that with the standard EHCI driver would be considerably more difficult.

Why was the FUSBH200 designed in this strange way? Why doesn't it use the standard EHCI register layout? Were the engineers at Faraday deliberately trying to make life harder for driver writers?

Quoted 3 lines

Also, usbmode_ex, hostpc, and txfill_tuning other than configured_flag are non-existent in fusbh200. They are used in both ehci-hcd.c and ehci-hub.c for several times.

They are used only if the hardware supports them, that is, only if the ehci->has_hostpc flag is set.

Alan Stern

#11 lore raw
Quoted 9 lines · Alan Stern
Quoted 6 lines · Yuan-Hsin Chen
Quoted 3 lines

What about the port_status registers? They're not between command and async_next. If they aren't consistent with EHCI, it makes things a lot more complicated.

fusbh200 has only one port_status register with different offset, 0x30, and the position of some bits are different from EHCI.

Quoted 6 lines

That's pretty nasty. Integrating that with the standard EHCI driver would be considerably more difficult.

Why was the FUSBH200 designed in this strange way? Why doesn't it use the standard EHCI register layout? Were the engineers at Faraday deliberately trying to make life harder for driver writers?

Since FUSBH200 was designed more than eight years ago, the engineers responsible for FUSBH200 are no longer working for Faraday. I have the same question as you, but no one here could answer it. The strange register layout and other implementation incompatible with EHCI are the reasons why the FUSBH200 driver was not tried to submit to mainline in the past.

Quoted 10 lines
Quoted 4 lines

Also, usbmode_ex, hostpc, and txfill_tuning other than configured_flag are non-existent in fusbh200. They are used in both ehci-hcd.c and ehci-hub.c for several times.

They are used only if the hardware supports them, that is, only if the ehci->has_hostpc flag is set.

Alan Stern

#12 lore raw
In reply to Alan Stern

Hi,

Quoted 8 lines · Alan Stern
Quoted 6 lines · Yuan-Hsin Chen
Quoted 3 lines

What about the port_status registers? They're not between command and async_next. If they aren't consistent with EHCI, it makes things a lot more complicated.

fusbh200 has only one port_status register with different offset, 0x30, and the position of some bits are different from EHCI.

How about adding kernel configuration to adjust offset for FUSBH200 in ehci_def.h? So port_status would be in offset 0x20 from ehci_regs.

For example,

/* ASYNCLISTADDR: offset 0x18 */
u32 async_next; /* address of next async queue head */

#ifndef CONFIG_USB_EHCI_HCD_FUSBH200
        u32             reserved1[2];

        /* TXFILLTUNING: offset 0x24 */
        u32             txfill_tuning;  /* TX FIFO Tuning register */

#define TXFIFO_DEFAULT (8<<16) /* FIFO burst threshold 8 */

        u32             reserved2[6];

        /* CONFIGFLAG: offset 0x40 */
        u32             configured_flag;

#define FLAG_CF (1<<0) /* true: we'll support "high speed" */

#else
        u32             reserved1;

#endif
/* PORTSC: offset 0x44 */
u32 port_status[0]; /* up to N_PORTS */

Furthermore, there are PORT_POWER, PORT_OWNER, PORT_LED_XXX, PORT_TEST, PORT_WKCONN_E, PORT_WKDISC_E, PORT_WKOC_E absent in port_status of FUSBH200. Also PORT_OC and PORT_OCC are in another register. Is it ok to use quirk flag also?

Quoted 8 lines

That's pretty nasty. Integrating that with the standard EHCI driver would be considerably more difficult.

Why was the FUSBH200 designed in this strange way? Why doesn't it use the standard EHCI register layout? Were the engineers at Faraday deliberately trying to make life harder for driver writers?

Quoted 9 lines
Quoted 3 lines

Also, usbmode_ex, hostpc, and txfill_tuning other than configured_flag are non-existent in fusbh200. They are used in both ehci-hcd.c and ehci-hub.c for several times.

They are used only if the hardware supports them, that is, only if the ehci->has_hostpc flag is set.

Alan Stern

Thank you for your help.

Yuan-Hsin

maintainer
#13 lore raw
Quoted 31 lines · Yuan-Hsin Chen

Hi,

Quoted 8 lines · Alan Stern
Quoted 6 lines · Yuan-Hsin Chen
Quoted 3 lines

What about the port_status registers? They're not between command and async_next. If they aren't consistent with EHCI, it makes things a lot more complicated.

fusbh200 has only one port_status register with different offset, 0x30, and the position of some bits are different from EHCI.

How about adding kernel configuration to adjust offset for FUSBH200 in ehci_def.h? So port_status would be in offset 0x20 from ehci_regs.

For example,

/* ASYNCLISTADDR: offset 0x18 */
u32 async_next; /* address of next async queue head */

#ifndef CONFIG_USB_EHCI_HCD_FUSBH200
        u32             reserved1[2];

        /* TXFILLTUNING: offset 0x24 */
        u32             txfill_tuning;  /* TX FIFO Tuning register */

#define TXFIFO_DEFAULT (8<<16) /* FIFO burst threshold 8 */

        u32             reserved2[6];

        /* CONFIGFLAG: offset 0x40 */
        u32             configured_flag;
Quoted 7 lines

#define FLAG_CF (1<<0) /* true: we'll support "high speed" */

#else
        u32             reserved1;

#endif
/* PORTSC: offset 0x44 */
u32 port_status[0]; /* up to N_PORTS */

This is acceptable _only_ if it is not possible to use an FUSBH200 controller in the same computer as a normal EHCI controller.

Quoted 4 lines

Furthermore, there are PORT_POWER, PORT_OWNER, PORT_LED_XXX, PORT_TEST, PORT_WKCONN_E, PORT_WKDISC_E, PORT_WKOC_E absent in port_status of FUSBH200. Also PORT_OC and PORT_OCC are in another register. Is it ok to use quirk flag also?

Yes, those can be handled by a quirk flag. Does the FUSBH200 have a built-in Transaction Translator?

Alan Stern

#14 lore raw

Hi,

Quoted 44 lines · Alan Stern
Quoted 31 lines · Yuan-Hsin Chen

Hi,

Quoted 8 lines · Alan Stern
Quoted 6 lines · Yuan-Hsin Chen
Quoted 3 lines

What about the port_status registers? They're not between command and async_next. If they aren't consistent with EHCI, it makes things a lot more complicated.

fusbh200 has only one port_status register with different offset, 0x30, and the position of some bits are different from EHCI.

How about adding kernel configuration to adjust offset for FUSBH200 in ehci_def.h? So port_status would be in offset 0x20 from ehci_regs.

For example,

/* ASYNCLISTADDR: offset 0x18 */
u32 async_next; /* address of next async queue head */

#ifndef CONFIG_USB_EHCI_HCD_FUSBH200
        u32             reserved1[2];

        /* TXFILLTUNING: offset 0x24 */
        u32             txfill_tuning;  /* TX FIFO Tuning register */

#define TXFIFO_DEFAULT (8<<16) /* FIFO burst threshold 8 */

        u32             reserved2[6];

        /* CONFIGFLAG: offset 0x40 */
        u32             configured_flag;
Quoted 7 lines

#define FLAG_CF (1<<0) /* true: we'll support "high speed" */

#else
        u32             reserved1;

#endif
/* PORTSC: offset 0x44 */
u32 port_status[0]; /* up to N_PORTS */

This is acceptable _only_ if it is not possible to use an FUSBH200 controller in the same computer as a normal EHCI controller.

Quoted 7 lines
Quoted 4 lines

Furthermore, there are PORT_POWER, PORT_OWNER, PORT_LED_XXX, PORT_TEST, PORT_WKCONN_E, PORT_WKDISC_E, PORT_WKOC_E absent in port_status of FUSBH200. Also PORT_OC and PORT_OCC are in another register. Is it ok to use quirk flag also?

Yes, those can be handled by a quirk flag. Does the FUSBH200 have a built-in Transaction Translator?

Yes, the FUSBH200 has built-in Transaction Translator.

I will modify the driver based on what we discussed before and re-submit it. Thank you for your time.

Quoted 3 lines

Alan Stern

#15 lore raw

PATCH v2 1/1 usb host: Faraday FUSBH200 HCD driver

In reply to Yuan-Hsin Chen

FUSBH200 is an ehci-like controller with some differences. First, register layout of FUSBH200 is incompatible with EHCI. We use a quirk flag and modify struct ehci_regs with anonymous union and struct to make sure driver of FUSBH200 and EHCI could coexist. Furthermore, FUSBH200 is lack of siTDs which means iTDs are used for both HS and FS ISO transfer.

---

Note that anonymous union and struct might not be supported in earlier version of gcc

v2:
use ehci-platform.c
use anonymous union and struct
add is_fusbh200 to struct ehci_hcd

 drivers/usb/host/Kconfig         |    9 ++
 drivers/usb/host/ehci-fusbh200.c |  223 ++++++++++++++++++++++++++++++++++++++
 drivers/usb/host/ehci-hcd.c      |   18 +++-
 drivers/usb/host/ehci-hub.c      |   30 +++---
 drivers/usb/host/ehci-mem.c      |    3 +-
 drivers/usb/host/ehci-sched.c    |   33 ++++--
 drivers/usb/host/ehci.h          |   27 +++++-
 include/linux/usb/ehci_def.h     |   58 +++++++---
 8 files changed, 351 insertions(+), 50 deletions(-)
 create mode 100644 drivers/usb/host/ehci-fusbh200.c
drivers/usb/host/Kconfig +9 -0
index 3f1431d..42b8768 100644
@@ -157,6 +157,15 @@ config USB_EHCI_HCD_OMAP
 	  Enables support for the on-chip EHCI controller on
 	  OMAP3 and later chips.
 
+config USB_EHCI_HCD_FUSBH200
+	bool "Faraday FUSBH200 HCD support"
+	depends on USB_EHCI_HCD && ARCH_FARADAY
+	select USB_EHCI_ROOT_HUB_TT
+	default y
+	---help---
+	  The USB HCD Driver of Faraday FUSBH200 is designed to
+	  meet USB2.0 EHCI specification with minor modification
+
 config USB_EHCI_MSM
 	bool "Support for MSM on-chip EHCI USB controller"
 	depends on USB_EHCI_HCD && ARCH_MSM
drivers/usb/host/ehci-fusbh200.c new file +223 -0

223 lines not on this page · raw message

drivers/usb/host/ehci-hcd.c +14 -4
index 6bf6c42..ce87c01 100644
@@ -247,7 +247,7 @@ static int ehci_reset (struct ehci_hcd *ehci)
 	if (retval)
 		return retval;
 
-	if (ehci_is_TDI(ehci))
+	if (ehci_is_TDI(ehci) && !ehci_is_fusbh200(ehci))
 		tdi_reset (ehci);
 
 	if (ehci->debug)
@@ -326,11 +326,15 @@ static void ehci_silence_controller(struct ehci_hcd *ehci)
 	ehci->rh_state = EHCI_RH_HALTED;
 	ehci_turn_off_all_ports(ehci);
 
+	if (ehci_is_fusbh200(ehci))
+		goto out;
+
 	/* make BIOS/etc use companion controller during reboot */
 	ehci_writel(ehci, 0, &ehci->regs->configured_flag);
 
 	/* unblock posted writes */
 	ehci_readl(ehci, &ehci->regs->configured_flag);
+out:
 	spin_unlock_irq(&ehci->lock);
 }
 
@@ -634,7 +638,8 @@ static int ehci_run (struct usb_hcd *hcd)
 	 */
 	down_write(&ehci_cf_port_reset_rwsem);
 	ehci->rh_state = EHCI_RH_RUNNING;
-	ehci_writel(ehci, FLAG_CF, &ehci->regs->configured_flag);
+	if (!ehci_is_fusbh200(ehci))
+		ehci_writel(ehci, FLAG_CF, &ehci->regs->configured_flag);
 	ehci_readl(ehci, &ehci->regs->command);	/* unblock posted writes */
 	msleep(5);
 	up_write(&ehci_cf_port_reset_rwsem);
@@ -684,7 +689,7 @@ static int ehci_setup(struct usb_hcd *hcd)
 	if (retval)
 		return retval;
 
-	if (ehci_is_TDI(ehci))
+	if (ehci_is_TDI(ehci) && !ehci_is_fusbh200(ehci))
 		tdi_reset(ehci);
 
 	ehci_reset(ehci);
@@ -887,7 +892,7 @@ static int ehci_urb_enqueue (
 		return intr_submit(ehci, urb, &qtd_list, mem_flags);
 
 	case PIPE_ISOCHRONOUS:
-		if (urb->dev->speed == USB_SPEED_HIGH)
+		if (urb->dev->speed == USB_SPEED_HIGH || ehci_is_fusbh200(ehci))
 			return itd_submit (ehci, urb, mem_flags);
 		else
 			return sitd_submit (ehci, urb, mem_flags);
@@ -1339,6 +1344,11 @@ MODULE_LICENSE ("GPL");
 #define PLATFORM_DRIVER		ehci_platform_driver
 #endif
 
+#ifdef CONFIG_USB_EHCI_HCD_FUSBH200
+#include "ehci-fusbh200.c"
+#define PLATFORM_DRIVER		ehci_hcd_fusbh200_driver
+#endif
+
 #if !defined(PCI_DRIVER) && !defined(PLATFORM_DRIVER) && \
     !defined(PS3_SYSTEM_BUS_DRIVER) && !defined(OF_PLATFORM_DRIVER) && \
     !defined(XILINX_OF_PLATFORM_DRIVER)
drivers/usb/host/ehci-hub.c +14 -16
index 914ce93..c374d6a 100644
@@ -63,7 +63,7 @@ static void ehci_handover_companion_ports(struct ehci_hcd *ehci)
 	port = HCS_N_PORTS(ehci->hcs_params);
 	while (port--) {
 		if (test_bit(port, &ehci->owned_ports)) {
-			reg = &ehci->regs->port_status[port];
+			reg = ehci_portsc_addr(ehci, port);
 			status = ehci_readl(ehci, reg) & ~PORT_RWC_BITS;
 
 			/* Port already owned by companion? */
@@ -100,7 +100,7 @@ static void ehci_handover_companion_ports(struct ehci_hcd *ehci)
 			 * but if something went wrong the port must not
 			 * remain enabled.
 			 */
-			reg = &ehci->regs->port_status[port];
+			reg = ehci_portsc_addr(ehci, port)
 			status = ehci_readl(ehci, reg) & ~PORT_RWC_BITS;
 			if (status & PORT_OWNER)
 				ehci_writel(ehci, status | PORT_CSC, reg);
@@ -131,7 +131,7 @@ static int ehci_port_change(struct ehci_hcd *ehci)
 	 */
 
 	while (i--)
-		if (ehci_readl(ehci, &ehci->regs->port_status[i]) & PORT_CSC)
+		if (ehci_readl(ehci, ehci_portsc_addr(ehci, i)) & PORT_CSC)
 			return 1;
 
 	return 0;
@@ -169,7 +169,7 @@ static void ehci_adjust_port_wakeup_flags(struct ehci_hcd *ehci,
 
 	port = HCS_N_PORTS(ehci->hcs_params);
 	while (port--) {
-		u32 __iomem	*reg = &ehci->regs->port_status[port];
+		u32 __iomem	*reg = ehci_portsc_addr(ehci, port);
 		u32		t1 = ehci_readl(ehci, reg) & ~PORT_RWC_BITS;
 		u32		t2 = t1 & ~PORT_WAKE_BITS;
 
@@ -247,7 +247,7 @@ static int ehci_bus_suspend (struct usb_hcd *hcd)
 	changed = 0;
 	port = HCS_N_PORTS(ehci->hcs_params);
 	while (port--) {
-		u32 __iomem	*reg = &ehci->regs->port_status [port];
+		u32 __iomem	*reg = ehci_portsc_addr(ehci, port);
 		u32		t1 = ehci_readl(ehci, reg) & ~PORT_RWC_BITS;
 		u32		t2 = t1 & ~PORT_WAKE_BITS;
 
@@ -415,14 +415,14 @@ static int ehci_bus_resume (struct usb_hcd *hcd)
 	/* manually resume the ports we suspended during bus_suspend() */
 	i = HCS_N_PORTS (ehci->hcs_params);
 	while (i--) {
-		temp = ehci_readl(ehci, &ehci->regs->port_status [i]);
+		temp = ehci_readl(ehci, ehci_portsc_addr(ehci, i));
 		temp &= ~(PORT_RWC_BITS | PORT_WAKE_BITS);
 		if (test_bit(i, &ehci->bus_suspended) &&
 				(temp & PORT_SUSPEND)) {
 			temp |= PORT_RESUME;
 			set_bit(i, &resume_needed);
 		}
-		ehci_writel(ehci, temp, &ehci->regs->port_status [i]);
+		ehci_writel(ehci, temp, ehci_portsc_addr(ehci, i));
 	}
 
 	/* msleep for 20ms only if code is trying to resume port */
@@ -436,10 +436,10 @@ static int ehci_bus_resume (struct usb_hcd *hcd)
 
 	i = HCS_N_PORTS (ehci->hcs_params);
 	while (i--) {
-		temp = ehci_readl(ehci, &ehci->regs->port_status [i]);
+		temp = ehci_readl(ehci, ehci_portsc_addr(ehci, i));
 		if (test_bit(i, &resume_needed)) {
 			temp &= ~(PORT_RWC_BITS | PORT_RESUME);
-			ehci_writel(ehci, temp, &ehci->regs->port_status [i]);
+			ehci_writel(ehci, temp, ehci_portsc_addr(ehci, i));
 			ehci_vdbg (ehci, "resumed port %d\n", i + 1);
 		}
 	}
@@ -482,7 +482,7 @@ static void set_owner(struct ehci_hcd *ehci, int portnum, int new_owner)
 	u32			port_status;
 	int 			try;
 
-	status_reg = &ehci->regs->port_status[portnum];
+	status_reg = ehci_portsc_addr(ehci, portnum);
 
 	/*
 	 * The controller won't set the OWNER bit if the port is
@@ -604,7 +604,7 @@ ehci_hub_status_data (struct usb_hcd *hcd, char *buf)
 		/* leverage per-port change bits feature */
 		if (ehci->has_ppcd && !(ppcd & (1 << i)))
 			continue;
-		temp = ehci_readl(ehci, &ehci->regs->port_status [i]);
+		temp = ehci_readl(ehci, ehci_portsc_addr(ehci, i));
 
 		/*
 		 * Return status information even for ports with OWNER set.
@@ -675,8 +675,7 @@ static int ehci_hub_control (
 ) {
 	struct ehci_hcd	*ehci = hcd_to_ehci (hcd);
 	int		ports = HCS_N_PORTS (ehci->hcs_params);
-	u32 __iomem	*status_reg = &ehci->regs->port_status[
-				(wIndex & 0xff) - 1];
+	u32 __iomem	*status_reg = ehci_portsc_addr(ehci, (wIndex & 0xff) - 1);
 	u32 __iomem	*hostpc_reg = &ehci->regs->hostpc[(wIndex & 0xff) - 1];
 	u32		temp, temp1, status;
 	unsigned long	flags;
@@ -1054,8 +1053,7 @@ static int ehci_hub_control (
 
 			/* Put all enabled ports into suspend */
 			while (ports--) {
-				u32 __iomem *sreg =
-						&ehci->regs->port_status[ports];
+				u32 __iomem *sreg = ehci_portsc_addr(ehci, ports);
 
 				temp = ehci_readl(ehci, sreg) & ~PORT_RWC_BITS;
 				if (temp & PORT_PE)
@@ -1106,6 +1104,6 @@ static int __maybe_unused ehci_port_handed_over(struct usb_hcd *hcd,
 
 	if (ehci_is_TDI(ehci))
 		return 0;
-	reg = &ehci->regs->port_status[portnum - 1];
+	reg = ehci_portsc_addr(ehci, portnum - 1);
 	return ehci_readl(ehci, reg) & PORT_OWNER;
 }
drivers/usb/host/ehci-mem.c +2 -1
index ef2c3a1..fd7e298 100644
@@ -159,6 +159,7 @@ static void ehci_mem_cleanup (struct ehci_hcd *ehci)
 static int ehci_mem_init (struct ehci_hcd *ehci, gfp_t flags)
 {
 	int i;
+	unsigned int itd_align = ehci_is_fusbh200(ehci) ? 64 : 32;
 
 	/* QTDs for control/bulk/intr transfers */
 	ehci->qtd_pool = dma_pool_create ("ehci_qtd",
@@ -188,7 +189,7 @@ static int ehci_mem_init (struct ehci_hcd *ehci, gfp_t flags)
 	ehci->itd_pool = dma_pool_create ("ehci_itd",
 			ehci_to_hcd(ehci)->self.controller,
 			sizeof (struct ehci_itd),
-			32 /* byte alignment (for hw parts) */,
+			itd_align /* byte alignment (for hw parts) */,
 			4096 /* can't cross 4K */);
 	if (!ehci->itd_pool) {
 		goto fail;
drivers/usb/host/ehci-sched.c +21 -12
index 7cf3da7..29b7c40 100644
@@ -1005,11 +1005,9 @@ iso_stream_init (
 	}
 
 	/* knows about ITD vs SITD */
-	if (dev->speed == USB_SPEED_HIGH) {
+	if (dev->speed == USB_SPEED_HIGH || ehci_is_fusbh200(ehci)) {
 		unsigned multi = hb_mult(maxp);
 
-		stream->highspeed = 1;
-
 		maxp = max_packet(maxp);
 		buf1 |= maxp;
 		maxp *= multi;
@@ -1021,10 +1019,17 @@ iso_stream_init (
 		/* usbfs wants to report the average usecs per frame tied up
 		 * when transfers on this endpoint are scheduled ...
 		 */
-		stream->usecs = HS_USECS_ISO (maxp);
+		if (dev->speed == USB_SPEED_FULL) {
+			interval <<= 3;
+			stream->usecs = NS_TO_US(usb_calc_bus_time(dev->speed,
+					is_input, 1, maxp));
+			stream->usecs /= 8;
+		} else {
+			stream->highspeed = 1;
+			stream->usecs = HS_USECS_ISO (maxp);
+		}
 		bandwidth = stream->usecs * 8;
 		bandwidth /= interval;
-
 	} else {
 		u32		addr;
 		int		think_time;
@@ -1377,7 +1382,7 @@ iso_stream_schedule (
 
 	period = urb->interval;
 	span = sched->span;
-	if (!stream->highspeed) {
+	if (!stream->highspeed && !ehci_is_fusbh200(ehci)) {
 		period <<= 3;
 		span <<= 3;
 	}
@@ -1449,7 +1454,7 @@ iso_stream_schedule (
 		do {
 			start--;
 			/* check schedule: enough space? */
-			if (stream->highspeed) {
+			if (stream->highspeed || ehci_is_fusbh200(ehci)) {
 				if (itd_slot_ok(ehci, mod, start,
 						stream->usecs, period))
 					done = 1;
@@ -1699,12 +1704,12 @@ static bool itd_complete(struct ehci_hcd *ehci, struct ehci_itd *itd)
 
 			/* HC need not update length with this error */
 			if (!(t & EHCI_ISOC_BABBLE)) {
-				desc->actual_length = EHCI_ITD_LENGTH(t);
+				desc->actual_length = ehci_itdlen(ehci, urb, desc, t);
 				urb->actual_length += desc->actual_length;
 			}
 		} else if (likely ((t & EHCI_ISOC_ACTIVE) == 0)) {
 			desc->status = 0;
-			desc->actual_length = EHCI_ITD_LENGTH(t);
+			desc->actual_length = ehci_itdlen(ehci, urb, desc, t);
 			urb->actual_length += desc->actual_length;
 		} else {
 			/* URB was too late */
@@ -1777,9 +1782,13 @@ static int itd_submit (struct ehci_hcd *ehci, struct urb *urb,
 		return -ENOMEM;
 	}
 	if (unlikely (urb->interval != stream->interval)) {
-		ehci_dbg (ehci, "can't change iso interval %d --> %d\n",
-			stream->interval, urb->interval);
-		goto done;
+		if (!ehci_is_fusbh200(ehci) ||
+		    (ehci_is_fusbh200(ehci) &&
+		     ehci_port_speed(ehci, 0) == USB_PORT_STAT_HIGH_SPEED)) {
+			ehci_dbg (ehci, "can't change iso interval %d --> %d\n",
+				stream->interval, urb->interval);
+			goto done;
+		}
 	}
 
 #ifdef EHCI_URB_TRACE
drivers/usb/host/ehci.h +26 -1
index da07d98..fa9028d 100644
@@ -197,6 +197,7 @@ struct ehci_hcd {			/* one per controller */
 	unsigned		use_dummy_qh:1;	/* AMD Frame List table quirk*/
 	unsigned		has_synopsys_hc_bug:1; /* Synopsys HC */
 	unsigned		frame_index_bug:1; /* MosChip (AKA NetMos) */
+	unsigned		is_fusbh200:1; /* Faraday FUSBH200 */
 
 	/* required for usb32 quirk */
 	#define OHCI_CTRL_HCFS          (3 << 6)
@@ -578,6 +579,8 @@ struct ehci_fstn {
 
 /*-------------------------------------------------------------------------*/
 
+#define	ehci_is_fusbh200(e)		((e)->is_fusbh200)
+
 #ifdef CONFIG_USB_EHCI_ROOT_HUB_TT
 
 /*
@@ -589,12 +592,23 @@ struct ehci_fstn {
 
 #define	ehci_is_TDI(e)			(ehci_to_hcd(e)->has_tt)
 
+static inline unsigned int
+ehci_get_speed(struct ehci_hcd *ehci, unsigned int portsc)
+{
+	if (ehci_is_fusbh200(ehci))
+		return (readl(&ehci->regs->bmcsr)
+			& BMCSR_HOST_SPD_TYP) >> 9;
+	else
+		return (portsc >> (ehci->has_hostpc ?
+			25 : 26)) & 3;
+}
+
 /* Returns the speed of a device attached to a port on the root hub. */
 static inline unsigned int
 ehci_port_speed(struct ehci_hcd *ehci, unsigned int portsc)
 {
 	if (ehci_is_TDI(ehci)) {
-		switch ((portsc >> (ehci->has_hostpc ? 25 : 26)) & 3) {
+		switch (ehci_get_speed(ehci, portsc)) {
 		case 0:
 			return 0;
 		case 1:
@@ -776,6 +790,17 @@ static inline unsigned ehci_read_frame_index(struct ehci_hcd *ehci)
 
 #endif
 
+#define ehci_portsc_addr(ehci, port) ({			\
+	ehci_is_fusbh200(ehci) ?			\
+	&(ehci)->regs->fusbh200_portsc :		\
+	&(ehci)->regs->port_status[(port)];		\
+})
+
+#define ehci_itdlen(ehci, urb, desc, t) ({			\
+	ehci_is_fusbh200(ehci) && usb_pipein((urb)->pipe) ?	\
+	(desc)->length - EHCI_ITD_LENGTH(t) :			\
+	EHCI_ITD_LENGTH(t);					\
+})
 /*-------------------------------------------------------------------------*/
 
 #ifndef DEBUG
include/linux/usb/ehci_def.h +42 -16

94 lines not on this page · raw message

Signature · 1 line
1.7.4.1
#16 lore raw

PATCH v3 1/1 usb host: Faraday USB2.0 FUSBH200-HCD driver

In reply to Yuan-Hsin Chen

FUSBH200-HCD is an USB2.0 hcd for Faraday FUSBH200. FUSBH200 is an ehci-like controller with some differences. First, register layout of FUSBH200 is incompatible with EHCI. Furthermore, FUSBH200 is lack of siTDs which means iTDs are used for both HS and FS ISO transfer.

---

v2:
use ehci-platform.c
use anonymous union and struct
add is_fusbh200 to struct ehci_hcd

v3:
duplicate most of code from Linux-3.8 ehci hcd

 drivers/usb/Makefile            |    1 +
 drivers/usb/host/Kconfig        |    8 +
 drivers/usb/host/Makefile       |    1 +
 drivers/usb/host/fusbh200-hcd.c | 5984 +++++++++++++++++++++++++++++++++++++++
 drivers/usb/host/fusbh200.h     |  743 +++++
 5 files changed, 6737 insertions(+), 0 deletions(-)
 create mode 100644 drivers/usb/host/fusbh200-hcd.c
 create mode 100644 drivers/usb/host/fusbh200.h
drivers/usb/Makefile +1 -0
index f5ed3d7..9f18502 100644
@@ -27,6 +27,7 @@ obj-$(CONFIG_USB_HWA_HCD)	+= host/
 obj-$(CONFIG_USB_ISP1760_HCD)	+= host/
 obj-$(CONFIG_USB_IMX21_HCD)	+= host/
 obj-$(CONFIG_USB_FSL_MPH_DR_OF)	+= host/
+obj-$(CONFIG_USB_FUSBH200_HCD)	+= host/
 
 obj-$(CONFIG_USB_C67X00_HCD)	+= c67x00/
 
drivers/usb/host/Kconfig +8 -0
index 3f1431d..4c1deea 100644
@@ -287,6 +287,14 @@ config USB_ISP1362_HCD
 	  To compile this driver as a module, choose M here: the
 	  module will be called isp1362-hcd.
 
+config USB_FUSBH200_HCD
+	bool "Faraday FUSBH200 HCD support"
+	depends on USB
+	default N
+	---help---
+	The USB HCD Driver of Faraday FUSBH200 is designed to
+	meet USB2.0 EHCI specification with minor modification
+
 config USB_OHCI_HCD
 	tristate "OHCI HCD support"
 	depends on USB && USB_ARCH_HAS_OHCI
drivers/usb/host/Makefile +1 -0
index 9e0a89c..00d29cf 100644
@@ -43,3 +43,4 @@ obj-$(CONFIG_USB_OCTEON2_COMMON) += octeon2-common.o
 obj-$(CONFIG_MIPS_ALCHEMY)	+= alchemy-common.o
 obj-$(CONFIG_USB_HCD_BCMA)	+= bcma-hcd.o
 obj-$(CONFIG_USB_HCD_SSB)	+= ssb-hcd.o
+obj-$(CONFIG_USB_FUSBH200_HCD)	+= fusbh200-hcd.o
drivers/usb/host/fusbh200-hcd.c new file +5984 -0

2,975 lines not on this page · raw message

drivers/usb/host/fusbh200.h new file +743 -0

743 lines not on this page · raw message

The rest of this diff is not shown. View the raw message.

Signature · 1 line
1.7.4.1

Part of the diff is not shown here. View the raw message.

#17 lore raw

PATCH v4 1/1 usb host: Faraday USB2.0 FUSBH200-HCD driver

In reply to Yuan-Hsin Chen

FUSBH200-HCD is an USB2.0 hcd for Faraday FUSBH200. FUSBH200 is an ehci-like controller with some differences. First, register layout of FUSBH200 is incompatible with EHCI. Furthermore, FUSBH200 is lack of siTDs which means iTDs are used for both HS and FS ISO transfer.

---

v2:
use ehci-platform.c
use anonymous union and struct
add is_fusbh200 to struct ehci_hcd

v3:
duplicate most of code from Linux-3.7 ehci hcd

v4:
tristate for compiling as a module

 drivers/usb/Makefile            |    1 +
 drivers/usb/host/Kconfig        |   11 +
 drivers/usb/host/Makefile       |    1 +
 drivers/usb/host/fusbh200-hcd.c | 5984 +++++++++++++++++++++++++++++++++++++++
 drivers/usb/host/fusbh200.h     |  743 +++++
 5 files changed, 6740 insertions(+), 0 deletions(-)
 create mode 100644 drivers/usb/host/fusbh200-hcd.c
 create mode 100644 drivers/usb/host/fusbh200.h
drivers/usb/Makefile +1 -0
index 8f5ebce..82ef0be 100644
@@ -27,6 +27,7 @@ obj-$(CONFIG_USB_HWA_HCD)	+= host/
 obj-$(CONFIG_USB_ISP1760_HCD)	+= host/
 obj-$(CONFIG_USB_IMX21_HCD)	+= host/
 obj-$(CONFIG_USB_FSL_MPH_DR_OF)	+= host/
+obj-$(CONFIG_USB_FUSBH200_HCD)	+= host/
 
 obj-$(CONFIG_USB_C67X00_HCD)	+= c67x00/
 
drivers/usb/host/Kconfig +11 -0
index c59a112..ccf0874 100644
@@ -296,6 +296,17 @@ config USB_ISP1362_HCD
 	  To compile this driver as a module, choose M here: the
 	  module will be called isp1362-hcd.
 
+config USB_FUSBH200_HCD
+	tristate "FUSBH200 HCD support"
+	depends on USB
+	default N
+	---help---
+	Faraday FUSBH200 is designed to meet USB2.0 EHCI specification
+	with minor modification.
+
+	To compile this driver as a module, choose M here: the
+	module will be called fusbh200-hcd.
+
 config USB_OHCI_HCD
 	tristate "OHCI HCD support"
 	depends on USB && USB_ARCH_HAS_OHCI
drivers/usb/host/Makefile +1 -0
index 001fbff..612bbd5 100644
@@ -46,3 +46,4 @@ obj-$(CONFIG_USB_FSL_MPH_DR_OF)	+= fsl-mph-dr-of.o
 obj-$(CONFIG_USB_OCTEON2_COMMON) += octeon2-common.o
 obj-$(CONFIG_USB_HCD_BCMA)	+= bcma-hcd.o
 obj-$(CONFIG_USB_HCD_SSB)	+= ssb-hcd.o
+obj-$(CONFIG_USB_FUSBH200_HCD)	+= fusbh200-hcd.o
drivers/usb/host/fusbh200-hcd.c new file +5984 -0

2,972 lines not on this page · raw message

drivers/usb/host/fusbh200.h new file +743 -0

743 lines not on this page · raw message

The rest of this diff is not shown. View the raw message.

Signature · 1 line
1.7.4.1

Part of the diff is not shown here. View the raw message.

#18 lore raw

Re: [PATCH v4] usb host: Faraday USB2.0 FUSBH200-HCD driver

Hi,

Are there any advice?
Thanks.

Quoted 6,814 lines · Yuan-Hsin Chen

FUSBH200-HCD is an USB2.0 hcd for Faraday FUSBH200. FUSBH200 is an ehci-like controller with some differences. First, register layout of FUSBH200 is incompatible with EHCI. Furthermore, FUSBH200 is lack of siTDs which means iTDs are used for both HS and FS ISO transfer.

---

v2:
use ehci-platform.c
use anonymous union and struct
add is_fusbh200 to struct ehci_hcd

v3:
duplicate most of code from Linux-3.7 ehci hcd

v4:
tristate for compiling as a module

 drivers/usb/Makefile            |    1 +
 drivers/usb/host/Kconfig        |   11 +
 drivers/usb/host/Makefile       |    1 +
 drivers/usb/host/fusbh200-hcd.c | 5984 +++++++++++++++++++++++++++++++++++++++
 drivers/usb/host/fusbh200.h     |  743 +++++
 5 files changed, 6740 insertions(+), 0 deletions(-)
 create mode 100644 drivers/usb/host/fusbh200-hcd.c
 create mode 100644 drivers/usb/host/fusbh200.h
drivers/usb/Makefile +1 -0
index 8f5ebce..82ef0be 100644
@@ -27,6 +27,7 @@ obj-$(CONFIG_USB_HWA_HCD)     += host/
 obj-$(CONFIG_USB_ISP1760_HCD)  += host/
 obj-$(CONFIG_USB_IMX21_HCD)    += host/
 obj-$(CONFIG_USB_FSL_MPH_DR_OF)        += host/
+obj-$(CONFIG_USB_FUSBH200_HCD) += host/
 
 obj-$(CONFIG_USB_C67X00_HCD)   += c67x00/
 
drivers/usb/host/Kconfig +11 -0
index c59a112..ccf0874 100644
@@ -296,6 +296,17 @@ config USB_ISP1362_HCD
          To compile this driver as a module, choose M here: the
          module will be called isp1362-hcd.
 
+config USB_FUSBH200_HCD
+       tristate "FUSBH200 HCD support"
+       depends on USB
+       default N
+       ---help---
+       Faraday FUSBH200 is designed to meet USB2.0 EHCI specification
+       with minor modification.
+
+       To compile this driver as a module, choose M here: the
+       module will be called fusbh200-hcd.
+
 config USB_OHCI_HCD
        tristate "OHCI HCD support"
        depends on USB && USB_ARCH_HAS_OHCI
drivers/usb/host/Makefile +1 -0
index 001fbff..612bbd5 100644
@@ -46,3 +46,4 @@ obj-$(CONFIG_USB_FSL_MPH_DR_OF)       += fsl-mph-dr-of.o
 obj-$(CONFIG_USB_OCTEON2_COMMON) += octeon2-common.o
 obj-$(CONFIG_USB_HCD_BCMA)     += bcma-hcd.o
 obj-$(CONFIG_USB_HCD_SSB)      += ssb-hcd.o
+obj-$(CONFIG_USB_FUSBH200_HCD) += fusbh200-hcd.o
drivers/usb/host/fusbh200-hcd.c new file +5984 -0
new file mode 100644
index 0000000..0a2d015
@@ -0,0 +1,5984 @@
+/*
+ * Faraday FUSBH200 EHCI-like driver
+ *
+ * Copyright (c) 2013 Faraday Technology Corporation
+ *
+ * Author: Yuan-Hsin Chen <[email protected]>
+ *        Feng-Hsin Chiang <[email protected]>
+ *        Po-Yu Chuang <[email protected]>
+ *
+ * Most of code borrowed from the Linux-3.7 EHCI driver
+ *
+ * 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; either version 2 of the License, or (at your
+ * option) any later version.
+ *
+ * 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.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <linux/module.h>
+#include <linux/device.h>
+#include <linux/dmapool.h>
+#include <linux/kernel.h>
+#include <linux/delay.h>
+#include <linux/ioport.h>
+#include <linux/sched.h>
+#include <linux/vmalloc.h>
+#include <linux/errno.h>
+#include <linux/init.h>
+#include <linux/hrtimer.h>
+#include <linux/list.h>
+#include <linux/interrupt.h>
+#include <linux/usb.h>
+#include <linux/usb/hcd.h>
+#include <linux/moduleparam.h>
+#include <linux/dma-mapping.h>
+#include <linux/debugfs.h>
+#include <linux/slab.h>
+#include <linux/uaccess.h>
+#include <linux/platform_device.h>
+
+#include <asm/byteorder.h>
+#include <asm/io.h>
+#include <asm/irq.h>
+#include <asm/unaligned.h>
+
+/*-------------------------------------------------------------------------*/
+#define DRIVER_AUTHOR "Yuan-Hsin Chen"
+#define DRIVER_DESC "FUSBH200 Host Controller (EHCI) Driver"
+
+static const char      hcd_name [] = "fusbh200_hcd";
+
+#undef VERBOSE_DEBUG
+#undef FUSBH200_URB_TRACE
+
+#ifdef DEBUG
+#define FUSBH200_STATS
+#endif
+
+/* magic numbers that can affect system performance */
+#define        FUSBH200_TUNE_CERR              3       /* 0-3 qtd retries; 0 == don't stop */
+#define        FUSBH200_TUNE_RL_HS             4       /* nak throttle; see 4.9 */
+#define        FUSBH200_TUNE_RL_TT             0
+#define        FUSBH200_TUNE_MULT_HS   1       /* 1-3 transactions/uframe; 4.10.3 */
+#define        FUSBH200_TUNE_MULT_TT   1
+/*
+ * Some drivers think it's safe to schedule isochronous transfers more than
+ * 256 ms into the future (partly as a result of an old bug in the scheduling
+ * code).  In an attempt to avoid trouble, we will use a minimum scheduling
+ * length of 512 frames instead of 256.
+ */
+#define        FUSBH200_TUNE_FLS               1       /* (medium) 512-frame schedule */
+
+/* Initial IRQ latency:  faster than hw default */
+static int log2_irq_thresh = 0;                // 0 to 6
+module_param (log2_irq_thresh, int, S_IRUGO);
+MODULE_PARM_DESC (log2_irq_thresh, "log2 IRQ latency, 1-64 microframes");
+
+/* initial park setting:  slower than hw default */
+static unsigned park = 0;
+module_param (park, uint, S_IRUGO);
+MODULE_PARM_DESC (park, "park setting; 1-3 back-to-back async packets");
+
+/* for link power management(LPM) feature */
+static unsigned int hird;
+module_param(hird, int, S_IRUGO);
+MODULE_PARM_DESC(hird, "host initiated resume duration, +1 for each 75us");
+
+#define        INTR_MASK (STS_IAA | STS_FATAL | STS_PCD | STS_ERR | STS_INT)
+
+#include "fusbh200.h"
+
+/*-------------------------------------------------------------------------*/
+
+#define fusbh200_dbg(fusbh200, fmt, args...) \
+       dev_dbg (fusbh200_to_hcd(fusbh200)->self.controller , fmt , ## args )
+#define fusbh200_err(fusbh200, fmt, args...) \
+       dev_err (fusbh200_to_hcd(fusbh200)->self.controller , fmt , ## args )
+#define fusbh200_info(fusbh200, fmt, args...) \
+       dev_info (fusbh200_to_hcd(fusbh200)->self.controller , fmt , ## args )
+#define fusbh200_warn(fusbh200, fmt, args...) \
+       dev_warn (fusbh200_to_hcd(fusbh200)->self.controller , fmt , ## args )
+
+#ifdef VERBOSE_DEBUG
+#      define fusbh200_vdbg fusbh200_dbg
+#else
+       static inline void fusbh200_vdbg(struct fusbh200_hcd *fusbh200, ...) {}
+#endif
+
+#ifdef DEBUG
+
+/* check the values in the HCSPARAMS register
+ * (host controller _Structural_ parameters)
+ * see EHCI spec, Table 2-4 for each value
+ */
+static void dbg_hcs_params (struct fusbh200_hcd *fusbh200, char *label)
+{
+       u32     params = fusbh200_readl(fusbh200, &fusbh200->caps->hcs_params);
+
+       fusbh200_dbg (fusbh200,
+               "%s hcs_params 0x%x ports=%d\n",
+               label, params,
+               HCS_N_PORTS (params)
+               );
+}
+#else
+
+static inline void dbg_hcs_params (struct fusbh200_hcd *fusbh200, char *label) {}
+
+#endif
+
+#ifdef DEBUG
+
+/* check the values in the HCCPARAMS register
+ * (host controller _Capability_ parameters)
+ * see EHCI Spec, Table 2-5 for each value
+ * */
+static void dbg_hcc_params (struct fusbh200_hcd *fusbh200, char *label)
+{
+       u32     params = fusbh200_readl(fusbh200, &fusbh200->caps->hcc_params);
+
+       fusbh200_dbg (fusbh200,
+               "%s hcc_params %04x thresh %d uframes %s%s%s\n",
+               label,
+               params,
+               HCC_PGM_FRAMELISTLEN(params) ? "256/512/1024" : "1024",
+               HCC_CANPARK(params) ? " park" : "",
+               HCC_HW_PREFETCH(params) ? " hw prefetch" : "",
+               HCC_32FRAME_PERIODIC_LIST(params) ?
+                       " 32 periodic list" : "");
+}
+#else
+
+static inline void dbg_hcc_params (struct fusbh200_hcd *fusbh200, char *label) {}
+
+#endif
+
+#ifdef DEBUG
+
+static void __maybe_unused
+dbg_qtd (const char *label, struct fusbh200_hcd *fusbh200, struct fusbh200_qtd *qtd)
+{
+       fusbh200_dbg(fusbh200, "%s td %p n%08x %08x t%08x p0=%08x\n", label, qtd,
+               hc32_to_cpup(fusbh200, &qtd->hw_next),
+               hc32_to_cpup(fusbh200, &qtd->hw_alt_next),
+               hc32_to_cpup(fusbh200, &qtd->hw_token),
+               hc32_to_cpup(fusbh200, &qtd->hw_buf [0]));
+       if (qtd->hw_buf [1])
+               fusbh200_dbg(fusbh200, "  p1=%08x p2=%08x p3=%08x p4=%08x\n",
+                       hc32_to_cpup(fusbh200, &qtd->hw_buf[1]),
+                       hc32_to_cpup(fusbh200, &qtd->hw_buf[2]),
+                       hc32_to_cpup(fusbh200, &qtd->hw_buf[3]),
+                       hc32_to_cpup(fusbh200, &qtd->hw_buf[4]));
+}
+
+static void __maybe_unused
+dbg_qh (const char *label, struct fusbh200_hcd *fusbh200, struct fusbh200_qh *qh)
+{
+       struct fusbh200_qh_hw *hw = qh->hw;
+
+       fusbh200_dbg (fusbh200, "%s qh %p n%08x info %x %x qtd %x\n", label,
+               qh, hw->hw_next, hw->hw_info1, hw->hw_info2, hw->hw_current);
+       dbg_qtd("overlay", fusbh200, (struct fusbh200_qtd *) &hw->hw_qtd_next);
+}
+
+static void __maybe_unused
+dbg_itd (const char *label, struct fusbh200_hcd *fusbh200, struct fusbh200_itd *itd)
+{
+       fusbh200_dbg (fusbh200, "%s [%d] itd %p, next %08x, urb %p\n",
+               label, itd->frame, itd, hc32_to_cpu(fusbh200, itd->hw_next),
+               itd->urb);
+       fusbh200_dbg (fusbh200,
+               "  trans: %08x %08x %08x %08x %08x %08x %08x %08x\n",
+               hc32_to_cpu(fusbh200, itd->hw_transaction[0]),
+               hc32_to_cpu(fusbh200, itd->hw_transaction[1]),
+               hc32_to_cpu(fusbh200, itd->hw_transaction[2]),
+               hc32_to_cpu(fusbh200, itd->hw_transaction[3]),
+               hc32_to_cpu(fusbh200, itd->hw_transaction[4]),
+               hc32_to_cpu(fusbh200, itd->hw_transaction[5]),
+               hc32_to_cpu(fusbh200, itd->hw_transaction[6]),
+               hc32_to_cpu(fusbh200, itd->hw_transaction[7]));
+       fusbh200_dbg (fusbh200,
+               "  buf:   %08x %08x %08x %08x %08x %08x %08x\n",
+               hc32_to_cpu(fusbh200, itd->hw_bufp[0]),
+               hc32_to_cpu(fusbh200, itd->hw_bufp[1]),
+               hc32_to_cpu(fusbh200, itd->hw_bufp[2]),
+               hc32_to_cpu(fusbh200, itd->hw_bufp[3]),
+               hc32_to_cpu(fusbh200, itd->hw_bufp[4]),
+               hc32_to_cpu(fusbh200, itd->hw_bufp[5]),
+               hc32_to_cpu(fusbh200, itd->hw_bufp[6]));
+       fusbh200_dbg (fusbh200, "  index: %d %d %d %d %d %d %d %d\n",
+               itd->index[0], itd->index[1], itd->index[2],
+               itd->index[3], itd->index[4], itd->index[5],
+               itd->index[6], itd->index[7]);
+}
+
+static int __maybe_unused
+dbg_status_buf (char *buf, unsigned len, const char *label, u32 status)
+{
+       return scnprintf (buf, len,
+               "%s%sstatus %04x%s%s%s%s%s%s%s%s%s%s",
+               label, label [0] ? " " : "", status,
+               (status & STS_ASS) ? " Async" : "",
+               (status & STS_PSS) ? " Periodic" : "",
+               (status & STS_RECL) ? " Recl" : "",
+               (status & STS_HALT) ? " Halt" : "",
+               (status & STS_IAA) ? " IAA" : "",
+               (status & STS_FATAL) ? " FATAL" : "",
+               (status & STS_FLR) ? " FLR" : "",
+               (status & STS_PCD) ? " PCD" : "",
+               (status & STS_ERR) ? " ERR" : "",
+               (status & STS_INT) ? " INT" : ""
+               );
+}
+
+static int __maybe_unused
+dbg_intr_buf (char *buf, unsigned len, const char *label, u32 enable)
+{
+       return scnprintf (buf, len,
+               "%s%sintrenable %02x%s%s%s%s%s%s",
+               label, label [0] ? " " : "", enable,
+               (enable & STS_IAA) ? " IAA" : "",
+               (enable & STS_FATAL) ? " FATAL" : "",
+               (enable & STS_FLR) ? " FLR" : "",
+               (enable & STS_PCD) ? " PCD" : "",
+               (enable & STS_ERR) ? " ERR" : "",
+               (enable & STS_INT) ? " INT" : ""
+               );
+}
+
+static const char *const fls_strings [] =
+    { "1024", "512", "256", "??" };
+
+static int
+dbg_command_buf (char *buf, unsigned len, const char *label, u32 command)
+{
+       return scnprintf (buf, len,
+               "%s%scommand %07x %s=%d ithresh=%d%s%s%s "
+               "period=%s%s %s",
+               label, label [0] ? " " : "", command,
+               (command & CMD_PARK) ? " park" : "(park)",
+               CMD_PARK_CNT (command),
+               (command >> 16) & 0x3f,
+               (command & CMD_IAAD) ? " IAAD" : "",
+               (command & CMD_ASE) ? " Async" : "",
+               (command & CMD_PSE) ? " Periodic" : "",
+               fls_strings [(command >> 2) & 0x3],
+               (command & CMD_RESET) ? " Reset" : "",
+               (command & CMD_RUN) ? "RUN" : "HALT"
+               );
+}
+
+static int
+dbg_port_buf (char *buf, unsigned len, const char *label, int port, u32 status)
+{
+       char    *sig;
+
+       /* signaling state */
+       switch (status & (3 << 10)) {
+       case 0 << 10: sig = "se0"; break;
+       case 1 << 10: sig = "k"; break;         /* low speed */
+       case 2 << 10: sig = "j"; break;
+       default: sig = "?"; break;
+       }
+
+       return scnprintf (buf, len,
+               "%s%sport:%d status %06x %d "
+               "sig=%s%s%s%s%s%s%s%s",
+               label, label [0] ? " " : "", port, status,
+               status>>25,/*device address */
+               sig,
+               (status & PORT_RESET) ? " RESET" : "",
+               (status & PORT_SUSPEND) ? " SUSPEND" : "",
+               (status & PORT_RESUME) ? " RESUME" : "",
+               (status & PORT_PEC) ? " PEC" : "",
+               (status & PORT_PE) ? " PE" : "",
+               (status & PORT_CSC) ? " CSC" : "",
+               (status & PORT_CONNECT) ? " CONNECT" : "");
+}
+
+#else
+static inline void __maybe_unused
+dbg_qh (char *label, struct fusbh200_hcd *fusbh200, struct fusbh200_qh *qh)
+{}
+
+static inline int __maybe_unused
+dbg_status_buf (char *buf, unsigned len, const char *label, u32 status)
+{ return 0; }
+
+static inline int __maybe_unused
+dbg_command_buf (char *buf, unsigned len, const char *label, u32 command)
+{ return 0; }
+
+static inline int __maybe_unused
+dbg_intr_buf (char *buf, unsigned len, const char *label, u32 enable)
+{ return 0; }
+
+static inline int __maybe_unused
+dbg_port_buf (char *buf, unsigned len, const char *label, int port, u32 status)
+{ return 0; }
+
+#endif /* DEBUG */
+
+/* functions have the "wrong" filename when they're output... */
+#define dbg_status(fusbh200, label, status) { \
+       char _buf [80]; \
+       dbg_status_buf (_buf, sizeof _buf, label, status); \
+       fusbh200_dbg (fusbh200, "%s\n", _buf); \
+}
+
+#define dbg_cmd(fusbh200, label, command) { \
+       char _buf [80]; \
+       dbg_command_buf (_buf, sizeof _buf, label, command); \
+       fusbh200_dbg (fusbh200, "%s\n", _buf); \
+}
+
+#define dbg_port(fusbh200, label, port, status) { \
+       char _buf [80]; \
+       dbg_port_buf (_buf, sizeof _buf, label, port, status); \
+       fusbh200_dbg (fusbh200, "%s\n", _buf); \
+}
+
+/*-------------------------------------------------------------------------*/
+
+#ifdef STUB_DEBUG_FILES
+
+static inline void create_debug_files (struct fusbh200_hcd *bus) { }
+static inline void remove_debug_files (struct fusbh200_hcd *bus) { }
+
+#else
+
+/* troubleshooting help: expose state in debugfs */
+
+static int debug_async_open(struct inode *, struct file *);
+static int debug_periodic_open(struct inode *, struct file *);
+static int debug_registers_open(struct inode *, struct file *);
+static int debug_async_open(struct inode *, struct file *);
+static int debug_lpm_close(struct inode *inode, struct file *file);
+
+static ssize_t debug_output(struct file*, char __user*, size_t, loff_t*);
+static int debug_close(struct inode *, struct file *);
+
+static const struct file_operations debug_async_fops = {
+       .owner          = THIS_MODULE,
+       .open           = debug_async_open,
+       .read           = debug_output,
+       .release        = debug_close,
+       .llseek         = default_llseek,
+};
+static const struct file_operations debug_periodic_fops = {
+       .owner          = THIS_MODULE,
+       .open           = debug_periodic_open,
+       .read           = debug_output,
+       .release        = debug_close,
+       .llseek         = default_llseek,
+};
+static const struct file_operations debug_registers_fops = {
+       .owner          = THIS_MODULE,
+       .open           = debug_registers_open,
+       .read           = debug_output,
+       .release        = debug_close,
+       .llseek         = default_llseek,
+};
+
+static struct dentry *fusbh200_debug_root;
+
+struct debug_buffer {
+       ssize_t (*fill_func)(struct debug_buffer *);    /* fill method */
+       struct usb_bus *bus;
+       struct mutex mutex;     /* protect filling of buffer */
+       size_t count;           /* number of characters filled into buffer */
+       char *output_buf;
+       size_t alloc_size;
+};
+
+#define speed_char(info1) ({ char tmp; \
+               switch (info1 & (3 << 12)) { \
+               case QH_FULL_SPEED: tmp = 'f'; break; \
+               case QH_LOW_SPEED:  tmp = 'l'; break; \
+               case QH_HIGH_SPEED: tmp = 'h'; break; \
+               default: tmp = '?'; break; \
+               }; tmp; })
+
+static inline char token_mark(struct fusbh200_hcd *fusbh200, __hc32 token)
+{
+       __u32 v = hc32_to_cpu(fusbh200, token);
+
+       if (v & QTD_STS_ACTIVE)
+               return '*';
+       if (v & QTD_STS_HALT)
+               return '-';
+       if (!IS_SHORT_READ (v))
+               return ' ';
+       /* tries to advance through hw_alt_next */
+       return '/';
+}
+
+static void qh_lines (
+       struct fusbh200_hcd *fusbh200,
+       struct fusbh200_qh *qh,
+       char **nextp,
+       unsigned *sizep
+)
+{
+       u32                     scratch;
+       u32                     hw_curr;
+       struct list_head        *entry;
+       struct fusbh200_qtd             *td;
+       unsigned                temp;
+       unsigned                size = *sizep;
+       char                    *next = *nextp;
+       char                    mark;
+       __le32                  list_end = FUSBH200_LIST_END(fusbh200);
+       struct fusbh200_qh_hw   *hw = qh->hw;
+
+       if (hw->hw_qtd_next == list_end)        /* NEC does this */
+               mark = '@';
+       else
+               mark = token_mark(fusbh200, hw->hw_token);
+       if (mark == '/') {      /* qh_alt_next controls qh advance? */
+               if ((hw->hw_alt_next & QTD_MASK(fusbh200))
+                               == fusbh200->async->hw->hw_alt_next)
+                       mark = '#';     /* blocked */
+               else if (hw->hw_alt_next == list_end)
+                       mark = '.';     /* use hw_qtd_next */
+               /* else alt_next points to some other qtd */
+       }
+       scratch = hc32_to_cpup(fusbh200, &hw->hw_info1);
+       hw_curr = (mark == '*') ? hc32_to_cpup(fusbh200, &hw->hw_current) : 0;
+       temp = scnprintf (next, size,
+                       "qh/%p dev%d %cs ep%d %08x %08x (%08x%c %s nak%d)",
+                       qh, scratch & 0x007f,
+                       speed_char (scratch),
+                       (scratch >> 8) & 0x000f,
+                       scratch, hc32_to_cpup(fusbh200, &hw->hw_info2),
+                       hc32_to_cpup(fusbh200, &hw->hw_token), mark,
+                       (cpu_to_hc32(fusbh200, QTD_TOGGLE) & hw->hw_token)
+                               ? "data1" : "data0",
+                       (hc32_to_cpup(fusbh200, &hw->hw_alt_next) >> 1) & 0x0f);
+       size -= temp;
+       next += temp;
+
+       /* hc may be modifying the list as we read it ... */
+       list_for_each (entry, &qh->qtd_list) {
+               td = list_entry (entry, struct fusbh200_qtd, qtd_list);
+               scratch = hc32_to_cpup(fusbh200, &td->hw_token);
+               mark = ' ';
+               if (hw_curr == td->qtd_dma)
+                       mark = '*';
+               else if (hw->hw_qtd_next == cpu_to_hc32(fusbh200, td->qtd_dma))
+                       mark = '+';
+               else if (QTD_LENGTH (scratch)) {
+                       if (td->hw_alt_next == fusbh200->async->hw->hw_alt_next)
+                               mark = '#';
+                       else if (td->hw_alt_next != list_end)
+                               mark = '/';
+               }
+               temp = snprintf (next, size,
+                               "\n\t%p%c%s len=%d %08x urb %p",
+                               td, mark, ({ char *tmp;
+                                switch ((scratch>>8)&0x03) {
+                                case 0: tmp = "out"; break;
+                                case 1: tmp = "in"; break;
+                                case 2: tmp = "setup"; break;
+                                default: tmp = "?"; break;
+                                } tmp;}),
+                               (scratch >> 16) & 0x7fff,
+                               scratch,
+                               td->urb);
+               if (size < temp)
+                       temp = size;
+               size -= temp;
+               next += temp;
+               if (temp == size)
+                       goto done;
+       }
+
+       temp = snprintf (next, size, "\n");
+       if (size < temp)
+               temp = size;
+       size -= temp;
+       next += temp;
+
+done:
+       *sizep = size;
+       *nextp = next;
+}
+
+static ssize_t fill_async_buffer(struct debug_buffer *buf)
+{
+       struct usb_hcd          *hcd;
+       struct fusbh200_hcd     *fusbh200;
+       unsigned long           flags;
+       unsigned                temp, size;
+       char                    *next;
+       struct fusbh200_qh              *qh;
+
+       hcd = bus_to_hcd(buf->bus);
+       fusbh200 = hcd_to_fusbh200 (hcd);
+       next = buf->output_buf;
+       size = buf->alloc_size;
+
+       *next = 0;
+
+       /* dumps a snapshot of the async schedule.
+        * usually empty except for long-term bulk reads, or head.
+        * one QH per line, and TDs we know about
+        */
+       spin_lock_irqsave (&fusbh200->lock, flags);
+       for (qh = fusbh200->async->qh_next.qh; size > 0 && qh; qh = qh->qh_next.qh)
+               qh_lines (fusbh200, qh, &next, &size);
+       if (fusbh200->async_unlink && size > 0) {
+               temp = scnprintf(next, size, "\nunlink =\n");
+               size -= temp;
+               next += temp;
+
+               for (qh = fusbh200->async_unlink; size > 0 && qh;
+                               qh = qh->unlink_next)
+                       qh_lines (fusbh200, qh, &next, &size);
+       }
+       spin_unlock_irqrestore (&fusbh200->lock, flags);
+
+       return strlen(buf->output_buf);
+}
+
+#define DBG_SCHED_LIMIT 64
+static ssize_t fill_periodic_buffer(struct debug_buffer *buf)
+{
+       struct usb_hcd          *hcd;
+       struct fusbh200_hcd             *fusbh200;
+       unsigned long           flags;
+       union fusbh200_shadow   p, *seen;
+       unsigned                temp, size, seen_count;
+       char                    *next;
+       unsigned                i;
+       __hc32                  tag;
+
+       if (!(seen = kmalloc (DBG_SCHED_LIMIT * sizeof *seen, GFP_ATOMIC)))
+               return 0;
+       seen_count = 0;
+
+       hcd = bus_to_hcd(buf->bus);
+       fusbh200 = hcd_to_fusbh200 (hcd);
+       next = buf->output_buf;
+       size = buf->alloc_size;
+
+       temp = scnprintf (next, size, "size = %d\n", fusbh200->periodic_size);
+       size -= temp;
+       next += temp;
+
+       /* dump a snapshot of the periodic schedule.
+        * iso changes, interrupt usually doesn't.
+        */
+       spin_lock_irqsave (&fusbh200->lock, flags);
+       for (i = 0; i < fusbh200->periodic_size; i++) {
+               p = fusbh200->pshadow [i];
+               if (likely (!p.ptr))
+                       continue;
+               tag = Q_NEXT_TYPE(fusbh200, fusbh200->periodic [i]);
+
+               temp = scnprintf (next, size, "%4d: ", i);
+               size -= temp;
+               next += temp;
+
+               do {
+                       struct fusbh200_qh_hw *hw;
+
+                       switch (hc32_to_cpu(fusbh200, tag)) {
+                       case Q_TYPE_QH:
+                               hw = p.qh->hw;
+                               temp = scnprintf (next, size, " qh%d-%04x/%p",
+                                               p.qh->period,
+                                               hc32_to_cpup(fusbh200,
+                                                       &hw->hw_info2)
+                                                       /* uframe masks */
+                                                       & (QH_CMASK | QH_SMASK),
+                                               p.qh);
+                               size -= temp;
+                               next += temp;
+                               /* don't repeat what follows this qh */
+                               for (temp = 0; temp < seen_count; temp++) {
+                                       if (seen [temp].ptr != p.ptr)
+                                               continue;
+                                       if (p.qh->qh_next.ptr) {
+                                               temp = scnprintf (next, size,
+                                                       " ...");
+                                               size -= temp;
+                                               next += temp;
+                                       }
+                                       break;
+                               }
+                               /* show more info the first time around */
+                               if (temp == seen_count) {
+                                       u32     scratch = hc32_to_cpup(fusbh200,
+                                                       &hw->hw_info1);
+                                       struct fusbh200_qtd     *qtd;
+                                       char            *type = "";
+
+                                       /* count tds, get ep direction */
+                                       temp = 0;
+                                       list_for_each_entry (qtd,
+                                                       &p.qh->qtd_list,
+                                                       qtd_list) {
+                                               temp++;
+                                               switch (0x03 & (hc32_to_cpu(
+                                                       fusbh200,
+                                                       qtd->hw_token) >> 8)) {
+                                               case 0: type = "out"; continue;
+                                               case 1: type = "in"; continue;
+                                               }
+                                       }
+
+                                       temp = scnprintf (next, size,
+                                               " (%c%d ep%d%s "
+                                               "[%d/%d] q%d p%d)",
+                                               speed_char (scratch),
+                                               scratch & 0x007f,
+                                               (scratch >> 8) & 0x000f, type,
+                                               p.qh->usecs, p.qh->c_usecs,
+                                               temp,
+                                               0x7ff & (scratch >> 16));
+
+                                       if (seen_count < DBG_SCHED_LIMIT)
+                                               seen [seen_count++].qh = p.qh;
+                               } else
+                                       temp = 0;
+                               tag = Q_NEXT_TYPE(fusbh200, hw->hw_next);
+                               p = p.qh->qh_next;
+                               break;
+                       case Q_TYPE_FSTN:
+                               temp = scnprintf (next, size,
+                                       " fstn-%8x/%p", p.fstn->hw_prev,
+                                       p.fstn);
+                               tag = Q_NEXT_TYPE(fusbh200, p.fstn->hw_next);
+                               p = p.fstn->fstn_next;
+                               break;
+                       case Q_TYPE_ITD:
+                               temp = scnprintf (next, size,
+                                       " itd/%p", p.itd);
+                               tag = Q_NEXT_TYPE(fusbh200, p.itd->hw_next);
+                               p = p.itd->itd_next;
+                               break;
+                       }
+                       size -= temp;
+                       next += temp;
+               } while (p.ptr);
+
+               temp = scnprintf (next, size, "\n");
+               size -= temp;
+               next += temp;
+       }
+       spin_unlock_irqrestore (&fusbh200->lock, flags);
+       kfree (seen);
+
+       return buf->alloc_size - size;
+}
+#undef DBG_SCHED_LIMIT
+
+static const char *rh_state_string(struct fusbh200_hcd *fusbh200)
+{
+       switch (fusbh200->rh_state) {
+       case FUSBH200_RH_HALTED:
+               return "halted";
+       case FUSBH200_RH_SUSPENDED:
+               return "suspended";
+       case FUSBH200_RH_RUNNING:
+               return "running";
+       case FUSBH200_RH_STOPPING:
+               return "stopping";
+       }
+       return "?";
+}
+
+static ssize_t fill_registers_buffer(struct debug_buffer *buf)
+{
+       struct usb_hcd          *hcd;
+       struct fusbh200_hcd     *fusbh200;
+       unsigned long           flags;
+       unsigned                temp, size, i;
+       char                    *next, scratch [80];
+       static char             fmt [] = "%*s\n";
+       static char             label [] = "";
+
+       hcd = bus_to_hcd(buf->bus);
+       fusbh200 = hcd_to_fusbh200 (hcd);
+       next = buf->output_buf;
+       size = buf->alloc_size;
+
+       spin_lock_irqsave (&fusbh200->lock, flags);
+
+       if (!HCD_HW_ACCESSIBLE(hcd)) {
+               size = scnprintf (next, size,
+                       "bus %s, device %s\n"
+                       "%s\n"
+                       "SUSPENDED (no register access)\n",
+                       hcd->self.controller->bus->name,
+                       dev_name(hcd->self.controller),
+                       hcd->product_desc);
+               goto done;
+       }
+
+       /* Capability Registers */
+       i = HC_VERSION(fusbh200, fusbh200_readl(fusbh200, &fusbh200->caps->hc_capbase));
+       temp = scnprintf (next, size,
+               "bus %s, device %s\n"
+               "%s\n"
+               "EHCI %x.%02x, rh state %s\n",
+               hcd->self.controller->bus->name,
+               dev_name(hcd->self.controller),
+               hcd->product_desc,
+               i >> 8, i & 0x0ff, rh_state_string(fusbh200));
+       size -= temp;
+       next += temp;
+
+       // FIXME interpret both types of params
+       i = fusbh200_readl(fusbh200, &fusbh200->caps->hcs_params);
+       temp = scnprintf (next, size, "structural params 0x%08x\n", i);
+       size -= temp;
+       next += temp;
+
+       i = fusbh200_readl(fusbh200, &fusbh200->caps->hcc_params);
+       temp = scnprintf (next, size, "capability params 0x%08x\n", i);
+       size -= temp;
+       next += temp;
+
+       /* Operational Registers */
+       temp = dbg_status_buf (scratch, sizeof scratch, label,
+                       fusbh200_readl(fusbh200, &fusbh200->regs->status));
+       temp = scnprintf (next, size, fmt, temp, scratch);
+       size -= temp;
+       next += temp;
+
+       temp = dbg_command_buf (scratch, sizeof scratch, label,
+                       fusbh200_readl(fusbh200, &fusbh200->regs->command));
+       temp = scnprintf (next, size, fmt, temp, scratch);
+       size -= temp;
+       next += temp;
+
+       temp = dbg_intr_buf (scratch, sizeof scratch, label,
+                       fusbh200_readl(fusbh200, &fusbh200->regs->intr_enable));
+       temp = scnprintf (next, size, fmt, temp, scratch);
+       size -= temp;
+       next += temp;
+
+       temp = scnprintf (next, size, "uframe %04x\n",
+                       fusbh200_read_frame_index(fusbh200));
+       size -= temp;
+       next += temp;
+
+       if (fusbh200->async_unlink) {
+               temp = scnprintf(next, size, "async unlink qh %p\n",
+                               fusbh200->async_unlink);
+               size -= temp;
+               next += temp;
+       }
+
+#ifdef FUSBH200_STATS
+       temp = scnprintf (next, size,
+               "irq normal %ld err %ld iaa %ld (lost %ld)\n",
+               fusbh200->stats.normal, fusbh200->stats.error, fusbh200->stats.iaa,
+               fusbh200->stats.lost_iaa);
+       size -= temp;
+       next += temp;
+
+       temp = scnprintf (next, size, "complete %ld unlink %ld\n",
+               fusbh200->stats.complete, fusbh200->stats.unlink);
+       size -= temp;
+       next += temp;
+#endif
+
+done:
+       spin_unlock_irqrestore (&fusbh200->lock, flags);
+
+       return buf->alloc_size - size;
+}
+
+static struct debug_buffer *alloc_buffer(struct usb_bus *bus,
+                               ssize_t (*fill_func)(struct debug_buffer *))
+{
+       struct debug_buffer *buf;
+
+       buf = kzalloc(sizeof(struct debug_buffer), GFP_KERNEL);
+
+       if (buf) {
+               buf->bus = bus;
+               buf->fill_func = fill_func;
+               mutex_init(&buf->mutex);
+               buf->alloc_size = PAGE_SIZE;
+       }
+
+       return buf;
+}
+
+static int fill_buffer(struct debug_buffer *buf)
+{
+       int ret = 0;
+
+       if (!buf->output_buf)
+               buf->output_buf = vmalloc(buf->alloc_size);
+
+       if (!buf->output_buf) {
+               ret = -ENOMEM;
+               goto out;
+       }
+
+       ret = buf->fill_func(buf);
+
+       if (ret >= 0) {
+               buf->count = ret;
+               ret = 0;
+       }
+
+out:
+       return ret;
+}
+
+static ssize_t debug_output(struct file *file, char __user *user_buf,
+                           size_t len, loff_t *offset)
+{
+       struct debug_buffer *buf = file->private_data;
+       int ret = 0;
+
+       mutex_lock(&buf->mutex);
+       if (buf->count == 0) {
+               ret = fill_buffer(buf);
+               if (ret != 0) {
+                       mutex_unlock(&buf->mutex);
+                       goto out;
+               }
+       }
+       mutex_unlock(&buf->mutex);
+
+       ret = simple_read_from_buffer(user_buf, len, offset,
+                                     buf->output_buf, buf->count);
+
+out:
+       return ret;
+
+}
+
+static int debug_close(struct inode *inode, struct file *file)
+{
+       struct debug_buffer *buf = file->private_data;
+
+       if (buf) {
+               vfree(buf->output_buf);
+               kfree(buf);
+       }
+
+       return 0;
+}
+static int debug_async_open(struct inode *inode, struct file *file)
+{
+       file->private_data = alloc_buffer(inode->i_private, fill_async_buffer);
+
+       return file->private_data ? 0 : -ENOMEM;
+}
+
+static int debug_periodic_open(struct inode *inode, struct file *file)
+{
+       struct debug_buffer *buf;
+       buf = alloc_buffer(inode->i_private, fill_periodic_buffer);
+       if (!buf)
+               return -ENOMEM;
+
+       buf->alloc_size = (sizeof(void *) == 4 ? 6 : 8)*PAGE_SIZE;
+       file->private_data = buf;
+       return 0;
+}
+
+static int debug_registers_open(struct inode *inode, struct file *file)
+{
+       file->private_data = alloc_buffer(inode->i_private,
+                                         fill_registers_buffer);
+
+       return file->private_data ? 0 : -ENOMEM;
+}
+
+static int debug_lpm_close(struct inode *inode, struct file *file)
+{
+       return 0;
+}
+
+static inline void create_debug_files (struct fusbh200_hcd *fusbh200)
+{
+       struct usb_bus *bus = &fusbh200_to_hcd(fusbh200)->self;
+
+       fusbh200->debug_dir = debugfs_create_dir(bus->bus_name, fusbh200_debug_root);
+       if (!fusbh200->debug_dir)
+               return;
+
+       if (!debugfs_create_file("async", S_IRUGO, fusbh200->debug_dir, bus,
+                                               &debug_async_fops))
+               goto file_error;
+
+       if (!debugfs_create_file("periodic", S_IRUGO, fusbh200->debug_dir, bus,
+                                               &debug_periodic_fops))
+               goto file_error;
+
+       if (!debugfs_create_file("registers", S_IRUGO, fusbh200->debug_dir, bus,
+                                                   &debug_registers_fops))
+               goto file_error;
+
+       return;
+
+file_error:
+       debugfs_remove_recursive(fusbh200->debug_dir);
+}
+
+static inline void remove_debug_files (struct fusbh200_hcd *fusbh200)
+{
+       debugfs_remove_recursive(fusbh200->debug_dir);
+}
+
+#endif /* STUB_DEBUG_FILES */
+/*-------------------------------------------------------------------------*/
+
+/*
+ * handshake - spin reading hc until handshake completes or fails
+ * @ptr: address of hc register to be read
+ * @mask: bits to look at in result of read
+ * @done: value of those bits when handshake succeeds
+ * @usec: timeout in microseconds
+ *
+ * Returns negative errno, or zero on success
+ *
+ * Success happens when the "mask" bits have the specified value (hardware
+ * handshake done).  There are two failure modes:  "usec" have passed (major
+ * hardware flakeout), or the register reads as all-ones (hardware removed).
+ *
+ * That last failure should_only happen in cases like physical cardbus eject
+ * before driver shutdown. But it also seems to be caused by bugs in cardbus
+ * bridge shutdown:  shutting down the bridge before the devices using it.
+ */
+static int handshake (struct fusbh200_hcd *fusbh200, void __iomem *ptr,
+                     u32 mask, u32 done, int usec)
+{
+       u32     result;
+
+       do {
+               result = fusbh200_readl(fusbh200, ptr);
+               if (result == ~(u32)0)          /* card removed */
+                       return -ENODEV;
+               result &= mask;
+               if (result == done)
+                       return 0;
+               udelay (1);
+               usec--;
+       } while (usec > 0);
+       return -ETIMEDOUT;
+}
+
+/*
+ * Force HC to halt state from unknown (EHCI spec section 2.3).
+ * Must be called with interrupts enabled and the lock not held.
+ */
+static int fusbh200_halt (struct fusbh200_hcd *fusbh200)
+{
+       u32     temp;
+
+       spin_lock_irq(&fusbh200->lock);
+
+       /* disable any irqs left enabled by previous code */
+       fusbh200_writel(fusbh200, 0, &fusbh200->regs->intr_enable);
+
+       /*
+        * This routine gets called during probe before fusbh200->command
+        * has been initialized, so we can't rely on its value.
+        */
+       fusbh200->command &= ~CMD_RUN;
+       temp = fusbh200_readl(fusbh200, &fusbh200->regs->command);
+       temp &= ~(CMD_RUN | CMD_IAAD);
+       fusbh200_writel(fusbh200, temp, &fusbh200->regs->command);
+
+       spin_unlock_irq(&fusbh200->lock);
+       synchronize_irq(fusbh200_to_hcd(fusbh200)->irq);
+
+       return handshake(fusbh200, &fusbh200->regs->status,
+                         STS_HALT, STS_HALT, 16 * 125);
+}
+
+/*
+ * Reset a non-running (STS_HALT == 1) controller.
+ * Must be called with interrupts enabled and the lock not held.
+ */
+static int fusbh200_reset (struct fusbh200_hcd *fusbh200)
+{
+       int     retval;
+       u32     command = fusbh200_readl(fusbh200, &fusbh200->regs->command);
+
+       /* If the EHCI debug controller is active, special care must be
+        * taken before and after a host controller reset */
+       if (fusbh200->debug && !dbgp_reset_prep(fusbh200_to_hcd(fusbh200)))
+               fusbh200->debug = NULL;
+
+       command |= CMD_RESET;
+       dbg_cmd (fusbh200, "reset", command);
+       fusbh200_writel(fusbh200, command, &fusbh200->regs->command);
+       fusbh200->rh_state = FUSBH200_RH_HALTED;
+       fusbh200->next_statechange = jiffies;
+       retval = handshake (fusbh200, &fusbh200->regs->command,
+                           CMD_RESET, 0, 250 * 1000);
+
+       if (retval)
+               return retval;
+
+       if (fusbh200->debug)
+               dbgp_external_startup(fusbh200_to_hcd(fusbh200));
+
+       fusbh200->port_c_suspend = fusbh200->suspended_ports =
+                       fusbh200->resuming_ports = 0;
+       return retval;
+}
+
+/*
+ * Idle the controller (turn off the schedules).
+ * Must be called with interrupts enabled and the lock not held.
+ */
+static void fusbh200_quiesce (struct fusbh200_hcd *fusbh200)
+{
+       u32     temp;
+
+       if (fusbh200->rh_state != FUSBH200_RH_RUNNING)
+               return;
+
+       /* wait for any schedule enables/disables to take effect */
+       temp = (fusbh200->command << 10) & (STS_ASS | STS_PSS);
+       handshake(fusbh200, &fusbh200->regs->status, STS_ASS | STS_PSS, temp, 16 * 125);
+
+       /* then disable anything that's still active */
+       spin_lock_irq(&fusbh200->lock);
+       fusbh200->command &= ~(CMD_ASE | CMD_PSE);
+       fusbh200_writel(fusbh200, fusbh200->command, &fusbh200->regs->command);
+       spin_unlock_irq(&fusbh200->lock);
+
+       /* hardware can take 16 microframes to turn off ... */
+       handshake(fusbh200, &fusbh200->regs->status, STS_ASS | STS_PSS, 0, 16 * 125);
+}
+
+/*-------------------------------------------------------------------------*/
+
+static void end_unlink_async(struct fusbh200_hcd *fusbh200);
+static void unlink_empty_async(struct fusbh200_hcd *fusbh200);
+static void fusbh200_work(struct fusbh200_hcd *fusbh200);
+static void start_unlink_intr(struct fusbh200_hcd *fusbh200, struct fusbh200_qh *qh);
+static void end_unlink_intr(struct fusbh200_hcd *fusbh200, struct fusbh200_qh *qh);
+
+/*-------------------------------------------------------------------------*/
+
+/* Set a bit in the USBCMD register */
+static void fusbh200_set_command_bit(struct fusbh200_hcd *fusbh200, u32 bit)
+{
+       fusbh200->command |= bit;
+       fusbh200_writel(fusbh200, fusbh200->command, &fusbh200->regs->command);
+
+       /* unblock posted write */
+       fusbh200_readl(fusbh200, &fusbh200->regs->command);
+}
+
+/* Clear a bit in the USBCMD register */
+static void fusbh200_clear_command_bit(struct fusbh200_hcd *fusbh200, u32 bit)
+{
+       fusbh200->command &= ~bit;
+       fusbh200_writel(fusbh200, fusbh200->command, &fusbh200->regs->command);
+
+       /* unblock posted write */
+       fusbh200_readl(fusbh200, &fusbh200->regs->command);
+}
+
+/*-------------------------------------------------------------------------*/
+
+/*
+ * EHCI timer support...  Now using hrtimers.
+ *
+ * Lots of different events are triggered from fusbh200->hrtimer.  Whenever
+ * the timer routine runs, it checks each possible event; events that are
+ * currently enabled and whose expiration time has passed get handled.
+ * The set of enabled events is stored as a collection of bitflags in
+ * fusbh200->enabled_hrtimer_events, and they are numbered in order of
+ * increasing delay values (ranging between 1 ms and 100 ms).
+ *
+ * Rather than implementing a sorted list or tree of all pending events,
+ * we keep track only of the lowest-numbered pending event, in
+ * fusbh200->next_hrtimer_event.  Whenever fusbh200->hrtimer gets restarted, its
+ * expiration time is set to the timeout value for this event.
+ *
+ * As a result, events might not get handled right away; the actual delay
+ * could be anywhere up to twice the requested delay.  This doesn't
+ * matter, because none of the events are especially time-critical.  The
+ * ones that matter most all have a delay of 1 ms, so they will be
+ * handled after 2 ms at most, which is okay.  In addition to this, we
+ * allow for an expiration range of 1 ms.
+ */
+
+/*
+ * Delay lengths for the hrtimer event types.
+ * Keep this list sorted by delay length, in the same order as
+ * the event types indexed by enum fusbh200_hrtimer_event in fusbh200.h.
+ */
+static unsigned event_delays_ns[] = {
+       1 * NSEC_PER_MSEC,      /* FUSBH200_HRTIMER_POLL_ASS */
+       1 * NSEC_PER_MSEC,      /* FUSBH200_HRTIMER_POLL_PSS */
+       1 * NSEC_PER_MSEC,      /* FUSBH200_HRTIMER_POLL_DEAD */
+       1125 * NSEC_PER_USEC,   /* FUSBH200_HRTIMER_UNLINK_INTR */
+       2 * NSEC_PER_MSEC,      /* FUSBH200_HRTIMER_FREE_ITDS */
+       6 * NSEC_PER_MSEC,      /* FUSBH200_HRTIMER_ASYNC_UNLINKS */
+       10 * NSEC_PER_MSEC,     /* FUSBH200_HRTIMER_IAA_WATCHDOG */
+       10 * NSEC_PER_MSEC,     /* FUSBH200_HRTIMER_DISABLE_PERIODIC */
+       15 * NSEC_PER_MSEC,     /* FUSBH200_HRTIMER_DISABLE_ASYNC */
+       100 * NSEC_PER_MSEC,    /* FUSBH200_HRTIMER_IO_WATCHDOG */
+};
+
+/* Enable a pending hrtimer event */
+static void fusbh200_enable_event(struct fusbh200_hcd *fusbh200, unsigned event,
+               bool resched)
+{
+       ktime_t         *timeout = &fusbh200->hr_timeouts[event];
+
+       if (resched)
+               *timeout = ktime_add(ktime_get(),
+                               ktime_set(0, event_delays_ns[event]));
+       fusbh200->enabled_hrtimer_events |= (1 << event);
+
+       /* Track only the lowest-numbered pending event */
+       if (event < fusbh200->next_hrtimer_event) {
+               fusbh200->next_hrtimer_event = event;
+               hrtimer_start_range_ns(&fusbh200->hrtimer, *timeout,
+                               NSEC_PER_MSEC, HRTIMER_MODE_ABS);
+       }
+}
+
+
+/* Poll the STS_ASS status bit; see when it agrees with CMD_ASE */
+static void fusbh200_poll_ASS(struct fusbh200_hcd *fusbh200)
+{
+       unsigned        actual, want;
+
+       /* Don't enable anything if the controller isn't running (e.g., died) */
+       if (fusbh200->rh_state != FUSBH200_RH_RUNNING)
+               return;
+
+       want = (fusbh200->command & CMD_ASE) ? STS_ASS : 0;
+       actual = fusbh200_readl(fusbh200, &fusbh200->regs->status) & STS_ASS;
+
+       if (want != actual) {
+
+               /* Poll again later, but give up after about 20 ms */
+               if (fusbh200->ASS_poll_count++ < 20) {
+                       fusbh200_enable_event(fusbh200, FUSBH200_HRTIMER_POLL_ASS, true);
+                       return;
+               }
+               fusbh200_dbg(fusbh200, "Waited too long for the async schedule status (%x/%x), giving up\n",
+                               want, actual);
+       }
+       fusbh200->ASS_poll_count = 0;
+
+       /* The status is up-to-date; restart or stop the schedule as needed */
+       if (want == 0) {        /* Stopped */
+               if (fusbh200->async_count > 0)
+                       fusbh200_set_command_bit(fusbh200, CMD_ASE);
+
+       } else {                /* Running */
+               if (fusbh200->async_count == 0) {
+
+                       /* Turn off the schedule after a while */
+                       fusbh200_enable_event(fusbh200, FUSBH200_HRTIMER_DISABLE_ASYNC,
+                                       true);
+               }
+       }
+}
+
+/* Turn off the async schedule after a brief delay */
+static void fusbh200_disable_ASE(struct fusbh200_hcd *fusbh200)
+{
+       fusbh200_clear_command_bit(fusbh200, CMD_ASE);
+}
+
+
+/* Poll the STS_PSS status bit; see when it agrees with CMD_PSE */
+static void fusbh200_poll_PSS(struct fusbh200_hcd *fusbh200)
+{
+       unsigned        actual, want;
+
+       /* Don't do anything if the controller isn't running (e.g., died) */
+       if (fusbh200->rh_state != FUSBH200_RH_RUNNING)
+               return;
+
+       want = (fusbh200->command & CMD_PSE) ? STS_PSS : 0;
+       actual = fusbh200_readl(fusbh200, &fusbh200->regs->status) & STS_PSS;
+
+       if (want != actual) {
+
+               /* Poll again later, but give up after about 20 ms */
+               if (fusbh200->PSS_poll_count++ < 20) {
+                       fusbh200_enable_event(fusbh200, FUSBH200_HRTIMER_POLL_PSS, true);
+                       return;
+               }
+               fusbh200_dbg(fusbh200, "Waited too long for the periodic schedule status (%x/%x), giving up\n",
+                               want, actual);
+       }
+       fusbh200->PSS_poll_count = 0;
+
+       /* The status is up-to-date; restart or stop the schedule as needed */
+       if (want == 0) {        /* Stopped */
+               if (fusbh200->periodic_count > 0)
+                       fusbh200_set_command_bit(fusbh200, CMD_PSE);
+
+       } else {                /* Running */
+               if (fusbh200->periodic_count == 0) {
+
+                       /* Turn off the schedule after a while */
+                       fusbh200_enable_event(fusbh200, FUSBH200_HRTIMER_DISABLE_PERIODIC,
+                                       true);
+               }
+       }
+}
+
+/* Turn off the periodic schedule after a brief delay */
+static void fusbh200_disable_PSE(struct fusbh200_hcd *fusbh200)
+{
+       fusbh200_clear_command_bit(fusbh200, CMD_PSE);
+}
+
+
+/* Poll the STS_HALT status bit; see when a dead controller stops */
+static void fusbh200_handle_controller_death(struct fusbh200_hcd *fusbh200)
+{
+       if (!(fusbh200_readl(fusbh200, &fusbh200->regs->status) & STS_HALT)) {
+
+               /* Give up after a few milliseconds */
+               if (fusbh200->died_poll_count++ < 5) {
+                       /* Try again later */
+                       fusbh200_enable_event(fusbh200, FUSBH200_HRTIMER_POLL_DEAD, true);
+                       return;
+               }
+               fusbh200_warn(fusbh200, "Waited too long for the controller to stop, giving up\n");
+       }
+
+       /* Clean up the mess */
+       fusbh200->rh_state = FUSBH200_RH_HALTED;
+       fusbh200_writel(fusbh200, 0, &fusbh200->regs->intr_enable);
+       fusbh200_work(fusbh200);
+       end_unlink_async(fusbh200);
+
+       /* Not in process context, so don't try to reset the controller */
+}
+
+
+/* Handle unlinked interrupt QHs once they are gone from the hardware */
+static void fusbh200_handle_intr_unlinks(struct fusbh200_hcd *fusbh200)
+{
+       bool            stopped = (fusbh200->rh_state < FUSBH200_RH_RUNNING);
+
+       /*
+        * Process all the QHs on the intr_unlink list that were added
+        * before the current unlink cycle began.  The list is in
+        * temporal order, so stop when we reach the first entry in the
+        * current cycle.  But if the root hub isn't running then
+        * process all the QHs on the list.
+        */
+       fusbh200->intr_unlinking = true;
+       while (fusbh200->intr_unlink) {
+               struct fusbh200_qh      *qh = fusbh200->intr_unlink;
+
+               if (!stopped && qh->unlink_cycle == fusbh200->intr_unlink_cycle)
+                       break;
+               fusbh200->intr_unlink = qh->unlink_next;
+               qh->unlink_next = NULL;
+               end_unlink_intr(fusbh200, qh);
+       }
+
+       /* Handle remaining entries later */
+       if (fusbh200->intr_unlink) {
+               fusbh200_enable_event(fusbh200, FUSBH200_HRTIMER_UNLINK_INTR, true);
+               ++fusbh200->intr_unlink_cycle;
+       }
+       fusbh200->intr_unlinking = false;
+}
+
+
+/* Start another free-iTDs/siTDs cycle */
+static void start_free_itds(struct fusbh200_hcd *fusbh200)
+{
+       if (!(fusbh200->enabled_hrtimer_events & BIT(FUSBH200_HRTIMER_FREE_ITDS))) {
+               fusbh200->last_itd_to_free = list_entry(
+                               fusbh200->cached_itd_list.prev,
+                               struct fusbh200_itd, itd_list);
+               fusbh200_enable_event(fusbh200, FUSBH200_HRTIMER_FREE_ITDS, true);
+       }
+}
+
+/* Wait for controller to stop using old iTDs and siTDs */
+static void end_free_itds(struct fusbh200_hcd *fusbh200)
+{
+       struct fusbh200_itd             *itd, *n;
+
+       if (fusbh200->rh_state < FUSBH200_RH_RUNNING) {
+               fusbh200->last_itd_to_free = NULL;
+       }
+
+       list_for_each_entry_safe(itd, n, &fusbh200->cached_itd_list, itd_list) {
+               list_del(&itd->itd_list);
+               dma_pool_free(fusbh200->itd_pool, itd, itd->itd_dma);
+               if (itd == fusbh200->last_itd_to_free)
+                       break;
+       }
+
+       if (!list_empty(&fusbh200->cached_itd_list))
+               start_free_itds(fusbh200);
+}
+
+
+/* Handle lost (or very late) IAA interrupts */
+static void fusbh200_iaa_watchdog(struct fusbh200_hcd *fusbh200)
+{
+       if (fusbh200->rh_state != FUSBH200_RH_RUNNING)
+               return;
+
+       /*
+        * Lost IAA irqs wedge things badly; seen first with a vt8235.
+        * So we need this watchdog, but must protect it against both
+        * (a) SMP races against real IAA firing and retriggering, and
+        * (b) clean HC shutdown, when IAA watchdog was pending.
+        */
+       if (fusbh200->async_iaa) {
+               u32 cmd, status;
+
+               /* If we get here, IAA is *REALLY* late.  It's barely
+                * conceivable that the system is so busy that CMD_IAAD
+                * is still legitimately set, so let's be sure it's
+                * clear before we read STS_IAA.  (The HC should clear
+                * CMD_IAAD when it sets STS_IAA.)
+                */
+               cmd = fusbh200_readl(fusbh200, &fusbh200->regs->command);
+
+               /*
+                * If IAA is set here it either legitimately triggered
+                * after the watchdog timer expired (_way_ late, so we'll
+                * still count it as lost) ... or a silicon erratum:
+                * - VIA seems to set IAA without triggering the IRQ;
+                * - IAAD potentially cleared without setting IAA.
+                */
+               status = fusbh200_readl(fusbh200, &fusbh200->regs->status);
+               if ((status & STS_IAA) || !(cmd & CMD_IAAD)) {
+                       COUNT(fusbh200->stats.lost_iaa);
+                       fusbh200_writel(fusbh200, STS_IAA, &fusbh200->regs->status);
+               }
+
+               fusbh200_vdbg(fusbh200, "IAA watchdog: status %x cmd %x\n",
+                               status, cmd);
+               end_unlink_async(fusbh200);
+       }
+}
+
+
+/* Enable the I/O watchdog, if appropriate */
+static void turn_on_io_watchdog(struct fusbh200_hcd *fusbh200)
+{
+       /* Not needed if the controller isn't running or it's already enabled */
+       if (fusbh200->rh_state != FUSBH200_RH_RUNNING ||
+                       (fusbh200->enabled_hrtimer_events &
+                               BIT(FUSBH200_HRTIMER_IO_WATCHDOG)))
+               return;
+
+       /*
+        * Isochronous transfers always need the watchdog.
+        * For other sorts we use it only if the flag is set.
+        */
+       if (fusbh200->isoc_count > 0 || (fusbh200->need_io_watchdog &&
+                       fusbh200->async_count + fusbh200->intr_count > 0))
+               fusbh200_enable_event(fusbh200, FUSBH200_HRTIMER_IO_WATCHDOG, true);
+}
+
+
+/*
+ * Handler functions for the hrtimer event types.
+ * Keep this array in the same order as the event types indexed by
+ * enum fusbh200_hrtimer_event in fusbh200.h.
+ */
+static void (*event_handlers[])(struct fusbh200_hcd *) = {
+       fusbh200_poll_ASS,                      /* FUSBH200_HRTIMER_POLL_ASS */
+       fusbh200_poll_PSS,                      /* FUSBH200_HRTIMER_POLL_PSS */
+       fusbh200_handle_controller_death,       /* FUSBH200_HRTIMER_POLL_DEAD */
+       fusbh200_handle_intr_unlinks,   /* FUSBH200_HRTIMER_UNLINK_INTR */
+       end_free_itds,                  /* FUSBH200_HRTIMER_FREE_ITDS */
+       unlink_empty_async,             /* FUSBH200_HRTIMER_ASYNC_UNLINKS */
+       fusbh200_iaa_watchdog,          /* FUSBH200_HRTIMER_IAA_WATCHDOG */
+       fusbh200_disable_PSE,           /* FUSBH200_HRTIMER_DISABLE_PERIODIC */
+       fusbh200_disable_ASE,           /* FUSBH200_HRTIMER_DISABLE_ASYNC */
+       fusbh200_work,                  /* FUSBH200_HRTIMER_IO_WATCHDOG */
+};
+
+static enum hrtimer_restart fusbh200_hrtimer_func(struct hrtimer *t)
+{
+       struct fusbh200_hcd     *fusbh200 = container_of(t, struct fusbh200_hcd, hrtimer);
+       ktime_t         now;
+       unsigned long   events;
+       unsigned long   flags;
+       unsigned        e;
+
+       spin_lock_irqsave(&fusbh200->lock, flags);
+
+       events = fusbh200->enabled_hrtimer_events;
+       fusbh200->enabled_hrtimer_events = 0;
+       fusbh200->next_hrtimer_event = FUSBH200_HRTIMER_NO_EVENT;
+
+       /*
+        * Check each pending event.  If its time has expired, handle
+        * the event; otherwise re-enable it.
+        */
+       now = ktime_get();
+       for_each_set_bit(e, &events, FUSBH200_HRTIMER_NUM_EVENTS) {
+               if (now.tv64 >= fusbh200->hr_timeouts[e].tv64)
+                       event_handlers[e](fusbh200);
+               else
+                       fusbh200_enable_event(fusbh200, e, false);
+       }
+
+       spin_unlock_irqrestore(&fusbh200->lock, flags);
+       return HRTIMER_NORESTART;
+}
+
+/*-------------------------------------------------------------------------*/
+
+#define fusbh200_bus_suspend   NULL
+#define fusbh200_bus_resume    NULL
+
+/*-------------------------------------------------------------------------*/
+
+static int check_reset_complete (
+       struct fusbh200_hcd     *fusbh200,
+       int             index,
+       u32 __iomem     *status_reg,
+       int             port_status
+) {
+       if (!(port_status & PORT_CONNECT))
+               return port_status;
+
+       /* if reset finished and it's still not enabled -- handoff */
+       if (!(port_status & PORT_PE)) {
+               /* with integrated TT, there's nobody to hand it to! */
+               fusbh200_dbg (fusbh200,
+                       "Failed to enable port %d on root hub TT\n",
+                       index+1);
+               return port_status;
+       } else {
+               fusbh200_dbg(fusbh200, "port %d reset complete, port enabled\n",
+                       index + 1);
+       }
+
+       return port_status;
+}
+
+/*-------------------------------------------------------------------------*/
+
+
+/* build "status change" packet (one or two bytes) from HC registers */
+
+static int
+fusbh200_hub_status_data (struct usb_hcd *hcd, char *buf)
+{
+       struct fusbh200_hcd     *fusbh200 = hcd_to_fusbh200 (hcd);
+       u32             temp, status;
+       u32             mask;
+       int             retval = 1;
+       unsigned long   flags;
+
+       /* init status to no-changes */
+       buf [0] = 0;
+
+       /* Inform the core about resumes-in-progress by returning
+        * a non-zero value even if there are no status changes.
+        */
+       status = fusbh200->resuming_ports;
+
+       mask = PORT_CSC | PORT_PEC;
+       // PORT_RESUME from hardware ~= PORT_STAT_C_SUSPEND
+
+       /* no hub change reports (bit 0) for now (power, ...) */
+
+       /* port N changes (bit N)? */
+       spin_lock_irqsave (&fusbh200->lock, flags);
+
+       temp = fusbh200_readl(fusbh200, &fusbh200->regs->port_status);
+
+       /*
+        * Return status information even for ports with OWNER set.
+        * Otherwise khubd wouldn't see the disconnect event when a
+        * high-speed device is switched over to the companion
+        * controller by the user.
+        */
+
+       if ((temp & mask) != 0 || test_bit(0, &fusbh200->port_c_suspend)
+                       || (fusbh200->reset_done[0] && time_after_eq(
+                               jiffies, fusbh200->reset_done[0]))) {
+               buf [0] |= 1 << 1;
+               status = STS_PCD;
+       }
+       /* FIXME autosuspend idle root hubs */
+       spin_unlock_irqrestore (&fusbh200->lock, flags);
+       return status ? retval : 0;
+}
+
+/*-------------------------------------------------------------------------*/
+
+static void
+fusbh200_hub_descriptor (
+       struct fusbh200_hcd             *fusbh200,
+       struct usb_hub_descriptor       *desc
+) {
+       int             ports = HCS_N_PORTS (fusbh200->hcs_params);
+       u16             temp;
+
+       desc->bDescriptorType = 0x29;
+       desc->bPwrOn2PwrGood = 10;      /* fusbh200 1.0, 2.3.9 says 20ms max */
+       desc->bHubContrCurrent = 0;
+
+       desc->bNbrPorts = ports;
+       temp = 1 + (ports / 8);
+       desc->bDescLength = 7 + 2 * temp;
+
+       /* two bitmaps:  ports removable, and usb 1.0 legacy PortPwrCtrlMask */
+       memset(&desc->u.hs.DeviceRemovable[0], 0, temp);
+       memset(&desc->u.hs.DeviceRemovable[temp], 0xff, temp);
+
+       temp = 0x0008;          /* per-port overcurrent reporting */
+       temp |= 0x0002;         /* no power switching */
+       desc->wHubCharacteristics = cpu_to_le16(temp);
+}
+
+/*-------------------------------------------------------------------------*/
+
+static int fusbh200_hub_control (
+       struct usb_hcd  *hcd,
+       u16             typeReq,
+       u16             wValue,
+       u16             wIndex,
+       char            *buf,
+       u16             wLength
+) {
+       struct fusbh200_hcd     *fusbh200 = hcd_to_fusbh200 (hcd);
+       int             ports = HCS_N_PORTS (fusbh200->hcs_params);
+       u32 __iomem     *status_reg = &fusbh200->regs->port_status;
+       u32             temp, temp1, status;
+       unsigned long   flags;
+       int             retval = 0;
+       unsigned        selector;
+
+       /*
+        * FIXME:  support SetPortFeatures USB_PORT_FEAT_INDICATOR.
+        * HCS_INDICATOR may say we can change LEDs to off/amber/green.
+        * (track current state ourselves) ... blink for diagnostics,
+        * power, "this is the one", etc.  EHCI spec supports this.
+        */
+
+       spin_lock_irqsave (&fusbh200->lock, flags);
+       switch (typeReq) {
+       case ClearHubFeature:
+               switch (wValue) {
+               case C_HUB_LOCAL_POWER:
+               case C_HUB_OVER_CURRENT:
+                       /* no hub-wide feature/status flags */
+                       break;
+               default:
+                       goto error;
+               }
+               break;
+       case ClearPortFeature:
+               if (!wIndex || wIndex > ports)
+                       goto error;
+               wIndex--;
+               temp = fusbh200_readl(fusbh200, status_reg);
+               temp &= ~PORT_RWC_BITS;
+
+               /*
+                * Even if OWNER is set, so the port is owned by the
+                * companion controller, khubd needs to be able to clear
+                * the port-change status bits (especially
+                * USB_PORT_STAT_C_CONNECTION).
+                */
+
+               switch (wValue) {
+               case USB_PORT_FEAT_ENABLE:
+                       fusbh200_writel(fusbh200, temp & ~PORT_PE, status_reg);
+                       break;
+               case USB_PORT_FEAT_C_ENABLE:
+                       fusbh200_writel(fusbh200, temp | PORT_PEC, status_reg);
+                       break;
+               case USB_PORT_FEAT_SUSPEND:
+                       if (temp & PORT_RESET)
+                               goto error;
+                       if (!(temp & PORT_SUSPEND))
+                               break;
+                       if ((temp & PORT_PE) == 0)
+                               goto error;
+
+                       /* resume signaling for 20 msec */
+                       fusbh200_writel(fusbh200, temp | PORT_RESUME, status_reg);
+                       fusbh200->reset_done[wIndex] = jiffies
+                                       + msecs_to_jiffies(20);
+                       break;
+               case USB_PORT_FEAT_C_SUSPEND:
+                       clear_bit(wIndex, &fusbh200->port_c_suspend);
+                       break;
+               case USB_PORT_FEAT_C_CONNECTION:
+                       fusbh200_writel(fusbh200, temp | PORT_CSC, status_reg);
+                       break;
+               case USB_PORT_FEAT_C_OVER_CURRENT:
+                       fusbh200_writel(fusbh200, temp | BMISR_OVC, &fusbh200->regs->bmisr);
+                       break;
+               case USB_PORT_FEAT_C_RESET:
+                       /* GetPortStatus clears reset */
+                       break;
+               default:
+                       goto error;
+               }
+               fusbh200_readl(fusbh200, &fusbh200->regs->command);     /* unblock posted write */
+               break;
+       case GetHubDescriptor:
+               fusbh200_hub_descriptor (fusbh200, (struct usb_hub_descriptor *)
+                       buf);
+               break;
+       case GetHubStatus:
+               /* no hub-wide feature/status flags */
+               memset (buf, 0, 4);
+               //cpu_to_le32s ((u32 *) buf);
+               break;
+       case GetPortStatus:
+               if (!wIndex || wIndex > ports)
+                       goto error;
+               wIndex--;
+               status = 0;
+               temp = fusbh200_readl(fusbh200, status_reg);
+
+               // wPortChange bits
+               if (temp & PORT_CSC)
+                       status |= USB_PORT_STAT_C_CONNECTION << 16;
+               if (temp & PORT_PEC)
+                       status |= USB_PORT_STAT_C_ENABLE << 16;
+
+               temp1 = fusbh200_readl(fusbh200, &fusbh200->regs->bmisr);
+               if (temp1 & BMISR_OVC)
+                       status |= USB_PORT_STAT_C_OVERCURRENT << 16;
+
+               /* whoever resumes must GetPortStatus to complete it!! */
+               if (temp & PORT_RESUME) {
+
+                       /* Remote Wakeup received? */
+                       if (!fusbh200->reset_done[wIndex]) {
+                               /* resume signaling for 20 msec */
+                               fusbh200->reset_done[wIndex] = jiffies
+                                               + msecs_to_jiffies(20);
+                               /* check the port again */
+                               mod_timer(&fusbh200_to_hcd(fusbh200)->rh_timer,
+                                               fusbh200->reset_done[wIndex]);
+                       }
+
+                       /* resume completed? */
+                       else if (time_after_eq(jiffies,
+                                       fusbh200->reset_done[wIndex])) {
+                               clear_bit(wIndex, &fusbh200->suspended_ports);
+                               set_bit(wIndex, &fusbh200->port_c_suspend);
+                               fusbh200->reset_done[wIndex] = 0;
+
+                               /* stop resume signaling */
+                               temp = fusbh200_readl(fusbh200, status_reg);
+                               fusbh200_writel(fusbh200,
+                                       temp & ~(PORT_RWC_BITS | PORT_RESUME),
+                                       status_reg);
+                               clear_bit(wIndex, &fusbh200->resuming_ports);
+                               retval = handshake(fusbh200, status_reg,
+                                          PORT_RESUME, 0, 2000 /* 2msec */);
+                               if (retval != 0) {
+                                       fusbh200_err(fusbh200,
+                                               "port %d resume error %d\n",
+                                               wIndex + 1, retval);
+                                       goto error;
+                               }
+                               temp &= ~(PORT_SUSPEND|PORT_RESUME|(3<<10));
+                       }
+               }
+
+               /* whoever resets must GetPortStatus to complete it!! */
+               if ((temp & PORT_RESET)
+                               && time_after_eq(jiffies,
+                                       fusbh200->reset_done[wIndex])) {
+                       status |= USB_PORT_STAT_C_RESET << 16;
+                       fusbh200->reset_done [wIndex] = 0;
+                       clear_bit(wIndex, &fusbh200->resuming_ports);
+
+                       /* force reset to complete */
+                       fusbh200_writel(fusbh200, temp & ~(PORT_RWC_BITS | PORT_RESET),
+                                       status_reg);
+                       /* REVISIT:  some hardware needs 550+ usec to clear
+                        * this bit; seems too long to spin routinely...
+                        */
+                       retval = handshake(fusbh200, status_reg,
+                                       PORT_RESET, 0, 1000);
+                       if (retval != 0) {
+                               fusbh200_err (fusbh200, "port %d reset error %d\n",
+                                       wIndex + 1, retval);
+                               goto error;
+                       }
+
+                       /* see what we found out */
+                       temp = check_reset_complete (fusbh200, wIndex, status_reg,
+                                       fusbh200_readl(fusbh200, status_reg));
+               }
+
+               if (!(temp & (PORT_RESUME|PORT_RESET))) {
+                       fusbh200->reset_done[wIndex] = 0;
+                       clear_bit(wIndex, &fusbh200->resuming_ports);
+               }
+
+               /* transfer dedicated ports to the companion hc */
+               if ((temp & PORT_CONNECT) &&
+                               test_bit(wIndex, &fusbh200->companion_ports)) {
+                       temp &= ~PORT_RWC_BITS;
+                       fusbh200_writel(fusbh200, temp, status_reg);
+                       fusbh200_dbg(fusbh200, "port %d --> companion\n", wIndex + 1);
+                       temp = fusbh200_readl(fusbh200, status_reg);
+               }
+
+               /*
+                * Even if OWNER is set, there's no harm letting khubd
+                * see the wPortStatus values (they should all be 0 except
+                * for PORT_POWER anyway).
+                */
+
+               if (temp & PORT_CONNECT) {
+                       status |= USB_PORT_STAT_CONNECTION;
+                       status |= fusbh200_port_speed(fusbh200, temp);
+               }
+               if (temp & PORT_PE)
+                       status |= USB_PORT_STAT_ENABLE;
+
+               /* maybe the port was unsuspended without our knowledge */
+               if (temp & (PORT_SUSPEND|PORT_RESUME)) {
+                       status |= USB_PORT_STAT_SUSPEND;
+               } else if (test_bit(wIndex, &fusbh200->suspended_ports)) {
+                       clear_bit(wIndex, &fusbh200->suspended_ports);
+                       clear_bit(wIndex, &fusbh200->resuming_ports);
+                       fusbh200->reset_done[wIndex] = 0;
+                       if (temp & PORT_PE)
+                               set_bit(wIndex, &fusbh200->port_c_suspend);
+               }
+
+               temp1 = fusbh200_readl(fusbh200, &fusbh200->regs->bmisr);
+               if (temp1 & BMISR_OVC)
+                       status |= USB_PORT_STAT_OVERCURRENT;
+               if (temp & PORT_RESET)
+                       status |= USB_PORT_STAT_RESET;
+               if (test_bit(wIndex, &fusbh200->port_c_suspend))
+                       status |= USB_PORT_STAT_C_SUSPEND << 16;
+
+#ifndef        VERBOSE_DEBUG
+       if (status & ~0xffff)   /* only if wPortChange is interesting */
+#endif
+               dbg_port (fusbh200, "GetStatus", wIndex + 1, temp);
+               put_unaligned_le32(status, buf);
+               break;
+       case SetHubFeature:
+               switch (wValue) {
+               case C_HUB_LOCAL_POWER:
+               case C_HUB_OVER_CURRENT:
+                       /* no hub-wide feature/status flags */
+                       break;
+               default:
+                       goto error;
+               }
+               break;
+       case SetPortFeature:
+               selector = wIndex >> 8;
+               wIndex &= 0xff;
+
+               if (!wIndex || wIndex > ports)
+                       goto error;
+               wIndex--;
+               temp = fusbh200_readl(fusbh200, status_reg);
+               temp &= ~PORT_RWC_BITS;
+               switch (wValue) {
+               case USB_PORT_FEAT_SUSPEND:
+                       if ((temp & PORT_PE) == 0
+                                       || (temp & PORT_RESET) != 0)
+                               goto error;
+
+                       /* After above check the port must be connected.
+                        * Set appropriate bit thus could put phy into low power
+                        * mode if we have hostpc feature
+                        */
+                       fusbh200_writel(fusbh200, temp | PORT_SUSPEND, status_reg);
+                       set_bit(wIndex, &fusbh200->suspended_ports);
+                       break;
+               case USB_PORT_FEAT_RESET:
+                       if (temp & PORT_RESUME)
+                               goto error;
+                       /* line status bits may report this as low speed,
+                        * which can be fine if this root hub has a
+                        * transaction translator built in.
+                        */
+                       fusbh200_vdbg (fusbh200, "port %d reset\n", wIndex + 1);
+                       temp |= PORT_RESET;
+                       temp &= ~PORT_PE;
+
+                       /*
+                        * caller must wait, then call GetPortStatus
+                        * usb 2.0 spec says 50 ms resets on root
+                        */
+                       fusbh200->reset_done [wIndex] = jiffies
+                                       + msecs_to_jiffies (50);
+                       fusbh200_writel(fusbh200, temp, status_reg);
+                       break;
+
+               /* For downstream facing ports (these):  one hub port is put
+                * into test mode according to USB2 11.24.2.13, then the hub
+                * must be reset (which for root hub now means rmmod+modprobe,
+                * or else system reboot).  See EHCI 2.3.9 and 4.14 for info
+                * about the EHCI-specific stuff.
+                */
+               case USB_PORT_FEAT_TEST:
+                       if (!selector || selector > 5)
+                               goto error;
+                       spin_unlock_irqrestore(&fusbh200->lock, flags);
+                       fusbh200_quiesce(fusbh200);
+                       spin_lock_irqsave(&fusbh200->lock, flags);
+
+                       /* Put all enabled ports into suspend */
+                       temp = fusbh200_readl(fusbh200, status_reg) & ~PORT_RWC_BITS;
+                       if (temp & PORT_PE)
+                               fusbh200_writel(fusbh200, temp | PORT_SUSPEND,
+                                               status_reg);
+
+                       spin_unlock_irqrestore(&fusbh200->lock, flags);
+                       fusbh200_halt(fusbh200);
+                       spin_lock_irqsave(&fusbh200->lock, flags);
+
+                       temp = fusbh200_readl(fusbh200, status_reg);
+                       temp |= selector << 16;
+                       fusbh200_writel(fusbh200, temp, status_reg);
+                       break;
+
+               default:
+                       goto error;
+               }
+               fusbh200_readl(fusbh200, &fusbh200->regs->command);     /* unblock posted writes */
+               break;
+
+       default:
+error:
+               /* "stall" on error */
+               retval = -EPIPE;
+       }
+       spin_unlock_irqrestore (&fusbh200->lock, flags);
+       return retval;
+}
+
+static void __maybe_unused fusbh200_relinquish_port(struct usb_hcd *hcd,
+               int portnum)
+{
+       return;
+}
+
+static int __maybe_unused fusbh200_port_handed_over(struct usb_hcd *hcd,
+               int portnum)
+{
+       return 0;
+}
+/*-------------------------------------------------------------------------*/
+/*
+ * There's basically three types of memory:
+ *     - data used only by the HCD ... kmalloc is fine
+ *     - async and periodic schedules, shared by HC and HCD ... these
+ *       need to use dma_pool or dma_alloc_coherent
+ *     - driver buffers, read/written by HC ... single shot DMA mapped
+ *
+ * There's also "register" data (e.g. PCI or SOC), which is memory mapped.
+ * No memory seen by this driver is pageable.
+ */
+
+/*-------------------------------------------------------------------------*/
+
+/* Allocate the key transfer structures from the previously allocated pool */
+
+static inline void fusbh200_qtd_init(struct fusbh200_hcd *fusbh200, struct fusbh200_qtd *qtd,
+                                 dma_addr_t dma)
+{
+       memset (qtd, 0, sizeof *qtd);
+       qtd->qtd_dma = dma;
+       qtd->hw_token = cpu_to_hc32(fusbh200, QTD_STS_HALT);
+       qtd->hw_next = FUSBH200_LIST_END(fusbh200);
+       qtd->hw_alt_next = FUSBH200_LIST_END(fusbh200);
+       INIT_LIST_HEAD (&qtd->qtd_list);
+}
+
+static struct fusbh200_qtd *fusbh200_qtd_alloc (struct fusbh200_hcd *fusbh200, gfp_t flags)
+{
+       struct fusbh200_qtd             *qtd;
+       dma_addr_t              dma;
+
+       qtd = dma_pool_alloc (fusbh200->qtd_pool, flags, &dma);
+       if (qtd != NULL) {
+               fusbh200_qtd_init(fusbh200, qtd, dma);
+       }
+       return qtd;
+}
+
+static inline void fusbh200_qtd_free (struct fusbh200_hcd *fusbh200, struct fusbh200_qtd *qtd)
+{
+       dma_pool_free (fusbh200->qtd_pool, qtd, qtd->qtd_dma);
+}
+
+
+static void qh_destroy(struct fusbh200_hcd *fusbh200, struct fusbh200_qh *qh)
+{
+       /* clean qtds first, and know this is not linked */
+       if (!list_empty (&qh->qtd_list) || qh->qh_next.ptr) {
+               fusbh200_dbg (fusbh200, "unused qh not empty!\n");
+               BUG ();
+       }
+       if (qh->dummy)
+               fusbh200_qtd_free (fusbh200, qh->dummy);
+       dma_pool_free(fusbh200->qh_pool, qh->hw, qh->qh_dma);
+       kfree(qh);
+}
+
+static struct fusbh200_qh *fusbh200_qh_alloc (struct fusbh200_hcd *fusbh200, gfp_t flags)
+{
+       struct fusbh200_qh              *qh;
+       dma_addr_t              dma;
+
+       qh = kzalloc(sizeof *qh, GFP_ATOMIC);
+       if (!qh)
+               goto done;
+       qh->hw = (struct fusbh200_qh_hw *)
+               dma_pool_alloc(fusbh200->qh_pool, flags, &dma);
+       if (!qh->hw)
+               goto fail;
+       memset(qh->hw, 0, sizeof *qh->hw);
+       qh->qh_dma = dma;
+       // INIT_LIST_HEAD (&qh->qh_list);
+       INIT_LIST_HEAD (&qh->qtd_list);
+
+       /* dummy td enables safe urb queuing */
+       qh->dummy = fusbh200_qtd_alloc (fusbh200, flags);
+       if (qh->dummy == NULL) {
+               fusbh200_dbg (fusbh200, "no dummy td\n");
+               goto fail1;
+       }
+done:
+       return qh;
+fail1:
+       dma_pool_free(fusbh200->qh_pool, qh->hw, qh->qh_dma);
+fail:
+       kfree(qh);
+       return NULL;
+}
+
+/*-------------------------------------------------------------------------*/
+
+/* The queue heads and transfer descriptors are managed from pools tied
+ * to each of the "per device" structures.
+ * This is the initialisation and cleanup code.
+ */
+
+static void fusbh200_mem_cleanup (struct fusbh200_hcd *fusbh200)
+{
+       if (fusbh200->async)
+               qh_destroy(fusbh200, fusbh200->async);
+       fusbh200->async = NULL;
+
+       if (fusbh200->dummy)
+               qh_destroy(fusbh200, fusbh200->dummy);
+       fusbh200->dummy = NULL;
+
+       /* DMA consistent memory and pools */
+       if (fusbh200->qtd_pool)
+               dma_pool_destroy (fusbh200->qtd_pool);
+       fusbh200->qtd_pool = NULL;
+
+       if (fusbh200->qh_pool) {
+               dma_pool_destroy (fusbh200->qh_pool);
+               fusbh200->qh_pool = NULL;
+       }
+
+       if (fusbh200->itd_pool)
+               dma_pool_destroy (fusbh200->itd_pool);
+       fusbh200->itd_pool = NULL;
+
+       if (fusbh200->periodic)
+               dma_free_coherent (fusbh200_to_hcd(fusbh200)->self.controller,
+                       fusbh200->periodic_size * sizeof (u32),
+                       fusbh200->periodic, fusbh200->periodic_dma);
+       fusbh200->periodic = NULL;
+
+       /* shadow periodic table */
+       kfree(fusbh200->pshadow);
+       fusbh200->pshadow = NULL;
+}
+
+/* remember to add cleanup code (above) if you add anything here */
+static int fusbh200_mem_init (struct fusbh200_hcd *fusbh200, gfp_t flags)
+{
+       int i;
+
+       /* QTDs for control/bulk/intr transfers */
+       fusbh200->qtd_pool = dma_pool_create ("fusbh200_qtd",
+                       fusbh200_to_hcd(fusbh200)->self.controller,
+                       sizeof (struct fusbh200_qtd),
+                       32 /* byte alignment (for hw parts) */,
+                       4096 /* can't cross 4K */);
+       if (!fusbh200->qtd_pool) {
+               goto fail;
+       }
+
+       /* QHs for control/bulk/intr transfers */
+       fusbh200->qh_pool = dma_pool_create ("fusbh200_qh",
+                       fusbh200_to_hcd(fusbh200)->self.controller,
+                       sizeof(struct fusbh200_qh_hw),
+                       32 /* byte alignment (for hw parts) */,
+                       4096 /* can't cross 4K */);
+       if (!fusbh200->qh_pool) {
+               goto fail;
+       }
+       fusbh200->async = fusbh200_qh_alloc (fusbh200, flags);
+       if (!fusbh200->async) {
+               goto fail;
+       }
+
+       /* ITD for high speed ISO transfers */
+       fusbh200->itd_pool = dma_pool_create ("fusbh200_itd",
+                       fusbh200_to_hcd(fusbh200)->self.controller,
+                       sizeof (struct fusbh200_itd),
+                       64 /* byte alignment (for hw parts) */,
+                       4096 /* can't cross 4K */);
+       if (!fusbh200->itd_pool) {
+               goto fail;
+       }
+
+       /* Hardware periodic table */
+       fusbh200->periodic = (__le32 *)
+               dma_alloc_coherent (fusbh200_to_hcd(fusbh200)->self.controller,
+                       fusbh200->periodic_size * sizeof(__le32),
+                       &fusbh200->periodic_dma, 0);
+       if (fusbh200->periodic == NULL) {
+               goto fail;
+       }
+
+               for (i = 0; i < fusbh200->periodic_size; i++)
+                       fusbh200->periodic[i] = FUSBH200_LIST_END(fusbh200);
+
+       /* software shadow of hardware table */
+       fusbh200->pshadow = kcalloc(fusbh200->periodic_size, sizeof(void *), flags);
+       if (fusbh200->pshadow != NULL)
+               return 0;
+
+fail:
+       fusbh200_dbg (fusbh200, "couldn't init memory\n");
+       fusbh200_mem_cleanup (fusbh200);
+       return -ENOMEM;
+}
+/*-------------------------------------------------------------------------*/
+/*
+ * EHCI hardware queue manipulation ... the core.  QH/QTD manipulation.
+ *
+ * Control, bulk, and interrupt traffic all use "qh" lists.  They list "qtd"
+ * entries describing USB transactions, max 16-20kB/entry (with 4kB-aligned
+ * buffers needed for the larger number).  We use one QH per endpoint, queue
+ * multiple urbs (all three types) per endpoint.  URBs may need several qtds.
+ *
+ * ISO traffic uses "ISO TD" (itd) records, and (along with
+ * interrupts) needs careful scheduling.  Performance improvements can be
+ * an ongoing challenge.  That's in "ehci-sched.c".
+ *
+ * USB 1.1 devices are handled (a) by "companion" OHCI or UHCI root hubs,
+ * or otherwise through transaction translators (TTs) in USB 2.0 hubs using
+ * (b) special fields in qh entries or (c) split iso entries.  TTs will
+ * buffer low/full speed data so the host collects it at high speed.
+ */
+
+/*-------------------------------------------------------------------------*/
+
+/* fill a qtd, returning how much of the buffer we were able to queue up */
+
+static int
+qtd_fill(struct fusbh200_hcd *fusbh200, struct fusbh200_qtd *qtd, dma_addr_t buf,
+                 size_t len, int token, int maxpacket)
+{
+       int     i, count;
+       u64     addr = buf;
+
+       /* one buffer entry per 4K ... first might be short or unaligned */
+       qtd->hw_buf[0] = cpu_to_hc32(fusbh200, (u32)addr);
+       qtd->hw_buf_hi[0] = cpu_to_hc32(fusbh200, (u32)(addr >> 32));
+       count = 0x1000 - (buf & 0x0fff);        /* rest of that page */
+       if (likely (len < count))               /* ... iff needed */
+               count = len;
+       else {
+               buf +=  0x1000;
+               buf &= ~0x0fff;
+
+               /* per-qtd limit: from 16K to 20K (best alignment) */
+               for (i = 1; count < len && i < 5; i++) {
+                       addr = buf;
+                       qtd->hw_buf[i] = cpu_to_hc32(fusbh200, (u32)addr);
+                       qtd->hw_buf_hi[i] = cpu_to_hc32(fusbh200,
+                                       (u32)(addr >> 32));
+                       buf += 0x1000;
+                       if ((count + 0x1000) < len)
+                               count += 0x1000;
+                       else
+                               count = len;
+               }
+
+               /* short packets may only terminate transfers */
+               if (count != len)
+                       count -= (count % maxpacket);
+       }
+       qtd->hw_token = cpu_to_hc32(fusbh200, (count << 16) | token);
+       qtd->length = count;
+
+       return count;
+}
+
+/*-------------------------------------------------------------------------*/
+
+static inline void
+qh_update (struct fusbh200_hcd *fusbh200, struct fusbh200_qh *qh, struct fusbh200_qtd *qtd)
+{
+       struct fusbh200_qh_hw *hw = qh->hw;
+
+       /* writes to an active overlay are unsafe */
+       BUG_ON(qh->qh_state != QH_STATE_IDLE);
+
+       hw->hw_qtd_next = QTD_NEXT(fusbh200, qtd->qtd_dma);
+       hw->hw_alt_next = FUSBH200_LIST_END(fusbh200);
+
+       /* Except for control endpoints, we make hardware maintain data
+        * toggle (like OHCI) ... here (re)initialize the toggle in the QH,
+        * and set the pseudo-toggle in udev. Only usb_clear_halt() will
+        * ever clear it.
+        */
+       if (!(hw->hw_info1 & cpu_to_hc32(fusbh200, QH_TOGGLE_CTL))) {
+               unsigned        is_out, epnum;
+
+               is_out = qh->is_out;
+               epnum = (hc32_to_cpup(fusbh200, &hw->hw_info1) >> 8) & 0x0f;
+               if (unlikely (!usb_gettoggle (qh->dev, epnum, is_out))) {
+                       hw->hw_token &= ~cpu_to_hc32(fusbh200, QTD_TOGGLE);
+                       usb_settoggle (qh->dev, epnum, is_out, 1);
+               }
+       }
+
+       hw->hw_token &= cpu_to_hc32(fusbh200, QTD_TOGGLE | QTD_STS_PING);
+}
+
+/* if it weren't for a common silicon quirk (writing the dummy into the qh
+ * overlay, so qh->hw_token wrongly becomes inactive/halted), only fault
+ * recovery (including urb dequeue) would need software changes to a QH...
+ */
+static void
+qh_refresh (struct fusbh200_hcd *fusbh200, struct fusbh200_qh *qh)
+{
+       struct fusbh200_qtd *qtd;
+
+       if (list_empty (&qh->qtd_list))
+               qtd = qh->dummy;
+       else {
+               qtd = list_entry (qh->qtd_list.next,
+                               struct fusbh200_qtd, qtd_list);
+               /*
+                * first qtd may already be partially processed.
+                * If we come here during unlink, the QH overlay region
+                * might have reference to the just unlinked qtd. The
+                * qtd is updated in qh_completions(). Update the QH
+                * overlay here.
+                */
+               if (cpu_to_hc32(fusbh200, qtd->qtd_dma) == qh->hw->hw_current) {
+                       qh->hw->hw_qtd_next = qtd->hw_next;
+                       qtd = NULL;
+               }
+       }
+
+       if (qtd)
+               qh_update (fusbh200, qh, qtd);
+}
+
+/*-------------------------------------------------------------------------*/
+
+static void qh_link_async(struct fusbh200_hcd *fusbh200, struct fusbh200_qh *qh);
+
+static void fusbh200_clear_tt_buffer_complete(struct usb_hcd *hcd,
+               struct usb_host_endpoint *ep)
+{
+       struct fusbh200_hcd             *fusbh200 = hcd_to_fusbh200(hcd);
+       struct fusbh200_qh              *qh = ep->hcpriv;
+       unsigned long           flags;
+
+       spin_lock_irqsave(&fusbh200->lock, flags);
+       qh->clearing_tt = 0;
+       if (qh->qh_state == QH_STATE_IDLE && !list_empty(&qh->qtd_list)
+                       && fusbh200->rh_state == FUSBH200_RH_RUNNING)
+               qh_link_async(fusbh200, qh);
+       spin_unlock_irqrestore(&fusbh200->lock, flags);
+}
+
+static void fusbh200_clear_tt_buffer(struct fusbh200_hcd *fusbh200, struct fusbh200_qh *qh,
+               struct urb *urb, u32 token)
+{
+
+       /* If an async split transaction gets an error or is unlinked,
+        * the TT buffer may be left in an indeterminate state.  We
+        * have to clear the TT buffer.
+        *
+        * Note: this routine is never called for Isochronous transfers.
+        */
+       if (urb->dev->tt && !usb_pipeint(urb->pipe) && !qh->clearing_tt) {
+#ifdef DEBUG
+               struct usb_device *tt = urb->dev->tt->hub;
+               dev_dbg(&tt->dev,
+                       "clear tt buffer port %d, a%d ep%d t%08x\n",
+                       urb->dev->ttport, urb->dev->devnum,
+                       usb_pipeendpoint(urb->pipe), token);
+#endif /* DEBUG */
+               if (urb->dev->tt->hub !=
+                   fusbh200_to_hcd(fusbh200)->self.root_hub) {
+                       if (usb_hub_clear_tt_buffer(urb) == 0)
+                               qh->clearing_tt = 1;
+               }
+       }
+}
+
+static int qtd_copy_status (
+       struct fusbh200_hcd *fusbh200,
+       struct urb *urb,
+       size_t length,
+       u32 token
+)
+{
+       int     status = -EINPROGRESS;
+
+       /* count IN/OUT bytes, not SETUP (even short packets) */
+       if (likely (QTD_PID (token) != 2))
+               urb->actual_length += length - QTD_LENGTH (token);
+
+       /* don't modify error codes */
+       if (unlikely(urb->unlinked))
+               return status;
+
+       /* force cleanup after short read; not always an error */
+       if (unlikely (IS_SHORT_READ (token)))
+               status = -EREMOTEIO;
+
+       /* serious "can't proceed" faults reported by the hardware */
+       if (token & QTD_STS_HALT) {
+               if (token & QTD_STS_BABBLE) {
+                       /* FIXME "must" disable babbling device's port too */
+                       status = -EOVERFLOW;
+               /* CERR nonzero + halt --> stall */
+               } else if (QTD_CERR(token)) {
+                       status = -EPIPE;
+
+               /* In theory, more than one of the following bits can be set
+                * since they are sticky and the transaction is retried.
+                * Which to test first is rather arbitrary.
+                */
+               } else if (token & QTD_STS_MMF) {
+                       /* fs/ls interrupt xfer missed the complete-split */
+                       status = -EPROTO;
+               } else if (token & QTD_STS_DBE) {
+                       status = (QTD_PID (token) == 1) /* IN ? */
+                               ? -ENOSR  /* hc couldn't read data */
+                               : -ECOMM; /* hc couldn't write data */
+               } else if (token & QTD_STS_XACT) {
+                       /* timeout, bad CRC, wrong PID, etc */
+                       fusbh200_dbg(fusbh200, "devpath %s ep%d%s 3strikes\n",
+                               urb->dev->devpath,
+                               usb_pipeendpoint(urb->pipe),
+                               usb_pipein(urb->pipe) ? "in" : "out");
+                       status = -EPROTO;
+               } else {        /* unknown */
+                       status = -EPROTO;
+               }
+
+               fusbh200_vdbg (fusbh200,
+                       "dev%d ep%d%s qtd token %08x --> status %d\n",
+                       usb_pipedevice (urb->pipe),
+                       usb_pipeendpoint (urb->pipe),
+                       usb_pipein (urb->pipe) ? "in" : "out",
+                       token, status);
+       }
+
+       return status;
+}
+
+static void
+fusbh200_urb_done(struct fusbh200_hcd *fusbh200, struct urb *urb, int status)
+__releases(fusbh200->lock)
+__acquires(fusbh200->lock)
+{
+       if (likely (urb->hcpriv != NULL)) {
+               struct fusbh200_qh      *qh = (struct fusbh200_qh *) urb->hcpriv;
+
+               /* S-mask in a QH means it's an interrupt urb */
+               if ((qh->hw->hw_info2 & cpu_to_hc32(fusbh200, QH_SMASK)) != 0) {
+
+                       /* ... update hc-wide periodic stats (for usbfs) */
+                       fusbh200_to_hcd(fusbh200)->self.bandwidth_int_reqs--;
+               }
+       }
+
+       if (unlikely(urb->unlinked)) {
+               COUNT(fusbh200->stats.unlink);
+       } else {
+               /* report non-error and short read status as zero */
+               if (status == -EINPROGRESS || status == -EREMOTEIO)
+                       status = 0;
+               COUNT(fusbh200->stats.complete);
+       }
+
+#ifdef FUSBH200_URB_TRACE
+       fusbh200_dbg (fusbh200,
+               "%s %s urb %p ep%d%s status %d len %d/%d\n",
+               __func__, urb->dev->devpath, urb,
+               usb_pipeendpoint (urb->pipe),
+               usb_pipein (urb->pipe) ? "in" : "out",
+               status,
+               urb->actual_length, urb->transfer_buffer_length);
+#endif
+
+       /* complete() can reenter this HCD */
+       usb_hcd_unlink_urb_from_ep(fusbh200_to_hcd(fusbh200), urb);
+       spin_unlock (&fusbh200->lock);
+       usb_hcd_giveback_urb(fusbh200_to_hcd(fusbh200), urb, status);
+       spin_lock (&fusbh200->lock);
+}
+
+static int qh_schedule (struct fusbh200_hcd *fusbh200, struct fusbh200_qh *qh);
+
+/*
+ * Process and free completed qtds for a qh, returning URBs to drivers.
+ * Chases up to qh->hw_current.  Returns number of completions called,
+ * indicating how much "real" work we did.
+ */
+static unsigned
+qh_completions (struct fusbh200_hcd *fusbh200, struct fusbh200_qh *qh)
+{
+       struct fusbh200_qtd             *last, *end = qh->dummy;
+       struct list_head        *entry, *tmp;
+       int                     last_status;
+       int                     stopped;
+       unsigned                count = 0;
+       u8                      state;
+       struct fusbh200_qh_hw   *hw = qh->hw;
+
+       if (unlikely (list_empty (&qh->qtd_list)))
+               return count;
+
+       /* completions (or tasks on other cpus) must never clobber HALT
+        * till we've gone through and cleaned everything up, even when
+        * they add urbs to this qh's queue or mark them for unlinking.
+        *
+        * NOTE:  unlinking expects to be done in queue order.
+        *
+        * It's a bug for qh->qh_state to be anything other than
+        * QH_STATE_IDLE, unless our caller is scan_async() or
+        * scan_intr().
+        */
+       state = qh->qh_state;
+       qh->qh_state = QH_STATE_COMPLETING;
+       stopped = (state == QH_STATE_IDLE);
+
+ rescan:
+       last = NULL;
+       last_status = -EINPROGRESS;
+       qh->needs_rescan = 0;
+
+       /* remove de-activated QTDs from front of queue.
+        * after faults (including short reads), cleanup this urb
+        * then let the queue advance.
+        * if queue is stopped, handles unlinks.
+        */
+       list_for_each_safe (entry, tmp, &qh->qtd_list) {
+               struct fusbh200_qtd     *qtd;
+               struct urb      *urb;
+               u32             token = 0;
+
+               qtd = list_entry (entry, struct fusbh200_qtd, qtd_list);
+               urb = qtd->urb;
+
+               /* clean up any state from previous QTD ...*/
+               if (last) {
+                       if (likely (last->urb != urb)) {
+                               fusbh200_urb_done(fusbh200, last->urb, last_status);
+                               count++;
+                               last_status = -EINPROGRESS;
+                       }
+                       fusbh200_qtd_free (fusbh200, last);
+                       last = NULL;
+               }
+
+               /* ignore urbs submitted during completions we reported */
+               if (qtd == end)
+                       break;
+
+               /* hardware copies qtd out of qh overlay */
+               rmb ();
+               token = hc32_to_cpu(fusbh200, qtd->hw_token);
+
+               /* always clean up qtds the hc de-activated */
+ retry_xacterr:
+               if ((token & QTD_STS_ACTIVE) == 0) {
+
+                       /* Report Data Buffer Error: non-fatal but useful */
+                       if (token & QTD_STS_DBE)
+                               fusbh200_dbg(fusbh200,
+                                       "detected DataBufferErr for urb %p ep%d%s len %d, qtd %p [qh %p]\n",
+                                       urb,
+                                       usb_endpoint_num(&urb->ep->desc),
+                                       usb_endpoint_dir_in(&urb->ep->desc) ? "in" : "out",
+                                       urb->transfer_buffer_length,
+                                       qtd,
+                                       qh);
+
+                       /* on STALL, error, and short reads this urb must
+                        * complete and all its qtds must be recycled.
+                        */
+                       if ((token & QTD_STS_HALT) != 0) {
+
+                               /* retry transaction errors until we
+                                * reach the software xacterr limit
+                                */
+                               if ((token & QTD_STS_XACT) &&
+                                               QTD_CERR(token) == 0 &&
+                                               ++qh->xacterrs < QH_XACTERR_MAX &&
+                                               !urb->unlinked) {
+                                       fusbh200_dbg(fusbh200,
+       "detected XactErr len %zu/%zu retry %d\n",
+       qtd->length - QTD_LENGTH(token), qtd->length, qh->xacterrs);
+
+                                       /* reset the token in the qtd and the
+                                        * qh overlay (which still contains
+                                        * the qtd) so that we pick up from
+                                        * where we left off
+                                        */
+                                       token &= ~QTD_STS_HALT;
+                                       token |= QTD_STS_ACTIVE |
+                                                       (FUSBH200_TUNE_CERR << 10);
+                                       qtd->hw_token = cpu_to_hc32(fusbh200,
+                                                       token);
+                                       wmb();
+                                       hw->hw_token = cpu_to_hc32(fusbh200,
+                                                       token);
+                                       goto retry_xacterr;
+                               }
+                               stopped = 1;
+
+                       /* magic dummy for some short reads; qh won't advance.
+                        * that silicon quirk can kick in with this dummy too.
+                        *
+                        * other short reads won't stop the queue, including
+                        * control transfers (status stage handles that) or
+                        * most other single-qtd reads ... the queue stops if
+                        * URB_SHORT_NOT_OK was set so the driver submitting
+                        * the urbs could clean it up.
+                        */
+                       } else if (IS_SHORT_READ (token)
+                                       && !(qtd->hw_alt_next
+                                               & FUSBH200_LIST_END(fusbh200))) {
+                               stopped = 1;
+                       }
+
+               /* stop scanning when we reach qtds the hc is using */
+               } else if (likely (!stopped
+                               && fusbh200->rh_state >= FUSBH200_RH_RUNNING)) {
+                       break;
+
+               /* scan the whole queue for unlinks whenever it stops */
+               } else {
+                       stopped = 1;
+
+                       /* cancel everything if we halt, suspend, etc */
+                       if (fusbh200->rh_state < FUSBH200_RH_RUNNING)
+                               last_status = -ESHUTDOWN;
+
+                       /* this qtd is active; skip it unless a previous qtd
+                        * for its urb faulted, or its urb was canceled.
+                        */
+                       else if (last_status == -EINPROGRESS && !urb->unlinked)
+                               continue;
+
+                       /* qh unlinked; token in overlay may be most current */
+                       if (state == QH_STATE_IDLE
+                                       && cpu_to_hc32(fusbh200, qtd->qtd_dma)
+                                               == hw->hw_current) {
+                               token = hc32_to_cpu(fusbh200, hw->hw_token);
+
+                               /* An unlink may leave an incomplete
+                                * async transaction in the TT buffer.
+                                * We have to clear it.
+                                */
+                               fusbh200_clear_tt_buffer(fusbh200, qh, urb, token);
+                       }
+               }
+
+               /* unless we already know the urb's status, collect qtd status
+                * and update count of bytes transferred.  in common short read
+                * cases with only one data qtd (including control transfers),
+                * queue processing won't halt.  but with two or more qtds (for
+                * example, with a 32 KB transfer), when the first qtd gets a
+                * short read the second must be removed by hand.
+                */
+               if (last_status == -EINPROGRESS) {
+                       last_status = qtd_copy_status(fusbh200, urb,
+                                       qtd->length, token);
+                       if (last_status == -EREMOTEIO
+                                       && (qtd->hw_alt_next
+                                               & FUSBH200_LIST_END(fusbh200)))
+                               last_status = -EINPROGRESS;
+
+                       /* As part of low/full-speed endpoint-halt processing
+                        * we must clear the TT buffer (11.17.5).
+                        */
+                       if (unlikely(last_status != -EINPROGRESS &&
+                                       last_status != -EREMOTEIO)) {
+                               /* The TT's in some hubs malfunction when they
+                                * receive this request following a STALL (they
+                                * stop sending isochronous packets).  Since a
+                                * STALL can't leave the TT buffer in a busy
+                                * state (if you believe Figures 11-48 - 11-51
+                                * in the USB 2.0 spec), we won't clear the TT
+                                * buffer in this case.  Strictly speaking this
+                                * is a violation of the spec.
+                                */
+                               if (last_status != -EPIPE)
+                                       fusbh200_clear_tt_buffer(fusbh200, qh, urb,
+                                                       token);
+                       }
+               }
+
+               /* if we're removing something not at the queue head,
+                * patch the hardware queue pointer.
+                */
+               if (stopped && qtd->qtd_list.prev != &qh->qtd_list) {
+                       last = list_entry (qtd->qtd_list.prev,
+                                       struct fusbh200_qtd, qtd_list);
+                       last->hw_next = qtd->hw_next;
+               }
+
+               /* remove qtd; it's recycled after possible urb completion */
+               list_del (&qtd->qtd_list);
+               last = qtd;
+
+               /* reinit the xacterr counter for the next qtd */
+               qh->xacterrs = 0;
+       }
+
+       /* last urb's completion might still need calling */
+       if (likely (last != NULL)) {
+               fusbh200_urb_done(fusbh200, last->urb, last_status);
+               count++;
+               fusbh200_qtd_free (fusbh200, last);
+       }
+
+       /* Do we need to rescan for URBs dequeued during a giveback? */
+       if (unlikely(qh->needs_rescan)) {
+               /* If the QH is already unlinked, do the rescan now. */
+               if (state == QH_STATE_IDLE)
+                       goto rescan;
+
+               /* Otherwise we have to wait until the QH is fully unlinked.
+                * Our caller will start an unlink if qh->needs_rescan is
+                * set.  But if an unlink has already started, nothing needs
+                * to be done.
+                */
+               if (state != QH_STATE_LINKED)
+                       qh->needs_rescan = 0;
+       }
+
+       /* restore original state; caller must unlink or relink */
+       qh->qh_state = state;
+
+       /* be sure the hardware's done with the qh before refreshing
+        * it after fault cleanup, or recovering from silicon wrongly
+        * overlaying the dummy qtd (which reduces DMA chatter).
+        */
+       if (stopped != 0 || hw->hw_qtd_next == FUSBH200_LIST_END(fusbh200)) {
+               switch (state) {
+               case QH_STATE_IDLE:
+                       qh_refresh(fusbh200, qh);
+                       break;
+               case QH_STATE_LINKED:
+                       /* We won't refresh a QH that's linked (after the HC
+                        * stopped the queue).  That avoids a race:
+                        *  - HC reads first part of QH;
+                        *  - CPU updates that first part and the token;
+                        *  - HC reads rest of that QH, including token
+                        * Result:  HC gets an inconsistent image, and then
+                        * DMAs to/from the wrong memory (corrupting it).
+                        *
+                        * That should be rare for interrupt transfers,
+                        * except maybe high bandwidth ...
+                        */
+
+                       /* Tell the caller to start an unlink */
+                       qh->needs_rescan = 1;
+                       break;
+               /* otherwise, unlink already started */
+               }
+       }
+
+       return count;
+}
+
+/*-------------------------------------------------------------------------*/
+
+// high bandwidth multiplier, as encoded in highspeed endpoint descriptors
+#define hb_mult(wMaxPacketSize) (1 + (((wMaxPacketSize) >> 11) & 0x03))
+// ... and packet size, for any kind of endpoint descriptor
+#define max_packet(wMaxPacketSize) ((wMaxPacketSize) & 0x07ff)
+
+/*
+ * reverse of qh_urb_transaction:  free a list of TDs.
+ * used for cleanup after errors, before HC sees an URB's TDs.
+ */
+static void qtd_list_free (
+       struct fusbh200_hcd             *fusbh200,
+       struct urb              *urb,
+       struct list_head        *qtd_list
+) {
+       struct list_head        *entry, *temp;
+
+       list_for_each_safe (entry, temp, qtd_list) {
+               struct fusbh200_qtd     *qtd;
+
+               qtd = list_entry (entry, struct fusbh200_qtd, qtd_list);
+               list_del (&qtd->qtd_list);
+               fusbh200_qtd_free (fusbh200, qtd);
+       }
+}
+
+/*
+ * create a list of filled qtds for this URB; won't link into qh.
+ */
+static struct list_head *
+qh_urb_transaction (
+       struct fusbh200_hcd             *fusbh200,
+       struct urb              *urb,
+       struct list_head        *head,
+       gfp_t                   flags
+) {
+       struct fusbh200_qtd             *qtd, *qtd_prev;
+       dma_addr_t              buf;
+       int                     len, this_sg_len, maxpacket;
+       int                     is_input;
+       u32                     token;
+       int                     i;
+       struct scatterlist      *sg;
+
+       /*
+        * URBs map to sequences of QTDs:  one logical transaction
+        */
+       qtd = fusbh200_qtd_alloc (fusbh200, flags);
+       if (unlikely (!qtd))
+               return NULL;
+       list_add_tail (&qtd->qtd_list, head);
+       qtd->urb = urb;
+
+       token = QTD_STS_ACTIVE;
+       token |= (FUSBH200_TUNE_CERR << 10);
+       /* for split transactions, SplitXState initialized to zero */
+
+       len = urb->transfer_buffer_length;
+       is_input = usb_pipein (urb->pipe);
+       if (usb_pipecontrol (urb->pipe)) {
+               /* SETUP pid */
+               qtd_fill(fusbh200, qtd, urb->setup_dma,
+                               sizeof (struct usb_ctrlrequest),
+                               token | (2 /* "setup" */ << 8), 8);
+
+               /* ... and always at least one more pid */
+               token ^= QTD_TOGGLE;
+               qtd_prev = qtd;
+               qtd = fusbh200_qtd_alloc (fusbh200, flags);
+               if (unlikely (!qtd))
+                       goto cleanup;
+               qtd->urb = urb;
+               qtd_prev->hw_next = QTD_NEXT(fusbh200, qtd->qtd_dma);
+               list_add_tail (&qtd->qtd_list, head);
+
+               /* for zero length DATA stages, STATUS is always IN */
+               if (len == 0)
+                       token |= (1 /* "in" */ << 8);
+       }
+
+       /*
+        * data transfer stage:  buffer setup
+        */
+       i = urb->num_mapped_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));
+
+       /*
+        * 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(fusbh200, 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.
+                * (this will usually be overridden later.)
+                */
+               if (is_input)
+                       qtd->hw_alt_next = fusbh200->async->hw->hw_alt_next;
+
+               /* qh makes control packets use qtd toggle; maybe 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 = fusbh200_qtd_alloc (fusbh200, flags);
+               if (unlikely (!qtd))
+                       goto cleanup;
+               qtd->urb = urb;
+               qtd_prev->hw_next = QTD_NEXT(fusbh200, qtd->qtd_dma);
+               list_add_tail (&qtd->qtd_list, head);
+       }
+
+       /*
+        * 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 most other cases).
+        */
+       if (likely ((urb->transfer_flags & URB_SHORT_NOT_OK) == 0
+                               || usb_pipecontrol (urb->pipe)))
+               qtd->hw_alt_next = FUSBH200_LIST_END(fusbh200);
+
+       /*
+        * control requests may need a terminating data "status" ack;
+        * other OUT ones may need a terminating short packet
+        * (zero length).
+        */
+       if (likely (urb->transfer_buffer_length != 0)) {
+               int     one_more = 0;
+
+               if (usb_pipecontrol (urb->pipe)) {
+                       one_more = 1;
+                       token ^= 0x0100;        /* "in" <--> "out"  */
+                       token |= QTD_TOGGLE;    /* force DATA1 */
+               } else if (usb_pipeout(urb->pipe)
+                               && (urb->transfer_flags & URB_ZERO_PACKET)
+                               && !(urb->transfer_buffer_length % maxpacket)) {
+                       one_more = 1;
+               }
+               if (one_more) {
+                       qtd_prev = qtd;
+                       qtd = fusbh200_qtd_alloc (fusbh200, flags);
+                       if (unlikely (!qtd))
+                               goto cleanup;
+                       qtd->urb = urb;
+                       qtd_prev->hw_next = QTD_NEXT(fusbh200, qtd->qtd_dma);
+                       list_add_tail (&qtd->qtd_list, head);
+
+                       /* never any data in such packets */
+                       qtd_fill(fusbh200, 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(fusbh200, QTD_IOC);
+       return head;
+
+cleanup:
+       qtd_list_free (fusbh200, urb, head);
+       return NULL;
+}
+
+/*-------------------------------------------------------------------------*/
+
+// Would be best to create all qh's from config descriptors,
+// when each interface/altsetting is established.  Unlink
+// any previous qh and cancel its urbs first; endpoints are
+// implicitly reset then (data toggle too).
+// That'd mean updating how usbcore talks to HCDs. (2.7?)
+
+
+/*
+ * Each QH holds a qtd list; a QH is used for everything except iso.
+ *
+ * For interrupt urbs, the scheduler must set the microframe scheduling
+ * mask(s) each time the QH gets scheduled.  For highspeed, that's
+ * just one microframe in the s-mask.  For split interrupt transactions
+ * there are additional complications: c-mask, maybe FSTNs.
+ */
+static struct fusbh200_qh *
+qh_make (
+       struct fusbh200_hcd             *fusbh200,
+       struct urb              *urb,
+       gfp_t                   flags
+) {
+       struct fusbh200_qh              *qh = fusbh200_qh_alloc (fusbh200, flags);
+       u32                     info1 = 0, info2 = 0;
+       int                     is_input, type;
+       int                     maxp = 0;
+       struct usb_tt           *tt = urb->dev->tt;
+       struct fusbh200_qh_hw   *hw;
+
+       if (!qh)
+               return qh;
+
+       /*
+        * init endpoint/device data for this QH
+        */
+       info1 |= usb_pipeendpoint (urb->pipe) << 8;
+       info1 |= usb_pipedevice (urb->pipe) << 0;
+
+       is_input = usb_pipein (urb->pipe);
+       type = usb_pipetype (urb->pipe);
+       maxp = usb_maxpacket (urb->dev, urb->pipe, !is_input);
+
+       /* 1024 byte maxpacket is a hardware ceiling.  High bandwidth
+        * acts like up to 3KB, but is built from smaller packets.
+        */
+       if (max_packet(maxp) > 1024) {
+               fusbh200_dbg(fusbh200, "bogus qh maxpacket %d\n", max_packet(maxp));
+               goto done;
+       }
+
+       /* Compute interrupt scheduling parameters just once, and save.
+        * - allowing for high bandwidth, how many nsec/uframe are used?
+        * - split transactions need a second CSPLIT uframe; same question
+        * - splits also need a schedule gap (for full/low speed I/O)
+        * - qh has a polling interval
+        *
+        * For control/bulk requests, the HC or TT handles these.
+        */
+       if (type == PIPE_INTERRUPT) {
+               qh->usecs = NS_TO_US(usb_calc_bus_time(USB_SPEED_HIGH,
+                               is_input, 0,
+                               hb_mult(maxp) * max_packet(maxp)));
+               qh->start = NO_FRAME;
+
+               if (urb->dev->speed == USB_SPEED_HIGH) {
+                       qh->c_usecs = 0;
+                       qh->gap_uf = 0;
+
+                       qh->period = urb->interval >> 3;
+                       if (qh->period == 0 && urb->interval != 1) {
+                               /* NOTE interval 2 or 4 uframes could work.
+                                * But interval 1 scheduling is simpler, and
+                                * includes high bandwidth.
+                                */
+                               urb->interval = 1;
+                       } else if (qh->period > fusbh200->periodic_size) {
+                               qh->period = fusbh200->periodic_size;
+                               urb->interval = qh->period << 3;
+                       }
+               } else {
+                       int             think_time;
+
+                       /* gap is f(FS/LS transfer times) */
+                       qh->gap_uf = 1 + usb_calc_bus_time (urb->dev->speed,
+                                       is_input, 0, maxp) / (125 * 1000);
+
+                       /* FIXME this just approximates SPLIT/CSPLIT times */
+                       if (is_input) {         // SPLIT, gap, CSPLIT+DATA
+                               qh->c_usecs = qh->usecs + HS_USECS (0);
+                               qh->usecs = HS_USECS (1);
+                       } else {                // SPLIT+DATA, gap, CSPLIT
+                               qh->usecs += HS_USECS (1);
+                               qh->c_usecs = HS_USECS (0);
+                       }
+
+                       think_time = tt ? tt->think_time : 0;
+                       qh->tt_usecs = NS_TO_US (think_time +
+                                       usb_calc_bus_time (urb->dev->speed,
+                                       is_input, 0, max_packet (maxp)));
+                       qh->period = urb->interval;
+                       if (qh->period > fusbh200->periodic_size) {
+                               qh->period = fusbh200->periodic_size;
+                               urb->interval = qh->period;
+                       }
+               }
+       }
+
+       /* support for tt scheduling, and access to toggles */
+       qh->dev = urb->dev;
+
+       /* using TT? */
+       switch (urb->dev->speed) {
+       case USB_SPEED_LOW:
+               info1 |= QH_LOW_SPEED;
+               /* FALL THROUGH */
+
+       case USB_SPEED_FULL:
+               /* EPS 0 means "full" */
+               if (type != PIPE_INTERRUPT)
+                       info1 |= (FUSBH200_TUNE_RL_TT << 28);
+               if (type == PIPE_CONTROL) {
+                       info1 |= QH_CONTROL_EP;         /* for TT */
+                       info1 |= QH_TOGGLE_CTL;         /* toggle from qtd */
+               }
+               info1 |= maxp << 16;
+
+               info2 |= (FUSBH200_TUNE_MULT_TT << 30);
+
+               /* Some Freescale processors have an erratum in which the
+                * port number in the queue head was 0..N-1 instead of 1..N.
+                */
+               if (fusbh200_has_fsl_portno_bug(fusbh200))
+                       info2 |= (urb->dev->ttport-1) << 23;
[… more lines in the raw message]

Lines of this file are not shown. View the raw message.

drivers/usb/host/fusbh200.h new file +743 -1
new file mode 100644
index 0000000..797c9e8

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

1.7.4.1

Part of the diff is not shown here. View the raw message.

maintainer
#19 lore raw

Re: [PATCH v4] usb host: Faraday USB2.0 FUSBH200-HCD driver

Quoted 11 lines · Yuan-Hsin Chen

Hi,

Are there any advice?
Thanks.

Quoted 5 lines · Yuan-Hsin Chen

FUSBH200-HCD is an USB2.0 hcd for Faraday FUSBH200. FUSBH200 is an ehci-like controller with some differences. First, register layout of FUSBH200 is incompatible with EHCI. Furthermore, FUSBH200 is lack of siTDs which means iTDs are used for both HS and FS ISO transfer.

As far as I'm concerned, this can be merged.

Alan Stern

#20 lore raw

Re: [PATCH v4] usb host: Faraday USB2.0 FUSBH200-HCD driver

Hi,

Quoted 7 lines · Alan Stern
Quoted 5 lines · Yuan-Hsin Chen

Hi,

Are there any advice?
Thanks.

Quoted 8 lines
Quoted 6 lines · Yuan-Hsin Chen
Quoted 5 lines

FUSBH200-HCD is an USB2.0 hcd for Faraday FUSBH200. FUSBH200 is an ehci-like controller with some differences. First, register layout of FUSBH200 is incompatible with EHCI. Furthermore, FUSBH200 is lack of siTDs which means iTDs are used for both HS and FS ISO transfer.

As far as I'm concerned, this can be merged.

Thanks for your great help.

Quoted 3 lines

Alan Stern

Yuan-Hsin

maintainer
#21 lore raw

Re: [PATCH v4] usb host: Faraday USB2.0 FUSBH200-HCD driver

In reply to Alan Stern
Quoted 7 lines · Alan Stern
Quoted 5 lines · Yuan-Hsin Chen

Hi,

Are there any advice?
Thanks.

Quoted 8 lines
Quoted 6 lines · Yuan-Hsin Chen
Quoted 5 lines

FUSBH200-HCD is an USB2.0 hcd for Faraday FUSBH200. FUSBH200 is an ehci-like controller with some differences. First, register layout of FUSBH200 is incompatible with EHCI. Furthermore, FUSBH200 is lack of siTDs which means iTDs are used for both HS and FS ISO transfer.

As far as I'm concerned, this can be merged.

Ok, I'll queue it up after 3.10-rc1 is out.

greg k-h

maintainer
#22 lore raw

Re: [PATCH v4] usb host: Faraday USB2.0 FUSBH200-HCD driver

In reply to Yuan-Hsin Chen
Quoted 7 lines · Yuan-Hsin Chen

FUSBH200-HCD is an USB2.0 hcd for Faraday FUSBH200. FUSBH200 is an ehci-like controller with some differences. First, register layout of FUSBH200 is incompatible with EHCI. Furthermore, FUSBH200 is lack of siTDs which means iTDs are used for both HS and FS ISO transfer.

This patch breaks the build on my machine, so I can't accept it:
CC [M] drivers/usb/host/fusbh200-hcd.o
drivers/usb/host/fusbh200-hcd.c: In function ‘dbg_hcc_params’:
drivers/usb/host/fusbh200-hcd.c:149:2: error: implicit declaration of function ‘HCC_HW_PREFETCH’ [-Werror=implicit-function-declaration] drivers/usb/host/fusbh200-hcd.c:149:2: error: implicit declaration of function ‘HCC_32FRAME_PERIODIC_LIST’ [-Werror=implicit-function-declaration] drivers/usb/host/fusbh200-hcd.c:149:2: warning: format ‘%d’ expects argument of type ‘int’, but argument 6 has type ‘char *’ [-Wformat] drivers/usb/host/fusbh200-hcd.c: At top level:
drivers/usb/host/fusbh200-hcd.c:906:12: warning: ‘debug_lpm_close’ defined but not used [-Wunused-function]
cc1: some warnings being treated as errors

Please be more careful. Can you fix this up and resend it?

thanks,

greg k-h

#23 lore raw

Re: [PATCH v4] usb host: Faraday USB2.0 FUSBH200-HCD driver

Quoted 19 lines · Greg KH
Quoted 7 lines · Yuan-Hsin Chen

FUSBH200-HCD is an USB2.0 hcd for Faraday FUSBH200. FUSBH200 is an ehci-like controller with some differences. First, register layout of FUSBH200 is incompatible with EHCI. Furthermore, FUSBH200 is lack of siTDs which means iTDs are used for both HS and FS ISO transfer.

This patch breaks the build on my machine, so I can't accept it:
CC [M] drivers/usb/host/fusbh200-hcd.o
drivers/usb/host/fusbh200-hcd.c: In function ‘dbg_hcc_params’:
drivers/usb/host/fusbh200-hcd.c:149:2: error: implicit declaration of function ‘HCC_HW_PREFETCH’ [-Werror=implicit-function-declaration] drivers/usb/host/fusbh200-hcd.c:149:2: error: implicit declaration of function ‘HCC_32FRAME_PERIODIC_LIST’ [-Werror=implicit-function-declaration] drivers/usb/host/fusbh200-hcd.c:149:2: warning: format ‘%d’ expects argument of type ‘int’, but argument 6 has type ‘char *’ [-Wformat] drivers/usb/host/fusbh200-hcd.c: At top level:
drivers/usb/host/fusbh200-hcd.c:906:12: warning: ‘debug_lpm_close’ defined but not used [-Wunused-function]
cc1: some warnings being treated as errors

Quoted 1 line

Please be more careful. Can you fix this up and resend it?

I am so sorry about the mistake. The fixed patch will be submitted soon.

Quoted 4 lines

thanks,

greg k-h

Yuan-Hsin Chen

#24 lore raw

PATCH v5 1/1 usb host: Faraday USB2.0 FUSBH200-HCD driver

In reply to Greg KH

FUSBH200-HCD is an USB2.0 hcd for Faraday FUSBH200. FUSBH200 is an ehci-like controller with some differences. First, register layout of FUSBH200 is incompatible with EHCI. Furthermore, FUSBH200 is lack of siTDs which means iTDs are used for both HS and FS ISO transfer.

---

v2:
use ehci-platform.c
use anonymous union and struct
add is_fusbh200 to struct ehci_hcd

v3:
duplicate most of code from Linux-3.7 ehci hcd

v4:
tristate for compiling as a module

v5:
fix compile error while defined DEBUG

 drivers/usb/Makefile            |    1 +
 drivers/usb/host/Kconfig        |   11 +
 drivers/usb/host/Makefile       |    1 +
 drivers/usb/host/fusbh200-hcd.c | 5975 +++++++++++++++++++++++++++++++++++++++
 drivers/usb/host/fusbh200.h     |  743 +++++
 5 files changed, 6731 insertions(+), 0 deletions(-)
 create mode 100644 drivers/usb/host/fusbh200-hcd.c
 create mode 100644 drivers/usb/host/fusbh200.h
drivers/usb/Makefile +1 -0
index 8f5ebce..82ef0be 100644
@@ -27,6 +27,7 @@ obj-$(CONFIG_USB_HWA_HCD)	+= host/
 obj-$(CONFIG_USB_ISP1760_HCD)	+= host/
 obj-$(CONFIG_USB_IMX21_HCD)	+= host/
 obj-$(CONFIG_USB_FSL_MPH_DR_OF)	+= host/
+obj-$(CONFIG_USB_FUSBH200_HCD)	+= host/
 
 obj-$(CONFIG_USB_C67X00_HCD)	+= c67x00/
 
drivers/usb/host/Kconfig +11 -0
index c59a112..ccf0874 100644
@@ -296,6 +296,17 @@ config USB_ISP1362_HCD
 	  To compile this driver as a module, choose M here: the
 	  module will be called isp1362-hcd.
 
+config USB_FUSBH200_HCD
+	tristate "FUSBH200 HCD support"
+	depends on USB
+	default N
+	---help---
+	Faraday FUSBH200 is designed to meet USB2.0 EHCI specification
+	with minor modification.
+
+	To compile this driver as a module, choose M here: the
+	module will be called fusbh200-hcd.
+
 config USB_OHCI_HCD
 	tristate "OHCI HCD support"
 	depends on USB && USB_ARCH_HAS_OHCI
drivers/usb/host/Makefile +1 -0
index 001fbff..612bbd5 100644
@@ -46,3 +46,4 @@ obj-$(CONFIG_USB_FSL_MPH_DR_OF)	+= fsl-mph-dr-of.o
 obj-$(CONFIG_USB_OCTEON2_COMMON) += octeon2-common.o
 obj-$(CONFIG_USB_HCD_BCMA)	+= bcma-hcd.o
 obj-$(CONFIG_USB_HCD_SSB)	+= ssb-hcd.o
+obj-$(CONFIG_USB_FUSBH200_HCD)	+= fusbh200-hcd.o
drivers/usb/host/fusbh200-hcd.c new file +5975 -0

2,972 lines not on this page · raw message

drivers/usb/host/fusbh200.h new file +743 -0

743 lines not on this page · raw message

The rest of this diff is not shown. View the raw message.

Signature · 1 line
1.7.4.1

Part of the diff is not shown here. View the raw message.