--- zzzz-none-000/linux-2.6.28.10/drivers/usb/musb/musb_gadget_ep0.c	2009-05-02 18:54:43.000000000 +0000
+++ puma5-6360-529/linux-2.6.28.10/drivers/usb/musb/musb_gadget_ep0.c	2010-05-17 16:39:56.000000000 +0000
@@ -107,8 +107,11 @@
 		struct musb_ep	*ep;
 		u16		tmp;
 		void __iomem	*regs;
-
+#ifdef CONFIG_ARCH_PUMA5
+		epnum = (u8) le16_to_cpu(ctrlrequest->wIndex);
+#else
 		epnum = (u8) ctrlrequest->wIndex;
+#endif
 		if (!epnum) {
 			result[0] = 0;
 			break;
@@ -240,15 +243,24 @@
 		case USB_REQ_SET_ADDRESS:
 			/* change it after the status stage */
 			musb->set_address = true;
+#ifdef CONFIG_ARCH_PUMA5
+			musb->address = (u8) (le16_to_cpu(ctrlrequest->wValue) & 0x7f);
+#else
 			musb->address = (u8) (ctrlrequest->wValue & 0x7f);
+#endif
 			handled = 1;
 			break;
 
 		case USB_REQ_CLEAR_FEATURE:
 			switch (recip) {
 			case USB_RECIP_DEVICE:
+#ifdef CONFIG_ARCH_PUMA5
+				if (le16_to_cpu(ctrlrequest->wValue)
+						!= USB_DEVICE_REMOTE_WAKEUP)
+#else
 				if (ctrlrequest->wValue
 						!= USB_DEVICE_REMOTE_WAKEUP)
+#endif
 					break;
 				musb->may_wakeup = 0;
 				handled = 1;
@@ -256,19 +268,23 @@
 			case USB_RECIP_INTERFACE:
 				break;
 			case USB_RECIP_ENDPOINT:{
-				const u8 num = ctrlrequest->wIndex & 0x0f;
+#ifdef CONFIG_ARCH_PUMA5
+				const u8 epnum = le16_to_cpu(ctrlrequest->wIndex) & 0x0f;
+#else
+				const u8 epnum = ctrlrequest->wIndex & 0x0f;
+#endif
 				struct musb_ep *musb_ep;
 
-				if (num == 0
-						|| num >= MUSB_C_NUM_EPS
-						|| ctrlrequest->wValue
+				if (epnum == 0
+						|| epnum >= MUSB_C_NUM_EPS
+						|| le16_to_cpu(ctrlrequest->wValue)
 							!= USB_ENDPOINT_HALT)
 					break;
 
-				if (ctrlrequest->wIndex & USB_DIR_IN)
-					musb_ep = &musb->endpoints[num].ep_in;
+				if (le16_to_cpu(ctrlrequest->wIndex) & USB_DIR_IN)
+					musb_ep = &musb->endpoints[epnum].ep_in;
 				else
-					musb_ep = &musb->endpoints[num].ep_out;
+					musb_ep = &musb->endpoints[epnum].ep_out;
 				if (!musb_ep->desc)
 					break;
 
@@ -292,17 +308,17 @@
 			switch (recip) {
 			case USB_RECIP_DEVICE:
 				handled = 1;
-				switch (ctrlrequest->wValue) {
+				switch (le16_to_cpu(ctrlrequest->wValue)) {
 				case USB_DEVICE_REMOTE_WAKEUP:
 					musb->may_wakeup = 1;
 					break;
 				case USB_DEVICE_TEST_MODE:
 					if (musb->g.speed != USB_SPEED_HIGH)
 						goto stall;
-					if (ctrlrequest->wIndex & 0xff)
+					if (le16_to_cpu(ctrlrequest->wIndex) & 0xff)
 						goto stall;
 
-					switch (ctrlrequest->wIndex >> 8) {
+					switch (le16_to_cpu(ctrlrequest->wIndex) >> 8) {
 					case 1:
 						pr_debug("TEST_J\n");
 						/* TEST_J */
@@ -365,7 +381,7 @@
 
 			case USB_RECIP_ENDPOINT:{
 				const u8		epnum =
-					ctrlrequest->wIndex & 0x0f;
+					le16_to_cpu(ctrlrequest->wIndex) & 0x0f;
 				struct musb_ep		*musb_ep;
 				struct musb_hw_ep	*ep;
 				void __iomem		*regs;
@@ -374,13 +390,13 @@
 
 				if (epnum == 0
 						|| epnum >= MUSB_C_NUM_EPS
-						|| ctrlrequest->wValue
+						|| le16_to_cpu(ctrlrequest->wValue)
 							!= USB_ENDPOINT_HALT)
 					break;
 
 				ep = musb->endpoints + epnum;
 				regs = ep->regs;
-				is_in = ctrlrequest->wIndex & USB_DIR_IN;
+				is_in = le16_to_cpu(ctrlrequest->wIndex) & USB_DIR_IN;
 				if (is_in)
 					musb_ep = &ep->ep_in;
 				else
@@ -435,9 +451,9 @@
  */
 static void ep0_rxstate(struct musb *musb)
 {
-	void __iomem		*regs = musb->control_ep->regs;
+	void __iomem		*regs = musb->endpoints->regs;
 	struct usb_request	*req;
-	u16			count, csr;
+	u16			tmp;
 
 	req = next_ep0_request(musb);
 
@@ -449,35 +465,35 @@
 		unsigned	len = req->length - req->actual;
 
 		/* read the buffer */
-		count = musb_readb(regs, MUSB_COUNT0);
-		if (count > len) {
+		tmp = musb_readb(regs, MUSB_COUNT0);
+		if (tmp > len) {
 			req->status = -EOVERFLOW;
-			count = len;
+			tmp = len;
 		}
-		musb_read_fifo(&musb->endpoints[0], count, buf);
-		req->actual += count;
-		csr = MUSB_CSR0_P_SVDRXPKTRDY;
-		if (count < 64 || req->actual == req->length) {
+		musb_read_fifo(&musb->endpoints[0], tmp, buf);
+		req->actual += tmp;
+		tmp = MUSB_CSR0_P_SVDRXPKTRDY;
+		if (tmp < 64 || req->actual == req->length) {
 			musb->ep0_state = MUSB_EP0_STAGE_STATUSIN;
-			csr |= MUSB_CSR0_P_DATAEND;
+			tmp |= MUSB_CSR0_P_DATAEND;
 		} else
 			req = NULL;
 	} else
-		csr = MUSB_CSR0_P_SVDRXPKTRDY | MUSB_CSR0_P_SENDSTALL;
+		tmp = MUSB_CSR0_P_SVDRXPKTRDY | MUSB_CSR0_P_SENDSTALL;
 
 
 	/* Completion handler may choose to stall, e.g. because the
 	 * message just received holds invalid data.
 	 */
 	if (req) {
-		musb->ackpend = csr;
+		musb->ackpend = tmp;
 		musb_g_ep0_giveback(musb, req);
 		if (!musb->ackpend)
 			return;
 		musb->ackpend = 0;
 	}
 	musb_ep_select(musb->mregs, 0);
-	musb_writew(regs, MUSB_CSR0, csr);
+	musb_writew(regs, MUSB_CSR0, tmp);
 }
 
 /*
@@ -488,7 +504,7 @@
  */
 static void ep0_txstate(struct musb *musb)
 {
-	void __iomem		*regs = musb->control_ep->regs;
+	void __iomem		*regs = musb->endpoints->regs;
 	struct usb_request	*request = next_ep0_request(musb);
 	u16			csr = MUSB_CSR0_TXPKTRDY;
 	u8			*fifo_src;
@@ -504,12 +520,13 @@
 	fifo_src = (u8 *) request->buf + request->actual;
 	fifo_count = min((unsigned) MUSB_EP0_FIFOSIZE,
 		request->length - request->actual);
+	if (fifo_count > 0)
 	musb_write_fifo(&musb->endpoints[0], fifo_count, fifo_src);
 	request->actual += fifo_count;
 
 	/* update the flags */
-	if (fifo_count < MUSB_MAX_END0_PACKET
-			|| request->actual == request->length) {
+	if ( !request->zero && (fifo_count < MUSB_MAX_END0_PACKET
+			|| request->actual == request->length)) {
 		musb->ep0_state = MUSB_EP0_STAGE_STATUSOUT;
 		csr |= MUSB_CSR0_P_DATAEND;
 	} else
@@ -543,14 +560,14 @@
 musb_read_setup(struct musb *musb, struct usb_ctrlrequest *req)
 {
 	struct usb_request	*r;
-	void __iomem		*regs = musb->control_ep->regs;
+	void __iomem		*regs = musb->endpoints->regs;
 
 	musb_read_fifo(&musb->endpoints[0], sizeof *req, (u8 *)req);
 
 	/* NOTE:  earlier 2.6 versions changed setup packets to host
 	 * order, but now USB packets always stay in USB byte order.
 	 */
-	DBG(3, "SETUP req%02x.%02x v%04x i%04x l%d\n",
+	DBG(3,"SETUP req%02x.%02x v%04x i%04x l%d\n",
 		req->bRequestType,
 		req->bRequest,
 		le16_to_cpu(req->wValue),
@@ -618,7 +635,7 @@
 	csr = musb_readw(regs, MUSB_CSR0);
 	len = musb_readb(regs, MUSB_COUNT0);
 
-	DBG(4, "csr %04x, count %d, myaddr %d, ep0stage %s\n",
+	DBG(4,"csr %04x, count %d, myaddr %d, ep0stage %s\n",
 			csr, len,
 			musb_readb(mbase, MUSB_FADDR),
 			decode_ep0stage(musb->ep0_state));
@@ -764,7 +781,7 @@
 				break;
 			}
 
-			DBG(3, "handled %d, csr %04x, ep0stage %s\n",
+			DBG(3,"handled %d, csr %04x, ep0stage %s\n",
 				handled, csr,
 				decode_ep0stage(musb->ep0_state));
 
@@ -776,7 +793,6 @@
 				goto stall;
 			else if (handled > 0)
 				goto finish;
-
 			handled = forward_to_driver(musb, &setup);
 			if (handled < 0) {
 				musb_ep_select(mbase, 0);
@@ -824,6 +840,19 @@
 	return -EINVAL;
 }
 
+static void *musb_g_ep0_alloc_buffer(struct usb_ep *ep, unsigned bytes,
+			dma_addr_t * dma, gfp_t gfp_flags)
+{
+	*dma = DMA_ADDR_INVALID;
+	return kmalloc(bytes, gfp_flags);
+}
+
+static void musb_g_ep0_free_buffer(struct usb_ep *ep, void *address,
+			dma_addr_t dma, unsigned bytes)
+{
+	kfree(address);
+}
+
 static int
 musb_g_ep0_queue(struct usb_ep *e, struct usb_request *r, gfp_t gfp_flags)
 {
@@ -839,7 +868,7 @@
 
 	ep = to_musb_ep(e);
 	musb = ep->musb;
-	regs = musb->control_ep->regs;
+	regs = musb->endpoints->regs;
 
 	req = to_musb_request(r);
 	req->musb = musb;
@@ -927,7 +956,7 @@
 	ep = to_musb_ep(e);
 	musb = ep->musb;
 	base = musb->mregs;
-	regs = musb->control_ep->regs;
+	regs = musb->endpoints->regs;
 	status = 0;
 
 	spin_lock_irqsave(&musb->lock, flags);
@@ -977,6 +1006,8 @@
 	.disable	= musb_g_ep0_disable,
 	.alloc_request	= musb_alloc_request,
 	.free_request	= musb_free_request,
+	.alloc_buffer	= musb_g_ep0_alloc_buffer,
+	.free_buffer	= musb_g_ep0_free_buffer,
 	.queue		= musb_g_ep0_queue,
 	.dequeue	= musb_g_ep0_dequeue,
 	.set_halt	= musb_g_ep0_halt,