3 * c94e289f195e: usb: gadget: remove incorrect __init/__exit annotations
5 * at91_udc -- driver for at91-series USB peripheral controller
7 * Copyright (C) 2004 by Thomas Rathbone
8 * Copyright (C) 2005 by HP Labs
9 * Copyright (C) 2005 by David Brownell
11 * SPDX-License-Identifier: GPL-2.0+
18 #include <asm/errno.h>
21 #include <asm/hardware.h>
22 #include <mach/at91_matrix.h>
23 #include <linux/list.h>
24 #include <linux/usb/ch9.h>
25 #include <linux/usb/gadget.h>
26 #include <linux/usb/at91_udc.h>
28 #include <usb/lin_gadget_compat.h>
33 * This controller is simple and PIO-only. It's used in many AT91-series
34 * full speed USB controllers, including the at91rm9200 (arm920T, with MMU),
35 * at91sam926x (arm926ejs, with MMU), and several no-mmu versions.
37 * This driver expects the board has been wired with two GPIOs supporting
38 * a VBUS sensing IRQ, and a D+ pullup. (They may be omitted, but the
39 * testing hasn't covered such cases.)
41 * The pullup is most important (so it's integrated on sam926x parts). It
42 * provides software control over whether the host enumerates the device.
44 * The VBUS sensing helps during enumeration, and allows both USB clocks
45 * (and the transceiver) to stay gated off until they're necessary, saving
46 * power. During USB suspend, the 48 MHz clock is gated off in hardware;
47 * it may also be gated off by software during some Linux sleep states.
50 #define DRIVER_VERSION "3 May 2006"
52 static const char driver_name [] = "at91_udc";
53 static const char * const ep_names[] = {
61 #define ep0name ep_names[0]
63 #define at91_udp_read(udc, reg) \
64 __raw_readl((udc)->udp_baseaddr + (reg))
65 #define at91_udp_write(udc, reg, val) \
66 __raw_writel((val), (udc)->udp_baseaddr + (reg))
68 static struct at91_udc *controller;
70 /*-------------------------------------------------------------------------*/
72 static void done(struct at91_ep *ep, struct at91_request *req, int status)
74 unsigned stopped = ep->stopped;
75 struct at91_udc *udc = ep->udc;
77 list_del_init(&req->queue);
78 if (req->req.status == -EINPROGRESS)
79 req->req.status = status;
81 status = req->req.status;
82 if (status && status != -ESHUTDOWN)
83 VDBG("%s done %p, status %d\n", ep->ep.name, req, status);
86 spin_unlock(&udc->lock);
87 req->req.complete(&ep->ep, &req->req);
88 spin_lock(&udc->lock);
89 ep->stopped = stopped;
91 /* ep0 is always ready; other endpoints need a non-empty queue */
92 if (list_empty(&ep->queue) && ep->int_mask != (1 << 0))
93 at91_udp_write(udc, AT91_UDP_IDR, ep->int_mask);
96 /*-------------------------------------------------------------------------*/
98 /* bits indicating OUT fifo has data ready */
99 #define RX_DATA_READY (AT91_UDP_RX_DATA_BK0 | AT91_UDP_RX_DATA_BK1)
102 * Endpoint FIFO CSR bits have a mix of bits, making it unsafe to just write
103 * back most of the value you just read (because of side effects, including
104 * bits that may change after reading and before writing).
106 * Except when changing a specific bit, always write values which:
107 * - clear SET_FX bits (setting them could change something)
108 * - set CLR_FX bits (clearing them could change something)
110 * There are also state bits like FORCESTALL, EPEDS, DIR, and EPTYPE
111 * that shouldn't normally be changed.
113 * NOTE at91sam9260 docs mention synch between UDPCK and MCK clock domains,
114 * implying a need to wait for one write to complete (test relevant bits)
115 * before starting the next write. This shouldn't be an issue given how
116 * infrequently we write, except maybe for write-then-read idioms.
118 #define SET_FX (AT91_UDP_TXPKTRDY)
119 #define CLR_FX (RX_DATA_READY | AT91_UDP_RXSETUP \
120 | AT91_UDP_STALLSENT | AT91_UDP_TXCOMP)
122 /* pull OUT packet data from the endpoint's fifo */
123 static int read_fifo (struct at91_ep *ep, struct at91_request *req)
125 u32 __iomem *creg = ep->creg;
126 u8 __iomem *dreg = ep->creg + (AT91_UDP_FDR(0) - AT91_UDP_CSR(0));
129 unsigned int count, bufferspace, is_done;
131 buf = req->req.buf + req->req.actual;
132 bufferspace = req->req.length - req->req.actual;
135 * there might be nothing to read if ep_queue() calls us,
136 * or if we already emptied both pingpong buffers
139 csr = __raw_readl(creg);
140 if ((csr & RX_DATA_READY) == 0)
143 count = (csr & AT91_UDP_RXBYTECNT) >> 16;
144 if (count > ep->ep.maxpacket)
145 count = ep->ep.maxpacket;
146 if (count > bufferspace) {
147 DBG("%s buffer overflow\n", ep->ep.name);
148 req->req.status = -EOVERFLOW;
151 __raw_readsb((unsigned long)dreg, buf, count);
153 /* release and swap pingpong mem bank */
155 if (ep->is_pingpong) {
156 if (ep->fifo_bank == 0) {
157 csr &= ~(SET_FX | AT91_UDP_RX_DATA_BK0);
160 csr &= ~(SET_FX | AT91_UDP_RX_DATA_BK1);
164 csr &= ~(SET_FX | AT91_UDP_RX_DATA_BK0);
165 __raw_writel(csr, creg);
167 req->req.actual += count;
168 is_done = (count < ep->ep.maxpacket);
169 if (count == bufferspace)
172 PACKET("%s %p out/%d%s\n", ep->ep.name, &req->req, count,
173 is_done ? " (done)" : "");
176 * avoid extra trips through IRQ logic for packets already in
177 * the fifo ... maybe preventing an extra (expensive) OUT-NAK
181 else if (ep->is_pingpong) {
183 * One dummy read to delay the code because of a HW glitch:
184 * CSR returns bad RXCOUNT when read too soon after updating
187 csr = __raw_readl(creg);
189 bufferspace -= count;
197 /* load fifo for an IN packet */
198 static int write_fifo(struct at91_ep *ep, struct at91_request *req)
200 u32 __iomem *creg = ep->creg;
201 u32 csr = __raw_readl(creg);
202 u8 __iomem *dreg = ep->creg + (AT91_UDP_FDR(0) - AT91_UDP_CSR(0));
203 unsigned total, count, is_last;
207 * TODO: allow for writing two packets to the fifo ... that'll
208 * reduce the amount of IN-NAKing, but probably won't affect
209 * throughput much. (Unlike preventing OUT-NAKing!)
213 * If ep_queue() calls us, the queue is empty and possibly in
214 * odd states like TXCOMP not yet cleared (we do it, saving at
215 * least one IRQ) or the fifo not yet being free. Those aren't
216 * issues normally (IRQ handler fast path).
218 if (unlikely(csr & (AT91_UDP_TXCOMP | AT91_UDP_TXPKTRDY))) {
219 if (csr & AT91_UDP_TXCOMP) {
221 csr &= ~(SET_FX | AT91_UDP_TXCOMP);
222 __raw_writel(csr, creg);
223 csr = __raw_readl(creg);
225 if (csr & AT91_UDP_TXPKTRDY)
229 buf = req->req.buf + req->req.actual;
231 total = req->req.length - req->req.actual;
232 if (ep->ep.maxpacket < total) {
233 count = ep->ep.maxpacket;
237 is_last = (count < ep->ep.maxpacket) || !req->req.zero;
241 * Write the packet, maybe it's a ZLP.
243 * NOTE: incrementing req->actual before we receive the ACK means
244 * gadget driver IN bytecounts can be wrong in fault cases. That's
245 * fixable with PIO drivers like this one (save "count" here, and
246 * do the increment later on TX irq), but not for most DMA hardware.
248 * So all gadget drivers must accept that potential error. Some
249 * hardware supports precise fifo status reporting, letting them
250 * recover when the actual bytecount matters (e.g. for USB Test
251 * and Measurement Class devices).
253 __raw_writesb((unsigned long)dreg, buf, count);
255 csr |= CLR_FX | AT91_UDP_TXPKTRDY;
256 __raw_writel(csr, creg);
257 req->req.actual += count;
259 PACKET("%s %p in/%d%s\n", ep->ep.name, &req->req, count,
260 is_last ? " (done)" : "");
266 static void nuke(struct at91_ep *ep, int status)
268 struct at91_request *req;
270 /* terminate any request in the queue */
272 if (list_empty(&ep->queue))
275 VDBG("%s %s\n", __func__, ep->ep.name);
276 while (!list_empty(&ep->queue)) {
277 req = list_entry(ep->queue.next, struct at91_request, queue);
278 done(ep, req, status);
282 /*-------------------------------------------------------------------------*/
284 static int at91_ep_enable(struct usb_ep *_ep,
285 const struct usb_endpoint_descriptor *desc)
287 struct at91_ep *ep = container_of(_ep, struct at91_ep, ep);
288 struct at91_udc *udc;
294 || !desc || _ep->name == ep0name
295 || desc->bDescriptorType != USB_DT_ENDPOINT
296 || (maxpacket = usb_endpoint_maxp(desc)) == 0
297 || maxpacket > ep->maxpacket) {
298 DBG("bad ep or descriptor\n");
303 if (!udc->driver || udc->gadget.speed == USB_SPEED_UNKNOWN) {
304 DBG("bogus device state\n");
308 tmp = usb_endpoint_type(desc);
310 case USB_ENDPOINT_XFER_CONTROL:
311 DBG("only one control endpoint\n");
313 case USB_ENDPOINT_XFER_INT:
317 case USB_ENDPOINT_XFER_BULK:
326 DBG("bogus maxpacket %d\n", maxpacket);
328 case USB_ENDPOINT_XFER_ISOC:
329 if (!ep->is_pingpong) {
330 DBG("iso requires double buffering\n");
337 spin_lock_irqsave(&udc->lock, flags);
339 /* initialize endpoint to match this descriptor */
340 ep->is_in = usb_endpoint_dir_in(desc);
341 ep->is_iso = (tmp == USB_ENDPOINT_XFER_ISOC);
346 tmp |= AT91_UDP_EPEDS;
347 __raw_writel(tmp, ep->creg);
349 ep->ep.maxpacket = maxpacket;
352 * reset/init endpoint fifo. NOTE: leaves fifo_bank alone,
353 * since endpoint resets don't reset hw pingpong state.
355 at91_udp_write(udc, AT91_UDP_RST_EP, ep->int_mask);
356 at91_udp_write(udc, AT91_UDP_RST_EP, 0);
358 spin_unlock_irqrestore(&udc->lock, flags);
362 static int at91_ep_disable (struct usb_ep * _ep)
364 struct at91_ep *ep = container_of(_ep, struct at91_ep, ep);
365 struct at91_udc *udc = ep->udc;
368 if (ep == &ep->udc->ep[0])
371 spin_lock_irqsave(&udc->lock, flags);
373 nuke(ep, -ESHUTDOWN);
375 /* restore the endpoint's pristine config */
377 ep->ep.maxpacket = ep->maxpacket;
379 /* reset fifos and endpoint */
380 if (ep->udc->clocked) {
381 at91_udp_write(udc, AT91_UDP_RST_EP, ep->int_mask);
382 at91_udp_write(udc, AT91_UDP_RST_EP, 0);
383 __raw_writel(0, ep->creg);
386 spin_unlock_irqrestore(&udc->lock, flags);
391 * this is a PIO-only driver, so there's nothing
392 * interesting for request or buffer allocation.
395 static struct usb_request *
396 at91_ep_alloc_request(struct usb_ep *_ep, gfp_t gfp_flags)
398 struct at91_request *req;
400 req = kzalloc(sizeof (struct at91_request), gfp_flags);
404 INIT_LIST_HEAD(&req->queue);
408 static void at91_ep_free_request(struct usb_ep *_ep, struct usb_request *_req)
410 struct at91_request *req;
412 req = container_of(_req, struct at91_request, req);
413 BUG_ON(!list_empty(&req->queue));
417 static int at91_ep_queue(struct usb_ep *_ep,
418 struct usb_request *_req, gfp_t gfp_flags)
420 struct at91_request *req;
422 struct at91_udc *udc;
426 req = container_of(_req, struct at91_request, req);
427 ep = container_of(_ep, struct at91_ep, ep);
429 if (!_req || !_req->complete
430 || !_req->buf || !list_empty(&req->queue)) {
431 DBG("invalid request\n");
435 if (!_ep || (!ep->ep.desc && ep->ep.name != ep0name)) {
442 if (!udc || !udc->driver || udc->gadget.speed == USB_SPEED_UNKNOWN) {
443 DBG("invalid device\n");
447 _req->status = -EINPROGRESS;
450 spin_lock_irqsave(&udc->lock, flags);
452 /* try to kickstart any empty and idle queue */
453 if (list_empty(&ep->queue) && !ep->stopped) {
457 * If this control request has a non-empty DATA stage, this
458 * will start that stage. It works just like a non-control
459 * request (until the status stage starts, maybe early).
461 * If the data stage is empty, then this starts a successful
462 * IN/STATUS stage. (Unsuccessful ones use set_halt.)
464 is_ep0 = (ep->ep.name == ep0name);
468 if (!udc->req_pending) {
474 * defer changing CONFG until after the gadget driver
475 * reconfigures the endpoints.
477 if (udc->wait_for_config_ack) {
478 tmp = at91_udp_read(udc, AT91_UDP_GLB_STAT);
479 tmp ^= AT91_UDP_CONFG;
480 VDBG("toggle config\n");
481 at91_udp_write(udc, AT91_UDP_GLB_STAT, tmp);
483 if (req->req.length == 0) {
485 PACKET("ep0 in/status\n");
487 tmp = __raw_readl(ep->creg);
489 tmp |= CLR_FX | AT91_UDP_TXPKTRDY;
490 __raw_writel(tmp, ep->creg);
491 udc->req_pending = 0;
497 status = write_fifo(ep, req);
499 status = read_fifo(ep, req);
501 /* IN/STATUS stage is otherwise triggered by irq */
502 if (status && is_ep0)
508 if (req && !status) {
509 list_add_tail (&req->queue, &ep->queue);
510 at91_udp_write(udc, AT91_UDP_IER, ep->int_mask);
513 spin_unlock_irqrestore(&udc->lock, flags);
514 return (status < 0) ? status : 0;
517 static int at91_ep_dequeue(struct usb_ep *_ep, struct usb_request *_req)
520 struct at91_request *req;
523 ep = container_of(_ep, struct at91_ep, ep);
524 if (!_ep || ep->ep.name == ep0name)
527 spin_lock_irqsave(&udc->lock, flags);
529 /* make sure it's actually queued on this endpoint */
530 list_for_each_entry (req, &ep->queue, queue) {
531 if (&req->req == _req)
534 if (&req->req != _req) {
535 spin_unlock_irqrestore(&udc->lock, flags);
539 done(ep, req, -ECONNRESET);
540 spin_unlock_irqrestore(&udc->lock, flags);
544 static int at91_ep_set_halt(struct usb_ep *_ep, int value)
546 struct at91_ep *ep = container_of(_ep, struct at91_ep, ep);
547 struct at91_udc *udc = ep->udc;
553 if (!_ep || ep->is_iso || !ep->udc->clocked)
557 spin_lock_irqsave(&udc->lock, flags);
559 csr = __raw_readl(creg);
562 * fail with still-busy IN endpoints, ensuring correct sequencing
563 * of data tx then stall. note that the fifo rx bytecount isn't
564 * completely accurate as a tx bytecount.
566 if (ep->is_in && (!list_empty(&ep->queue) || (csr >> 16) != 0))
572 csr |= AT91_UDP_FORCESTALL;
573 VDBG("halt %s\n", ep->ep.name);
575 at91_udp_write(udc, AT91_UDP_RST_EP, ep->int_mask);
576 at91_udp_write(udc, AT91_UDP_RST_EP, 0);
577 csr &= ~AT91_UDP_FORCESTALL;
579 __raw_writel(csr, creg);
582 spin_unlock_irqrestore(&udc->lock, flags);
586 static const struct usb_ep_ops at91_ep_ops = {
587 .enable = at91_ep_enable,
588 .disable = at91_ep_disable,
589 .alloc_request = at91_ep_alloc_request,
590 .free_request = at91_ep_free_request,
591 .queue = at91_ep_queue,
592 .dequeue = at91_ep_dequeue,
593 .set_halt = at91_ep_set_halt,
594 /* there's only imprecise fifo status reporting */
597 /*-------------------------------------------------------------------------*/
599 static int at91_get_frame(struct usb_gadget *gadget)
601 struct at91_udc *udc = to_udc(gadget);
603 if (!to_udc(gadget)->clocked)
605 return at91_udp_read(udc, AT91_UDP_FRM_NUM) & AT91_UDP_NUM;
608 static int at91_wakeup(struct usb_gadget *gadget)
610 struct at91_udc *udc = to_udc(gadget);
612 int status = -EINVAL;
615 DBG("%s\n", __func__ );
616 spin_lock_irqsave(&udc->lock, flags);
618 if (!udc->clocked || !udc->suspended)
621 /* NOTE: some "early versions" handle ESR differently ... */
623 glbstate = at91_udp_read(udc, AT91_UDP_GLB_STAT);
624 if (!(glbstate & AT91_UDP_ESR))
626 glbstate |= AT91_UDP_ESR;
627 at91_udp_write(udc, AT91_UDP_GLB_STAT, glbstate);
630 spin_unlock_irqrestore(&udc->lock, flags);
634 /* reinit == restore initial software state */
635 static void udc_reinit(struct at91_udc *udc)
639 INIT_LIST_HEAD(&udc->gadget.ep_list);
640 INIT_LIST_HEAD(&udc->gadget.ep0->ep_list);
642 for (i = 0; i < NUM_ENDPOINTS; i++) {
643 struct at91_ep *ep = &udc->ep[i];
646 list_add_tail(&ep->ep.ep_list, &udc->gadget.ep_list);
650 usb_ep_set_maxpacket_limit(&ep->ep, ep->maxpacket);
651 ep->creg = (void __iomem *) udc->udp_baseaddr + AT91_UDP_CSR(i);
652 /* initialize one queue per endpoint */
653 INIT_LIST_HEAD(&ep->queue);
657 static void reset_gadget(struct at91_udc *udc)
659 struct usb_gadget_driver *driver = udc->driver;
662 if (udc->gadget.speed == USB_SPEED_UNKNOWN)
664 udc->gadget.speed = USB_SPEED_UNKNOWN;
667 for (i = 0; i < NUM_ENDPOINTS; i++) {
668 struct at91_ep *ep = &udc->ep[i];
671 nuke(ep, -ESHUTDOWN);
674 spin_unlock(&udc->lock);
675 udc->driver->disconnect(&udc->gadget);
676 spin_lock(&udc->lock);
682 static void stop_activity(struct at91_udc *udc)
684 struct usb_gadget_driver *driver = udc->driver;
687 if (udc->gadget.speed == USB_SPEED_UNKNOWN)
689 udc->gadget.speed = USB_SPEED_UNKNOWN;
692 for (i = 0; i < NUM_ENDPOINTS; i++) {
693 struct at91_ep *ep = &udc->ep[i];
695 nuke(ep, -ESHUTDOWN);
698 spin_unlock(&udc->lock);
699 driver->disconnect(&udc->gadget);
700 spin_lock(&udc->lock);
706 static void clk_on(struct at91_udc *udc)
713 static void clk_off(struct at91_udc *udc)
718 udc->gadget.speed = USB_SPEED_UNKNOWN;
722 * activate/deactivate link with host; minimize power usage for
723 * inactive links by cutting clocks and transceiver power.
725 static void pullup(struct at91_udc *udc, int is_on)
727 if (!udc->enabled || !udc->vbus)
729 DBG("%sactive\n", is_on ? "" : "in");
733 at91_udp_write(udc, AT91_UDP_ICR, AT91_UDP_RXRSM);
734 at91_udp_write(udc, AT91_UDP_TXVC, 0);
737 at91_udp_write(udc, AT91_UDP_IDR, AT91_UDP_RXRSM);
738 at91_udp_write(udc, AT91_UDP_TXVC, AT91_UDP_TXVC_TXVDIS);
742 if (udc->caps && udc->caps->pullup)
743 udc->caps->pullup(udc, is_on);
746 /* vbus is here! turn everything on that's ready */
747 static int at91_vbus_session(struct usb_gadget *gadget, int is_active)
749 struct at91_udc *udc = to_udc(gadget);
752 /* VDBG("vbus %s\n", is_active ? "on" : "off"); */
753 spin_lock_irqsave(&udc->lock, flags);
754 udc->vbus = (is_active != 0);
756 pullup(udc, is_active);
759 spin_unlock_irqrestore(&udc->lock, flags);
763 static int at91_pullup(struct usb_gadget *gadget, int is_on)
765 struct at91_udc *udc = to_udc(gadget);
768 spin_lock_irqsave(&udc->lock, flags);
769 udc->enabled = is_on = !!is_on;
771 spin_unlock_irqrestore(&udc->lock, flags);
775 static int at91_set_selfpowered(struct usb_gadget *gadget, int is_on)
777 struct at91_udc *udc = to_udc(gadget);
780 spin_lock_irqsave(&udc->lock, flags);
781 udc->selfpowered = (is_on != 0);
782 spin_unlock_irqrestore(&udc->lock, flags);
786 static int at91_start(struct usb_gadget *gadget,
787 struct usb_gadget_driver *driver);
788 static int at91_stop(struct usb_gadget *gadget);
790 static const struct usb_gadget_ops at91_udc_ops = {
791 .get_frame = at91_get_frame,
792 .wakeup = at91_wakeup,
793 .set_selfpowered = at91_set_selfpowered,
794 .vbus_session = at91_vbus_session,
795 .pullup = at91_pullup,
796 .udc_start = at91_start,
797 .udc_stop = at91_stop,
800 * VBUS-powered devices may also also want to support bigger
801 * power budgets after an appropriate SET_CONFIGURATION.
803 /* .vbus_power = at91_vbus_power, */
806 /*-------------------------------------------------------------------------*/
808 static int handle_ep(struct at91_ep *ep)
810 struct at91_request *req;
811 u32 __iomem *creg = ep->creg;
812 u32 csr = __raw_readl(creg);
814 if (!list_empty(&ep->queue))
815 req = list_entry(ep->queue.next,
816 struct at91_request, queue);
821 if (csr & (AT91_UDP_STALLSENT | AT91_UDP_TXCOMP)) {
823 csr &= ~(SET_FX | AT91_UDP_STALLSENT | AT91_UDP_TXCOMP);
824 __raw_writel(csr, creg);
827 return write_fifo(ep, req);
830 if (csr & AT91_UDP_STALLSENT) {
831 /* STALLSENT bit == ISOERR */
832 if (ep->is_iso && req)
833 req->req.status = -EILSEQ;
835 csr &= ~(SET_FX | AT91_UDP_STALLSENT);
836 __raw_writel(csr, creg);
837 csr = __raw_readl(creg);
839 if (req && (csr & RX_DATA_READY))
840 return read_fifo(ep, req);
847 struct usb_ctrlrequest r;
850 static void handle_setup(struct at91_udc *udc, struct at91_ep *ep, u32 csr)
852 u32 __iomem *creg = ep->creg;
853 u8 __iomem *dreg = ep->creg + (AT91_UDP_FDR(0) - AT91_UDP_CSR(0));
854 unsigned rxcount, i = 0;
859 /* read and ack SETUP; hard-fail for bogus packets */
860 rxcount = (csr & AT91_UDP_RXBYTECNT) >> 16;
861 if (likely(rxcount == 8)) {
863 pkt.raw[i++] = __raw_readb(dreg);
864 if (pkt.r.bRequestType & USB_DIR_IN) {
868 csr &= ~AT91_UDP_DIR;
872 /* REVISIT this happens sometimes under load; why?? */
873 ERR("SETUP len %d, csr %08x\n", rxcount, csr);
877 csr &= ~(SET_FX | AT91_UDP_RXSETUP);
878 __raw_writel(csr, creg);
879 udc->wait_for_addr_ack = 0;
880 udc->wait_for_config_ack = 0;
882 if (unlikely(status != 0))
885 #define w_index le16_to_cpu(pkt.r.wIndex)
886 #define w_value le16_to_cpu(pkt.r.wValue)
887 #define w_length le16_to_cpu(pkt.r.wLength)
889 VDBG("SETUP %02x.%02x v%04x i%04x l%04x\n",
890 pkt.r.bRequestType, pkt.r.bRequest,
891 w_value, w_index, w_length);
894 * A few standard requests get handled here, ones that touch
895 * hardware ... notably for device and endpoint features.
897 udc->req_pending = 1;
898 csr = __raw_readl(creg);
901 switch ((pkt.r.bRequestType << 8) | pkt.r.bRequest) {
903 case ((USB_TYPE_STANDARD|USB_RECIP_DEVICE) << 8)
904 | USB_REQ_SET_ADDRESS:
905 __raw_writel(csr | AT91_UDP_TXPKTRDY, creg);
907 udc->wait_for_addr_ack = 1;
908 udc->req_pending = 0;
909 /* FADDR is set later, when we ack host STATUS */
912 case ((USB_TYPE_STANDARD|USB_RECIP_DEVICE) << 8)
913 | USB_REQ_SET_CONFIGURATION:
914 tmp = at91_udp_read(udc, AT91_UDP_GLB_STAT) & AT91_UDP_CONFG;
916 udc->wait_for_config_ack = (tmp == 0);
918 udc->wait_for_config_ack = (tmp != 0);
919 if (udc->wait_for_config_ack)
920 VDBG("wait for config\n");
921 /* CONFG is toggled later, if gadget driver succeeds */
925 * Hosts may set or clear remote wakeup status, and
926 * devices may report they're VBUS powered.
928 case ((USB_DIR_IN|USB_TYPE_STANDARD|USB_RECIP_DEVICE) << 8)
929 | USB_REQ_GET_STATUS:
930 tmp = (udc->selfpowered << USB_DEVICE_SELF_POWERED);
931 if (at91_udp_read(udc, AT91_UDP_GLB_STAT) & AT91_UDP_ESR)
932 tmp |= (1 << USB_DEVICE_REMOTE_WAKEUP);
933 PACKET("get device status\n");
934 __raw_writeb(tmp, dreg);
935 __raw_writeb(0, dreg);
937 /* then STATUS starts later, automatically */
938 case ((USB_TYPE_STANDARD|USB_RECIP_DEVICE) << 8)
939 | USB_REQ_SET_FEATURE:
940 if (w_value != USB_DEVICE_REMOTE_WAKEUP)
942 tmp = at91_udp_read(udc, AT91_UDP_GLB_STAT);
944 at91_udp_write(udc, AT91_UDP_GLB_STAT, tmp);
946 case ((USB_TYPE_STANDARD|USB_RECIP_DEVICE) << 8)
947 | USB_REQ_CLEAR_FEATURE:
948 if (w_value != USB_DEVICE_REMOTE_WAKEUP)
950 tmp = at91_udp_read(udc, AT91_UDP_GLB_STAT);
951 tmp &= ~AT91_UDP_ESR;
952 at91_udp_write(udc, AT91_UDP_GLB_STAT, tmp);
956 * Interfaces have no feature settings; this is pretty useless.
957 * we won't even insist the interface exists...
959 case ((USB_DIR_IN|USB_TYPE_STANDARD|USB_RECIP_INTERFACE) << 8)
960 | USB_REQ_GET_STATUS:
961 PACKET("get interface status\n");
962 __raw_writeb(0, dreg);
963 __raw_writeb(0, dreg);
965 /* then STATUS starts later, automatically */
966 case ((USB_TYPE_STANDARD|USB_RECIP_INTERFACE) << 8)
967 | USB_REQ_SET_FEATURE:
968 case ((USB_TYPE_STANDARD|USB_RECIP_INTERFACE) << 8)
969 | USB_REQ_CLEAR_FEATURE:
973 * Hosts may clear bulk/intr endpoint halt after the gadget
974 * driver sets it (not widely used); or set it (for testing)
976 case ((USB_DIR_IN|USB_TYPE_STANDARD|USB_RECIP_ENDPOINT) << 8)
977 | USB_REQ_GET_STATUS:
978 tmp = w_index & USB_ENDPOINT_NUMBER_MASK;
980 if (tmp >= NUM_ENDPOINTS || (tmp && !ep->ep.desc))
984 if ((w_index & USB_DIR_IN)) {
987 } else if (ep->is_in)
990 PACKET("get %s status\n", ep->ep.name);
991 if (__raw_readl(ep->creg) & AT91_UDP_FORCESTALL)
992 tmp = (1 << USB_ENDPOINT_HALT);
995 __raw_writeb(tmp, dreg);
996 __raw_writeb(0, dreg);
998 /* then STATUS starts later, automatically */
999 case ((USB_TYPE_STANDARD|USB_RECIP_ENDPOINT) << 8)
1000 | USB_REQ_SET_FEATURE:
1001 tmp = w_index & USB_ENDPOINT_NUMBER_MASK;
1003 if (w_value != USB_ENDPOINT_HALT || tmp >= NUM_ENDPOINTS)
1005 if (!ep->ep.desc || ep->is_iso)
1007 if ((w_index & USB_DIR_IN)) {
1010 } else if (ep->is_in)
1013 tmp = __raw_readl(ep->creg);
1015 tmp |= CLR_FX | AT91_UDP_FORCESTALL;
1016 __raw_writel(tmp, ep->creg);
1018 case ((USB_TYPE_STANDARD|USB_RECIP_ENDPOINT) << 8)
1019 | USB_REQ_CLEAR_FEATURE:
1020 tmp = w_index & USB_ENDPOINT_NUMBER_MASK;
1022 if (w_value != USB_ENDPOINT_HALT || tmp >= NUM_ENDPOINTS)
1026 if (!ep->ep.desc || ep->is_iso)
1028 if ((w_index & USB_DIR_IN)) {
1031 } else if (ep->is_in)
1034 at91_udp_write(udc, AT91_UDP_RST_EP, ep->int_mask);
1035 at91_udp_write(udc, AT91_UDP_RST_EP, 0);
1036 tmp = __raw_readl(ep->creg);
1038 tmp &= ~(SET_FX | AT91_UDP_FORCESTALL);
1039 __raw_writel(tmp, ep->creg);
1040 if (!list_empty(&ep->queue))
1049 /* pass request up to the gadget driver */
1051 spin_unlock(&udc->lock);
1052 status = udc->driver->setup(&udc->gadget, &pkt.r);
1053 spin_lock(&udc->lock);
1059 VDBG("req %02x.%02x protocol STALL; stat %d\n",
1060 pkt.r.bRequestType, pkt.r.bRequest, status);
1061 csr |= AT91_UDP_FORCESTALL;
1062 __raw_writel(csr, creg);
1063 udc->req_pending = 0;
1068 /* immediate successful (IN) STATUS after zero length DATA */
1069 PACKET("ep0 in/status\n");
1071 csr |= AT91_UDP_TXPKTRDY;
1072 __raw_writel(csr, creg);
1073 udc->req_pending = 0;
1076 static void handle_ep0(struct at91_udc *udc)
1078 struct at91_ep *ep0 = &udc->ep[0];
1079 u32 __iomem *creg = ep0->creg;
1080 u32 csr = __raw_readl(creg);
1081 struct at91_request *req;
1083 if (unlikely(csr & AT91_UDP_STALLSENT)) {
1085 udc->req_pending = 0;
1087 csr &= ~(SET_FX | AT91_UDP_STALLSENT | AT91_UDP_FORCESTALL);
1088 __raw_writel(csr, creg);
1089 VDBG("ep0 stalled\n");
1090 csr = __raw_readl(creg);
1092 if (csr & AT91_UDP_RXSETUP) {
1094 udc->req_pending = 0;
1095 handle_setup(udc, ep0, csr);
1099 if (list_empty(&ep0->queue))
1102 req = list_entry(ep0->queue.next, struct at91_request, queue);
1104 /* host ACKed an IN packet that we sent */
1105 if (csr & AT91_UDP_TXCOMP) {
1107 csr &= ~(SET_FX | AT91_UDP_TXCOMP);
1109 /* write more IN DATA? */
1110 if (req && ep0->is_in) {
1112 udc->req_pending = 0;
1116 * - last IN DATA packet (including GET_STATUS)
1117 * - IN/STATUS for OUT DATA
1118 * - IN/STATUS for any zero-length DATA stage
1119 * except for the IN DATA case, the host should send
1120 * an OUT status later, which we'll ack.
1123 udc->req_pending = 0;
1124 __raw_writel(csr, creg);
1127 * SET_ADDRESS takes effect only after the STATUS
1128 * (to the original address) gets acked.
1130 if (udc->wait_for_addr_ack) {
1133 at91_udp_write(udc, AT91_UDP_FADDR,
1134 AT91_UDP_FEN | udc->addr);
1135 tmp = at91_udp_read(udc, AT91_UDP_GLB_STAT);
1136 tmp &= ~AT91_UDP_FADDEN;
1138 tmp |= AT91_UDP_FADDEN;
1139 at91_udp_write(udc, AT91_UDP_GLB_STAT, tmp);
1141 udc->wait_for_addr_ack = 0;
1142 VDBG("address %d\n", udc->addr);
1147 /* OUT packet arrived ... */
1148 else if (csr & AT91_UDP_RX_DATA_BK0) {
1150 csr &= ~(SET_FX | AT91_UDP_RX_DATA_BK0);
1152 /* OUT DATA stage */
1155 if (handle_ep(ep0)) {
1156 /* send IN/STATUS */
1157 PACKET("ep0 in/status\n");
1158 csr = __raw_readl(creg);
1160 csr |= CLR_FX | AT91_UDP_TXPKTRDY;
1161 __raw_writel(csr, creg);
1162 udc->req_pending = 0;
1164 } else if (udc->req_pending) {
1166 * AT91 hardware has a hard time with this
1167 * "deferred response" mode for control-OUT
1168 * transfers. (For control-IN it's fine.)
1170 * The normal solution leaves OUT data in the
1171 * fifo until the gadget driver is ready.
1172 * We couldn't do that here without disabling
1173 * the IRQ that tells about SETUP packets,
1174 * e.g. when the host gets impatient...
1176 * Working around it by copying into a buffer
1177 * would almost be a non-deferred response,
1178 * except that it wouldn't permit reliable
1179 * stalling of the request. Instead, demand
1180 * that gadget drivers not use this mode.
1182 DBG("no control-OUT deferred responses!\n");
1183 __raw_writel(csr | AT91_UDP_FORCESTALL, creg);
1184 udc->req_pending = 0;
1187 /* STATUS stage for control-IN; ack. */
1189 PACKET("ep0 out/status ACK\n");
1190 __raw_writel(csr, creg);
1192 /* "early" status stage */
1199 static irqreturn_t at91_udc_irq(struct at91_udc *udc)
1202 int disable_clock = 0;
1203 unsigned long flags;
1205 spin_lock_irqsave(&udc->lock, flags);
1207 if (!udc->clocked) {
1215 status = at91_udp_read(udc, AT91_UDP_ISR)
1216 & at91_udp_read(udc, AT91_UDP_IMR);
1220 /* USB reset irq: not maskable */
1221 if (status & AT91_UDP_ENDBUSRES) {
1222 at91_udp_write(udc, AT91_UDP_IDR, ~MINIMUS_INTERRUPTUS);
1223 at91_udp_write(udc, AT91_UDP_IER, MINIMUS_INTERRUPTUS);
1224 /* Atmel code clears this irq twice */
1225 at91_udp_write(udc, AT91_UDP_ICR, AT91_UDP_ENDBUSRES);
1226 at91_udp_write(udc, AT91_UDP_ICR, AT91_UDP_ENDBUSRES);
1227 VDBG("end bus reset\n");
1232 at91_udp_write(udc, AT91_UDP_CSR(0),
1233 AT91_UDP_EPEDS | AT91_UDP_EPTYPE_CTRL);
1234 udc->gadget.speed = USB_SPEED_FULL;
1236 at91_udp_write(udc, AT91_UDP_IER, AT91_UDP_EP(0));
1239 * NOTE: this driver keeps clocks off unless the
1240 * USB host is present. That saves power, but for
1241 * boards that don't support VBUS detection, both
1242 * clocks need to be active most of the time.
1245 /* host initiated suspend (3+ms bus idle) */
1246 } else if (status & AT91_UDP_RXSUSP) {
1247 at91_udp_write(udc, AT91_UDP_IDR, AT91_UDP_RXSUSP);
1248 at91_udp_write(udc, AT91_UDP_IER, AT91_UDP_RXRSM);
1249 at91_udp_write(udc, AT91_UDP_ICR, AT91_UDP_RXSUSP);
1250 /* VDBG("bus suspend\n"); */
1256 * NOTE: when suspending a VBUS-powered device, the
1257 * gadget driver should switch into slow clock mode
1258 * and then into standby to avoid drawing more than
1259 * 500uA power (2500uA for some high-power configs).
1261 if (udc->driver && udc->driver->suspend) {
1262 spin_unlock(&udc->lock);
1263 udc->driver->suspend(&udc->gadget);
1264 spin_lock(&udc->lock);
1267 /* host initiated resume */
1268 } else if (status & AT91_UDP_RXRSM) {
1269 at91_udp_write(udc, AT91_UDP_IDR, AT91_UDP_RXRSM);
1270 at91_udp_write(udc, AT91_UDP_IER, AT91_UDP_RXSUSP);
1271 at91_udp_write(udc, AT91_UDP_ICR, AT91_UDP_RXRSM);
1272 /* VDBG("bus resume\n"); */
1273 if (!udc->suspended)
1278 * NOTE: for a VBUS-powered device, the gadget driver
1279 * would normally want to switch out of slow clock
1280 * mode into normal mode.
1282 if (udc->driver && udc->driver->resume) {
1283 spin_unlock(&udc->lock);
1284 udc->driver->resume(&udc->gadget);
1285 spin_lock(&udc->lock);
1288 /* endpoint IRQs are cleared by handling them */
1292 struct at91_ep *ep = &udc->ep[1];
1296 for (i = 1; i < NUM_ENDPOINTS; i++) {
1308 spin_unlock_irqrestore(&udc->lock, flags);
1313 /*-------------------------------------------------------------------------*/
1315 static int at91_start(struct usb_gadget *gadget,
1316 struct usb_gadget_driver *driver)
1318 struct at91_udc *udc = controller;
1320 udc->driver = driver;
1322 udc->selfpowered = 1;
1327 static int at91_stop(struct usb_gadget *gadget)
1329 struct at91_udc *udc = controller;
1330 unsigned long flags;
1332 spin_lock_irqsave(&udc->lock, flags);
1334 at91_udp_write(udc, AT91_UDP_IDR, ~0);
1335 spin_unlock_irqrestore(&udc->lock, flags);
1342 /*-------------------------------------------------------------------------*/
1344 static int at91rm9200_udc_init(struct at91_udc *udc)
1350 for (i = 0; i < NUM_ENDPOINTS; i++) {
1362 ep->maxpacket = 256;
1367 ret = gpio_request(udc->board.pullup_pin, "udc_pullup");
1369 DBG("D+ pullup is busy\n");
1373 gpio_direction_output(udc->board.pullup_pin,
1374 udc->board.pullup_active_low);
1379 static void at91rm9200_udc_pullup(struct at91_udc *udc, int is_on)
1381 int active = !udc->board.pullup_active_low;
1384 gpio_set_value(udc->board.pullup_pin, active);
1386 gpio_set_value(udc->board.pullup_pin, !active);
1389 static const struct at91_udc_caps at91rm9200_udc_caps = {
1390 .init = at91rm9200_udc_init,
1391 .pullup = at91rm9200_udc_pullup,
1394 static int at91sam9260_udc_init(struct at91_udc *udc)
1399 for (i = 0; i < NUM_ENDPOINTS; i++) {
1407 ep->maxpacket = 512;
1415 #if defined(CONFIG_AT91SAM9260) || defined(CONFIG_AT91SAM9G20)
1416 static void at91sam9260_udc_pullup(struct at91_udc *udc, int is_on)
1418 u32 txvc = at91_udp_read(udc, AT91_UDP_TXVC);
1421 txvc |= AT91_UDP_TXVC_PUON;
1423 txvc &= ~AT91_UDP_TXVC_PUON;
1425 at91_udp_write(udc, AT91_UDP_TXVC, txvc);
1428 static const struct at91_udc_caps at91sam9260_udc_caps = {
1429 .init = at91sam9260_udc_init,
1430 .pullup = at91sam9260_udc_pullup,
1434 #if defined(CONFIG_AT91SAM9261)
1435 static int at91sam9261_udc_init(struct at91_udc *udc)
1440 for (i = 0; i < NUM_ENDPOINTS; i++) {
1451 ep->maxpacket = 256;
1456 udc->matrix = (struct at91_matrix *)ATMEL_BASE_MATRIX;
1458 if (IS_ERR(udc->matrix))
1459 return PTR_ERR(udc->matrix);
1464 static void at91sam9261_udc_pullup(struct at91_udc *udc, int is_on)
1468 usbpucr = readl(&udc->matrix->pucr);
1470 usbpucr |= AT91_MATRIX_USBPUCR_PUON;
1472 writel(usbpucr, &udc->matrix->pucr);
1475 static const struct at91_udc_caps at91sam9261_udc_caps = {
1476 .init = at91sam9261_udc_init,
1477 .pullup = at91sam9261_udc_pullup,
1481 static int at91sam9263_udc_init(struct at91_udc *udc)
1486 for (i = 0; i < NUM_ENDPOINTS; i++) {
1498 ep->maxpacket = 256;
1506 static const struct at91_udc_caps at91sam9263_udc_caps = {
1507 .init = at91sam9263_udc_init,
1508 .pullup = at91sam9260_udc_pullup,
1511 int usb_gadget_handle_interrupts(int index)
1513 struct at91_udc *udc = controller;
1515 return at91_udc_irq(udc);
1518 int usb_gadget_register_driver(struct usb_gadget_driver *driver)
1520 struct at91_udc *udc = controller;
1523 if (!driver || !driver->bind || !driver->setup) {
1524 printf("bad paramter\n");
1529 printf("UDC already has a gadget driver\n");
1533 at91_start(&udc->gadget, driver);
1535 udc->driver = driver;
1537 ret = driver->bind(&udc->gadget);
1539 error("driver->bind() returned %d\n", ret);
1546 int usb_gadget_unregister_driver(struct usb_gadget_driver *driver)
1548 struct at91_udc *udc = controller;
1550 if (!driver || !driver->unbind || !driver->disconnect) {
1551 error("bad paramter\n");
1555 driver->disconnect(&udc->gadget);
1556 driver->unbind(&udc->gadget);
1559 at91_stop(&udc->gadget);
1564 int at91_udc_probe(struct at91_udc_data *pdata)
1566 struct at91_udc *udc;
1571 udc = kzalloc(sizeof(*udc), GFP_KERNEL);
1576 memcpy(&udc->board, pdata, sizeof(struct at91_udc_data));
1577 if (udc->board.vbus_pin) {
1578 printf("%s: gpio vbus pin not supported yet.\n", __func__);
1581 DBG("no VBUS detection, assuming always-on\n");
1585 #if defined(CONFIG_AT91SAM9260) || defined(CONFIG_AT91SAM9G20)
1586 udc->caps = &at91sam9260_udc_caps;
1590 spin_lock_init(&udc->lock);
1592 udc->gadget.ops = &at91_udc_ops;
1593 udc->gadget.ep0 = &udc->ep[0].ep;
1594 udc->gadget.name = driver_name;
1596 for (i = 0; i < NUM_ENDPOINTS; i++) {
1598 ep->ep.name = ep_names[i];
1599 ep->ep.ops = &at91_ep_ops;
1601 ep->int_mask = (1 << i);
1602 if (i != 0 && i != 3)
1603 ep->is_pingpong = 1;
1606 udc->udp_baseaddr = (void *)udc->board.baseaddr;
1607 if (IS_ERR(udc->udp_baseaddr))
1608 return PTR_ERR(udc->udp_baseaddr);
1610 if (udc->caps && udc->caps->init) {
1611 retval = udc->caps->init(udc);
1618 at91_udp_write(udc, AT91_UDP_TXVC, AT91_UDP_TXVC_TXVDIS);
1619 at91_udp_write(udc, AT91_UDP_IDR, 0xffffffff);
1620 /* Clear all pending interrupts - UDP may be used by bootloader. */
1621 at91_udp_write(udc, AT91_UDP_ICR, 0xffffffff);
1623 INFO("%s version %s\n", driver_name, DRIVER_VERSION);