more usb patches

9 files changed, 2472 insertions, 12 deletions

diff --git a/usb/usb-add-support-for-at91-gadget.patch b/usb/usb-add-support-for-at91-gadget.patch
new file mode 100644
index 00000000000000..4ae77f61f6d4aa
--- /dev/null
+++ b/usb/usb-add-support-for-at91-gadget.patch
@@ -0,0 +1,2022 @@
+From david-b@pacbell.net Sun Jan 22 11:29:00 2006
+From: David Brownell <david-b@pacbell.net>
+To: Greg KH <greg@kroah.com>
+Subject: USB: add support for AT91 gadget
+Date: Sun, 22 Jan 2006 10:32:37 -0800
+Cc: Andrew Victor <andrew@sanpeople.com>
+Message-Id: <200601221032.37299.david-b@pacbell.net>
+
+
+This adds support for the USB peripheral controller on AT91
+(rm9200, eventually also sam9261 or uClinux) platforms.
+
+More SOC support for Linux-USB ... an uncomplicated pure PIO driver.
+It'd be worth using this as a model, if you're starting a driver
+for some other peripheral controller.
+
+Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
+Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
+
+---
+ drivers/usb/gadget/Kconfig    |   17 
+ drivers/usb/gadget/Makefile   |    1 
+ drivers/usb/gadget/at91_udc.c | 1773 ++++++++++++++++++++++++++++++++++++++++++
+ drivers/usb/gadget/at91_udc.h |  181 ++++
+ 4 files changed, 1972 insertions(+)
+
+--- gregkh-2.6.orig/drivers/usb/gadget/Kconfig
++++ gregkh-2.6/drivers/usb/gadget/Kconfig
+@@ -187,6 +187,23 @@ config USB_OTG
+ 
+ 	   Select this only if your OMAP board has a Mini-AB connector.
+ 
++config USB_GADGET_AT91
++	boolean "AT91 USB Device Port"
++	depends on ARCH_AT91RM9200
++	select USB_GADGET_SELECTED
++	help
++	   Many Atmel AT91 processors (such as the AT91RM2000) have a
++	   full speed USB Device Port with support for five configurable
++	   endpoints (plus endpoint zero).
++
++	   Say "y" to link the driver statically, or "m" to build a
++	   dynamically linked module called "at91_udc" and force all
++	   gadget drivers to also be dynamically linked.
++
++config USB_AT91
++	tristate
++	depends on USB_GADGET_AT91
++	default USB_GADGET
+ 
+ config USB_GADGET_DUMMY_HCD
+ 	boolean "Dummy HCD (DEVELOPMENT)"
+--- gregkh-2.6.orig/drivers/usb/gadget/Makefile
++++ gregkh-2.6/drivers/usb/gadget/Makefile
+@@ -7,6 +7,7 @@ obj-$(CONFIG_USB_PXA2XX)	+= pxa2xx_udc.o
+ obj-$(CONFIG_USB_GOKU)		+= goku_udc.o
+ obj-$(CONFIG_USB_OMAP)		+= omap_udc.o
+ obj-$(CONFIG_USB_LH7A40X)	+= lh7a40x_udc.o
++obj-$(CONFIG_USB_AT91)		+= at91_udc.o
+ 
+ #
+ # USB gadget drivers
+--- /dev/null
++++ gregkh-2.6/drivers/usb/gadget/at91_udc.c
+@@ -0,0 +1,1773 @@
++/*
++ * at91_udc -- driver for at91-series USB peripheral controller
++ *
++ * Copyright (C) 2004 by Thomas Rathbone
++ * Copyright (C) 2005 by HP Labs
++ * Copyright (C) 2005 by David Brownell
++ *
++ * 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., 59 Temple Place - Suite 330,
++ * Boston, MA  02111-1307, USA.
++ */
++
++#undef	DEBUG
++#undef	VERBOSE
++#undef	PACKET_TRACE
++
++#include <linux/config.h>
++#include <linux/kernel.h>
++#include <linux/module.h>
++#include <linux/platform_device.h>
++#include <linux/delay.h>
++#include <linux/ioport.h>
++#include <linux/sched.h>
++#include <linux/slab.h>
++#include <linux/smp_lock.h>
++#include <linux/errno.h>
++#include <linux/init.h>
++#include <linux/list.h>
++#include <linux/interrupt.h>
++#include <linux/proc_fs.h>
++#include <linux/clk.h>
++#include <linux/usb_ch9.h>
++#include <linux/usb_gadget.h>
++
++#include <asm/byteorder.h>
++#include <asm/io.h>
++#include <asm/irq.h>
++#include <asm/system.h>
++#include <asm/mach-types.h>
++
++#include <asm/arch/hardware.h>
++#include <asm/arch/gpio.h>
++#include <asm/arch/board.h>
++
++#include "at91_udc.h"
++
++
++/*
++ * This controller is simple and PIO-only.  It's used in many AT91-series
++ * ARMv4T controllers, including the at91rm9200 (arm920T, with MMU),
++ * at91sam9261 (arm926ejs, with MMU), and several no-mmu versions.
++ *
++ * This driver expects the board has been wired with two GPIOs suppporting
++ * a VBUS sensing IRQ, and a D+ pullup.  (They may be omitted, but the
++ * testing hasn't covered such cases.)  The pullup is most important; it
++ * provides software control over whether the host enumerates the device.
++ * The VBUS sensing helps during enumeration, and allows both USB clocks
++ * (and the transceiver) to stay gated off until they're necessary, saving
++ * power.  During USB suspend, the 48 MHz clock is gated off.
++ */
++
++#define	DRIVER_VERSION	"8 March 2005"
++
++static const char driver_name [] = "at91_udc";
++static const char ep0name[] = "ep0";
++
++/*-------------------------------------------------------------------------*/
++
++/*
++ * Read from a UDP register.
++ */
++static inline unsigned long at91_udp_read(unsigned int reg)
++{
++	void __iomem *udp_base = (void __iomem *)AT91_VA_BASE_UDP;
++
++	return __raw_readl(udp_base + reg);
++}
++
++/*
++ * Write to a UDP register.
++ */
++static inline void at91_udp_write(unsigned int reg, unsigned long value)
++{
++	void __iomem *udp_base = (void __iomem *)AT91_VA_BASE_UDP;
++
++	__raw_writel(value, udp_base + reg);
++}
++
++/*-------------------------------------------------------------------------*/
++
++#ifdef CONFIG_USB_GADGET_DEBUG_FILES
++
++#include <linux/seq_file.h>
++
++static const char debug_filename[] = "driver/udc";
++
++#define FOURBITS "%s%s%s%s"
++#define EIGHTBITS FOURBITS FOURBITS
++
++static void proc_ep_show(struct seq_file *s, struct at91_ep *ep)
++{
++	static char		*types[] = {
++		"control", "out-iso", "out-bulk", "out-int",
++		"BOGUS",   "in-iso",  "in-bulk",  "in-int"};
++
++	u32			csr;
++	struct at91_request	*req;
++	unsigned long	flags;
++
++	local_irq_save(flags);
++
++	csr = __raw_readl(ep->creg);
++
++	/* NOTE:  not collecting per-endpoint irq statistics... */
++
++	seq_printf(s, "\n");
++	seq_printf(s, "%s, maxpacket %d %s%s %s%s\n",
++			ep->ep.name, ep->ep.maxpacket,
++			ep->is_in ? "in" : "out",
++			ep->is_iso ? " iso" : "",
++			ep->is_pingpong
++				? (ep->fifo_bank ? "pong" : "ping")
++				: "",
++			ep->stopped ? " stopped" : "");
++	seq_printf(s, "csr %08x rxbytes=%d %s %s %s" EIGHTBITS "\n",
++		csr,
++		(csr & 0x07ff0000) >> 16,
++		(csr & (1 << 15)) ? "enabled" : "disabled",
++		(csr & (1 << 11)) ? "DATA1" : "DATA0",
++		types[(csr & 0x700) >> 8],
++
++		/* iff type is control then print current direction */
++		(!(csr & 0x700))
++			? ((csr & (1 << 7)) ? " IN" : " OUT")
++			: "",
++		(csr & (1 << 6)) ? " rxdatabk1" : "",
++		(csr & (1 << 5)) ? " forcestall" : "",
++		(csr & (1 << 4)) ? " txpktrdy" : "",
++
++		(csr & (1 << 3)) ? " stallsent" : "",
++		(csr & (1 << 2)) ? " rxsetup" : "",
++		(csr & (1 << 1)) ? " rxdatabk0" : "",
++		(csr & (1 << 0)) ? " txcomp" : "");
++	if (list_empty (&ep->queue))
++		seq_printf(s, "\t(queue empty)\n");
++
++	else list_for_each_entry (req, &ep->queue, queue) {
++		unsigned	length = req->req.actual;
++
++		seq_printf(s, "\treq %p len %d/%d buf %p\n",
++				&req->req, length,
++				req->req.length, req->req.buf);
++	}
++	local_irq_restore(flags);
++}
++
++static void proc_irq_show(struct seq_file *s, const char *label, u32 mask)
++{
++	int i;
++
++	seq_printf(s, "%s %04x:%s%s" FOURBITS, label, mask,
++		(mask & (1 << 13)) ? " wakeup" : "",
++		(mask & (1 << 12)) ? " endbusres" : "",
++
++		(mask & (1 << 11)) ? " sofint" : "",
++		(mask & (1 << 10)) ? " extrsm" : "",
++		(mask & (1 << 9)) ? " rxrsm" : "",
++		(mask & (1 << 8)) ? " rxsusp" : "");
++	for (i = 0; i < 8; i++) {
++		if (mask & (1 << i))
++			seq_printf(s, " ep%d", i);
++	}
++	seq_printf(s, "\n");
++}
++
++static int proc_udc_show(struct seq_file *s, void *unused)
++{
++	struct at91_udc	*udc = s->private;
++	struct at91_ep	*ep;
++	u32		tmp;
++
++	seq_printf(s, "%s: version %s\n", driver_name, DRIVER_VERSION);
++
++	seq_printf(s, "vbus %s, pullup %s, %s powered%s, gadget %s\n\n",
++		udc->vbus ? "present" : "off",
++		udc->enabled
++			? (udc->vbus ? "active" : "enabled")
++			: "disabled",
++		udc->selfpowered ? "self" : "VBUS",
++		udc->suspended ? ", suspended" : "",
++		udc->driver ? udc->driver->driver.name : "(none)");
++
++	/* don't access registers when interface isn't clocked */
++	if (!udc->clocked) {
++		seq_printf(s, "(not clocked)\n");
++		return 0;
++	}
++
++	tmp = at91_udp_read(AT91_UDP_FRM_NUM);
++	seq_printf(s, "frame %05x:%s%s frame=%d\n", tmp,
++		(tmp & AT91_UDP_FRM_OK) ? " ok" : "",
++		(tmp & AT91_UDP_FRM_ERR) ? " err" : "",
++		(tmp & AT91_UDP_NUM));
++
++	tmp = at91_udp_read(AT91_UDP_GLB_STAT);
++	seq_printf(s, "glbstate %02x:%s" FOURBITS "\n", tmp,
++		(tmp & AT91_UDP_RMWUPE) ? " rmwupe" : "",
++		(tmp & AT91_UDP_RSMINPR) ? " rsminpr" : "",
++		(tmp & AT91_UDP_ESR) ? " esr" : "",
++		(tmp & AT91_UDP_CONFG) ? " confg" : "",
++		(tmp & AT91_UDP_FADDEN) ? " fadden" : "");
++
++	tmp = at91_udp_read(AT91_UDP_FADDR);
++	seq_printf(s, "faddr   %03x:%s fadd=%d\n", tmp,
++		(tmp & AT91_UDP_FEN) ? " fen" : "",
++		(tmp & AT91_UDP_FADD));
++
++	proc_irq_show(s, "imr   ", at91_udp_read(AT91_UDP_IMR));
++	proc_irq_show(s, "isr   ", at91_udp_read(AT91_UDP_ISR));
++
++	if (udc->enabled && udc->vbus) {
++		proc_ep_show(s, &udc->ep[0]);
++		list_for_each_entry (ep, &udc->gadget.ep_list, ep.ep_list) {
++			if (ep->desc)
++				proc_ep_show(s, ep);
++		}
++	}
++	return 0;
++}
++
++static int proc_udc_open(struct inode *inode, struct file *file)
++{
++	return single_open(file, proc_udc_show, PDE(inode)->data);
++}
++
++static struct file_operations proc_ops = {
++	.open		= proc_udc_open,
++	.read		= seq_read,
++	.llseek		= seq_lseek,
++	.release	= single_release,
++};
++
++static void create_debug_file(struct at91_udc *udc)
++{
++	struct proc_dir_entry *pde;
++
++	pde = create_proc_entry (debug_filename, 0, NULL);
++	udc->pde = pde;
++	if (pde == NULL)
++		return;
++
++	pde->proc_fops = &proc_ops;
++	pde->data = udc;
++}
++
++static void remove_debug_file(struct at91_udc *udc)
++{
++	if (udc->pde)
++		remove_proc_entry(debug_filename, NULL);
++}
++
++#else
++
++static inline void create_debug_file(struct at91_udc *udc) {}
++static inline void remove_debug_file(struct at91_udc *udc) {}
++
++#endif
++
++
++/*-------------------------------------------------------------------------*/
++
++static void done(struct at91_ep *ep, struct at91_request *req, int status)
++{
++	unsigned	stopped = ep->stopped;
++
++	list_del_init(&req->queue);
++	if (req->req.status == -EINPROGRESS)
++		req->req.status = status;
++	else
++		status = req->req.status;
++	if (status && status != -ESHUTDOWN)
++		VDBG("%s done %p, status %d\n", ep->ep.name, req, status);
++
++	ep->stopped = 1;
++	req->req.complete(&ep->ep, &req->req);
++	ep->stopped = stopped;
++
++	/* ep0 is always ready; other endpoints need a non-empty queue */
++	if (list_empty(&ep->queue) && ep->int_mask != (1 << 0))
++		at91_udp_write(AT91_UDP_IDR, ep->int_mask);
++}
++
++/*-------------------------------------------------------------------------*/
++
++/* bits indicating OUT fifo has data ready */
++#define	RX_DATA_READY	(AT91_UDP_RX_DATA_BK0 | AT91_UDP_RX_DATA_BK1)
++
++/*
++ * Endpoint FIFO CSR bits have a mix of bits, making it unsafe to just write
++ * back most of the value you just read (because of side effects, including
++ * bits that may change after reading and before writing).
++ *
++ * Except when changing a specific bit, always write values which:
++ *  - clear SET_FX bits (setting them could change something)
++ *  - set CLR_FX bits (clearing them could change something)
++ *
++ * There are also state bits like FORCESTALL, EPEDS, DIR, and EPTYPE
++ * that shouldn't normally be changed.
++ */
++#define	SET_FX	(AT91_UDP_TXPKTRDY)
++#define	CLR_FX	(RX_DATA_READY | AT91_UDP_RXSETUP | AT91_UDP_STALLSENT | AT91_UDP_TXCOMP)
++
++/* pull OUT packet data from the endpoint's fifo */
++static int read_fifo (struct at91_ep *ep, struct at91_request *req)
++{
++	u32 __iomem	*creg = ep->creg;
++	u8 __iomem	*dreg = ep->creg + (AT91_UDP_FDR(0) - AT91_UDP_CSR(0));
++	u32		csr;
++	u8		*buf;
++	unsigned int	count, bufferspace, is_done;
++
++	buf = req->req.buf + req->req.actual;
++	bufferspace = req->req.length - req->req.actual;
++
++	/*
++	 * there might be nothing to read if ep_queue() calls us,
++	 * or if we already emptied both pingpong buffers
++	 */
++rescan:
++	csr = __raw_readl(creg);
++	if ((csr & RX_DATA_READY) == 0)
++		return 0;
++
++	count = (csr & AT91_UDP_RXBYTECNT) >> 16;
++	if (count > ep->ep.maxpacket)
++		count = ep->ep.maxpacket;
++	if (count > bufferspace) {
++		DBG("%s buffer overflow\n", ep->ep.name);
++		req->req.status = -EOVERFLOW;
++		count = bufferspace;
++	}
++	__raw_readsb(dreg, buf, count);
++
++	/* release and swap pingpong mem bank */
++	csr |= CLR_FX;
++	if (ep->is_pingpong) {
++		if (ep->fifo_bank == 0) {
++			csr &= ~(SET_FX | AT91_UDP_RX_DATA_BK0);
++			ep->fifo_bank = 1;
++		} else {
++			csr &= ~(SET_FX | AT91_UDP_RX_DATA_BK1);
++			ep->fifo_bank = 0;
++		}
++	} else
++		csr &= ~(SET_FX | AT91_UDP_RX_DATA_BK0);
++	__raw_writel(csr, creg);
++
++	req->req.actual += count;
++	is_done = (count < ep->ep.maxpacket);
++	if (count == bufferspace)
++		is_done = 1;
++
++	PACKET("%s %p out/%d%s\n", ep->ep.name, &req->req, count,
++			is_done ? " (done)" : "");
++
++	/*
++	 * avoid extra trips through IRQ logic for packets already in
++	 * the fifo ... maybe preventing an extra (expensive) OUT-NAK
++	 */
++	if (is_done)
++		done(ep, req, 0);
++	else if (ep->is_pingpong) {
++		bufferspace -= count;
++		buf += count;
++		goto rescan;
++	}
++
++	return is_done;
++}
++
++/* load fifo for an IN packet */
++static int write_fifo(struct at91_ep *ep, struct at91_request *req)
++{
++	u32 __iomem	*creg = ep->creg;
++	u32		csr = __raw_readl(creg);
++	u8 __iomem	*dreg = ep->creg + (AT91_UDP_FDR(0) - AT91_UDP_CSR(0));
++	unsigned	total, count, is_last;
++
++	/*
++	 * TODO: allow for writing two packets to the fifo ... that'll
++	 * reduce the amount of IN-NAKing, but probably won't affect
++	 * throughput much.  (Unlike preventing OUT-NAKing!)
++	 */
++
++	/*
++	 * If ep_queue() calls us, the queue is empty and possibly in
++	 * odd states like TXCOMP not yet cleared (we do it, saving at
++	 * least one IRQ) or the fifo not yet being free.  Those aren't
++	 * issues normally (IRQ handler fast path).
++	 */
++	if (unlikely(csr & (AT91_UDP_TXCOMP | AT91_UDP_TXPKTRDY))) {
++		if (csr & AT91_UDP_TXCOMP) {
++			csr |= CLR_FX;
++			csr &= ~(SET_FX | AT91_UDP_TXCOMP);
++			__raw_writel(csr, creg);
++			csr = __raw_readl(creg);
++		}
++		if (csr & AT91_UDP_TXPKTRDY)
++			return 0;
++	}
++
++	total = req->req.length - req->req.actual;
++	if (ep->ep.maxpacket < total) {
++		count = ep->ep.maxpacket;
++		is_last = 0;
++	} else {
++		count = total;
++		is_last = (count < ep->ep.maxpacket) || !req->req.zero;
++	}
++
++	/*
++	 * Write the packet, maybe it's a ZLP.
++	 *
++	 * NOTE:  incrementing req->actual before we receive the ACK means
++	 * gadget driver IN bytecounts can be wrong in fault cases.  That's
++	 * fixable with PIO drivers like this one (save "count" here, and
++	 * do the increment later on TX irq), but not for most DMA hardware.
++	 *
++	 * So all gadget drivers must accept that potential error.  Some
++	 * hardware supports precise fifo status reporting, letting them
++	 * recover when the actual bytecount matters (e.g. for USB Test
++	 * and Measurement Class devices).
++	 */
++	__raw_writesb(dreg, req->req.buf + req->req.actual, count);
++	csr &= ~SET_FX;
++	csr |= CLR_FX | AT91_UDP_TXPKTRDY;
++	__raw_writel(csr, creg);
++	req->req.actual += count;
++
++	PACKET("%s %p in/%d%s\n", ep->ep.name, &req->req, count,
++			is_last ? " (done)" : "");
++	if (is_last)
++		done(ep, req, 0);
++	return is_last;
++}
++
++static void nuke(struct at91_ep *ep, int status)
++{
++	struct at91_request *req;
++
++	// terminer chaque requete dans la queue
++	ep->stopped = 1;
++	if (list_empty(&ep->queue))
++		return;
++
++	VDBG("%s %s\n", __FUNCTION__, ep->ep.name);
++	while (!list_empty(&ep->queue)) {
++		req = list_entry(ep->queue.next, struct at91_request, queue);
++		done(ep, req, status);
++	}
++}
++
++/*-------------------------------------------------------------------------*/
++
++static int at91_ep_enable(struct usb_ep *_ep, const struct usb_endpoint_descriptor *desc)
++{
++	struct at91_ep	*ep = container_of(_ep, struct at91_ep, ep);
++	struct at91_udc	*dev = ep->udc;
++	u16		maxpacket;
++	u32		tmp;
++	unsigned long	flags;
++
++	if (!_ep || !ep
++			|| !desc || ep->desc
++			|| _ep->name == ep0name
++			|| desc->bDescriptorType != USB_DT_ENDPOINT
++			|| (maxpacket = le16_to_cpu(desc->wMaxPacketSize)) == 0
++			|| maxpacket > ep->maxpacket) {
++		DBG("bad ep or descriptor\n");
++		return -EINVAL;
++	}
++
++	if (!dev->driver || dev->gadget.speed == USB_SPEED_UNKNOWN) {
++		DBG("bogus device state\n");
++		return -ESHUTDOWN;
++	}
++
++	tmp = desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK;
++	switch (tmp) {
++	case USB_ENDPOINT_XFER_CONTROL:
++		DBG("only one control endpoint\n");
++		return -EINVAL;
++	case USB_ENDPOINT_XFER_INT:
++		if (maxpacket > 64)
++			goto bogus_max;
++		break;
++	case USB_ENDPOINT_XFER_BULK:
++		switch (maxpacket) {
++		case 8:
++		case 16:
++		case 32:
++		case 64:
++			goto ok;
++		}
++bogus_max:
++		DBG("bogus maxpacket %d\n", maxpacket);
++		return -EINVAL;
++	case USB_ENDPOINT_XFER_ISOC:
++		if (!ep->is_pingpong) {
++			DBG("iso requires double buffering\n");
++			return -EINVAL;
++		}
++		break;
++	}
++
++ok:
++	local_irq_save(flags);
++
++	/* initialize endpoint to match this descriptor */
++	ep->is_in = (desc->bEndpointAddress & USB_DIR_IN) != 0;
++	ep->is_iso = (tmp == USB_ENDPOINT_XFER_ISOC);
++	ep->stopped = 0;
++	if (ep->is_in)
++		tmp |= 0x04;
++	tmp <<= 8;
++	tmp |= AT91_UDP_EPEDS;
++	__raw_writel(tmp, ep->creg);
++
++	ep->desc = desc;
++	ep->ep.maxpacket = maxpacket;
++
++	/*
++	 * reset/init endpoint fifo.  NOTE:  leaves fifo_bank alone,
++	 * since endpoint resets don't reset hw pingpong state.
++	 */
++	at91_udp_write(AT91_UDP_RST_EP, ep->int_mask);
++	at91_udp_write(AT91_UDP_RST_EP, 0);
++
++	local_irq_restore(flags);
++	return 0;
++}
++
++static int at91_ep_disable (struct usb_ep * _ep)
++{
++	struct at91_ep	*ep = container_of(_ep, struct at91_ep, ep);
++	unsigned long	flags;
++
++	if (ep == &ep->udc->ep[0])
++		return -EINVAL;
++
++	local_irq_save(flags);
++
++	nuke(ep, -ESHUTDOWN);
++
++	/* restore the endpoint's pristine config */
++	ep->desc = NULL;
++	ep->ep.maxpacket = ep->maxpacket;
++
++	/* reset fifos and endpoint */
++	if (ep->udc->clocked) {
++		at91_udp_write(AT91_UDP_RST_EP, ep->int_mask);
++		at91_udp_write(AT91_UDP_RST_EP, 0);
++		__raw_writel(0, ep->creg);
++	}
++
++	local_irq_restore(flags);
++	return 0;
++}
++
++/*
++ * this is a PIO-only driver, so there's nothing
++ * interesting for request or buffer allocation.
++ */
++
++static struct usb_request *at91_ep_alloc_request (struct usb_ep *_ep, unsigned int gfp_flags)
++{
++	struct at91_request *req;
++
++	req = kcalloc(1, sizeof (struct at91_request), SLAB_KERNEL);
++	if (!req)
++		return NULL;
++
++	INIT_LIST_HEAD(&req->queue);
++	return &req->req;
++}
++
++static void at91_ep_free_request(struct usb_ep *_ep, struct usb_request *_req)
++{
++	struct at91_request *req;
++
++	req = container_of(_req, struct at91_request, req);
++	BUG_ON(!list_empty(&req->queue));
++	kfree(req);
++}
++
++static void *at91_ep_alloc_buffer(
++	struct usb_ep *_ep,
++	unsigned bytes,
++	dma_addr_t *dma,
++	gfp_t gfp_flags)
++{
++	*dma = ~0;
++	return kmalloc(bytes, gfp_flags);
++}
++
++static void at91_ep_free_buffer(
++	struct usb_ep *ep,
++	void *buf,
++	dma_addr_t dma,
++	unsigned bytes)
++{
++	kfree(buf);
++}
++
++static int at91_ep_queue(struct usb_ep *_ep,
++			struct usb_request *_req, gfp_t gfp_flags)
++{
++	struct at91_request	*req;
++	struct at91_ep		*ep;
++	struct at91_udc		*dev;
++	int			status;
++	unsigned long		flags;
++
++	req = container_of(_req, struct at91_request, req);
++	ep = container_of(_ep, struct at91_ep, ep);
++
++	if (!_req || !_req->complete
++			|| !_req->buf || !list_empty(&req->queue)) {
++		DBG("invalid request\n");
++		return -EINVAL;
++	}
++
++	if (!_ep || (!ep->desc && ep->ep.name != ep0name)) {
++		DBG("invalid ep\n");
++		return -EINVAL;
++	}
++
++	dev = ep->udc;
++
++	if (!dev || !dev->driver || dev->gadget.speed == USB_SPEED_UNKNOWN) {
++		DBG("invalid device\n");
++		return -EINVAL;
++	}
++
++	_req->status = -EINPROGRESS;
++	_req->actual = 0;
++
++	local_irq_save(flags);
++
++	/* try to kickstart any empty and idle queue */
++	if (list_empty(&ep->queue) && !ep->stopped) {
++		int	is_ep0;
++
++		/*
++		 * If this control request has a non-empty DATA stage, this
++		 * will start that stage.  It works just like a non-control
++		 * request (until the status stage starts, maybe early).
++		 *
++		 * If the data stage is empty, then this starts a successful
++		 * IN/STATUS stage.  (Unsuccessful ones use set_halt.)
++		 */
++		is_ep0 = (ep->ep.name == ep0name);
++		if (is_ep0) {
++			u32	tmp;
++
++			if (!dev->req_pending) {
++				status = -EINVAL;
++				goto done;
++			}
++
++			/*
++			 * defer changing CONFG until after the gadget driver
++			 * reconfigures the endpoints.
++			 */
++			if (dev->wait_for_config_ack) {
++				tmp = at91_udp_read(AT91_UDP_GLB_STAT);
++				tmp ^= AT91_UDP_CONFG;
++				VDBG("toggle config\n");
++				at91_udp_write(AT91_UDP_GLB_STAT, tmp);
++			}
++			if (req->req.length == 0) {
++ep0_in_status:
++				PACKET("ep0 in/status\n");
++				status = 0;
++				tmp = __raw_readl(ep->creg);
++				tmp &= ~SET_FX;
++				tmp |= CLR_FX | AT91_UDP_TXPKTRDY;
++				__raw_writel(tmp, ep->creg);
++				dev->req_pending = 0;
++				goto done;
++			}
++		}
++
++		if (ep->is_in)
++			status = write_fifo(ep, req);
++		else {
++			status = read_fifo(ep, req);
++
++			/* IN/STATUS stage is otherwise triggered by irq */
++			if (status && is_ep0)
++				goto ep0_in_status;
++		}
++	} else
++		status = 0;
++
++	if (req && !status) {
++		list_add_tail (&req->queue, &ep->queue);
++		at91_udp_write(AT91_UDP_IER, ep->int_mask);
++	}
++done:
++	local_irq_restore(flags);
++	return (status < 0) ? status : 0;
++}
++
++static int at91_ep_dequeue(struct usb_ep *_ep, struct usb_request *_req)
++{
++	struct at91_ep	*ep;
++	struct at91_request	*req;
++
++	ep = container_of(_ep, struct at91_ep, ep);
++	if (!_ep || ep->ep.name == ep0name)
++		return -EINVAL;
++
++	/* make sure it's actually queued on this endpoint */
++	list_for_each_entry (req, &ep->queue, queue) {
++		if (&req->req == _req)
++			break;
++	}
++	if (&req->req != _req)
++		return -EINVAL;
++
++	done(ep, req, -ECONNRESET);
++	return 0;
++}
++
++static int at91_ep_set_halt(struct usb_ep *_ep, int value)
++{
++	struct at91_ep	*ep = container_of(_ep, struct at91_ep, ep);
++	u32 __iomem	*creg;
++	u32		csr;
++	unsigned long	flags;
++	int		status = 0;
++
++	if (!_ep || ep->is_iso || !ep->udc->clocked)
++		return -EINVAL;
++
++	creg = ep->creg;
++	local_irq_save(flags);
++
++	csr = __raw_readl(creg);
++
++	/*
++	 * fail with still-busy IN endpoints, ensuring correct sequencing
++	 * of data tx then stall.  note that the fifo rx bytecount isn't
++	 * completely accurate as a tx bytecount.
++	 */
++	if (ep->is_in && (!list_empty(&ep->queue) || (csr >> 16) != 0))
++		status = -EAGAIN;
++	else {
++		csr |= CLR_FX;
++		csr &= ~SET_FX;
++		if (value) {
++			csr |= AT91_UDP_FORCESTALL;
++			VDBG("halt %s\n", ep->ep.name);
++		} else {
++			at91_udp_write(AT91_UDP_RST_EP, ep->int_mask);
++			at91_udp_write(AT91_UDP_RST_EP, 0);
++			csr &= ~AT91_UDP_FORCESTALL;
++		}
++		__raw_writel(csr, creg);
++	}
++
++	local_irq_restore(flags);
++	return status;
++}
++
++static struct usb_ep_ops at91_ep_ops = {
++	.enable		= at91_ep_enable,
++	.disable	= at91_ep_disable,
++	.alloc_request	= at91_ep_alloc_request,
++	.free_request	= at91_ep_free_request,
++	.alloc_buffer	= at91_ep_alloc_buffer,
++	.free_buffer	= at91_ep_free_buffer,
++	.queue		= at91_ep_queue,
++	.dequeue	= at91_ep_dequeue,
++	.set_halt	= at91_ep_set_halt,
++	// there's only imprecise fifo status reporting
++};
++
++/*-------------------------------------------------------------------------*/
++
++static int at91_get_frame(struct usb_gadget *gadget)
++{
++	if (!to_udc(gadget)->clocked)
++		return -EINVAL;
++	return at91_udp_read(AT91_UDP_FRM_NUM) & AT91_UDP_NUM;
++}
++
++static int at91_wakeup(struct usb_gadget *gadget)
++{
++	struct at91_udc	*udc = to_udc(gadget);
++	u32		glbstate;
++	int		status = -EINVAL;
++	unsigned long	flags;
++
++	DBG("%s\n", __FUNCTION__ );
++	local_irq_save(flags);
++
++	if (!udc->clocked || !udc->suspended)
++		goto done;
++
++	/* NOTE:  some "early versions" handle ESR differently ... */
++
++	glbstate = at91_udp_read(AT91_UDP_GLB_STAT);
++	if (!(glbstate & AT91_UDP_ESR))
++		goto done;
++	glbstate |= AT91_UDP_ESR;
++	at91_udp_write(AT91_UDP_GLB_STAT, glbstate);
++
++done:
++	local_irq_restore(flags);
++	return status;
++}
++
++/* reinit == restore inital software state */
++static void udc_reinit(struct at91_udc *udc)
++{
++	u32 i;
++
++	INIT_LIST_HEAD(&udc->gadget.ep_list);
++	INIT_LIST_HEAD(&udc->gadget.ep0->ep_list);
++
++	for (i = 0; i < NUM_ENDPOINTS; i++) {
++		struct at91_ep *ep = &udc->ep[i];
++
++		if (i != 0)
++			list_add_tail(&ep->ep.ep_list, &udc->gadget.ep_list);
++		ep->desc = NULL;
++		ep->stopped = 0;
++		ep->fifo_bank = 0;
++		ep->ep.maxpacket = ep->maxpacket;
++		// initialiser une queue par endpoint
++		INIT_LIST_HEAD(&ep->queue);
++	}
++}
++
++static void stop_activity(struct at91_udc *udc)
++{
++	struct usb_gadget_driver *driver = udc->driver;
++	int i;
++
++	if (udc->gadget.speed == USB_SPEED_UNKNOWN)
++		driver = NULL;
++	udc->gadget.speed = USB_SPEED_UNKNOWN;
++
++	for (i = 0; i < NUM_ENDPOINTS; i++) {
++		struct at91_ep *ep = &udc->ep[i];
++		ep->stopped = 1;
++		nuke(ep, -ESHUTDOWN);
++	}
++	if (driver)
++		driver->disconnect(&udc->gadget);
++
++	udc_reinit(udc);
++}
++
++static void clk_on(struct at91_udc *udc)
++{
++	if (udc->clocked)
++		return;
++	udc->clocked = 1;
++	clk_enable(udc->iclk);
++	clk_enable(udc->fclk);
++}
++
++static void clk_off(struct at91_udc *udc)
++{
++	if (!udc->clocked)
++		return;
++	udc->clocked = 0;
++	udc->gadget.speed = USB_SPEED_UNKNOWN;
++	clk_disable(udc->iclk);
++	clk_disable(udc->fclk);
++}
++
++/*
++ * activate/deactivate link with host; minimize power usage for
++ * inactive links by cutting clocks and transceiver power.
++ */
++static void pullup(struct at91_udc *udc, int is_on)
++{
++	if (!udc->enabled || !udc->vbus)
++		is_on = 0;
++	DBG("%sactive\n", is_on ? "" : "in");
++	if (is_on) {
++		clk_on(udc);
++		at91_udp_write(AT91_UDP_TXVC, 0);
++		at91_set_gpio_value(udc->board.pullup_pin, 1);
++	} else  {
++		stop_activity(udc);
++		at91_udp_write(AT91_UDP_TXVC, AT91_UDP_TXVC_TXVDIS);
++		at91_set_gpio_value(udc->board.pullup_pin, 0);
++		clk_off(udc);
++
++		// REVISIT:  with transceiver disabled, will D- float
++		// so that a host would falsely detect a device?
++	}
++}
++
++/* vbus is here!  turn everything on that's ready */
++static int at91_vbus_session(struct usb_gadget *gadget, int is_active)
++{
++	struct at91_udc	*udc = to_udc(gadget);
++	unsigned long	flags;
++
++	// VDBG("vbus %s\n", is_active ? "on" : "off");
++	local_irq_save(flags);
++	udc->vbus = (is_active != 0);
++	pullup(udc, is_active);
++	local_irq_restore(flags);
++	return 0;
++}
++
++static int at91_pullup(struct usb_gadget *gadget, int is_on)
++{
++	struct at91_udc	*udc = to_udc(gadget);
++	unsigned long	flags;
++
++	local_irq_save(flags);
++	udc->enabled = is_on = !!is_on;
++	pullup(udc, is_on);
++	local_irq_restore(flags);
++	return 0;
++}
++
++static int at91_set_selfpowered(struct usb_gadget *gadget, int is_on)
++{
++	struct at91_udc	*udc = to_udc(gadget);
++	unsigned long	flags;
++
++	local_irq_save(flags);
++	udc->selfpowered = (is_on != 0);
++	local_irq_restore(flags);
++	return 0;
++}
++
++static const struct usb_gadget_ops at91_udc_ops = {
++	.get_frame		= at91_get_frame,
++	.wakeup			= at91_wakeup,
++	.set_selfpowered	= at91_set_selfpowered,
++	.vbus_session		= at91_vbus_session,
++	.pullup			= at91_pullup,
++
++	/*
++	 * VBUS-powered devices may also also want to support bigger
++	 * power budgets after an appropriate SET_CONFIGURATION.
++	 */
++	// .vbus_power		= at91_vbus_power,
++};
++
++/*-------------------------------------------------------------------------*/
++
++static int handle_ep(struct at91_ep *ep)
++{
++	struct at91_request	*req;
++	u32 __iomem		*creg = ep->creg;
++	u32			csr = __raw_readl(creg);
++
++	if (!list_empty(&ep->queue))
++		req = list_entry(ep->queue.next,
++			struct at91_request, queue);
++	else
++		req = NULL;
++
++	if (ep->is_in) {
++		if (csr & (AT91_UDP_STALLSENT | AT91_UDP_TXCOMP)) {
++			csr |= CLR_FX;
++			csr &= ~(SET_FX | AT91_UDP_STALLSENT | AT91_UDP_TXCOMP);
++			__raw_writel(csr, creg);
++		}
++		if (req)
++			return write_fifo(ep, req);
++
++	} else {
++		if (csr & AT91_UDP_STALLSENT) {
++			/* STALLSENT bit == ISOERR */
++			if (ep->is_iso && req)
++				req->req.status = -EILSEQ;
++			csr |= CLR_FX;
++			csr &= ~(SET_FX | AT91_UDP_STALLSENT);
++			__raw_writel(csr, creg);
++			csr = __raw_readl(creg);
++		}
++		if (req && (csr & RX_DATA_READY))
++			return read_fifo(ep, req);
++	}
++	return 0;
++}
++
++union setup {
++	u8			raw[8];
++	struct usb_ctrlrequest	r;
++};
++
++static void handle_setup(struct at91_udc *udc, struct at91_ep *ep, u32 csr)
++{
++	u32 __iomem	*creg = ep->creg;
++	u8 __iomem	*dreg = ep->creg + (AT91_UDP_FDR(0) - AT91_UDP_CSR(0));
++	unsigned	rxcount, i = 0;
++	u32		tmp;
++	union setup	pkt;
++	int		status = 0;
++
++	/* read and ack SETUP; hard-fail for bogus packets */
++	rxcount = (csr & AT91_UDP_RXBYTECNT) >> 16;
++	if (likely(rxcount == 8)) {
++		while (rxcount--)
++			pkt.raw[i++] = __raw_readb(dreg);
++		if (pkt.r.bRequestType & USB_DIR_IN) {
++			csr |= AT91_UDP_DIR;
++			ep->is_in = 1;
++		} else {
++			csr &= ~AT91_UDP_DIR;
++			ep->is_in = 0;
++		}
++	} else {
++		// REVISIT this happens sometimes under load; why??
++		ERR("SETUP len %d, csr %08x\n", rxcount, csr);
++		status = -EINVAL;
++	}
++	csr |= CLR_FX;
++	csr &= ~(SET_FX | AT91_UDP_RXSETUP);
++	__raw_writel(csr, creg);
++	udc->wait_for_addr_ack = 0;
++	udc->wait_for_config_ack = 0;
++	ep->stopped = 0;
++	if (unlikely(status != 0))
++		goto stall;
++
++#define w_index		le16_to_cpu(pkt.r.wIndex)
++#define w_value		le16_to_cpu(pkt.r.wValue)
++#define w_length	le16_to_cpu(pkt.r.wLength)
++
++	VDBG("SETUP %02x.%02x v%04x i%04x l%04x\n",
++			pkt.r.bRequestType, pkt.r.bRequest,
++			w_value, w_index, w_length);
++
++	/*
++	 * A few standard requests get handled here, ones that touch
++	 * hardware ... notably for device and endpoint features.
++	 */
++	udc->req_pending = 1;
++	csr = __raw_readl(creg);
++	csr |= CLR_FX;
++	csr &= ~SET_FX;
++	switch ((pkt.r.bRequestType << 8) | pkt.r.bRequest) {
++
++	case ((USB_TYPE_STANDARD|USB_RECIP_DEVICE) << 8)
++			| USB_REQ_SET_ADDRESS:
++		__raw_writel(csr | AT91_UDP_TXPKTRDY, creg);
++		udc->addr = w_value;
++		udc->wait_for_addr_ack = 1;
++		udc->req_pending = 0;
++		/* FADDR is set later, when we ack host STATUS */
++		return;
++
++	case ((USB_TYPE_STANDARD|USB_RECIP_DEVICE) << 8)
++			| USB_REQ_SET_CONFIGURATION:
++		tmp = at91_udp_read(AT91_UDP_GLB_STAT) & AT91_UDP_CONFG;
++		if (pkt.r.wValue)
++			udc->wait_for_config_ack = (tmp == 0);
++		else
++			udc->wait_for_config_ack = (tmp != 0);
++		if (udc->wait_for_config_ack)
++			VDBG("wait for config\n");
++		/* CONFG is toggled later, if gadget driver succeeds */
++		break;
++
++	/*
++	 * Hosts may set or clear remote wakeup status, and
++	 * devices may report they're VBUS powered.
++	 */
++	case ((USB_DIR_IN|USB_TYPE_STANDARD|USB_RECIP_DEVICE) << 8)
++			| USB_REQ_GET_STATUS:
++		tmp = (udc->selfpowered << USB_DEVICE_SELF_POWERED);
++		if (at91_udp_read(AT91_UDP_GLB_STAT) & AT91_UDP_ESR)
++			tmp |= (1 << USB_DEVICE_REMOTE_WAKEUP);
++		PACKET("get device status\n");
++		__raw_writeb(tmp, dreg);
++		__raw_writeb(0, dreg);
++		goto write_in;
++		/* then STATUS starts later, automatically */
++	case ((USB_TYPE_STANDARD|USB_RECIP_DEVICE) << 8)
++			| USB_REQ_SET_FEATURE:
++		if (w_value != USB_DEVICE_REMOTE_WAKEUP)
++			goto stall;
++		tmp = at91_udp_read(AT91_UDP_GLB_STAT);
++		tmp |= AT91_UDP_ESR;
++		at91_udp_write(AT91_UDP_GLB_STAT, tmp);
++		goto succeed;
++	case ((USB_TYPE_STANDARD|USB_RECIP_DEVICE) << 8)
++			| USB_REQ_CLEAR_FEATURE:
++		if (w_value != USB_DEVICE_REMOTE_WAKEUP)
++			goto stall;
++		tmp = at91_udp_read(AT91_UDP_GLB_STAT);
++		tmp &= ~AT91_UDP_ESR;
++		at91_udp_write(AT91_UDP_GLB_STAT, tmp);
++		goto succeed;
++
++	/*
++	 * Interfaces have no feature settings; this is pretty useless.
++	 * we won't even insist the interface exists...
++	 */
++	case ((USB_DIR_IN|USB_TYPE_STANDARD|USB_RECIP_INTERFACE) << 8)
++			| USB_REQ_GET_STATUS:
++		PACKET("get interface status\n");
++		__raw_writeb(0, dreg);
++		__raw_writeb(0, dreg);
++		goto write_in;
++		/* then STATUS starts later, automatically */
++	case ((USB_TYPE_STANDARD|USB_RECIP_INTERFACE) << 8)
++			| USB_REQ_SET_FEATURE:
++	case ((USB_TYPE_STANDARD|USB_RECIP_INTERFACE) << 8)
++			| USB_REQ_CLEAR_FEATURE:
++		goto stall;
++
++	/*
++	 * Hosts may clear bulk/intr endpoint halt after the gadget
++	 * driver sets it (not widely used); or set it (for testing)
++	 */
++	case ((USB_DIR_IN|USB_TYPE_STANDARD|USB_RECIP_ENDPOINT) << 8)
++			| USB_REQ_GET_STATUS:
++		tmp = w_index & USB_ENDPOINT_NUMBER_MASK;
++		ep = &udc->ep[tmp];
++		if (tmp > NUM_ENDPOINTS || (tmp && !ep->desc))
++			goto stall;
++
++		if (tmp) {
++			if ((w_index & USB_DIR_IN)) {
++				if (!ep->is_in)
++					goto stall;
++			} else if (ep->is_in)
++				goto stall;
++		}
++		PACKET("get %s status\n", ep->ep.name);
++		if (__raw_readl(ep->creg) & AT91_UDP_FORCESTALL)
++			tmp = (1 << USB_ENDPOINT_HALT);
++		else
++			tmp = 0;
++		__raw_writeb(tmp, dreg);
++		__raw_writeb(0, dreg);
++		goto write_in;
++		/* then STATUS starts later, automatically */
++	case ((USB_TYPE_STANDARD|USB_RECIP_ENDPOINT) << 8)
++			| USB_REQ_SET_FEATURE:
++		tmp = w_index & USB_ENDPOINT_NUMBER_MASK;
++		ep = &udc->ep[tmp];
++		if (w_value != USB_ENDPOINT_HALT || tmp > NUM_ENDPOINTS)
++			goto stall;
++		if (!ep->desc || ep->is_iso)
++			goto stall;
++		if ((w_index & USB_DIR_IN)) {
++			if (!ep->is_in)
++				goto stall;
++		} else if (ep->is_in)
++			goto stall;
++
++		tmp = __raw_readl(ep->creg);
++		tmp &= ~SET_FX;
++		tmp |= CLR_FX | AT91_UDP_FORCESTALL;
++		__raw_writel(tmp, ep->creg);
++		goto succeed;
++	case ((USB_TYPE_STANDARD|USB_RECIP_ENDPOINT) << 8)
++			| USB_REQ_CLEAR_FEATURE:
++		tmp = w_index & USB_ENDPOINT_NUMBER_MASK;
++		ep = &udc->ep[tmp];
++		if (w_value != USB_ENDPOINT_HALT || tmp > NUM_ENDPOINTS)
++			goto stall;
++		if (tmp == 0)
++			goto succeed;
++		if (!ep->desc || ep->is_iso)
++			goto stall;
++		if ((w_index & USB_DIR_IN)) {
++			if (!ep->is_in)
++				goto stall;
++		} else if (ep->is_in)
++			goto stall;
++
++		at91_udp_write(AT91_UDP_RST_EP, ep->int_mask);
++		at91_udp_write(AT91_UDP_RST_EP, 0);
++		tmp = __raw_readl(ep->creg);
++		tmp |= CLR_FX;
++		tmp &= ~(SET_FX | AT91_UDP_FORCESTALL);
++		__raw_writel(tmp, ep->creg);
++		if (!list_empty(&ep->queue))
++			handle_ep(ep);
++		goto succeed;
++	}
++
++#undef w_value
++#undef w_index
++#undef w_length
++
++	/* pass request up to the gadget driver */
++	status = udc->driver->setup(&udc->gadget, &pkt.r);
++	if (status < 0) {
++stall:
++		VDBG("req %02x.%02x protocol STALL; stat %d\n",
++				pkt.r.bRequestType, pkt.r.bRequest, status);
++		csr |= AT91_UDP_FORCESTALL;
++		__raw_writel(csr, creg);
++		udc->req_pending = 0;
++	}
++	return;
++
++succeed:
++	/* immediate successful (IN) STATUS after zero length DATA */
++	PACKET("ep0 in/status\n");
++write_in:
++	csr |= AT91_UDP_TXPKTRDY;
++	__raw_writel(csr, creg);
++	udc->req_pending = 0;
++	return;
++}
++
++static void handle_ep0(struct at91_udc *udc)
++{
++	struct at91_ep		*ep0 = &udc->ep[0];
++	u32 __iomem		*creg = ep0->creg;
++	u32			csr = __raw_readl(creg);
++	struct at91_request	*req;
++
++	if (unlikely(csr & AT91_UDP_STALLSENT)) {
++		nuke(ep0, -EPROTO);
++		udc->req_pending = 0;
++		csr |= CLR_FX;
++		csr &= ~(SET_FX | AT91_UDP_STALLSENT | AT91_UDP_FORCESTALL);
++		__raw_writel(csr, creg);
++		VDBG("ep0 stalled\n");
++		csr = __raw_readl(creg);
++	}
++	if (csr & AT91_UDP_RXSETUP) {
++		nuke(ep0, 0);
++		udc->req_pending = 0;
++		handle_setup(udc, ep0, csr);
++		return;
++	}
++
++	if (list_empty(&ep0->queue))
++		req = NULL;
++	else
++		req = list_entry(ep0->queue.next, struct at91_request, queue);
++
++	/* host ACKed an IN packet that we sent */
++	if (csr & AT91_UDP_TXCOMP) {
++		csr |= CLR_FX;
++		csr &= ~(SET_FX | AT91_UDP_TXCOMP);
++
++		/* write more IN DATA? */
++		if (req && ep0->is_in) {
++			if (handle_ep(ep0))
++				udc->req_pending = 0;
++
++		/*
++		 * Ack after:
++		 *  - last IN DATA packet (including GET_STATUS)
++		 *  - IN/STATUS for OUT DATA
++		 *  - IN/STATUS for any zero-length DATA stage
++		 * except for the IN DATA case, the host should send
++		 * an OUT status later, which we'll ack.
++		 */
++		} else {
++			udc->req_pending = 0;
++			__raw_writel(csr, creg);
++
++			/*
++			 * SET_ADDRESS takes effect only after the STATUS
++			 * (to the original address) gets acked.
++			 */
++			if (udc->wait_for_addr_ack) {
++				u32	tmp;
++
++				at91_udp_write(AT91_UDP_FADDR, AT91_UDP_FEN | udc->addr);
++				tmp = at91_udp_read(AT91_UDP_GLB_STAT);
++				tmp &= ~AT91_UDP_FADDEN;
++				if (udc->addr)
++					tmp |= AT91_UDP_FADDEN;
++				at91_udp_write(AT91_UDP_GLB_STAT, tmp);
++
++				udc->wait_for_addr_ack = 0;
++				VDBG("address %d\n", udc->addr);
++			}
++		}
++	}
++
++	/* OUT packet arrived ... */
++	else if (csr & AT91_UDP_RX_DATA_BK0) {
++		csr |= CLR_FX;
++		csr &= ~(SET_FX | AT91_UDP_RX_DATA_BK0);
++
++		/* OUT DATA stage */
++		if (!ep0->is_in) {
++			if (req) {
++				if (handle_ep(ep0)) {
++					/* send IN/STATUS */
++					PACKET("ep0 in/status\n");
++					csr = __raw_readl(creg);
++					csr &= ~SET_FX;
++					csr |= CLR_FX | AT91_UDP_TXPKTRDY;
++					__raw_writel(csr, creg);
++					udc->req_pending = 0;
++				}
++			} else if (udc->req_pending) {
++				/*
++				 * AT91 hardware has a hard time with this
++				 * "deferred response" mode for control-OUT
++				 * transfers.  (For control-IN it's fine.)
++				 *
++				 * The normal solution leaves OUT data in the
++				 * fifo until the gadget driver is ready.
++				 * We couldn't do that here without disabling
++				 * the IRQ that tells about SETUP packets,
++				 * e.g. when the host gets impatient...
++				 *
++				 * Working around it by copying into a buffer
++				 * would almost be a non-deferred response,
++				 * except that it wouldn't permit reliable
++				 * stalling of the request.  Instead, demand
++				 * that gadget drivers not use this mode.
++				 */
++				DBG("no control-OUT deferred responses!\n");
++				__raw_writel(csr | AT91_UDP_FORCESTALL, creg);
++				udc->req_pending = 0;
++			}
++
++		/* STATUS stage for control-IN; ack.  */
++		} else {
++			PACKET("ep0 out/status ACK\n");
++			__raw_writel(csr, creg);
++
++			/* "early" status stage */
++			if (req)
++				done(ep0, req, 0);
++		}
++	}
++}
++
++static irqreturn_t at91_udc_irq (int irq, void *_udc, struct pt_regs *r)
++{
++	struct at91_udc		*udc = _udc;
++	u32			rescans = 5;
++
++	while (rescans--) {
++		u32	status = at91_udp_read(AT91_UDP_ISR);
++
++		status &= at91_udp_read(AT91_UDP_IMR);
++		if (!status)
++			break;
++
++		/* USB reset irq:  not maskable */
++		if (status & AT91_UDP_ENDBUSRES) {
++			at91_udp_write(AT91_UDP_IDR, ~MINIMUS_INTERRUPTUS);
++			at91_udp_write(AT91_UDP_IER, MINIMUS_INTERRUPTUS);
++			/* Atmel code clears this irq twice */
++			at91_udp_write(AT91_UDP_ICR, AT91_UDP_ENDBUSRES);
++			at91_udp_write(AT91_UDP_ICR, AT91_UDP_ENDBUSRES);
++			VDBG("end bus reset\n");
++			udc->addr = 0;
++			stop_activity(udc);
++
++			/* enable ep0 */
++			at91_udp_write(AT91_UDP_CSR(0), AT91_UDP_EPEDS | AT91_UDP_EPTYPE_CTRL);
++			udc->gadget.speed = USB_SPEED_FULL;
++			udc->suspended = 0;
++			at91_udp_write(AT91_UDP_IER, AT91_UDP_EP(0));
++
++			/*
++			 * NOTE:  this driver keeps clocks off unless the
++			 * USB host is present.  That saves power, and also
++			 * eliminates IRQs (reset, resume, suspend) that can
++			 * otherwise flood from the controller.  If your
++			 * board doesn't support VBUS detection, suspend and
++			 * resume irq logic may need more attention...
++			 */
++
++		/* host initiated suspend (3+ms bus idle) */
++		} else if (status & AT91_UDP_RXSUSP) {
++			at91_udp_write(AT91_UDP_IDR, AT91_UDP_RXSUSP);
++			at91_udp_write(AT91_UDP_IER, AT91_UDP_RXRSM);
++			at91_udp_write(AT91_UDP_ICR, AT91_UDP_RXSUSP);
++			// VDBG("bus suspend\n");
++			if (udc->suspended)
++				continue;
++			udc->suspended = 1;
++
++			/*
++			 * NOTE:  when suspending a VBUS-powered device, the
++			 * gadget driver should switch into slow clock mode
++			 * and then into standby to avoid drawing more than
++			 * 500uA power (2500uA for some high-power configs).
++			 */
++			if (udc->driver && udc->driver->suspend)
++				udc->driver->suspend(&udc->gadget);
++
++		/* host initiated resume */
++		} else if (status & AT91_UDP_RXRSM) {
++			at91_udp_write(AT91_UDP_IDR, AT91_UDP_RXRSM);
++			at91_udp_write(AT91_UDP_IER, AT91_UDP_RXSUSP);
++			at91_udp_write(AT91_UDP_ICR, AT91_UDP_RXRSM);
++			// VDBG("bus resume\n");
++			if (!udc->suspended)
++				continue;
++			udc->suspended = 0;
++
++			/*
++			 * NOTE:  for a VBUS-powered device, the gadget driver
++			 * would normally want to switch out of slow clock
++			 * mode into normal mode.
++			 */
++			if (udc->driver && udc->driver->resume)
++				udc->driver->resume(&udc->gadget);
++
++		/* endpoint IRQs are cleared by handling them */
++		} else {
++			int		i;
++			unsigned	mask = 1;
++			struct at91_ep	*ep = &udc->ep[1];
++
++			if (status & mask)
++				handle_ep0(udc);
++			for (i = 1; i < NUM_ENDPOINTS; i++) {
++				mask <<= 1;
++				if (status & mask)
++					handle_ep(ep);
++				ep++;
++			}
++		}
++	}
++
++	return IRQ_HANDLED;
++}
++
++/*-------------------------------------------------------------------------*/
++
++static struct at91_udc controller = {
++	.gadget = {
++		.ops = &at91_udc_ops,
++		.ep0 = &controller.ep[0].ep,
++		.name = driver_name,
++		.dev = {
++			.bus_id = "gadget"
++		}
++	},
++	.ep[0] = {
++		.ep = {
++			.name	= ep0name,
++			.ops	= &at91_ep_ops,
++		},
++		.udc		= &controller,
++		.maxpacket	= 8,
++		.creg		= (void __iomem *)(AT91_VA_BASE_UDP + AT91_UDP_CSR(0)),
++		.int_mask	= 1 << 0,
++	},
++	.ep[1] = {
++		.ep = {
++			.name	= "ep1",
++			.ops	= &at91_ep_ops,
++		},
++		.udc		= &controller,
++		.is_pingpong	= 1,
++		.maxpacket	= 64,
++		.creg		= (void __iomem *)(AT91_VA_BASE_UDP + AT91_UDP_CSR(1)),
++		.int_mask	= 1 << 1,
++	},
++	.ep[2] = {
++		.ep = {
++			.name	= "ep2",
++			.ops	= &at91_ep_ops,
++		},
++		.udc		= &controller,
++		.is_pingpong	= 1,
++		.maxpacket	= 64,
++		.creg		= (void __iomem *)(AT91_VA_BASE_UDP + AT91_UDP_CSR(2)),
++		.int_mask	= 1 << 2,
++	},
++	.ep[3] = {
++		.ep = {
++			/* could actually do bulk too */
++			.name	= "ep3-int",
++			.ops	= &at91_ep_ops,
++		},
++		.udc		= &controller,
++		.maxpacket	= 8,
++		.creg		= (void __iomem *)(AT91_VA_BASE_UDP + AT91_UDP_CSR(3)),
++		.int_mask	= 1 << 3,
++	},
++	.ep[4] = {
++		.ep = {
++			.name	= "ep4",
++			.ops	= &at91_ep_ops,
++		},
++		.udc		= &controller,
++		.is_pingpong	= 1,
++		.maxpacket	= 256,
++		.creg		= (void __iomem *)(AT91_VA_BASE_UDP + AT91_UDP_CSR(4)),
++		.int_mask	= 1 << 4,
++	},
++	.ep[5] = {
++		.ep = {
++			.name	= "ep5",
++			.ops	= &at91_ep_ops,
++		},
++		.udc		= &controller,
++		.is_pingpong	= 1,
++		.maxpacket	= 256,
++		.creg		= (void __iomem *)(AT91_VA_BASE_UDP + AT91_UDP_CSR(5)),
++		.int_mask	= 1 << 5,
++	},
++	/* ep6 and ep7 are also reserved */
++};
++
++static irqreturn_t at91_vbus_irq(int irq, void *_udc, struct pt_regs *r)
++{
++	struct at91_udc	*udc = _udc;
++	unsigned	value;
++
++	/* vbus needs at least brief debouncing */
++	udelay(10);
++	value = at91_get_gpio_value(udc->board.vbus_pin);
++	if (value != udc->vbus)
++		at91_vbus_session(&udc->gadget, value);
++
++	return IRQ_HANDLED;
++}
++
++int usb_gadget_register_driver (struct usb_gadget_driver *driver)
++{
++	struct at91_udc	*udc = &controller;
++	int		retval;
++
++	if (!driver
++			|| driver->speed != USB_SPEED_FULL
++			|| !driver->bind
++			|| !driver->unbind
++			|| !driver->setup) {
++		DBG("bad parameter.\n");
++		return -EINVAL;
++	}
++
++	if (udc->driver) {
++		DBG("UDC already has a gadget driver\n");
++		return -EBUSY;
++	}
++
++	udc->driver = driver;
++	udc->gadget.dev.driver = &driver->driver;
++	udc->gadget.dev.driver_data = &driver->driver;
++	udc->enabled = 1;
++	udc->selfpowered = 1;
++
++	retval = driver->bind(&udc->gadget);
++	if (retval) {
++		DBG("driver->bind() returned %d\n", retval);
++		udc->driver = NULL;
++		return retval;
++	}
++
++	local_irq_disable();
++	pullup(udc, 1);
++	local_irq_enable();
++
++	DBG("bound to %s\n", driver->driver.name);
++	return 0;
++}
++EXPORT_SYMBOL (usb_gadget_register_driver);
++
++int usb_gadget_unregister_driver (struct usb_gadget_driver *driver)
++{
++	struct at91_udc *udc = &controller;
++
++	if (!driver || driver != udc->driver)
++		return -EINVAL;
++
++	local_irq_disable();
++	udc->enabled = 0;
++	pullup(udc, 0);
++	local_irq_enable();
++
++	driver->unbind(&udc->gadget);
++	udc->driver = NULL;
++
++	DBG("unbound from %s\n", driver->driver.name);
++	return 0;
++}
++EXPORT_SYMBOL (usb_gadget_unregister_driver);
++
++/*-------------------------------------------------------------------------*/
++
++static void at91udc_shutdown(struct platform_device *dev)
++{
++	/* force disconnect on reboot */
++	pullup(platform_get_drvdata(dev), 0);
++}
++
++static int __devinit at91udc_probe(struct platform_device *pdev)
++{
++	struct device	*dev = &pdev->dev;
++	struct at91_udc	*udc;
++	int		retval;
++
++	if (!dev->platform_data) {
++		/* small (so we copy it) but critical! */
++		DBG("missing platform_data\n");
++		return -ENODEV;
++	}
++
++	if (!request_mem_region(AT91_BASE_UDP, SZ_16K, driver_name)) {
++		DBG("someone's using UDC memory\n");
++		return -EBUSY;
++	}
++
++	/* init software state */
++	udc = &controller;
++	udc->gadget.dev.parent = dev;
++	udc->board = *(struct at91_udc_data *) dev->platform_data;
++	udc->pdev = pdev;
++	udc_reinit(udc);
++	udc->enabled = 0;
++
++	/* get interface and function clocks */
++	udc->iclk = clk_get(dev, "udc_clk");
++	udc->fclk = clk_get(dev, "udpck");
++	if (IS_ERR(udc->iclk) || IS_ERR(udc->fclk)) {
++		DBG("clocks missing\n");
++		return -ENODEV;
++	}
++
++	retval = device_register(&udc->gadget.dev);
++	if (retval < 0)
++		goto fail0;
++
++	/* disable everything until there's a gadget driver and vbus */
++	pullup(udc, 0);
++
++	/* request UDC and maybe VBUS irqs */
++	if (request_irq(AT91_ID_UDP, at91_udc_irq, SA_INTERRUPT, driver_name, udc)) {
++		DBG("request irq %d failed\n", AT91_ID_UDP);
++		retval = -EBUSY;
++		goto fail1;
++	}
++	if (udc->board.vbus_pin > 0) {
++		if (request_irq(udc->board.vbus_pin, at91_vbus_irq, SA_INTERRUPT, driver_name, udc)) {
++			DBG("request vbus irq %d failed\n", udc->board.vbus_pin);
++			free_irq(AT91_ID_UDP, udc);
++			retval = -EBUSY;
++			goto fail1;
++		}
++	} else {
++		DBG("no VBUS detection, assuming always-on\n");
++		udc->vbus = 1;
++	}
++	dev_set_drvdata(dev, udc);
++	create_debug_file(udc);
++
++	INFO("%s version %s\n", driver_name, DRIVER_VERSION);
++	return 0;
++
++fail1:
++	device_unregister(&udc->gadget.dev);
++fail0:
++	release_mem_region(AT91_VA_BASE_UDP, SZ_16K);
++	DBG("%s probe failed, %d\n", driver_name, retval);
++	return retval;
++}
++
++static int __devexit at91udc_remove(struct platform_device *dev)
++{
++	struct at91_udc *udc = platform_get_drvdata(dev);
++
++	DBG("remove\n");
++
++	pullup(udc, 0);
++
++	if (udc->driver != 0)
++		usb_gadget_unregister_driver(udc->driver);
++
++	remove_debug_file(udc);
++	if (udc->board.vbus_pin > 0)
++		free_irq(udc->board.vbus_pin, udc);
++	free_irq(AT91_ID_UDP, udc);
++	device_unregister(&udc->gadget.dev);
++	release_mem_region(AT91_BASE_UDP, SZ_16K);
++
++	clk_put(udc->iclk);
++	clk_put(udc->fclk);
++
++	return 0;
++}
++
++#ifdef CONFIG_PM
++static int at91udc_suspend(struct platform_device *dev, u32 state, u32 level)
++{
++	struct at91_udc *udc = platform_get_drvdata(dev);
++
++	/*
++	 * The "safe" suspend transitions are opportunistic ... e.g. when
++	 * the USB link is suspended (48MHz clock autogated off), or when
++	 * it's disconnected (programmatically gated off, elsewhere).
++	 * Then we can suspend, and the chip can enter slow clock mode.
++	 *
++	 * The problem case is some component (user mode?) suspending this
++	 * device while it's active, with the 48 MHz clock in use.  There
++	 * are two basic approaches:  (a) veto suspend levels involving slow
++	 * clock mode, (b) disconnect, so 48 MHz will no longer be in use
++	 * and we can enter slow clock mode.  This uses (b) for now, since
++	 * it's simplest until AT91 PM exists and supports the other option.
++	 */
++	if (udc->vbus && !udc->suspended)
++		pullup(udc, 0);
++	return 0;
++}
++
++static int at91udc_resume(struct platform_device *dev, u32 level)
++{
++	struct at91_udc *udc = platform_get_drvdata(dev);
++
++	/* maybe reconnect to host; if so, clocks on */
++	pullup(udc, 1);
++	return 0;
++}
++#else
++#define	at91udc_suspend	NULL
++#define	at91udc_resume	NULL
++#endif
++
++static struct platform_driver at91_udc = {
++	.probe		= at91udc_probe,
++	.remove		= __devexit_p(at91udc_remove),
++	.shutdown	= at91udc_shutdown,
++	.suspend	= at91udc_suspend,
++	.resume 	= at91udc_resume,
++	.driver		= {
++		.name	= (char *) driver_name,
++		.owner	= THIS_MODULE,
++	},
++};
++
++static int __devinit udc_init_module(void)
++{
++	return platform_driver_register(&at91_udc);
++}
++module_init(udc_init_module);
++
++static void __devexit udc_exit_module(void)
++{
++	platform_driver_unregister(&at91_udc);
++}
++module_exit(udc_exit_module);
++
++MODULE_DESCRIPTION("AT91RM9200 udc driver");
++MODULE_AUTHOR("Thomas Rathbone, David Brownell");
++MODULE_LICENSE("GPL");
+--- /dev/null
++++ gregkh-2.6/drivers/usb/gadget/at91_udc.h
+@@ -0,0 +1,181 @@
++/*
++ * Copyright (C) 2004 by Thomas Rathbone, HP Labs
++ * Copyright (C) 2005 by Ivan Kokshaysky
++ * Copyright (C) 2006 by SAN People
++ *
++ * 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.,
++ * 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
++ */
++
++#ifndef AT91_UDC_H
++#define AT91_UDC_H
++
++/*
++ * USB Device Port (UDP) registers.
++ * Based on AT91RM9200 datasheet revision E.
++ */
++
++#define AT91_UDP_FRM_NUM	0x00		/* Frame Number Register */
++#define     AT91_UDP_NUM	(0x7ff <<  0)	/* Frame Number */
++#define     AT91_UDP_FRM_ERR	(1     << 16)	/* Frame Error */
++#define     AT91_UDP_FRM_OK	(1     << 17)	/* Frame OK */
++
++#define AT91_UDP_GLB_STAT	0x04		/* Global State Register */
++#define     AT91_UDP_FADDEN	(1 <<  0)	/* Function Address Enable */
++#define     AT91_UDP_CONFG	(1 <<  1)	/* Configured */
++#define     AT91_UDP_ESR	(1 <<  2)	/* Enable Send Resume */
++#define     AT91_UDP_RSMINPR	(1 <<  3)	/* Resume has been sent */
++#define     AT91_UDP_RMWUPE	(1 <<  4)	/* Remote Wake Up Enable */
++
++#define AT91_UDP_FADDR		0x08		/* Function Address Register */
++#define     AT91_UDP_FADD	(0x7f << 0)	/* Function Address Value */
++#define     AT91_UDP_FEN	(1    << 8)	/* Function Enable */
++
++#define AT91_UDP_IER		0x10		/* Interrupt Enable Register */
++#define AT91_UDP_IDR		0x14		/* Interrupt Disable Register */
++#define AT91_UDP_IMR		0x18		/* Interrupt Mask Register */
++
++#define AT91_UDP_ISR		0x1c		/* Interrupt Status Register */
++#define     AT91_UDP_EP(n)	(1 << (n))	/* Endpoint Interrupt Status */
++#define     AT91_UDP_RXSUSP	(1 <<  8) 	/* USB Suspend Interrupt Status */
++#define     AT91_UDP_RXRSM	(1 <<  9)	/* USB Resume Interrupt Status */
++#define     AT91_UDP_EXTRSM	(1 << 10)	/* External Resume Interrupt Status */
++#define     AT91_UDP_SOFINT	(1 << 11)	/* Start of Frame Interrupt Status */
++#define     AT91_UDP_ENDBUSRES	(1 << 12)	/* End of Bus Reset Interrpt Status */
++#define     AT91_UDP_WAKEUP	(1 << 13)	/* USB Wakeup Interrupt Status */
++
++#define AT91_UDP_ICR		0x20		/* Interrupt Clear Register */
++#define AT91_UDP_RST_EP		0x28		/* Reset Endpoint Register */
++
++#define AT91_UDP_CSR(n)		(0x30+((n)*4))	/* Endpoint Control/Status Registers 0-7 */
++#define     AT91_UDP_TXCOMP	(1 <<  0)	/* Generates IN packet with data previously written in DPR */
++#define     AT91_UDP_RX_DATA_BK0 (1 <<  1)	/* Receive Data Bank 0 */
++#define     AT91_UDP_RXSETUP	(1 <<  2)	/* Send STALL to the host */
++#define     AT91_UDP_STALLSENT	(1 <<  3)	/* Stall Sent / Isochronous error (Isochronous endpoints) */
++#define     AT91_UDP_TXPKTRDY	(1 <<  4)	/* Transmit Packet Ready */
++#define     AT91_UDP_FORCESTALL	(1 <<  5)	/* Force Stall */
++#define     AT91_UDP_RX_DATA_BK1 (1 <<  6)	/* Receive Data Bank 1 */
++#define     AT91_UDP_DIR	(1 <<  7)	/* Transfer Direction */
++#define     AT91_UDP_EPTYPE	(7 <<  8)	/* Endpoint Type */
++#define		AT91_UDP_EPTYPE_CTRL		(0 <<  8)
++#define		AT91_UDP_EPTYPE_ISO_OUT		(1 <<  8)
++#define		AT91_UDP_EPTYPE_BULK_OUT	(2 <<  8)
++#define		AT91_UDP_EPTYPE_INT_OUT		(3 <<  8)
++#define		AT91_UDP_EPTYPE_ISO_IN		(5 <<  8)
++#define		AT91_UDP_EPTYPE_BULK_IN		(6 <<  8)
++#define		AT91_UDP_EPTYPE_INT_IN		(7 <<  8)
++#define     AT91_UDP_DTGLE	(1 << 11)	/* Data Toggle */
++#define     AT91_UDP_EPEDS	(1 << 15)	/* Endpoint Enable/Disable */
++#define     AT91_UDP_RXBYTECNT	(0x7ff << 16)	/* Number of bytes in FIFO */
++
++#define AT91_UDP_FDR(n)		(0x50+((n)*4))	/* Endpoint FIFO Data Registers 0-7 */
++
++#define AT91_UDP_TXVC		0x74		/* Transceiver Control Register */
++#define     AT91_UDP_TXVC_TXVDIS (1 << 8)	/* Transceiver Disable */
++
++
++/*-------------------------------------------------------------------------*/
++
++/*
++ * controller driver data structures
++ */
++
++#define	NUM_ENDPOINTS	6
++
++/*
++ * hardware won't disable bus reset, or resume while the controller
++ * is suspended ... watching suspend helps keep the logic symmetric.
++ */
++#define	MINIMUS_INTERRUPTUS \
++	(AT91_UDP_ENDBUSRES | AT91_UDP_RXRSM | AT91_UDP_RXSUSP)
++
++struct at91_ep {
++	struct usb_ep			ep;
++	struct list_head		queue;
++	struct at91_udc			*udc;
++	void __iomem			*creg;
++
++	unsigned			maxpacket:16;
++	u8				int_mask;
++	unsigned			is_pingpong:1;
++
++	unsigned			stopped:1;
++	unsigned			is_in:1;
++	unsigned			is_iso:1;
++	unsigned			fifo_bank:1;
++
++	const struct usb_endpoint_descriptor
++					*desc;
++};
++
++/*
++ * driver is non-SMP, and just blocks IRQs whenever it needs
++ * access protection for chip registers or driver state
++ */
++struct at91_udc {
++	struct usb_gadget		gadget;
++	struct at91_ep			ep[NUM_ENDPOINTS];
++	struct usb_gadget_driver	*driver;
++	unsigned			vbus:1;
++	unsigned			enabled:1;
++	unsigned			clocked:1;
++	unsigned			suspended:1;
++	unsigned			req_pending:1;
++	unsigned			wait_for_addr_ack:1;
++	unsigned			wait_for_config_ack:1;
++	unsigned			selfpowered:1;
++	u8				addr;
++	struct at91_udc_data		board;
++	struct clk			*iclk, *fclk;
++	struct platform_device		*pdev;
++	struct proc_dir_entry		*pde;
++};
++
++static inline struct at91_udc *to_udc(struct usb_gadget *g)
++{
++	return container_of(g, struct at91_udc, gadget);
++}
++
++struct at91_request {
++	struct usb_request		req;
++	struct list_head		queue;
++};
++
++/*-------------------------------------------------------------------------*/
++
++#ifdef DEBUG
++#define DBG(stuff...)		printk(KERN_DEBUG "udc: " stuff)
++#else
++#define DBG(stuff...)		do{}while(0)
++#endif
++
++#ifdef VERBOSE
++#    define VDBG		DBG
++#else
++#    define VDBG(stuff...)	do{}while(0)
++#endif
++
++#ifdef PACKET_TRACE
++#    define PACKET		VDBG
++#else
++#    define PACKET(stuff...)	do{}while(0)
++#endif
++
++#define ERR(stuff...)		printk(KERN_ERR "udc: " stuff)
++#define WARN(stuff...)		printk(KERN_WARNING "udc: " stuff)
++#define INFO(stuff...)		printk(KERN_INFO "udc: " stuff)
++
++#endif
++
diff --git a/usb/usb-add-support-for-ochi-on-at91rm9200.patch b/usb/usb-add-support-for-ochi-on-at91rm9200.patch
new file mode 100644
index 00000000000000..945b88cbe20770
--- /dev/null
+++ b/usb/usb-add-support-for-ochi-on-at91rm9200.patch
@@ -0,0 +1,378 @@
+From david-b@pacbell.net Sun Jan 22 11:29:00 2006
+From: David Brownell <david-b@pacbell.net>
+To: Greg KH <greg@kroah.com>
+Subject: USB: add support for OCHI on AT91rm9200
+Date: Sun, 22 Jan 2006 10:32:13 -0800
+Cc: Andrew Victor <andrew@sanpeople.com>
+Message-Id: <200601221032.13463.david-b@pacbell.net>
+
+From: Andrew Victor <andrew@sanpeople.com>
+
+This adds support for OHCI on AT91rm9200 based boards.
+
+Possibly of interest here is the way this uses <linux/clk.h> to
+gate clocks on/off during system pm state transitions.  That's
+typical for non-PCI systems.  Some can go further; Mini-A host
+side connectors enable ID-pin sensing.
+
+From: Andrew Victor <andrew@sanpeople.com>
+Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
+Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
+
+---
+ drivers/usb/Kconfig          |    1 
+ drivers/usb/Makefile         |    1 
+ drivers/usb/host/ohci-at91.c |  306 +++++++++++++++++++++++++++++++++++++++++++
+ drivers/usb/host/ohci-hcd.c  |    5 
+ 4 files changed, 313 insertions(+)
+
+--- gregkh-2.6.orig/drivers/usb/Kconfig
++++ gregkh-2.6/drivers/usb/Kconfig
+@@ -23,6 +23,7 @@ config USB_ARCH_HAS_OHCI
+ 	default y if ARCH_LH7A404
+ 	default y if ARCH_S3C2410
+ 	default y if PXA27x
++	default y if ARCH_AT91RM9200
+ 	# PPC:
+ 	default y if STB03xxx
+ 	default y if PPC_MPC52xx
+--- gregkh-2.6.orig/drivers/usb/Makefile
++++ gregkh-2.6/drivers/usb/Makefile
+@@ -15,6 +15,7 @@ obj-$(CONFIG_USB_OHCI_HCD)	+= host/
+ obj-$(CONFIG_USB_UHCI_HCD)	+= host/
+ obj-$(CONFIG_USB_SL811_HCD)	+= host/
+ obj-$(CONFIG_ETRAX_USB_HOST)	+= host/
++obj-$(CONFIG_USB_OHCI_AT91)	+= host/
+ 
+ obj-$(CONFIG_USB_ACM)		+= class/
+ obj-$(CONFIG_USB_AUDIO)		+= class/
+--- /dev/null
++++ gregkh-2.6/drivers/usb/host/ohci-at91.c
+@@ -0,0 +1,306 @@
++/*
++ * OHCI HCD (Host Controller Driver) for USB.
++ *
++ *  Copyright (C) 2004 SAN People (Pty) Ltd.
++ *  Copyright (C) 2005 Thibaut VARENE <varenet@parisc-linux.org>
++ *
++ * AT91RM9200 Bus Glue
++ *
++ * Based on fragments of 2.4 driver by Rick Bronson.
++ * Based on ohci-omap.c
++ *
++ * This file is licenced under the GPL.
++ */
++
++#include <linux/clk.h>
++#include <linux/platform_device.h>
++
++#include <asm/mach-types.h>
++#include <asm/hardware.h>
++#include <asm/arch/board.h>
++
++#ifndef CONFIG_ARCH_AT91RM9200
++#error "This file is AT91RM9200 bus glue.  CONFIG_ARCH_AT91RM9200 must be defined."
++#endif
++
++/* interface and function clocks */
++static struct clk *iclk, *fclk;
++
++extern int usb_disabled(void);
++
++/*-------------------------------------------------------------------------*/
++
++static void at91_start_hc(struct platform_device *pdev)
++{
++	struct usb_hcd *hcd = platform_get_drvdata(pdev);
++	struct ohci_regs __iomem *regs = hcd->regs;
++
++	dev_dbg(&pdev->dev, "starting AT91RM9200 OHCI USB Controller\n");
++
++	/*
++	 * Start the USB clocks.
++	 */
++	clk_enable(iclk);
++	clk_enable(fclk);
++
++	/*
++	 * The USB host controller must remain in reset.
++	 */
++	writel(0, &regs->control);
++}
++
++static void at91_stop_hc(struct platform_device *pdev)
++{
++	struct usb_hcd *hcd = platform_get_drvdata(pdev);
++	struct ohci_regs __iomem *regs = hcd->regs;
++
++	dev_dbg(&pdev->dev, "stopping AT91RM9200 OHCI USB Controller\n");
++
++	/*
++	 * Put the USB host controller into reset.
++	 */
++	writel(0, &regs->control);
++
++	/*
++	 * Stop the USB clocks.
++	 */
++	clk_disable(fclk);
++	clk_disable(iclk);
++}
++
++
++/*-------------------------------------------------------------------------*/
++
++static int usb_hcd_at91_remove (struct usb_hcd *, struct platform_device *);
++
++/* configure so an HC device and id are always provided */
++/* always called with process context; sleeping is OK */
++
++
++/**
++ * usb_hcd_at91_probe - initialize AT91RM9200-based HCDs
++ * Context: !in_interrupt()
++ *
++ * Allocates basic resources for this USB host controller, and
++ * then invokes the start() method for the HCD associated with it
++ * through the hotplug entry's driver_data.
++ *
++ * Store this function in the HCD's struct pci_driver as probe().
++ */
++int usb_hcd_at91_probe (const struct hc_driver *driver, struct platform_device *pdev)
++{
++	int retval;
++	struct usb_hcd *hcd = NULL;
++
++	if (pdev->num_resources != 2) {
++		pr_debug("hcd probe: invalid num_resources");
++		return -ENODEV;
++	}
++
++	if ((pdev->resource[0].flags != IORESOURCE_MEM) || (pdev->resource[1].flags != IORESOURCE_IRQ)) {
++		pr_debug("hcd probe: invalid resource type\n");
++		return -ENODEV;
++	}
++
++	hcd = usb_create_hcd(driver, &pdev->dev, "at91rm9200");
++	if (!hcd)
++		return -ENOMEM;
++	hcd->rsrc_start = pdev->resource[0].start;
++	hcd->rsrc_len = pdev->resource[0].end - pdev->resource[0].start + 1;
++
++	if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len, hcd_name)) {
++		pr_debug("request_mem_region failed\n");
++		retval = -EBUSY;
++		goto err1;
++	}
++
++	hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len);
++	if (!hcd->regs) {
++		pr_debug("ioremap failed\n");
++		retval = -EIO;
++		goto err2;
++	}
++
++	iclk = clk_get(&pdev->dev, "ohci_clk");
++	fclk = clk_get(&pdev->dev, "uhpck");
++
++	at91_start_hc(pdev);
++	ohci_hcd_init(hcd_to_ohci(hcd));
++
++	retval = usb_add_hcd(hcd, pdev->resource[1].start, SA_INTERRUPT);
++	if (retval == 0)
++		return retval;
++
++	/* Error handling */
++	at91_stop_hc(pdev);
++
++	clk_put(fclk);
++	clk_put(iclk);
++
++	iounmap(hcd->regs);
++
++ err2:
++	release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
++
++ err1:
++	usb_put_hcd(hcd);
++	return retval;
++}
++
++
++/* may be called without controller electrically present */
++/* may be called with controller, bus, and devices active */
++
++/**
++ * usb_hcd_at91_remove - shutdown processing for AT91RM9200-based HCDs
++ * @dev: USB Host Controller being removed
++ * Context: !in_interrupt()
++ *
++ * Reverses the effect of usb_hcd_at91_probe(), first invoking
++ * the HCD's stop() method.  It is always called from a thread
++ * context, normally "rmmod", "apmd", or something similar.
++ *
++ */
++static int usb_hcd_at91_remove (struct usb_hcd *hcd, struct platform_device *pdev)
++{
++	usb_remove_hcd(hcd);
++	at91_stop_hc(pdev);
++	iounmap(hcd->regs);
++ 	release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
++
++ 	clk_put(fclk);
++ 	clk_put(iclk);
++ 	fclk = iclk = NULL;
++
++	dev_set_drvdata(&pdev->dev, NULL);
++	return 0;
++}
++
++/*-------------------------------------------------------------------------*/
++
++static int __devinit
++ohci_at91_start (struct usb_hcd *hcd)
++{
++//	struct at91_ohci_data	*board = hcd->self.controller->platform_data;
++	struct ohci_hcd		*ohci = hcd_to_ohci (hcd);
++	int			ret;
++
++	if ((ret = ohci_init(ohci)) < 0)
++		return ret;
++
++	if ((ret = ohci_run(ohci)) < 0) {
++		err("can't start %s", hcd->self.bus_name);
++		ohci_stop(hcd);
++		return ret;
++	}
++//	hcd->self.root_hub->maxchild = board->ports;
++	return 0;
++}
++
++/*-------------------------------------------------------------------------*/
++
++static const struct hc_driver ohci_at91_hc_driver = {
++	.description =		hcd_name,
++	.product_desc =		"AT91RM9200 OHCI",
++	.hcd_priv_size =	sizeof(struct ohci_hcd),
++
++	/*
++	 * generic hardware linkage
++	 */
++	.irq =			ohci_irq,
++	.flags =		HCD_USB11 | HCD_MEMORY,
++
++	/*
++	 * basic lifecycle operations
++	 */
++	.start =		ohci_at91_start,
++	.stop =			ohci_stop,
++
++	/*
++	 * managing i/o requests and associated device resources
++	 */
++	.urb_enqueue =		ohci_urb_enqueue,
++	.urb_dequeue =		ohci_urb_dequeue,
++	.endpoint_disable =	ohci_endpoint_disable,
++
++	/*
++	 * scheduling support
++	 */
++	.get_frame_number =	ohci_get_frame,
++
++	/*
++	 * root hub support
++	 */
++	.hub_status_data =	ohci_hub_status_data,
++	.hub_control =		ohci_hub_control,
++
++#ifdef CONFIG_PM
++	.hub_suspend =		ohci_hub_suspend,
++	.hub_resume =		ohci_hub_resume,
++#endif
++	.start_port_reset =	ohci_start_port_reset,
++};
++
++/*-------------------------------------------------------------------------*/
++
++static int ohci_hcd_at91_drv_probe(struct platform_device *dev)
++{
++	return usb_hcd_at91_probe(&ohci_at91_hc_driver, dev);
++}
++
++static int ohci_hcd_at91_drv_remove(struct platform_device *dev)
++{
++	return usb_hcd_at91_remove(platform_get_drvdata(dev), dev);
++}
++
++#ifdef CONFIG_PM
++static int ohci_hcd_at91_drv_suspend(struct platform_device *dev, u32 state, u32 level)
++{
++	printk("%s(%s:%d): not implemented yet\n",
++		__func__, __FILE__, __LINE__);
++
++	clk_disable(fclk);
++
++	return 0;
++}
++
++static int ohci_hcd_at91_drv_resume(struct platform_device *dev, u32 state)
++{
++	printk("%s(%s:%d): not implemented yet\n",
++		__func__, __FILE__, __LINE__);
++
++	clk_enable(fclk);
++
++	return 0;
++}
++#else
++#define ohci_hcd_at91_drv_suspend NULL
++#define ohci_hcd_at91_drv_resume  NULL
++#endif
++
++static struct platform_driver ohci_hcd_at91_driver = {
++	.probe		= ohci_hcd_at91_drv_probe,
++	.remove		= ohci_hcd_at91_drv_remove,
++	.suspend	= ohci_hcd_at91_drv_suspend,
++	.resume		= ohci_hcd_at91_drv_resume,
++	.driver		= {
++		.name	= "at91rm9200-ohci",
++		.owner	= THIS_MODULE,
++	},
++};
++
++static int __init ohci_hcd_at91_init (void)
++{
++	if (usb_disabled())
++		return -ENODEV;
++
++	return platform_driver_register(&ohci_hcd_at91_driver);
++}
++
++static void __exit ohci_hcd_at91_cleanup (void)
++{
++	platform_driver_unregister(&ohci_hcd_at91_driver);
++}
++
++module_init (ohci_hcd_at91_init);
++module_exit (ohci_hcd_at91_cleanup);
+--- gregkh-2.6.orig/drivers/usb/host/ohci-hcd.c
++++ gregkh-2.6/drivers/usb/host/ohci-hcd.c
+@@ -905,6 +905,10 @@ MODULE_LICENSE ("GPL");
+ #include "ohci-ppc-soc.c"
+ #endif
+ 
++#ifdef CONFIG_ARCH_AT91RM9200
++#include "ohci-at91.c"
++#endif
++
+ #if !(defined(CONFIG_PCI) \
+       || defined(CONFIG_SA1111) \
+       || defined(CONFIG_ARCH_S3C2410) \
+@@ -913,6 +917,7 @@ MODULE_LICENSE ("GPL");
+       || defined (CONFIG_PXA27x) \
+       || defined (CONFIG_SOC_AU1X00) \
+       || defined (CONFIG_USB_OHCI_HCD_PPC_SOC) \
++      || defined (CONFIG_ARCH_AT91RM9200) \
+ 	)
+ #error "missing bus glue for ohci-hcd"
+ #endif
diff --git a/usb/usb-core-and-hcds-don-t-put_device-while-atomic.patch b/usb/usb-core-and-hcds-don-t-put_device-while-atomic.patch
index 2951a78c6b4b1c..3178ac8250ca97 100644
--- a/usb/usb-core-and-hcds-don-t-put_device-while-atomic.patch
+++ b/usb/usb-core-and-hcds-don-t-put_device-while-atomic.patch
@@ -105,7 +105,7 @@ Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
  	switch (urb->dev->speed) {
 --- gregkh-2.6.orig/drivers/usb/host/ehci-sched.c
 +++ gregkh-2.6/drivers/usb/host/ehci-sched.c
-@@ -1397,7 +1397,7 @@ itd_complete (
+@@ -1399,7 +1399,7 @@ itd_complete (
  	 */
  
  	/* give urb back to the driver ... can be out-of-order */
@@ -114,7 +114,7 @@ Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
  	ehci_urb_done (ehci, urb, regs);
  	urb = NULL;
  
-@@ -1416,7 +1416,6 @@ itd_complete (
+@@ -1418,7 +1418,6 @@ itd_complete (
  			(stream->bEndpointAddress & USB_DIR_IN) ? "in" : "out");
  	}
  	iso_stream_put (ehci, stream);
@@ -122,7 +122,7 @@ Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
  
  	return 1;
  }
-@@ -1763,7 +1762,7 @@ sitd_complete (
+@@ -1765,7 +1764,7 @@ sitd_complete (
  	 */
  
  	/* give urb back to the driver */
@@ -131,7 +131,7 @@ Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
  	ehci_urb_done (ehci, urb, regs);
  	urb = NULL;
  
-@@ -1782,7 +1781,6 @@ sitd_complete (
+@@ -1784,7 +1783,6 @@ sitd_complete (
  			(stream->bEndpointAddress & USB_DIR_IN) ? "in" : "out");
  	}
  	iso_stream_put (ehci, stream);
diff --git a/usb/usb-ehci-another-full-speed-iso-fix.patch b/usb/usb-ehci-another-full-speed-iso-fix.patch
new file mode 100644
index 00000000000000..28c0338a55c2e9
--- /dev/null
+++ b/usb/usb-ehci-another-full-speed-iso-fix.patch
@@ -0,0 +1,30 @@
+From david-b@pacbell.net Sun Jan 22 11:29:03 2006
+From: David Brownell <david-b@pacbell.net>
+To: Greg KH <greg@kroah.com>
+Subject: USB: EHCI, another full speed iso fix
+Date: Sun, 22 Jan 2006 10:32:49 -0800
+Message-Id: <200601221032.49822.david-b@pacbell.net>
+
+From: Clemens Ladisch <clemens@ladisch.de>
+
+This patch adds a reinitializion for the uf variable that got modified
+by the preceding start-split bandwidth check.
+
+Signed-off-by: Clemens Ladisch <clemens@ladisch.de>
+Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
+Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
+
+---
+ drivers/usb/host/ehci-sched.c |    1 +
+ 1 file changed, 1 insertion(+)
+
+--- gregkh-2.6.orig/drivers/usb/host/ehci-sched.c
++++ gregkh-2.6/drivers/usb/host/ehci-sched.c
+@@ -1063,6 +1063,7 @@ sitd_slot_ok (
+ 
+ 		/* for IN, check CSPLIT */
+ 		if (stream->c_usecs) {
++			uf = uframe & 7;
+ 			max_used = 100 - stream->c_usecs;
+ 			do {
+ 				tmp = 1 << uf;
diff --git a/usb/usb-ehci-fix-gfp_t-sparse-warning.patch b/usb/usb-ehci-fix-gfp_t-sparse-warning.patch
index 7e9c818b066dea..df91b8021ed9f6 100644
--- a/usb/usb-ehci-fix-gfp_t-sparse-warning.patch
+++ b/usb/usb-ehci-fix-gfp_t-sparse-warning.patch
@@ -22,7 +22,7 @@ Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
 
 --- gregkh-2.6.orig/drivers/usb/host/ehci-sched.c
 +++ gregkh-2.6/drivers/usb/host/ehci-sched.c
-@@ -1843,8 +1843,7 @@ done:
+@@ -1844,8 +1844,7 @@ done:
  #else
  
  static inline int
diff --git a/usb/usb-gotemp.patch b/usb/usb-gotemp.patch
index 5d00ccc1f26ba6..15b86c93073754 100644
--- a/usb/usb-gotemp.patch
+++ b/usb/usb-gotemp.patch
@@ -331,7 +331,7 @@
 +MODULE_LICENSE("GPL");
 --- gregkh-2.6.orig/drivers/usb/Makefile
 +++ gregkh-2.6/drivers/usb/Makefile
-@@ -66,6 +66,7 @@ obj-$(CONFIG_USB_AUERSWALD)	+= misc/
+@@ -67,6 +67,7 @@ obj-$(CONFIG_USB_AUERSWALD)	+= misc/
  obj-$(CONFIG_USB_CYTHERM)	+= misc/
  obj-$(CONFIG_USB_EMI26)		+= misc/
  obj-$(CONFIG_USB_EMI62)		+= misc/
diff --git a/usb/usb-hid-add-blacklist-entry-for-hp-keyboard.patch b/usb/usb-hid-add-blacklist-entry-for-hp-keyboard.patch
index a461f4eaf079bb..bda20c23a9964e 100644
--- a/usb/usb-hid-add-blacklist-entry-for-hp-keyboard.patch
+++ b/usb/usb-hid-add-blacklist-entry-for-hp-keyboard.patch
@@ -25,7 +25,7 @@ Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
 
 --- gregkh-2.6.orig/drivers/usb/input/hid-core.c
 +++ gregkh-2.6/drivers/usb/input/hid-core.c
-@@ -1445,6 +1445,9 @@ void hid_init_reports(struct hid_device 
+@@ -1453,6 +1453,9 @@ void hid_init_reports(struct hid_device 
  #define USB_VENDOR_ID_CHERRY		0x046a
  #define USB_DEVICE_ID_CHERRY_CYMOTION	0x0023
  
@@ -35,7 +35,7 @@ Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
  /*
   * Alphabetically sorted blacklist by quirk type.
   */
-@@ -1558,6 +1561,7 @@ static const struct hid_blacklist {
+@@ -1566,6 +1569,7 @@ static const struct hid_blacklist {
  	{ USB_VENDOR_ID_ATEN, USB_DEVICE_ID_ATEN_4PORTKVMC, HID_QUIRK_NOGET },
  	{ USB_VENDOR_ID_BTC, USB_DEVICE_ID_BTC_KEYBOARD, HID_QUIRK_NOGET},
  	{ USB_VENDOR_ID_CHICONY, USB_DEVICE_ID_CHICONY_USBHUB_KB, HID_QUIRK_NOGET},
@@ -43,7 +43,7 @@ Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
  	{ USB_VENDOR_ID_TANGTOP, USB_DEVICE_ID_TANGTOP_USBPS2, HID_QUIRK_NOGET },
  
  	{ USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_POWERMOUSE, HID_QUIRK_2WHEEL_POWERMOUSE },
-@@ -1820,9 +1824,6 @@ static struct hid_device *usb_hid_config
+@@ -1828,9 +1832,6 @@ static struct hid_device *usb_hid_config
  	hid->urbctrl->transfer_dma = hid->ctrlbuf_dma;
  	hid->urbctrl->transfer_flags |= (URB_NO_TRANSFER_DMA_MAP | URB_NO_SETUP_DMA_MAP);
  
diff --git a/usb/usb-minor-gadget-rndis-tweak.patch b/usb/usb-minor-gadget-rndis-tweak.patch
new file mode 100644
index 00000000000000..e84a8f0194243b
--- /dev/null
+++ b/usb/usb-minor-gadget-rndis-tweak.patch
@@ -0,0 +1,30 @@
+From david-b@pacbell.net Sun Jan 22 11:29:03 2006
+From: David Brownell <david-b@pacbell.net>
+To: Greg KH <greg@kroah.com>
+Subject: USB: minor gadget/rndis tweak
+Date: Sun, 22 Jan 2006 10:33:27 -0800
+Cc: Andrew Victor <andrew@sanpeople.com>
+Message-Id: <200601221033.27776.david-b@pacbell.net>
+
+Resove a minor FIXME:  don't change MTU while RNDIS link is active,
+the other end won't expect such things...
+
+Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
+Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
+
+---
+ drivers/usb/gadget/ether.c |    3 ++-
+ 1 file changed, 2 insertions(+), 1 deletion(-)
+
+--- gregkh-2.6.orig/drivers/usb/gadget/ether.c
++++ gregkh-2.6/drivers/usb/gadget/ether.c
+@@ -1549,7 +1549,8 @@ static int eth_change_mtu (struct net_de
+ {
+ 	struct eth_dev	*dev = netdev_priv(net);
+ 
+-	// FIXME if rndis, don't change while link's live
++	if (dev->rndis)
++		return -EBUSY;
+ 
+ 	if (new_mtu <= ETH_HLEN || new_mtu > ETH_FRAME_LEN)
+ 		return -ERANGE;
diff --git a/usb/usbip.patch b/usb/usbip.patch
index fc08f519478b09..dd3300ec31c610 100644
--- a/usb/usbip.patch
+++ b/usb/usbip.patch
@@ -29,7 +29,7 @@ a link to the userspace tools needed to get this to work.
 
 --- gregkh-2.6.orig/drivers/usb/Kconfig
 +++ gregkh-2.6/drivers/usb/Kconfig
-@@ -70,6 +70,8 @@ source "drivers/usb/core/Kconfig"
+@@ -79,6 +79,8 @@ source "drivers/usb/core/Kconfig"
  
  source "drivers/usb/host/Kconfig"
  
@@ -75,9 +75,9 @@ a link to the userspace tools needed to get this to work.
 +
 --- gregkh-2.6.orig/drivers/usb/Makefile
 +++ gregkh-2.6/drivers/usb/Makefile
-@@ -16,6 +16,8 @@ obj-$(CONFIG_USB_UHCI_HCD)	+= host/
- obj-$(CONFIG_USB_SL811_HCD)	+= host/
+@@ -17,6 +17,8 @@ obj-$(CONFIG_USB_SL811_HCD)	+= host/
  obj-$(CONFIG_ETRAX_USB_HOST)	+= host/
+ obj-$(CONFIG_USB_OHCI_AT91)	+= host/
  
 +obj-$(CONFIG_USB_IP)		+= ip/
 +