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