Merge branches 'arm/rockchip', 'arm/exynos', 'arm/smmu', 'x86/vt-d', 'x86/amd', ...
[sfrench/cifs-2.6.git] / drivers / usb / gadget / udc / 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/list.h>
25 #include <linux/interrupt.h>
26 #include <linux/proc_fs.h>
27 #include <linux/prefetch.h>
28 #include <linux/clk.h>
29 #include <linux/usb/ch9.h>
30 #include <linux/usb/gadget.h>
31 #include <linux/of.h>
32 #include <linux/of_gpio.h>
33 #include <linux/platform_data/atmel.h>
34 #include <linux/regmap.h>
35 #include <linux/mfd/syscon.h>
36 #include <linux/mfd/syscon/atmel-matrix.h>
37
38 #include "at91_udc.h"
39
40
41 /*
42  * This controller is simple and PIO-only.  It's used in many AT91-series
43  * full speed USB controllers, including the at91rm9200 (arm920T, with MMU),
44  * at91sam926x (arm926ejs, with MMU), and several no-mmu versions.
45  *
46  * This driver expects the board has been wired with two GPIOs supporting
47  * a VBUS sensing IRQ, and a D+ pullup.  (They may be omitted, but the
48  * testing hasn't covered such cases.)
49  *
50  * The pullup is most important (so it's integrated on sam926x parts).  It
51  * provides software control over whether the host enumerates the device.
52  *
53  * The VBUS sensing helps during enumeration, and allows both USB clocks
54  * (and the transceiver) to stay gated off until they're necessary, saving
55  * power.  During USB suspend, the 48 MHz clock is gated off in hardware;
56  * it may also be gated off by software during some Linux sleep states.
57  */
58
59 #define DRIVER_VERSION  "3 May 2006"
60
61 static const char driver_name [] = "at91_udc";
62 static const char * const ep_names[] = {
63         "ep0",
64         "ep1",
65         "ep2",
66         "ep3-int",
67         "ep4",
68         "ep5",
69 };
70 #define ep0name         ep_names[0]
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->gadget.is_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->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_DATA(inode));
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         usb_gadget_giveback_request(&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;
473         u16             maxpacket;
474         u32             tmp;
475         unsigned long   flags;
476
477         if (!_ep || !ep
478                         || !desc || _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         udc = ep->udc;
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->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->ep.desc = NULL;
561         ep->ep.maxpacket = ep->maxpacket;
562
563         /* reset fifos and endpoint */
564         if (ep->udc->clocked) {
565                 at91_udp_write(udc, AT91_UDP_RST_EP, ep->int_mask);
566                 at91_udp_write(udc, AT91_UDP_RST_EP, 0);
567                 __raw_writel(0, ep->creg);
568         }
569
570         spin_unlock_irqrestore(&udc->lock, flags);
571         return 0;
572 }
573
574 /*
575  * this is a PIO-only driver, so there's nothing
576  * interesting for request or buffer allocation.
577  */
578
579 static struct usb_request *
580 at91_ep_alloc_request(struct usb_ep *_ep, gfp_t gfp_flags)
581 {
582         struct at91_request *req;
583
584         req = kzalloc(sizeof (struct at91_request), gfp_flags);
585         if (!req)
586                 return NULL;
587
588         INIT_LIST_HEAD(&req->queue);
589         return &req->req;
590 }
591
592 static void at91_ep_free_request(struct usb_ep *_ep, struct usb_request *_req)
593 {
594         struct at91_request *req;
595
596         req = container_of(_req, struct at91_request, req);
597         BUG_ON(!list_empty(&req->queue));
598         kfree(req);
599 }
600
601 static int at91_ep_queue(struct usb_ep *_ep,
602                         struct usb_request *_req, gfp_t gfp_flags)
603 {
604         struct at91_request     *req;
605         struct at91_ep          *ep;
606         struct at91_udc         *udc;
607         int                     status;
608         unsigned long           flags;
609
610         req = container_of(_req, struct at91_request, req);
611         ep = container_of(_ep, struct at91_ep, ep);
612
613         if (!_req || !_req->complete
614                         || !_req->buf || !list_empty(&req->queue)) {
615                 DBG("invalid request\n");
616                 return -EINVAL;
617         }
618
619         if (!_ep || (!ep->ep.desc && ep->ep.name != ep0name)) {
620                 DBG("invalid ep\n");
621                 return -EINVAL;
622         }
623
624         udc = ep->udc;
625
626         if (!udc || !udc->driver || udc->gadget.speed == USB_SPEED_UNKNOWN) {
627                 DBG("invalid device\n");
628                 return -EINVAL;
629         }
630
631         _req->status = -EINPROGRESS;
632         _req->actual = 0;
633
634         spin_lock_irqsave(&udc->lock, flags);
635
636         /* try to kickstart any empty and idle queue */
637         if (list_empty(&ep->queue) && !ep->stopped) {
638                 int     is_ep0;
639
640                 /*
641                  * If this control request has a non-empty DATA stage, this
642                  * will start that stage.  It works just like a non-control
643                  * request (until the status stage starts, maybe early).
644                  *
645                  * If the data stage is empty, then this starts a successful
646                  * IN/STATUS stage.  (Unsuccessful ones use set_halt.)
647                  */
648                 is_ep0 = (ep->ep.name == ep0name);
649                 if (is_ep0) {
650                         u32     tmp;
651
652                         if (!udc->req_pending) {
653                                 status = -EINVAL;
654                                 goto done;
655                         }
656
657                         /*
658                          * defer changing CONFG until after the gadget driver
659                          * reconfigures the endpoints.
660                          */
661                         if (udc->wait_for_config_ack) {
662                                 tmp = at91_udp_read(udc, AT91_UDP_GLB_STAT);
663                                 tmp ^= AT91_UDP_CONFG;
664                                 VDBG("toggle config\n");
665                                 at91_udp_write(udc, AT91_UDP_GLB_STAT, tmp);
666                         }
667                         if (req->req.length == 0) {
668 ep0_in_status:
669                                 PACKET("ep0 in/status\n");
670                                 status = 0;
671                                 tmp = __raw_readl(ep->creg);
672                                 tmp &= ~SET_FX;
673                                 tmp |= CLR_FX | AT91_UDP_TXPKTRDY;
674                                 __raw_writel(tmp, ep->creg);
675                                 udc->req_pending = 0;
676                                 goto done;
677                         }
678                 }
679
680                 if (ep->is_in)
681                         status = write_fifo(ep, req);
682                 else {
683                         status = read_fifo(ep, req);
684
685                         /* IN/STATUS stage is otherwise triggered by irq */
686                         if (status && is_ep0)
687                                 goto ep0_in_status;
688                 }
689         } else
690                 status = 0;
691
692         if (req && !status) {
693                 list_add_tail (&req->queue, &ep->queue);
694                 at91_udp_write(udc, AT91_UDP_IER, ep->int_mask);
695         }
696 done:
697         spin_unlock_irqrestore(&udc->lock, flags);
698         return (status < 0) ? status : 0;
699 }
700
701 static int at91_ep_dequeue(struct usb_ep *_ep, struct usb_request *_req)
702 {
703         struct at91_ep          *ep;
704         struct at91_request     *req;
705         unsigned long           flags;
706         struct at91_udc         *udc;
707
708         ep = container_of(_ep, struct at91_ep, ep);
709         if (!_ep || ep->ep.name == ep0name)
710                 return -EINVAL;
711
712         udc = ep->udc;
713
714         spin_lock_irqsave(&udc->lock, flags);
715
716         /* make sure it's actually queued on this endpoint */
717         list_for_each_entry (req, &ep->queue, queue) {
718                 if (&req->req == _req)
719                         break;
720         }
721         if (&req->req != _req) {
722                 spin_unlock_irqrestore(&udc->lock, flags);
723                 return -EINVAL;
724         }
725
726         done(ep, req, -ECONNRESET);
727         spin_unlock_irqrestore(&udc->lock, flags);
728         return 0;
729 }
730
731 static int at91_ep_set_halt(struct usb_ep *_ep, int value)
732 {
733         struct at91_ep  *ep = container_of(_ep, struct at91_ep, ep);
734         struct at91_udc *udc = ep->udc;
735         u32 __iomem     *creg;
736         u32             csr;
737         unsigned long   flags;
738         int             status = 0;
739
740         if (!_ep || ep->is_iso || !ep->udc->clocked)
741                 return -EINVAL;
742
743         creg = ep->creg;
744         spin_lock_irqsave(&udc->lock, flags);
745
746         csr = __raw_readl(creg);
747
748         /*
749          * fail with still-busy IN endpoints, ensuring correct sequencing
750          * of data tx then stall.  note that the fifo rx bytecount isn't
751          * completely accurate as a tx bytecount.
752          */
753         if (ep->is_in && (!list_empty(&ep->queue) || (csr >> 16) != 0))
754                 status = -EAGAIN;
755         else {
756                 csr |= CLR_FX;
757                 csr &= ~SET_FX;
758                 if (value) {
759                         csr |= AT91_UDP_FORCESTALL;
760                         VDBG("halt %s\n", ep->ep.name);
761                 } else {
762                         at91_udp_write(udc, AT91_UDP_RST_EP, ep->int_mask);
763                         at91_udp_write(udc, AT91_UDP_RST_EP, 0);
764                         csr &= ~AT91_UDP_FORCESTALL;
765                 }
766                 __raw_writel(csr, creg);
767         }
768
769         spin_unlock_irqrestore(&udc->lock, flags);
770         return status;
771 }
772
773 static const struct usb_ep_ops at91_ep_ops = {
774         .enable         = at91_ep_enable,
775         .disable        = at91_ep_disable,
776         .alloc_request  = at91_ep_alloc_request,
777         .free_request   = at91_ep_free_request,
778         .queue          = at91_ep_queue,
779         .dequeue        = at91_ep_dequeue,
780         .set_halt       = at91_ep_set_halt,
781         /* there's only imprecise fifo status reporting */
782 };
783
784 /*-------------------------------------------------------------------------*/
785
786 static int at91_get_frame(struct usb_gadget *gadget)
787 {
788         struct at91_udc *udc = to_udc(gadget);
789
790         if (!to_udc(gadget)->clocked)
791                 return -EINVAL;
792         return at91_udp_read(udc, AT91_UDP_FRM_NUM) & AT91_UDP_NUM;
793 }
794
795 static int at91_wakeup(struct usb_gadget *gadget)
796 {
797         struct at91_udc *udc = to_udc(gadget);
798         u32             glbstate;
799         int             status = -EINVAL;
800         unsigned long   flags;
801
802         DBG("%s\n", __func__ );
803         spin_lock_irqsave(&udc->lock, flags);
804
805         if (!udc->clocked || !udc->suspended)
806                 goto done;
807
808         /* NOTE:  some "early versions" handle ESR differently ... */
809
810         glbstate = at91_udp_read(udc, AT91_UDP_GLB_STAT);
811         if (!(glbstate & AT91_UDP_ESR))
812                 goto done;
813         glbstate |= AT91_UDP_ESR;
814         at91_udp_write(udc, AT91_UDP_GLB_STAT, glbstate);
815
816 done:
817         spin_unlock_irqrestore(&udc->lock, flags);
818         return status;
819 }
820
821 /* reinit == restore initial software state */
822 static void udc_reinit(struct at91_udc *udc)
823 {
824         u32 i;
825
826         INIT_LIST_HEAD(&udc->gadget.ep_list);
827         INIT_LIST_HEAD(&udc->gadget.ep0->ep_list);
828
829         for (i = 0; i < NUM_ENDPOINTS; i++) {
830                 struct at91_ep *ep = &udc->ep[i];
831
832                 if (i != 0)
833                         list_add_tail(&ep->ep.ep_list, &udc->gadget.ep_list);
834                 ep->ep.desc = NULL;
835                 ep->stopped = 0;
836                 ep->fifo_bank = 0;
837                 usb_ep_set_maxpacket_limit(&ep->ep, ep->maxpacket);
838                 ep->creg = (void __iomem *) udc->udp_baseaddr + AT91_UDP_CSR(i);
839                 /* initialize one queue per endpoint */
840                 INIT_LIST_HEAD(&ep->queue);
841         }
842 }
843
844 static void reset_gadget(struct at91_udc *udc)
845 {
846         struct usb_gadget_driver *driver = udc->driver;
847         int i;
848
849         if (udc->gadget.speed == USB_SPEED_UNKNOWN)
850                 driver = NULL;
851         udc->gadget.speed = USB_SPEED_UNKNOWN;
852         udc->suspended = 0;
853
854         for (i = 0; i < NUM_ENDPOINTS; i++) {
855                 struct at91_ep *ep = &udc->ep[i];
856
857                 ep->stopped = 1;
858                 nuke(ep, -ESHUTDOWN);
859         }
860         if (driver) {
861                 spin_unlock(&udc->lock);
862                 usb_gadget_udc_reset(&udc->gadget, driver);
863                 spin_lock(&udc->lock);
864         }
865
866         udc_reinit(udc);
867 }
868
869 static void stop_activity(struct at91_udc *udc)
870 {
871         struct usb_gadget_driver *driver = udc->driver;
872         int i;
873
874         if (udc->gadget.speed == USB_SPEED_UNKNOWN)
875                 driver = NULL;
876         udc->gadget.speed = USB_SPEED_UNKNOWN;
877         udc->suspended = 0;
878
879         for (i = 0; i < NUM_ENDPOINTS; i++) {
880                 struct at91_ep *ep = &udc->ep[i];
881                 ep->stopped = 1;
882                 nuke(ep, -ESHUTDOWN);
883         }
884         if (driver) {
885                 spin_unlock(&udc->lock);
886                 driver->disconnect(&udc->gadget);
887                 spin_lock(&udc->lock);
888         }
889
890         udc_reinit(udc);
891 }
892
893 static void clk_on(struct at91_udc *udc)
894 {
895         if (udc->clocked)
896                 return;
897         udc->clocked = 1;
898
899         clk_enable(udc->iclk);
900         clk_enable(udc->fclk);
901 }
902
903 static void clk_off(struct at91_udc *udc)
904 {
905         if (!udc->clocked)
906                 return;
907         udc->clocked = 0;
908         udc->gadget.speed = USB_SPEED_UNKNOWN;
909         clk_disable(udc->fclk);
910         clk_disable(udc->iclk);
911 }
912
913 /*
914  * activate/deactivate link with host; minimize power usage for
915  * inactive links by cutting clocks and transceiver power.
916  */
917 static void pullup(struct at91_udc *udc, int is_on)
918 {
919         if (!udc->enabled || !udc->vbus)
920                 is_on = 0;
921         DBG("%sactive\n", is_on ? "" : "in");
922
923         if (is_on) {
924                 clk_on(udc);
925                 at91_udp_write(udc, AT91_UDP_ICR, AT91_UDP_RXRSM);
926                 at91_udp_write(udc, AT91_UDP_TXVC, 0);
927         } else {
928                 stop_activity(udc);
929                 at91_udp_write(udc, AT91_UDP_IDR, AT91_UDP_RXRSM);
930                 at91_udp_write(udc, AT91_UDP_TXVC, AT91_UDP_TXVC_TXVDIS);
931                 clk_off(udc);
932         }
933
934         if (udc->caps && udc->caps->pullup)
935                 udc->caps->pullup(udc, is_on);
936 }
937
938 /* vbus is here!  turn everything on that's ready */
939 static int at91_vbus_session(struct usb_gadget *gadget, int is_active)
940 {
941         struct at91_udc *udc = to_udc(gadget);
942         unsigned long   flags;
943
944         /* VDBG("vbus %s\n", is_active ? "on" : "off"); */
945         spin_lock_irqsave(&udc->lock, flags);
946         udc->vbus = (is_active != 0);
947         if (udc->driver)
948                 pullup(udc, is_active);
949         else
950                 pullup(udc, 0);
951         spin_unlock_irqrestore(&udc->lock, flags);
952         return 0;
953 }
954
955 static int at91_pullup(struct usb_gadget *gadget, int is_on)
956 {
957         struct at91_udc *udc = to_udc(gadget);
958         unsigned long   flags;
959
960         spin_lock_irqsave(&udc->lock, flags);
961         udc->enabled = is_on = !!is_on;
962         pullup(udc, is_on);
963         spin_unlock_irqrestore(&udc->lock, flags);
964         return 0;
965 }
966
967 static int at91_set_selfpowered(struct usb_gadget *gadget, int is_on)
968 {
969         struct at91_udc *udc = to_udc(gadget);
970         unsigned long   flags;
971
972         spin_lock_irqsave(&udc->lock, flags);
973         gadget->is_selfpowered = (is_on != 0);
974         spin_unlock_irqrestore(&udc->lock, flags);
975         return 0;
976 }
977
978 static int at91_start(struct usb_gadget *gadget,
979                 struct usb_gadget_driver *driver);
980 static int at91_stop(struct usb_gadget *gadget);
981
982 static const struct usb_gadget_ops at91_udc_ops = {
983         .get_frame              = at91_get_frame,
984         .wakeup                 = at91_wakeup,
985         .set_selfpowered        = at91_set_selfpowered,
986         .vbus_session           = at91_vbus_session,
987         .pullup                 = at91_pullup,
988         .udc_start              = at91_start,
989         .udc_stop               = at91_stop,
990
991         /*
992          * VBUS-powered devices may also also want to support bigger
993          * power budgets after an appropriate SET_CONFIGURATION.
994          */
995         /* .vbus_power          = at91_vbus_power, */
996 };
997
998 /*-------------------------------------------------------------------------*/
999
1000 static int handle_ep(struct at91_ep *ep)
1001 {
1002         struct at91_request     *req;
1003         u32 __iomem             *creg = ep->creg;
1004         u32                     csr = __raw_readl(creg);
1005
1006         if (!list_empty(&ep->queue))
1007                 req = list_entry(ep->queue.next,
1008                         struct at91_request, queue);
1009         else
1010                 req = NULL;
1011
1012         if (ep->is_in) {
1013                 if (csr & (AT91_UDP_STALLSENT | AT91_UDP_TXCOMP)) {
1014                         csr |= CLR_FX;
1015                         csr &= ~(SET_FX | AT91_UDP_STALLSENT | AT91_UDP_TXCOMP);
1016                         __raw_writel(csr, creg);
1017                 }
1018                 if (req)
1019                         return write_fifo(ep, req);
1020
1021         } else {
1022                 if (csr & AT91_UDP_STALLSENT) {
1023                         /* STALLSENT bit == ISOERR */
1024                         if (ep->is_iso && req)
1025                                 req->req.status = -EILSEQ;
1026                         csr |= CLR_FX;
1027                         csr &= ~(SET_FX | AT91_UDP_STALLSENT);
1028                         __raw_writel(csr, creg);
1029                         csr = __raw_readl(creg);
1030                 }
1031                 if (req && (csr & RX_DATA_READY))
1032                         return read_fifo(ep, req);
1033         }
1034         return 0;
1035 }
1036
1037 union setup {
1038         u8                      raw[8];
1039         struct usb_ctrlrequest  r;
1040 };
1041
1042 static void handle_setup(struct at91_udc *udc, struct at91_ep *ep, u32 csr)
1043 {
1044         u32 __iomem     *creg = ep->creg;
1045         u8 __iomem      *dreg = ep->creg + (AT91_UDP_FDR(0) - AT91_UDP_CSR(0));
1046         unsigned        rxcount, i = 0;
1047         u32             tmp;
1048         union setup     pkt;
1049         int             status = 0;
1050
1051         /* read and ack SETUP; hard-fail for bogus packets */
1052         rxcount = (csr & AT91_UDP_RXBYTECNT) >> 16;
1053         if (likely(rxcount == 8)) {
1054                 while (rxcount--)
1055                         pkt.raw[i++] = __raw_readb(dreg);
1056                 if (pkt.r.bRequestType & USB_DIR_IN) {
1057                         csr |= AT91_UDP_DIR;
1058                         ep->is_in = 1;
1059                 } else {
1060                         csr &= ~AT91_UDP_DIR;
1061                         ep->is_in = 0;
1062                 }
1063         } else {
1064                 /* REVISIT this happens sometimes under load; why?? */
1065                 ERR("SETUP len %d, csr %08x\n", rxcount, csr);
1066                 status = -EINVAL;
1067         }
1068         csr |= CLR_FX;
1069         csr &= ~(SET_FX | AT91_UDP_RXSETUP);
1070         __raw_writel(csr, creg);
1071         udc->wait_for_addr_ack = 0;
1072         udc->wait_for_config_ack = 0;
1073         ep->stopped = 0;
1074         if (unlikely(status != 0))
1075                 goto stall;
1076
1077 #define w_index         le16_to_cpu(pkt.r.wIndex)
1078 #define w_value         le16_to_cpu(pkt.r.wValue)
1079 #define w_length        le16_to_cpu(pkt.r.wLength)
1080
1081         VDBG("SETUP %02x.%02x v%04x i%04x l%04x\n",
1082                         pkt.r.bRequestType, pkt.r.bRequest,
1083                         w_value, w_index, w_length);
1084
1085         /*
1086          * A few standard requests get handled here, ones that touch
1087          * hardware ... notably for device and endpoint features.
1088          */
1089         udc->req_pending = 1;
1090         csr = __raw_readl(creg);
1091         csr |= CLR_FX;
1092         csr &= ~SET_FX;
1093         switch ((pkt.r.bRequestType << 8) | pkt.r.bRequest) {
1094
1095         case ((USB_TYPE_STANDARD|USB_RECIP_DEVICE) << 8)
1096                         | USB_REQ_SET_ADDRESS:
1097                 __raw_writel(csr | AT91_UDP_TXPKTRDY, creg);
1098                 udc->addr = w_value;
1099                 udc->wait_for_addr_ack = 1;
1100                 udc->req_pending = 0;
1101                 /* FADDR is set later, when we ack host STATUS */
1102                 return;
1103
1104         case ((USB_TYPE_STANDARD|USB_RECIP_DEVICE) << 8)
1105                         | USB_REQ_SET_CONFIGURATION:
1106                 tmp = at91_udp_read(udc, AT91_UDP_GLB_STAT) & AT91_UDP_CONFG;
1107                 if (pkt.r.wValue)
1108                         udc->wait_for_config_ack = (tmp == 0);
1109                 else
1110                         udc->wait_for_config_ack = (tmp != 0);
1111                 if (udc->wait_for_config_ack)
1112                         VDBG("wait for config\n");
1113                 /* CONFG is toggled later, if gadget driver succeeds */
1114                 break;
1115
1116         /*
1117          * Hosts may set or clear remote wakeup status, and
1118          * devices may report they're VBUS powered.
1119          */
1120         case ((USB_DIR_IN|USB_TYPE_STANDARD|USB_RECIP_DEVICE) << 8)
1121                         | USB_REQ_GET_STATUS:
1122                 tmp = (udc->gadget.is_selfpowered << USB_DEVICE_SELF_POWERED);
1123                 if (at91_udp_read(udc, AT91_UDP_GLB_STAT) & AT91_UDP_ESR)
1124                         tmp |= (1 << USB_DEVICE_REMOTE_WAKEUP);
1125                 PACKET("get device status\n");
1126                 __raw_writeb(tmp, dreg);
1127                 __raw_writeb(0, dreg);
1128                 goto write_in;
1129                 /* then STATUS starts later, automatically */
1130         case ((USB_TYPE_STANDARD|USB_RECIP_DEVICE) << 8)
1131                         | USB_REQ_SET_FEATURE:
1132                 if (w_value != USB_DEVICE_REMOTE_WAKEUP)
1133                         goto stall;
1134                 tmp = at91_udp_read(udc, AT91_UDP_GLB_STAT);
1135                 tmp |= AT91_UDP_ESR;
1136                 at91_udp_write(udc, AT91_UDP_GLB_STAT, tmp);
1137                 goto succeed;
1138         case ((USB_TYPE_STANDARD|USB_RECIP_DEVICE) << 8)
1139                         | USB_REQ_CLEAR_FEATURE:
1140                 if (w_value != USB_DEVICE_REMOTE_WAKEUP)
1141                         goto stall;
1142                 tmp = at91_udp_read(udc, AT91_UDP_GLB_STAT);
1143                 tmp &= ~AT91_UDP_ESR;
1144                 at91_udp_write(udc, AT91_UDP_GLB_STAT, tmp);
1145                 goto succeed;
1146
1147         /*
1148          * Interfaces have no feature settings; this is pretty useless.
1149          * we won't even insist the interface exists...
1150          */
1151         case ((USB_DIR_IN|USB_TYPE_STANDARD|USB_RECIP_INTERFACE) << 8)
1152                         | USB_REQ_GET_STATUS:
1153                 PACKET("get interface status\n");
1154                 __raw_writeb(0, dreg);
1155                 __raw_writeb(0, dreg);
1156                 goto write_in;
1157                 /* then STATUS starts later, automatically */
1158         case ((USB_TYPE_STANDARD|USB_RECIP_INTERFACE) << 8)
1159                         | USB_REQ_SET_FEATURE:
1160         case ((USB_TYPE_STANDARD|USB_RECIP_INTERFACE) << 8)
1161                         | USB_REQ_CLEAR_FEATURE:
1162                 goto stall;
1163
1164         /*
1165          * Hosts may clear bulk/intr endpoint halt after the gadget
1166          * driver sets it (not widely used); or set it (for testing)
1167          */
1168         case ((USB_DIR_IN|USB_TYPE_STANDARD|USB_RECIP_ENDPOINT) << 8)
1169                         | USB_REQ_GET_STATUS:
1170                 tmp = w_index & USB_ENDPOINT_NUMBER_MASK;
1171                 ep = &udc->ep[tmp];
1172                 if (tmp >= NUM_ENDPOINTS || (tmp && !ep->ep.desc))
1173                         goto stall;
1174
1175                 if (tmp) {
1176                         if ((w_index & USB_DIR_IN)) {
1177                                 if (!ep->is_in)
1178                                         goto stall;
1179                         } else if (ep->is_in)
1180                                 goto stall;
1181                 }
1182                 PACKET("get %s status\n", ep->ep.name);
1183                 if (__raw_readl(ep->creg) & AT91_UDP_FORCESTALL)
1184                         tmp = (1 << USB_ENDPOINT_HALT);
1185                 else
1186                         tmp = 0;
1187                 __raw_writeb(tmp, dreg);
1188                 __raw_writeb(0, dreg);
1189                 goto write_in;
1190                 /* then STATUS starts later, automatically */
1191         case ((USB_TYPE_STANDARD|USB_RECIP_ENDPOINT) << 8)
1192                         | USB_REQ_SET_FEATURE:
1193                 tmp = w_index & USB_ENDPOINT_NUMBER_MASK;
1194                 ep = &udc->ep[tmp];
1195                 if (w_value != USB_ENDPOINT_HALT || tmp >= NUM_ENDPOINTS)
1196                         goto stall;
1197                 if (!ep->ep.desc || ep->is_iso)
1198                         goto stall;
1199                 if ((w_index & USB_DIR_IN)) {
1200                         if (!ep->is_in)
1201                                 goto stall;
1202                 } else if (ep->is_in)
1203                         goto stall;
1204
1205                 tmp = __raw_readl(ep->creg);
1206                 tmp &= ~SET_FX;
1207                 tmp |= CLR_FX | AT91_UDP_FORCESTALL;
1208                 __raw_writel(tmp, ep->creg);
1209                 goto succeed;
1210         case ((USB_TYPE_STANDARD|USB_RECIP_ENDPOINT) << 8)
1211                         | USB_REQ_CLEAR_FEATURE:
1212                 tmp = w_index & USB_ENDPOINT_NUMBER_MASK;
1213                 ep = &udc->ep[tmp];
1214                 if (w_value != USB_ENDPOINT_HALT || tmp >= NUM_ENDPOINTS)
1215                         goto stall;
1216                 if (tmp == 0)
1217                         goto succeed;
1218                 if (!ep->ep.desc || ep->is_iso)
1219                         goto stall;
1220                 if ((w_index & USB_DIR_IN)) {
1221                         if (!ep->is_in)
1222                                 goto stall;
1223                 } else if (ep->is_in)
1224                         goto stall;
1225
1226                 at91_udp_write(udc, AT91_UDP_RST_EP, ep->int_mask);
1227                 at91_udp_write(udc, AT91_UDP_RST_EP, 0);
1228                 tmp = __raw_readl(ep->creg);
1229                 tmp |= CLR_FX;
1230                 tmp &= ~(SET_FX | AT91_UDP_FORCESTALL);
1231                 __raw_writel(tmp, ep->creg);
1232                 if (!list_empty(&ep->queue))
1233                         handle_ep(ep);
1234                 goto succeed;
1235         }
1236
1237 #undef w_value
1238 #undef w_index
1239 #undef w_length
1240
1241         /* pass request up to the gadget driver */
1242         if (udc->driver) {
1243                 spin_unlock(&udc->lock);
1244                 status = udc->driver->setup(&udc->gadget, &pkt.r);
1245                 spin_lock(&udc->lock);
1246         }
1247         else
1248                 status = -ENODEV;
1249         if (status < 0) {
1250 stall:
1251                 VDBG("req %02x.%02x protocol STALL; stat %d\n",
1252                                 pkt.r.bRequestType, pkt.r.bRequest, status);
1253                 csr |= AT91_UDP_FORCESTALL;
1254                 __raw_writel(csr, creg);
1255                 udc->req_pending = 0;
1256         }
1257         return;
1258
1259 succeed:
1260         /* immediate successful (IN) STATUS after zero length DATA */
1261         PACKET("ep0 in/status\n");
1262 write_in:
1263         csr |= AT91_UDP_TXPKTRDY;
1264         __raw_writel(csr, creg);
1265         udc->req_pending = 0;
1266 }
1267
1268 static void handle_ep0(struct at91_udc *udc)
1269 {
1270         struct at91_ep          *ep0 = &udc->ep[0];
1271         u32 __iomem             *creg = ep0->creg;
1272         u32                     csr = __raw_readl(creg);
1273         struct at91_request     *req;
1274
1275         if (unlikely(csr & AT91_UDP_STALLSENT)) {
1276                 nuke(ep0, -EPROTO);
1277                 udc->req_pending = 0;
1278                 csr |= CLR_FX;
1279                 csr &= ~(SET_FX | AT91_UDP_STALLSENT | AT91_UDP_FORCESTALL);
1280                 __raw_writel(csr, creg);
1281                 VDBG("ep0 stalled\n");
1282                 csr = __raw_readl(creg);
1283         }
1284         if (csr & AT91_UDP_RXSETUP) {
1285                 nuke(ep0, 0);
1286                 udc->req_pending = 0;
1287                 handle_setup(udc, ep0, csr);
1288                 return;
1289         }
1290
1291         if (list_empty(&ep0->queue))
1292                 req = NULL;
1293         else
1294                 req = list_entry(ep0->queue.next, struct at91_request, queue);
1295
1296         /* host ACKed an IN packet that we sent */
1297         if (csr & AT91_UDP_TXCOMP) {
1298                 csr |= CLR_FX;
1299                 csr &= ~(SET_FX | AT91_UDP_TXCOMP);
1300
1301                 /* write more IN DATA? */
1302                 if (req && ep0->is_in) {
1303                         if (handle_ep(ep0))
1304                                 udc->req_pending = 0;
1305
1306                 /*
1307                  * Ack after:
1308                  *  - last IN DATA packet (including GET_STATUS)
1309                  *  - IN/STATUS for OUT DATA
1310                  *  - IN/STATUS for any zero-length DATA stage
1311                  * except for the IN DATA case, the host should send
1312                  * an OUT status later, which we'll ack.
1313                  */
1314                 } else {
1315                         udc->req_pending = 0;
1316                         __raw_writel(csr, creg);
1317
1318                         /*
1319                          * SET_ADDRESS takes effect only after the STATUS
1320                          * (to the original address) gets acked.
1321                          */
1322                         if (udc->wait_for_addr_ack) {
1323                                 u32     tmp;
1324
1325                                 at91_udp_write(udc, AT91_UDP_FADDR,
1326                                                 AT91_UDP_FEN | udc->addr);
1327                                 tmp = at91_udp_read(udc, AT91_UDP_GLB_STAT);
1328                                 tmp &= ~AT91_UDP_FADDEN;
1329                                 if (udc->addr)
1330                                         tmp |= AT91_UDP_FADDEN;
1331                                 at91_udp_write(udc, AT91_UDP_GLB_STAT, tmp);
1332
1333                                 udc->wait_for_addr_ack = 0;
1334                                 VDBG("address %d\n", udc->addr);
1335                         }
1336                 }
1337         }
1338
1339         /* OUT packet arrived ... */
1340         else if (csr & AT91_UDP_RX_DATA_BK0) {
1341                 csr |= CLR_FX;
1342                 csr &= ~(SET_FX | AT91_UDP_RX_DATA_BK0);
1343
1344                 /* OUT DATA stage */
1345                 if (!ep0->is_in) {
1346                         if (req) {
1347                                 if (handle_ep(ep0)) {
1348                                         /* send IN/STATUS */
1349                                         PACKET("ep0 in/status\n");
1350                                         csr = __raw_readl(creg);
1351                                         csr &= ~SET_FX;
1352                                         csr |= CLR_FX | AT91_UDP_TXPKTRDY;
1353                                         __raw_writel(csr, creg);
1354                                         udc->req_pending = 0;
1355                                 }
1356                         } else if (udc->req_pending) {
1357                                 /*
1358                                  * AT91 hardware has a hard time with this
1359                                  * "deferred response" mode for control-OUT
1360                                  * transfers.  (For control-IN it's fine.)
1361                                  *
1362                                  * The normal solution leaves OUT data in the
1363                                  * fifo until the gadget driver is ready.
1364                                  * We couldn't do that here without disabling
1365                                  * the IRQ that tells about SETUP packets,
1366                                  * e.g. when the host gets impatient...
1367                                  *
1368                                  * Working around it by copying into a buffer
1369                                  * would almost be a non-deferred response,
1370                                  * except that it wouldn't permit reliable
1371                                  * stalling of the request.  Instead, demand
1372                                  * that gadget drivers not use this mode.
1373                                  */
1374                                 DBG("no control-OUT deferred responses!\n");
1375                                 __raw_writel(csr | AT91_UDP_FORCESTALL, creg);
1376                                 udc->req_pending = 0;
1377                         }
1378
1379                 /* STATUS stage for control-IN; ack.  */
1380                 } else {
1381                         PACKET("ep0 out/status ACK\n");
1382                         __raw_writel(csr, creg);
1383
1384                         /* "early" status stage */
1385                         if (req)
1386                                 done(ep0, req, 0);
1387                 }
1388         }
1389 }
1390
1391 static irqreturn_t at91_udc_irq (int irq, void *_udc)
1392 {
1393         struct at91_udc         *udc = _udc;
1394         u32                     rescans = 5;
1395         int                     disable_clock = 0;
1396         unsigned long           flags;
1397
1398         spin_lock_irqsave(&udc->lock, flags);
1399
1400         if (!udc->clocked) {
1401                 clk_on(udc);
1402                 disable_clock = 1;
1403         }
1404
1405         while (rescans--) {
1406                 u32 status;
1407
1408                 status = at91_udp_read(udc, AT91_UDP_ISR)
1409                         & at91_udp_read(udc, AT91_UDP_IMR);
1410                 if (!status)
1411                         break;
1412
1413                 /* USB reset irq:  not maskable */
1414                 if (status & AT91_UDP_ENDBUSRES) {
1415                         at91_udp_write(udc, AT91_UDP_IDR, ~MINIMUS_INTERRUPTUS);
1416                         at91_udp_write(udc, AT91_UDP_IER, MINIMUS_INTERRUPTUS);
1417                         /* Atmel code clears this irq twice */
1418                         at91_udp_write(udc, AT91_UDP_ICR, AT91_UDP_ENDBUSRES);
1419                         at91_udp_write(udc, AT91_UDP_ICR, AT91_UDP_ENDBUSRES);
1420                         VDBG("end bus reset\n");
1421                         udc->addr = 0;
1422                         reset_gadget(udc);
1423
1424                         /* enable ep0 */
1425                         at91_udp_write(udc, AT91_UDP_CSR(0),
1426                                         AT91_UDP_EPEDS | AT91_UDP_EPTYPE_CTRL);
1427                         udc->gadget.speed = USB_SPEED_FULL;
1428                         udc->suspended = 0;
1429                         at91_udp_write(udc, AT91_UDP_IER, AT91_UDP_EP(0));
1430
1431                         /*
1432                          * NOTE:  this driver keeps clocks off unless the
1433                          * USB host is present.  That saves power, but for
1434                          * boards that don't support VBUS detection, both
1435                          * clocks need to be active most of the time.
1436                          */
1437
1438                 /* host initiated suspend (3+ms bus idle) */
1439                 } else if (status & AT91_UDP_RXSUSP) {
1440                         at91_udp_write(udc, AT91_UDP_IDR, AT91_UDP_RXSUSP);
1441                         at91_udp_write(udc, AT91_UDP_IER, AT91_UDP_RXRSM);
1442                         at91_udp_write(udc, AT91_UDP_ICR, AT91_UDP_RXSUSP);
1443                         /* VDBG("bus suspend\n"); */
1444                         if (udc->suspended)
1445                                 continue;
1446                         udc->suspended = 1;
1447
1448                         /*
1449                          * NOTE:  when suspending a VBUS-powered device, the
1450                          * gadget driver should switch into slow clock mode
1451                          * and then into standby to avoid drawing more than
1452                          * 500uA power (2500uA for some high-power configs).
1453                          */
1454                         if (udc->driver && udc->driver->suspend) {
1455                                 spin_unlock(&udc->lock);
1456                                 udc->driver->suspend(&udc->gadget);
1457                                 spin_lock(&udc->lock);
1458                         }
1459
1460                 /* host initiated resume */
1461                 } else if (status & AT91_UDP_RXRSM) {
1462                         at91_udp_write(udc, AT91_UDP_IDR, AT91_UDP_RXRSM);
1463                         at91_udp_write(udc, AT91_UDP_IER, AT91_UDP_RXSUSP);
1464                         at91_udp_write(udc, AT91_UDP_ICR, AT91_UDP_RXRSM);
1465                         /* VDBG("bus resume\n"); */
1466                         if (!udc->suspended)
1467                                 continue;
1468                         udc->suspended = 0;
1469
1470                         /*
1471                          * NOTE:  for a VBUS-powered device, the gadget driver
1472                          * would normally want to switch out of slow clock
1473                          * mode into normal mode.
1474                          */
1475                         if (udc->driver && udc->driver->resume) {
1476                                 spin_unlock(&udc->lock);
1477                                 udc->driver->resume(&udc->gadget);
1478                                 spin_lock(&udc->lock);
1479                         }
1480
1481                 /* endpoint IRQs are cleared by handling them */
1482                 } else {
1483                         int             i;
1484                         unsigned        mask = 1;
1485                         struct at91_ep  *ep = &udc->ep[1];
1486
1487                         if (status & mask)
1488                                 handle_ep0(udc);
1489                         for (i = 1; i < NUM_ENDPOINTS; i++) {
1490                                 mask <<= 1;
1491                                 if (status & mask)
1492                                         handle_ep(ep);
1493                                 ep++;
1494                         }
1495                 }
1496         }
1497
1498         if (disable_clock)
1499                 clk_off(udc);
1500
1501         spin_unlock_irqrestore(&udc->lock, flags);
1502
1503         return IRQ_HANDLED;
1504 }
1505
1506 /*-------------------------------------------------------------------------*/
1507
1508 static void at91_vbus_update(struct at91_udc *udc, unsigned value)
1509 {
1510         value ^= udc->board.vbus_active_low;
1511         if (value != udc->vbus)
1512                 at91_vbus_session(&udc->gadget, value);
1513 }
1514
1515 static irqreturn_t at91_vbus_irq(int irq, void *_udc)
1516 {
1517         struct at91_udc *udc = _udc;
1518
1519         /* vbus needs at least brief debouncing */
1520         udelay(10);
1521         at91_vbus_update(udc, gpio_get_value(udc->board.vbus_pin));
1522
1523         return IRQ_HANDLED;
1524 }
1525
1526 static void at91_vbus_timer_work(struct work_struct *work)
1527 {
1528         struct at91_udc *udc = container_of(work, struct at91_udc,
1529                                             vbus_timer_work);
1530
1531         at91_vbus_update(udc, gpio_get_value_cansleep(udc->board.vbus_pin));
1532
1533         if (!timer_pending(&udc->vbus_timer))
1534                 mod_timer(&udc->vbus_timer, jiffies + VBUS_POLL_TIMEOUT);
1535 }
1536
1537 static void at91_vbus_timer(unsigned long data)
1538 {
1539         struct at91_udc *udc = (struct at91_udc *)data;
1540
1541         /*
1542          * If we are polling vbus it is likely that the gpio is on an
1543          * bus such as i2c or spi which may sleep, so schedule some work
1544          * to read the vbus gpio
1545          */
1546         schedule_work(&udc->vbus_timer_work);
1547 }
1548
1549 static int at91_start(struct usb_gadget *gadget,
1550                 struct usb_gadget_driver *driver)
1551 {
1552         struct at91_udc *udc;
1553
1554         udc = container_of(gadget, struct at91_udc, gadget);
1555         udc->driver = driver;
1556         udc->gadget.dev.of_node = udc->pdev->dev.of_node;
1557         udc->enabled = 1;
1558         udc->gadget.is_selfpowered = 1;
1559
1560         return 0;
1561 }
1562
1563 static int at91_stop(struct usb_gadget *gadget)
1564 {
1565         struct at91_udc *udc;
1566         unsigned long   flags;
1567
1568         udc = container_of(gadget, struct at91_udc, gadget);
1569         spin_lock_irqsave(&udc->lock, flags);
1570         udc->enabled = 0;
1571         at91_udp_write(udc, AT91_UDP_IDR, ~0);
1572         spin_unlock_irqrestore(&udc->lock, flags);
1573
1574         udc->driver = NULL;
1575
1576         return 0;
1577 }
1578
1579 /*-------------------------------------------------------------------------*/
1580
1581 static void at91udc_shutdown(struct platform_device *dev)
1582 {
1583         struct at91_udc *udc = platform_get_drvdata(dev);
1584         unsigned long   flags;
1585
1586         /* force disconnect on reboot */
1587         spin_lock_irqsave(&udc->lock, flags);
1588         pullup(platform_get_drvdata(dev), 0);
1589         spin_unlock_irqrestore(&udc->lock, flags);
1590 }
1591
1592 static int at91rm9200_udc_init(struct at91_udc *udc)
1593 {
1594         struct at91_ep *ep;
1595         int ret;
1596         int i;
1597
1598         for (i = 0; i < NUM_ENDPOINTS; i++) {
1599                 ep = &udc->ep[i];
1600
1601                 switch (i) {
1602                 case 0:
1603                 case 3:
1604                         ep->maxpacket = 8;
1605                         break;
1606                 case 1 ... 2:
1607                         ep->maxpacket = 64;
1608                         break;
1609                 case 4 ... 5:
1610                         ep->maxpacket = 256;
1611                         break;
1612                 }
1613         }
1614
1615         if (!gpio_is_valid(udc->board.pullup_pin)) {
1616                 DBG("no D+ pullup?\n");
1617                 return -ENODEV;
1618         }
1619
1620         ret = devm_gpio_request(&udc->pdev->dev, udc->board.pullup_pin,
1621                                 "udc_pullup");
1622         if (ret) {
1623                 DBG("D+ pullup is busy\n");
1624                 return ret;
1625         }
1626
1627         gpio_direction_output(udc->board.pullup_pin,
1628                               udc->board.pullup_active_low);
1629
1630         return 0;
1631 }
1632
1633 static void at91rm9200_udc_pullup(struct at91_udc *udc, int is_on)
1634 {
1635         int active = !udc->board.pullup_active_low;
1636
1637         if (is_on)
1638                 gpio_set_value(udc->board.pullup_pin, active);
1639         else
1640                 gpio_set_value(udc->board.pullup_pin, !active);
1641 }
1642
1643 static const struct at91_udc_caps at91rm9200_udc_caps = {
1644         .init = at91rm9200_udc_init,
1645         .pullup = at91rm9200_udc_pullup,
1646 };
1647
1648 static int at91sam9260_udc_init(struct at91_udc *udc)
1649 {
1650         struct at91_ep *ep;
1651         int i;
1652
1653         for (i = 0; i < NUM_ENDPOINTS; i++) {
1654                 ep = &udc->ep[i];
1655
1656                 switch (i) {
1657                 case 0 ... 3:
1658                         ep->maxpacket = 64;
1659                         break;
1660                 case 4 ... 5:
1661                         ep->maxpacket = 512;
1662                         break;
1663                 }
1664         }
1665
1666         return 0;
1667 }
1668
1669 static void at91sam9260_udc_pullup(struct at91_udc *udc, int is_on)
1670 {
1671         u32 txvc = at91_udp_read(udc, AT91_UDP_TXVC);
1672
1673         if (is_on)
1674                 txvc |= AT91_UDP_TXVC_PUON;
1675         else
1676                 txvc &= ~AT91_UDP_TXVC_PUON;
1677
1678         at91_udp_write(udc, AT91_UDP_TXVC, txvc);
1679 }
1680
1681 static const struct at91_udc_caps at91sam9260_udc_caps = {
1682         .init = at91sam9260_udc_init,
1683         .pullup = at91sam9260_udc_pullup,
1684 };
1685
1686 static int at91sam9261_udc_init(struct at91_udc *udc)
1687 {
1688         struct at91_ep *ep;
1689         int i;
1690
1691         for (i = 0; i < NUM_ENDPOINTS; i++) {
1692                 ep = &udc->ep[i];
1693
1694                 switch (i) {
1695                 case 0:
1696                         ep->maxpacket = 8;
1697                         break;
1698                 case 1 ... 3:
1699                         ep->maxpacket = 64;
1700                         break;
1701                 case 4 ... 5:
1702                         ep->maxpacket = 256;
1703                         break;
1704                 }
1705         }
1706
1707         udc->matrix = syscon_regmap_lookup_by_phandle(udc->pdev->dev.of_node,
1708                                                       "atmel,matrix");
1709         if (IS_ERR(udc->matrix))
1710                 return PTR_ERR(udc->matrix);
1711
1712         return 0;
1713 }
1714
1715 static void at91sam9261_udc_pullup(struct at91_udc *udc, int is_on)
1716 {
1717         u32 usbpucr = 0;
1718
1719         if (is_on)
1720                 usbpucr = AT91_MATRIX_USBPUCR_PUON;
1721
1722         regmap_update_bits(udc->matrix, AT91SAM9261_MATRIX_USBPUCR,
1723                            AT91_MATRIX_USBPUCR_PUON, usbpucr);
1724 }
1725
1726 static const struct at91_udc_caps at91sam9261_udc_caps = {
1727         .init = at91sam9261_udc_init,
1728         .pullup = at91sam9261_udc_pullup,
1729 };
1730
1731 static int at91sam9263_udc_init(struct at91_udc *udc)
1732 {
1733         struct at91_ep *ep;
1734         int i;
1735
1736         for (i = 0; i < NUM_ENDPOINTS; i++) {
1737                 ep = &udc->ep[i];
1738
1739                 switch (i) {
1740                 case 0:
1741                 case 1:
1742                 case 2:
1743                 case 3:
1744                         ep->maxpacket = 64;
1745                         break;
1746                 case 4:
1747                 case 5:
1748                         ep->maxpacket = 256;
1749                         break;
1750                 }
1751         }
1752
1753         return 0;
1754 }
1755
1756 static const struct at91_udc_caps at91sam9263_udc_caps = {
1757         .init = at91sam9263_udc_init,
1758         .pullup = at91sam9260_udc_pullup,
1759 };
1760
1761 static const struct of_device_id at91_udc_dt_ids[] = {
1762         {
1763                 .compatible = "atmel,at91rm9200-udc",
1764                 .data = &at91rm9200_udc_caps,
1765         },
1766         {
1767                 .compatible = "atmel,at91sam9260-udc",
1768                 .data = &at91sam9260_udc_caps,
1769         },
1770         {
1771                 .compatible = "atmel,at91sam9261-udc",
1772                 .data = &at91sam9261_udc_caps,
1773         },
1774         {
1775                 .compatible = "atmel,at91sam9263-udc",
1776                 .data = &at91sam9263_udc_caps,
1777         },
1778         { /* sentinel */ }
1779 };
1780 MODULE_DEVICE_TABLE(of, at91_udc_dt_ids);
1781
1782 static void at91udc_of_init(struct at91_udc *udc, struct device_node *np)
1783 {
1784         struct at91_udc_data *board = &udc->board;
1785         const struct of_device_id *match;
1786         enum of_gpio_flags flags;
1787         u32 val;
1788
1789         if (of_property_read_u32(np, "atmel,vbus-polled", &val) == 0)
1790                 board->vbus_polled = 1;
1791
1792         board->vbus_pin = of_get_named_gpio_flags(np, "atmel,vbus-gpio", 0,
1793                                                   &flags);
1794         board->vbus_active_low = (flags & OF_GPIO_ACTIVE_LOW) ? 1 : 0;
1795
1796         board->pullup_pin = of_get_named_gpio_flags(np, "atmel,pullup-gpio", 0,
1797                                                   &flags);
1798
1799         board->pullup_active_low = (flags & OF_GPIO_ACTIVE_LOW) ? 1 : 0;
1800
1801         match = of_match_node(at91_udc_dt_ids, np);
1802         if (match)
1803                 udc->caps = match->data;
1804 }
1805
1806 static int at91udc_probe(struct platform_device *pdev)
1807 {
1808         struct device   *dev = &pdev->dev;
1809         struct at91_udc *udc;
1810         int             retval;
1811         struct resource *res;
1812         struct at91_ep  *ep;
1813         int             i;
1814
1815         udc = devm_kzalloc(dev, sizeof(*udc), GFP_KERNEL);
1816         if (!udc)
1817                 return -ENOMEM;
1818
1819         /* init software state */
1820         udc->gadget.dev.parent = dev;
1821         at91udc_of_init(udc, pdev->dev.of_node);
1822         udc->pdev = pdev;
1823         udc->enabled = 0;
1824         spin_lock_init(&udc->lock);
1825
1826         udc->gadget.ops = &at91_udc_ops;
1827         udc->gadget.ep0 = &udc->ep[0].ep;
1828         udc->gadget.name = driver_name;
1829         udc->gadget.dev.init_name = "gadget";
1830
1831         for (i = 0; i < NUM_ENDPOINTS; i++) {
1832                 ep = &udc->ep[i];
1833                 ep->ep.name = ep_names[i];
1834                 ep->ep.ops = &at91_ep_ops;
1835                 ep->udc = udc;
1836                 ep->int_mask = BIT(i);
1837                 if (i != 0 && i != 3)
1838                         ep->is_pingpong = 1;
1839         }
1840
1841         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1842         udc->udp_baseaddr = devm_ioremap_resource(dev, res);
1843         if (IS_ERR(udc->udp_baseaddr))
1844                 return PTR_ERR(udc->udp_baseaddr);
1845
1846         if (udc->caps && udc->caps->init) {
1847                 retval = udc->caps->init(udc);
1848                 if (retval)
1849                         return retval;
1850         }
1851
1852         udc_reinit(udc);
1853
1854         /* get interface and function clocks */
1855         udc->iclk = devm_clk_get(dev, "pclk");
1856         if (IS_ERR(udc->iclk))
1857                 return PTR_ERR(udc->iclk);
1858
1859         udc->fclk = devm_clk_get(dev, "hclk");
1860         if (IS_ERR(udc->fclk))
1861                 return PTR_ERR(udc->fclk);
1862
1863         /* don't do anything until we have both gadget driver and VBUS */
1864         clk_set_rate(udc->fclk, 48000000);
1865         retval = clk_prepare(udc->fclk);
1866         if (retval)
1867                 return retval;
1868
1869         retval = clk_prepare_enable(udc->iclk);
1870         if (retval)
1871                 goto err_unprepare_fclk;
1872
1873         at91_udp_write(udc, AT91_UDP_TXVC, AT91_UDP_TXVC_TXVDIS);
1874         at91_udp_write(udc, AT91_UDP_IDR, 0xffffffff);
1875         /* Clear all pending interrupts - UDP may be used by bootloader. */
1876         at91_udp_write(udc, AT91_UDP_ICR, 0xffffffff);
1877         clk_disable(udc->iclk);
1878
1879         /* request UDC and maybe VBUS irqs */
1880         udc->udp_irq = platform_get_irq(pdev, 0);
1881         retval = devm_request_irq(dev, udc->udp_irq, at91_udc_irq, 0,
1882                                   driver_name, udc);
1883         if (retval) {
1884                 DBG("request irq %d failed\n", udc->udp_irq);
1885                 goto err_unprepare_iclk;
1886         }
1887
1888         if (gpio_is_valid(udc->board.vbus_pin)) {
1889                 retval = devm_gpio_request(dev, udc->board.vbus_pin,
1890                                            "udc_vbus");
1891                 if (retval) {
1892                         DBG("request vbus pin failed\n");
1893                         goto err_unprepare_iclk;
1894                 }
1895
1896                 gpio_direction_input(udc->board.vbus_pin);
1897
1898                 /*
1899                  * Get the initial state of VBUS - we cannot expect
1900                  * a pending interrupt.
1901                  */
1902                 udc->vbus = gpio_get_value_cansleep(udc->board.vbus_pin) ^
1903                         udc->board.vbus_active_low;
1904
1905                 if (udc->board.vbus_polled) {
1906                         INIT_WORK(&udc->vbus_timer_work, at91_vbus_timer_work);
1907                         setup_timer(&udc->vbus_timer, at91_vbus_timer,
1908                                     (unsigned long)udc);
1909                         mod_timer(&udc->vbus_timer,
1910                                   jiffies + VBUS_POLL_TIMEOUT);
1911                 } else {
1912                         retval = devm_request_irq(dev,
1913                                         gpio_to_irq(udc->board.vbus_pin),
1914                                         at91_vbus_irq, 0, driver_name, udc);
1915                         if (retval) {
1916                                 DBG("request vbus irq %d failed\n",
1917                                     udc->board.vbus_pin);
1918                                 goto err_unprepare_iclk;
1919                         }
1920                 }
1921         } else {
1922                 DBG("no VBUS detection, assuming always-on\n");
1923                 udc->vbus = 1;
1924         }
1925         retval = usb_add_gadget_udc(dev, &udc->gadget);
1926         if (retval)
1927                 goto err_unprepare_iclk;
1928         dev_set_drvdata(dev, udc);
1929         device_init_wakeup(dev, 1);
1930         create_debug_file(udc);
1931
1932         INFO("%s version %s\n", driver_name, DRIVER_VERSION);
1933         return 0;
1934
1935 err_unprepare_iclk:
1936         clk_unprepare(udc->iclk);
1937 err_unprepare_fclk:
1938         clk_unprepare(udc->fclk);
1939
1940         DBG("%s probe failed, %d\n", driver_name, retval);
1941
1942         return retval;
1943 }
1944
1945 static int at91udc_remove(struct platform_device *pdev)
1946 {
1947         struct at91_udc *udc = platform_get_drvdata(pdev);
1948         unsigned long   flags;
1949
1950         DBG("remove\n");
1951
1952         usb_del_gadget_udc(&udc->gadget);
1953         if (udc->driver)
1954                 return -EBUSY;
1955
1956         spin_lock_irqsave(&udc->lock, flags);
1957         pullup(udc, 0);
1958         spin_unlock_irqrestore(&udc->lock, flags);
1959
1960         device_init_wakeup(&pdev->dev, 0);
1961         remove_debug_file(udc);
1962         clk_unprepare(udc->fclk);
1963         clk_unprepare(udc->iclk);
1964
1965         return 0;
1966 }
1967
1968 #ifdef CONFIG_PM
1969 static int at91udc_suspend(struct platform_device *pdev, pm_message_t mesg)
1970 {
1971         struct at91_udc *udc = platform_get_drvdata(pdev);
1972         int             wake = udc->driver && device_may_wakeup(&pdev->dev);
1973         unsigned long   flags;
1974
1975         /* Unless we can act normally to the host (letting it wake us up
1976          * whenever it has work for us) force disconnect.  Wakeup requires
1977          * PLLB for USB events (signaling for reset, wakeup, or incoming
1978          * tokens) and VBUS irqs (on systems which support them).
1979          */
1980         if ((!udc->suspended && udc->addr)
1981                         || !wake
1982                         || at91_suspend_entering_slow_clock()) {
1983                 spin_lock_irqsave(&udc->lock, flags);
1984                 pullup(udc, 0);
1985                 wake = 0;
1986                 spin_unlock_irqrestore(&udc->lock, flags);
1987         } else
1988                 enable_irq_wake(udc->udp_irq);
1989
1990         udc->active_suspend = wake;
1991         if (gpio_is_valid(udc->board.vbus_pin) && !udc->board.vbus_polled && wake)
1992                 enable_irq_wake(udc->board.vbus_pin);
1993         return 0;
1994 }
1995
1996 static int at91udc_resume(struct platform_device *pdev)
1997 {
1998         struct at91_udc *udc = platform_get_drvdata(pdev);
1999         unsigned long   flags;
2000
2001         if (gpio_is_valid(udc->board.vbus_pin) && !udc->board.vbus_polled &&
2002             udc->active_suspend)
2003                 disable_irq_wake(udc->board.vbus_pin);
2004
2005         /* maybe reconnect to host; if so, clocks on */
2006         if (udc->active_suspend)
2007                 disable_irq_wake(udc->udp_irq);
2008         else {
2009                 spin_lock_irqsave(&udc->lock, flags);
2010                 pullup(udc, 1);
2011                 spin_unlock_irqrestore(&udc->lock, flags);
2012         }
2013         return 0;
2014 }
2015 #else
2016 #define at91udc_suspend NULL
2017 #define at91udc_resume  NULL
2018 #endif
2019
2020 static struct platform_driver at91_udc_driver = {
2021         .remove         = at91udc_remove,
2022         .shutdown       = at91udc_shutdown,
2023         .suspend        = at91udc_suspend,
2024         .resume         = at91udc_resume,
2025         .driver         = {
2026                 .name   = (char *) driver_name,
2027                 .of_match_table = at91_udc_dt_ids,
2028         },
2029 };
2030
2031 module_platform_driver_probe(at91_udc_driver, at91udc_probe);
2032
2033 MODULE_DESCRIPTION("AT91 udc driver");
2034 MODULE_AUTHOR("Thomas Rathbone, David Brownell");
2035 MODULE_LICENSE("GPL");
2036 MODULE_ALIAS("platform:at91_udc");