[ARM] Eliminate useless includes of asm/mach-types.h
[linux-2.6.git] / drivers / usb / gadget / at91_udc.c
1 /*
2  * at91_udc -- driver for at91-series USB peripheral controller
3  *
4  * Copyright (C) 2004 by Thomas Rathbone
5  * Copyright (C) 2005 by HP Labs
6  * Copyright (C) 2005 by David Brownell
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 2 of the License, or
11  * (at your option) any later version.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the
20  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
21  * Boston, MA  02111-1307, USA.
22  */
23
24 #undef  VERBOSE_DEBUG
25 #undef  PACKET_TRACE
26
27 #include <linux/kernel.h>
28 #include <linux/module.h>
29 #include <linux/platform_device.h>
30 #include <linux/delay.h>
31 #include <linux/ioport.h>
32 #include <linux/slab.h>
33 #include <linux/errno.h>
34 #include <linux/init.h>
35 #include <linux/list.h>
36 #include <linux/interrupt.h>
37 #include <linux/proc_fs.h>
38 #include <linux/clk.h>
39 #include <linux/usb/ch9.h>
40 #include <linux/usb/gadget.h>
41
42 #include <asm/byteorder.h>
43 #include <asm/hardware.h>
44 #include <asm/io.h>
45 #include <asm/irq.h>
46 #include <asm/system.h>
47 #include <asm/gpio.h>
48
49 #include <asm/arch/board.h>
50 #include <asm/arch/cpu.h>
51 #include <asm/arch/at91sam9261_matrix.h>
52
53 #include "at91_udc.h"
54
55
56 /*
57  * This controller is simple and PIO-only.  It's used in many AT91-series
58  * full speed USB controllers, including the at91rm9200 (arm920T, with MMU),
59  * at91sam926x (arm926ejs, with MMU), and several no-mmu versions.
60  *
61  * This driver expects the board has been wired with two GPIOs suppporting
62  * a VBUS sensing IRQ, and a D+ pullup.  (They may be omitted, but the
63  * testing hasn't covered such cases.)
64  *
65  * The pullup is most important (so it's integrated on sam926x parts).  It
66  * provides software control over whether the host enumerates the device.
67  *
68  * The VBUS sensing helps during enumeration, and allows both USB clocks
69  * (and the transceiver) to stay gated off until they're necessary, saving
70  * power.  During USB suspend, the 48 MHz clock is gated off in hardware;
71  * it may also be gated off by software during some Linux sleep states.
72  */
73
74 #define DRIVER_VERSION  "3 May 2006"
75
76 static const char driver_name [] = "at91_udc";
77 static const char ep0name[] = "ep0";
78
79
80 #define at91_udp_read(dev, reg) \
81         __raw_readl((dev)->udp_baseaddr + (reg))
82 #define at91_udp_write(dev, reg, val) \
83         __raw_writel((val), (dev)->udp_baseaddr + (reg))
84
85 /*-------------------------------------------------------------------------*/
86
87 #ifdef CONFIG_USB_GADGET_DEBUG_FILES
88
89 #include <linux/seq_file.h>
90
91 static const char debug_filename[] = "driver/udc";
92
93 #define FOURBITS "%s%s%s%s"
94 #define EIGHTBITS FOURBITS FOURBITS
95
96 static void proc_ep_show(struct seq_file *s, struct at91_ep *ep)
97 {
98         static char             *types[] = {
99                 "control", "out-iso", "out-bulk", "out-int",
100                 "BOGUS",   "in-iso",  "in-bulk",  "in-int"};
101
102         u32                     csr;
103         struct at91_request     *req;
104         unsigned long   flags;
105
106         local_irq_save(flags);
107
108         csr = __raw_readl(ep->creg);
109
110         /* NOTE:  not collecting per-endpoint irq statistics... */
111
112         seq_printf(s, "\n");
113         seq_printf(s, "%s, maxpacket %d %s%s %s%s\n",
114                         ep->ep.name, ep->ep.maxpacket,
115                         ep->is_in ? "in" : "out",
116                         ep->is_iso ? " iso" : "",
117                         ep->is_pingpong
118                                 ? (ep->fifo_bank ? "pong" : "ping")
119                                 : "",
120                         ep->stopped ? " stopped" : "");
121         seq_printf(s, "csr %08x rxbytes=%d %s %s %s" EIGHTBITS "\n",
122                 csr,
123                 (csr & 0x07ff0000) >> 16,
124                 (csr & (1 << 15)) ? "enabled" : "disabled",
125                 (csr & (1 << 11)) ? "DATA1" : "DATA0",
126                 types[(csr & 0x700) >> 8],
127
128                 /* iff type is control then print current direction */
129                 (!(csr & 0x700))
130                         ? ((csr & (1 << 7)) ? " IN" : " OUT")
131                         : "",
132                 (csr & (1 << 6)) ? " rxdatabk1" : "",
133                 (csr & (1 << 5)) ? " forcestall" : "",
134                 (csr & (1 << 4)) ? " txpktrdy" : "",
135
136                 (csr & (1 << 3)) ? " stallsent" : "",
137                 (csr & (1 << 2)) ? " rxsetup" : "",
138                 (csr & (1 << 1)) ? " rxdatabk0" : "",
139                 (csr & (1 << 0)) ? " txcomp" : "");
140         if (list_empty (&ep->queue))
141                 seq_printf(s, "\t(queue empty)\n");
142
143         else list_for_each_entry (req, &ep->queue, queue) {
144                 unsigned        length = req->req.actual;
145
146                 seq_printf(s, "\treq %p len %d/%d buf %p\n",
147                                 &req->req, length,
148                                 req->req.length, req->req.buf);
149         }
150         local_irq_restore(flags);
151 }
152
153 static void proc_irq_show(struct seq_file *s, const char *label, u32 mask)
154 {
155         int i;
156
157         seq_printf(s, "%s %04x:%s%s" FOURBITS, label, mask,
158                 (mask & (1 << 13)) ? " wakeup" : "",
159                 (mask & (1 << 12)) ? " endbusres" : "",
160
161                 (mask & (1 << 11)) ? " sofint" : "",
162                 (mask & (1 << 10)) ? " extrsm" : "",
163                 (mask & (1 << 9)) ? " rxrsm" : "",
164                 (mask & (1 << 8)) ? " rxsusp" : "");
165         for (i = 0; i < 8; i++) {
166                 if (mask & (1 << i))
167                         seq_printf(s, " ep%d", i);
168         }
169         seq_printf(s, "\n");
170 }
171
172 static int proc_udc_show(struct seq_file *s, void *unused)
173 {
174         struct at91_udc *udc = s->private;
175         struct at91_ep  *ep;
176         u32             tmp;
177
178         seq_printf(s, "%s: version %s\n", driver_name, DRIVER_VERSION);
179
180         seq_printf(s, "vbus %s, pullup %s, %s powered%s, gadget %s\n\n",
181                 udc->vbus ? "present" : "off",
182                 udc->enabled
183                         ? (udc->vbus ? "active" : "enabled")
184                         : "disabled",
185                 udc->selfpowered ? "self" : "VBUS",
186                 udc->suspended ? ", suspended" : "",
187                 udc->driver ? udc->driver->driver.name : "(none)");
188
189         /* don't access registers when interface isn't clocked */
190         if (!udc->clocked) {
191                 seq_printf(s, "(not clocked)\n");
192                 return 0;
193         }
194
195         tmp = at91_udp_read(udc, AT91_UDP_FRM_NUM);
196         seq_printf(s, "frame %05x:%s%s frame=%d\n", tmp,
197                 (tmp & AT91_UDP_FRM_OK) ? " ok" : "",
198                 (tmp & AT91_UDP_FRM_ERR) ? " err" : "",
199                 (tmp & AT91_UDP_NUM));
200
201         tmp = at91_udp_read(udc, AT91_UDP_GLB_STAT);
202         seq_printf(s, "glbstate %02x:%s" FOURBITS "\n", tmp,
203                 (tmp & AT91_UDP_RMWUPE) ? " rmwupe" : "",
204                 (tmp & AT91_UDP_RSMINPR) ? " rsminpr" : "",
205                 (tmp & AT91_UDP_ESR) ? " esr" : "",
206                 (tmp & AT91_UDP_CONFG) ? " confg" : "",
207                 (tmp & AT91_UDP_FADDEN) ? " fadden" : "");
208
209         tmp = at91_udp_read(udc, AT91_UDP_FADDR);
210         seq_printf(s, "faddr   %03x:%s fadd=%d\n", tmp,
211                 (tmp & AT91_UDP_FEN) ? " fen" : "",
212                 (tmp & AT91_UDP_FADD));
213
214         proc_irq_show(s, "imr   ", at91_udp_read(udc, AT91_UDP_IMR));
215         proc_irq_show(s, "isr   ", at91_udp_read(udc, AT91_UDP_ISR));
216
217         if (udc->enabled && udc->vbus) {
218                 proc_ep_show(s, &udc->ep[0]);
219                 list_for_each_entry (ep, &udc->gadget.ep_list, ep.ep_list) {
220                         if (ep->desc)
221                                 proc_ep_show(s, ep);
222                 }
223         }
224         return 0;
225 }
226
227 static int proc_udc_open(struct inode *inode, struct file *file)
228 {
229         return single_open(file, proc_udc_show, PDE(inode)->data);
230 }
231
232 static const struct file_operations proc_ops = {
233         .owner          = THIS_MODULE,
234         .open           = proc_udc_open,
235         .read           = seq_read,
236         .llseek         = seq_lseek,
237         .release        = single_release,
238 };
239
240 static void create_debug_file(struct at91_udc *udc)
241 {
242         udc->pde = proc_create_data(debug_filename, 0, NULL, &proc_ops, udc);
243 }
244
245 static void remove_debug_file(struct at91_udc *udc)
246 {
247         if (udc->pde)
248                 remove_proc_entry(debug_filename, NULL);
249 }
250
251 #else
252
253 static inline void create_debug_file(struct at91_udc *udc) {}
254 static inline void remove_debug_file(struct at91_udc *udc) {}
255
256 #endif
257
258
259 /*-------------------------------------------------------------------------*/
260
261 static void done(struct at91_ep *ep, struct at91_request *req, int status)
262 {
263         unsigned        stopped = ep->stopped;
264         struct at91_udc *udc = ep->udc;
265
266         list_del_init(&req->queue);
267         if (req->req.status == -EINPROGRESS)
268                 req->req.status = status;
269         else
270                 status = req->req.status;
271         if (status && status != -ESHUTDOWN)
272                 VDBG("%s done %p, status %d\n", ep->ep.name, req, status);
273
274         ep->stopped = 1;
275         req->req.complete(&ep->ep, &req->req);
276         ep->stopped = stopped;
277
278         /* ep0 is always ready; other endpoints need a non-empty queue */
279         if (list_empty(&ep->queue) && ep->int_mask != (1 << 0))
280                 at91_udp_write(udc, AT91_UDP_IDR, ep->int_mask);
281 }
282
283 /*-------------------------------------------------------------------------*/
284
285 /* bits indicating OUT fifo has data ready */
286 #define RX_DATA_READY   (AT91_UDP_RX_DATA_BK0 | AT91_UDP_RX_DATA_BK1)
287
288 /*
289  * Endpoint FIFO CSR bits have a mix of bits, making it unsafe to just write
290  * back most of the value you just read (because of side effects, including
291  * bits that may change after reading and before writing).
292  *
293  * Except when changing a specific bit, always write values which:
294  *  - clear SET_FX bits (setting them could change something)
295  *  - set CLR_FX bits (clearing them could change something)
296  *
297  * There are also state bits like FORCESTALL, EPEDS, DIR, and EPTYPE
298  * that shouldn't normally be changed.
299  *
300  * NOTE at91sam9260 docs mention synch between UDPCK and MCK clock domains,
301  * implying a need to wait for one write to complete (test relevant bits)
302  * before starting the next write.  This shouldn't be an issue given how
303  * infrequently we write, except maybe for write-then-read idioms.
304  */
305 #define SET_FX  (AT91_UDP_TXPKTRDY)
306 #define CLR_FX  (RX_DATA_READY | AT91_UDP_RXSETUP \
307                 | AT91_UDP_STALLSENT | AT91_UDP_TXCOMP)
308
309 /* pull OUT packet data from the endpoint's fifo */
310 static int read_fifo (struct at91_ep *ep, struct at91_request *req)
311 {
312         u32 __iomem     *creg = ep->creg;
313         u8 __iomem      *dreg = ep->creg + (AT91_UDP_FDR(0) - AT91_UDP_CSR(0));
314         u32             csr;
315         u8              *buf;
316         unsigned int    count, bufferspace, is_done;
317
318         buf = req->req.buf + req->req.actual;
319         bufferspace = req->req.length - req->req.actual;
320
321         /*
322          * there might be nothing to read if ep_queue() calls us,
323          * or if we already emptied both pingpong buffers
324          */
325 rescan:
326         csr = __raw_readl(creg);
327         if ((csr & RX_DATA_READY) == 0)
328                 return 0;
329
330         count = (csr & AT91_UDP_RXBYTECNT) >> 16;
331         if (count > ep->ep.maxpacket)
332                 count = ep->ep.maxpacket;
333         if (count > bufferspace) {
334                 DBG("%s buffer overflow\n", ep->ep.name);
335                 req->req.status = -EOVERFLOW;
336                 count = bufferspace;
337         }
338         __raw_readsb(dreg, buf, count);
339
340         /* release and swap pingpong mem bank */
341         csr |= CLR_FX;
342         if (ep->is_pingpong) {
343                 if (ep->fifo_bank == 0) {
344                         csr &= ~(SET_FX | AT91_UDP_RX_DATA_BK0);
345                         ep->fifo_bank = 1;
346                 } else {
347                         csr &= ~(SET_FX | AT91_UDP_RX_DATA_BK1);
348                         ep->fifo_bank = 0;
349                 }
350         } else
351                 csr &= ~(SET_FX | AT91_UDP_RX_DATA_BK0);
352         __raw_writel(csr, creg);
353
354         req->req.actual += count;
355         is_done = (count < ep->ep.maxpacket);
356         if (count == bufferspace)
357                 is_done = 1;
358
359         PACKET("%s %p out/%d%s\n", ep->ep.name, &req->req, count,
360                         is_done ? " (done)" : "");
361
362         /*
363          * avoid extra trips through IRQ logic for packets already in
364          * the fifo ... maybe preventing an extra (expensive) OUT-NAK
365          */
366         if (is_done)
367                 done(ep, req, 0);
368         else if (ep->is_pingpong) {
369                 bufferspace -= count;
370                 buf += count;
371                 goto rescan;
372         }
373
374         return is_done;
375 }
376
377 /* load fifo for an IN packet */
378 static int write_fifo(struct at91_ep *ep, struct at91_request *req)
379 {
380         u32 __iomem     *creg = ep->creg;
381         u32             csr = __raw_readl(creg);
382         u8 __iomem      *dreg = ep->creg + (AT91_UDP_FDR(0) - AT91_UDP_CSR(0));
383         unsigned        total, count, is_last;
384         u8              *buf;
385
386         /*
387          * TODO: allow for writing two packets to the fifo ... that'll
388          * reduce the amount of IN-NAKing, but probably won't affect
389          * throughput much.  (Unlike preventing OUT-NAKing!)
390          */
391
392         /*
393          * If ep_queue() calls us, the queue is empty and possibly in
394          * odd states like TXCOMP not yet cleared (we do it, saving at
395          * least one IRQ) or the fifo not yet being free.  Those aren't
396          * issues normally (IRQ handler fast path).
397          */
398         if (unlikely(csr & (AT91_UDP_TXCOMP | AT91_UDP_TXPKTRDY))) {
399                 if (csr & AT91_UDP_TXCOMP) {
400                         csr |= CLR_FX;
401                         csr &= ~(SET_FX | AT91_UDP_TXCOMP);
402                         __raw_writel(csr, creg);
403                         csr = __raw_readl(creg);
404                 }
405                 if (csr & AT91_UDP_TXPKTRDY)
406                         return 0;
407         }
408
409         buf = req->req.buf + req->req.actual;
410         prefetch(buf);
411         total = req->req.length - req->req.actual;
412         if (ep->ep.maxpacket < total) {
413                 count = ep->ep.maxpacket;
414                 is_last = 0;
415         } else {
416                 count = total;
417                 is_last = (count < ep->ep.maxpacket) || !req->req.zero;
418         }
419
420         /*
421          * Write the packet, maybe it's a ZLP.
422          *
423          * NOTE:  incrementing req->actual before we receive the ACK means
424          * gadget driver IN bytecounts can be wrong in fault cases.  That's
425          * fixable with PIO drivers like this one (save "count" here, and
426          * do the increment later on TX irq), but not for most DMA hardware.
427          *
428          * So all gadget drivers must accept that potential error.  Some
429          * hardware supports precise fifo status reporting, letting them
430          * recover when the actual bytecount matters (e.g. for USB Test
431          * and Measurement Class devices).
432          */
433         __raw_writesb(dreg, buf, count);
434         csr &= ~SET_FX;
435         csr |= CLR_FX | AT91_UDP_TXPKTRDY;
436         __raw_writel(csr, creg);
437         req->req.actual += count;
438
439         PACKET("%s %p in/%d%s\n", ep->ep.name, &req->req, count,
440                         is_last ? " (done)" : "");
441         if (is_last)
442                 done(ep, req, 0);
443         return is_last;
444 }
445
446 static void nuke(struct at91_ep *ep, int status)
447 {
448         struct at91_request *req;
449
450         // terminer chaque requete dans la queue
451         ep->stopped = 1;
452         if (list_empty(&ep->queue))
453                 return;
454
455         VDBG("%s %s\n", __func__, ep->ep.name);
456         while (!list_empty(&ep->queue)) {
457                 req = list_entry(ep->queue.next, struct at91_request, queue);
458                 done(ep, req, status);
459         }
460 }
461
462 /*-------------------------------------------------------------------------*/
463
464 static int at91_ep_enable(struct usb_ep *_ep,
465                                 const struct usb_endpoint_descriptor *desc)
466 {
467         struct at91_ep  *ep = container_of(_ep, struct at91_ep, ep);
468         struct at91_udc *dev = ep->udc;
469         u16             maxpacket;
470         u32             tmp;
471         unsigned long   flags;
472
473         if (!_ep || !ep
474                         || !desc || ep->desc
475                         || _ep->name == ep0name
476                         || desc->bDescriptorType != USB_DT_ENDPOINT
477                         || (maxpacket = le16_to_cpu(desc->wMaxPacketSize)) == 0
478                         || maxpacket > ep->maxpacket) {
479                 DBG("bad ep or descriptor\n");
480                 return -EINVAL;
481         }
482
483         if (!dev->driver || dev->gadget.speed == USB_SPEED_UNKNOWN) {
484                 DBG("bogus device state\n");
485                 return -ESHUTDOWN;
486         }
487
488         tmp = desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK;
489         switch (tmp) {
490         case USB_ENDPOINT_XFER_CONTROL:
491                 DBG("only one control endpoint\n");
492                 return -EINVAL;
493         case USB_ENDPOINT_XFER_INT:
494                 if (maxpacket > 64)
495                         goto bogus_max;
496                 break;
497         case USB_ENDPOINT_XFER_BULK:
498                 switch (maxpacket) {
499                 case 8:
500                 case 16:
501                 case 32:
502                 case 64:
503                         goto ok;
504                 }
505 bogus_max:
506                 DBG("bogus maxpacket %d\n", maxpacket);
507                 return -EINVAL;
508         case USB_ENDPOINT_XFER_ISOC:
509                 if (!ep->is_pingpong) {
510                         DBG("iso requires double buffering\n");
511                         return -EINVAL;
512                 }
513                 break;
514         }
515
516 ok:
517         local_irq_save(flags);
518
519         /* initialize endpoint to match this descriptor */
520         ep->is_in = (desc->bEndpointAddress & USB_DIR_IN) != 0;
521         ep->is_iso = (tmp == USB_ENDPOINT_XFER_ISOC);
522         ep->stopped = 0;
523         if (ep->is_in)
524                 tmp |= 0x04;
525         tmp <<= 8;
526         tmp |= AT91_UDP_EPEDS;
527         __raw_writel(tmp, ep->creg);
528
529         ep->desc = desc;
530         ep->ep.maxpacket = maxpacket;
531
532         /*
533          * reset/init endpoint fifo.  NOTE:  leaves fifo_bank alone,
534          * since endpoint resets don't reset hw pingpong state.
535          */
536         at91_udp_write(dev, AT91_UDP_RST_EP, ep->int_mask);
537         at91_udp_write(dev, AT91_UDP_RST_EP, 0);
538
539         local_irq_restore(flags);
540         return 0;
541 }
542
543 static int at91_ep_disable (struct usb_ep * _ep)
544 {
545         struct at91_ep  *ep = container_of(_ep, struct at91_ep, ep);
546         struct at91_udc *udc = ep->udc;
547         unsigned long   flags;
548
549         if (ep == &ep->udc->ep[0])
550                 return -EINVAL;
551
552         local_irq_save(flags);
553
554         nuke(ep, -ESHUTDOWN);
555
556         /* restore the endpoint's pristine config */
557         ep->desc = NULL;
558         ep->ep.maxpacket = ep->maxpacket;
559
560         /* reset fifos and endpoint */
561         if (ep->udc->clocked) {
562                 at91_udp_write(udc, AT91_UDP_RST_EP, ep->int_mask);
563                 at91_udp_write(udc, AT91_UDP_RST_EP, 0);
564                 __raw_writel(0, ep->creg);
565         }
566
567         local_irq_restore(flags);
568         return 0;
569 }
570
571 /*
572  * this is a PIO-only driver, so there's nothing
573  * interesting for request or buffer allocation.
574  */
575
576 static struct usb_request *
577 at91_ep_alloc_request(struct usb_ep *_ep, gfp_t gfp_flags)
578 {
579         struct at91_request *req;
580
581         req = kzalloc(sizeof (struct at91_request), gfp_flags);
582         if (!req)
583                 return NULL;
584
585         INIT_LIST_HEAD(&req->queue);
586         return &req->req;
587 }
588
589 static void at91_ep_free_request(struct usb_ep *_ep, struct usb_request *_req)
590 {
591         struct at91_request *req;
592
593         req = container_of(_req, struct at91_request, req);
594         BUG_ON(!list_empty(&req->queue));
595         kfree(req);
596 }
597
598 static int at91_ep_queue(struct usb_ep *_ep,
599                         struct usb_request *_req, gfp_t gfp_flags)
600 {
601         struct at91_request     *req;
602         struct at91_ep          *ep;
603         struct at91_udc         *dev;
604         int                     status;
605         unsigned long           flags;
606
607         req = container_of(_req, struct at91_request, req);
608         ep = container_of(_ep, struct at91_ep, ep);
609
610         if (!_req || !_req->complete
611                         || !_req->buf || !list_empty(&req->queue)) {
612                 DBG("invalid request\n");
613                 return -EINVAL;
614         }
615
616         if (!_ep || (!ep->desc && ep->ep.name != ep0name)) {
617                 DBG("invalid ep\n");
618                 return -EINVAL;
619         }
620
621         dev = ep->udc;
622
623         if (!dev || !dev->driver || dev->gadget.speed == USB_SPEED_UNKNOWN) {
624                 DBG("invalid device\n");
625                 return -EINVAL;
626         }
627
628         _req->status = -EINPROGRESS;
629         _req->actual = 0;
630
631         local_irq_save(flags);
632
633         /* try to kickstart any empty and idle queue */
634         if (list_empty(&ep->queue) && !ep->stopped) {
635                 int     is_ep0;
636
637                 /*
638                  * If this control request has a non-empty DATA stage, this
639                  * will start that stage.  It works just like a non-control
640                  * request (until the status stage starts, maybe early).
641                  *
642                  * If the data stage is empty, then this starts a successful
643                  * IN/STATUS stage.  (Unsuccessful ones use set_halt.)
644                  */
645                 is_ep0 = (ep->ep.name == ep0name);
646                 if (is_ep0) {
647                         u32     tmp;
648
649                         if (!dev->req_pending) {
650                                 status = -EINVAL;
651                                 goto done;
652                         }
653
654                         /*
655                          * defer changing CONFG until after the gadget driver
656                          * reconfigures the endpoints.
657                          */
658                         if (dev->wait_for_config_ack) {
659                                 tmp = at91_udp_read(dev, AT91_UDP_GLB_STAT);
660                                 tmp ^= AT91_UDP_CONFG;
661                                 VDBG("toggle config\n");
662                                 at91_udp_write(dev, AT91_UDP_GLB_STAT, tmp);
663                         }
664                         if (req->req.length == 0) {
665 ep0_in_status:
666                                 PACKET("ep0 in/status\n");
667                                 status = 0;
668                                 tmp = __raw_readl(ep->creg);
669                                 tmp &= ~SET_FX;
670                                 tmp |= CLR_FX | AT91_UDP_TXPKTRDY;
671                                 __raw_writel(tmp, ep->creg);
672                                 dev->req_pending = 0;
673                                 goto done;
674                         }
675                 }
676
677                 if (ep->is_in)
678                         status = write_fifo(ep, req);
679                 else {
680                         status = read_fifo(ep, req);
681
682                         /* IN/STATUS stage is otherwise triggered by irq */
683                         if (status && is_ep0)
684                                 goto ep0_in_status;
685                 }
686         } else
687                 status = 0;
688
689         if (req && !status) {
690                 list_add_tail (&req->queue, &ep->queue);
691                 at91_udp_write(dev, AT91_UDP_IER, ep->int_mask);
692         }
693 done:
694         local_irq_restore(flags);
695         return (status < 0) ? status : 0;
696 }
697
698 static int at91_ep_dequeue(struct usb_ep *_ep, struct usb_request *_req)
699 {
700         struct at91_ep  *ep;
701         struct at91_request     *req;
702
703         ep = container_of(_ep, struct at91_ep, ep);
704         if (!_ep || ep->ep.name == ep0name)
705                 return -EINVAL;
706
707         /* make sure it's actually queued on this endpoint */
708         list_for_each_entry (req, &ep->queue, queue) {
709                 if (&req->req == _req)
710                         break;
711         }
712         if (&req->req != _req)
713                 return -EINVAL;
714
715         done(ep, req, -ECONNRESET);
716         return 0;
717 }
718
719 static int at91_ep_set_halt(struct usb_ep *_ep, int value)
720 {
721         struct at91_ep  *ep = container_of(_ep, struct at91_ep, ep);
722         struct at91_udc *udc = ep->udc;
723         u32 __iomem     *creg;
724         u32             csr;
725         unsigned long   flags;
726         int             status = 0;
727
728         if (!_ep || ep->is_iso || !ep->udc->clocked)
729                 return -EINVAL;
730
731         creg = ep->creg;
732         local_irq_save(flags);
733
734         csr = __raw_readl(creg);
735
736         /*
737          * fail with still-busy IN endpoints, ensuring correct sequencing
738          * of data tx then stall.  note that the fifo rx bytecount isn't
739          * completely accurate as a tx bytecount.
740          */
741         if (ep->is_in && (!list_empty(&ep->queue) || (csr >> 16) != 0))
742                 status = -EAGAIN;
743         else {
744                 csr |= CLR_FX;
745                 csr &= ~SET_FX;
746                 if (value) {
747                         csr |= AT91_UDP_FORCESTALL;
748                         VDBG("halt %s\n", ep->ep.name);
749                 } else {
750                         at91_udp_write(udc, AT91_UDP_RST_EP, ep->int_mask);
751                         at91_udp_write(udc, AT91_UDP_RST_EP, 0);
752                         csr &= ~AT91_UDP_FORCESTALL;
753                 }
754                 __raw_writel(csr, creg);
755         }
756
757         local_irq_restore(flags);
758         return status;
759 }
760
761 static const struct usb_ep_ops at91_ep_ops = {
762         .enable         = at91_ep_enable,
763         .disable        = at91_ep_disable,
764         .alloc_request  = at91_ep_alloc_request,
765         .free_request   = at91_ep_free_request,
766         .queue          = at91_ep_queue,
767         .dequeue        = at91_ep_dequeue,
768         .set_halt       = at91_ep_set_halt,
769         // there's only imprecise fifo status reporting
770 };
771
772 /*-------------------------------------------------------------------------*/
773
774 static int at91_get_frame(struct usb_gadget *gadget)
775 {
776         struct at91_udc *udc = to_udc(gadget);
777
778         if (!to_udc(gadget)->clocked)
779                 return -EINVAL;
780         return at91_udp_read(udc, AT91_UDP_FRM_NUM) & AT91_UDP_NUM;
781 }
782
783 static int at91_wakeup(struct usb_gadget *gadget)
784 {
785         struct at91_udc *udc = to_udc(gadget);
786         u32             glbstate;
787         int             status = -EINVAL;
788         unsigned long   flags;
789
790         DBG("%s\n", __func__ );
791         local_irq_save(flags);
792
793         if (!udc->clocked || !udc->suspended)
794                 goto done;
795
796         /* NOTE:  some "early versions" handle ESR differently ... */
797
798         glbstate = at91_udp_read(udc, AT91_UDP_GLB_STAT);
799         if (!(glbstate & AT91_UDP_ESR))
800                 goto done;
801         glbstate |= AT91_UDP_ESR;
802         at91_udp_write(udc, AT91_UDP_GLB_STAT, glbstate);
803
804 done:
805         local_irq_restore(flags);
806         return status;
807 }
808
809 /* reinit == restore inital software state */
810 static void udc_reinit(struct at91_udc *udc)
811 {
812         u32 i;
813
814         INIT_LIST_HEAD(&udc->gadget.ep_list);
815         INIT_LIST_HEAD(&udc->gadget.ep0->ep_list);
816
817         for (i = 0; i < NUM_ENDPOINTS; i++) {
818                 struct at91_ep *ep = &udc->ep[i];
819
820                 if (i != 0)
821                         list_add_tail(&ep->ep.ep_list, &udc->gadget.ep_list);
822                 ep->desc = NULL;
823                 ep->stopped = 0;
824                 ep->fifo_bank = 0;
825                 ep->ep.maxpacket = ep->maxpacket;
826                 ep->creg = (void __iomem *) udc->udp_baseaddr + AT91_UDP_CSR(i);
827                 // initialiser une queue par endpoint
828                 INIT_LIST_HEAD(&ep->queue);
829         }
830 }
831
832 static void stop_activity(struct at91_udc *udc)
833 {
834         struct usb_gadget_driver *driver = udc->driver;
835         int i;
836
837         if (udc->gadget.speed == USB_SPEED_UNKNOWN)
838                 driver = NULL;
839         udc->gadget.speed = USB_SPEED_UNKNOWN;
840         udc->suspended = 0;
841
842         for (i = 0; i < NUM_ENDPOINTS; i++) {
843                 struct at91_ep *ep = &udc->ep[i];
844                 ep->stopped = 1;
845                 nuke(ep, -ESHUTDOWN);
846         }
847         if (driver)
848                 driver->disconnect(&udc->gadget);
849
850         udc_reinit(udc);
851 }
852
853 static void clk_on(struct at91_udc *udc)
854 {
855         if (udc->clocked)
856                 return;
857         udc->clocked = 1;
858         clk_enable(udc->iclk);
859         clk_enable(udc->fclk);
860 }
861
862 static void clk_off(struct at91_udc *udc)
863 {
864         if (!udc->clocked)
865                 return;
866         udc->clocked = 0;
867         udc->gadget.speed = USB_SPEED_UNKNOWN;
868         clk_disable(udc->fclk);
869         clk_disable(udc->iclk);
870 }
871
872 /*
873  * activate/deactivate link with host; minimize power usage for
874  * inactive links by cutting clocks and transceiver power.
875  */
876 static void pullup(struct at91_udc *udc, int is_on)
877 {
878         int     active = !udc->board.pullup_active_low;
879
880         if (!udc->enabled || !udc->vbus)
881                 is_on = 0;
882         DBG("%sactive\n", is_on ? "" : "in");
883
884         if (is_on) {
885                 clk_on(udc);
886                 at91_udp_write(udc, AT91_UDP_ICR, AT91_UDP_RXRSM);
887                 at91_udp_write(udc, AT91_UDP_TXVC, 0);
888                 if (cpu_is_at91rm9200())
889                         gpio_set_value(udc->board.pullup_pin, active);
890                 else if (cpu_is_at91sam9260() || cpu_is_at91sam9263() || cpu_is_at91sam9g20()) {
891                         u32     txvc = at91_udp_read(udc, AT91_UDP_TXVC);
892
893                         txvc |= AT91_UDP_TXVC_PUON;
894                         at91_udp_write(udc, AT91_UDP_TXVC, txvc);
895                 } else if (cpu_is_at91sam9261()) {
896                         u32     usbpucr;
897
898                         usbpucr = at91_sys_read(AT91_MATRIX_USBPUCR);
899                         usbpucr |= AT91_MATRIX_USBPUCR_PUON;
900                         at91_sys_write(AT91_MATRIX_USBPUCR, usbpucr);
901                 }
902         } else {
903                 stop_activity(udc);
904                 at91_udp_write(udc, AT91_UDP_IDR, AT91_UDP_RXRSM);
905                 at91_udp_write(udc, AT91_UDP_TXVC, AT91_UDP_TXVC_TXVDIS);
906                 if (cpu_is_at91rm9200())
907                         gpio_set_value(udc->board.pullup_pin, !active);
908                 else if (cpu_is_at91sam9260() || cpu_is_at91sam9263() || cpu_is_at91sam9g20()) {
909                         u32     txvc = at91_udp_read(udc, AT91_UDP_TXVC);
910
911                         txvc &= ~AT91_UDP_TXVC_PUON;
912                         at91_udp_write(udc, AT91_UDP_TXVC, txvc);
913                 } else if (cpu_is_at91sam9261()) {
914                         u32     usbpucr;
915
916                         usbpucr = at91_sys_read(AT91_MATRIX_USBPUCR);
917                         usbpucr &= ~AT91_MATRIX_USBPUCR_PUON;
918                         at91_sys_write(AT91_MATRIX_USBPUCR, usbpucr);
919                 }
920                 clk_off(udc);
921         }
922 }
923
924 /* vbus is here!  turn everything on that's ready */
925 static int at91_vbus_session(struct usb_gadget *gadget, int is_active)
926 {
927         struct at91_udc *udc = to_udc(gadget);
928         unsigned long   flags;
929
930         // VDBG("vbus %s\n", is_active ? "on" : "off");
931         local_irq_save(flags);
932         udc->vbus = (is_active != 0);
933         if (udc->driver)
934                 pullup(udc, is_active);
935         else
936                 pullup(udc, 0);
937         local_irq_restore(flags);
938         return 0;
939 }
940
941 static int at91_pullup(struct usb_gadget *gadget, int is_on)
942 {
943         struct at91_udc *udc = to_udc(gadget);
944         unsigned long   flags;
945
946         local_irq_save(flags);
947         udc->enabled = is_on = !!is_on;
948         pullup(udc, is_on);
949         local_irq_restore(flags);
950         return 0;
951 }
952
953 static int at91_set_selfpowered(struct usb_gadget *gadget, int is_on)
954 {
955         struct at91_udc *udc = to_udc(gadget);
956         unsigned long   flags;
957
958         local_irq_save(flags);
959         udc->selfpowered = (is_on != 0);
960         local_irq_restore(flags);
961         return 0;
962 }
963
964 static const struct usb_gadget_ops at91_udc_ops = {
965         .get_frame              = at91_get_frame,
966         .wakeup                 = at91_wakeup,
967         .set_selfpowered        = at91_set_selfpowered,
968         .vbus_session           = at91_vbus_session,
969         .pullup                 = at91_pullup,
970
971         /*
972          * VBUS-powered devices may also also want to support bigger
973          * power budgets after an appropriate SET_CONFIGURATION.
974          */
975         // .vbus_power          = at91_vbus_power,
976 };
977
978 /*-------------------------------------------------------------------------*/
979
980 static int handle_ep(struct at91_ep *ep)
981 {
982         struct at91_request     *req;
983         u32 __iomem             *creg = ep->creg;
984         u32                     csr = __raw_readl(creg);
985
986         if (!list_empty(&ep->queue))
987                 req = list_entry(ep->queue.next,
988                         struct at91_request, queue);
989         else
990                 req = NULL;
991
992         if (ep->is_in) {
993                 if (csr & (AT91_UDP_STALLSENT | AT91_UDP_TXCOMP)) {
994                         csr |= CLR_FX;
995                         csr &= ~(SET_FX | AT91_UDP_STALLSENT | AT91_UDP_TXCOMP);
996                         __raw_writel(csr, creg);
997                 }
998                 if (req)
999                         return write_fifo(ep, req);
1000
1001         } else {
1002                 if (csr & AT91_UDP_STALLSENT) {
1003                         /* STALLSENT bit == ISOERR */
1004                         if (ep->is_iso && req)
1005                                 req->req.status = -EILSEQ;
1006                         csr |= CLR_FX;
1007                         csr &= ~(SET_FX | AT91_UDP_STALLSENT);
1008                         __raw_writel(csr, creg);
1009                         csr = __raw_readl(creg);
1010                 }
1011                 if (req && (csr & RX_DATA_READY))
1012                         return read_fifo(ep, req);
1013         }
1014         return 0;
1015 }
1016
1017 union setup {
1018         u8                      raw[8];
1019         struct usb_ctrlrequest  r;
1020 };
1021
1022 static void handle_setup(struct at91_udc *udc, struct at91_ep *ep, u32 csr)
1023 {
1024         u32 __iomem     *creg = ep->creg;
1025         u8 __iomem      *dreg = ep->creg + (AT91_UDP_FDR(0) - AT91_UDP_CSR(0));
1026         unsigned        rxcount, i = 0;
1027         u32             tmp;
1028         union setup     pkt;
1029         int             status = 0;
1030
1031         /* read and ack SETUP; hard-fail for bogus packets */
1032         rxcount = (csr & AT91_UDP_RXBYTECNT) >> 16;
1033         if (likely(rxcount == 8)) {
1034                 while (rxcount--)
1035                         pkt.raw[i++] = __raw_readb(dreg);
1036                 if (pkt.r.bRequestType & USB_DIR_IN) {
1037                         csr |= AT91_UDP_DIR;
1038                         ep->is_in = 1;
1039                 } else {
1040                         csr &= ~AT91_UDP_DIR;
1041                         ep->is_in = 0;
1042                 }
1043         } else {
1044                 // REVISIT this happens sometimes under load; why??
1045                 ERR("SETUP len %d, csr %08x\n", rxcount, csr);
1046                 status = -EINVAL;
1047         }
1048         csr |= CLR_FX;
1049         csr &= ~(SET_FX | AT91_UDP_RXSETUP);
1050         __raw_writel(csr, creg);
1051         udc->wait_for_addr_ack = 0;
1052         udc->wait_for_config_ack = 0;
1053         ep->stopped = 0;
1054         if (unlikely(status != 0))
1055                 goto stall;
1056
1057 #define w_index         le16_to_cpu(pkt.r.wIndex)
1058 #define w_value         le16_to_cpu(pkt.r.wValue)
1059 #define w_length        le16_to_cpu(pkt.r.wLength)
1060
1061         VDBG("SETUP %02x.%02x v%04x i%04x l%04x\n",
1062                         pkt.r.bRequestType, pkt.r.bRequest,
1063                         w_value, w_index, w_length);
1064
1065         /*
1066          * A few standard requests get handled here, ones that touch
1067          * hardware ... notably for device and endpoint features.
1068          */
1069         udc->req_pending = 1;
1070         csr = __raw_readl(creg);
1071         csr |= CLR_FX;
1072         csr &= ~SET_FX;
1073         switch ((pkt.r.bRequestType << 8) | pkt.r.bRequest) {
1074
1075         case ((USB_TYPE_STANDARD|USB_RECIP_DEVICE) << 8)
1076                         | USB_REQ_SET_ADDRESS:
1077                 __raw_writel(csr | AT91_UDP_TXPKTRDY, creg);
1078                 udc->addr = w_value;
1079                 udc->wait_for_addr_ack = 1;
1080                 udc->req_pending = 0;
1081                 /* FADDR is set later, when we ack host STATUS */
1082                 return;
1083
1084         case ((USB_TYPE_STANDARD|USB_RECIP_DEVICE) << 8)
1085                         | USB_REQ_SET_CONFIGURATION:
1086                 tmp = at91_udp_read(udc, AT91_UDP_GLB_STAT) & AT91_UDP_CONFG;
1087                 if (pkt.r.wValue)
1088                         udc->wait_for_config_ack = (tmp == 0);
1089                 else
1090                         udc->wait_for_config_ack = (tmp != 0);
1091                 if (udc->wait_for_config_ack)
1092                         VDBG("wait for config\n");
1093                 /* CONFG is toggled later, if gadget driver succeeds */
1094                 break;
1095
1096         /*
1097          * Hosts may set or clear remote wakeup status, and
1098          * devices may report they're VBUS powered.
1099          */
1100         case ((USB_DIR_IN|USB_TYPE_STANDARD|USB_RECIP_DEVICE) << 8)
1101                         | USB_REQ_GET_STATUS:
1102                 tmp = (udc->selfpowered << USB_DEVICE_SELF_POWERED);
1103                 if (at91_udp_read(udc, AT91_UDP_GLB_STAT) & AT91_UDP_ESR)
1104                         tmp |= (1 << USB_DEVICE_REMOTE_WAKEUP);
1105                 PACKET("get device status\n");
1106                 __raw_writeb(tmp, dreg);
1107                 __raw_writeb(0, dreg);
1108                 goto write_in;
1109                 /* then STATUS starts later, automatically */
1110         case ((USB_TYPE_STANDARD|USB_RECIP_DEVICE) << 8)
1111                         | USB_REQ_SET_FEATURE:
1112                 if (w_value != USB_DEVICE_REMOTE_WAKEUP)
1113                         goto stall;
1114                 tmp = at91_udp_read(udc, AT91_UDP_GLB_STAT);
1115                 tmp |= AT91_UDP_ESR;
1116                 at91_udp_write(udc, AT91_UDP_GLB_STAT, tmp);
1117                 goto succeed;
1118         case ((USB_TYPE_STANDARD|USB_RECIP_DEVICE) << 8)
1119                         | USB_REQ_CLEAR_FEATURE:
1120                 if (w_value != USB_DEVICE_REMOTE_WAKEUP)
1121                         goto stall;
1122                 tmp = at91_udp_read(udc, AT91_UDP_GLB_STAT);
1123                 tmp &= ~AT91_UDP_ESR;
1124                 at91_udp_write(udc, AT91_UDP_GLB_STAT, tmp);
1125                 goto succeed;
1126
1127         /*
1128          * Interfaces have no feature settings; this is pretty useless.
1129          * we won't even insist the interface exists...
1130          */
1131         case ((USB_DIR_IN|USB_TYPE_STANDARD|USB_RECIP_INTERFACE) << 8)
1132                         | USB_REQ_GET_STATUS:
1133                 PACKET("get interface status\n");
1134                 __raw_writeb(0, dreg);
1135                 __raw_writeb(0, dreg);
1136                 goto write_in;
1137                 /* then STATUS starts later, automatically */
1138         case ((USB_TYPE_STANDARD|USB_RECIP_INTERFACE) << 8)
1139                         | USB_REQ_SET_FEATURE:
1140         case ((USB_TYPE_STANDARD|USB_RECIP_INTERFACE) << 8)
1141                         | USB_REQ_CLEAR_FEATURE:
1142                 goto stall;
1143
1144         /*
1145          * Hosts may clear bulk/intr endpoint halt after the gadget
1146          * driver sets it (not widely used); or set it (for testing)
1147          */
1148         case ((USB_DIR_IN|USB_TYPE_STANDARD|USB_RECIP_ENDPOINT) << 8)
1149                         | USB_REQ_GET_STATUS:
1150                 tmp = w_index & USB_ENDPOINT_NUMBER_MASK;
1151                 ep = &udc->ep[tmp];
1152                 if (tmp >= NUM_ENDPOINTS || (tmp && !ep->desc))
1153                         goto stall;
1154
1155                 if (tmp) {
1156                         if ((w_index & USB_DIR_IN)) {
1157                                 if (!ep->is_in)
1158                                         goto stall;
1159                         } else if (ep->is_in)
1160                                 goto stall;
1161                 }
1162                 PACKET("get %s status\n", ep->ep.name);
1163                 if (__raw_readl(ep->creg) & AT91_UDP_FORCESTALL)
1164                         tmp = (1 << USB_ENDPOINT_HALT);
1165                 else
1166                         tmp = 0;
1167                 __raw_writeb(tmp, dreg);
1168                 __raw_writeb(0, dreg);
1169                 goto write_in;
1170                 /* then STATUS starts later, automatically */
1171         case ((USB_TYPE_STANDARD|USB_RECIP_ENDPOINT) << 8)
1172                         | USB_REQ_SET_FEATURE:
1173                 tmp = w_index & USB_ENDPOINT_NUMBER_MASK;
1174                 ep = &udc->ep[tmp];
1175                 if (w_value != USB_ENDPOINT_HALT || tmp >= NUM_ENDPOINTS)
1176                         goto stall;
1177                 if (!ep->desc || ep->is_iso)
1178                         goto stall;
1179                 if ((w_index & USB_DIR_IN)) {
1180                         if (!ep->is_in)
1181                                 goto stall;
1182                 } else if (ep->is_in)
1183                         goto stall;
1184
1185                 tmp = __raw_readl(ep->creg);
1186                 tmp &= ~SET_FX;
1187                 tmp |= CLR_FX | AT91_UDP_FORCESTALL;
1188                 __raw_writel(tmp, ep->creg);
1189                 goto succeed;
1190         case ((USB_TYPE_STANDARD|USB_RECIP_ENDPOINT) << 8)
1191                         | USB_REQ_CLEAR_FEATURE:
1192                 tmp = w_index & USB_ENDPOINT_NUMBER_MASK;
1193                 ep = &udc->ep[tmp];
1194                 if (w_value != USB_ENDPOINT_HALT || tmp >= NUM_ENDPOINTS)
1195                         goto stall;
1196                 if (tmp == 0)
1197                         goto succeed;
1198                 if (!ep->desc || ep->is_iso)
1199                         goto stall;
1200                 if ((w_index & USB_DIR_IN)) {
1201                         if (!ep->is_in)
1202                                 goto stall;
1203                 } else if (ep->is_in)
1204                         goto stall;
1205
1206                 at91_udp_write(udc, AT91_UDP_RST_EP, ep->int_mask);
1207                 at91_udp_write(udc, AT91_UDP_RST_EP, 0);
1208                 tmp = __raw_readl(ep->creg);
1209                 tmp |= CLR_FX;
1210                 tmp &= ~(SET_FX | AT91_UDP_FORCESTALL);
1211                 __raw_writel(tmp, ep->creg);
1212                 if (!list_empty(&ep->queue))
1213                         handle_ep(ep);
1214                 goto succeed;
1215         }
1216
1217 #undef w_value
1218 #undef w_index
1219 #undef w_length
1220
1221         /* pass request up to the gadget driver */
1222         if (udc->driver)
1223                 status = udc->driver->setup(&udc->gadget, &pkt.r);
1224         else
1225                 status = -ENODEV;
1226         if (status < 0) {
1227 stall:
1228                 VDBG("req %02x.%02x protocol STALL; stat %d\n",
1229                                 pkt.r.bRequestType, pkt.r.bRequest, status);
1230                 csr |= AT91_UDP_FORCESTALL;
1231                 __raw_writel(csr, creg);
1232                 udc->req_pending = 0;
1233         }
1234         return;
1235
1236 succeed:
1237         /* immediate successful (IN) STATUS after zero length DATA */
1238         PACKET("ep0 in/status\n");
1239 write_in:
1240         csr |= AT91_UDP_TXPKTRDY;
1241         __raw_writel(csr, creg);
1242         udc->req_pending = 0;
1243         return;
1244 }
1245
1246 static void handle_ep0(struct at91_udc *udc)
1247 {
1248         struct at91_ep          *ep0 = &udc->ep[0];
1249         u32 __iomem             *creg = ep0->creg;
1250         u32                     csr = __raw_readl(creg);
1251         struct at91_request     *req;
1252
1253         if (unlikely(csr & AT91_UDP_STALLSENT)) {
1254                 nuke(ep0, -EPROTO);
1255                 udc->req_pending = 0;
1256                 csr |= CLR_FX;
1257                 csr &= ~(SET_FX | AT91_UDP_STALLSENT | AT91_UDP_FORCESTALL);
1258                 __raw_writel(csr, creg);
1259                 VDBG("ep0 stalled\n");
1260                 csr = __raw_readl(creg);
1261         }
1262         if (csr & AT91_UDP_RXSETUP) {
1263                 nuke(ep0, 0);
1264                 udc->req_pending = 0;
1265                 handle_setup(udc, ep0, csr);
1266                 return;
1267         }
1268
1269         if (list_empty(&ep0->queue))
1270                 req = NULL;
1271         else
1272                 req = list_entry(ep0->queue.next, struct at91_request, queue);
1273
1274         /* host ACKed an IN packet that we sent */
1275         if (csr & AT91_UDP_TXCOMP) {
1276                 csr |= CLR_FX;
1277                 csr &= ~(SET_FX | AT91_UDP_TXCOMP);
1278
1279                 /* write more IN DATA? */
1280                 if (req && ep0->is_in) {
1281                         if (handle_ep(ep0))
1282                                 udc->req_pending = 0;
1283
1284                 /*
1285                  * Ack after:
1286                  *  - last IN DATA packet (including GET_STATUS)
1287                  *  - IN/STATUS for OUT DATA
1288                  *  - IN/STATUS for any zero-length DATA stage
1289                  * except for the IN DATA case, the host should send
1290                  * an OUT status later, which we'll ack.
1291                  */
1292                 } else {
1293                         udc->req_pending = 0;
1294                         __raw_writel(csr, creg);
1295
1296                         /*
1297                          * SET_ADDRESS takes effect only after the STATUS
1298                          * (to the original address) gets acked.
1299                          */
1300                         if (udc->wait_for_addr_ack) {
1301                                 u32     tmp;
1302
1303                                 at91_udp_write(udc, AT91_UDP_FADDR,
1304                                                 AT91_UDP_FEN | udc->addr);
1305                                 tmp = at91_udp_read(udc, AT91_UDP_GLB_STAT);
1306                                 tmp &= ~AT91_UDP_FADDEN;
1307                                 if (udc->addr)
1308                                         tmp |= AT91_UDP_FADDEN;
1309                                 at91_udp_write(udc, AT91_UDP_GLB_STAT, tmp);
1310
1311                                 udc->wait_for_addr_ack = 0;
1312                                 VDBG("address %d\n", udc->addr);
1313                         }
1314                 }
1315         }
1316
1317         /* OUT packet arrived ... */
1318         else if (csr & AT91_UDP_RX_DATA_BK0) {
1319                 csr |= CLR_FX;
1320                 csr &= ~(SET_FX | AT91_UDP_RX_DATA_BK0);
1321
1322                 /* OUT DATA stage */
1323                 if (!ep0->is_in) {
1324                         if (req) {
1325                                 if (handle_ep(ep0)) {
1326                                         /* send IN/STATUS */
1327                                         PACKET("ep0 in/status\n");
1328                                         csr = __raw_readl(creg);
1329                                         csr &= ~SET_FX;
1330                                         csr |= CLR_FX | AT91_UDP_TXPKTRDY;
1331                                         __raw_writel(csr, creg);
1332                                         udc->req_pending = 0;
1333                                 }
1334                         } else if (udc->req_pending) {
1335                                 /*
1336                                  * AT91 hardware has a hard time with this
1337                                  * "deferred response" mode for control-OUT
1338                                  * transfers.  (For control-IN it's fine.)
1339                                  *
1340                                  * The normal solution leaves OUT data in the
1341                                  * fifo until the gadget driver is ready.
1342                                  * We couldn't do that here without disabling
1343                                  * the IRQ that tells about SETUP packets,
1344                                  * e.g. when the host gets impatient...
1345                                  *
1346                                  * Working around it by copying into a buffer
1347                                  * would almost be a non-deferred response,
1348                                  * except that it wouldn't permit reliable
1349                                  * stalling of the request.  Instead, demand
1350                                  * that gadget drivers not use this mode.
1351                                  */
1352                                 DBG("no control-OUT deferred responses!\n");
1353                                 __raw_writel(csr | AT91_UDP_FORCESTALL, creg);
1354                                 udc->req_pending = 0;
1355                         }
1356
1357                 /* STATUS stage for control-IN; ack.  */
1358                 } else {
1359                         PACKET("ep0 out/status ACK\n");
1360                         __raw_writel(csr, creg);
1361
1362                         /* "early" status stage */
1363                         if (req)
1364                                 done(ep0, req, 0);
1365                 }
1366         }
1367 }
1368
1369 static irqreturn_t at91_udc_irq (int irq, void *_udc)
1370 {
1371         struct at91_udc         *udc = _udc;
1372         u32                     rescans = 5;
1373
1374         while (rescans--) {
1375                 u32 status;
1376
1377                 status = at91_udp_read(udc, AT91_UDP_ISR)
1378                         & at91_udp_read(udc, AT91_UDP_IMR);
1379                 if (!status)
1380                         break;
1381
1382                 /* USB reset irq:  not maskable */
1383                 if (status & AT91_UDP_ENDBUSRES) {
1384                         at91_udp_write(udc, AT91_UDP_IDR, ~MINIMUS_INTERRUPTUS);
1385                         at91_udp_write(udc, AT91_UDP_IER, MINIMUS_INTERRUPTUS);
1386                         /* Atmel code clears this irq twice */
1387                         at91_udp_write(udc, AT91_UDP_ICR, AT91_UDP_ENDBUSRES);
1388                         at91_udp_write(udc, AT91_UDP_ICR, AT91_UDP_ENDBUSRES);
1389                         VDBG("end bus reset\n");
1390                         udc->addr = 0;
1391                         stop_activity(udc);
1392
1393                         /* enable ep0 */
1394                         at91_udp_write(udc, AT91_UDP_CSR(0),
1395                                         AT91_UDP_EPEDS | AT91_UDP_EPTYPE_CTRL);
1396                         udc->gadget.speed = USB_SPEED_FULL;
1397                         udc->suspended = 0;
1398                         at91_udp_write(udc, AT91_UDP_IER, AT91_UDP_EP(0));
1399
1400                         /*
1401                          * NOTE:  this driver keeps clocks off unless the
1402                          * USB host is present.  That saves power, but for
1403                          * boards that don't support VBUS detection, both
1404                          * clocks need to be active most of the time.
1405                          */
1406
1407                 /* host initiated suspend (3+ms bus idle) */
1408                 } else if (status & AT91_UDP_RXSUSP) {
1409                         at91_udp_write(udc, AT91_UDP_IDR, AT91_UDP_RXSUSP);
1410                         at91_udp_write(udc, AT91_UDP_IER, AT91_UDP_RXRSM);
1411                         at91_udp_write(udc, AT91_UDP_ICR, AT91_UDP_RXSUSP);
1412                         // VDBG("bus suspend\n");
1413                         if (udc->suspended)
1414                                 continue;
1415                         udc->suspended = 1;
1416
1417                         /*
1418                          * NOTE:  when suspending a VBUS-powered device, the
1419                          * gadget driver should switch into slow clock mode
1420                          * and then into standby to avoid drawing more than
1421                          * 500uA power (2500uA for some high-power configs).
1422                          */
1423                         if (udc->driver && udc->driver->suspend)
1424                                 udc->driver->suspend(&udc->gadget);
1425
1426                 /* host initiated resume */
1427                 } else if (status & AT91_UDP_RXRSM) {
1428                         at91_udp_write(udc, AT91_UDP_IDR, AT91_UDP_RXRSM);
1429                         at91_udp_write(udc, AT91_UDP_IER, AT91_UDP_RXSUSP);
1430                         at91_udp_write(udc, AT91_UDP_ICR, AT91_UDP_RXRSM);
1431                         // VDBG("bus resume\n");
1432                         if (!udc->suspended)
1433                                 continue;
1434                         udc->suspended = 0;
1435
1436                         /*
1437                          * NOTE:  for a VBUS-powered device, the gadget driver
1438                          * would normally want to switch out of slow clock
1439                          * mode into normal mode.
1440                          */
1441                         if (udc->driver && udc->driver->resume)
1442                                 udc->driver->resume(&udc->gadget);
1443
1444                 /* endpoint IRQs are cleared by handling them */
1445                 } else {
1446                         int             i;
1447                         unsigned        mask = 1;
1448                         struct at91_ep  *ep = &udc->ep[1];
1449
1450                         if (status & mask)
1451                                 handle_ep0(udc);
1452                         for (i = 1; i < NUM_ENDPOINTS; i++) {
1453                                 mask <<= 1;
1454                                 if (status & mask)
1455                                         handle_ep(ep);
1456                                 ep++;
1457                         }
1458                 }
1459         }
1460
1461         return IRQ_HANDLED;
1462 }
1463
1464 /*-------------------------------------------------------------------------*/
1465
1466 static void nop_release(struct device *dev)
1467 {
1468         /* nothing to free */
1469 }
1470
1471 static struct at91_udc controller = {
1472         .gadget = {
1473                 .ops    = &at91_udc_ops,
1474                 .ep0    = &controller.ep[0].ep,
1475                 .name   = driver_name,
1476                 .dev    = {
1477                         .bus_id = "gadget",
1478                         .release = nop_release,
1479                 }
1480         },
1481         .ep[0] = {
1482                 .ep = {
1483                         .name   = ep0name,
1484                         .ops    = &at91_ep_ops,
1485                 },
1486                 .udc            = &controller,
1487                 .maxpacket      = 8,
1488                 .int_mask       = 1 << 0,
1489         },
1490         .ep[1] = {
1491                 .ep = {
1492                         .name   = "ep1",
1493                         .ops    = &at91_ep_ops,
1494                 },
1495                 .udc            = &controller,
1496                 .is_pingpong    = 1,
1497                 .maxpacket      = 64,
1498                 .int_mask       = 1 << 1,
1499         },
1500         .ep[2] = {
1501                 .ep = {
1502                         .name   = "ep2",
1503                         .ops    = &at91_ep_ops,
1504                 },
1505                 .udc            = &controller,
1506                 .is_pingpong    = 1,
1507                 .maxpacket      = 64,
1508                 .int_mask       = 1 << 2,
1509         },
1510         .ep[3] = {
1511                 .ep = {
1512                         /* could actually do bulk too */
1513                         .name   = "ep3-int",
1514                         .ops    = &at91_ep_ops,
1515                 },
1516                 .udc            = &controller,
1517                 .maxpacket      = 8,
1518                 .int_mask       = 1 << 3,
1519         },
1520         .ep[4] = {
1521                 .ep = {
1522                         .name   = "ep4",
1523                         .ops    = &at91_ep_ops,
1524                 },
1525                 .udc            = &controller,
1526                 .is_pingpong    = 1,
1527                 .maxpacket      = 256,
1528                 .int_mask       = 1 << 4,
1529         },
1530         .ep[5] = {
1531                 .ep = {
1532                         .name   = "ep5",
1533                         .ops    = &at91_ep_ops,
1534                 },
1535                 .udc            = &controller,
1536                 .is_pingpong    = 1,
1537                 .maxpacket      = 256,
1538                 .int_mask       = 1 << 5,
1539         },
1540         /* ep6 and ep7 are also reserved (custom silicon might use them) */
1541 };
1542
1543 static irqreturn_t at91_vbus_irq(int irq, void *_udc)
1544 {
1545         struct at91_udc *udc = _udc;
1546         unsigned        value;
1547
1548         /* vbus needs at least brief debouncing */
1549         udelay(10);
1550         value = gpio_get_value(udc->board.vbus_pin);
1551         if (value != udc->vbus)
1552                 at91_vbus_session(&udc->gadget, value);
1553
1554         return IRQ_HANDLED;
1555 }
1556
1557 int usb_gadget_register_driver (struct usb_gadget_driver *driver)
1558 {
1559         struct at91_udc *udc = &controller;
1560         int             retval;
1561
1562         if (!driver
1563                         || driver->speed < USB_SPEED_FULL
1564                         || !driver->bind
1565                         || !driver->setup) {
1566                 DBG("bad parameter.\n");
1567                 return -EINVAL;
1568         }
1569
1570         if (udc->driver) {
1571                 DBG("UDC already has a gadget driver\n");
1572                 return -EBUSY;
1573         }
1574
1575         udc->driver = driver;
1576         udc->gadget.dev.driver = &driver->driver;
1577         udc->gadget.dev.driver_data = &driver->driver;
1578         udc->enabled = 1;
1579         udc->selfpowered = 1;
1580
1581         retval = driver->bind(&udc->gadget);
1582         if (retval) {
1583                 DBG("driver->bind() returned %d\n", retval);
1584                 udc->driver = NULL;
1585                 udc->gadget.dev.driver = NULL;
1586                 udc->gadget.dev.driver_data = NULL;
1587                 udc->enabled = 0;
1588                 udc->selfpowered = 0;
1589                 return retval;
1590         }
1591
1592         local_irq_disable();
1593         pullup(udc, 1);
1594         local_irq_enable();
1595
1596         DBG("bound to %s\n", driver->driver.name);
1597         return 0;
1598 }
1599 EXPORT_SYMBOL (usb_gadget_register_driver);
1600
1601 int usb_gadget_unregister_driver (struct usb_gadget_driver *driver)
1602 {
1603         struct at91_udc *udc = &controller;
1604
1605         if (!driver || driver != udc->driver || !driver->unbind)
1606                 return -EINVAL;
1607
1608         local_irq_disable();
1609         udc->enabled = 0;
1610         at91_udp_write(udc, AT91_UDP_IDR, ~0);
1611         pullup(udc, 0);
1612         local_irq_enable();
1613
1614         driver->unbind(&udc->gadget);
1615         udc->gadget.dev.driver = NULL;
1616         udc->gadget.dev.driver_data = NULL;
1617         udc->driver = NULL;
1618
1619         DBG("unbound from %s\n", driver->driver.name);
1620         return 0;
1621 }
1622 EXPORT_SYMBOL (usb_gadget_unregister_driver);
1623
1624 /*-------------------------------------------------------------------------*/
1625
1626 static void at91udc_shutdown(struct platform_device *dev)
1627 {
1628         /* force disconnect on reboot */
1629         pullup(platform_get_drvdata(dev), 0);
1630 }
1631
1632 static int __init at91udc_probe(struct platform_device *pdev)
1633 {
1634         struct device   *dev = &pdev->dev;
1635         struct at91_udc *udc;
1636         int             retval;
1637         struct resource *res;
1638
1639         if (!dev->platform_data) {
1640                 /* small (so we copy it) but critical! */
1641                 DBG("missing platform_data\n");
1642                 return -ENODEV;
1643         }
1644
1645         if (pdev->num_resources != 2) {
1646                 DBG("invalid num_resources\n");
1647                 return -ENODEV;
1648         }
1649         if ((pdev->resource[0].flags != IORESOURCE_MEM)
1650                         || (pdev->resource[1].flags != IORESOURCE_IRQ)) {
1651                 DBG("invalid resource type\n");
1652                 return -ENODEV;
1653         }
1654
1655         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1656         if (!res)
1657                 return -ENXIO;
1658
1659         if (!request_mem_region(res->start,
1660                         res->end - res->start + 1,
1661                         driver_name)) {
1662                 DBG("someone's using UDC memory\n");
1663                 return -EBUSY;
1664         }
1665
1666         /* init software state */
1667         udc = &controller;
1668         udc->gadget.dev.parent = dev;
1669         udc->board = *(struct at91_udc_data *) dev->platform_data;
1670         udc->pdev = pdev;
1671         udc->enabled = 0;
1672
1673         /* rm9200 needs manual D+ pullup; off by default */
1674         if (cpu_is_at91rm9200()) {
1675                 if (udc->board.pullup_pin <= 0) {
1676                         DBG("no D+ pullup?\n");
1677                         retval = -ENODEV;
1678                         goto fail0;
1679                 }
1680                 retval = gpio_request(udc->board.pullup_pin, "udc_pullup");
1681                 if (retval) {
1682                         DBG("D+ pullup is busy\n");
1683                         goto fail0;
1684                 }
1685                 gpio_direction_output(udc->board.pullup_pin,
1686                                 udc->board.pullup_active_low);
1687         }
1688
1689         /* newer chips have more FIFO memory than rm9200 */
1690         if (cpu_is_at91sam9260()) {
1691                 udc->ep[0].maxpacket = 64;
1692                 udc->ep[3].maxpacket = 64;
1693                 udc->ep[4].maxpacket = 512;
1694                 udc->ep[5].maxpacket = 512;
1695         } else if (cpu_is_at91sam9261()) {
1696                 udc->ep[3].maxpacket = 64;
1697         } else if (cpu_is_at91sam9263()) {
1698                 udc->ep[0].maxpacket = 64;
1699                 udc->ep[3].maxpacket = 64;
1700         }
1701
1702         udc->udp_baseaddr = ioremap(res->start, res->end - res->start + 1);
1703         if (!udc->udp_baseaddr) {
1704                 retval = -ENOMEM;
1705                 goto fail0a;
1706         }
1707
1708         udc_reinit(udc);
1709
1710         /* get interface and function clocks */
1711         udc->iclk = clk_get(dev, "udc_clk");
1712         udc->fclk = clk_get(dev, "udpck");
1713         if (IS_ERR(udc->iclk) || IS_ERR(udc->fclk)) {
1714                 DBG("clocks missing\n");
1715                 retval = -ENODEV;
1716                 /* NOTE: we "know" here that refcounts on these are NOPs */
1717                 goto fail0b;
1718         }
1719
1720         retval = device_register(&udc->gadget.dev);
1721         if (retval < 0)
1722                 goto fail0b;
1723
1724         /* don't do anything until we have both gadget driver and VBUS */
1725         clk_enable(udc->iclk);
1726         at91_udp_write(udc, AT91_UDP_TXVC, AT91_UDP_TXVC_TXVDIS);
1727         at91_udp_write(udc, AT91_UDP_IDR, 0xffffffff);
1728         /* Clear all pending interrupts - UDP may be used by bootloader. */
1729         at91_udp_write(udc, AT91_UDP_ICR, 0xffffffff);
1730         clk_disable(udc->iclk);
1731
1732         /* request UDC and maybe VBUS irqs */
1733         udc->udp_irq = platform_get_irq(pdev, 0);
1734         retval = request_irq(udc->udp_irq, at91_udc_irq,
1735                         IRQF_DISABLED, driver_name, udc);
1736         if (retval < 0) {
1737                 DBG("request irq %d failed\n", udc->udp_irq);
1738                 goto fail1;
1739         }
1740         if (udc->board.vbus_pin > 0) {
1741                 retval = gpio_request(udc->board.vbus_pin, "udc_vbus");
1742                 if (retval < 0) {
1743                         DBG("request vbus pin failed\n");
1744                         goto fail2;
1745                 }
1746                 gpio_direction_input(udc->board.vbus_pin);
1747
1748                 /*
1749                  * Get the initial state of VBUS - we cannot expect
1750                  * a pending interrupt.
1751                  */
1752                 udc->vbus = gpio_get_value(udc->board.vbus_pin);
1753                 if (request_irq(udc->board.vbus_pin, at91_vbus_irq,
1754                                 IRQF_DISABLED, driver_name, udc)) {
1755                         DBG("request vbus irq %d failed\n",
1756                                         udc->board.vbus_pin);
1757                         free_irq(udc->udp_irq, udc);
1758                         retval = -EBUSY;
1759                         goto fail3;
1760                 }
1761         } else {
1762                 DBG("no VBUS detection, assuming always-on\n");
1763                 udc->vbus = 1;
1764         }
1765         dev_set_drvdata(dev, udc);
1766         device_init_wakeup(dev, 1);
1767         create_debug_file(udc);
1768
1769         INFO("%s version %s\n", driver_name, DRIVER_VERSION);
1770         return 0;
1771
1772 fail3:
1773         if (udc->board.vbus_pin > 0)
1774                 gpio_free(udc->board.vbus_pin);
1775 fail2:
1776         free_irq(udc->udp_irq, udc);
1777 fail1:
1778         device_unregister(&udc->gadget.dev);
1779 fail0b:
1780         iounmap(udc->udp_baseaddr);
1781 fail0a:
1782         if (cpu_is_at91rm9200())
1783                 gpio_free(udc->board.pullup_pin);
1784 fail0:
1785         release_mem_region(res->start, res->end - res->start + 1);
1786         DBG("%s probe failed, %d\n", driver_name, retval);
1787         return retval;
1788 }
1789
1790 static int __exit at91udc_remove(struct platform_device *pdev)
1791 {
1792         struct at91_udc *udc = platform_get_drvdata(pdev);
1793         struct resource *res;
1794
1795         DBG("remove\n");
1796
1797         if (udc->driver)
1798                 return -EBUSY;
1799
1800         pullup(udc, 0);
1801
1802         device_init_wakeup(&pdev->dev, 0);
1803         remove_debug_file(udc);
1804         if (udc->board.vbus_pin > 0) {
1805                 free_irq(udc->board.vbus_pin, udc);
1806                 gpio_free(udc->board.vbus_pin);
1807         }
1808         free_irq(udc->udp_irq, udc);
1809         device_unregister(&udc->gadget.dev);
1810
1811         iounmap(udc->udp_baseaddr);
1812
1813         if (cpu_is_at91rm9200())
1814                 gpio_free(udc->board.pullup_pin);
1815
1816         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1817         release_mem_region(res->start, res->end - res->start + 1);
1818
1819         clk_put(udc->iclk);
1820         clk_put(udc->fclk);
1821
1822         return 0;
1823 }
1824
1825 #ifdef CONFIG_PM
1826 static int at91udc_suspend(struct platform_device *pdev, pm_message_t mesg)
1827 {
1828         struct at91_udc *udc = platform_get_drvdata(pdev);
1829         int             wake = udc->driver && device_may_wakeup(&pdev->dev);
1830
1831         /* Unless we can act normally to the host (letting it wake us up
1832          * whenever it has work for us) force disconnect.  Wakeup requires
1833          * PLLB for USB events (signaling for reset, wakeup, or incoming
1834          * tokens) and VBUS irqs (on systems which support them).
1835          */
1836         if ((!udc->suspended && udc->addr)
1837                         || !wake
1838                         || at91_suspend_entering_slow_clock()) {
1839                 pullup(udc, 0);
1840                 wake = 0;
1841         } else
1842                 enable_irq_wake(udc->udp_irq);
1843
1844         udc->active_suspend = wake;
1845         if (udc->board.vbus_pin > 0 && wake)
1846                 enable_irq_wake(udc->board.vbus_pin);
1847         return 0;
1848 }
1849
1850 static int at91udc_resume(struct platform_device *pdev)
1851 {
1852         struct at91_udc *udc = platform_get_drvdata(pdev);
1853
1854         if (udc->board.vbus_pin > 0 && udc->active_suspend)
1855                 disable_irq_wake(udc->board.vbus_pin);
1856
1857         /* maybe reconnect to host; if so, clocks on */
1858         if (udc->active_suspend)
1859                 disable_irq_wake(udc->udp_irq);
1860         else
1861                 pullup(udc, 1);
1862         return 0;
1863 }
1864 #else
1865 #define at91udc_suspend NULL
1866 #define at91udc_resume  NULL
1867 #endif
1868
1869 static struct platform_driver at91_udc_driver = {
1870         .remove         = __exit_p(at91udc_remove),
1871         .shutdown       = at91udc_shutdown,
1872         .suspend        = at91udc_suspend,
1873         .resume         = at91udc_resume,
1874         .driver         = {
1875                 .name   = (char *) driver_name,
1876                 .owner  = THIS_MODULE,
1877         },
1878 };
1879
1880 static int __init udc_init_module(void)
1881 {
1882         return platform_driver_probe(&at91_udc_driver, at91udc_probe);
1883 }
1884 module_init(udc_init_module);
1885
1886 static void __exit udc_exit_module(void)
1887 {
1888         platform_driver_unregister(&at91_udc_driver);
1889 }
1890 module_exit(udc_exit_module);
1891
1892 MODULE_DESCRIPTION("AT91 udc driver");
1893 MODULE_AUTHOR("Thomas Rathbone, David Brownell");
1894 MODULE_LICENSE("GPL");
1895 MODULE_ALIAS("platform:at91_udc");