1*83d290c5STom Rini // SPDX-License-Identifier: GPL-2.0+
28ea1fbf7SHeiko Schocher /*
362019767SHeiko Schocher * from linux:
462019767SHeiko Schocher * c94e289f195e: usb: gadget: remove incorrect __init/__exit annotations
562019767SHeiko Schocher *
68ea1fbf7SHeiko Schocher * at91_udc -- driver for at91-series USB peripheral controller
78ea1fbf7SHeiko Schocher *
88ea1fbf7SHeiko Schocher * Copyright (C) 2004 by Thomas Rathbone
98ea1fbf7SHeiko Schocher * Copyright (C) 2005 by HP Labs
108ea1fbf7SHeiko Schocher * Copyright (C) 2005 by David Brownell
118ea1fbf7SHeiko Schocher */
128ea1fbf7SHeiko Schocher
138ea1fbf7SHeiko Schocher #undef VERBOSE_DEBUG
148ea1fbf7SHeiko Schocher #undef PACKET_TRACE
158ea1fbf7SHeiko Schocher
1662019767SHeiko Schocher #include <common.h>
171221ce45SMasahiro Yamada #include <linux/errno.h>
1862019767SHeiko Schocher #include <asm/io.h>
1962019767SHeiko Schocher #include <asm/gpio.h>
2062019767SHeiko Schocher #include <asm/hardware.h>
2162019767SHeiko Schocher #include <mach/at91_matrix.h>
228ea1fbf7SHeiko Schocher #include <linux/list.h>
238ea1fbf7SHeiko Schocher #include <linux/usb/ch9.h>
248ea1fbf7SHeiko Schocher #include <linux/usb/gadget.h>
2562019767SHeiko Schocher #include <linux/usb/at91_udc.h>
2662019767SHeiko Schocher #include <malloc.h>
278ea1fbf7SHeiko Schocher
288ea1fbf7SHeiko Schocher #include "at91_udc.h"
298ea1fbf7SHeiko Schocher
308ea1fbf7SHeiko Schocher /*
318ea1fbf7SHeiko Schocher * This controller is simple and PIO-only. It's used in many AT91-series
328ea1fbf7SHeiko Schocher * full speed USB controllers, including the at91rm9200 (arm920T, with MMU),
338ea1fbf7SHeiko Schocher * at91sam926x (arm926ejs, with MMU), and several no-mmu versions.
348ea1fbf7SHeiko Schocher *
358ea1fbf7SHeiko Schocher * This driver expects the board has been wired with two GPIOs supporting
368ea1fbf7SHeiko Schocher * a VBUS sensing IRQ, and a D+ pullup. (They may be omitted, but the
378ea1fbf7SHeiko Schocher * testing hasn't covered such cases.)
388ea1fbf7SHeiko Schocher *
398ea1fbf7SHeiko Schocher * The pullup is most important (so it's integrated on sam926x parts). It
408ea1fbf7SHeiko Schocher * provides software control over whether the host enumerates the device.
418ea1fbf7SHeiko Schocher *
428ea1fbf7SHeiko Schocher * The VBUS sensing helps during enumeration, and allows both USB clocks
438ea1fbf7SHeiko Schocher * (and the transceiver) to stay gated off until they're necessary, saving
448ea1fbf7SHeiko Schocher * power. During USB suspend, the 48 MHz clock is gated off in hardware;
458ea1fbf7SHeiko Schocher * it may also be gated off by software during some Linux sleep states.
468ea1fbf7SHeiko Schocher */
478ea1fbf7SHeiko Schocher
488ea1fbf7SHeiko Schocher #define DRIVER_VERSION "3 May 2006"
498ea1fbf7SHeiko Schocher
508ea1fbf7SHeiko Schocher static const char driver_name [] = "at91_udc";
518ea1fbf7SHeiko Schocher static const char * const ep_names[] = {
528ea1fbf7SHeiko Schocher "ep0",
538ea1fbf7SHeiko Schocher "ep1",
548ea1fbf7SHeiko Schocher "ep2",
558ea1fbf7SHeiko Schocher "ep3-int",
568ea1fbf7SHeiko Schocher "ep4",
578ea1fbf7SHeiko Schocher "ep5",
588ea1fbf7SHeiko Schocher };
598ea1fbf7SHeiko Schocher #define ep0name ep_names[0]
608ea1fbf7SHeiko Schocher
618ea1fbf7SHeiko Schocher #define at91_udp_read(udc, reg) \
628ea1fbf7SHeiko Schocher __raw_readl((udc)->udp_baseaddr + (reg))
638ea1fbf7SHeiko Schocher #define at91_udp_write(udc, reg, val) \
648ea1fbf7SHeiko Schocher __raw_writel((val), (udc)->udp_baseaddr + (reg))
658ea1fbf7SHeiko Schocher
6662019767SHeiko Schocher static struct at91_udc *controller;
678ea1fbf7SHeiko Schocher
688ea1fbf7SHeiko Schocher /*-------------------------------------------------------------------------*/
698ea1fbf7SHeiko Schocher
done(struct at91_ep * ep,struct at91_request * req,int status)708ea1fbf7SHeiko Schocher static void done(struct at91_ep *ep, struct at91_request *req, int status)
718ea1fbf7SHeiko Schocher {
728ea1fbf7SHeiko Schocher unsigned stopped = ep->stopped;
738ea1fbf7SHeiko Schocher struct at91_udc *udc = ep->udc;
748ea1fbf7SHeiko Schocher
758ea1fbf7SHeiko Schocher list_del_init(&req->queue);
768ea1fbf7SHeiko Schocher if (req->req.status == -EINPROGRESS)
778ea1fbf7SHeiko Schocher req->req.status = status;
788ea1fbf7SHeiko Schocher else
798ea1fbf7SHeiko Schocher status = req->req.status;
808ea1fbf7SHeiko Schocher if (status && status != -ESHUTDOWN)
818ea1fbf7SHeiko Schocher VDBG("%s done %p, status %d\n", ep->ep.name, req, status);
828ea1fbf7SHeiko Schocher
838ea1fbf7SHeiko Schocher ep->stopped = 1;
848ea1fbf7SHeiko Schocher spin_unlock(&udc->lock);
8562019767SHeiko Schocher req->req.complete(&ep->ep, &req->req);
868ea1fbf7SHeiko Schocher spin_lock(&udc->lock);
878ea1fbf7SHeiko Schocher ep->stopped = stopped;
888ea1fbf7SHeiko Schocher
898ea1fbf7SHeiko Schocher /* ep0 is always ready; other endpoints need a non-empty queue */
908ea1fbf7SHeiko Schocher if (list_empty(&ep->queue) && ep->int_mask != (1 << 0))
918ea1fbf7SHeiko Schocher at91_udp_write(udc, AT91_UDP_IDR, ep->int_mask);
928ea1fbf7SHeiko Schocher }
938ea1fbf7SHeiko Schocher
948ea1fbf7SHeiko Schocher /*-------------------------------------------------------------------------*/
958ea1fbf7SHeiko Schocher
968ea1fbf7SHeiko Schocher /* bits indicating OUT fifo has data ready */
978ea1fbf7SHeiko Schocher #define RX_DATA_READY (AT91_UDP_RX_DATA_BK0 | AT91_UDP_RX_DATA_BK1)
988ea1fbf7SHeiko Schocher
998ea1fbf7SHeiko Schocher /*
1008ea1fbf7SHeiko Schocher * Endpoint FIFO CSR bits have a mix of bits, making it unsafe to just write
1018ea1fbf7SHeiko Schocher * back most of the value you just read (because of side effects, including
1028ea1fbf7SHeiko Schocher * bits that may change after reading and before writing).
1038ea1fbf7SHeiko Schocher *
1048ea1fbf7SHeiko Schocher * Except when changing a specific bit, always write values which:
1058ea1fbf7SHeiko Schocher * - clear SET_FX bits (setting them could change something)
1068ea1fbf7SHeiko Schocher * - set CLR_FX bits (clearing them could change something)
1078ea1fbf7SHeiko Schocher *
1088ea1fbf7SHeiko Schocher * There are also state bits like FORCESTALL, EPEDS, DIR, and EPTYPE
1098ea1fbf7SHeiko Schocher * that shouldn't normally be changed.
1108ea1fbf7SHeiko Schocher *
1118ea1fbf7SHeiko Schocher * NOTE at91sam9260 docs mention synch between UDPCK and MCK clock domains,
1128ea1fbf7SHeiko Schocher * implying a need to wait for one write to complete (test relevant bits)
1138ea1fbf7SHeiko Schocher * before starting the next write. This shouldn't be an issue given how
1148ea1fbf7SHeiko Schocher * infrequently we write, except maybe for write-then-read idioms.
1158ea1fbf7SHeiko Schocher */
1168ea1fbf7SHeiko Schocher #define SET_FX (AT91_UDP_TXPKTRDY)
1178ea1fbf7SHeiko Schocher #define CLR_FX (RX_DATA_READY | AT91_UDP_RXSETUP \
1188ea1fbf7SHeiko Schocher | AT91_UDP_STALLSENT | AT91_UDP_TXCOMP)
1198ea1fbf7SHeiko Schocher
1208ea1fbf7SHeiko Schocher /* pull OUT packet data from the endpoint's fifo */
read_fifo(struct at91_ep * ep,struct at91_request * req)1218ea1fbf7SHeiko Schocher static int read_fifo (struct at91_ep *ep, struct at91_request *req)
1228ea1fbf7SHeiko Schocher {
1238ea1fbf7SHeiko Schocher u32 __iomem *creg = ep->creg;
1248ea1fbf7SHeiko Schocher u8 __iomem *dreg = ep->creg + (AT91_UDP_FDR(0) - AT91_UDP_CSR(0));
1258ea1fbf7SHeiko Schocher u32 csr;
1268ea1fbf7SHeiko Schocher u8 *buf;
1278ea1fbf7SHeiko Schocher unsigned int count, bufferspace, is_done;
1288ea1fbf7SHeiko Schocher
1298ea1fbf7SHeiko Schocher buf = req->req.buf + req->req.actual;
1308ea1fbf7SHeiko Schocher bufferspace = req->req.length - req->req.actual;
1318ea1fbf7SHeiko Schocher
1328ea1fbf7SHeiko Schocher /*
1338ea1fbf7SHeiko Schocher * there might be nothing to read if ep_queue() calls us,
1348ea1fbf7SHeiko Schocher * or if we already emptied both pingpong buffers
1358ea1fbf7SHeiko Schocher */
1368ea1fbf7SHeiko Schocher rescan:
1378ea1fbf7SHeiko Schocher csr = __raw_readl(creg);
1388ea1fbf7SHeiko Schocher if ((csr & RX_DATA_READY) == 0)
1398ea1fbf7SHeiko Schocher return 0;
1408ea1fbf7SHeiko Schocher
1418ea1fbf7SHeiko Schocher count = (csr & AT91_UDP_RXBYTECNT) >> 16;
1428ea1fbf7SHeiko Schocher if (count > ep->ep.maxpacket)
1438ea1fbf7SHeiko Schocher count = ep->ep.maxpacket;
1448ea1fbf7SHeiko Schocher if (count > bufferspace) {
1458ea1fbf7SHeiko Schocher DBG("%s buffer overflow\n", ep->ep.name);
1468ea1fbf7SHeiko Schocher req->req.status = -EOVERFLOW;
1478ea1fbf7SHeiko Schocher count = bufferspace;
1488ea1fbf7SHeiko Schocher }
14962019767SHeiko Schocher __raw_readsb((unsigned long)dreg, buf, count);
1508ea1fbf7SHeiko Schocher
1518ea1fbf7SHeiko Schocher /* release and swap pingpong mem bank */
1528ea1fbf7SHeiko Schocher csr |= CLR_FX;
1538ea1fbf7SHeiko Schocher if (ep->is_pingpong) {
1548ea1fbf7SHeiko Schocher if (ep->fifo_bank == 0) {
1558ea1fbf7SHeiko Schocher csr &= ~(SET_FX | AT91_UDP_RX_DATA_BK0);
1568ea1fbf7SHeiko Schocher ep->fifo_bank = 1;
1578ea1fbf7SHeiko Schocher } else {
1588ea1fbf7SHeiko Schocher csr &= ~(SET_FX | AT91_UDP_RX_DATA_BK1);
1598ea1fbf7SHeiko Schocher ep->fifo_bank = 0;
1608ea1fbf7SHeiko Schocher }
1618ea1fbf7SHeiko Schocher } else
1628ea1fbf7SHeiko Schocher csr &= ~(SET_FX | AT91_UDP_RX_DATA_BK0);
1638ea1fbf7SHeiko Schocher __raw_writel(csr, creg);
1648ea1fbf7SHeiko Schocher
1658ea1fbf7SHeiko Schocher req->req.actual += count;
1668ea1fbf7SHeiko Schocher is_done = (count < ep->ep.maxpacket);
1678ea1fbf7SHeiko Schocher if (count == bufferspace)
1688ea1fbf7SHeiko Schocher is_done = 1;
1698ea1fbf7SHeiko Schocher
1708ea1fbf7SHeiko Schocher PACKET("%s %p out/%d%s\n", ep->ep.name, &req->req, count,
1718ea1fbf7SHeiko Schocher is_done ? " (done)" : "");
1728ea1fbf7SHeiko Schocher
1738ea1fbf7SHeiko Schocher /*
1748ea1fbf7SHeiko Schocher * avoid extra trips through IRQ logic for packets already in
1758ea1fbf7SHeiko Schocher * the fifo ... maybe preventing an extra (expensive) OUT-NAK
1768ea1fbf7SHeiko Schocher */
1778ea1fbf7SHeiko Schocher if (is_done)
1788ea1fbf7SHeiko Schocher done(ep, req, 0);
1798ea1fbf7SHeiko Schocher else if (ep->is_pingpong) {
1808ea1fbf7SHeiko Schocher /*
1818ea1fbf7SHeiko Schocher * One dummy read to delay the code because of a HW glitch:
1828ea1fbf7SHeiko Schocher * CSR returns bad RXCOUNT when read too soon after updating
1838ea1fbf7SHeiko Schocher * RX_DATA_BK flags.
1848ea1fbf7SHeiko Schocher */
1858ea1fbf7SHeiko Schocher csr = __raw_readl(creg);
1868ea1fbf7SHeiko Schocher
1878ea1fbf7SHeiko Schocher bufferspace -= count;
1888ea1fbf7SHeiko Schocher buf += count;
1898ea1fbf7SHeiko Schocher goto rescan;
1908ea1fbf7SHeiko Schocher }
1918ea1fbf7SHeiko Schocher
1928ea1fbf7SHeiko Schocher return is_done;
1938ea1fbf7SHeiko Schocher }
1948ea1fbf7SHeiko Schocher
1958ea1fbf7SHeiko Schocher /* load fifo for an IN packet */
write_fifo(struct at91_ep * ep,struct at91_request * req)1968ea1fbf7SHeiko Schocher static int write_fifo(struct at91_ep *ep, struct at91_request *req)
1978ea1fbf7SHeiko Schocher {
1988ea1fbf7SHeiko Schocher u32 __iomem *creg = ep->creg;
1998ea1fbf7SHeiko Schocher u32 csr = __raw_readl(creg);
2008ea1fbf7SHeiko Schocher u8 __iomem *dreg = ep->creg + (AT91_UDP_FDR(0) - AT91_UDP_CSR(0));
2018ea1fbf7SHeiko Schocher unsigned total, count, is_last;
2028ea1fbf7SHeiko Schocher u8 *buf;
2038ea1fbf7SHeiko Schocher
2048ea1fbf7SHeiko Schocher /*
2058ea1fbf7SHeiko Schocher * TODO: allow for writing two packets to the fifo ... that'll
2068ea1fbf7SHeiko Schocher * reduce the amount of IN-NAKing, but probably won't affect
2078ea1fbf7SHeiko Schocher * throughput much. (Unlike preventing OUT-NAKing!)
2088ea1fbf7SHeiko Schocher */
2098ea1fbf7SHeiko Schocher
2108ea1fbf7SHeiko Schocher /*
2118ea1fbf7SHeiko Schocher * If ep_queue() calls us, the queue is empty and possibly in
2128ea1fbf7SHeiko Schocher * odd states like TXCOMP not yet cleared (we do it, saving at
2138ea1fbf7SHeiko Schocher * least one IRQ) or the fifo not yet being free. Those aren't
2148ea1fbf7SHeiko Schocher * issues normally (IRQ handler fast path).
2158ea1fbf7SHeiko Schocher */
2168ea1fbf7SHeiko Schocher if (unlikely(csr & (AT91_UDP_TXCOMP | AT91_UDP_TXPKTRDY))) {
2178ea1fbf7SHeiko Schocher if (csr & AT91_UDP_TXCOMP) {
2188ea1fbf7SHeiko Schocher csr |= CLR_FX;
2198ea1fbf7SHeiko Schocher csr &= ~(SET_FX | AT91_UDP_TXCOMP);
2208ea1fbf7SHeiko Schocher __raw_writel(csr, creg);
2218ea1fbf7SHeiko Schocher csr = __raw_readl(creg);
2228ea1fbf7SHeiko Schocher }
2238ea1fbf7SHeiko Schocher if (csr & AT91_UDP_TXPKTRDY)
2248ea1fbf7SHeiko Schocher return 0;
2258ea1fbf7SHeiko Schocher }
2268ea1fbf7SHeiko Schocher
2278ea1fbf7SHeiko Schocher buf = req->req.buf + req->req.actual;
2288ea1fbf7SHeiko Schocher prefetch(buf);
2298ea1fbf7SHeiko Schocher total = req->req.length - req->req.actual;
2308ea1fbf7SHeiko Schocher if (ep->ep.maxpacket < total) {
2318ea1fbf7SHeiko Schocher count = ep->ep.maxpacket;
2328ea1fbf7SHeiko Schocher is_last = 0;
2338ea1fbf7SHeiko Schocher } else {
2348ea1fbf7SHeiko Schocher count = total;
2358ea1fbf7SHeiko Schocher is_last = (count < ep->ep.maxpacket) || !req->req.zero;
2368ea1fbf7SHeiko Schocher }
2378ea1fbf7SHeiko Schocher
2388ea1fbf7SHeiko Schocher /*
2398ea1fbf7SHeiko Schocher * Write the packet, maybe it's a ZLP.
2408ea1fbf7SHeiko Schocher *
2418ea1fbf7SHeiko Schocher * NOTE: incrementing req->actual before we receive the ACK means
2428ea1fbf7SHeiko Schocher * gadget driver IN bytecounts can be wrong in fault cases. That's
2438ea1fbf7SHeiko Schocher * fixable with PIO drivers like this one (save "count" here, and
2448ea1fbf7SHeiko Schocher * do the increment later on TX irq), but not for most DMA hardware.
2458ea1fbf7SHeiko Schocher *
2468ea1fbf7SHeiko Schocher * So all gadget drivers must accept that potential error. Some
2478ea1fbf7SHeiko Schocher * hardware supports precise fifo status reporting, letting them
2488ea1fbf7SHeiko Schocher * recover when the actual bytecount matters (e.g. for USB Test
2498ea1fbf7SHeiko Schocher * and Measurement Class devices).
2508ea1fbf7SHeiko Schocher */
25162019767SHeiko Schocher __raw_writesb((unsigned long)dreg, buf, count);
2528ea1fbf7SHeiko Schocher csr &= ~SET_FX;
2538ea1fbf7SHeiko Schocher csr |= CLR_FX | AT91_UDP_TXPKTRDY;
2548ea1fbf7SHeiko Schocher __raw_writel(csr, creg);
2558ea1fbf7SHeiko Schocher req->req.actual += count;
2568ea1fbf7SHeiko Schocher
2578ea1fbf7SHeiko Schocher PACKET("%s %p in/%d%s\n", ep->ep.name, &req->req, count,
2588ea1fbf7SHeiko Schocher is_last ? " (done)" : "");
2598ea1fbf7SHeiko Schocher if (is_last)
2608ea1fbf7SHeiko Schocher done(ep, req, 0);
2618ea1fbf7SHeiko Schocher return is_last;
2628ea1fbf7SHeiko Schocher }
2638ea1fbf7SHeiko Schocher
nuke(struct at91_ep * ep,int status)2648ea1fbf7SHeiko Schocher static void nuke(struct at91_ep *ep, int status)
2658ea1fbf7SHeiko Schocher {
2668ea1fbf7SHeiko Schocher struct at91_request *req;
2678ea1fbf7SHeiko Schocher
2688ea1fbf7SHeiko Schocher /* terminate any request in the queue */
2698ea1fbf7SHeiko Schocher ep->stopped = 1;
2708ea1fbf7SHeiko Schocher if (list_empty(&ep->queue))
2718ea1fbf7SHeiko Schocher return;
2728ea1fbf7SHeiko Schocher
2738ea1fbf7SHeiko Schocher VDBG("%s %s\n", __func__, ep->ep.name);
2748ea1fbf7SHeiko Schocher while (!list_empty(&ep->queue)) {
2758ea1fbf7SHeiko Schocher req = list_entry(ep->queue.next, struct at91_request, queue);
2768ea1fbf7SHeiko Schocher done(ep, req, status);
2778ea1fbf7SHeiko Schocher }
2788ea1fbf7SHeiko Schocher }
2798ea1fbf7SHeiko Schocher
2808ea1fbf7SHeiko Schocher /*-------------------------------------------------------------------------*/
2818ea1fbf7SHeiko Schocher
at91_ep_enable(struct usb_ep * _ep,const struct usb_endpoint_descriptor * desc)2828ea1fbf7SHeiko Schocher static int at91_ep_enable(struct usb_ep *_ep,
2838ea1fbf7SHeiko Schocher const struct usb_endpoint_descriptor *desc)
2848ea1fbf7SHeiko Schocher {
2858ea1fbf7SHeiko Schocher struct at91_ep *ep = container_of(_ep, struct at91_ep, ep);
2868ea1fbf7SHeiko Schocher struct at91_udc *udc;
2878ea1fbf7SHeiko Schocher u16 maxpacket;
2888ea1fbf7SHeiko Schocher u32 tmp;
2898ea1fbf7SHeiko Schocher unsigned long flags;
2908ea1fbf7SHeiko Schocher
2918ea1fbf7SHeiko Schocher if (!_ep || !ep
2928ea1fbf7SHeiko Schocher || !desc || _ep->name == ep0name
2938ea1fbf7SHeiko Schocher || desc->bDescriptorType != USB_DT_ENDPOINT
2948ea1fbf7SHeiko Schocher || (maxpacket = usb_endpoint_maxp(desc)) == 0
2958ea1fbf7SHeiko Schocher || maxpacket > ep->maxpacket) {
2968ea1fbf7SHeiko Schocher DBG("bad ep or descriptor\n");
2978ea1fbf7SHeiko Schocher return -EINVAL;
2988ea1fbf7SHeiko Schocher }
2998ea1fbf7SHeiko Schocher
3008ea1fbf7SHeiko Schocher udc = ep->udc;
3018ea1fbf7SHeiko Schocher if (!udc->driver || udc->gadget.speed == USB_SPEED_UNKNOWN) {
3028ea1fbf7SHeiko Schocher DBG("bogus device state\n");
3038ea1fbf7SHeiko Schocher return -ESHUTDOWN;
3048ea1fbf7SHeiko Schocher }
3058ea1fbf7SHeiko Schocher
3068ea1fbf7SHeiko Schocher tmp = usb_endpoint_type(desc);
3078ea1fbf7SHeiko Schocher switch (tmp) {
3088ea1fbf7SHeiko Schocher case USB_ENDPOINT_XFER_CONTROL:
3098ea1fbf7SHeiko Schocher DBG("only one control endpoint\n");
3108ea1fbf7SHeiko Schocher return -EINVAL;
3118ea1fbf7SHeiko Schocher case USB_ENDPOINT_XFER_INT:
3128ea1fbf7SHeiko Schocher if (maxpacket > 64)
3138ea1fbf7SHeiko Schocher goto bogus_max;
3148ea1fbf7SHeiko Schocher break;
3158ea1fbf7SHeiko Schocher case USB_ENDPOINT_XFER_BULK:
3168ea1fbf7SHeiko Schocher switch (maxpacket) {
3178ea1fbf7SHeiko Schocher case 8:
3188ea1fbf7SHeiko Schocher case 16:
3198ea1fbf7SHeiko Schocher case 32:
3208ea1fbf7SHeiko Schocher case 64:
3218ea1fbf7SHeiko Schocher goto ok;
3228ea1fbf7SHeiko Schocher }
3238ea1fbf7SHeiko Schocher bogus_max:
3248ea1fbf7SHeiko Schocher DBG("bogus maxpacket %d\n", maxpacket);
3258ea1fbf7SHeiko Schocher return -EINVAL;
3268ea1fbf7SHeiko Schocher case USB_ENDPOINT_XFER_ISOC:
3278ea1fbf7SHeiko Schocher if (!ep->is_pingpong) {
3288ea1fbf7SHeiko Schocher DBG("iso requires double buffering\n");
3298ea1fbf7SHeiko Schocher return -EINVAL;
3308ea1fbf7SHeiko Schocher }
3318ea1fbf7SHeiko Schocher break;
3328ea1fbf7SHeiko Schocher }
3338ea1fbf7SHeiko Schocher
3348ea1fbf7SHeiko Schocher ok:
3358ea1fbf7SHeiko Schocher spin_lock_irqsave(&udc->lock, flags);
3368ea1fbf7SHeiko Schocher
3378ea1fbf7SHeiko Schocher /* initialize endpoint to match this descriptor */
3388ea1fbf7SHeiko Schocher ep->is_in = usb_endpoint_dir_in(desc);
3398ea1fbf7SHeiko Schocher ep->is_iso = (tmp == USB_ENDPOINT_XFER_ISOC);
3408ea1fbf7SHeiko Schocher ep->stopped = 0;
3418ea1fbf7SHeiko Schocher if (ep->is_in)
3428ea1fbf7SHeiko Schocher tmp |= 0x04;
3438ea1fbf7SHeiko Schocher tmp <<= 8;
3448ea1fbf7SHeiko Schocher tmp |= AT91_UDP_EPEDS;
3458ea1fbf7SHeiko Schocher __raw_writel(tmp, ep->creg);
3468ea1fbf7SHeiko Schocher
3478ea1fbf7SHeiko Schocher ep->ep.maxpacket = maxpacket;
3488ea1fbf7SHeiko Schocher
3498ea1fbf7SHeiko Schocher /*
3508ea1fbf7SHeiko Schocher * reset/init endpoint fifo. NOTE: leaves fifo_bank alone,
3518ea1fbf7SHeiko Schocher * since endpoint resets don't reset hw pingpong state.
3528ea1fbf7SHeiko Schocher */
3538ea1fbf7SHeiko Schocher at91_udp_write(udc, AT91_UDP_RST_EP, ep->int_mask);
3548ea1fbf7SHeiko Schocher at91_udp_write(udc, AT91_UDP_RST_EP, 0);
3558ea1fbf7SHeiko Schocher
3568ea1fbf7SHeiko Schocher spin_unlock_irqrestore(&udc->lock, flags);
3578ea1fbf7SHeiko Schocher return 0;
3588ea1fbf7SHeiko Schocher }
3598ea1fbf7SHeiko Schocher
at91_ep_disable(struct usb_ep * _ep)3608ea1fbf7SHeiko Schocher static int at91_ep_disable (struct usb_ep * _ep)
3618ea1fbf7SHeiko Schocher {
3628ea1fbf7SHeiko Schocher struct at91_ep *ep = container_of(_ep, struct at91_ep, ep);
3638ea1fbf7SHeiko Schocher struct at91_udc *udc = ep->udc;
3648ea1fbf7SHeiko Schocher unsigned long flags;
3658ea1fbf7SHeiko Schocher
3668ea1fbf7SHeiko Schocher if (ep == &ep->udc->ep[0])
3678ea1fbf7SHeiko Schocher return -EINVAL;
3688ea1fbf7SHeiko Schocher
3698ea1fbf7SHeiko Schocher spin_lock_irqsave(&udc->lock, flags);
3708ea1fbf7SHeiko Schocher
3718ea1fbf7SHeiko Schocher nuke(ep, -ESHUTDOWN);
3728ea1fbf7SHeiko Schocher
3738ea1fbf7SHeiko Schocher /* restore the endpoint's pristine config */
3748ea1fbf7SHeiko Schocher ep->ep.desc = NULL;
3758ea1fbf7SHeiko Schocher ep->ep.maxpacket = ep->maxpacket;
3768ea1fbf7SHeiko Schocher
3778ea1fbf7SHeiko Schocher /* reset fifos and endpoint */
3788ea1fbf7SHeiko Schocher if (ep->udc->clocked) {
3798ea1fbf7SHeiko Schocher at91_udp_write(udc, AT91_UDP_RST_EP, ep->int_mask);
3808ea1fbf7SHeiko Schocher at91_udp_write(udc, AT91_UDP_RST_EP, 0);
3818ea1fbf7SHeiko Schocher __raw_writel(0, ep->creg);
3828ea1fbf7SHeiko Schocher }
3838ea1fbf7SHeiko Schocher
3848ea1fbf7SHeiko Schocher spin_unlock_irqrestore(&udc->lock, flags);
3858ea1fbf7SHeiko Schocher return 0;
3868ea1fbf7SHeiko Schocher }
3878ea1fbf7SHeiko Schocher
3888ea1fbf7SHeiko Schocher /*
3898ea1fbf7SHeiko Schocher * this is a PIO-only driver, so there's nothing
3908ea1fbf7SHeiko Schocher * interesting for request or buffer allocation.
3918ea1fbf7SHeiko Schocher */
3928ea1fbf7SHeiko Schocher
3938ea1fbf7SHeiko Schocher static struct usb_request *
at91_ep_alloc_request(struct usb_ep * _ep,gfp_t gfp_flags)3948ea1fbf7SHeiko Schocher at91_ep_alloc_request(struct usb_ep *_ep, gfp_t gfp_flags)
3958ea1fbf7SHeiko Schocher {
3968ea1fbf7SHeiko Schocher struct at91_request *req;
3978ea1fbf7SHeiko Schocher
3988ea1fbf7SHeiko Schocher req = kzalloc(sizeof (struct at91_request), gfp_flags);
3998ea1fbf7SHeiko Schocher if (!req)
4008ea1fbf7SHeiko Schocher return NULL;
4018ea1fbf7SHeiko Schocher
4028ea1fbf7SHeiko Schocher INIT_LIST_HEAD(&req->queue);
4038ea1fbf7SHeiko Schocher return &req->req;
4048ea1fbf7SHeiko Schocher }
4058ea1fbf7SHeiko Schocher
at91_ep_free_request(struct usb_ep * _ep,struct usb_request * _req)4068ea1fbf7SHeiko Schocher static void at91_ep_free_request(struct usb_ep *_ep, struct usb_request *_req)
4078ea1fbf7SHeiko Schocher {
4088ea1fbf7SHeiko Schocher struct at91_request *req;
4098ea1fbf7SHeiko Schocher
4108ea1fbf7SHeiko Schocher req = container_of(_req, struct at91_request, req);
4118ea1fbf7SHeiko Schocher BUG_ON(!list_empty(&req->queue));
4128ea1fbf7SHeiko Schocher kfree(req);
4138ea1fbf7SHeiko Schocher }
4148ea1fbf7SHeiko Schocher
at91_ep_queue(struct usb_ep * _ep,struct usb_request * _req,gfp_t gfp_flags)4158ea1fbf7SHeiko Schocher static int at91_ep_queue(struct usb_ep *_ep,
4168ea1fbf7SHeiko Schocher struct usb_request *_req, gfp_t gfp_flags)
4178ea1fbf7SHeiko Schocher {
4188ea1fbf7SHeiko Schocher struct at91_request *req;
4198ea1fbf7SHeiko Schocher struct at91_ep *ep;
4208ea1fbf7SHeiko Schocher struct at91_udc *udc;
4218ea1fbf7SHeiko Schocher int status;
4228ea1fbf7SHeiko Schocher unsigned long flags;
4238ea1fbf7SHeiko Schocher
4248ea1fbf7SHeiko Schocher req = container_of(_req, struct at91_request, req);
4258ea1fbf7SHeiko Schocher ep = container_of(_ep, struct at91_ep, ep);
4268ea1fbf7SHeiko Schocher
4278ea1fbf7SHeiko Schocher if (!_req || !_req->complete
4288ea1fbf7SHeiko Schocher || !_req->buf || !list_empty(&req->queue)) {
4298ea1fbf7SHeiko Schocher DBG("invalid request\n");
4308ea1fbf7SHeiko Schocher return -EINVAL;
4318ea1fbf7SHeiko Schocher }
4328ea1fbf7SHeiko Schocher
4338ea1fbf7SHeiko Schocher if (!_ep || (!ep->ep.desc && ep->ep.name != ep0name)) {
4348ea1fbf7SHeiko Schocher DBG("invalid ep\n");
4358ea1fbf7SHeiko Schocher return -EINVAL;
4368ea1fbf7SHeiko Schocher }
4378ea1fbf7SHeiko Schocher
4388ea1fbf7SHeiko Schocher udc = ep->udc;
4398ea1fbf7SHeiko Schocher
4408ea1fbf7SHeiko Schocher if (!udc || !udc->driver || udc->gadget.speed == USB_SPEED_UNKNOWN) {
4418ea1fbf7SHeiko Schocher DBG("invalid device\n");
4428ea1fbf7SHeiko Schocher return -EINVAL;
4438ea1fbf7SHeiko Schocher }
4448ea1fbf7SHeiko Schocher
4458ea1fbf7SHeiko Schocher _req->status = -EINPROGRESS;
4468ea1fbf7SHeiko Schocher _req->actual = 0;
4478ea1fbf7SHeiko Schocher
4488ea1fbf7SHeiko Schocher spin_lock_irqsave(&udc->lock, flags);
4498ea1fbf7SHeiko Schocher
4508ea1fbf7SHeiko Schocher /* try to kickstart any empty and idle queue */
4518ea1fbf7SHeiko Schocher if (list_empty(&ep->queue) && !ep->stopped) {
4528ea1fbf7SHeiko Schocher int is_ep0;
4538ea1fbf7SHeiko Schocher
4548ea1fbf7SHeiko Schocher /*
4558ea1fbf7SHeiko Schocher * If this control request has a non-empty DATA stage, this
4568ea1fbf7SHeiko Schocher * will start that stage. It works just like a non-control
4578ea1fbf7SHeiko Schocher * request (until the status stage starts, maybe early).
4588ea1fbf7SHeiko Schocher *
4598ea1fbf7SHeiko Schocher * If the data stage is empty, then this starts a successful
4608ea1fbf7SHeiko Schocher * IN/STATUS stage. (Unsuccessful ones use set_halt.)
4618ea1fbf7SHeiko Schocher */
4628ea1fbf7SHeiko Schocher is_ep0 = (ep->ep.name == ep0name);
4638ea1fbf7SHeiko Schocher if (is_ep0) {
4648ea1fbf7SHeiko Schocher u32 tmp;
4658ea1fbf7SHeiko Schocher
4668ea1fbf7SHeiko Schocher if (!udc->req_pending) {
4678ea1fbf7SHeiko Schocher status = -EINVAL;
4688ea1fbf7SHeiko Schocher goto done;
4698ea1fbf7SHeiko Schocher }
4708ea1fbf7SHeiko Schocher
4718ea1fbf7SHeiko Schocher /*
4728ea1fbf7SHeiko Schocher * defer changing CONFG until after the gadget driver
4738ea1fbf7SHeiko Schocher * reconfigures the endpoints.
4748ea1fbf7SHeiko Schocher */
4758ea1fbf7SHeiko Schocher if (udc->wait_for_config_ack) {
4768ea1fbf7SHeiko Schocher tmp = at91_udp_read(udc, AT91_UDP_GLB_STAT);
4778ea1fbf7SHeiko Schocher tmp ^= AT91_UDP_CONFG;
4788ea1fbf7SHeiko Schocher VDBG("toggle config\n");
4798ea1fbf7SHeiko Schocher at91_udp_write(udc, AT91_UDP_GLB_STAT, tmp);
4808ea1fbf7SHeiko Schocher }
4818ea1fbf7SHeiko Schocher if (req->req.length == 0) {
4828ea1fbf7SHeiko Schocher ep0_in_status:
4838ea1fbf7SHeiko Schocher PACKET("ep0 in/status\n");
4848ea1fbf7SHeiko Schocher status = 0;
4858ea1fbf7SHeiko Schocher tmp = __raw_readl(ep->creg);
4868ea1fbf7SHeiko Schocher tmp &= ~SET_FX;
4878ea1fbf7SHeiko Schocher tmp |= CLR_FX | AT91_UDP_TXPKTRDY;
4888ea1fbf7SHeiko Schocher __raw_writel(tmp, ep->creg);
4898ea1fbf7SHeiko Schocher udc->req_pending = 0;
4908ea1fbf7SHeiko Schocher goto done;
4918ea1fbf7SHeiko Schocher }
4928ea1fbf7SHeiko Schocher }
4938ea1fbf7SHeiko Schocher
4948ea1fbf7SHeiko Schocher if (ep->is_in)
4958ea1fbf7SHeiko Schocher status = write_fifo(ep, req);
4968ea1fbf7SHeiko Schocher else {
4978ea1fbf7SHeiko Schocher status = read_fifo(ep, req);
4988ea1fbf7SHeiko Schocher
4998ea1fbf7SHeiko Schocher /* IN/STATUS stage is otherwise triggered by irq */
5008ea1fbf7SHeiko Schocher if (status && is_ep0)
5018ea1fbf7SHeiko Schocher goto ep0_in_status;
5028ea1fbf7SHeiko Schocher }
5038ea1fbf7SHeiko Schocher } else
5048ea1fbf7SHeiko Schocher status = 0;
5058ea1fbf7SHeiko Schocher
5068ea1fbf7SHeiko Schocher if (req && !status) {
5078ea1fbf7SHeiko Schocher list_add_tail (&req->queue, &ep->queue);
5088ea1fbf7SHeiko Schocher at91_udp_write(udc, AT91_UDP_IER, ep->int_mask);
5098ea1fbf7SHeiko Schocher }
5108ea1fbf7SHeiko Schocher done:
5118ea1fbf7SHeiko Schocher spin_unlock_irqrestore(&udc->lock, flags);
5128ea1fbf7SHeiko Schocher return (status < 0) ? status : 0;
5138ea1fbf7SHeiko Schocher }
5148ea1fbf7SHeiko Schocher
at91_ep_dequeue(struct usb_ep * _ep,struct usb_request * _req)5158ea1fbf7SHeiko Schocher static int at91_ep_dequeue(struct usb_ep *_ep, struct usb_request *_req)
5168ea1fbf7SHeiko Schocher {
5178ea1fbf7SHeiko Schocher struct at91_ep *ep;
5188ea1fbf7SHeiko Schocher struct at91_request *req;
5198ea1fbf7SHeiko Schocher unsigned long flags;
5208ea1fbf7SHeiko Schocher
5218ea1fbf7SHeiko Schocher ep = container_of(_ep, struct at91_ep, ep);
5228ea1fbf7SHeiko Schocher if (!_ep || ep->ep.name == ep0name)
5238ea1fbf7SHeiko Schocher return -EINVAL;
5248ea1fbf7SHeiko Schocher
5258ea1fbf7SHeiko Schocher spin_lock_irqsave(&udc->lock, flags);
5268ea1fbf7SHeiko Schocher
5278ea1fbf7SHeiko Schocher /* make sure it's actually queued on this endpoint */
5288ea1fbf7SHeiko Schocher list_for_each_entry (req, &ep->queue, queue) {
5298ea1fbf7SHeiko Schocher if (&req->req == _req)
5308ea1fbf7SHeiko Schocher break;
5318ea1fbf7SHeiko Schocher }
5328ea1fbf7SHeiko Schocher if (&req->req != _req) {
5338ea1fbf7SHeiko Schocher spin_unlock_irqrestore(&udc->lock, flags);
5348ea1fbf7SHeiko Schocher return -EINVAL;
5358ea1fbf7SHeiko Schocher }
5368ea1fbf7SHeiko Schocher
5378ea1fbf7SHeiko Schocher done(ep, req, -ECONNRESET);
5388ea1fbf7SHeiko Schocher spin_unlock_irqrestore(&udc->lock, flags);
5398ea1fbf7SHeiko Schocher return 0;
5408ea1fbf7SHeiko Schocher }
5418ea1fbf7SHeiko Schocher
at91_ep_set_halt(struct usb_ep * _ep,int value)5428ea1fbf7SHeiko Schocher static int at91_ep_set_halt(struct usb_ep *_ep, int value)
5438ea1fbf7SHeiko Schocher {
5448ea1fbf7SHeiko Schocher struct at91_ep *ep = container_of(_ep, struct at91_ep, ep);
5458ea1fbf7SHeiko Schocher struct at91_udc *udc = ep->udc;
5468ea1fbf7SHeiko Schocher u32 __iomem *creg;
5478ea1fbf7SHeiko Schocher u32 csr;
5488ea1fbf7SHeiko Schocher unsigned long flags;
5498ea1fbf7SHeiko Schocher int status = 0;
5508ea1fbf7SHeiko Schocher
5518ea1fbf7SHeiko Schocher if (!_ep || ep->is_iso || !ep->udc->clocked)
5528ea1fbf7SHeiko Schocher return -EINVAL;
5538ea1fbf7SHeiko Schocher
5548ea1fbf7SHeiko Schocher creg = ep->creg;
5558ea1fbf7SHeiko Schocher spin_lock_irqsave(&udc->lock, flags);
5568ea1fbf7SHeiko Schocher
5578ea1fbf7SHeiko Schocher csr = __raw_readl(creg);
5588ea1fbf7SHeiko Schocher
5598ea1fbf7SHeiko Schocher /*
5608ea1fbf7SHeiko Schocher * fail with still-busy IN endpoints, ensuring correct sequencing
5618ea1fbf7SHeiko Schocher * of data tx then stall. note that the fifo rx bytecount isn't
5628ea1fbf7SHeiko Schocher * completely accurate as a tx bytecount.
5638ea1fbf7SHeiko Schocher */
5648ea1fbf7SHeiko Schocher if (ep->is_in && (!list_empty(&ep->queue) || (csr >> 16) != 0))
5658ea1fbf7SHeiko Schocher status = -EAGAIN;
5668ea1fbf7SHeiko Schocher else {
5678ea1fbf7SHeiko Schocher csr |= CLR_FX;
5688ea1fbf7SHeiko Schocher csr &= ~SET_FX;
5698ea1fbf7SHeiko Schocher if (value) {
5708ea1fbf7SHeiko Schocher csr |= AT91_UDP_FORCESTALL;
5718ea1fbf7SHeiko Schocher VDBG("halt %s\n", ep->ep.name);
5728ea1fbf7SHeiko Schocher } else {
5738ea1fbf7SHeiko Schocher at91_udp_write(udc, AT91_UDP_RST_EP, ep->int_mask);
5748ea1fbf7SHeiko Schocher at91_udp_write(udc, AT91_UDP_RST_EP, 0);
5758ea1fbf7SHeiko Schocher csr &= ~AT91_UDP_FORCESTALL;
5768ea1fbf7SHeiko Schocher }
5778ea1fbf7SHeiko Schocher __raw_writel(csr, creg);
5788ea1fbf7SHeiko Schocher }
5798ea1fbf7SHeiko Schocher
5808ea1fbf7SHeiko Schocher spin_unlock_irqrestore(&udc->lock, flags);
5818ea1fbf7SHeiko Schocher return status;
5828ea1fbf7SHeiko Schocher }
5838ea1fbf7SHeiko Schocher
5848ea1fbf7SHeiko Schocher static const struct usb_ep_ops at91_ep_ops = {
5858ea1fbf7SHeiko Schocher .enable = at91_ep_enable,
5868ea1fbf7SHeiko Schocher .disable = at91_ep_disable,
5878ea1fbf7SHeiko Schocher .alloc_request = at91_ep_alloc_request,
5888ea1fbf7SHeiko Schocher .free_request = at91_ep_free_request,
5898ea1fbf7SHeiko Schocher .queue = at91_ep_queue,
5908ea1fbf7SHeiko Schocher .dequeue = at91_ep_dequeue,
5918ea1fbf7SHeiko Schocher .set_halt = at91_ep_set_halt,
5928ea1fbf7SHeiko Schocher /* there's only imprecise fifo status reporting */
5938ea1fbf7SHeiko Schocher };
5948ea1fbf7SHeiko Schocher
5958ea1fbf7SHeiko Schocher /*-------------------------------------------------------------------------*/
5968ea1fbf7SHeiko Schocher
at91_get_frame(struct usb_gadget * gadget)5978ea1fbf7SHeiko Schocher static int at91_get_frame(struct usb_gadget *gadget)
5988ea1fbf7SHeiko Schocher {
5998ea1fbf7SHeiko Schocher struct at91_udc *udc = to_udc(gadget);
6008ea1fbf7SHeiko Schocher
6018ea1fbf7SHeiko Schocher if (!to_udc(gadget)->clocked)
6028ea1fbf7SHeiko Schocher return -EINVAL;
6038ea1fbf7SHeiko Schocher return at91_udp_read(udc, AT91_UDP_FRM_NUM) & AT91_UDP_NUM;
6048ea1fbf7SHeiko Schocher }
6058ea1fbf7SHeiko Schocher
at91_wakeup(struct usb_gadget * gadget)6068ea1fbf7SHeiko Schocher static int at91_wakeup(struct usb_gadget *gadget)
6078ea1fbf7SHeiko Schocher {
6088ea1fbf7SHeiko Schocher struct at91_udc *udc = to_udc(gadget);
6098ea1fbf7SHeiko Schocher u32 glbstate;
6108ea1fbf7SHeiko Schocher int status = -EINVAL;
6118ea1fbf7SHeiko Schocher unsigned long flags;
6128ea1fbf7SHeiko Schocher
6138ea1fbf7SHeiko Schocher DBG("%s\n", __func__ );
6148ea1fbf7SHeiko Schocher spin_lock_irqsave(&udc->lock, flags);
6158ea1fbf7SHeiko Schocher
6168ea1fbf7SHeiko Schocher if (!udc->clocked || !udc->suspended)
6178ea1fbf7SHeiko Schocher goto done;
6188ea1fbf7SHeiko Schocher
6198ea1fbf7SHeiko Schocher /* NOTE: some "early versions" handle ESR differently ... */
6208ea1fbf7SHeiko Schocher
6218ea1fbf7SHeiko Schocher glbstate = at91_udp_read(udc, AT91_UDP_GLB_STAT);
6228ea1fbf7SHeiko Schocher if (!(glbstate & AT91_UDP_ESR))
6238ea1fbf7SHeiko Schocher goto done;
6248ea1fbf7SHeiko Schocher glbstate |= AT91_UDP_ESR;
6258ea1fbf7SHeiko Schocher at91_udp_write(udc, AT91_UDP_GLB_STAT, glbstate);
6268ea1fbf7SHeiko Schocher
6278ea1fbf7SHeiko Schocher done:
6288ea1fbf7SHeiko Schocher spin_unlock_irqrestore(&udc->lock, flags);
6298ea1fbf7SHeiko Schocher return status;
6308ea1fbf7SHeiko Schocher }
6318ea1fbf7SHeiko Schocher
6328ea1fbf7SHeiko Schocher /* reinit == restore initial software state */
udc_reinit(struct at91_udc * udc)6338ea1fbf7SHeiko Schocher static void udc_reinit(struct at91_udc *udc)
6348ea1fbf7SHeiko Schocher {
6358ea1fbf7SHeiko Schocher u32 i;
6368ea1fbf7SHeiko Schocher
6378ea1fbf7SHeiko Schocher INIT_LIST_HEAD(&udc->gadget.ep_list);
6388ea1fbf7SHeiko Schocher INIT_LIST_HEAD(&udc->gadget.ep0->ep_list);
6398ea1fbf7SHeiko Schocher
6408ea1fbf7SHeiko Schocher for (i = 0; i < NUM_ENDPOINTS; i++) {
6418ea1fbf7SHeiko Schocher struct at91_ep *ep = &udc->ep[i];
6428ea1fbf7SHeiko Schocher
6438ea1fbf7SHeiko Schocher if (i != 0)
6448ea1fbf7SHeiko Schocher list_add_tail(&ep->ep.ep_list, &udc->gadget.ep_list);
6458ea1fbf7SHeiko Schocher ep->ep.desc = NULL;
6468ea1fbf7SHeiko Schocher ep->stopped = 0;
6478ea1fbf7SHeiko Schocher ep->fifo_bank = 0;
6488ea1fbf7SHeiko Schocher usb_ep_set_maxpacket_limit(&ep->ep, ep->maxpacket);
6498ea1fbf7SHeiko Schocher ep->creg = (void __iomem *) udc->udp_baseaddr + AT91_UDP_CSR(i);
6508ea1fbf7SHeiko Schocher /* initialize one queue per endpoint */
6518ea1fbf7SHeiko Schocher INIT_LIST_HEAD(&ep->queue);
6528ea1fbf7SHeiko Schocher }
6538ea1fbf7SHeiko Schocher }
6548ea1fbf7SHeiko Schocher
reset_gadget(struct at91_udc * udc)6558ea1fbf7SHeiko Schocher static void reset_gadget(struct at91_udc *udc)
6568ea1fbf7SHeiko Schocher {
6578ea1fbf7SHeiko Schocher struct usb_gadget_driver *driver = udc->driver;
6588ea1fbf7SHeiko Schocher int i;
6598ea1fbf7SHeiko Schocher
6608ea1fbf7SHeiko Schocher if (udc->gadget.speed == USB_SPEED_UNKNOWN)
6618ea1fbf7SHeiko Schocher driver = NULL;
6628ea1fbf7SHeiko Schocher udc->gadget.speed = USB_SPEED_UNKNOWN;
6638ea1fbf7SHeiko Schocher udc->suspended = 0;
6648ea1fbf7SHeiko Schocher
6658ea1fbf7SHeiko Schocher for (i = 0; i < NUM_ENDPOINTS; i++) {
6668ea1fbf7SHeiko Schocher struct at91_ep *ep = &udc->ep[i];
6678ea1fbf7SHeiko Schocher
6688ea1fbf7SHeiko Schocher ep->stopped = 1;
6698ea1fbf7SHeiko Schocher nuke(ep, -ESHUTDOWN);
6708ea1fbf7SHeiko Schocher }
6718ea1fbf7SHeiko Schocher if (driver) {
6728ea1fbf7SHeiko Schocher spin_unlock(&udc->lock);
67362019767SHeiko Schocher udc->driver->disconnect(&udc->gadget);
6748ea1fbf7SHeiko Schocher spin_lock(&udc->lock);
6758ea1fbf7SHeiko Schocher }
6768ea1fbf7SHeiko Schocher
6778ea1fbf7SHeiko Schocher udc_reinit(udc);
6788ea1fbf7SHeiko Schocher }
6798ea1fbf7SHeiko Schocher
stop_activity(struct at91_udc * udc)6808ea1fbf7SHeiko Schocher static void stop_activity(struct at91_udc *udc)
6818ea1fbf7SHeiko Schocher {
6828ea1fbf7SHeiko Schocher struct usb_gadget_driver *driver = udc->driver;
6838ea1fbf7SHeiko Schocher int i;
6848ea1fbf7SHeiko Schocher
6858ea1fbf7SHeiko Schocher if (udc->gadget.speed == USB_SPEED_UNKNOWN)
6868ea1fbf7SHeiko Schocher driver = NULL;
6878ea1fbf7SHeiko Schocher udc->gadget.speed = USB_SPEED_UNKNOWN;
6888ea1fbf7SHeiko Schocher udc->suspended = 0;
6898ea1fbf7SHeiko Schocher
6908ea1fbf7SHeiko Schocher for (i = 0; i < NUM_ENDPOINTS; i++) {
6918ea1fbf7SHeiko Schocher struct at91_ep *ep = &udc->ep[i];
6928ea1fbf7SHeiko Schocher ep->stopped = 1;
6938ea1fbf7SHeiko Schocher nuke(ep, -ESHUTDOWN);
6948ea1fbf7SHeiko Schocher }
6958ea1fbf7SHeiko Schocher if (driver) {
6968ea1fbf7SHeiko Schocher spin_unlock(&udc->lock);
6978ea1fbf7SHeiko Schocher driver->disconnect(&udc->gadget);
6988ea1fbf7SHeiko Schocher spin_lock(&udc->lock);
6998ea1fbf7SHeiko Schocher }
7008ea1fbf7SHeiko Schocher
7018ea1fbf7SHeiko Schocher udc_reinit(udc);
7028ea1fbf7SHeiko Schocher }
7038ea1fbf7SHeiko Schocher
clk_on(struct at91_udc * udc)7048ea1fbf7SHeiko Schocher static void clk_on(struct at91_udc *udc)
7058ea1fbf7SHeiko Schocher {
7068ea1fbf7SHeiko Schocher if (udc->clocked)
7078ea1fbf7SHeiko Schocher return;
7088ea1fbf7SHeiko Schocher udc->clocked = 1;
7098ea1fbf7SHeiko Schocher }
7108ea1fbf7SHeiko Schocher
clk_off(struct at91_udc * udc)7118ea1fbf7SHeiko Schocher static void clk_off(struct at91_udc *udc)
7128ea1fbf7SHeiko Schocher {
7138ea1fbf7SHeiko Schocher if (!udc->clocked)
7148ea1fbf7SHeiko Schocher return;
7158ea1fbf7SHeiko Schocher udc->clocked = 0;
7168ea1fbf7SHeiko Schocher udc->gadget.speed = USB_SPEED_UNKNOWN;
7178ea1fbf7SHeiko Schocher }
7188ea1fbf7SHeiko Schocher
7198ea1fbf7SHeiko Schocher /*
7208ea1fbf7SHeiko Schocher * activate/deactivate link with host; minimize power usage for
7218ea1fbf7SHeiko Schocher * inactive links by cutting clocks and transceiver power.
7228ea1fbf7SHeiko Schocher */
pullup(struct at91_udc * udc,int is_on)7238ea1fbf7SHeiko Schocher static void pullup(struct at91_udc *udc, int is_on)
7248ea1fbf7SHeiko Schocher {
7258ea1fbf7SHeiko Schocher if (!udc->enabled || !udc->vbus)
7268ea1fbf7SHeiko Schocher is_on = 0;
7278ea1fbf7SHeiko Schocher DBG("%sactive\n", is_on ? "" : "in");
7288ea1fbf7SHeiko Schocher
7298ea1fbf7SHeiko Schocher if (is_on) {
7308ea1fbf7SHeiko Schocher clk_on(udc);
7318ea1fbf7SHeiko Schocher at91_udp_write(udc, AT91_UDP_ICR, AT91_UDP_RXRSM);
7328ea1fbf7SHeiko Schocher at91_udp_write(udc, AT91_UDP_TXVC, 0);
7338ea1fbf7SHeiko Schocher } else {
7348ea1fbf7SHeiko Schocher stop_activity(udc);
7358ea1fbf7SHeiko Schocher at91_udp_write(udc, AT91_UDP_IDR, AT91_UDP_RXRSM);
7368ea1fbf7SHeiko Schocher at91_udp_write(udc, AT91_UDP_TXVC, AT91_UDP_TXVC_TXVDIS);
7378ea1fbf7SHeiko Schocher clk_off(udc);
7388ea1fbf7SHeiko Schocher }
7398ea1fbf7SHeiko Schocher
7408ea1fbf7SHeiko Schocher if (udc->caps && udc->caps->pullup)
7418ea1fbf7SHeiko Schocher udc->caps->pullup(udc, is_on);
7428ea1fbf7SHeiko Schocher }
7438ea1fbf7SHeiko Schocher
7448ea1fbf7SHeiko Schocher /* vbus is here! turn everything on that's ready */
at91_vbus_session(struct usb_gadget * gadget,int is_active)7458ea1fbf7SHeiko Schocher static int at91_vbus_session(struct usb_gadget *gadget, int is_active)
7468ea1fbf7SHeiko Schocher {
7478ea1fbf7SHeiko Schocher struct at91_udc *udc = to_udc(gadget);
7488ea1fbf7SHeiko Schocher unsigned long flags;
7498ea1fbf7SHeiko Schocher
7508ea1fbf7SHeiko Schocher /* VDBG("vbus %s\n", is_active ? "on" : "off"); */
7518ea1fbf7SHeiko Schocher spin_lock_irqsave(&udc->lock, flags);
7528ea1fbf7SHeiko Schocher udc->vbus = (is_active != 0);
7538ea1fbf7SHeiko Schocher if (udc->driver)
7548ea1fbf7SHeiko Schocher pullup(udc, is_active);
7558ea1fbf7SHeiko Schocher else
7568ea1fbf7SHeiko Schocher pullup(udc, 0);
7578ea1fbf7SHeiko Schocher spin_unlock_irqrestore(&udc->lock, flags);
7588ea1fbf7SHeiko Schocher return 0;
7598ea1fbf7SHeiko Schocher }
7608ea1fbf7SHeiko Schocher
at91_pullup(struct usb_gadget * gadget,int is_on)7618ea1fbf7SHeiko Schocher static int at91_pullup(struct usb_gadget *gadget, int is_on)
7628ea1fbf7SHeiko Schocher {
7638ea1fbf7SHeiko Schocher struct at91_udc *udc = to_udc(gadget);
7648ea1fbf7SHeiko Schocher unsigned long flags;
7658ea1fbf7SHeiko Schocher
7668ea1fbf7SHeiko Schocher spin_lock_irqsave(&udc->lock, flags);
7678ea1fbf7SHeiko Schocher udc->enabled = is_on = !!is_on;
7688ea1fbf7SHeiko Schocher pullup(udc, is_on);
7698ea1fbf7SHeiko Schocher spin_unlock_irqrestore(&udc->lock, flags);
7708ea1fbf7SHeiko Schocher return 0;
7718ea1fbf7SHeiko Schocher }
7728ea1fbf7SHeiko Schocher
at91_set_selfpowered(struct usb_gadget * gadget,int is_on)7738ea1fbf7SHeiko Schocher static int at91_set_selfpowered(struct usb_gadget *gadget, int is_on)
7748ea1fbf7SHeiko Schocher {
7758ea1fbf7SHeiko Schocher struct at91_udc *udc = to_udc(gadget);
7768ea1fbf7SHeiko Schocher unsigned long flags;
7778ea1fbf7SHeiko Schocher
7788ea1fbf7SHeiko Schocher spin_lock_irqsave(&udc->lock, flags);
77962019767SHeiko Schocher udc->selfpowered = (is_on != 0);
7808ea1fbf7SHeiko Schocher spin_unlock_irqrestore(&udc->lock, flags);
7818ea1fbf7SHeiko Schocher return 0;
7828ea1fbf7SHeiko Schocher }
7838ea1fbf7SHeiko Schocher
7848ea1fbf7SHeiko Schocher static int at91_start(struct usb_gadget *gadget,
7858ea1fbf7SHeiko Schocher struct usb_gadget_driver *driver);
7868ea1fbf7SHeiko Schocher static int at91_stop(struct usb_gadget *gadget);
7878ea1fbf7SHeiko Schocher
7888ea1fbf7SHeiko Schocher static const struct usb_gadget_ops at91_udc_ops = {
7898ea1fbf7SHeiko Schocher .get_frame = at91_get_frame,
7908ea1fbf7SHeiko Schocher .wakeup = at91_wakeup,
7918ea1fbf7SHeiko Schocher .set_selfpowered = at91_set_selfpowered,
7928ea1fbf7SHeiko Schocher .vbus_session = at91_vbus_session,
7938ea1fbf7SHeiko Schocher .pullup = at91_pullup,
7948ea1fbf7SHeiko Schocher .udc_start = at91_start,
7958ea1fbf7SHeiko Schocher .udc_stop = at91_stop,
7968ea1fbf7SHeiko Schocher
7978ea1fbf7SHeiko Schocher /*
7988ea1fbf7SHeiko Schocher * VBUS-powered devices may also also want to support bigger
7998ea1fbf7SHeiko Schocher * power budgets after an appropriate SET_CONFIGURATION.
8008ea1fbf7SHeiko Schocher */
8018ea1fbf7SHeiko Schocher /* .vbus_power = at91_vbus_power, */
8028ea1fbf7SHeiko Schocher };
8038ea1fbf7SHeiko Schocher
8048ea1fbf7SHeiko Schocher /*-------------------------------------------------------------------------*/
8058ea1fbf7SHeiko Schocher
handle_ep(struct at91_ep * ep)8068ea1fbf7SHeiko Schocher static int handle_ep(struct at91_ep *ep)
8078ea1fbf7SHeiko Schocher {
8088ea1fbf7SHeiko Schocher struct at91_request *req;
8098ea1fbf7SHeiko Schocher u32 __iomem *creg = ep->creg;
8108ea1fbf7SHeiko Schocher u32 csr = __raw_readl(creg);
8118ea1fbf7SHeiko Schocher
8128ea1fbf7SHeiko Schocher if (!list_empty(&ep->queue))
8138ea1fbf7SHeiko Schocher req = list_entry(ep->queue.next,
8148ea1fbf7SHeiko Schocher struct at91_request, queue);
8158ea1fbf7SHeiko Schocher else
8168ea1fbf7SHeiko Schocher req = NULL;
8178ea1fbf7SHeiko Schocher
8188ea1fbf7SHeiko Schocher if (ep->is_in) {
8198ea1fbf7SHeiko Schocher if (csr & (AT91_UDP_STALLSENT | AT91_UDP_TXCOMP)) {
8208ea1fbf7SHeiko Schocher csr |= CLR_FX;
8218ea1fbf7SHeiko Schocher csr &= ~(SET_FX | AT91_UDP_STALLSENT | AT91_UDP_TXCOMP);
8228ea1fbf7SHeiko Schocher __raw_writel(csr, creg);
8238ea1fbf7SHeiko Schocher }
8248ea1fbf7SHeiko Schocher if (req)
8258ea1fbf7SHeiko Schocher return write_fifo(ep, req);
8268ea1fbf7SHeiko Schocher
8278ea1fbf7SHeiko Schocher } else {
8288ea1fbf7SHeiko Schocher if (csr & AT91_UDP_STALLSENT) {
8298ea1fbf7SHeiko Schocher /* STALLSENT bit == ISOERR */
8308ea1fbf7SHeiko Schocher if (ep->is_iso && req)
8318ea1fbf7SHeiko Schocher req->req.status = -EILSEQ;
8328ea1fbf7SHeiko Schocher csr |= CLR_FX;
8338ea1fbf7SHeiko Schocher csr &= ~(SET_FX | AT91_UDP_STALLSENT);
8348ea1fbf7SHeiko Schocher __raw_writel(csr, creg);
8358ea1fbf7SHeiko Schocher csr = __raw_readl(creg);
8368ea1fbf7SHeiko Schocher }
8378ea1fbf7SHeiko Schocher if (req && (csr & RX_DATA_READY))
8388ea1fbf7SHeiko Schocher return read_fifo(ep, req);
8398ea1fbf7SHeiko Schocher }
8408ea1fbf7SHeiko Schocher return 0;
8418ea1fbf7SHeiko Schocher }
8428ea1fbf7SHeiko Schocher
8438ea1fbf7SHeiko Schocher union setup {
8448ea1fbf7SHeiko Schocher u8 raw[8];
8458ea1fbf7SHeiko Schocher struct usb_ctrlrequest r;
8468ea1fbf7SHeiko Schocher };
8478ea1fbf7SHeiko Schocher
handle_setup(struct at91_udc * udc,struct at91_ep * ep,u32 csr)8488ea1fbf7SHeiko Schocher static void handle_setup(struct at91_udc *udc, struct at91_ep *ep, u32 csr)
8498ea1fbf7SHeiko Schocher {
8508ea1fbf7SHeiko Schocher u32 __iomem *creg = ep->creg;
8518ea1fbf7SHeiko Schocher u8 __iomem *dreg = ep->creg + (AT91_UDP_FDR(0) - AT91_UDP_CSR(0));
8528ea1fbf7SHeiko Schocher unsigned rxcount, i = 0;
8538ea1fbf7SHeiko Schocher u32 tmp;
8548ea1fbf7SHeiko Schocher union setup pkt;
8558ea1fbf7SHeiko Schocher int status = 0;
8568ea1fbf7SHeiko Schocher
8578ea1fbf7SHeiko Schocher /* read and ack SETUP; hard-fail for bogus packets */
8588ea1fbf7SHeiko Schocher rxcount = (csr & AT91_UDP_RXBYTECNT) >> 16;
8598ea1fbf7SHeiko Schocher if (likely(rxcount == 8)) {
8608ea1fbf7SHeiko Schocher while (rxcount--)
8618ea1fbf7SHeiko Schocher pkt.raw[i++] = __raw_readb(dreg);
8628ea1fbf7SHeiko Schocher if (pkt.r.bRequestType & USB_DIR_IN) {
8638ea1fbf7SHeiko Schocher csr |= AT91_UDP_DIR;
8648ea1fbf7SHeiko Schocher ep->is_in = 1;
8658ea1fbf7SHeiko Schocher } else {
8668ea1fbf7SHeiko Schocher csr &= ~AT91_UDP_DIR;
8678ea1fbf7SHeiko Schocher ep->is_in = 0;
8688ea1fbf7SHeiko Schocher }
8698ea1fbf7SHeiko Schocher } else {
8708ea1fbf7SHeiko Schocher /* REVISIT this happens sometimes under load; why?? */
8718ea1fbf7SHeiko Schocher ERR("SETUP len %d, csr %08x\n", rxcount, csr);
8728ea1fbf7SHeiko Schocher status = -EINVAL;
8738ea1fbf7SHeiko Schocher }
8748ea1fbf7SHeiko Schocher csr |= CLR_FX;
8758ea1fbf7SHeiko Schocher csr &= ~(SET_FX | AT91_UDP_RXSETUP);
8768ea1fbf7SHeiko Schocher __raw_writel(csr, creg);
8778ea1fbf7SHeiko Schocher udc->wait_for_addr_ack = 0;
8788ea1fbf7SHeiko Schocher udc->wait_for_config_ack = 0;
8798ea1fbf7SHeiko Schocher ep->stopped = 0;
8808ea1fbf7SHeiko Schocher if (unlikely(status != 0))
8818ea1fbf7SHeiko Schocher goto stall;
8828ea1fbf7SHeiko Schocher
8838ea1fbf7SHeiko Schocher #define w_index le16_to_cpu(pkt.r.wIndex)
8848ea1fbf7SHeiko Schocher #define w_value le16_to_cpu(pkt.r.wValue)
8858ea1fbf7SHeiko Schocher #define w_length le16_to_cpu(pkt.r.wLength)
8868ea1fbf7SHeiko Schocher
8878ea1fbf7SHeiko Schocher VDBG("SETUP %02x.%02x v%04x i%04x l%04x\n",
8888ea1fbf7SHeiko Schocher pkt.r.bRequestType, pkt.r.bRequest,
8898ea1fbf7SHeiko Schocher w_value, w_index, w_length);
8908ea1fbf7SHeiko Schocher
8918ea1fbf7SHeiko Schocher /*
8928ea1fbf7SHeiko Schocher * A few standard requests get handled here, ones that touch
8938ea1fbf7SHeiko Schocher * hardware ... notably for device and endpoint features.
8948ea1fbf7SHeiko Schocher */
8958ea1fbf7SHeiko Schocher udc->req_pending = 1;
8968ea1fbf7SHeiko Schocher csr = __raw_readl(creg);
8978ea1fbf7SHeiko Schocher csr |= CLR_FX;
8988ea1fbf7SHeiko Schocher csr &= ~SET_FX;
8998ea1fbf7SHeiko Schocher switch ((pkt.r.bRequestType << 8) | pkt.r.bRequest) {
9008ea1fbf7SHeiko Schocher
9018ea1fbf7SHeiko Schocher case ((USB_TYPE_STANDARD|USB_RECIP_DEVICE) << 8)
9028ea1fbf7SHeiko Schocher | USB_REQ_SET_ADDRESS:
9038ea1fbf7SHeiko Schocher __raw_writel(csr | AT91_UDP_TXPKTRDY, creg);
9048ea1fbf7SHeiko Schocher udc->addr = w_value;
9058ea1fbf7SHeiko Schocher udc->wait_for_addr_ack = 1;
9068ea1fbf7SHeiko Schocher udc->req_pending = 0;
9078ea1fbf7SHeiko Schocher /* FADDR is set later, when we ack host STATUS */
9088ea1fbf7SHeiko Schocher return;
9098ea1fbf7SHeiko Schocher
9108ea1fbf7SHeiko Schocher case ((USB_TYPE_STANDARD|USB_RECIP_DEVICE) << 8)
9118ea1fbf7SHeiko Schocher | USB_REQ_SET_CONFIGURATION:
9128ea1fbf7SHeiko Schocher tmp = at91_udp_read(udc, AT91_UDP_GLB_STAT) & AT91_UDP_CONFG;
9138ea1fbf7SHeiko Schocher if (pkt.r.wValue)
9148ea1fbf7SHeiko Schocher udc->wait_for_config_ack = (tmp == 0);
9158ea1fbf7SHeiko Schocher else
9168ea1fbf7SHeiko Schocher udc->wait_for_config_ack = (tmp != 0);
9178ea1fbf7SHeiko Schocher if (udc->wait_for_config_ack)
9188ea1fbf7SHeiko Schocher VDBG("wait for config\n");
9198ea1fbf7SHeiko Schocher /* CONFG is toggled later, if gadget driver succeeds */
9208ea1fbf7SHeiko Schocher break;
9218ea1fbf7SHeiko Schocher
9228ea1fbf7SHeiko Schocher /*
9238ea1fbf7SHeiko Schocher * Hosts may set or clear remote wakeup status, and
9248ea1fbf7SHeiko Schocher * devices may report they're VBUS powered.
9258ea1fbf7SHeiko Schocher */
9268ea1fbf7SHeiko Schocher case ((USB_DIR_IN|USB_TYPE_STANDARD|USB_RECIP_DEVICE) << 8)
9278ea1fbf7SHeiko Schocher | USB_REQ_GET_STATUS:
92862019767SHeiko Schocher tmp = (udc->selfpowered << USB_DEVICE_SELF_POWERED);
9298ea1fbf7SHeiko Schocher if (at91_udp_read(udc, AT91_UDP_GLB_STAT) & AT91_UDP_ESR)
9308ea1fbf7SHeiko Schocher tmp |= (1 << USB_DEVICE_REMOTE_WAKEUP);
9318ea1fbf7SHeiko Schocher PACKET("get device status\n");
9328ea1fbf7SHeiko Schocher __raw_writeb(tmp, dreg);
9338ea1fbf7SHeiko Schocher __raw_writeb(0, dreg);
9348ea1fbf7SHeiko Schocher goto write_in;
9358ea1fbf7SHeiko Schocher /* then STATUS starts later, automatically */
9368ea1fbf7SHeiko Schocher case ((USB_TYPE_STANDARD|USB_RECIP_DEVICE) << 8)
9378ea1fbf7SHeiko Schocher | USB_REQ_SET_FEATURE:
9388ea1fbf7SHeiko Schocher if (w_value != USB_DEVICE_REMOTE_WAKEUP)
9398ea1fbf7SHeiko Schocher goto stall;
9408ea1fbf7SHeiko Schocher tmp = at91_udp_read(udc, AT91_UDP_GLB_STAT);
9418ea1fbf7SHeiko Schocher tmp |= AT91_UDP_ESR;
9428ea1fbf7SHeiko Schocher at91_udp_write(udc, AT91_UDP_GLB_STAT, tmp);
9438ea1fbf7SHeiko Schocher goto succeed;
9448ea1fbf7SHeiko Schocher case ((USB_TYPE_STANDARD|USB_RECIP_DEVICE) << 8)
9458ea1fbf7SHeiko Schocher | USB_REQ_CLEAR_FEATURE:
9468ea1fbf7SHeiko Schocher if (w_value != USB_DEVICE_REMOTE_WAKEUP)
9478ea1fbf7SHeiko Schocher goto stall;
9488ea1fbf7SHeiko Schocher tmp = at91_udp_read(udc, AT91_UDP_GLB_STAT);
9498ea1fbf7SHeiko Schocher tmp &= ~AT91_UDP_ESR;
9508ea1fbf7SHeiko Schocher at91_udp_write(udc, AT91_UDP_GLB_STAT, tmp);
9518ea1fbf7SHeiko Schocher goto succeed;
9528ea1fbf7SHeiko Schocher
9538ea1fbf7SHeiko Schocher /*
9548ea1fbf7SHeiko Schocher * Interfaces have no feature settings; this is pretty useless.
9558ea1fbf7SHeiko Schocher * we won't even insist the interface exists...
9568ea1fbf7SHeiko Schocher */
9578ea1fbf7SHeiko Schocher case ((USB_DIR_IN|USB_TYPE_STANDARD|USB_RECIP_INTERFACE) << 8)
9588ea1fbf7SHeiko Schocher | USB_REQ_GET_STATUS:
9598ea1fbf7SHeiko Schocher PACKET("get interface status\n");
9608ea1fbf7SHeiko Schocher __raw_writeb(0, dreg);
9618ea1fbf7SHeiko Schocher __raw_writeb(0, dreg);
9628ea1fbf7SHeiko Schocher goto write_in;
9638ea1fbf7SHeiko Schocher /* then STATUS starts later, automatically */
9648ea1fbf7SHeiko Schocher case ((USB_TYPE_STANDARD|USB_RECIP_INTERFACE) << 8)
9658ea1fbf7SHeiko Schocher | USB_REQ_SET_FEATURE:
9668ea1fbf7SHeiko Schocher case ((USB_TYPE_STANDARD|USB_RECIP_INTERFACE) << 8)
9678ea1fbf7SHeiko Schocher | USB_REQ_CLEAR_FEATURE:
9688ea1fbf7SHeiko Schocher goto stall;
9698ea1fbf7SHeiko Schocher
9708ea1fbf7SHeiko Schocher /*
9718ea1fbf7SHeiko Schocher * Hosts may clear bulk/intr endpoint halt after the gadget
9728ea1fbf7SHeiko Schocher * driver sets it (not widely used); or set it (for testing)
9738ea1fbf7SHeiko Schocher */
9748ea1fbf7SHeiko Schocher case ((USB_DIR_IN|USB_TYPE_STANDARD|USB_RECIP_ENDPOINT) << 8)
9758ea1fbf7SHeiko Schocher | USB_REQ_GET_STATUS:
9768ea1fbf7SHeiko Schocher tmp = w_index & USB_ENDPOINT_NUMBER_MASK;
9778ea1fbf7SHeiko Schocher ep = &udc->ep[tmp];
9788ea1fbf7SHeiko Schocher if (tmp >= NUM_ENDPOINTS || (tmp && !ep->ep.desc))
9798ea1fbf7SHeiko Schocher goto stall;
9808ea1fbf7SHeiko Schocher
9818ea1fbf7SHeiko Schocher if (tmp) {
9828ea1fbf7SHeiko Schocher if ((w_index & USB_DIR_IN)) {
9838ea1fbf7SHeiko Schocher if (!ep->is_in)
9848ea1fbf7SHeiko Schocher goto stall;
9858ea1fbf7SHeiko Schocher } else if (ep->is_in)
9868ea1fbf7SHeiko Schocher goto stall;
9878ea1fbf7SHeiko Schocher }
9888ea1fbf7SHeiko Schocher PACKET("get %s status\n", ep->ep.name);
9898ea1fbf7SHeiko Schocher if (__raw_readl(ep->creg) & AT91_UDP_FORCESTALL)
9908ea1fbf7SHeiko Schocher tmp = (1 << USB_ENDPOINT_HALT);
9918ea1fbf7SHeiko Schocher else
9928ea1fbf7SHeiko Schocher tmp = 0;
9938ea1fbf7SHeiko Schocher __raw_writeb(tmp, dreg);
9948ea1fbf7SHeiko Schocher __raw_writeb(0, dreg);
9958ea1fbf7SHeiko Schocher goto write_in;
9968ea1fbf7SHeiko Schocher /* then STATUS starts later, automatically */
9978ea1fbf7SHeiko Schocher case ((USB_TYPE_STANDARD|USB_RECIP_ENDPOINT) << 8)
9988ea1fbf7SHeiko Schocher | USB_REQ_SET_FEATURE:
9998ea1fbf7SHeiko Schocher tmp = w_index & USB_ENDPOINT_NUMBER_MASK;
10008ea1fbf7SHeiko Schocher ep = &udc->ep[tmp];
10018ea1fbf7SHeiko Schocher if (w_value != USB_ENDPOINT_HALT || tmp >= NUM_ENDPOINTS)
10028ea1fbf7SHeiko Schocher goto stall;
10038ea1fbf7SHeiko Schocher if (!ep->ep.desc || ep->is_iso)
10048ea1fbf7SHeiko Schocher goto stall;
10058ea1fbf7SHeiko Schocher if ((w_index & USB_DIR_IN)) {
10068ea1fbf7SHeiko Schocher if (!ep->is_in)
10078ea1fbf7SHeiko Schocher goto stall;
10088ea1fbf7SHeiko Schocher } else if (ep->is_in)
10098ea1fbf7SHeiko Schocher goto stall;
10108ea1fbf7SHeiko Schocher
10118ea1fbf7SHeiko Schocher tmp = __raw_readl(ep->creg);
10128ea1fbf7SHeiko Schocher tmp &= ~SET_FX;
10138ea1fbf7SHeiko Schocher tmp |= CLR_FX | AT91_UDP_FORCESTALL;
10148ea1fbf7SHeiko Schocher __raw_writel(tmp, ep->creg);
10158ea1fbf7SHeiko Schocher goto succeed;
10168ea1fbf7SHeiko Schocher case ((USB_TYPE_STANDARD|USB_RECIP_ENDPOINT) << 8)
10178ea1fbf7SHeiko Schocher | USB_REQ_CLEAR_FEATURE:
10188ea1fbf7SHeiko Schocher tmp = w_index & USB_ENDPOINT_NUMBER_MASK;
10198ea1fbf7SHeiko Schocher ep = &udc->ep[tmp];
10208ea1fbf7SHeiko Schocher if (w_value != USB_ENDPOINT_HALT || tmp >= NUM_ENDPOINTS)
10218ea1fbf7SHeiko Schocher goto stall;
10228ea1fbf7SHeiko Schocher if (tmp == 0)
10238ea1fbf7SHeiko Schocher goto succeed;
10248ea1fbf7SHeiko Schocher if (!ep->ep.desc || ep->is_iso)
10258ea1fbf7SHeiko Schocher goto stall;
10268ea1fbf7SHeiko Schocher if ((w_index & USB_DIR_IN)) {
10278ea1fbf7SHeiko Schocher if (!ep->is_in)
10288ea1fbf7SHeiko Schocher goto stall;
10298ea1fbf7SHeiko Schocher } else if (ep->is_in)
10308ea1fbf7SHeiko Schocher goto stall;
10318ea1fbf7SHeiko Schocher
10328ea1fbf7SHeiko Schocher at91_udp_write(udc, AT91_UDP_RST_EP, ep->int_mask);
10338ea1fbf7SHeiko Schocher at91_udp_write(udc, AT91_UDP_RST_EP, 0);
10348ea1fbf7SHeiko Schocher tmp = __raw_readl(ep->creg);
10358ea1fbf7SHeiko Schocher tmp |= CLR_FX;
10368ea1fbf7SHeiko Schocher tmp &= ~(SET_FX | AT91_UDP_FORCESTALL);
10378ea1fbf7SHeiko Schocher __raw_writel(tmp, ep->creg);
10388ea1fbf7SHeiko Schocher if (!list_empty(&ep->queue))
10398ea1fbf7SHeiko Schocher handle_ep(ep);
10408ea1fbf7SHeiko Schocher goto succeed;
10418ea1fbf7SHeiko Schocher }
10428ea1fbf7SHeiko Schocher
10438ea1fbf7SHeiko Schocher #undef w_value
10448ea1fbf7SHeiko Schocher #undef w_index
10458ea1fbf7SHeiko Schocher #undef w_length
10468ea1fbf7SHeiko Schocher
10478ea1fbf7SHeiko Schocher /* pass request up to the gadget driver */
10488ea1fbf7SHeiko Schocher if (udc->driver) {
10498ea1fbf7SHeiko Schocher spin_unlock(&udc->lock);
10508ea1fbf7SHeiko Schocher status = udc->driver->setup(&udc->gadget, &pkt.r);
10518ea1fbf7SHeiko Schocher spin_lock(&udc->lock);
10528ea1fbf7SHeiko Schocher }
10538ea1fbf7SHeiko Schocher else
10548ea1fbf7SHeiko Schocher status = -ENODEV;
10558ea1fbf7SHeiko Schocher if (status < 0) {
10568ea1fbf7SHeiko Schocher stall:
10578ea1fbf7SHeiko Schocher VDBG("req %02x.%02x protocol STALL; stat %d\n",
10588ea1fbf7SHeiko Schocher pkt.r.bRequestType, pkt.r.bRequest, status);
10598ea1fbf7SHeiko Schocher csr |= AT91_UDP_FORCESTALL;
10608ea1fbf7SHeiko Schocher __raw_writel(csr, creg);
10618ea1fbf7SHeiko Schocher udc->req_pending = 0;
10628ea1fbf7SHeiko Schocher }
10638ea1fbf7SHeiko Schocher return;
10648ea1fbf7SHeiko Schocher
10658ea1fbf7SHeiko Schocher succeed:
10668ea1fbf7SHeiko Schocher /* immediate successful (IN) STATUS after zero length DATA */
10678ea1fbf7SHeiko Schocher PACKET("ep0 in/status\n");
10688ea1fbf7SHeiko Schocher write_in:
10698ea1fbf7SHeiko Schocher csr |= AT91_UDP_TXPKTRDY;
10708ea1fbf7SHeiko Schocher __raw_writel(csr, creg);
10718ea1fbf7SHeiko Schocher udc->req_pending = 0;
10728ea1fbf7SHeiko Schocher }
10738ea1fbf7SHeiko Schocher
handle_ep0(struct at91_udc * udc)10748ea1fbf7SHeiko Schocher static void handle_ep0(struct at91_udc *udc)
10758ea1fbf7SHeiko Schocher {
10768ea1fbf7SHeiko Schocher struct at91_ep *ep0 = &udc->ep[0];
10778ea1fbf7SHeiko Schocher u32 __iomem *creg = ep0->creg;
10788ea1fbf7SHeiko Schocher u32 csr = __raw_readl(creg);
10798ea1fbf7SHeiko Schocher struct at91_request *req;
10808ea1fbf7SHeiko Schocher
10818ea1fbf7SHeiko Schocher if (unlikely(csr & AT91_UDP_STALLSENT)) {
10828ea1fbf7SHeiko Schocher nuke(ep0, -EPROTO);
10838ea1fbf7SHeiko Schocher udc->req_pending = 0;
10848ea1fbf7SHeiko Schocher csr |= CLR_FX;
10858ea1fbf7SHeiko Schocher csr &= ~(SET_FX | AT91_UDP_STALLSENT | AT91_UDP_FORCESTALL);
10868ea1fbf7SHeiko Schocher __raw_writel(csr, creg);
10878ea1fbf7SHeiko Schocher VDBG("ep0 stalled\n");
10888ea1fbf7SHeiko Schocher csr = __raw_readl(creg);
10898ea1fbf7SHeiko Schocher }
10908ea1fbf7SHeiko Schocher if (csr & AT91_UDP_RXSETUP) {
10918ea1fbf7SHeiko Schocher nuke(ep0, 0);
10928ea1fbf7SHeiko Schocher udc->req_pending = 0;
10938ea1fbf7SHeiko Schocher handle_setup(udc, ep0, csr);
10948ea1fbf7SHeiko Schocher return;
10958ea1fbf7SHeiko Schocher }
10968ea1fbf7SHeiko Schocher
10978ea1fbf7SHeiko Schocher if (list_empty(&ep0->queue))
10988ea1fbf7SHeiko Schocher req = NULL;
10998ea1fbf7SHeiko Schocher else
11008ea1fbf7SHeiko Schocher req = list_entry(ep0->queue.next, struct at91_request, queue);
11018ea1fbf7SHeiko Schocher
11028ea1fbf7SHeiko Schocher /* host ACKed an IN packet that we sent */
11038ea1fbf7SHeiko Schocher if (csr & AT91_UDP_TXCOMP) {
11048ea1fbf7SHeiko Schocher csr |= CLR_FX;
11058ea1fbf7SHeiko Schocher csr &= ~(SET_FX | AT91_UDP_TXCOMP);
11068ea1fbf7SHeiko Schocher
11078ea1fbf7SHeiko Schocher /* write more IN DATA? */
11088ea1fbf7SHeiko Schocher if (req && ep0->is_in) {
11098ea1fbf7SHeiko Schocher if (handle_ep(ep0))
11108ea1fbf7SHeiko Schocher udc->req_pending = 0;
11118ea1fbf7SHeiko Schocher
11128ea1fbf7SHeiko Schocher /*
11138ea1fbf7SHeiko Schocher * Ack after:
11148ea1fbf7SHeiko Schocher * - last IN DATA packet (including GET_STATUS)
11158ea1fbf7SHeiko Schocher * - IN/STATUS for OUT DATA
11168ea1fbf7SHeiko Schocher * - IN/STATUS for any zero-length DATA stage
11178ea1fbf7SHeiko Schocher * except for the IN DATA case, the host should send
11188ea1fbf7SHeiko Schocher * an OUT status later, which we'll ack.
11198ea1fbf7SHeiko Schocher */
11208ea1fbf7SHeiko Schocher } else {
11218ea1fbf7SHeiko Schocher udc->req_pending = 0;
11228ea1fbf7SHeiko Schocher __raw_writel(csr, creg);
11238ea1fbf7SHeiko Schocher
11248ea1fbf7SHeiko Schocher /*
11258ea1fbf7SHeiko Schocher * SET_ADDRESS takes effect only after the STATUS
11268ea1fbf7SHeiko Schocher * (to the original address) gets acked.
11278ea1fbf7SHeiko Schocher */
11288ea1fbf7SHeiko Schocher if (udc->wait_for_addr_ack) {
11298ea1fbf7SHeiko Schocher u32 tmp;
11308ea1fbf7SHeiko Schocher
11318ea1fbf7SHeiko Schocher at91_udp_write(udc, AT91_UDP_FADDR,
11328ea1fbf7SHeiko Schocher AT91_UDP_FEN | udc->addr);
11338ea1fbf7SHeiko Schocher tmp = at91_udp_read(udc, AT91_UDP_GLB_STAT);
11348ea1fbf7SHeiko Schocher tmp &= ~AT91_UDP_FADDEN;
11358ea1fbf7SHeiko Schocher if (udc->addr)
11368ea1fbf7SHeiko Schocher tmp |= AT91_UDP_FADDEN;
11378ea1fbf7SHeiko Schocher at91_udp_write(udc, AT91_UDP_GLB_STAT, tmp);
11388ea1fbf7SHeiko Schocher
11398ea1fbf7SHeiko Schocher udc->wait_for_addr_ack = 0;
11408ea1fbf7SHeiko Schocher VDBG("address %d\n", udc->addr);
11418ea1fbf7SHeiko Schocher }
11428ea1fbf7SHeiko Schocher }
11438ea1fbf7SHeiko Schocher }
11448ea1fbf7SHeiko Schocher
11458ea1fbf7SHeiko Schocher /* OUT packet arrived ... */
11468ea1fbf7SHeiko Schocher else if (csr & AT91_UDP_RX_DATA_BK0) {
11478ea1fbf7SHeiko Schocher csr |= CLR_FX;
11488ea1fbf7SHeiko Schocher csr &= ~(SET_FX | AT91_UDP_RX_DATA_BK0);
11498ea1fbf7SHeiko Schocher
11508ea1fbf7SHeiko Schocher /* OUT DATA stage */
11518ea1fbf7SHeiko Schocher if (!ep0->is_in) {
11528ea1fbf7SHeiko Schocher if (req) {
11538ea1fbf7SHeiko Schocher if (handle_ep(ep0)) {
11548ea1fbf7SHeiko Schocher /* send IN/STATUS */
11558ea1fbf7SHeiko Schocher PACKET("ep0 in/status\n");
11568ea1fbf7SHeiko Schocher csr = __raw_readl(creg);
11578ea1fbf7SHeiko Schocher csr &= ~SET_FX;
11588ea1fbf7SHeiko Schocher csr |= CLR_FX | AT91_UDP_TXPKTRDY;
11598ea1fbf7SHeiko Schocher __raw_writel(csr, creg);
11608ea1fbf7SHeiko Schocher udc->req_pending = 0;
11618ea1fbf7SHeiko Schocher }
11628ea1fbf7SHeiko Schocher } else if (udc->req_pending) {
11638ea1fbf7SHeiko Schocher /*
11648ea1fbf7SHeiko Schocher * AT91 hardware has a hard time with this
11658ea1fbf7SHeiko Schocher * "deferred response" mode for control-OUT
11668ea1fbf7SHeiko Schocher * transfers. (For control-IN it's fine.)
11678ea1fbf7SHeiko Schocher *
11688ea1fbf7SHeiko Schocher * The normal solution leaves OUT data in the
11698ea1fbf7SHeiko Schocher * fifo until the gadget driver is ready.
11708ea1fbf7SHeiko Schocher * We couldn't do that here without disabling
11718ea1fbf7SHeiko Schocher * the IRQ that tells about SETUP packets,
11728ea1fbf7SHeiko Schocher * e.g. when the host gets impatient...
11738ea1fbf7SHeiko Schocher *
11748ea1fbf7SHeiko Schocher * Working around it by copying into a buffer
11758ea1fbf7SHeiko Schocher * would almost be a non-deferred response,
11768ea1fbf7SHeiko Schocher * except that it wouldn't permit reliable
11778ea1fbf7SHeiko Schocher * stalling of the request. Instead, demand
11788ea1fbf7SHeiko Schocher * that gadget drivers not use this mode.
11798ea1fbf7SHeiko Schocher */
11808ea1fbf7SHeiko Schocher DBG("no control-OUT deferred responses!\n");
11818ea1fbf7SHeiko Schocher __raw_writel(csr | AT91_UDP_FORCESTALL, creg);
11828ea1fbf7SHeiko Schocher udc->req_pending = 0;
11838ea1fbf7SHeiko Schocher }
11848ea1fbf7SHeiko Schocher
11858ea1fbf7SHeiko Schocher /* STATUS stage for control-IN; ack. */
11868ea1fbf7SHeiko Schocher } else {
11878ea1fbf7SHeiko Schocher PACKET("ep0 out/status ACK\n");
11888ea1fbf7SHeiko Schocher __raw_writel(csr, creg);
11898ea1fbf7SHeiko Schocher
11908ea1fbf7SHeiko Schocher /* "early" status stage */
11918ea1fbf7SHeiko Schocher if (req)
11928ea1fbf7SHeiko Schocher done(ep0, req, 0);
11938ea1fbf7SHeiko Schocher }
11948ea1fbf7SHeiko Schocher }
11958ea1fbf7SHeiko Schocher }
11968ea1fbf7SHeiko Schocher
at91_udc_irq(struct at91_udc * udc)119762019767SHeiko Schocher static irqreturn_t at91_udc_irq(struct at91_udc *udc)
11988ea1fbf7SHeiko Schocher {
11998ea1fbf7SHeiko Schocher u32 rescans = 5;
12008ea1fbf7SHeiko Schocher int disable_clock = 0;
12018ea1fbf7SHeiko Schocher unsigned long flags;
12028ea1fbf7SHeiko Schocher
12038ea1fbf7SHeiko Schocher spin_lock_irqsave(&udc->lock, flags);
12048ea1fbf7SHeiko Schocher
12058ea1fbf7SHeiko Schocher if (!udc->clocked) {
12068ea1fbf7SHeiko Schocher clk_on(udc);
12078ea1fbf7SHeiko Schocher disable_clock = 1;
12088ea1fbf7SHeiko Schocher }
12098ea1fbf7SHeiko Schocher
12108ea1fbf7SHeiko Schocher while (rescans--) {
12118ea1fbf7SHeiko Schocher u32 status;
12128ea1fbf7SHeiko Schocher
12138ea1fbf7SHeiko Schocher status = at91_udp_read(udc, AT91_UDP_ISR)
12148ea1fbf7SHeiko Schocher & at91_udp_read(udc, AT91_UDP_IMR);
12158ea1fbf7SHeiko Schocher if (!status)
12168ea1fbf7SHeiko Schocher break;
12178ea1fbf7SHeiko Schocher
12188ea1fbf7SHeiko Schocher /* USB reset irq: not maskable */
12198ea1fbf7SHeiko Schocher if (status & AT91_UDP_ENDBUSRES) {
12208ea1fbf7SHeiko Schocher at91_udp_write(udc, AT91_UDP_IDR, ~MINIMUS_INTERRUPTUS);
12218ea1fbf7SHeiko Schocher at91_udp_write(udc, AT91_UDP_IER, MINIMUS_INTERRUPTUS);
12228ea1fbf7SHeiko Schocher /* Atmel code clears this irq twice */
12238ea1fbf7SHeiko Schocher at91_udp_write(udc, AT91_UDP_ICR, AT91_UDP_ENDBUSRES);
12248ea1fbf7SHeiko Schocher at91_udp_write(udc, AT91_UDP_ICR, AT91_UDP_ENDBUSRES);
12258ea1fbf7SHeiko Schocher VDBG("end bus reset\n");
12268ea1fbf7SHeiko Schocher udc->addr = 0;
12278ea1fbf7SHeiko Schocher reset_gadget(udc);
12288ea1fbf7SHeiko Schocher
12298ea1fbf7SHeiko Schocher /* enable ep0 */
12308ea1fbf7SHeiko Schocher at91_udp_write(udc, AT91_UDP_CSR(0),
12318ea1fbf7SHeiko Schocher AT91_UDP_EPEDS | AT91_UDP_EPTYPE_CTRL);
12328ea1fbf7SHeiko Schocher udc->gadget.speed = USB_SPEED_FULL;
12338ea1fbf7SHeiko Schocher udc->suspended = 0;
12348ea1fbf7SHeiko Schocher at91_udp_write(udc, AT91_UDP_IER, AT91_UDP_EP(0));
12358ea1fbf7SHeiko Schocher
12368ea1fbf7SHeiko Schocher /*
12378ea1fbf7SHeiko Schocher * NOTE: this driver keeps clocks off unless the
12388ea1fbf7SHeiko Schocher * USB host is present. That saves power, but for
12398ea1fbf7SHeiko Schocher * boards that don't support VBUS detection, both
12408ea1fbf7SHeiko Schocher * clocks need to be active most of the time.
12418ea1fbf7SHeiko Schocher */
12428ea1fbf7SHeiko Schocher
12438ea1fbf7SHeiko Schocher /* host initiated suspend (3+ms bus idle) */
12448ea1fbf7SHeiko Schocher } else if (status & AT91_UDP_RXSUSP) {
12458ea1fbf7SHeiko Schocher at91_udp_write(udc, AT91_UDP_IDR, AT91_UDP_RXSUSP);
12468ea1fbf7SHeiko Schocher at91_udp_write(udc, AT91_UDP_IER, AT91_UDP_RXRSM);
12478ea1fbf7SHeiko Schocher at91_udp_write(udc, AT91_UDP_ICR, AT91_UDP_RXSUSP);
12488ea1fbf7SHeiko Schocher /* VDBG("bus suspend\n"); */
12498ea1fbf7SHeiko Schocher if (udc->suspended)
12508ea1fbf7SHeiko Schocher continue;
12518ea1fbf7SHeiko Schocher udc->suspended = 1;
12528ea1fbf7SHeiko Schocher
12538ea1fbf7SHeiko Schocher /*
12548ea1fbf7SHeiko Schocher * NOTE: when suspending a VBUS-powered device, the
12558ea1fbf7SHeiko Schocher * gadget driver should switch into slow clock mode
12568ea1fbf7SHeiko Schocher * and then into standby to avoid drawing more than
12578ea1fbf7SHeiko Schocher * 500uA power (2500uA for some high-power configs).
12588ea1fbf7SHeiko Schocher */
12598ea1fbf7SHeiko Schocher if (udc->driver && udc->driver->suspend) {
12608ea1fbf7SHeiko Schocher spin_unlock(&udc->lock);
12618ea1fbf7SHeiko Schocher udc->driver->suspend(&udc->gadget);
12628ea1fbf7SHeiko Schocher spin_lock(&udc->lock);
12638ea1fbf7SHeiko Schocher }
12648ea1fbf7SHeiko Schocher
12658ea1fbf7SHeiko Schocher /* host initiated resume */
12668ea1fbf7SHeiko Schocher } else if (status & AT91_UDP_RXRSM) {
12678ea1fbf7SHeiko Schocher at91_udp_write(udc, AT91_UDP_IDR, AT91_UDP_RXRSM);
12688ea1fbf7SHeiko Schocher at91_udp_write(udc, AT91_UDP_IER, AT91_UDP_RXSUSP);
12698ea1fbf7SHeiko Schocher at91_udp_write(udc, AT91_UDP_ICR, AT91_UDP_RXRSM);
12708ea1fbf7SHeiko Schocher /* VDBG("bus resume\n"); */
12718ea1fbf7SHeiko Schocher if (!udc->suspended)
12728ea1fbf7SHeiko Schocher continue;
12738ea1fbf7SHeiko Schocher udc->suspended = 0;
12748ea1fbf7SHeiko Schocher
12758ea1fbf7SHeiko Schocher /*
12768ea1fbf7SHeiko Schocher * NOTE: for a VBUS-powered device, the gadget driver
12778ea1fbf7SHeiko Schocher * would normally want to switch out of slow clock
12788ea1fbf7SHeiko Schocher * mode into normal mode.
12798ea1fbf7SHeiko Schocher */
12808ea1fbf7SHeiko Schocher if (udc->driver && udc->driver->resume) {
12818ea1fbf7SHeiko Schocher spin_unlock(&udc->lock);
12828ea1fbf7SHeiko Schocher udc->driver->resume(&udc->gadget);
12838ea1fbf7SHeiko Schocher spin_lock(&udc->lock);
12848ea1fbf7SHeiko Schocher }
12858ea1fbf7SHeiko Schocher
12868ea1fbf7SHeiko Schocher /* endpoint IRQs are cleared by handling them */
12878ea1fbf7SHeiko Schocher } else {
12888ea1fbf7SHeiko Schocher int i;
12898ea1fbf7SHeiko Schocher unsigned mask = 1;
12908ea1fbf7SHeiko Schocher struct at91_ep *ep = &udc->ep[1];
12918ea1fbf7SHeiko Schocher
12928ea1fbf7SHeiko Schocher if (status & mask)
12938ea1fbf7SHeiko Schocher handle_ep0(udc);
12948ea1fbf7SHeiko Schocher for (i = 1; i < NUM_ENDPOINTS; i++) {
12958ea1fbf7SHeiko Schocher mask <<= 1;
12968ea1fbf7SHeiko Schocher if (status & mask)
12978ea1fbf7SHeiko Schocher handle_ep(ep);
12988ea1fbf7SHeiko Schocher ep++;
12998ea1fbf7SHeiko Schocher }
13008ea1fbf7SHeiko Schocher }
13018ea1fbf7SHeiko Schocher }
13028ea1fbf7SHeiko Schocher
13038ea1fbf7SHeiko Schocher if (disable_clock)
13048ea1fbf7SHeiko Schocher clk_off(udc);
13058ea1fbf7SHeiko Schocher
13068ea1fbf7SHeiko Schocher spin_unlock_irqrestore(&udc->lock, flags);
13078ea1fbf7SHeiko Schocher
13088ea1fbf7SHeiko Schocher return IRQ_HANDLED;
13098ea1fbf7SHeiko Schocher }
13108ea1fbf7SHeiko Schocher
13118ea1fbf7SHeiko Schocher /*-------------------------------------------------------------------------*/
13128ea1fbf7SHeiko Schocher
at91_start(struct usb_gadget * gadget,struct usb_gadget_driver * driver)13138ea1fbf7SHeiko Schocher static int at91_start(struct usb_gadget *gadget,
13148ea1fbf7SHeiko Schocher struct usb_gadget_driver *driver)
13158ea1fbf7SHeiko Schocher {
131662019767SHeiko Schocher struct at91_udc *udc = controller;
13178ea1fbf7SHeiko Schocher
13188ea1fbf7SHeiko Schocher udc->driver = driver;
13198ea1fbf7SHeiko Schocher udc->enabled = 1;
132062019767SHeiko Schocher udc->selfpowered = 1;
13218ea1fbf7SHeiko Schocher
13228ea1fbf7SHeiko Schocher return 0;
13238ea1fbf7SHeiko Schocher }
13248ea1fbf7SHeiko Schocher
at91_stop(struct usb_gadget * gadget)13258ea1fbf7SHeiko Schocher static int at91_stop(struct usb_gadget *gadget)
13268ea1fbf7SHeiko Schocher {
132762019767SHeiko Schocher struct at91_udc *udc = controller;
13288ea1fbf7SHeiko Schocher unsigned long flags;
13298ea1fbf7SHeiko Schocher
13308ea1fbf7SHeiko Schocher spin_lock_irqsave(&udc->lock, flags);
13318ea1fbf7SHeiko Schocher udc->enabled = 0;
13328ea1fbf7SHeiko Schocher at91_udp_write(udc, AT91_UDP_IDR, ~0);
13338ea1fbf7SHeiko Schocher spin_unlock_irqrestore(&udc->lock, flags);
13348ea1fbf7SHeiko Schocher
13358ea1fbf7SHeiko Schocher udc->driver = NULL;
13368ea1fbf7SHeiko Schocher
13378ea1fbf7SHeiko Schocher return 0;
13388ea1fbf7SHeiko Schocher }
13398ea1fbf7SHeiko Schocher
13408ea1fbf7SHeiko Schocher /*-------------------------------------------------------------------------*/
13418ea1fbf7SHeiko Schocher
13422fa5130dSHeiko Schocher #if defined(CONFIG_AT91SAM9260) || defined(CONFIG_AT91SAM9G20)
at91sam9260_udc_init(struct at91_udc * udc)13438ea1fbf7SHeiko Schocher static int at91sam9260_udc_init(struct at91_udc *udc)
13448ea1fbf7SHeiko Schocher {
13458ea1fbf7SHeiko Schocher struct at91_ep *ep;
13468ea1fbf7SHeiko Schocher int i;
13478ea1fbf7SHeiko Schocher
13488ea1fbf7SHeiko Schocher for (i = 0; i < NUM_ENDPOINTS; i++) {
13498ea1fbf7SHeiko Schocher ep = &udc->ep[i];
13508ea1fbf7SHeiko Schocher
13518ea1fbf7SHeiko Schocher switch (i) {
13528ea1fbf7SHeiko Schocher case 0 ... 3:
13538ea1fbf7SHeiko Schocher ep->maxpacket = 64;
13548ea1fbf7SHeiko Schocher break;
13558ea1fbf7SHeiko Schocher case 4 ... 5:
13568ea1fbf7SHeiko Schocher ep->maxpacket = 512;
13578ea1fbf7SHeiko Schocher break;
13588ea1fbf7SHeiko Schocher }
13598ea1fbf7SHeiko Schocher }
13608ea1fbf7SHeiko Schocher
13618ea1fbf7SHeiko Schocher return 0;
13628ea1fbf7SHeiko Schocher }
13638ea1fbf7SHeiko Schocher
at91sam9260_udc_pullup(struct at91_udc * udc,int is_on)13648ea1fbf7SHeiko Schocher static void at91sam9260_udc_pullup(struct at91_udc *udc, int is_on)
13658ea1fbf7SHeiko Schocher {
13668ea1fbf7SHeiko Schocher u32 txvc = at91_udp_read(udc, AT91_UDP_TXVC);
13678ea1fbf7SHeiko Schocher
13688ea1fbf7SHeiko Schocher if (is_on)
13698ea1fbf7SHeiko Schocher txvc |= AT91_UDP_TXVC_PUON;
13708ea1fbf7SHeiko Schocher else
13718ea1fbf7SHeiko Schocher txvc &= ~AT91_UDP_TXVC_PUON;
13728ea1fbf7SHeiko Schocher
13738ea1fbf7SHeiko Schocher at91_udp_write(udc, AT91_UDP_TXVC, txvc);
13748ea1fbf7SHeiko Schocher }
13758ea1fbf7SHeiko Schocher
13768ea1fbf7SHeiko Schocher static const struct at91_udc_caps at91sam9260_udc_caps = {
13778ea1fbf7SHeiko Schocher .init = at91sam9260_udc_init,
13788ea1fbf7SHeiko Schocher .pullup = at91sam9260_udc_pullup,
13798ea1fbf7SHeiko Schocher };
138062019767SHeiko Schocher #endif
13818ea1fbf7SHeiko Schocher
138262019767SHeiko Schocher #if defined(CONFIG_AT91SAM9261)
at91sam9261_udc_init(struct at91_udc * udc)13838ea1fbf7SHeiko Schocher static int at91sam9261_udc_init(struct at91_udc *udc)
13848ea1fbf7SHeiko Schocher {
13858ea1fbf7SHeiko Schocher struct at91_ep *ep;
13868ea1fbf7SHeiko Schocher int i;
13878ea1fbf7SHeiko Schocher
13888ea1fbf7SHeiko Schocher for (i = 0; i < NUM_ENDPOINTS; i++) {
13898ea1fbf7SHeiko Schocher ep = &udc->ep[i];
13908ea1fbf7SHeiko Schocher
13918ea1fbf7SHeiko Schocher switch (i) {
13928ea1fbf7SHeiko Schocher case 0:
13938ea1fbf7SHeiko Schocher ep->maxpacket = 8;
13948ea1fbf7SHeiko Schocher break;
13958ea1fbf7SHeiko Schocher case 1 ... 3:
13968ea1fbf7SHeiko Schocher ep->maxpacket = 64;
13978ea1fbf7SHeiko Schocher break;
13988ea1fbf7SHeiko Schocher case 4 ... 5:
13998ea1fbf7SHeiko Schocher ep->maxpacket = 256;
14008ea1fbf7SHeiko Schocher break;
14018ea1fbf7SHeiko Schocher }
14028ea1fbf7SHeiko Schocher }
14038ea1fbf7SHeiko Schocher
140462019767SHeiko Schocher udc->matrix = (struct at91_matrix *)ATMEL_BASE_MATRIX;
140562019767SHeiko Schocher
14068ea1fbf7SHeiko Schocher if (IS_ERR(udc->matrix))
14078ea1fbf7SHeiko Schocher return PTR_ERR(udc->matrix);
14088ea1fbf7SHeiko Schocher
14098ea1fbf7SHeiko Schocher return 0;
14108ea1fbf7SHeiko Schocher }
14118ea1fbf7SHeiko Schocher
at91sam9261_udc_pullup(struct at91_udc * udc,int is_on)14128ea1fbf7SHeiko Schocher static void at91sam9261_udc_pullup(struct at91_udc *udc, int is_on)
14138ea1fbf7SHeiko Schocher {
14148ea1fbf7SHeiko Schocher u32 usbpucr = 0;
14158ea1fbf7SHeiko Schocher
141662019767SHeiko Schocher usbpucr = readl(&udc->matrix->pucr);
14178ea1fbf7SHeiko Schocher if (is_on)
141862019767SHeiko Schocher usbpucr |= AT91_MATRIX_USBPUCR_PUON;
14198ea1fbf7SHeiko Schocher
142062019767SHeiko Schocher writel(usbpucr, &udc->matrix->pucr);
14218ea1fbf7SHeiko Schocher }
14228ea1fbf7SHeiko Schocher
14238ea1fbf7SHeiko Schocher static const struct at91_udc_caps at91sam9261_udc_caps = {
14248ea1fbf7SHeiko Schocher .init = at91sam9261_udc_init,
14258ea1fbf7SHeiko Schocher .pullup = at91sam9261_udc_pullup,
14268ea1fbf7SHeiko Schocher };
142762019767SHeiko Schocher #endif
14288ea1fbf7SHeiko Schocher
usb_gadget_handle_interrupts(int index)142962019767SHeiko Schocher int usb_gadget_handle_interrupts(int index)
14308ea1fbf7SHeiko Schocher {
143162019767SHeiko Schocher struct at91_udc *udc = controller;
14328ea1fbf7SHeiko Schocher
143362019767SHeiko Schocher return at91_udc_irq(udc);
14348ea1fbf7SHeiko Schocher }
14358ea1fbf7SHeiko Schocher
usb_gadget_register_driver(struct usb_gadget_driver * driver)143662019767SHeiko Schocher int usb_gadget_register_driver(struct usb_gadget_driver *driver)
14378ea1fbf7SHeiko Schocher {
143862019767SHeiko Schocher struct at91_udc *udc = controller;
143962019767SHeiko Schocher int ret;
144062019767SHeiko Schocher
144162019767SHeiko Schocher if (!driver || !driver->bind || !driver->setup) {
144262019767SHeiko Schocher printf("bad paramter\n");
144362019767SHeiko Schocher return -EINVAL;
144462019767SHeiko Schocher }
144562019767SHeiko Schocher
144662019767SHeiko Schocher if (udc->driver) {
144762019767SHeiko Schocher printf("UDC already has a gadget driver\n");
144862019767SHeiko Schocher return -EBUSY;
144962019767SHeiko Schocher }
145062019767SHeiko Schocher
145162019767SHeiko Schocher at91_start(&udc->gadget, driver);
145262019767SHeiko Schocher
145362019767SHeiko Schocher udc->driver = driver;
145462019767SHeiko Schocher
145562019767SHeiko Schocher ret = driver->bind(&udc->gadget);
145662019767SHeiko Schocher if (ret) {
14579b643e31SMasahiro Yamada pr_err("driver->bind() returned %d\n", ret);
145862019767SHeiko Schocher udc->driver = NULL;
145962019767SHeiko Schocher }
146062019767SHeiko Schocher
146162019767SHeiko Schocher return ret;
146262019767SHeiko Schocher }
146362019767SHeiko Schocher
usb_gadget_unregister_driver(struct usb_gadget_driver * driver)146462019767SHeiko Schocher int usb_gadget_unregister_driver(struct usb_gadget_driver *driver)
146562019767SHeiko Schocher {
146662019767SHeiko Schocher struct at91_udc *udc = controller;
146762019767SHeiko Schocher
146862019767SHeiko Schocher if (!driver || !driver->unbind || !driver->disconnect) {
14699b643e31SMasahiro Yamada pr_err("bad paramter\n");
147062019767SHeiko Schocher return -EINVAL;
147162019767SHeiko Schocher }
147262019767SHeiko Schocher
147362019767SHeiko Schocher driver->disconnect(&udc->gadget);
147462019767SHeiko Schocher driver->unbind(&udc->gadget);
147562019767SHeiko Schocher udc->driver = NULL;
147662019767SHeiko Schocher
147762019767SHeiko Schocher at91_stop(&udc->gadget);
147862019767SHeiko Schocher
147962019767SHeiko Schocher return 0;
148062019767SHeiko Schocher }
148162019767SHeiko Schocher
at91_udc_probe(struct at91_udc_data * pdata)148262019767SHeiko Schocher int at91_udc_probe(struct at91_udc_data *pdata)
148362019767SHeiko Schocher {
14848ea1fbf7SHeiko Schocher struct at91_udc *udc;
14858ea1fbf7SHeiko Schocher int retval;
14868ea1fbf7SHeiko Schocher struct at91_ep *ep;
14878ea1fbf7SHeiko Schocher int i;
14888ea1fbf7SHeiko Schocher
148962019767SHeiko Schocher udc = kzalloc(sizeof(*udc), GFP_KERNEL);
14908ea1fbf7SHeiko Schocher if (!udc)
14918ea1fbf7SHeiko Schocher return -ENOMEM;
14928ea1fbf7SHeiko Schocher
149362019767SHeiko Schocher controller = udc;
149462019767SHeiko Schocher memcpy(&udc->board, pdata, sizeof(struct at91_udc_data));
149562019767SHeiko Schocher if (udc->board.vbus_pin) {
149662019767SHeiko Schocher printf("%s: gpio vbus pin not supported yet.\n", __func__);
149762019767SHeiko Schocher return -ENXIO;
149862019767SHeiko Schocher } else {
149962019767SHeiko Schocher DBG("no VBUS detection, assuming always-on\n");
150062019767SHeiko Schocher udc->vbus = 1;
150162019767SHeiko Schocher }
150262019767SHeiko Schocher
150362019767SHeiko Schocher #if defined(CONFIG_AT91SAM9260) || defined(CONFIG_AT91SAM9G20)
150462019767SHeiko Schocher udc->caps = &at91sam9260_udc_caps;
150562019767SHeiko Schocher #endif
150662019767SHeiko Schocher
15078ea1fbf7SHeiko Schocher udc->enabled = 0;
15088ea1fbf7SHeiko Schocher spin_lock_init(&udc->lock);
15098ea1fbf7SHeiko Schocher
15108ea1fbf7SHeiko Schocher udc->gadget.ops = &at91_udc_ops;
15118ea1fbf7SHeiko Schocher udc->gadget.ep0 = &udc->ep[0].ep;
15128ea1fbf7SHeiko Schocher udc->gadget.name = driver_name;
15138ea1fbf7SHeiko Schocher
15148ea1fbf7SHeiko Schocher for (i = 0; i < NUM_ENDPOINTS; i++) {
15158ea1fbf7SHeiko Schocher ep = &udc->ep[i];
15168ea1fbf7SHeiko Schocher ep->ep.name = ep_names[i];
15178ea1fbf7SHeiko Schocher ep->ep.ops = &at91_ep_ops;
15188ea1fbf7SHeiko Schocher ep->udc = udc;
151962019767SHeiko Schocher ep->int_mask = (1 << i);
15208ea1fbf7SHeiko Schocher if (i != 0 && i != 3)
15218ea1fbf7SHeiko Schocher ep->is_pingpong = 1;
15228ea1fbf7SHeiko Schocher }
15238ea1fbf7SHeiko Schocher
152462019767SHeiko Schocher udc->udp_baseaddr = (void *)udc->board.baseaddr;
15258ea1fbf7SHeiko Schocher if (IS_ERR(udc->udp_baseaddr))
15268ea1fbf7SHeiko Schocher return PTR_ERR(udc->udp_baseaddr);
15278ea1fbf7SHeiko Schocher
15288ea1fbf7SHeiko Schocher if (udc->caps && udc->caps->init) {
15298ea1fbf7SHeiko Schocher retval = udc->caps->init(udc);
15308ea1fbf7SHeiko Schocher if (retval)
15318ea1fbf7SHeiko Schocher return retval;
15328ea1fbf7SHeiko Schocher }
15338ea1fbf7SHeiko Schocher
15348ea1fbf7SHeiko Schocher udc_reinit(udc);
15358ea1fbf7SHeiko Schocher
15368ea1fbf7SHeiko Schocher at91_udp_write(udc, AT91_UDP_TXVC, AT91_UDP_TXVC_TXVDIS);
15378ea1fbf7SHeiko Schocher at91_udp_write(udc, AT91_UDP_IDR, 0xffffffff);
15388ea1fbf7SHeiko Schocher /* Clear all pending interrupts - UDP may be used by bootloader. */
15398ea1fbf7SHeiko Schocher at91_udp_write(udc, AT91_UDP_ICR, 0xffffffff);
15408ea1fbf7SHeiko Schocher
15418ea1fbf7SHeiko Schocher INFO("%s version %s\n", driver_name, DRIVER_VERSION);
15428ea1fbf7SHeiko Schocher return 0;
15438ea1fbf7SHeiko Schocher }
1544