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