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