drivers/usb/gadget/udc/at91_udc.c

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