1 // SPDX-License-Identifier: GPL-2.0+
4 * c94e289f195e: usb: gadget: remove incorrect __init/__exit annotations
6 * at91_udc -- driver for at91-series USB peripheral controller
8 * Copyright (C) 2004 by Thomas Rathbone
9 * Copyright (C) 2005 by HP Labs
10 * Copyright (C) 2005 by David Brownell
17 #include <linux/errno.h>
20 #include <asm/hardware.h>
21 #include <mach/at91_matrix.h>
22 #include <linux/list.h>
23 #include <linux/usb/ch9.h>
24 #include <linux/usb/gadget.h>
25 #include <linux/usb/at91_udc.h>
27 #include <usb/lin_gadget_compat.h>
32 * This controller is simple and PIO-only. It's used in many AT91-series
33 * full speed USB controllers, including the at91rm9200 (arm920T, with MMU),
34 * at91sam926x (arm926ejs, with MMU), and several no-mmu versions.
36 * This driver expects the board has been wired with two GPIOs supporting
37 * a VBUS sensing IRQ, and a D+ pullup. (They may be omitted, but the
38 * testing hasn't covered such cases.)
40 * The pullup is most important (so it's integrated on sam926x parts). It
41 * provides software control over whether the host enumerates the device.
43 * The VBUS sensing helps during enumeration, and allows both USB clocks
44 * (and the transceiver) to stay gated off until they're necessary, saving
45 * power. During USB suspend, the 48 MHz clock is gated off in hardware;
46 * it may also be gated off by software during some Linux sleep states.
49 #define DRIVER_VERSION "3 May 2006"
51 static const char driver_name [] = "at91_udc";
52 static const char * const ep_names[] = {
60 #define ep0name ep_names[0]
62 #define at91_udp_read(udc, reg) \
63 __raw_readl((udc)->udp_baseaddr + (reg))
64 #define at91_udp_write(udc, reg, val) \
65 __raw_writel((val), (udc)->udp_baseaddr + (reg))
67 static struct at91_udc *controller;
69 /*-------------------------------------------------------------------------*/
71 static void done(struct at91_ep *ep, struct at91_request *req, int status)
73 unsigned stopped = ep->stopped;
74 struct at91_udc *udc = ep->udc;
76 list_del_init(&req->queue);
77 if (req->req.status == -EINPROGRESS)
78 req->req.status = status;
80 status = req->req.status;
81 if (status && status != -ESHUTDOWN)
82 VDBG("%s done %p, status %d\n", ep->ep.name, req, status);
85 spin_unlock(&udc->lock);
86 req->req.complete(&ep->ep, &req->req);
87 spin_lock(&udc->lock);
88 ep->stopped = stopped;
90 /* ep0 is always ready; other endpoints need a non-empty queue */
91 if (list_empty(&ep->queue) && ep->int_mask != (1 << 0))
92 at91_udp_write(udc, AT91_UDP_IDR, ep->int_mask);
95 /*-------------------------------------------------------------------------*/
97 /* bits indicating OUT fifo has data ready */
98 #define RX_DATA_READY (AT91_UDP_RX_DATA_BK0 | AT91_UDP_RX_DATA_BK1)
101 * Endpoint FIFO CSR bits have a mix of bits, making it unsafe to just write
102 * back most of the value you just read (because of side effects, including
103 * bits that may change after reading and before writing).
105 * Except when changing a specific bit, always write values which:
106 * - clear SET_FX bits (setting them could change something)
107 * - set CLR_FX bits (clearing them could change something)
109 * There are also state bits like FORCESTALL, EPEDS, DIR, and EPTYPE
110 * that shouldn't normally be changed.
112 * NOTE at91sam9260 docs mention synch between UDPCK and MCK clock domains,
113 * implying a need to wait for one write to complete (test relevant bits)
114 * before starting the next write. This shouldn't be an issue given how
115 * infrequently we write, except maybe for write-then-read idioms.
117 #define SET_FX (AT91_UDP_TXPKTRDY)
118 #define CLR_FX (RX_DATA_READY | AT91_UDP_RXSETUP \
119 | AT91_UDP_STALLSENT | AT91_UDP_TXCOMP)
121 /* pull OUT packet data from the endpoint's fifo */
122 static int read_fifo (struct at91_ep *ep, struct at91_request *req)
124 u32 __iomem *creg = ep->creg;
125 u8 __iomem *dreg = ep->creg + (AT91_UDP_FDR(0) - AT91_UDP_CSR(0));
128 unsigned int count, bufferspace, is_done;
130 buf = req->req.buf + req->req.actual;
131 bufferspace = req->req.length - req->req.actual;
134 * there might be nothing to read if ep_queue() calls us,
135 * or if we already emptied both pingpong buffers
138 csr = __raw_readl(creg);
139 if ((csr & RX_DATA_READY) == 0)
142 count = (csr & AT91_UDP_RXBYTECNT) >> 16;
143 if (count > ep->ep.maxpacket)
144 count = ep->ep.maxpacket;
145 if (count > bufferspace) {
146 DBG("%s buffer overflow\n", ep->ep.name);
147 req->req.status = -EOVERFLOW;
150 __raw_readsb((unsigned long)dreg, buf, count);
152 /* release and swap pingpong mem bank */
154 if (ep->is_pingpong) {
155 if (ep->fifo_bank == 0) {
156 csr &= ~(SET_FX | AT91_UDP_RX_DATA_BK0);
159 csr &= ~(SET_FX | AT91_UDP_RX_DATA_BK1);
163 csr &= ~(SET_FX | AT91_UDP_RX_DATA_BK0);
164 __raw_writel(csr, creg);
166 req->req.actual += count;
167 is_done = (count < ep->ep.maxpacket);
168 if (count == bufferspace)
171 PACKET("%s %p out/%d%s\n", ep->ep.name, &req->req, count,
172 is_done ? " (done)" : "");
175 * avoid extra trips through IRQ logic for packets already in
176 * the fifo ... maybe preventing an extra (expensive) OUT-NAK
180 else if (ep->is_pingpong) {
182 * One dummy read to delay the code because of a HW glitch:
183 * CSR returns bad RXCOUNT when read too soon after updating
186 csr = __raw_readl(creg);
188 bufferspace -= count;
196 /* load fifo for an IN packet */
197 static int write_fifo(struct at91_ep *ep, struct at91_request *req)
199 u32 __iomem *creg = ep->creg;
200 u32 csr = __raw_readl(creg);
201 u8 __iomem *dreg = ep->creg + (AT91_UDP_FDR(0) - AT91_UDP_CSR(0));
202 unsigned total, count, is_last;
206 * TODO: allow for writing two packets to the fifo ... that'll
207 * reduce the amount of IN-NAKing, but probably won't affect
208 * throughput much. (Unlike preventing OUT-NAKing!)
212 * If ep_queue() calls us, the queue is empty and possibly in
213 * odd states like TXCOMP not yet cleared (we do it, saving at
214 * least one IRQ) or the fifo not yet being free. Those aren't
215 * issues normally (IRQ handler fast path).
217 if (unlikely(csr & (AT91_UDP_TXCOMP | AT91_UDP_TXPKTRDY))) {
218 if (csr & AT91_UDP_TXCOMP) {
220 csr &= ~(SET_FX | AT91_UDP_TXCOMP);
221 __raw_writel(csr, creg);
222 csr = __raw_readl(creg);
224 if (csr & AT91_UDP_TXPKTRDY)
228 buf = req->req.buf + req->req.actual;
230 total = req->req.length - req->req.actual;
231 if (ep->ep.maxpacket < total) {
232 count = ep->ep.maxpacket;
236 is_last = (count < ep->ep.maxpacket) || !req->req.zero;
240 * Write the packet, maybe it's a ZLP.
242 * NOTE: incrementing req->actual before we receive the ACK means
243 * gadget driver IN bytecounts can be wrong in fault cases. That's
244 * fixable with PIO drivers like this one (save "count" here, and
245 * do the increment later on TX irq), but not for most DMA hardware.
247 * So all gadget drivers must accept that potential error. Some
248 * hardware supports precise fifo status reporting, letting them
249 * recover when the actual bytecount matters (e.g. for USB Test
250 * and Measurement Class devices).
252 __raw_writesb((unsigned long)dreg, buf, count);
254 csr |= CLR_FX | AT91_UDP_TXPKTRDY;
255 __raw_writel(csr, creg);
256 req->req.actual += count;
258 PACKET("%s %p in/%d%s\n", ep->ep.name, &req->req, count,
259 is_last ? " (done)" : "");
265 static void nuke(struct at91_ep *ep, int status)
267 struct at91_request *req;
269 /* terminate any request in the queue */
271 if (list_empty(&ep->queue))
274 VDBG("%s %s\n", __func__, ep->ep.name);
275 while (!list_empty(&ep->queue)) {
276 req = list_entry(ep->queue.next, struct at91_request, queue);
277 done(ep, req, status);
281 /*-------------------------------------------------------------------------*/
283 static int at91_ep_enable(struct usb_ep *_ep,
284 const struct usb_endpoint_descriptor *desc)
286 struct at91_ep *ep = container_of(_ep, struct at91_ep, ep);
287 struct at91_udc *udc;
293 || !desc || _ep->name == ep0name
294 || desc->bDescriptorType != USB_DT_ENDPOINT
295 || (maxpacket = usb_endpoint_maxp(desc)) == 0
296 || maxpacket > ep->maxpacket) {
297 DBG("bad ep or descriptor\n");
302 if (!udc->driver || udc->gadget.speed == USB_SPEED_UNKNOWN) {
303 DBG("bogus device state\n");
307 tmp = usb_endpoint_type(desc);
309 case USB_ENDPOINT_XFER_CONTROL:
310 DBG("only one control endpoint\n");
312 case USB_ENDPOINT_XFER_INT:
316 case USB_ENDPOINT_XFER_BULK:
325 DBG("bogus maxpacket %d\n", maxpacket);
327 case USB_ENDPOINT_XFER_ISOC:
328 if (!ep->is_pingpong) {
329 DBG("iso requires double buffering\n");
336 spin_lock_irqsave(&udc->lock, flags);
338 /* initialize endpoint to match this descriptor */
339 ep->is_in = usb_endpoint_dir_in(desc);
340 ep->is_iso = (tmp == USB_ENDPOINT_XFER_ISOC);
345 tmp |= AT91_UDP_EPEDS;
346 __raw_writel(tmp, ep->creg);
348 ep->ep.maxpacket = maxpacket;
351 * reset/init endpoint fifo. NOTE: leaves fifo_bank alone,
352 * since endpoint resets don't reset hw pingpong state.
354 at91_udp_write(udc, AT91_UDP_RST_EP, ep->int_mask);
355 at91_udp_write(udc, AT91_UDP_RST_EP, 0);
357 spin_unlock_irqrestore(&udc->lock, flags);
361 static int at91_ep_disable (struct usb_ep * _ep)
363 struct at91_ep *ep = container_of(_ep, struct at91_ep, ep);
364 struct at91_udc *udc = ep->udc;
367 if (ep == &ep->udc->ep[0])
370 spin_lock_irqsave(&udc->lock, flags);
372 nuke(ep, -ESHUTDOWN);
374 /* restore the endpoint's pristine config */
376 ep->ep.maxpacket = ep->maxpacket;
378 /* reset fifos and endpoint */
379 if (ep->udc->clocked) {
380 at91_udp_write(udc, AT91_UDP_RST_EP, ep->int_mask);
381 at91_udp_write(udc, AT91_UDP_RST_EP, 0);
382 __raw_writel(0, ep->creg);
385 spin_unlock_irqrestore(&udc->lock, flags);
390 * this is a PIO-only driver, so there's nothing
391 * interesting for request or buffer allocation.
394 static struct usb_request *
395 at91_ep_alloc_request(struct usb_ep *_ep, gfp_t gfp_flags)
397 struct at91_request *req;
399 req = kzalloc(sizeof (struct at91_request), gfp_flags);
403 INIT_LIST_HEAD(&req->queue);
407 static void at91_ep_free_request(struct usb_ep *_ep, struct usb_request *_req)
409 struct at91_request *req;
411 req = container_of(_req, struct at91_request, req);
412 BUG_ON(!list_empty(&req->queue));
416 static int at91_ep_queue(struct usb_ep *_ep,
417 struct usb_request *_req, gfp_t gfp_flags)
419 struct at91_request *req;
421 struct at91_udc *udc;
425 req = container_of(_req, struct at91_request, req);
426 ep = container_of(_ep, struct at91_ep, ep);
428 if (!_req || !_req->complete
429 || !_req->buf || !list_empty(&req->queue)) {
430 DBG("invalid request\n");
434 if (!_ep || (!ep->ep.desc && ep->ep.name != ep0name)) {
441 if (!udc || !udc->driver || udc->gadget.speed == USB_SPEED_UNKNOWN) {
442 DBG("invalid device\n");
446 _req->status = -EINPROGRESS;
449 spin_lock_irqsave(&udc->lock, flags);
451 /* try to kickstart any empty and idle queue */
452 if (list_empty(&ep->queue) && !ep->stopped) {
456 * If this control request has a non-empty DATA stage, this
457 * will start that stage. It works just like a non-control
458 * request (until the status stage starts, maybe early).
460 * If the data stage is empty, then this starts a successful
461 * IN/STATUS stage. (Unsuccessful ones use set_halt.)
463 is_ep0 = (ep->ep.name == ep0name);
467 if (!udc->req_pending) {
473 * defer changing CONFG until after the gadget driver
474 * reconfigures the endpoints.
476 if (udc->wait_for_config_ack) {
477 tmp = at91_udp_read(udc, AT91_UDP_GLB_STAT);
478 tmp ^= AT91_UDP_CONFG;
479 VDBG("toggle config\n");
480 at91_udp_write(udc, AT91_UDP_GLB_STAT, tmp);
482 if (req->req.length == 0) {
484 PACKET("ep0 in/status\n");
486 tmp = __raw_readl(ep->creg);
488 tmp |= CLR_FX | AT91_UDP_TXPKTRDY;
489 __raw_writel(tmp, ep->creg);
490 udc->req_pending = 0;
496 status = write_fifo(ep, req);
498 status = read_fifo(ep, req);
500 /* IN/STATUS stage is otherwise triggered by irq */
501 if (status && is_ep0)
507 if (req && !status) {
508 list_add_tail (&req->queue, &ep->queue);
509 at91_udp_write(udc, AT91_UDP_IER, ep->int_mask);
512 spin_unlock_irqrestore(&udc->lock, flags);
513 return (status < 0) ? status : 0;
516 static int at91_ep_dequeue(struct usb_ep *_ep, struct usb_request *_req)
519 struct at91_request *req;
522 ep = container_of(_ep, struct at91_ep, ep);
523 if (!_ep || ep->ep.name == ep0name)
526 spin_lock_irqsave(&udc->lock, flags);
528 /* make sure it's actually queued on this endpoint */
529 list_for_each_entry (req, &ep->queue, queue) {
530 if (&req->req == _req)
533 if (&req->req != _req) {
534 spin_unlock_irqrestore(&udc->lock, flags);
538 done(ep, req, -ECONNRESET);
539 spin_unlock_irqrestore(&udc->lock, flags);
543 static int at91_ep_set_halt(struct usb_ep *_ep, int value)
545 struct at91_ep *ep = container_of(_ep, struct at91_ep, ep);
546 struct at91_udc *udc = ep->udc;
552 if (!_ep || ep->is_iso || !ep->udc->clocked)
556 spin_lock_irqsave(&udc->lock, flags);
558 csr = __raw_readl(creg);
561 * fail with still-busy IN endpoints, ensuring correct sequencing
562 * of data tx then stall. note that the fifo rx bytecount isn't
563 * completely accurate as a tx bytecount.
565 if (ep->is_in && (!list_empty(&ep->queue) || (csr >> 16) != 0))
571 csr |= AT91_UDP_FORCESTALL;
572 VDBG("halt %s\n", ep->ep.name);
574 at91_udp_write(udc, AT91_UDP_RST_EP, ep->int_mask);
575 at91_udp_write(udc, AT91_UDP_RST_EP, 0);
576 csr &= ~AT91_UDP_FORCESTALL;
578 __raw_writel(csr, creg);
581 spin_unlock_irqrestore(&udc->lock, flags);
585 static const struct usb_ep_ops at91_ep_ops = {
586 .enable = at91_ep_enable,
587 .disable = at91_ep_disable,
588 .alloc_request = at91_ep_alloc_request,
589 .free_request = at91_ep_free_request,
590 .queue = at91_ep_queue,
591 .dequeue = at91_ep_dequeue,
592 .set_halt = at91_ep_set_halt,
593 /* there's only imprecise fifo status reporting */
596 /*-------------------------------------------------------------------------*/
598 static int at91_get_frame(struct usb_gadget *gadget)
600 struct at91_udc *udc = to_udc(gadget);
602 if (!to_udc(gadget)->clocked)
604 return at91_udp_read(udc, AT91_UDP_FRM_NUM) & AT91_UDP_NUM;
607 static int at91_wakeup(struct usb_gadget *gadget)
609 struct at91_udc *udc = to_udc(gadget);
611 int status = -EINVAL;
614 DBG("%s\n", __func__ );
615 spin_lock_irqsave(&udc->lock, flags);
617 if (!udc->clocked || !udc->suspended)
620 /* NOTE: some "early versions" handle ESR differently ... */
622 glbstate = at91_udp_read(udc, AT91_UDP_GLB_STAT);
623 if (!(glbstate & AT91_UDP_ESR))
625 glbstate |= AT91_UDP_ESR;
626 at91_udp_write(udc, AT91_UDP_GLB_STAT, glbstate);
629 spin_unlock_irqrestore(&udc->lock, flags);
633 /* reinit == restore initial software state */
634 static void udc_reinit(struct at91_udc *udc)
638 INIT_LIST_HEAD(&udc->gadget.ep_list);
639 INIT_LIST_HEAD(&udc->gadget.ep0->ep_list);
641 for (i = 0; i < NUM_ENDPOINTS; i++) {
642 struct at91_ep *ep = &udc->ep[i];
645 list_add_tail(&ep->ep.ep_list, &udc->gadget.ep_list);
649 usb_ep_set_maxpacket_limit(&ep->ep, ep->maxpacket);
650 ep->creg = (void __iomem *) udc->udp_baseaddr + AT91_UDP_CSR(i);
651 /* initialize one queue per endpoint */
652 INIT_LIST_HEAD(&ep->queue);
656 static void reset_gadget(struct at91_udc *udc)
658 struct usb_gadget_driver *driver = udc->driver;
661 if (udc->gadget.speed == USB_SPEED_UNKNOWN)
663 udc->gadget.speed = USB_SPEED_UNKNOWN;
666 for (i = 0; i < NUM_ENDPOINTS; i++) {
667 struct at91_ep *ep = &udc->ep[i];
670 nuke(ep, -ESHUTDOWN);
673 spin_unlock(&udc->lock);
674 udc->driver->disconnect(&udc->gadget);
675 spin_lock(&udc->lock);
681 static void stop_activity(struct at91_udc *udc)
683 struct usb_gadget_driver *driver = udc->driver;
686 if (udc->gadget.speed == USB_SPEED_UNKNOWN)
688 udc->gadget.speed = USB_SPEED_UNKNOWN;
691 for (i = 0; i < NUM_ENDPOINTS; i++) {
692 struct at91_ep *ep = &udc->ep[i];
694 nuke(ep, -ESHUTDOWN);
697 spin_unlock(&udc->lock);
698 driver->disconnect(&udc->gadget);
699 spin_lock(&udc->lock);
705 static void clk_on(struct at91_udc *udc)
712 static void clk_off(struct at91_udc *udc)
717 udc->gadget.speed = USB_SPEED_UNKNOWN;
721 * activate/deactivate link with host; minimize power usage for
722 * inactive links by cutting clocks and transceiver power.
724 static void pullup(struct at91_udc *udc, int is_on)
726 if (!udc->enabled || !udc->vbus)
728 DBG("%sactive\n", is_on ? "" : "in");
732 at91_udp_write(udc, AT91_UDP_ICR, AT91_UDP_RXRSM);
733 at91_udp_write(udc, AT91_UDP_TXVC, 0);
736 at91_udp_write(udc, AT91_UDP_IDR, AT91_UDP_RXRSM);
737 at91_udp_write(udc, AT91_UDP_TXVC, AT91_UDP_TXVC_TXVDIS);
741 if (udc->caps && udc->caps->pullup)
742 udc->caps->pullup(udc, is_on);
745 /* vbus is here! turn everything on that's ready */
746 static int at91_vbus_session(struct usb_gadget *gadget, int is_active)
748 struct at91_udc *udc = to_udc(gadget);
751 /* VDBG("vbus %s\n", is_active ? "on" : "off"); */
752 spin_lock_irqsave(&udc->lock, flags);
753 udc->vbus = (is_active != 0);
755 pullup(udc, is_active);
758 spin_unlock_irqrestore(&udc->lock, flags);
762 static int at91_pullup(struct usb_gadget *gadget, int is_on)
764 struct at91_udc *udc = to_udc(gadget);
767 spin_lock_irqsave(&udc->lock, flags);
768 udc->enabled = is_on = !!is_on;
770 spin_unlock_irqrestore(&udc->lock, flags);
774 static int at91_set_selfpowered(struct usb_gadget *gadget, int is_on)
776 struct at91_udc *udc = to_udc(gadget);
779 spin_lock_irqsave(&udc->lock, flags);
780 udc->selfpowered = (is_on != 0);
781 spin_unlock_irqrestore(&udc->lock, flags);
785 static int at91_start(struct usb_gadget *gadget,
786 struct usb_gadget_driver *driver);
787 static int at91_stop(struct usb_gadget *gadget);
789 static const struct usb_gadget_ops at91_udc_ops = {
790 .get_frame = at91_get_frame,
791 .wakeup = at91_wakeup,
792 .set_selfpowered = at91_set_selfpowered,
793 .vbus_session = at91_vbus_session,
794 .pullup = at91_pullup,
795 .udc_start = at91_start,
796 .udc_stop = at91_stop,
799 * VBUS-powered devices may also also want to support bigger
800 * power budgets after an appropriate SET_CONFIGURATION.
802 /* .vbus_power = at91_vbus_power, */
805 /*-------------------------------------------------------------------------*/
807 static int handle_ep(struct at91_ep *ep)
809 struct at91_request *req;
810 u32 __iomem *creg = ep->creg;
811 u32 csr = __raw_readl(creg);
813 if (!list_empty(&ep->queue))
814 req = list_entry(ep->queue.next,
815 struct at91_request, queue);
820 if (csr & (AT91_UDP_STALLSENT | AT91_UDP_TXCOMP)) {
822 csr &= ~(SET_FX | AT91_UDP_STALLSENT | AT91_UDP_TXCOMP);
823 __raw_writel(csr, creg);
826 return write_fifo(ep, req);
829 if (csr & AT91_UDP_STALLSENT) {
830 /* STALLSENT bit == ISOERR */
831 if (ep->is_iso && req)
832 req->req.status = -EILSEQ;
834 csr &= ~(SET_FX | AT91_UDP_STALLSENT);
835 __raw_writel(csr, creg);
836 csr = __raw_readl(creg);
838 if (req && (csr & RX_DATA_READY))
839 return read_fifo(ep, req);
846 struct usb_ctrlrequest r;
849 static void handle_setup(struct at91_udc *udc, struct at91_ep *ep, u32 csr)
851 u32 __iomem *creg = ep->creg;
852 u8 __iomem *dreg = ep->creg + (AT91_UDP_FDR(0) - AT91_UDP_CSR(0));
853 unsigned rxcount, i = 0;
858 /* read and ack SETUP; hard-fail for bogus packets */
859 rxcount = (csr & AT91_UDP_RXBYTECNT) >> 16;
860 if (likely(rxcount == 8)) {
862 pkt.raw[i++] = __raw_readb(dreg);
863 if (pkt.r.bRequestType & USB_DIR_IN) {
867 csr &= ~AT91_UDP_DIR;
871 /* REVISIT this happens sometimes under load; why?? */
872 ERR("SETUP len %d, csr %08x\n", rxcount, csr);
876 csr &= ~(SET_FX | AT91_UDP_RXSETUP);
877 __raw_writel(csr, creg);
878 udc->wait_for_addr_ack = 0;
879 udc->wait_for_config_ack = 0;
881 if (unlikely(status != 0))
884 #define w_index le16_to_cpu(pkt.r.wIndex)
885 #define w_value le16_to_cpu(pkt.r.wValue)
886 #define w_length le16_to_cpu(pkt.r.wLength)
888 VDBG("SETUP %02x.%02x v%04x i%04x l%04x\n",
889 pkt.r.bRequestType, pkt.r.bRequest,
890 w_value, w_index, w_length);
893 * A few standard requests get handled here, ones that touch
894 * hardware ... notably for device and endpoint features.
896 udc->req_pending = 1;
897 csr = __raw_readl(creg);
900 switch ((pkt.r.bRequestType << 8) | pkt.r.bRequest) {
902 case ((USB_TYPE_STANDARD|USB_RECIP_DEVICE) << 8)
903 | USB_REQ_SET_ADDRESS:
904 __raw_writel(csr | AT91_UDP_TXPKTRDY, creg);
906 udc->wait_for_addr_ack = 1;
907 udc->req_pending = 0;
908 /* FADDR is set later, when we ack host STATUS */
911 case ((USB_TYPE_STANDARD|USB_RECIP_DEVICE) << 8)
912 | USB_REQ_SET_CONFIGURATION:
913 tmp = at91_udp_read(udc, AT91_UDP_GLB_STAT) & AT91_UDP_CONFG;
915 udc->wait_for_config_ack = (tmp == 0);
917 udc->wait_for_config_ack = (tmp != 0);
918 if (udc->wait_for_config_ack)
919 VDBG("wait for config\n");
920 /* CONFG is toggled later, if gadget driver succeeds */
924 * Hosts may set or clear remote wakeup status, and
925 * devices may report they're VBUS powered.
927 case ((USB_DIR_IN|USB_TYPE_STANDARD|USB_RECIP_DEVICE) << 8)
928 | USB_REQ_GET_STATUS:
929 tmp = (udc->selfpowered << USB_DEVICE_SELF_POWERED);
930 if (at91_udp_read(udc, AT91_UDP_GLB_STAT) & AT91_UDP_ESR)
931 tmp |= (1 << USB_DEVICE_REMOTE_WAKEUP);
932 PACKET("get device status\n");
933 __raw_writeb(tmp, dreg);
934 __raw_writeb(0, dreg);
936 /* then STATUS starts later, automatically */
937 case ((USB_TYPE_STANDARD|USB_RECIP_DEVICE) << 8)
938 | USB_REQ_SET_FEATURE:
939 if (w_value != USB_DEVICE_REMOTE_WAKEUP)
941 tmp = at91_udp_read(udc, AT91_UDP_GLB_STAT);
943 at91_udp_write(udc, AT91_UDP_GLB_STAT, tmp);
945 case ((USB_TYPE_STANDARD|USB_RECIP_DEVICE) << 8)
946 | USB_REQ_CLEAR_FEATURE:
947 if (w_value != USB_DEVICE_REMOTE_WAKEUP)
949 tmp = at91_udp_read(udc, AT91_UDP_GLB_STAT);
950 tmp &= ~AT91_UDP_ESR;
951 at91_udp_write(udc, AT91_UDP_GLB_STAT, tmp);
955 * Interfaces have no feature settings; this is pretty useless.
956 * we won't even insist the interface exists...
958 case ((USB_DIR_IN|USB_TYPE_STANDARD|USB_RECIP_INTERFACE) << 8)
959 | USB_REQ_GET_STATUS:
960 PACKET("get interface status\n");
961 __raw_writeb(0, dreg);
962 __raw_writeb(0, dreg);
964 /* then STATUS starts later, automatically */
965 case ((USB_TYPE_STANDARD|USB_RECIP_INTERFACE) << 8)
966 | USB_REQ_SET_FEATURE:
967 case ((USB_TYPE_STANDARD|USB_RECIP_INTERFACE) << 8)
968 | USB_REQ_CLEAR_FEATURE:
972 * Hosts may clear bulk/intr endpoint halt after the gadget
973 * driver sets it (not widely used); or set it (for testing)
975 case ((USB_DIR_IN|USB_TYPE_STANDARD|USB_RECIP_ENDPOINT) << 8)
976 | USB_REQ_GET_STATUS:
977 tmp = w_index & USB_ENDPOINT_NUMBER_MASK;
979 if (tmp >= NUM_ENDPOINTS || (tmp && !ep->ep.desc))
983 if ((w_index & USB_DIR_IN)) {
986 } else if (ep->is_in)
989 PACKET("get %s status\n", ep->ep.name);
990 if (__raw_readl(ep->creg) & AT91_UDP_FORCESTALL)
991 tmp = (1 << USB_ENDPOINT_HALT);
994 __raw_writeb(tmp, dreg);
995 __raw_writeb(0, dreg);
997 /* then STATUS starts later, automatically */
998 case ((USB_TYPE_STANDARD|USB_RECIP_ENDPOINT) << 8)
999 | USB_REQ_SET_FEATURE:
1000 tmp = w_index & USB_ENDPOINT_NUMBER_MASK;
1002 if (w_value != USB_ENDPOINT_HALT || tmp >= NUM_ENDPOINTS)
1004 if (!ep->ep.desc || ep->is_iso)
1006 if ((w_index & USB_DIR_IN)) {
1009 } else if (ep->is_in)
1012 tmp = __raw_readl(ep->creg);
1014 tmp |= CLR_FX | AT91_UDP_FORCESTALL;
1015 __raw_writel(tmp, ep->creg);
1017 case ((USB_TYPE_STANDARD|USB_RECIP_ENDPOINT) << 8)
1018 | USB_REQ_CLEAR_FEATURE:
1019 tmp = w_index & USB_ENDPOINT_NUMBER_MASK;
1021 if (w_value != USB_ENDPOINT_HALT || tmp >= NUM_ENDPOINTS)
1025 if (!ep->ep.desc || ep->is_iso)
1027 if ((w_index & USB_DIR_IN)) {
1030 } else if (ep->is_in)
1033 at91_udp_write(udc, AT91_UDP_RST_EP, ep->int_mask);
1034 at91_udp_write(udc, AT91_UDP_RST_EP, 0);
1035 tmp = __raw_readl(ep->creg);
1037 tmp &= ~(SET_FX | AT91_UDP_FORCESTALL);
1038 __raw_writel(tmp, ep->creg);
1039 if (!list_empty(&ep->queue))
1048 /* pass request up to the gadget driver */
1050 spin_unlock(&udc->lock);
1051 status = udc->driver->setup(&udc->gadget, &pkt.r);
1052 spin_lock(&udc->lock);
1058 VDBG("req %02x.%02x protocol STALL; stat %d\n",
1059 pkt.r.bRequestType, pkt.r.bRequest, status);
1060 csr |= AT91_UDP_FORCESTALL;
1061 __raw_writel(csr, creg);
1062 udc->req_pending = 0;
1067 /* immediate successful (IN) STATUS after zero length DATA */
1068 PACKET("ep0 in/status\n");
1070 csr |= AT91_UDP_TXPKTRDY;
1071 __raw_writel(csr, creg);
1072 udc->req_pending = 0;
1075 static void handle_ep0(struct at91_udc *udc)
1077 struct at91_ep *ep0 = &udc->ep[0];
1078 u32 __iomem *creg = ep0->creg;
1079 u32 csr = __raw_readl(creg);
1080 struct at91_request *req;
1082 if (unlikely(csr & AT91_UDP_STALLSENT)) {
1084 udc->req_pending = 0;
1086 csr &= ~(SET_FX | AT91_UDP_STALLSENT | AT91_UDP_FORCESTALL);
1087 __raw_writel(csr, creg);
1088 VDBG("ep0 stalled\n");
1089 csr = __raw_readl(creg);
1091 if (csr & AT91_UDP_RXSETUP) {
1093 udc->req_pending = 0;
1094 handle_setup(udc, ep0, csr);
1098 if (list_empty(&ep0->queue))
1101 req = list_entry(ep0->queue.next, struct at91_request, queue);
1103 /* host ACKed an IN packet that we sent */
1104 if (csr & AT91_UDP_TXCOMP) {
1106 csr &= ~(SET_FX | AT91_UDP_TXCOMP);
1108 /* write more IN DATA? */
1109 if (req && ep0->is_in) {
1111 udc->req_pending = 0;
1115 * - last IN DATA packet (including GET_STATUS)
1116 * - IN/STATUS for OUT DATA
1117 * - IN/STATUS for any zero-length DATA stage
1118 * except for the IN DATA case, the host should send
1119 * an OUT status later, which we'll ack.
1122 udc->req_pending = 0;
1123 __raw_writel(csr, creg);
1126 * SET_ADDRESS takes effect only after the STATUS
1127 * (to the original address) gets acked.
1129 if (udc->wait_for_addr_ack) {
1132 at91_udp_write(udc, AT91_UDP_FADDR,
1133 AT91_UDP_FEN | udc->addr);
1134 tmp = at91_udp_read(udc, AT91_UDP_GLB_STAT);
1135 tmp &= ~AT91_UDP_FADDEN;
1137 tmp |= AT91_UDP_FADDEN;
1138 at91_udp_write(udc, AT91_UDP_GLB_STAT, tmp);
1140 udc->wait_for_addr_ack = 0;
1141 VDBG("address %d\n", udc->addr);
1146 /* OUT packet arrived ... */
1147 else if (csr & AT91_UDP_RX_DATA_BK0) {
1149 csr &= ~(SET_FX | AT91_UDP_RX_DATA_BK0);
1151 /* OUT DATA stage */
1154 if (handle_ep(ep0)) {
1155 /* send IN/STATUS */
1156 PACKET("ep0 in/status\n");
1157 csr = __raw_readl(creg);
1159 csr |= CLR_FX | AT91_UDP_TXPKTRDY;
1160 __raw_writel(csr, creg);
1161 udc->req_pending = 0;
1163 } else if (udc->req_pending) {
1165 * AT91 hardware has a hard time with this
1166 * "deferred response" mode for control-OUT
1167 * transfers. (For control-IN it's fine.)
1169 * The normal solution leaves OUT data in the
1170 * fifo until the gadget driver is ready.
1171 * We couldn't do that here without disabling
1172 * the IRQ that tells about SETUP packets,
1173 * e.g. when the host gets impatient...
1175 * Working around it by copying into a buffer
1176 * would almost be a non-deferred response,
1177 * except that it wouldn't permit reliable
1178 * stalling of the request. Instead, demand
1179 * that gadget drivers not use this mode.
1181 DBG("no control-OUT deferred responses!\n");
1182 __raw_writel(csr | AT91_UDP_FORCESTALL, creg);
1183 udc->req_pending = 0;
1186 /* STATUS stage for control-IN; ack. */
1188 PACKET("ep0 out/status ACK\n");
1189 __raw_writel(csr, creg);
1191 /* "early" status stage */
1198 static irqreturn_t at91_udc_irq(struct at91_udc *udc)
1201 int disable_clock = 0;
1202 unsigned long flags;
1204 spin_lock_irqsave(&udc->lock, flags);
1206 if (!udc->clocked) {
1214 status = at91_udp_read(udc, AT91_UDP_ISR)
1215 & at91_udp_read(udc, AT91_UDP_IMR);
1219 /* USB reset irq: not maskable */
1220 if (status & AT91_UDP_ENDBUSRES) {
1221 at91_udp_write(udc, AT91_UDP_IDR, ~MINIMUS_INTERRUPTUS);
1222 at91_udp_write(udc, AT91_UDP_IER, MINIMUS_INTERRUPTUS);
1223 /* Atmel code clears this irq twice */
1224 at91_udp_write(udc, AT91_UDP_ICR, AT91_UDP_ENDBUSRES);
1225 at91_udp_write(udc, AT91_UDP_ICR, AT91_UDP_ENDBUSRES);
1226 VDBG("end bus reset\n");
1231 at91_udp_write(udc, AT91_UDP_CSR(0),
1232 AT91_UDP_EPEDS | AT91_UDP_EPTYPE_CTRL);
1233 udc->gadget.speed = USB_SPEED_FULL;
1235 at91_udp_write(udc, AT91_UDP_IER, AT91_UDP_EP(0));
1238 * NOTE: this driver keeps clocks off unless the
1239 * USB host is present. That saves power, but for
1240 * boards that don't support VBUS detection, both
1241 * clocks need to be active most of the time.
1244 /* host initiated suspend (3+ms bus idle) */
1245 } else if (status & AT91_UDP_RXSUSP) {
1246 at91_udp_write(udc, AT91_UDP_IDR, AT91_UDP_RXSUSP);
1247 at91_udp_write(udc, AT91_UDP_IER, AT91_UDP_RXRSM);
1248 at91_udp_write(udc, AT91_UDP_ICR, AT91_UDP_RXSUSP);
1249 /* VDBG("bus suspend\n"); */
1255 * NOTE: when suspending a VBUS-powered device, the
1256 * gadget driver should switch into slow clock mode
1257 * and then into standby to avoid drawing more than
1258 * 500uA power (2500uA for some high-power configs).
1260 if (udc->driver && udc->driver->suspend) {
1261 spin_unlock(&udc->lock);
1262 udc->driver->suspend(&udc->gadget);
1263 spin_lock(&udc->lock);
1266 /* host initiated resume */
1267 } else if (status & AT91_UDP_RXRSM) {
1268 at91_udp_write(udc, AT91_UDP_IDR, AT91_UDP_RXRSM);
1269 at91_udp_write(udc, AT91_UDP_IER, AT91_UDP_RXSUSP);
1270 at91_udp_write(udc, AT91_UDP_ICR, AT91_UDP_RXRSM);
1271 /* VDBG("bus resume\n"); */
1272 if (!udc->suspended)
1277 * NOTE: for a VBUS-powered device, the gadget driver
1278 * would normally want to switch out of slow clock
1279 * mode into normal mode.
1281 if (udc->driver && udc->driver->resume) {
1282 spin_unlock(&udc->lock);
1283 udc->driver->resume(&udc->gadget);
1284 spin_lock(&udc->lock);
1287 /* endpoint IRQs are cleared by handling them */
1291 struct at91_ep *ep = &udc->ep[1];
1295 for (i = 1; i < NUM_ENDPOINTS; i++) {
1307 spin_unlock_irqrestore(&udc->lock, flags);
1312 /*-------------------------------------------------------------------------*/
1314 static int at91_start(struct usb_gadget *gadget,
1315 struct usb_gadget_driver *driver)
1317 struct at91_udc *udc = controller;
1319 udc->driver = driver;
1321 udc->selfpowered = 1;
1326 static int at91_stop(struct usb_gadget *gadget)
1328 struct at91_udc *udc = controller;
1329 unsigned long flags;
1331 spin_lock_irqsave(&udc->lock, flags);
1333 at91_udp_write(udc, AT91_UDP_IDR, ~0);
1334 spin_unlock_irqrestore(&udc->lock, flags);
1341 /*-------------------------------------------------------------------------*/
1343 #if defined(CONFIG_AT91SAM9260) || defined(CONFIG_AT91SAM9G20)
1344 static int at91sam9260_udc_init(struct at91_udc *udc)
1349 for (i = 0; i < NUM_ENDPOINTS; i++) {
1357 ep->maxpacket = 512;
1365 static void at91sam9260_udc_pullup(struct at91_udc *udc, int is_on)
1367 u32 txvc = at91_udp_read(udc, AT91_UDP_TXVC);
1370 txvc |= AT91_UDP_TXVC_PUON;
1372 txvc &= ~AT91_UDP_TXVC_PUON;
1374 at91_udp_write(udc, AT91_UDP_TXVC, txvc);
1377 static const struct at91_udc_caps at91sam9260_udc_caps = {
1378 .init = at91sam9260_udc_init,
1379 .pullup = at91sam9260_udc_pullup,
1383 #if defined(CONFIG_AT91SAM9261)
1384 static int at91sam9261_udc_init(struct at91_udc *udc)
1389 for (i = 0; i < NUM_ENDPOINTS; i++) {
1400 ep->maxpacket = 256;
1405 udc->matrix = (struct at91_matrix *)ATMEL_BASE_MATRIX;
1407 if (IS_ERR(udc->matrix))
1408 return PTR_ERR(udc->matrix);
1413 static void at91sam9261_udc_pullup(struct at91_udc *udc, int is_on)
1417 usbpucr = readl(&udc->matrix->pucr);
1419 usbpucr |= AT91_MATRIX_USBPUCR_PUON;
1421 writel(usbpucr, &udc->matrix->pucr);
1424 static const struct at91_udc_caps at91sam9261_udc_caps = {
1425 .init = at91sam9261_udc_init,
1426 .pullup = at91sam9261_udc_pullup,
1430 int usb_gadget_handle_interrupts(int index)
1432 struct at91_udc *udc = controller;
1434 return at91_udc_irq(udc);
1437 int usb_gadget_register_driver(struct usb_gadget_driver *driver)
1439 struct at91_udc *udc = controller;
1442 if (!driver || !driver->bind || !driver->setup) {
1443 printf("bad paramter\n");
1448 printf("UDC already has a gadget driver\n");
1452 at91_start(&udc->gadget, driver);
1454 udc->driver = driver;
1456 ret = driver->bind(&udc->gadget);
1458 pr_err("driver->bind() returned %d\n", ret);
1465 int usb_gadget_unregister_driver(struct usb_gadget_driver *driver)
1467 struct at91_udc *udc = controller;
1469 if (!driver || !driver->unbind || !driver->disconnect) {
1470 pr_err("bad paramter\n");
1474 driver->disconnect(&udc->gadget);
1475 driver->unbind(&udc->gadget);
1478 at91_stop(&udc->gadget);
1483 int at91_udc_probe(struct at91_udc_data *pdata)
1485 struct at91_udc *udc;
1490 udc = kzalloc(sizeof(*udc), GFP_KERNEL);
1495 memcpy(&udc->board, pdata, sizeof(struct at91_udc_data));
1496 if (udc->board.vbus_pin) {
1497 printf("%s: gpio vbus pin not supported yet.\n", __func__);
1500 DBG("no VBUS detection, assuming always-on\n");
1504 #if defined(CONFIG_AT91SAM9260) || defined(CONFIG_AT91SAM9G20)
1505 udc->caps = &at91sam9260_udc_caps;
1509 spin_lock_init(&udc->lock);
1511 udc->gadget.ops = &at91_udc_ops;
1512 udc->gadget.ep0 = &udc->ep[0].ep;
1513 udc->gadget.name = driver_name;
1515 for (i = 0; i < NUM_ENDPOINTS; i++) {
1517 ep->ep.name = ep_names[i];
1518 ep->ep.ops = &at91_ep_ops;
1520 ep->int_mask = (1 << i);
1521 if (i != 0 && i != 3)
1522 ep->is_pingpong = 1;
1525 udc->udp_baseaddr = (void *)udc->board.baseaddr;
1526 if (IS_ERR(udc->udp_baseaddr))
1527 return PTR_ERR(udc->udp_baseaddr);
1529 if (udc->caps && udc->caps->init) {
1530 retval = udc->caps->init(udc);
1537 at91_udp_write(udc, AT91_UDP_TXVC, AT91_UDP_TXVC_TXVDIS);
1538 at91_udp_write(udc, AT91_UDP_IDR, 0xffffffff);
1539 /* Clear all pending interrupts - UDP may be used by bootloader. */
1540 at91_udp_write(udc, AT91_UDP_ICR, 0xffffffff);
1542 INFO("%s version %s\n", driver_name, DRIVER_VERSION);