Merge branch 'linus' into x86/core
[linux-2.6] / drivers / usb / musb / musb_host.c
1 /*
2  * MUSB OTG driver host support
3  *
4  * Copyright 2005 Mentor Graphics Corporation
5  * Copyright (C) 2005-2006 by Texas Instruments
6  * Copyright (C) 2006-2007 Nokia Corporation
7  *
8  * This program is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU General Public License
10  * version 2 as published by the Free Software Foundation.
11  *
12  * This program is distributed in the hope that it will be useful, but
13  * WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
20  * 02110-1301 USA
21  *
22  * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
23  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
24  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN
25  * NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT,
26  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
27  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
28  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
29  * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
30  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
31  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32  *
33  */
34
35 #include <linux/module.h>
36 #include <linux/kernel.h>
37 #include <linux/delay.h>
38 #include <linux/sched.h>
39 #include <linux/slab.h>
40 #include <linux/errno.h>
41 #include <linux/init.h>
42 #include <linux/list.h>
43
44 #include "musb_core.h"
45 #include "musb_host.h"
46
47
48 /* MUSB HOST status 22-mar-2006
49  *
50  * - There's still lots of partial code duplication for fault paths, so
51  *   they aren't handled as consistently as they need to be.
52  *
53  * - PIO mostly behaved when last tested.
54  *     + including ep0, with all usbtest cases 9, 10
55  *     + usbtest 14 (ep0out) doesn't seem to run at all
56  *     + double buffered OUT/TX endpoints saw stalls(!) with certain usbtest
57  *       configurations, but otherwise double buffering passes basic tests.
58  *     + for 2.6.N, for N > ~10, needs API changes for hcd framework.
59  *
60  * - DMA (CPPI) ... partially behaves, not currently recommended
61  *     + about 1/15 the speed of typical EHCI implementations (PCI)
62  *     + RX, all too often reqpkt seems to misbehave after tx
63  *     + TX, no known issues (other than evident silicon issue)
64  *
65  * - DMA (Mentor/OMAP) ...has at least toggle update problems
66  *
67  * - [23-feb-2009] minimal traffic scheduling to avoid bulk RX packet
68  *   starvation ... nothing yet for TX, interrupt, or bulk.
69  *
70  * - Not tested with HNP, but some SRP paths seem to behave.
71  *
72  * NOTE 24-August-2006:
73  *
74  * - Bulk traffic finally uses both sides of hardware ep1, freeing up an
75  *   extra endpoint for periodic use enabling hub + keybd + mouse.  That
76  *   mostly works, except that with "usbnet" it's easy to trigger cases
77  *   with "ping" where RX loses.  (a) ping to davinci, even "ping -f",
78  *   fine; but (b) ping _from_ davinci, even "ping -c 1", ICMP RX loses
79  *   although ARP RX wins.  (That test was done with a full speed link.)
80  */
81
82
83 /*
84  * NOTE on endpoint usage:
85  *
86  * CONTROL transfers all go through ep0.  BULK ones go through dedicated IN
87  * and OUT endpoints ... hardware is dedicated for those "async" queue(s).
88  * (Yes, bulk _could_ use more of the endpoints than that, and would even
89  * benefit from it.)
90  *
91  * INTERUPPT and ISOCHRONOUS transfers are scheduled to the other endpoints.
92  * So far that scheduling is both dumb and optimistic:  the endpoint will be
93  * "claimed" until its software queue is no longer refilled.  No multiplexing
94  * of transfers between endpoints, or anything clever.
95  */
96
97
98 static void musb_ep_program(struct musb *musb, u8 epnum,
99                         struct urb *urb, unsigned int nOut,
100                         u8 *buf, u32 len);
101
102 /*
103  * Clear TX fifo. Needed to avoid BABBLE errors.
104  */
105 static void musb_h_tx_flush_fifo(struct musb_hw_ep *ep)
106 {
107         void __iomem    *epio = ep->regs;
108         u16             csr;
109         u16             lastcsr = 0;
110         int             retries = 1000;
111
112         csr = musb_readw(epio, MUSB_TXCSR);
113         while (csr & MUSB_TXCSR_FIFONOTEMPTY) {
114                 if (csr != lastcsr)
115                         DBG(3, "Host TX FIFONOTEMPTY csr: %02x\n", csr);
116                 lastcsr = csr;
117                 csr |= MUSB_TXCSR_FLUSHFIFO;
118                 musb_writew(epio, MUSB_TXCSR, csr);
119                 csr = musb_readw(epio, MUSB_TXCSR);
120                 if (WARN(retries-- < 1,
121                                 "Could not flush host TX%d fifo: csr: %04x\n",
122                                 ep->epnum, csr))
123                         return;
124                 mdelay(1);
125         }
126 }
127
128 /*
129  * Start transmit. Caller is responsible for locking shared resources.
130  * musb must be locked.
131  */
132 static inline void musb_h_tx_start(struct musb_hw_ep *ep)
133 {
134         u16     txcsr;
135
136         /* NOTE: no locks here; caller should lock and select EP */
137         if (ep->epnum) {
138                 txcsr = musb_readw(ep->regs, MUSB_TXCSR);
139                 txcsr |= MUSB_TXCSR_TXPKTRDY | MUSB_TXCSR_H_WZC_BITS;
140                 musb_writew(ep->regs, MUSB_TXCSR, txcsr);
141         } else {
142                 txcsr = MUSB_CSR0_H_SETUPPKT | MUSB_CSR0_TXPKTRDY;
143                 musb_writew(ep->regs, MUSB_CSR0, txcsr);
144         }
145
146 }
147
148 static inline void cppi_host_txdma_start(struct musb_hw_ep *ep)
149 {
150         u16     txcsr;
151
152         /* NOTE: no locks here; caller should lock and select EP */
153         txcsr = musb_readw(ep->regs, MUSB_TXCSR);
154         txcsr |= MUSB_TXCSR_DMAENAB | MUSB_TXCSR_H_WZC_BITS;
155         musb_writew(ep->regs, MUSB_TXCSR, txcsr);
156 }
157
158 /*
159  * Start the URB at the front of an endpoint's queue
160  * end must be claimed from the caller.
161  *
162  * Context: controller locked, irqs blocked
163  */
164 static void
165 musb_start_urb(struct musb *musb, int is_in, struct musb_qh *qh)
166 {
167         u16                     frame;
168         u32                     len;
169         void                    *buf;
170         void __iomem            *mbase =  musb->mregs;
171         struct urb              *urb = next_urb(qh);
172         struct musb_hw_ep       *hw_ep = qh->hw_ep;
173         unsigned                pipe = urb->pipe;
174         u8                      address = usb_pipedevice(pipe);
175         int                     epnum = hw_ep->epnum;
176
177         /* initialize software qh state */
178         qh->offset = 0;
179         qh->segsize = 0;
180
181         /* gather right source of data */
182         switch (qh->type) {
183         case USB_ENDPOINT_XFER_CONTROL:
184                 /* control transfers always start with SETUP */
185                 is_in = 0;
186                 hw_ep->out_qh = qh;
187                 musb->ep0_stage = MUSB_EP0_START;
188                 buf = urb->setup_packet;
189                 len = 8;
190                 break;
191         case USB_ENDPOINT_XFER_ISOC:
192                 qh->iso_idx = 0;
193                 qh->frame = 0;
194                 buf = urb->transfer_buffer + urb->iso_frame_desc[0].offset;
195                 len = urb->iso_frame_desc[0].length;
196                 break;
197         default:                /* bulk, interrupt */
198                 /* actual_length may be nonzero on retry paths */
199                 buf = urb->transfer_buffer + urb->actual_length;
200                 len = urb->transfer_buffer_length - urb->actual_length;
201         }
202
203         DBG(4, "qh %p urb %p dev%d ep%d%s%s, hw_ep %d, %p/%d\n",
204                         qh, urb, address, qh->epnum,
205                         is_in ? "in" : "out",
206                         ({char *s; switch (qh->type) {
207                         case USB_ENDPOINT_XFER_CONTROL: s = ""; break;
208                         case USB_ENDPOINT_XFER_BULK:    s = "-bulk"; break;
209                         case USB_ENDPOINT_XFER_ISOC:    s = "-iso"; break;
210                         default:                        s = "-intr"; break;
211                         }; s; }),
212                         epnum, buf, len);
213
214         /* Configure endpoint */
215         if (is_in || hw_ep->is_shared_fifo)
216                 hw_ep->in_qh = qh;
217         else
218                 hw_ep->out_qh = qh;
219         musb_ep_program(musb, epnum, urb, !is_in, buf, len);
220
221         /* transmit may have more work: start it when it is time */
222         if (is_in)
223                 return;
224
225         /* determine if the time is right for a periodic transfer */
226         switch (qh->type) {
227         case USB_ENDPOINT_XFER_ISOC:
228         case USB_ENDPOINT_XFER_INT:
229                 DBG(3, "check whether there's still time for periodic Tx\n");
230                 qh->iso_idx = 0;
231                 frame = musb_readw(mbase, MUSB_FRAME);
232                 /* FIXME this doesn't implement that scheduling policy ...
233                  * or handle framecounter wrapping
234                  */
235                 if ((urb->transfer_flags & URB_ISO_ASAP)
236                                 || (frame >= urb->start_frame)) {
237                         /* REVISIT the SOF irq handler shouldn't duplicate
238                          * this code; and we don't init urb->start_frame...
239                          */
240                         qh->frame = 0;
241                         goto start;
242                 } else {
243                         qh->frame = urb->start_frame;
244                         /* enable SOF interrupt so we can count down */
245                         DBG(1, "SOF for %d\n", epnum);
246 #if 1 /* ifndef CONFIG_ARCH_DAVINCI */
247                         musb_writeb(mbase, MUSB_INTRUSBE, 0xff);
248 #endif
249                 }
250                 break;
251         default:
252 start:
253                 DBG(4, "Start TX%d %s\n", epnum,
254                         hw_ep->tx_channel ? "dma" : "pio");
255
256                 if (!hw_ep->tx_channel)
257                         musb_h_tx_start(hw_ep);
258                 else if (is_cppi_enabled() || tusb_dma_omap())
259                         cppi_host_txdma_start(hw_ep);
260         }
261 }
262
263 /* caller owns controller lock, irqs are blocked */
264 static void
265 __musb_giveback(struct musb *musb, struct urb *urb, int status)
266 __releases(musb->lock)
267 __acquires(musb->lock)
268 {
269         DBG(({ int level; switch (status) {
270                                 case 0:
271                                         level = 4;
272                                         break;
273                                 /* common/boring faults */
274                                 case -EREMOTEIO:
275                                 case -ESHUTDOWN:
276                                 case -ECONNRESET:
277                                 case -EPIPE:
278                                         level = 3;
279                                         break;
280                                 default:
281                                         level = 2;
282                                         break;
283                                 }; level; }),
284                         "complete %p %pF (%d), dev%d ep%d%s, %d/%d\n",
285                         urb, urb->complete, status,
286                         usb_pipedevice(urb->pipe),
287                         usb_pipeendpoint(urb->pipe),
288                         usb_pipein(urb->pipe) ? "in" : "out",
289                         urb->actual_length, urb->transfer_buffer_length
290                         );
291
292         usb_hcd_unlink_urb_from_ep(musb_to_hcd(musb), urb);
293         spin_unlock(&musb->lock);
294         usb_hcd_giveback_urb(musb_to_hcd(musb), urb, status);
295         spin_lock(&musb->lock);
296 }
297
298 /* for bulk/interrupt endpoints only */
299 static inline void
300 musb_save_toggle(struct musb_hw_ep *ep, int is_in, struct urb *urb)
301 {
302         struct usb_device       *udev = urb->dev;
303         u16                     csr;
304         void __iomem            *epio = ep->regs;
305         struct musb_qh          *qh;
306
307         /* FIXME:  the current Mentor DMA code seems to have
308          * problems getting toggle correct.
309          */
310
311         if (is_in || ep->is_shared_fifo)
312                 qh = ep->in_qh;
313         else
314                 qh = ep->out_qh;
315
316         if (!is_in) {
317                 csr = musb_readw(epio, MUSB_TXCSR);
318                 usb_settoggle(udev, qh->epnum, 1,
319                         (csr & MUSB_TXCSR_H_DATATOGGLE)
320                                 ? 1 : 0);
321         } else {
322                 csr = musb_readw(epio, MUSB_RXCSR);
323                 usb_settoggle(udev, qh->epnum, 0,
324                         (csr & MUSB_RXCSR_H_DATATOGGLE)
325                                 ? 1 : 0);
326         }
327 }
328
329 /* caller owns controller lock, irqs are blocked */
330 static struct musb_qh *
331 musb_giveback(struct musb_qh *qh, struct urb *urb, int status)
332 {
333         struct musb_hw_ep       *ep = qh->hw_ep;
334         struct musb             *musb = ep->musb;
335         int                     is_in = usb_pipein(urb->pipe);
336         int                     ready = qh->is_ready;
337
338         /* save toggle eagerly, for paranoia */
339         switch (qh->type) {
340         case USB_ENDPOINT_XFER_BULK:
341         case USB_ENDPOINT_XFER_INT:
342                 musb_save_toggle(ep, is_in, urb);
343                 break;
344         case USB_ENDPOINT_XFER_ISOC:
345                 if (status == 0 && urb->error_count)
346                         status = -EXDEV;
347                 break;
348         }
349
350         qh->is_ready = 0;
351         __musb_giveback(musb, urb, status);
352         qh->is_ready = ready;
353
354         /* reclaim resources (and bandwidth) ASAP; deschedule it, and
355          * invalidate qh as soon as list_empty(&hep->urb_list)
356          */
357         if (list_empty(&qh->hep->urb_list)) {
358                 struct list_head        *head;
359
360                 if (is_in)
361                         ep->rx_reinit = 1;
362                 else
363                         ep->tx_reinit = 1;
364
365                 /* clobber old pointers to this qh */
366                 if (is_in || ep->is_shared_fifo)
367                         ep->in_qh = NULL;
368                 else
369                         ep->out_qh = NULL;
370                 qh->hep->hcpriv = NULL;
371
372                 switch (qh->type) {
373
374                 case USB_ENDPOINT_XFER_CONTROL:
375                 case USB_ENDPOINT_XFER_BULK:
376                         /* fifo policy for these lists, except that NAKing
377                          * should rotate a qh to the end (for fairness).
378                          */
379                         if (qh->mux == 1) {
380                                 head = qh->ring.prev;
381                                 list_del(&qh->ring);
382                                 kfree(qh);
383                                 qh = first_qh(head);
384                                 break;
385                         }
386
387                 case USB_ENDPOINT_XFER_ISOC:
388                 case USB_ENDPOINT_XFER_INT:
389                         /* this is where periodic bandwidth should be
390                          * de-allocated if it's tracked and allocated;
391                          * and where we'd update the schedule tree...
392                          */
393                         kfree(qh);
394                         qh = NULL;
395                         break;
396                 }
397         }
398         return qh;
399 }
400
401 /*
402  * Advance this hardware endpoint's queue, completing the specified urb and
403  * advancing to either the next urb queued to that qh, or else invalidating
404  * that qh and advancing to the next qh scheduled after the current one.
405  *
406  * Context: caller owns controller lock, irqs are blocked
407  */
408 static void
409 musb_advance_schedule(struct musb *musb, struct urb *urb,
410                 struct musb_hw_ep *hw_ep, int is_in)
411 {
412         struct musb_qh  *qh;
413
414         if (is_in || hw_ep->is_shared_fifo)
415                 qh = hw_ep->in_qh;
416         else
417                 qh = hw_ep->out_qh;
418
419         if (urb->status == -EINPROGRESS)
420                 qh = musb_giveback(qh, urb, 0);
421         else
422                 qh = musb_giveback(qh, urb, urb->status);
423
424         if (qh != NULL && qh->is_ready) {
425                 DBG(4, "... next ep%d %cX urb %p\n",
426                                 hw_ep->epnum, is_in ? 'R' : 'T',
427                                 next_urb(qh));
428                 musb_start_urb(musb, is_in, qh);
429         }
430 }
431
432 static u16 musb_h_flush_rxfifo(struct musb_hw_ep *hw_ep, u16 csr)
433 {
434         /* we don't want fifo to fill itself again;
435          * ignore dma (various models),
436          * leave toggle alone (may not have been saved yet)
437          */
438         csr |= MUSB_RXCSR_FLUSHFIFO | MUSB_RXCSR_RXPKTRDY;
439         csr &= ~(MUSB_RXCSR_H_REQPKT
440                 | MUSB_RXCSR_H_AUTOREQ
441                 | MUSB_RXCSR_AUTOCLEAR);
442
443         /* write 2x to allow double buffering */
444         musb_writew(hw_ep->regs, MUSB_RXCSR, csr);
445         musb_writew(hw_ep->regs, MUSB_RXCSR, csr);
446
447         /* flush writebuffer */
448         return musb_readw(hw_ep->regs, MUSB_RXCSR);
449 }
450
451 /*
452  * PIO RX for a packet (or part of it).
453  */
454 static bool
455 musb_host_packet_rx(struct musb *musb, struct urb *urb, u8 epnum, u8 iso_err)
456 {
457         u16                     rx_count;
458         u8                      *buf;
459         u16                     csr;
460         bool                    done = false;
461         u32                     length;
462         int                     do_flush = 0;
463         struct musb_hw_ep       *hw_ep = musb->endpoints + epnum;
464         void __iomem            *epio = hw_ep->regs;
465         struct musb_qh          *qh = hw_ep->in_qh;
466         int                     pipe = urb->pipe;
467         void                    *buffer = urb->transfer_buffer;
468
469         /* musb_ep_select(mbase, epnum); */
470         rx_count = musb_readw(epio, MUSB_RXCOUNT);
471         DBG(3, "RX%d count %d, buffer %p len %d/%d\n", epnum, rx_count,
472                         urb->transfer_buffer, qh->offset,
473                         urb->transfer_buffer_length);
474
475         /* unload FIFO */
476         if (usb_pipeisoc(pipe)) {
477                 int                                     status = 0;
478                 struct usb_iso_packet_descriptor        *d;
479
480                 if (iso_err) {
481                         status = -EILSEQ;
482                         urb->error_count++;
483                 }
484
485                 d = urb->iso_frame_desc + qh->iso_idx;
486                 buf = buffer + d->offset;
487                 length = d->length;
488                 if (rx_count > length) {
489                         if (status == 0) {
490                                 status = -EOVERFLOW;
491                                 urb->error_count++;
492                         }
493                         DBG(2, "** OVERFLOW %d into %d\n", rx_count, length);
494                         do_flush = 1;
495                 } else
496                         length = rx_count;
497                 urb->actual_length += length;
498                 d->actual_length = length;
499
500                 d->status = status;
501
502                 /* see if we are done */
503                 done = (++qh->iso_idx >= urb->number_of_packets);
504         } else {
505                 /* non-isoch */
506                 buf = buffer + qh->offset;
507                 length = urb->transfer_buffer_length - qh->offset;
508                 if (rx_count > length) {
509                         if (urb->status == -EINPROGRESS)
510                                 urb->status = -EOVERFLOW;
511                         DBG(2, "** OVERFLOW %d into %d\n", rx_count, length);
512                         do_flush = 1;
513                 } else
514                         length = rx_count;
515                 urb->actual_length += length;
516                 qh->offset += length;
517
518                 /* see if we are done */
519                 done = (urb->actual_length == urb->transfer_buffer_length)
520                         || (rx_count < qh->maxpacket)
521                         || (urb->status != -EINPROGRESS);
522                 if (done
523                                 && (urb->status == -EINPROGRESS)
524                                 && (urb->transfer_flags & URB_SHORT_NOT_OK)
525                                 && (urb->actual_length
526                                         < urb->transfer_buffer_length))
527                         urb->status = -EREMOTEIO;
528         }
529
530         musb_read_fifo(hw_ep, length, buf);
531
532         csr = musb_readw(epio, MUSB_RXCSR);
533         csr |= MUSB_RXCSR_H_WZC_BITS;
534         if (unlikely(do_flush))
535                 musb_h_flush_rxfifo(hw_ep, csr);
536         else {
537                 /* REVISIT this assumes AUTOCLEAR is never set */
538                 csr &= ~(MUSB_RXCSR_RXPKTRDY | MUSB_RXCSR_H_REQPKT);
539                 if (!done)
540                         csr |= MUSB_RXCSR_H_REQPKT;
541                 musb_writew(epio, MUSB_RXCSR, csr);
542         }
543
544         return done;
545 }
546
547 /* we don't always need to reinit a given side of an endpoint...
548  * when we do, use tx/rx reinit routine and then construct a new CSR
549  * to address data toggle, NYET, and DMA or PIO.
550  *
551  * it's possible that driver bugs (especially for DMA) or aborting a
552  * transfer might have left the endpoint busier than it should be.
553  * the busy/not-empty tests are basically paranoia.
554  */
555 static void
556 musb_rx_reinit(struct musb *musb, struct musb_qh *qh, struct musb_hw_ep *ep)
557 {
558         u16     csr;
559
560         /* NOTE:  we know the "rx" fifo reinit never triggers for ep0.
561          * That always uses tx_reinit since ep0 repurposes TX register
562          * offsets; the initial SETUP packet is also a kind of OUT.
563          */
564
565         /* if programmed for Tx, put it in RX mode */
566         if (ep->is_shared_fifo) {
567                 csr = musb_readw(ep->regs, MUSB_TXCSR);
568                 if (csr & MUSB_TXCSR_MODE) {
569                         musb_h_tx_flush_fifo(ep);
570                         musb_writew(ep->regs, MUSB_TXCSR,
571                                         MUSB_TXCSR_FRCDATATOG);
572                 }
573                 /* clear mode (and everything else) to enable Rx */
574                 musb_writew(ep->regs, MUSB_TXCSR, 0);
575
576         /* scrub all previous state, clearing toggle */
577         } else {
578                 csr = musb_readw(ep->regs, MUSB_RXCSR);
579                 if (csr & MUSB_RXCSR_RXPKTRDY)
580                         WARNING("rx%d, packet/%d ready?\n", ep->epnum,
581                                 musb_readw(ep->regs, MUSB_RXCOUNT));
582
583                 musb_h_flush_rxfifo(ep, MUSB_RXCSR_CLRDATATOG);
584         }
585
586         /* target addr and (for multipoint) hub addr/port */
587         if (musb->is_multipoint) {
588                 musb_write_rxfunaddr(ep->target_regs, qh->addr_reg);
589                 musb_write_rxhubaddr(ep->target_regs, qh->h_addr_reg);
590                 musb_write_rxhubport(ep->target_regs, qh->h_port_reg);
591
592         } else
593                 musb_writeb(musb->mregs, MUSB_FADDR, qh->addr_reg);
594
595         /* protocol/endpoint, interval/NAKlimit, i/o size */
596         musb_writeb(ep->regs, MUSB_RXTYPE, qh->type_reg);
597         musb_writeb(ep->regs, MUSB_RXINTERVAL, qh->intv_reg);
598         /* NOTE: bulk combining rewrites high bits of maxpacket */
599         musb_writew(ep->regs, MUSB_RXMAXP, qh->maxpacket);
600
601         ep->rx_reinit = 0;
602 }
603
604
605 /*
606  * Program an HDRC endpoint as per the given URB
607  * Context: irqs blocked, controller lock held
608  */
609 static void musb_ep_program(struct musb *musb, u8 epnum,
610                         struct urb *urb, unsigned int is_out,
611                         u8 *buf, u32 len)
612 {
613         struct dma_controller   *dma_controller;
614         struct dma_channel      *dma_channel;
615         u8                      dma_ok;
616         void __iomem            *mbase = musb->mregs;
617         struct musb_hw_ep       *hw_ep = musb->endpoints + epnum;
618         void __iomem            *epio = hw_ep->regs;
619         struct musb_qh          *qh;
620         u16                     packet_sz;
621
622         if (!is_out || hw_ep->is_shared_fifo)
623                 qh = hw_ep->in_qh;
624         else
625                 qh = hw_ep->out_qh;
626
627         packet_sz = qh->maxpacket;
628
629         DBG(3, "%s hw%d urb %p spd%d dev%d ep%d%s "
630                                 "h_addr%02x h_port%02x bytes %d\n",
631                         is_out ? "-->" : "<--",
632                         epnum, urb, urb->dev->speed,
633                         qh->addr_reg, qh->epnum, is_out ? "out" : "in",
634                         qh->h_addr_reg, qh->h_port_reg,
635                         len);
636
637         musb_ep_select(mbase, epnum);
638
639         /* candidate for DMA? */
640         dma_controller = musb->dma_controller;
641         if (is_dma_capable() && epnum && dma_controller) {
642                 dma_channel = is_out ? hw_ep->tx_channel : hw_ep->rx_channel;
643                 if (!dma_channel) {
644                         dma_channel = dma_controller->channel_alloc(
645                                         dma_controller, hw_ep, is_out);
646                         if (is_out)
647                                 hw_ep->tx_channel = dma_channel;
648                         else
649                                 hw_ep->rx_channel = dma_channel;
650                 }
651         } else
652                 dma_channel = NULL;
653
654         /* make sure we clear DMAEnab, autoSet bits from previous run */
655
656         /* OUT/transmit/EP0 or IN/receive? */
657         if (is_out) {
658                 u16     csr;
659                 u16     int_txe;
660                 u16     load_count;
661
662                 csr = musb_readw(epio, MUSB_TXCSR);
663
664                 /* disable interrupt in case we flush */
665                 int_txe = musb_readw(mbase, MUSB_INTRTXE);
666                 musb_writew(mbase, MUSB_INTRTXE, int_txe & ~(1 << epnum));
667
668                 /* general endpoint setup */
669                 if (epnum) {
670                         /* ASSERT:  TXCSR_DMAENAB was already cleared */
671
672                         /* flush all old state, set default */
673                         musb_h_tx_flush_fifo(hw_ep);
674                         csr &= ~(MUSB_TXCSR_H_NAKTIMEOUT
675                                         | MUSB_TXCSR_DMAMODE
676                                         | MUSB_TXCSR_FRCDATATOG
677                                         | MUSB_TXCSR_H_RXSTALL
678                                         | MUSB_TXCSR_H_ERROR
679                                         | MUSB_TXCSR_TXPKTRDY
680                                         );
681                         csr |= MUSB_TXCSR_MODE;
682
683                         if (usb_gettoggle(urb->dev,
684                                         qh->epnum, 1))
685                                 csr |= MUSB_TXCSR_H_WR_DATATOGGLE
686                                         | MUSB_TXCSR_H_DATATOGGLE;
687                         else
688                                 csr |= MUSB_TXCSR_CLRDATATOG;
689
690                         /* twice in case of double packet buffering */
691                         musb_writew(epio, MUSB_TXCSR, csr);
692                         /* REVISIT may need to clear FLUSHFIFO ... */
693                         musb_writew(epio, MUSB_TXCSR, csr);
694                         csr = musb_readw(epio, MUSB_TXCSR);
695                 } else {
696                         /* endpoint 0: just flush */
697                         musb_writew(epio, MUSB_CSR0,
698                                 csr | MUSB_CSR0_FLUSHFIFO);
699                         musb_writew(epio, MUSB_CSR0,
700                                 csr | MUSB_CSR0_FLUSHFIFO);
701                 }
702
703                 /* target addr and (for multipoint) hub addr/port */
704                 if (musb->is_multipoint) {
705                         musb_write_txfunaddr(mbase, epnum, qh->addr_reg);
706                         musb_write_txhubaddr(mbase, epnum, qh->h_addr_reg);
707                         musb_write_txhubport(mbase, epnum, qh->h_port_reg);
708 /* FIXME if !epnum, do the same for RX ... */
709                 } else
710                         musb_writeb(mbase, MUSB_FADDR, qh->addr_reg);
711
712                 /* protocol/endpoint/interval/NAKlimit */
713                 if (epnum) {
714                         musb_writeb(epio, MUSB_TXTYPE, qh->type_reg);
715                         if (can_bulk_split(musb, qh->type))
716                                 musb_writew(epio, MUSB_TXMAXP,
717                                         packet_sz
718                                         | ((hw_ep->max_packet_sz_tx /
719                                                 packet_sz) - 1) << 11);
720                         else
721                                 musb_writew(epio, MUSB_TXMAXP,
722                                         packet_sz);
723                         musb_writeb(epio, MUSB_TXINTERVAL, qh->intv_reg);
724                 } else {
725                         musb_writeb(epio, MUSB_NAKLIMIT0, qh->intv_reg);
726                         if (musb->is_multipoint)
727                                 musb_writeb(epio, MUSB_TYPE0,
728                                                 qh->type_reg);
729                 }
730
731                 if (can_bulk_split(musb, qh->type))
732                         load_count = min((u32) hw_ep->max_packet_sz_tx,
733                                                 len);
734                 else
735                         load_count = min((u32) packet_sz, len);
736
737 #ifdef CONFIG_USB_INVENTRA_DMA
738                 if (dma_channel) {
739
740                         /* clear previous state */
741                         csr = musb_readw(epio, MUSB_TXCSR);
742                         csr &= ~(MUSB_TXCSR_AUTOSET
743                                 | MUSB_TXCSR_DMAMODE
744                                 | MUSB_TXCSR_DMAENAB);
745                         csr |= MUSB_TXCSR_MODE;
746                         musb_writew(epio, MUSB_TXCSR,
747                                 csr | MUSB_TXCSR_MODE);
748
749                         qh->segsize = min(len, dma_channel->max_len);
750
751                         if (qh->segsize <= packet_sz)
752                                 dma_channel->desired_mode = 0;
753                         else
754                                 dma_channel->desired_mode = 1;
755
756
757                         if (dma_channel->desired_mode == 0) {
758                                 csr &= ~(MUSB_TXCSR_AUTOSET
759                                         | MUSB_TXCSR_DMAMODE);
760                                 csr |= (MUSB_TXCSR_DMAENAB);
761                                         /* against programming guide */
762                         } else
763                                 csr |= (MUSB_TXCSR_AUTOSET
764                                         | MUSB_TXCSR_DMAENAB
765                                         | MUSB_TXCSR_DMAMODE);
766
767                         musb_writew(epio, MUSB_TXCSR, csr);
768
769                         dma_ok = dma_controller->channel_program(
770                                         dma_channel, packet_sz,
771                                         dma_channel->desired_mode,
772                                         urb->transfer_dma,
773                                         qh->segsize);
774                         if (dma_ok) {
775                                 load_count = 0;
776                         } else {
777                                 dma_controller->channel_release(dma_channel);
778                                 if (is_out)
779                                         hw_ep->tx_channel = NULL;
780                                 else
781                                         hw_ep->rx_channel = NULL;
782                                 dma_channel = NULL;
783                         }
784                 }
785 #endif
786
787                 /* candidate for DMA */
788                 if ((is_cppi_enabled() || tusb_dma_omap()) && dma_channel) {
789
790                         /* program endpoint CSRs first, then setup DMA.
791                          * assume CPPI setup succeeds.
792                          * defer enabling dma.
793                          */
794                         csr = musb_readw(epio, MUSB_TXCSR);
795                         csr &= ~(MUSB_TXCSR_AUTOSET
796                                         | MUSB_TXCSR_DMAMODE
797                                         | MUSB_TXCSR_DMAENAB);
798                         csr |= MUSB_TXCSR_MODE;
799                         musb_writew(epio, MUSB_TXCSR,
800                                 csr | MUSB_TXCSR_MODE);
801
802                         dma_channel->actual_len = 0L;
803                         qh->segsize = len;
804
805                         /* TX uses "rndis" mode automatically, but needs help
806                          * to identify the zero-length-final-packet case.
807                          */
808                         dma_ok = dma_controller->channel_program(
809                                         dma_channel, packet_sz,
810                                         (urb->transfer_flags
811                                                         & URB_ZERO_PACKET)
812                                                 == URB_ZERO_PACKET,
813                                         urb->transfer_dma,
814                                         qh->segsize);
815                         if (dma_ok) {
816                                 load_count = 0;
817                         } else {
818                                 dma_controller->channel_release(dma_channel);
819                                 hw_ep->tx_channel = NULL;
820                                 dma_channel = NULL;
821
822                                 /* REVISIT there's an error path here that
823                                  * needs handling:  can't do dma, but
824                                  * there's no pio buffer address...
825                                  */
826                         }
827                 }
828
829                 if (load_count) {
830                         /* ASSERT:  TXCSR_DMAENAB was already cleared */
831
832                         /* PIO to load FIFO */
833                         qh->segsize = load_count;
834                         musb_write_fifo(hw_ep, load_count, buf);
835                         csr = musb_readw(epio, MUSB_TXCSR);
836                         csr &= ~(MUSB_TXCSR_DMAENAB
837                                 | MUSB_TXCSR_DMAMODE
838                                 | MUSB_TXCSR_AUTOSET);
839                         /* write CSR */
840                         csr |= MUSB_TXCSR_MODE;
841
842                         if (epnum)
843                                 musb_writew(epio, MUSB_TXCSR, csr);
844                 }
845
846                 /* re-enable interrupt */
847                 musb_writew(mbase, MUSB_INTRTXE, int_txe);
848
849         /* IN/receive */
850         } else {
851                 u16     csr;
852
853                 if (hw_ep->rx_reinit) {
854                         musb_rx_reinit(musb, qh, hw_ep);
855
856                         /* init new state: toggle and NYET, maybe DMA later */
857                         if (usb_gettoggle(urb->dev, qh->epnum, 0))
858                                 csr = MUSB_RXCSR_H_WR_DATATOGGLE
859                                         | MUSB_RXCSR_H_DATATOGGLE;
860                         else
861                                 csr = 0;
862                         if (qh->type == USB_ENDPOINT_XFER_INT)
863                                 csr |= MUSB_RXCSR_DISNYET;
864
865                 } else {
866                         csr = musb_readw(hw_ep->regs, MUSB_RXCSR);
867
868                         if (csr & (MUSB_RXCSR_RXPKTRDY
869                                         | MUSB_RXCSR_DMAENAB
870                                         | MUSB_RXCSR_H_REQPKT))
871                                 ERR("broken !rx_reinit, ep%d csr %04x\n",
872                                                 hw_ep->epnum, csr);
873
874                         /* scrub any stale state, leaving toggle alone */
875                         csr &= MUSB_RXCSR_DISNYET;
876                 }
877
878                 /* kick things off */
879
880                 if ((is_cppi_enabled() || tusb_dma_omap()) && dma_channel) {
881                         /* candidate for DMA */
882                         if (dma_channel) {
883                                 dma_channel->actual_len = 0L;
884                                 qh->segsize = len;
885
886                                 /* AUTOREQ is in a DMA register */
887                                 musb_writew(hw_ep->regs, MUSB_RXCSR, csr);
888                                 csr = musb_readw(hw_ep->regs,
889                                                 MUSB_RXCSR);
890
891                                 /* unless caller treats short rx transfers as
892                                  * errors, we dare not queue multiple transfers.
893                                  */
894                                 dma_ok = dma_controller->channel_program(
895                                                 dma_channel, packet_sz,
896                                                 !(urb->transfer_flags
897                                                         & URB_SHORT_NOT_OK),
898                                                 urb->transfer_dma,
899                                                 qh->segsize);
900                                 if (!dma_ok) {
901                                         dma_controller->channel_release(
902                                                         dma_channel);
903                                         hw_ep->rx_channel = NULL;
904                                         dma_channel = NULL;
905                                 } else
906                                         csr |= MUSB_RXCSR_DMAENAB;
907                         }
908                 }
909
910                 csr |= MUSB_RXCSR_H_REQPKT;
911                 DBG(7, "RXCSR%d := %04x\n", epnum, csr);
912                 musb_writew(hw_ep->regs, MUSB_RXCSR, csr);
913                 csr = musb_readw(hw_ep->regs, MUSB_RXCSR);
914         }
915 }
916
917
918 /*
919  * Service the default endpoint (ep0) as host.
920  * Return true until it's time to start the status stage.
921  */
922 static bool musb_h_ep0_continue(struct musb *musb, u16 len, struct urb *urb)
923 {
924         bool                     more = false;
925         u8                      *fifo_dest = NULL;
926         u16                     fifo_count = 0;
927         struct musb_hw_ep       *hw_ep = musb->control_ep;
928         struct musb_qh          *qh = hw_ep->in_qh;
929         struct usb_ctrlrequest  *request;
930
931         switch (musb->ep0_stage) {
932         case MUSB_EP0_IN:
933                 fifo_dest = urb->transfer_buffer + urb->actual_length;
934                 fifo_count = min_t(size_t, len, urb->transfer_buffer_length -
935                                    urb->actual_length);
936                 if (fifo_count < len)
937                         urb->status = -EOVERFLOW;
938
939                 musb_read_fifo(hw_ep, fifo_count, fifo_dest);
940
941                 urb->actual_length += fifo_count;
942                 if (len < qh->maxpacket) {
943                         /* always terminate on short read; it's
944                          * rarely reported as an error.
945                          */
946                 } else if (urb->actual_length <
947                                 urb->transfer_buffer_length)
948                         more = true;
949                 break;
950         case MUSB_EP0_START:
951                 request = (struct usb_ctrlrequest *) urb->setup_packet;
952
953                 if (!request->wLength) {
954                         DBG(4, "start no-DATA\n");
955                         break;
956                 } else if (request->bRequestType & USB_DIR_IN) {
957                         DBG(4, "start IN-DATA\n");
958                         musb->ep0_stage = MUSB_EP0_IN;
959                         more = true;
960                         break;
961                 } else {
962                         DBG(4, "start OUT-DATA\n");
963                         musb->ep0_stage = MUSB_EP0_OUT;
964                         more = true;
965                 }
966                 /* FALLTHROUGH */
967         case MUSB_EP0_OUT:
968                 fifo_count = min_t(size_t, qh->maxpacket,
969                                    urb->transfer_buffer_length -
970                                    urb->actual_length);
971                 if (fifo_count) {
972                         fifo_dest = (u8 *) (urb->transfer_buffer
973                                         + urb->actual_length);
974                         DBG(3, "Sending %d byte%s to ep0 fifo %p\n",
975                                         fifo_count,
976                                         (fifo_count == 1) ? "" : "s",
977                                         fifo_dest);
978                         musb_write_fifo(hw_ep, fifo_count, fifo_dest);
979
980                         urb->actual_length += fifo_count;
981                         more = true;
982                 }
983                 break;
984         default:
985                 ERR("bogus ep0 stage %d\n", musb->ep0_stage);
986                 break;
987         }
988
989         return more;
990 }
991
992 /*
993  * Handle default endpoint interrupt as host. Only called in IRQ time
994  * from musb_interrupt().
995  *
996  * called with controller irqlocked
997  */
998 irqreturn_t musb_h_ep0_irq(struct musb *musb)
999 {
1000         struct urb              *urb;
1001         u16                     csr, len;
1002         int                     status = 0;
1003         void __iomem            *mbase = musb->mregs;
1004         struct musb_hw_ep       *hw_ep = musb->control_ep;
1005         void __iomem            *epio = hw_ep->regs;
1006         struct musb_qh          *qh = hw_ep->in_qh;
1007         bool                    complete = false;
1008         irqreturn_t             retval = IRQ_NONE;
1009
1010         /* ep0 only has one queue, "in" */
1011         urb = next_urb(qh);
1012
1013         musb_ep_select(mbase, 0);
1014         csr = musb_readw(epio, MUSB_CSR0);
1015         len = (csr & MUSB_CSR0_RXPKTRDY)
1016                         ? musb_readb(epio, MUSB_COUNT0)
1017                         : 0;
1018
1019         DBG(4, "<== csr0 %04x, qh %p, count %d, urb %p, stage %d\n",
1020                 csr, qh, len, urb, musb->ep0_stage);
1021
1022         /* if we just did status stage, we are done */
1023         if (MUSB_EP0_STATUS == musb->ep0_stage) {
1024                 retval = IRQ_HANDLED;
1025                 complete = true;
1026         }
1027
1028         /* prepare status */
1029         if (csr & MUSB_CSR0_H_RXSTALL) {
1030                 DBG(6, "STALLING ENDPOINT\n");
1031                 status = -EPIPE;
1032
1033         } else if (csr & MUSB_CSR0_H_ERROR) {
1034                 DBG(2, "no response, csr0 %04x\n", csr);
1035                 status = -EPROTO;
1036
1037         } else if (csr & MUSB_CSR0_H_NAKTIMEOUT) {
1038                 DBG(2, "control NAK timeout\n");
1039
1040                 /* NOTE:  this code path would be a good place to PAUSE a
1041                  * control transfer, if another one is queued, so that
1042                  * ep0 is more likely to stay busy.  That's already done
1043                  * for bulk RX transfers.
1044                  *
1045                  * if (qh->ring.next != &musb->control), then
1046                  * we have a candidate... NAKing is *NOT* an error
1047                  */
1048                 musb_writew(epio, MUSB_CSR0, 0);
1049                 retval = IRQ_HANDLED;
1050         }
1051
1052         if (status) {
1053                 DBG(6, "aborting\n");
1054                 retval = IRQ_HANDLED;
1055                 if (urb)
1056                         urb->status = status;
1057                 complete = true;
1058
1059                 /* use the proper sequence to abort the transfer */
1060                 if (csr & MUSB_CSR0_H_REQPKT) {
1061                         csr &= ~MUSB_CSR0_H_REQPKT;
1062                         musb_writew(epio, MUSB_CSR0, csr);
1063                         csr &= ~MUSB_CSR0_H_NAKTIMEOUT;
1064                         musb_writew(epio, MUSB_CSR0, csr);
1065                 } else {
1066                         csr |= MUSB_CSR0_FLUSHFIFO;
1067                         musb_writew(epio, MUSB_CSR0, csr);
1068                         musb_writew(epio, MUSB_CSR0, csr);
1069                         csr &= ~MUSB_CSR0_H_NAKTIMEOUT;
1070                         musb_writew(epio, MUSB_CSR0, csr);
1071                 }
1072
1073                 musb_writeb(epio, MUSB_NAKLIMIT0, 0);
1074
1075                 /* clear it */
1076                 musb_writew(epio, MUSB_CSR0, 0);
1077         }
1078
1079         if (unlikely(!urb)) {
1080                 /* stop endpoint since we have no place for its data, this
1081                  * SHOULD NEVER HAPPEN! */
1082                 ERR("no URB for end 0\n");
1083
1084                 musb_writew(epio, MUSB_CSR0, MUSB_CSR0_FLUSHFIFO);
1085                 musb_writew(epio, MUSB_CSR0, MUSB_CSR0_FLUSHFIFO);
1086                 musb_writew(epio, MUSB_CSR0, 0);
1087
1088                 goto done;
1089         }
1090
1091         if (!complete) {
1092                 /* call common logic and prepare response */
1093                 if (musb_h_ep0_continue(musb, len, urb)) {
1094                         /* more packets required */
1095                         csr = (MUSB_EP0_IN == musb->ep0_stage)
1096                                 ?  MUSB_CSR0_H_REQPKT : MUSB_CSR0_TXPKTRDY;
1097                 } else {
1098                         /* data transfer complete; perform status phase */
1099                         if (usb_pipeout(urb->pipe)
1100                                         || !urb->transfer_buffer_length)
1101                                 csr = MUSB_CSR0_H_STATUSPKT
1102                                         | MUSB_CSR0_H_REQPKT;
1103                         else
1104                                 csr = MUSB_CSR0_H_STATUSPKT
1105                                         | MUSB_CSR0_TXPKTRDY;
1106
1107                         /* flag status stage */
1108                         musb->ep0_stage = MUSB_EP0_STATUS;
1109
1110                         DBG(5, "ep0 STATUS, csr %04x\n", csr);
1111
1112                 }
1113                 musb_writew(epio, MUSB_CSR0, csr);
1114                 retval = IRQ_HANDLED;
1115         } else
1116                 musb->ep0_stage = MUSB_EP0_IDLE;
1117
1118         /* call completion handler if done */
1119         if (complete)
1120                 musb_advance_schedule(musb, urb, hw_ep, 1);
1121 done:
1122         return retval;
1123 }
1124
1125
1126 #ifdef CONFIG_USB_INVENTRA_DMA
1127
1128 /* Host side TX (OUT) using Mentor DMA works as follows:
1129         submit_urb ->
1130                 - if queue was empty, Program Endpoint
1131                 - ... which starts DMA to fifo in mode 1 or 0
1132
1133         DMA Isr (transfer complete) -> TxAvail()
1134                 - Stop DMA (~DmaEnab)   (<--- Alert ... currently happens
1135                                         only in musb_cleanup_urb)
1136                 - TxPktRdy has to be set in mode 0 or for
1137                         short packets in mode 1.
1138 */
1139
1140 #endif
1141
1142 /* Service a Tx-Available or dma completion irq for the endpoint */
1143 void musb_host_tx(struct musb *musb, u8 epnum)
1144 {
1145         int                     pipe;
1146         bool                    done = false;
1147         u16                     tx_csr;
1148         size_t                  wLength = 0;
1149         u8                      *buf = NULL;
1150         struct urb              *urb;
1151         struct musb_hw_ep       *hw_ep = musb->endpoints + epnum;
1152         void __iomem            *epio = hw_ep->regs;
1153         struct musb_qh          *qh = hw_ep->is_shared_fifo ? hw_ep->in_qh
1154                                                             : hw_ep->out_qh;
1155         u32                     status = 0;
1156         void __iomem            *mbase = musb->mregs;
1157         struct dma_channel      *dma;
1158
1159         urb = next_urb(qh);
1160
1161         musb_ep_select(mbase, epnum);
1162         tx_csr = musb_readw(epio, MUSB_TXCSR);
1163
1164         /* with CPPI, DMA sometimes triggers "extra" irqs */
1165         if (!urb) {
1166                 DBG(4, "extra TX%d ready, csr %04x\n", epnum, tx_csr);
1167                 goto finish;
1168         }
1169
1170         pipe = urb->pipe;
1171         dma = is_dma_capable() ? hw_ep->tx_channel : NULL;
1172         DBG(4, "OUT/TX%d end, csr %04x%s\n", epnum, tx_csr,
1173                         dma ? ", dma" : "");
1174
1175         /* check for errors */
1176         if (tx_csr & MUSB_TXCSR_H_RXSTALL) {
1177                 /* dma was disabled, fifo flushed */
1178                 DBG(3, "TX end %d stall\n", epnum);
1179
1180                 /* stall; record URB status */
1181                 status = -EPIPE;
1182
1183         } else if (tx_csr & MUSB_TXCSR_H_ERROR) {
1184                 /* (NON-ISO) dma was disabled, fifo flushed */
1185                 DBG(3, "TX 3strikes on ep=%d\n", epnum);
1186
1187                 status = -ETIMEDOUT;
1188
1189         } else if (tx_csr & MUSB_TXCSR_H_NAKTIMEOUT) {
1190                 DBG(6, "TX end=%d device not responding\n", epnum);
1191
1192                 /* NOTE:  this code path would be a good place to PAUSE a
1193                  * transfer, if there's some other (nonperiodic) tx urb
1194                  * that could use this fifo.  (dma complicates it...)
1195                  * That's already done for bulk RX transfers.
1196                  *
1197                  * if (bulk && qh->ring.next != &musb->out_bulk), then
1198                  * we have a candidate... NAKing is *NOT* an error
1199                  */
1200                 musb_ep_select(mbase, epnum);
1201                 musb_writew(epio, MUSB_TXCSR,
1202                                 MUSB_TXCSR_H_WZC_BITS
1203                                 | MUSB_TXCSR_TXPKTRDY);
1204                 goto finish;
1205         }
1206
1207         if (status) {
1208                 if (dma_channel_status(dma) == MUSB_DMA_STATUS_BUSY) {
1209                         dma->status = MUSB_DMA_STATUS_CORE_ABORT;
1210                         (void) musb->dma_controller->channel_abort(dma);
1211                 }
1212
1213                 /* do the proper sequence to abort the transfer in the
1214                  * usb core; the dma engine should already be stopped.
1215                  */
1216                 musb_h_tx_flush_fifo(hw_ep);
1217                 tx_csr &= ~(MUSB_TXCSR_AUTOSET
1218                                 | MUSB_TXCSR_DMAENAB
1219                                 | MUSB_TXCSR_H_ERROR
1220                                 | MUSB_TXCSR_H_RXSTALL
1221                                 | MUSB_TXCSR_H_NAKTIMEOUT
1222                                 );
1223
1224                 musb_ep_select(mbase, epnum);
1225                 musb_writew(epio, MUSB_TXCSR, tx_csr);
1226                 /* REVISIT may need to clear FLUSHFIFO ... */
1227                 musb_writew(epio, MUSB_TXCSR, tx_csr);
1228                 musb_writeb(epio, MUSB_TXINTERVAL, 0);
1229
1230                 done = true;
1231         }
1232
1233         /* second cppi case */
1234         if (dma_channel_status(dma) == MUSB_DMA_STATUS_BUSY) {
1235                 DBG(4, "extra TX%d ready, csr %04x\n", epnum, tx_csr);
1236                 goto finish;
1237
1238         }
1239
1240         /* REVISIT this looks wrong... */
1241         if (!status || dma || usb_pipeisoc(pipe)) {
1242                 if (dma)
1243                         wLength = dma->actual_len;
1244                 else
1245                         wLength = qh->segsize;
1246                 qh->offset += wLength;
1247
1248                 if (usb_pipeisoc(pipe)) {
1249                         struct usb_iso_packet_descriptor        *d;
1250
1251                         d = urb->iso_frame_desc + qh->iso_idx;
1252                         d->actual_length = qh->segsize;
1253                         if (++qh->iso_idx >= urb->number_of_packets) {
1254                                 done = true;
1255                         } else {
1256                                 d++;
1257                                 buf = urb->transfer_buffer + d->offset;
1258                                 wLength = d->length;
1259                         }
1260                 } else if (dma) {
1261                         done = true;
1262                 } else {
1263                         /* see if we need to send more data, or ZLP */
1264                         if (qh->segsize < qh->maxpacket)
1265                                 done = true;
1266                         else if (qh->offset == urb->transfer_buffer_length
1267                                         && !(urb->transfer_flags
1268                                                 & URB_ZERO_PACKET))
1269                                 done = true;
1270                         if (!done) {
1271                                 buf = urb->transfer_buffer
1272                                                 + qh->offset;
1273                                 wLength = urb->transfer_buffer_length
1274                                                 - qh->offset;
1275                         }
1276                 }
1277         }
1278
1279         /* urb->status != -EINPROGRESS means request has been faulted,
1280          * so we must abort this transfer after cleanup
1281          */
1282         if (urb->status != -EINPROGRESS) {
1283                 done = true;
1284                 if (status == 0)
1285                         status = urb->status;
1286         }
1287
1288         if (done) {
1289                 /* set status */
1290                 urb->status = status;
1291                 urb->actual_length = qh->offset;
1292                 musb_advance_schedule(musb, urb, hw_ep, USB_DIR_OUT);
1293
1294         } else if (!(tx_csr & MUSB_TXCSR_DMAENAB)) {
1295                 /* WARN_ON(!buf); */
1296
1297                 /* REVISIT:  some docs say that when hw_ep->tx_double_buffered,
1298                  * (and presumably, fifo is not half-full) we should write TWO
1299                  * packets before updating TXCSR ... other docs disagree ...
1300                  */
1301                 /* PIO:  start next packet in this URB */
1302                 if (wLength > qh->maxpacket)
1303                         wLength = qh->maxpacket;
1304                 musb_write_fifo(hw_ep, wLength, buf);
1305                 qh->segsize = wLength;
1306
1307                 musb_ep_select(mbase, epnum);
1308                 musb_writew(epio, MUSB_TXCSR,
1309                                 MUSB_TXCSR_H_WZC_BITS | MUSB_TXCSR_TXPKTRDY);
1310         } else
1311                 DBG(1, "not complete, but dma enabled?\n");
1312
1313 finish:
1314         return;
1315 }
1316
1317
1318 #ifdef CONFIG_USB_INVENTRA_DMA
1319
1320 /* Host side RX (IN) using Mentor DMA works as follows:
1321         submit_urb ->
1322                 - if queue was empty, ProgramEndpoint
1323                 - first IN token is sent out (by setting ReqPkt)
1324         LinuxIsr -> RxReady()
1325         /\      => first packet is received
1326         |       - Set in mode 0 (DmaEnab, ~ReqPkt)
1327         |               -> DMA Isr (transfer complete) -> RxReady()
1328         |                   - Ack receive (~RxPktRdy), turn off DMA (~DmaEnab)
1329         |                   - if urb not complete, send next IN token (ReqPkt)
1330         |                          |            else complete urb.
1331         |                          |
1332         ---------------------------
1333  *
1334  * Nuances of mode 1:
1335  *      For short packets, no ack (+RxPktRdy) is sent automatically
1336  *      (even if AutoClear is ON)
1337  *      For full packets, ack (~RxPktRdy) and next IN token (+ReqPkt) is sent
1338  *      automatically => major problem, as collecting the next packet becomes
1339  *      difficult. Hence mode 1 is not used.
1340  *
1341  * REVISIT
1342  *      All we care about at this driver level is that
1343  *       (a) all URBs terminate with REQPKT cleared and fifo(s) empty;
1344  *       (b) termination conditions are: short RX, or buffer full;
1345  *       (c) fault modes include
1346  *           - iff URB_SHORT_NOT_OK, short RX status is -EREMOTEIO.
1347  *             (and that endpoint's dma queue stops immediately)
1348  *           - overflow (full, PLUS more bytes in the terminal packet)
1349  *
1350  *      So for example, usb-storage sets URB_SHORT_NOT_OK, and would
1351  *      thus be a great candidate for using mode 1 ... for all but the
1352  *      last packet of one URB's transfer.
1353  */
1354
1355 #endif
1356
1357 /* Schedule next QH from musb->in_bulk and move the current qh to
1358  * the end; avoids starvation for other endpoints.
1359  */
1360 static void musb_bulk_rx_nak_timeout(struct musb *musb, struct musb_hw_ep *ep)
1361 {
1362         struct dma_channel      *dma;
1363         struct urb              *urb;
1364         void __iomem            *mbase = musb->mregs;
1365         void __iomem            *epio = ep->regs;
1366         struct musb_qh          *cur_qh, *next_qh;
1367         u16                     rx_csr;
1368
1369         musb_ep_select(mbase, ep->epnum);
1370         dma = is_dma_capable() ? ep->rx_channel : NULL;
1371
1372         /* clear nak timeout bit */
1373         rx_csr = musb_readw(epio, MUSB_RXCSR);
1374         rx_csr |= MUSB_RXCSR_H_WZC_BITS;
1375         rx_csr &= ~MUSB_RXCSR_DATAERROR;
1376         musb_writew(epio, MUSB_RXCSR, rx_csr);
1377
1378         cur_qh = first_qh(&musb->in_bulk);
1379         if (cur_qh) {
1380                 urb = next_urb(cur_qh);
1381                 if (dma_channel_status(dma) == MUSB_DMA_STATUS_BUSY) {
1382                         dma->status = MUSB_DMA_STATUS_CORE_ABORT;
1383                         musb->dma_controller->channel_abort(dma);
1384                         urb->actual_length += dma->actual_len;
1385                         dma->actual_len = 0L;
1386                 }
1387                 musb_save_toggle(ep, 1, urb);
1388
1389                 /* move cur_qh to end of queue */
1390                 list_move_tail(&cur_qh->ring, &musb->in_bulk);
1391
1392                 /* get the next qh from musb->in_bulk */
1393                 next_qh = first_qh(&musb->in_bulk);
1394
1395                 /* set rx_reinit and schedule the next qh */
1396                 ep->rx_reinit = 1;
1397                 musb_start_urb(musb, 1, next_qh);
1398         }
1399 }
1400
1401 /*
1402  * Service an RX interrupt for the given IN endpoint; docs cover bulk, iso,
1403  * and high-bandwidth IN transfer cases.
1404  */
1405 void musb_host_rx(struct musb *musb, u8 epnum)
1406 {
1407         struct urb              *urb;
1408         struct musb_hw_ep       *hw_ep = musb->endpoints + epnum;
1409         void __iomem            *epio = hw_ep->regs;
1410         struct musb_qh          *qh = hw_ep->in_qh;
1411         size_t                  xfer_len;
1412         void __iomem            *mbase = musb->mregs;
1413         int                     pipe;
1414         u16                     rx_csr, val;
1415         bool                    iso_err = false;
1416         bool                    done = false;
1417         u32                     status;
1418         struct dma_channel      *dma;
1419
1420         musb_ep_select(mbase, epnum);
1421
1422         urb = next_urb(qh);
1423         dma = is_dma_capable() ? hw_ep->rx_channel : NULL;
1424         status = 0;
1425         xfer_len = 0;
1426
1427         rx_csr = musb_readw(epio, MUSB_RXCSR);
1428         val = rx_csr;
1429
1430         if (unlikely(!urb)) {
1431                 /* REVISIT -- THIS SHOULD NEVER HAPPEN ... but, at least
1432                  * usbtest #11 (unlinks) triggers it regularly, sometimes
1433                  * with fifo full.  (Only with DMA??)
1434                  */
1435                 DBG(3, "BOGUS RX%d ready, csr %04x, count %d\n", epnum, val,
1436                         musb_readw(epio, MUSB_RXCOUNT));
1437                 musb_h_flush_rxfifo(hw_ep, MUSB_RXCSR_CLRDATATOG);
1438                 return;
1439         }
1440
1441         pipe = urb->pipe;
1442
1443         DBG(5, "<== hw %d rxcsr %04x, urb actual %d (+dma %zu)\n",
1444                 epnum, rx_csr, urb->actual_length,
1445                 dma ? dma->actual_len : 0);
1446
1447         /* check for errors, concurrent stall & unlink is not really
1448          * handled yet! */
1449         if (rx_csr & MUSB_RXCSR_H_RXSTALL) {
1450                 DBG(3, "RX end %d STALL\n", epnum);
1451
1452                 /* stall; record URB status */
1453                 status = -EPIPE;
1454
1455         } else if (rx_csr & MUSB_RXCSR_H_ERROR) {
1456                 DBG(3, "end %d RX proto error\n", epnum);
1457
1458                 status = -EPROTO;
1459                 musb_writeb(epio, MUSB_RXINTERVAL, 0);
1460
1461         } else if (rx_csr & MUSB_RXCSR_DATAERROR) {
1462
1463                 if (USB_ENDPOINT_XFER_ISOC != qh->type) {
1464                         DBG(6, "RX end %d NAK timeout\n", epnum);
1465
1466                         /* NOTE: NAKing is *NOT* an error, so we want to
1467                          * continue.  Except ... if there's a request for
1468                          * another QH, use that instead of starving it.
1469                          *
1470                          * Devices like Ethernet and serial adapters keep
1471                          * reads posted at all times, which will starve
1472                          * other devices without this logic.
1473                          */
1474                         if (usb_pipebulk(urb->pipe)
1475                                         && qh->mux == 1
1476                                         && !list_is_singular(&musb->in_bulk)) {
1477                                 musb_bulk_rx_nak_timeout(musb, hw_ep);
1478                                 return;
1479                         }
1480                         musb_ep_select(mbase, epnum);
1481                         rx_csr |= MUSB_RXCSR_H_WZC_BITS;
1482                         rx_csr &= ~MUSB_RXCSR_DATAERROR;
1483                         musb_writew(epio, MUSB_RXCSR, rx_csr);
1484
1485                         goto finish;
1486                 } else {
1487                         DBG(4, "RX end %d ISO data error\n", epnum);
1488                         /* packet error reported later */
1489                         iso_err = true;
1490                 }
1491         }
1492
1493         /* faults abort the transfer */
1494         if (status) {
1495                 /* clean up dma and collect transfer count */
1496                 if (dma_channel_status(dma) == MUSB_DMA_STATUS_BUSY) {
1497                         dma->status = MUSB_DMA_STATUS_CORE_ABORT;
1498                         (void) musb->dma_controller->channel_abort(dma);
1499                         xfer_len = dma->actual_len;
1500                 }
1501                 musb_h_flush_rxfifo(hw_ep, MUSB_RXCSR_CLRDATATOG);
1502                 musb_writeb(epio, MUSB_RXINTERVAL, 0);
1503                 done = true;
1504                 goto finish;
1505         }
1506
1507         if (unlikely(dma_channel_status(dma) == MUSB_DMA_STATUS_BUSY)) {
1508                 /* SHOULD NEVER HAPPEN ... but at least DaVinci has done it */
1509                 ERR("RX%d dma busy, csr %04x\n", epnum, rx_csr);
1510                 goto finish;
1511         }
1512
1513         /* thorough shutdown for now ... given more precise fault handling
1514          * and better queueing support, we might keep a DMA pipeline going
1515          * while processing this irq for earlier completions.
1516          */
1517
1518         /* FIXME this is _way_ too much in-line logic for Mentor DMA */
1519
1520 #ifndef CONFIG_USB_INVENTRA_DMA
1521         if (rx_csr & MUSB_RXCSR_H_REQPKT)  {
1522                 /* REVISIT this happened for a while on some short reads...
1523                  * the cleanup still needs investigation... looks bad...
1524                  * and also duplicates dma cleanup code above ... plus,
1525                  * shouldn't this be the "half full" double buffer case?
1526                  */
1527                 if (dma_channel_status(dma) == MUSB_DMA_STATUS_BUSY) {
1528                         dma->status = MUSB_DMA_STATUS_CORE_ABORT;
1529                         (void) musb->dma_controller->channel_abort(dma);
1530                         xfer_len = dma->actual_len;
1531                         done = true;
1532                 }
1533
1534                 DBG(2, "RXCSR%d %04x, reqpkt, len %zu%s\n", epnum, rx_csr,
1535                                 xfer_len, dma ? ", dma" : "");
1536                 rx_csr &= ~MUSB_RXCSR_H_REQPKT;
1537
1538                 musb_ep_select(mbase, epnum);
1539                 musb_writew(epio, MUSB_RXCSR,
1540                                 MUSB_RXCSR_H_WZC_BITS | rx_csr);
1541         }
1542 #endif
1543         if (dma && (rx_csr & MUSB_RXCSR_DMAENAB)) {
1544                 xfer_len = dma->actual_len;
1545
1546                 val &= ~(MUSB_RXCSR_DMAENAB
1547                         | MUSB_RXCSR_H_AUTOREQ
1548                         | MUSB_RXCSR_AUTOCLEAR
1549                         | MUSB_RXCSR_RXPKTRDY);
1550                 musb_writew(hw_ep->regs, MUSB_RXCSR, val);
1551
1552 #ifdef CONFIG_USB_INVENTRA_DMA
1553                 if (usb_pipeisoc(pipe)) {
1554                         struct usb_iso_packet_descriptor *d;
1555
1556                         d = urb->iso_frame_desc + qh->iso_idx;
1557                         d->actual_length = xfer_len;
1558
1559                         /* even if there was an error, we did the dma
1560                          * for iso_frame_desc->length
1561                          */
1562                         if (d->status != EILSEQ && d->status != -EOVERFLOW)
1563                                 d->status = 0;
1564
1565                         if (++qh->iso_idx >= urb->number_of_packets)
1566                                 done = true;
1567                         else
1568                                 done = false;
1569
1570                 } else  {
1571                 /* done if urb buffer is full or short packet is recd */
1572                 done = (urb->actual_length + xfer_len >=
1573                                 urb->transfer_buffer_length
1574                         || dma->actual_len < qh->maxpacket);
1575                 }
1576
1577                 /* send IN token for next packet, without AUTOREQ */
1578                 if (!done) {
1579                         val |= MUSB_RXCSR_H_REQPKT;
1580                         musb_writew(epio, MUSB_RXCSR,
1581                                 MUSB_RXCSR_H_WZC_BITS | val);
1582                 }
1583
1584                 DBG(4, "ep %d dma %s, rxcsr %04x, rxcount %d\n", epnum,
1585                         done ? "off" : "reset",
1586                         musb_readw(epio, MUSB_RXCSR),
1587                         musb_readw(epio, MUSB_RXCOUNT));
1588 #else
1589                 done = true;
1590 #endif
1591         } else if (urb->status == -EINPROGRESS) {
1592                 /* if no errors, be sure a packet is ready for unloading */
1593                 if (unlikely(!(rx_csr & MUSB_RXCSR_RXPKTRDY))) {
1594                         status = -EPROTO;
1595                         ERR("Rx interrupt with no errors or packet!\n");
1596
1597                         /* FIXME this is another "SHOULD NEVER HAPPEN" */
1598
1599 /* SCRUB (RX) */
1600                         /* do the proper sequence to abort the transfer */
1601                         musb_ep_select(mbase, epnum);
1602                         val &= ~MUSB_RXCSR_H_REQPKT;
1603                         musb_writew(epio, MUSB_RXCSR, val);
1604                         goto finish;
1605                 }
1606
1607                 /* we are expecting IN packets */
1608 #ifdef CONFIG_USB_INVENTRA_DMA
1609                 if (dma) {
1610                         struct dma_controller   *c;
1611                         u16                     rx_count;
1612                         int                     ret, length;
1613                         dma_addr_t              buf;
1614
1615                         rx_count = musb_readw(epio, MUSB_RXCOUNT);
1616
1617                         DBG(2, "RX%d count %d, buffer 0x%x len %d/%d\n",
1618                                         epnum, rx_count,
1619                                         urb->transfer_dma
1620                                                 + urb->actual_length,
1621                                         qh->offset,
1622                                         urb->transfer_buffer_length);
1623
1624                         c = musb->dma_controller;
1625
1626                         if (usb_pipeisoc(pipe)) {
1627                                 int status = 0;
1628                                 struct usb_iso_packet_descriptor *d;
1629
1630                                 d = urb->iso_frame_desc + qh->iso_idx;
1631
1632                                 if (iso_err) {
1633                                         status = -EILSEQ;
1634                                         urb->error_count++;
1635                                 }
1636                                 if (rx_count > d->length) {
1637                                         if (status == 0) {
1638                                                 status = -EOVERFLOW;
1639                                                 urb->error_count++;
1640                                         }
1641                                         DBG(2, "** OVERFLOW %d into %d\n",\
1642                                             rx_count, d->length);
1643
1644                                         length = d->length;
1645                                 } else
1646                                         length = rx_count;
1647                                 d->status = status;
1648                                 buf = urb->transfer_dma + d->offset;
1649                         } else {
1650                                 length = rx_count;
1651                                 buf = urb->transfer_dma +
1652                                                 urb->actual_length;
1653                         }
1654
1655                         dma->desired_mode = 0;
1656 #ifdef USE_MODE1
1657                         /* because of the issue below, mode 1 will
1658                          * only rarely behave with correct semantics.
1659                          */
1660                         if ((urb->transfer_flags &
1661                                                 URB_SHORT_NOT_OK)
1662                                 && (urb->transfer_buffer_length -
1663                                                 urb->actual_length)
1664                                         > qh->maxpacket)
1665                                 dma->desired_mode = 1;
1666                         if (rx_count < hw_ep->max_packet_sz_rx) {
1667                                 length = rx_count;
1668                                 dma->bDesiredMode = 0;
1669                         } else {
1670                                 length = urb->transfer_buffer_length;
1671                         }
1672 #endif
1673
1674 /* Disadvantage of using mode 1:
1675  *      It's basically usable only for mass storage class; essentially all
1676  *      other protocols also terminate transfers on short packets.
1677  *
1678  * Details:
1679  *      An extra IN token is sent at the end of the transfer (due to AUTOREQ)
1680  *      If you try to use mode 1 for (transfer_buffer_length - 512), and try
1681  *      to use the extra IN token to grab the last packet using mode 0, then
1682  *      the problem is that you cannot be sure when the device will send the
1683  *      last packet and RxPktRdy set. Sometimes the packet is recd too soon
1684  *      such that it gets lost when RxCSR is re-set at the end of the mode 1
1685  *      transfer, while sometimes it is recd just a little late so that if you
1686  *      try to configure for mode 0 soon after the mode 1 transfer is
1687  *      completed, you will find rxcount 0. Okay, so you might think why not
1688  *      wait for an interrupt when the pkt is recd. Well, you won't get any!
1689  */
1690
1691                         val = musb_readw(epio, MUSB_RXCSR);
1692                         val &= ~MUSB_RXCSR_H_REQPKT;
1693
1694                         if (dma->desired_mode == 0)
1695                                 val &= ~MUSB_RXCSR_H_AUTOREQ;
1696                         else
1697                                 val |= MUSB_RXCSR_H_AUTOREQ;
1698                         val |= MUSB_RXCSR_AUTOCLEAR | MUSB_RXCSR_DMAENAB;
1699
1700                         musb_writew(epio, MUSB_RXCSR,
1701                                 MUSB_RXCSR_H_WZC_BITS | val);
1702
1703                         /* REVISIT if when actual_length != 0,
1704                          * transfer_buffer_length needs to be
1705                          * adjusted first...
1706                          */
1707                         ret = c->channel_program(
1708                                 dma, qh->maxpacket,
1709                                 dma->desired_mode, buf, length);
1710
1711                         if (!ret) {
1712                                 c->channel_release(dma);
1713                                 hw_ep->rx_channel = NULL;
1714                                 dma = NULL;
1715                                 /* REVISIT reset CSR */
1716                         }
1717                 }
1718 #endif  /* Mentor DMA */
1719
1720                 if (!dma) {
1721                         done = musb_host_packet_rx(musb, urb,
1722                                         epnum, iso_err);
1723                         DBG(6, "read %spacket\n", done ? "last " : "");
1724                 }
1725         }
1726
1727 finish:
1728         urb->actual_length += xfer_len;
1729         qh->offset += xfer_len;
1730         if (done) {
1731                 if (urb->status == -EINPROGRESS)
1732                         urb->status = status;
1733                 musb_advance_schedule(musb, urb, hw_ep, USB_DIR_IN);
1734         }
1735 }
1736
1737 /* schedule nodes correspond to peripheral endpoints, like an OHCI QH.
1738  * the software schedule associates multiple such nodes with a given
1739  * host side hardware endpoint + direction; scheduling may activate
1740  * that hardware endpoint.
1741  */
1742 static int musb_schedule(
1743         struct musb             *musb,
1744         struct musb_qh          *qh,
1745         int                     is_in)
1746 {
1747         int                     idle;
1748         int                     best_diff;
1749         int                     best_end, epnum;
1750         struct musb_hw_ep       *hw_ep = NULL;
1751         struct list_head        *head = NULL;
1752
1753         /* use fixed hardware for control and bulk */
1754         if (qh->type == USB_ENDPOINT_XFER_CONTROL) {
1755                 head = &musb->control;
1756                 hw_ep = musb->control_ep;
1757                 goto success;
1758         }
1759
1760         /* else, periodic transfers get muxed to other endpoints */
1761
1762         /*
1763          * We know this qh hasn't been scheduled, so all we need to do
1764          * is choose which hardware endpoint to put it on ...
1765          *
1766          * REVISIT what we really want here is a regular schedule tree
1767          * like e.g. OHCI uses.
1768          */
1769         best_diff = 4096;
1770         best_end = -1;
1771
1772         for (epnum = 1, hw_ep = musb->endpoints + 1;
1773                         epnum < musb->nr_endpoints;
1774                         epnum++, hw_ep++) {
1775                 int     diff;
1776
1777                 if (is_in || hw_ep->is_shared_fifo) {
1778                         if (hw_ep->in_qh  != NULL)
1779                                 continue;
1780                 } else  if (hw_ep->out_qh != NULL)
1781                         continue;
1782
1783                 if (hw_ep == musb->bulk_ep)
1784                         continue;
1785
1786                 if (is_in)
1787                         diff = hw_ep->max_packet_sz_rx - qh->maxpacket;
1788                 else
1789                         diff = hw_ep->max_packet_sz_tx - qh->maxpacket;
1790
1791                 if (diff >= 0 && best_diff > diff) {
1792                         best_diff = diff;
1793                         best_end = epnum;
1794                 }
1795         }
1796         /* use bulk reserved ep1 if no other ep is free */
1797         if (best_end < 0 && qh->type == USB_ENDPOINT_XFER_BULK) {
1798                 hw_ep = musb->bulk_ep;
1799                 if (is_in)
1800                         head = &musb->in_bulk;
1801                 else
1802                         head = &musb->out_bulk;
1803
1804                 /* Enable bulk RX NAK timeout scheme when bulk requests are
1805                  * multiplexed.  This scheme doen't work in high speed to full
1806                  * speed scenario as NAK interrupts are not coming from a
1807                  * full speed device connected to a high speed device.
1808                  * NAK timeout interval is 8 (128 uframe or 16ms) for HS and
1809                  * 4 (8 frame or 8ms) for FS device.
1810                  */
1811                 if (is_in && qh->dev)
1812                         qh->intv_reg =
1813                                 (USB_SPEED_HIGH == qh->dev->speed) ? 8 : 4;
1814                 goto success;
1815         } else if (best_end < 0) {
1816                 return -ENOSPC;
1817         }
1818
1819         idle = 1;
1820         qh->mux = 0;
1821         hw_ep = musb->endpoints + best_end;
1822         DBG(4, "qh %p periodic slot %d\n", qh, best_end);
1823 success:
1824         if (head) {
1825                 idle = list_empty(head);
1826                 list_add_tail(&qh->ring, head);
1827                 qh->mux = 1;
1828         }
1829         qh->hw_ep = hw_ep;
1830         qh->hep->hcpriv = qh;
1831         if (idle)
1832                 musb_start_urb(musb, is_in, qh);
1833         return 0;
1834 }
1835
1836 static int musb_urb_enqueue(
1837         struct usb_hcd                  *hcd,
1838         struct urb                      *urb,
1839         gfp_t                           mem_flags)
1840 {
1841         unsigned long                   flags;
1842         struct musb                     *musb = hcd_to_musb(hcd);
1843         struct usb_host_endpoint        *hep = urb->ep;
1844         struct musb_qh                  *qh = hep->hcpriv;
1845         struct usb_endpoint_descriptor  *epd = &hep->desc;
1846         int                             ret;
1847         unsigned                        type_reg;
1848         unsigned                        interval;
1849
1850         /* host role must be active */
1851         if (!is_host_active(musb) || !musb->is_active)
1852                 return -ENODEV;
1853
1854         spin_lock_irqsave(&musb->lock, flags);
1855         ret = usb_hcd_link_urb_to_ep(hcd, urb);
1856         spin_unlock_irqrestore(&musb->lock, flags);
1857         if (ret)
1858                 return ret;
1859
1860         /* DMA mapping was already done, if needed, and this urb is on
1861          * hep->urb_list ... so there's little to do unless hep wasn't
1862          * yet scheduled onto a live qh.
1863          *
1864          * REVISIT best to keep hep->hcpriv valid until the endpoint gets
1865          * disabled, testing for empty qh->ring and avoiding qh setup costs
1866          * except for the first urb queued after a config change.
1867          */
1868         if (qh) {
1869                 urb->hcpriv = qh;
1870                 return 0;
1871         }
1872
1873         /* Allocate and initialize qh, minimizing the work done each time
1874          * hw_ep gets reprogrammed, or with irqs blocked.  Then schedule it.
1875          *
1876          * REVISIT consider a dedicated qh kmem_cache, so it's harder
1877          * for bugs in other kernel code to break this driver...
1878          */
1879         qh = kzalloc(sizeof *qh, mem_flags);
1880         if (!qh) {
1881                 spin_lock_irqsave(&musb->lock, flags);
1882                 usb_hcd_unlink_urb_from_ep(hcd, urb);
1883                 spin_unlock_irqrestore(&musb->lock, flags);
1884                 return -ENOMEM;
1885         }
1886
1887         qh->hep = hep;
1888         qh->dev = urb->dev;
1889         INIT_LIST_HEAD(&qh->ring);
1890         qh->is_ready = 1;
1891
1892         qh->maxpacket = le16_to_cpu(epd->wMaxPacketSize);
1893
1894         /* no high bandwidth support yet */
1895         if (qh->maxpacket & ~0x7ff) {
1896                 ret = -EMSGSIZE;
1897                 goto done;
1898         }
1899
1900         qh->epnum = usb_endpoint_num(epd);
1901         qh->type = usb_endpoint_type(epd);
1902
1903         /* NOTE: urb->dev->devnum is wrong during SET_ADDRESS */
1904         qh->addr_reg = (u8) usb_pipedevice(urb->pipe);
1905
1906         /* precompute rxtype/txtype/type0 register */
1907         type_reg = (qh->type << 4) | qh->epnum;
1908         switch (urb->dev->speed) {
1909         case USB_SPEED_LOW:
1910                 type_reg |= 0xc0;
1911                 break;
1912         case USB_SPEED_FULL:
1913                 type_reg |= 0x80;
1914                 break;
1915         default:
1916                 type_reg |= 0x40;
1917         }
1918         qh->type_reg = type_reg;
1919
1920         /* Precompute RXINTERVAL/TXINTERVAL register */
1921         switch (qh->type) {
1922         case USB_ENDPOINT_XFER_INT:
1923                 /*
1924                  * Full/low speeds use the  linear encoding,
1925                  * high speed uses the logarithmic encoding.
1926                  */
1927                 if (urb->dev->speed <= USB_SPEED_FULL) {
1928                         interval = max_t(u8, epd->bInterval, 1);
1929                         break;
1930                 }
1931                 /* FALLTHROUGH */
1932         case USB_ENDPOINT_XFER_ISOC:
1933                 /* ISO always uses logarithmic encoding */
1934                 interval = min_t(u8, epd->bInterval, 16);
1935                 break;
1936         default:
1937                 /* REVISIT we actually want to use NAK limits, hinting to the
1938                  * transfer scheduling logic to try some other qh, e.g. try
1939                  * for 2 msec first:
1940                  *
1941                  * interval = (USB_SPEED_HIGH == urb->dev->speed) ? 16 : 2;
1942                  *
1943                  * The downside of disabling this is that transfer scheduling
1944                  * gets VERY unfair for nonperiodic transfers; a misbehaving
1945                  * peripheral could make that hurt.  That's perfectly normal
1946                  * for reads from network or serial adapters ... so we have
1947                  * partial NAKlimit support for bulk RX.
1948                  *
1949                  * The upside of disabling it is simpler transfer scheduling.
1950                  */
1951                 interval = 0;
1952         }
1953         qh->intv_reg = interval;
1954
1955         /* precompute addressing for external hub/tt ports */
1956         if (musb->is_multipoint) {
1957                 struct usb_device       *parent = urb->dev->parent;
1958
1959                 if (parent != hcd->self.root_hub) {
1960                         qh->h_addr_reg = (u8) parent->devnum;
1961
1962                         /* set up tt info if needed */
1963                         if (urb->dev->tt) {
1964                                 qh->h_port_reg = (u8) urb->dev->ttport;
1965                                 if (urb->dev->tt->hub)
1966                                         qh->h_addr_reg =
1967                                                 (u8) urb->dev->tt->hub->devnum;
1968                                 if (urb->dev->tt->multi)
1969                                         qh->h_addr_reg |= 0x80;
1970                         }
1971                 }
1972         }
1973
1974         /* invariant: hep->hcpriv is null OR the qh that's already scheduled.
1975          * until we get real dma queues (with an entry for each urb/buffer),
1976          * we only have work to do in the former case.
1977          */
1978         spin_lock_irqsave(&musb->lock, flags);
1979         if (hep->hcpriv) {
1980                 /* some concurrent activity submitted another urb to hep...
1981                  * odd, rare, error prone, but legal.
1982                  */
1983                 kfree(qh);
1984                 ret = 0;
1985         } else
1986                 ret = musb_schedule(musb, qh,
1987                                 epd->bEndpointAddress & USB_ENDPOINT_DIR_MASK);
1988
1989         if (ret == 0) {
1990                 urb->hcpriv = qh;
1991                 /* FIXME set urb->start_frame for iso/intr, it's tested in
1992                  * musb_start_urb(), but otherwise only konicawc cares ...
1993                  */
1994         }
1995         spin_unlock_irqrestore(&musb->lock, flags);
1996
1997 done:
1998         if (ret != 0) {
1999                 spin_lock_irqsave(&musb->lock, flags);
2000                 usb_hcd_unlink_urb_from_ep(hcd, urb);
2001                 spin_unlock_irqrestore(&musb->lock, flags);
2002                 kfree(qh);
2003         }
2004         return ret;
2005 }
2006
2007
2008 /*
2009  * abort a transfer that's at the head of a hardware queue.
2010  * called with controller locked, irqs blocked
2011  * that hardware queue advances to the next transfer, unless prevented
2012  */
2013 static int musb_cleanup_urb(struct urb *urb, struct musb_qh *qh, int is_in)
2014 {
2015         struct musb_hw_ep       *ep = qh->hw_ep;
2016         void __iomem            *epio = ep->regs;
2017         unsigned                hw_end = ep->epnum;
2018         void __iomem            *regs = ep->musb->mregs;
2019         u16                     csr;
2020         int                     status = 0;
2021
2022         musb_ep_select(regs, hw_end);
2023
2024         if (is_dma_capable()) {
2025                 struct dma_channel      *dma;
2026
2027                 dma = is_in ? ep->rx_channel : ep->tx_channel;
2028                 if (dma) {
2029                         status = ep->musb->dma_controller->channel_abort(dma);
2030                         DBG(status ? 1 : 3,
2031                                 "abort %cX%d DMA for urb %p --> %d\n",
2032                                 is_in ? 'R' : 'T', ep->epnum,
2033                                 urb, status);
2034                         urb->actual_length += dma->actual_len;
2035                 }
2036         }
2037
2038         /* turn off DMA requests, discard state, stop polling ... */
2039         if (is_in) {
2040                 /* giveback saves bulk toggle */
2041                 csr = musb_h_flush_rxfifo(ep, 0);
2042
2043                 /* REVISIT we still get an irq; should likely clear the
2044                  * endpoint's irq status here to avoid bogus irqs.
2045                  * clearing that status is platform-specific...
2046                  */
2047         } else {
2048                 musb_h_tx_flush_fifo(ep);
2049                 csr = musb_readw(epio, MUSB_TXCSR);
2050                 csr &= ~(MUSB_TXCSR_AUTOSET
2051                         | MUSB_TXCSR_DMAENAB
2052                         | MUSB_TXCSR_H_RXSTALL
2053                         | MUSB_TXCSR_H_NAKTIMEOUT
2054                         | MUSB_TXCSR_H_ERROR
2055                         | MUSB_TXCSR_TXPKTRDY);
2056                 musb_writew(epio, MUSB_TXCSR, csr);
2057                 /* REVISIT may need to clear FLUSHFIFO ... */
2058                 musb_writew(epio, MUSB_TXCSR, csr);
2059                 /* flush cpu writebuffer */
2060                 csr = musb_readw(epio, MUSB_TXCSR);
2061         }
2062         if (status == 0)
2063                 musb_advance_schedule(ep->musb, urb, ep, is_in);
2064         return status;
2065 }
2066
2067 static int musb_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
2068 {
2069         struct musb             *musb = hcd_to_musb(hcd);
2070         struct musb_qh          *qh;
2071         struct list_head        *sched;
2072         unsigned long           flags;
2073         int                     ret;
2074
2075         DBG(4, "urb=%p, dev%d ep%d%s\n", urb,
2076                         usb_pipedevice(urb->pipe),
2077                         usb_pipeendpoint(urb->pipe),
2078                         usb_pipein(urb->pipe) ? "in" : "out");
2079
2080         spin_lock_irqsave(&musb->lock, flags);
2081         ret = usb_hcd_check_unlink_urb(hcd, urb, status);
2082         if (ret)
2083                 goto done;
2084
2085         qh = urb->hcpriv;
2086         if (!qh)
2087                 goto done;
2088
2089         /* Any URB not actively programmed into endpoint hardware can be
2090          * immediately given back; that's any URB not at the head of an
2091          * endpoint queue, unless someday we get real DMA queues.  And even
2092          * if it's at the head, it might not be known to the hardware...
2093          *
2094          * Otherwise abort current transfer, pending dma, etc.; urb->status
2095          * has already been updated.  This is a synchronous abort; it'd be
2096          * OK to hold off until after some IRQ, though.
2097          */
2098         if (!qh->is_ready || urb->urb_list.prev != &qh->hep->urb_list)
2099                 ret = -EINPROGRESS;
2100         else {
2101                 switch (qh->type) {
2102                 case USB_ENDPOINT_XFER_CONTROL:
2103                         sched = &musb->control;
2104                         break;
2105                 case USB_ENDPOINT_XFER_BULK:
2106                         if (qh->mux == 1) {
2107                                 if (usb_pipein(urb->pipe))
2108                                         sched = &musb->in_bulk;
2109                                 else
2110                                         sched = &musb->out_bulk;
2111                                 break;
2112                         }
2113                 default:
2114                         /* REVISIT when we get a schedule tree, periodic
2115                          * transfers won't always be at the head of a
2116                          * singleton queue...
2117                          */
2118                         sched = NULL;
2119                         break;
2120                 }
2121         }
2122
2123         /* NOTE:  qh is invalid unless !list_empty(&hep->urb_list) */
2124         if (ret < 0 || (sched && qh != first_qh(sched))) {
2125                 int     ready = qh->is_ready;
2126
2127                 ret = 0;
2128                 qh->is_ready = 0;
2129                 __musb_giveback(musb, urb, 0);
2130                 qh->is_ready = ready;
2131
2132                 /* If nothing else (usually musb_giveback) is using it
2133                  * and its URB list has emptied, recycle this qh.
2134                  */
2135                 if (ready && list_empty(&qh->hep->urb_list)) {
2136                         qh->hep->hcpriv = NULL;
2137                         list_del(&qh->ring);
2138                         kfree(qh);
2139                 }
2140         } else
2141                 ret = musb_cleanup_urb(urb, qh, urb->pipe & USB_DIR_IN);
2142 done:
2143         spin_unlock_irqrestore(&musb->lock, flags);
2144         return ret;
2145 }
2146
2147 /* disable an endpoint */
2148 static void
2149 musb_h_disable(struct usb_hcd *hcd, struct usb_host_endpoint *hep)
2150 {
2151         u8                      epnum = hep->desc.bEndpointAddress;
2152         unsigned long           flags;
2153         struct musb             *musb = hcd_to_musb(hcd);
2154         u8                      is_in = epnum & USB_DIR_IN;
2155         struct musb_qh          *qh;
2156         struct urb              *urb;
2157         struct list_head        *sched;
2158
2159         spin_lock_irqsave(&musb->lock, flags);
2160
2161         qh = hep->hcpriv;
2162         if (qh == NULL)
2163                 goto exit;
2164
2165         switch (qh->type) {
2166         case USB_ENDPOINT_XFER_CONTROL:
2167                 sched = &musb->control;
2168                 break;
2169         case USB_ENDPOINT_XFER_BULK:
2170                 if (qh->mux == 1) {
2171                         if (is_in)
2172                                 sched = &musb->in_bulk;
2173                         else
2174                                 sched = &musb->out_bulk;
2175                         break;
2176                 }
2177         default:
2178                 /* REVISIT when we get a schedule tree, periodic transfers
2179                  * won't always be at the head of a singleton queue...
2180                  */
2181                 sched = NULL;
2182                 break;
2183         }
2184
2185         /* NOTE:  qh is invalid unless !list_empty(&hep->urb_list) */
2186
2187         /* kick first urb off the hardware, if needed */
2188         qh->is_ready = 0;
2189         if (!sched || qh == first_qh(sched)) {
2190                 urb = next_urb(qh);
2191
2192                 /* make software (then hardware) stop ASAP */
2193                 if (!urb->unlinked)
2194                         urb->status = -ESHUTDOWN;
2195
2196                 /* cleanup */
2197                 musb_cleanup_urb(urb, qh, urb->pipe & USB_DIR_IN);
2198
2199                 /* Then nuke all the others ... and advance the
2200                  * queue on hw_ep (e.g. bulk ring) when we're done.
2201                  */
2202                 while (!list_empty(&hep->urb_list)) {
2203                         urb = next_urb(qh);
2204                         urb->status = -ESHUTDOWN;
2205                         musb_advance_schedule(musb, urb, qh->hw_ep, is_in);
2206                 }
2207         } else {
2208                 /* Just empty the queue; the hardware is busy with
2209                  * other transfers, and since !qh->is_ready nothing
2210                  * will activate any of these as it advances.
2211                  */
2212                 while (!list_empty(&hep->urb_list))
2213                         __musb_giveback(musb, next_urb(qh), -ESHUTDOWN);
2214
2215                 hep->hcpriv = NULL;
2216                 list_del(&qh->ring);
2217                 kfree(qh);
2218         }
2219 exit:
2220         spin_unlock_irqrestore(&musb->lock, flags);
2221 }
2222
2223 static int musb_h_get_frame_number(struct usb_hcd *hcd)
2224 {
2225         struct musb     *musb = hcd_to_musb(hcd);
2226
2227         return musb_readw(musb->mregs, MUSB_FRAME);
2228 }
2229
2230 static int musb_h_start(struct usb_hcd *hcd)
2231 {
2232         struct musb     *musb = hcd_to_musb(hcd);
2233
2234         /* NOTE: musb_start() is called when the hub driver turns
2235          * on port power, or when (OTG) peripheral starts.
2236          */
2237         hcd->state = HC_STATE_RUNNING;
2238         musb->port1_status = 0;
2239         return 0;
2240 }
2241
2242 static void musb_h_stop(struct usb_hcd *hcd)
2243 {
2244         musb_stop(hcd_to_musb(hcd));
2245         hcd->state = HC_STATE_HALT;
2246 }
2247
2248 static int musb_bus_suspend(struct usb_hcd *hcd)
2249 {
2250         struct musb     *musb = hcd_to_musb(hcd);
2251
2252         if (musb->xceiv.state == OTG_STATE_A_SUSPEND)
2253                 return 0;
2254
2255         if (is_host_active(musb) && musb->is_active) {
2256                 WARNING("trying to suspend as %s is_active=%i\n",
2257                         otg_state_string(musb), musb->is_active);
2258                 return -EBUSY;
2259         } else
2260                 return 0;
2261 }
2262
2263 static int musb_bus_resume(struct usb_hcd *hcd)
2264 {
2265         /* resuming child port does the work */
2266         return 0;
2267 }
2268
2269 const struct hc_driver musb_hc_driver = {
2270         .description            = "musb-hcd",
2271         .product_desc           = "MUSB HDRC host driver",
2272         .hcd_priv_size          = sizeof(struct musb),
2273         .flags                  = HCD_USB2 | HCD_MEMORY,
2274
2275         /* not using irq handler or reset hooks from usbcore, since
2276          * those must be shared with peripheral code for OTG configs
2277          */
2278
2279         .start                  = musb_h_start,
2280         .stop                   = musb_h_stop,
2281
2282         .get_frame_number       = musb_h_get_frame_number,
2283
2284         .urb_enqueue            = musb_urb_enqueue,
2285         .urb_dequeue            = musb_urb_dequeue,
2286         .endpoint_disable       = musb_h_disable,
2287
2288         .hub_status_data        = musb_hub_status_data,
2289         .hub_control            = musb_hub_control,
2290         .bus_suspend            = musb_bus_suspend,
2291         .bus_resume             = musb_bus_resume,
2292         /* .start_port_reset    = NULL, */
2293         /* .hub_irq_enable      = NULL, */
2294 };