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