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