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/gpio/consumer.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 = NULL, *iter;
 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(iter, &ep->queue, queue) {
 721                 if (&iter->req != _req)
 722                         continue;
 723                 req = iter;
 724                 break;
 725         }
 726         if (!req) {
 727                 spin_unlock_irqrestore(&udc->lock, flags);
 728                 return -EINVAL;
 729         }
 730
 731         done(ep, req, -ECONNRESET);
 732         spin_unlock_irqrestore(&udc->lock, flags);
 733         return 0;
 734 }
 735
 736 static int at91_ep_set_halt(struct usb_ep *_ep, int value)
 737 {
 738         struct at91_ep  *ep = container_of(_ep, struct at91_ep, ep);
 739         struct at91_udc *udc = ep->udc;
 740         u32 __iomem     *creg;
 741         u32             csr;
 742         unsigned long   flags;
 743         int             status = 0;
 744
 745         if (!_ep || ep->is_iso || !ep->udc->clocked)
 746                 return -EINVAL;
 747
 748         creg = ep->creg;
 749         spin_lock_irqsave(&udc->lock, flags);
 750
 751         csr = __raw_readl(creg);
 752
 753         /*
 754          * fail with still-busy IN endpoints, ensuring correct sequencing
 755          * of data tx then stall.  note that the fifo rx bytecount isn't
 756          * completely accurate as a tx bytecount.
 757          */
 758         if (ep->is_in && (!list_empty(&ep->queue) || (csr >> 16) != 0))
 759                 status = -EAGAIN;
 760         else {
 761                 csr |= CLR_FX;
 762                 csr &= ~SET_FX;
 763                 if (value) {
 764                         csr |= AT91_UDP_FORCESTALL;
 765                         VDBG("halt %s\n", ep->ep.name);
 766                 } else {
 767                         at91_udp_write(udc, AT91_UDP_RST_EP, ep->int_mask);
 768                         at91_udp_write(udc, AT91_UDP_RST_EP, 0);
 769                         csr &= ~AT91_UDP_FORCESTALL;
 770                 }
 771                 __raw_writel(csr, creg);
 772         }
 773
 774         spin_unlock_irqrestore(&udc->lock, flags);
 775         return status;
 776 }
 777
 778 static const struct usb_ep_ops at91_ep_ops = {
 779         .enable         = at91_ep_enable,
 780         .disable        = at91_ep_disable,
 781         .alloc_request  = at91_ep_alloc_request,
 782         .free_request   = at91_ep_free_request,
 783         .queue          = at91_ep_queue,
 784         .dequeue        = at91_ep_dequeue,
 785         .set_halt       = at91_ep_set_halt,
 786         /* there's only imprecise fifo status reporting */
 787 };
 788
 789 /*-------------------------------------------------------------------------*/
 790
 791 static int at91_get_frame(struct usb_gadget *gadget)
 792 {
 793         struct at91_udc *udc = to_udc(gadget);
 794
 795         if (!to_udc(gadget)->clocked)
 796                 return -EINVAL;
 797         return at91_udp_read(udc, AT91_UDP_FRM_NUM) & AT91_UDP_NUM;
 798 }
 799
 800 static int at91_wakeup(struct usb_gadget *gadget)
 801 {
 802         struct at91_udc *udc = to_udc(gadget);
 803         u32             glbstate;
 804         unsigned long   flags;
 805
 806         DBG("%s\n", __func__ );
 807         spin_lock_irqsave(&udc->lock, flags);
 808
 809         if (!udc->clocked || !udc->suspended)
 810                 goto done;
 811
 812         /* NOTE:  some "early versions" handle ESR differently ... */
 813
 814         glbstate = at91_udp_read(udc, AT91_UDP_GLB_STAT);
 815         if (!(glbstate & AT91_UDP_ESR))
 816                 goto done;
 817         glbstate |= AT91_UDP_ESR;
 818         at91_udp_write(udc, AT91_UDP_GLB_STAT, glbstate);
 819
 820 done:
 821         spin_unlock_irqrestore(&udc->lock, flags);
 822         return 0;
 823 }
 824
 825 /* reinit == restore initial software state */
 826 static void udc_reinit(struct at91_udc *udc)
 827 {
 828         u32 i;
 829
 830         INIT_LIST_HEAD(&udc->gadget.ep_list);
 831         INIT_LIST_HEAD(&udc->gadget.ep0->ep_list);
 832         udc->gadget.quirk_stall_not_supp = 1;
 833
 834         for (i = 0; i < NUM_ENDPOINTS; i++) {
 835                 struct at91_ep *ep = &udc->ep[i];
 836
 837                 if (i != 0)
 838                         list_add_tail(&ep->ep.ep_list, &udc->gadget.ep_list);
 839                 ep->ep.desc = NULL;
 840                 ep->stopped = 0;
 841                 ep->fifo_bank = 0;
 842                 usb_ep_set_maxpacket_limit(&ep->ep, ep->maxpacket);
 843                 ep->creg = (void __iomem *) udc->udp_baseaddr + AT91_UDP_CSR(i);
 844                 /* initialize one queue per endpoint */
 845                 INIT_LIST_HEAD(&ep->queue);
 846         }
 847 }
 848
 849 static void reset_gadget(struct at91_udc *udc)
 850 {
 851         struct usb_gadget_driver *driver = udc->driver;
 852         int i;
 853
 854         if (udc->gadget.speed == USB_SPEED_UNKNOWN)
 855                 driver = NULL;
 856         udc->gadget.speed = USB_SPEED_UNKNOWN;
 857         udc->suspended = 0;
 858
 859         for (i = 0; i < NUM_ENDPOINTS; i++) {
 860                 struct at91_ep *ep = &udc->ep[i];
 861
 862                 ep->stopped = 1;
 863                 nuke(ep, -ESHUTDOWN);
 864         }
 865         if (driver) {
 866                 spin_unlock(&udc->lock);
 867                 usb_gadget_udc_reset(&udc->gadget, driver);
 868                 spin_lock(&udc->lock);
 869         }
 870
 871         udc_reinit(udc);
 872 }
 873
 874 static void stop_activity(struct at91_udc *udc)
 875 {
 876         struct usb_gadget_driver *driver = udc->driver;
 877         int i;
 878
 879         if (udc->gadget.speed == USB_SPEED_UNKNOWN)
 880                 driver = NULL;
 881         udc->gadget.speed = USB_SPEED_UNKNOWN;
 882         udc->suspended = 0;
 883
 884         for (i = 0; i < NUM_ENDPOINTS; i++) {
 885                 struct at91_ep *ep = &udc->ep[i];
 886                 ep->stopped = 1;
 887                 nuke(ep, -ESHUTDOWN);
 888         }
 889         if (driver) {
 890                 spin_unlock(&udc->lock);
 891                 driver->disconnect(&udc->gadget);
 892                 spin_lock(&udc->lock);
 893         }
 894
 895         udc_reinit(udc);
 896 }
 897
 898 static void clk_on(struct at91_udc *udc)
 899 {
 900         if (udc->clocked)
 901                 return;
 902         udc->clocked = 1;
 903
 904         clk_enable(udc->iclk);
 905         clk_enable(udc->fclk);
 906 }
 907
 908 static void clk_off(struct at91_udc *udc)
 909 {
 910         if (!udc->clocked)
 911                 return;
 912         udc->clocked = 0;
 913         udc->gadget.speed = USB_SPEED_UNKNOWN;
 914         clk_disable(udc->fclk);
 915         clk_disable(udc->iclk);
 916 }
 917
 918 /*
 919  * activate/deactivate link with host; minimize power usage for
 920  * inactive links by cutting clocks and transceiver power.
 921  */
 922 static void pullup(struct at91_udc *udc, int is_on)
 923 {
 924         if (!udc->enabled || !udc->vbus)
 925                 is_on = 0;
 926         DBG("%sactive\n", is_on ? "" : "in");
 927
 928         if (is_on) {
 929                 clk_on(udc);
 930                 at91_udp_write(udc, AT91_UDP_ICR, AT91_UDP_RXRSM);
 931                 at91_udp_write(udc, AT91_UDP_TXVC, 0);
 932         } else {
 933                 stop_activity(udc);
 934                 at91_udp_write(udc, AT91_UDP_IDR, AT91_UDP_RXRSM);
 935                 at91_udp_write(udc, AT91_UDP_TXVC, AT91_UDP_TXVC_TXVDIS);
 936                 clk_off(udc);
 937         }
 938
 939         if (udc->caps && udc->caps->pullup)
 940                 udc->caps->pullup(udc, is_on);
 941 }
 942
 943 /* vbus is here!  turn everything on that's ready */
 944 static int at91_vbus_session(struct usb_gadget *gadget, int is_active)
 945 {
 946         struct at91_udc *udc = to_udc(gadget);
 947         unsigned long   flags;
 948
 949         /* VDBG("vbus %s\n", is_active ? "on" : "off"); */
 950         spin_lock_irqsave(&udc->lock, flags);
 951         udc->vbus = (is_active != 0);
 952         if (udc->driver)
 953                 pullup(udc, is_active);
 954         else
 955                 pullup(udc, 0);
 956         spin_unlock_irqrestore(&udc->lock, flags);
 957         return 0;
 958 }
 959
 960 static int at91_pullup(struct usb_gadget *gadget, int is_on)
 961 {
 962         struct at91_udc *udc = to_udc(gadget);
 963         unsigned long   flags;
 964
 965         spin_lock_irqsave(&udc->lock, flags);
 966         udc->enabled = is_on = !!is_on;
 967         pullup(udc, is_on);
 968         spin_unlock_irqrestore(&udc->lock, flags);
 969         return 0;
 970 }
 971
 972 static int at91_set_selfpowered(struct usb_gadget *gadget, int is_on)
 973 {
 974         struct at91_udc *udc = to_udc(gadget);
 975         unsigned long   flags;
 976
 977         spin_lock_irqsave(&udc->lock, flags);
 978         gadget->is_selfpowered = (is_on != 0);
 979         spin_unlock_irqrestore(&udc->lock, flags);
 980         return 0;
 981 }
 982
 983 static int at91_start(struct usb_gadget *gadget,
 984                 struct usb_gadget_driver *driver);
 985 static int at91_stop(struct usb_gadget *gadget);
 986
 987 static const struct usb_gadget_ops at91_udc_ops = {
 988         .get_frame              = at91_get_frame,
 989         .wakeup                 = at91_wakeup,
 990         .set_selfpowered        = at91_set_selfpowered,
 991         .vbus_session           = at91_vbus_session,
 992         .pullup                 = at91_pullup,
 993         .udc_start              = at91_start,
 994         .udc_stop               = at91_stop,
 995
 996         /*
 997          * VBUS-powered devices may also also want to support bigger
 998          * power budgets after an appropriate SET_CONFIGURATION.
 999          */
1000         /* .vbus_power          = at91_vbus_power, */
1001 };
1002
1003 /*-------------------------------------------------------------------------*/
1004
1005 static int handle_ep(struct at91_ep *ep)
1006 {
1007         struct at91_request     *req;
1008         u32 __iomem             *creg = ep->creg;
1009         u32                     csr = __raw_readl(creg);
1010
1011         if (!list_empty(&ep->queue))
1012                 req = list_entry(ep->queue.next,
1013                         struct at91_request, queue);
1014         else
1015                 req = NULL;
1016
1017         if (ep->is_in) {
1018                 if (csr & (AT91_UDP_STALLSENT | AT91_UDP_TXCOMP)) {
1019                         csr |= CLR_FX;
1020                         csr &= ~(SET_FX | AT91_UDP_STALLSENT | AT91_UDP_TXCOMP);
1021                         __raw_writel(csr, creg);
1022                 }
1023                 if (req)
1024                         return write_fifo(ep, req);
1025
1026         } else {
1027                 if (csr & AT91_UDP_STALLSENT) {
1028                         /* STALLSENT bit == ISOERR */
1029                         if (ep->is_iso && req)
1030                                 req->req.status = -EILSEQ;
1031                         csr |= CLR_FX;
1032                         csr &= ~(SET_FX | AT91_UDP_STALLSENT);
1033                         __raw_writel(csr, creg);
1034                         csr = __raw_readl(creg);
1035                 }
1036                 if (req && (csr & RX_DATA_READY))
1037                         return read_fifo(ep, req);
1038         }
1039         return 0;
1040 }
1041
1042 union setup {
1043         u8                      raw[8];
1044         struct usb_ctrlrequest  r;
1045 };
1046
1047 static void handle_setup(struct at91_udc *udc, struct at91_ep *ep, u32 csr)
1048 {
1049         u32 __iomem     *creg = ep->creg;
1050         u8 __iomem      *dreg = ep->creg + (AT91_UDP_FDR(0) - AT91_UDP_CSR(0));
1051         unsigned        rxcount, i = 0;
1052         u32             tmp;
1053         union setup     pkt;
1054         int             status = 0;
1055
1056         /* read and ack SETUP; hard-fail for bogus packets */
1057         rxcount = (csr & AT91_UDP_RXBYTECNT) >> 16;
1058         if (likely(rxcount == 8)) {
1059                 while (rxcount--)
1060                         pkt.raw[i++] = __raw_readb(dreg);
1061                 if (pkt.r.bRequestType & USB_DIR_IN) {
1062                         csr |= AT91_UDP_DIR;
1063                         ep->is_in = 1;
1064                 } else {
1065                         csr &= ~AT91_UDP_DIR;
1066                         ep->is_in = 0;
1067                 }
1068         } else {
1069                 /* REVISIT this happens sometimes under load; why?? */
1070                 ERR("SETUP len %d, csr %08x\n", rxcount, csr);
1071                 status = -EINVAL;
1072         }
1073         csr |= CLR_FX;
1074         csr &= ~(SET_FX | AT91_UDP_RXSETUP);
1075         __raw_writel(csr, creg);
1076         udc->wait_for_addr_ack = 0;
1077         udc->wait_for_config_ack = 0;
1078         ep->stopped = 0;
1079         if (unlikely(status != 0))
1080                 goto stall;
1081
1082 #define w_index         le16_to_cpu(pkt.r.wIndex)
1083 #define w_value         le16_to_cpu(pkt.r.wValue)
1084 #define w_length        le16_to_cpu(pkt.r.wLength)
1085
1086         VDBG("SETUP %02x.%02x v%04x i%04x l%04x\n",
1087                         pkt.r.bRequestType, pkt.r.bRequest,
1088                         w_value, w_index, w_length);
1089
1090         /*
1091          * A few standard requests get handled here, ones that touch
1092          * hardware ... notably for device and endpoint features.
1093          */
1094         udc->req_pending = 1;
1095         csr = __raw_readl(creg);
1096         csr |= CLR_FX;
1097         csr &= ~SET_FX;
1098         switch ((pkt.r.bRequestType << 8) | pkt.r.bRequest) {
1099
1100         case ((USB_TYPE_STANDARD|USB_RECIP_DEVICE) << 8)
1101                         | USB_REQ_SET_ADDRESS:
1102                 __raw_writel(csr | AT91_UDP_TXPKTRDY, creg);
1103                 udc->addr = w_value;
1104                 udc->wait_for_addr_ack = 1;
1105                 udc->req_pending = 0;
1106                 /* FADDR is set later, when we ack host STATUS */
1107                 return;
1108
1109         case ((USB_TYPE_STANDARD|USB_RECIP_DEVICE) << 8)
1110                         | USB_REQ_SET_CONFIGURATION:
1111                 tmp = at91_udp_read(udc, AT91_UDP_GLB_STAT) & AT91_UDP_CONFG;
1112                 if (pkt.r.wValue)
1113                         udc->wait_for_config_ack = (tmp == 0);
1114                 else
1115                         udc->wait_for_config_ack = (tmp != 0);
1116                 if (udc->wait_for_config_ack)
1117                         VDBG("wait for config\n");
1118                 /* CONFG is toggled later, if gadget driver succeeds */
1119                 break;
1120
1121         /*
1122          * Hosts may set or clear remote wakeup status, and
1123          * devices may report they're VBUS powered.
1124          */
1125         case ((USB_DIR_IN|USB_TYPE_STANDARD|USB_RECIP_DEVICE) << 8)
1126                         | USB_REQ_GET_STATUS:
1127                 tmp = (udc->gadget.is_selfpowered << USB_DEVICE_SELF_POWERED);
1128                 if (at91_udp_read(udc, AT91_UDP_GLB_STAT) & AT91_UDP_ESR)
1129                         tmp |= (1 << USB_DEVICE_REMOTE_WAKEUP);
1130                 PACKET("get device status\n");
1131                 __raw_writeb(tmp, dreg);
1132                 __raw_writeb(0, dreg);
1133                 goto write_in;
1134                 /* then STATUS starts later, automatically */
1135         case ((USB_TYPE_STANDARD|USB_RECIP_DEVICE) << 8)
1136                         | USB_REQ_SET_FEATURE:
1137                 if (w_value != USB_DEVICE_REMOTE_WAKEUP)
1138                         goto stall;
1139                 tmp = at91_udp_read(udc, AT91_UDP_GLB_STAT);
1140                 tmp |= AT91_UDP_ESR;
1141                 at91_udp_write(udc, AT91_UDP_GLB_STAT, tmp);
1142                 goto succeed;
1143         case ((USB_TYPE_STANDARD|USB_RECIP_DEVICE) << 8)
1144                         | USB_REQ_CLEAR_FEATURE:
1145                 if (w_value != USB_DEVICE_REMOTE_WAKEUP)
1146                         goto stall;
1147                 tmp = at91_udp_read(udc, AT91_UDP_GLB_STAT);
1148                 tmp &= ~AT91_UDP_ESR;
1149                 at91_udp_write(udc, AT91_UDP_GLB_STAT, tmp);
1150                 goto succeed;
1151
1152         /*
1153          * Interfaces have no feature settings; this is pretty useless.
1154          * we won't even insist the interface exists...
1155          */
1156         case ((USB_DIR_IN|USB_TYPE_STANDARD|USB_RECIP_INTERFACE) << 8)
1157                         | USB_REQ_GET_STATUS:
1158                 PACKET("get interface status\n");
1159                 __raw_writeb(0, dreg);
1160                 __raw_writeb(0, dreg);
1161                 goto write_in;
1162                 /* then STATUS starts later, automatically */
1163         case ((USB_TYPE_STANDARD|USB_RECIP_INTERFACE) << 8)
1164                         | USB_REQ_SET_FEATURE:
1165         case ((USB_TYPE_STANDARD|USB_RECIP_INTERFACE) << 8)
1166                         | USB_REQ_CLEAR_FEATURE:
1167                 goto stall;
1168
1169         /*
1170          * Hosts may clear bulk/intr endpoint halt after the gadget
1171          * driver sets it (not widely used); or set it (for testing)
1172          */
1173         case ((USB_DIR_IN|USB_TYPE_STANDARD|USB_RECIP_ENDPOINT) << 8)
1174                         | USB_REQ_GET_STATUS:
1175                 tmp = w_index & USB_ENDPOINT_NUMBER_MASK;
1176                 ep = &udc->ep[tmp];
1177                 if (tmp >= NUM_ENDPOINTS || (tmp && !ep->ep.desc))
1178                         goto stall;
1179
1180                 if (tmp) {
1181                         if ((w_index & USB_DIR_IN)) {
1182                                 if (!ep->is_in)
1183                                         goto stall;
1184                         } else if (ep->is_in)
1185                                 goto stall;
1186                 }
1187                 PACKET("get %s status\n", ep->ep.name);
1188                 if (__raw_readl(ep->creg) & AT91_UDP_FORCESTALL)
1189                         tmp = (1 << USB_ENDPOINT_HALT);
1190                 else
1191                         tmp = 0;
1192                 __raw_writeb(tmp, dreg);
1193                 __raw_writeb(0, dreg);
1194                 goto write_in;
1195                 /* then STATUS starts later, automatically */
1196         case ((USB_TYPE_STANDARD|USB_RECIP_ENDPOINT) << 8)
1197                         | USB_REQ_SET_FEATURE:
1198                 tmp = w_index & USB_ENDPOINT_NUMBER_MASK;
1199                 ep = &udc->ep[tmp];
1200                 if (w_value != USB_ENDPOINT_HALT || tmp >= NUM_ENDPOINTS)
1201                         goto stall;
1202                 if (!ep->ep.desc || ep->is_iso)
1203                         goto stall;
1204                 if ((w_index & USB_DIR_IN)) {
1205                         if (!ep->is_in)
1206                                 goto stall;
1207                 } else if (ep->is_in)
1208                         goto stall;
1209
1210                 tmp = __raw_readl(ep->creg);
1211                 tmp &= ~SET_FX;
1212                 tmp |= CLR_FX | AT91_UDP_FORCESTALL;
1213                 __raw_writel(tmp, ep->creg);
1214                 goto succeed;
1215         case ((USB_TYPE_STANDARD|USB_RECIP_ENDPOINT) << 8)
1216                         | USB_REQ_CLEAR_FEATURE:
1217                 tmp = w_index & USB_ENDPOINT_NUMBER_MASK;
1218                 ep = &udc->ep[tmp];
1219                 if (w_value != USB_ENDPOINT_HALT || tmp >= NUM_ENDPOINTS)
1220                         goto stall;
1221                 if (tmp == 0)
1222                         goto succeed;
1223                 if (!ep->ep.desc || ep->is_iso)
1224                         goto stall;
1225                 if ((w_index & USB_DIR_IN)) {
1226                         if (!ep->is_in)
1227                                 goto stall;
1228                 } else if (ep->is_in)
1229                         goto stall;
1230
1231                 at91_udp_write(udc, AT91_UDP_RST_EP, ep->int_mask);
1232                 at91_udp_write(udc, AT91_UDP_RST_EP, 0);
1233                 tmp = __raw_readl(ep->creg);
1234                 tmp |= CLR_FX;
1235                 tmp &= ~(SET_FX | AT91_UDP_FORCESTALL);
1236                 __raw_writel(tmp, ep->creg);
1237                 if (!list_empty(&ep->queue))
1238                         handle_ep(ep);
1239                 goto succeed;
1240         }
1241
1242 #undef w_value
1243 #undef w_index
1244 #undef w_length
1245
1246         /* pass request up to the gadget driver */
1247         if (udc->driver) {
1248                 spin_unlock(&udc->lock);
1249                 status = udc->driver->setup(&udc->gadget, &pkt.r);
1250                 spin_lock(&udc->lock);
1251         }
1252         else
1253                 status = -ENODEV;
1254         if (status < 0) {
1255 stall:
1256                 VDBG("req %02x.%02x protocol STALL; stat %d\n",
1257                                 pkt.r.bRequestType, pkt.r.bRequest, status);
1258                 csr |= AT91_UDP_FORCESTALL;
1259                 __raw_writel(csr, creg);
1260                 udc->req_pending = 0;
1261         }
1262         return;
1263
1264 succeed:
1265         /* immediate successful (IN) STATUS after zero length DATA */
1266         PACKET("ep0 in/status\n");
1267 write_in:
1268         csr |= AT91_UDP_TXPKTRDY;
1269         __raw_writel(csr, creg);
1270         udc->req_pending = 0;
1271 }
1272
1273 static void handle_ep0(struct at91_udc *udc)
1274 {
1275         struct at91_ep          *ep0 = &udc->ep[0];
1276         u32 __iomem             *creg = ep0->creg;
1277         u32                     csr = __raw_readl(creg);
1278         struct at91_request     *req;
1279
1280         if (unlikely(csr & AT91_UDP_STALLSENT)) {
1281                 nuke(ep0, -EPROTO);
1282                 udc->req_pending = 0;
1283                 csr |= CLR_FX;
1284                 csr &= ~(SET_FX | AT91_UDP_STALLSENT | AT91_UDP_FORCESTALL);
1285                 __raw_writel(csr, creg);
1286                 VDBG("ep0 stalled\n");
1287                 csr = __raw_readl(creg);
1288         }
1289         if (csr & AT91_UDP_RXSETUP) {
1290                 nuke(ep0, 0);
1291                 udc->req_pending = 0;
1292                 handle_setup(udc, ep0, csr);
1293                 return;
1294         }
1295
1296         if (list_empty(&ep0->queue))
1297                 req = NULL;
1298         else
1299                 req = list_entry(ep0->queue.next, struct at91_request, queue);
1300
1301         /* host ACKed an IN packet that we sent */
1302         if (csr & AT91_UDP_TXCOMP) {
1303                 csr |= CLR_FX;
1304                 csr &= ~(SET_FX | AT91_UDP_TXCOMP);
1305
1306                 /* write more IN DATA? */
1307                 if (req && ep0->is_in) {
1308                         if (handle_ep(ep0))
1309                                 udc->req_pending = 0;
1310
1311                 /*
1312                  * Ack after:
1313                  *  - last IN DATA packet (including GET_STATUS)
1314                  *  - IN/STATUS for OUT DATA
1315                  *  - IN/STATUS for any zero-length DATA stage
1316                  * except for the IN DATA case, the host should send
1317                  * an OUT status later, which we'll ack.
1318                  */
1319                 } else {
1320                         udc->req_pending = 0;
1321                         __raw_writel(csr, creg);
1322
1323                         /*
1324                          * SET_ADDRESS takes effect only after the STATUS
1325                          * (to the original address) gets acked.
1326                          */
1327                         if (udc->wait_for_addr_ack) {
1328                                 u32     tmp;
1329
1330                                 at91_udp_write(udc, AT91_UDP_FADDR,
1331                                                 AT91_UDP_FEN | udc->addr);
1332                                 tmp = at91_udp_read(udc, AT91_UDP_GLB_STAT);
1333                                 tmp &= ~AT91_UDP_FADDEN;
1334                                 if (udc->addr)
1335                                         tmp |= AT91_UDP_FADDEN;
1336                                 at91_udp_write(udc, AT91_UDP_GLB_STAT, tmp);
1337
1338                                 udc->wait_for_addr_ack = 0;
1339                                 VDBG("address %d\n", udc->addr);
1340                         }
1341                 }
1342         }
1343
1344         /* OUT packet arrived ... */
1345         else if (csr & AT91_UDP_RX_DATA_BK0) {
1346                 csr |= CLR_FX;
1347                 csr &= ~(SET_FX | AT91_UDP_RX_DATA_BK0);
1348
1349                 /* OUT DATA stage */
1350                 if (!ep0->is_in) {
1351                         if (req) {
1352                                 if (handle_ep(ep0)) {
1353                                         /* send IN/STATUS */
1354                                         PACKET("ep0 in/status\n");
1355                                         csr = __raw_readl(creg);
1356                                         csr &= ~SET_FX;
1357                                         csr |= CLR_FX | AT91_UDP_TXPKTRDY;
1358                                         __raw_writel(csr, creg);
1359                                         udc->req_pending = 0;
1360                                 }
1361                         } else if (udc->req_pending) {
1362                                 /*
1363                                  * AT91 hardware has a hard time with this
1364                                  * "deferred response" mode for control-OUT
1365                                  * transfers.  (For control-IN it's fine.)
1366                                  *
1367                                  * The normal solution leaves OUT data in the
1368                                  * fifo until the gadget driver is ready.
1369                                  * We couldn't do that here without disabling
1370                                  * the IRQ that tells about SETUP packets,
1371                                  * e.g. when the host gets impatient...
1372                                  *
1373                                  * Working around it by copying into a buffer
1374                                  * would almost be a non-deferred response,
1375                                  * except that it wouldn't permit reliable
1376                                  * stalling of the request.  Instead, demand
1377                                  * that gadget drivers not use this mode.
1378                                  */
1379                                 DBG("no control-OUT deferred responses!\n");
1380                                 __raw_writel(csr | AT91_UDP_FORCESTALL, creg);
1381                                 udc->req_pending = 0;
1382                         }
1383
1384                 /* STATUS stage for control-IN; ack.  */
1385                 } else {
1386                         PACKET("ep0 out/status ACK\n");
1387                         __raw_writel(csr, creg);
1388
1389                         /* "early" status stage */
1390                         if (req)
1391                                 done(ep0, req, 0);
1392                 }
1393         }
1394 }
1395
1396 static irqreturn_t at91_udc_irq (int irq, void *_udc)
1397 {
1398         struct at91_udc         *udc = _udc;
1399         u32                     rescans = 5;
1400         int                     disable_clock = 0;
1401         unsigned long           flags;
1402
1403         spin_lock_irqsave(&udc->lock, flags);
1404
1405         if (!udc->clocked) {
1406                 clk_on(udc);
1407                 disable_clock = 1;
1408         }
1409
1410         while (rescans--) {
1411                 u32 status;
1412
1413                 status = at91_udp_read(udc, AT91_UDP_ISR)
1414                         & at91_udp_read(udc, AT91_UDP_IMR);
1415                 if (!status)
1416                         break;
1417
1418                 /* USB reset irq:  not maskable */
1419                 if (status & AT91_UDP_ENDBUSRES) {
1420                         at91_udp_write(udc, AT91_UDP_IDR, ~MINIMUS_INTERRUPTUS);
1421                         at91_udp_write(udc, AT91_UDP_IER, MINIMUS_INTERRUPTUS);
1422                         /* Atmel code clears this irq twice */
1423                         at91_udp_write(udc, AT91_UDP_ICR, AT91_UDP_ENDBUSRES);
1424                         at91_udp_write(udc, AT91_UDP_ICR, AT91_UDP_ENDBUSRES);
1425                         VDBG("end bus reset\n");
1426                         udc->addr = 0;
1427                         reset_gadget(udc);
1428
1429                         /* enable ep0 */
1430                         at91_udp_write(udc, AT91_UDP_CSR(0),
1431                                         AT91_UDP_EPEDS | AT91_UDP_EPTYPE_CTRL);
1432                         udc->gadget.speed = USB_SPEED_FULL;
1433                         udc->suspended = 0;
1434                         at91_udp_write(udc, AT91_UDP_IER, AT91_UDP_EP(0));
1435
1436                         /*
1437                          * NOTE:  this driver keeps clocks off unless the
1438                          * USB host is present.  That saves power, but for
1439                          * boards that don't support VBUS detection, both
1440                          * clocks need to be active most of the time.
1441                          */
1442
1443                 /* host initiated suspend (3+ms bus idle) */
1444                 } else if (status & AT91_UDP_RXSUSP) {
1445                         at91_udp_write(udc, AT91_UDP_IDR, AT91_UDP_RXSUSP);
1446                         at91_udp_write(udc, AT91_UDP_IER, AT91_UDP_RXRSM);
1447                         at91_udp_write(udc, AT91_UDP_ICR, AT91_UDP_RXSUSP);
1448                         /* VDBG("bus suspend\n"); */
1449                         if (udc->suspended)
1450                                 continue;
1451                         udc->suspended = 1;
1452
1453                         /*
1454                          * NOTE:  when suspending a VBUS-powered device, the
1455                          * gadget driver should switch into slow clock mode
1456                          * and then into standby to avoid drawing more than
1457                          * 500uA power (2500uA for some high-power configs).
1458                          */
1459                         if (udc->driver && udc->driver->suspend) {
1460                                 spin_unlock(&udc->lock);
1461                                 udc->driver->suspend(&udc->gadget);
1462                                 spin_lock(&udc->lock);
1463                         }
1464
1465                 /* host initiated resume */
1466                 } else if (status & AT91_UDP_RXRSM) {
1467                         at91_udp_write(udc, AT91_UDP_IDR, AT91_UDP_RXRSM);
1468                         at91_udp_write(udc, AT91_UDP_IER, AT91_UDP_RXSUSP);
1469                         at91_udp_write(udc, AT91_UDP_ICR, AT91_UDP_RXRSM);
1470                         /* VDBG("bus resume\n"); */
1471                         if (!udc->suspended)
1472                                 continue;
1473                         udc->suspended = 0;
1474
1475                         /*
1476                          * NOTE:  for a VBUS-powered device, the gadget driver
1477                          * would normally want to switch out of slow clock
1478                          * mode into normal mode.
1479                          */
1480                         if (udc->driver && udc->driver->resume) {
1481                                 spin_unlock(&udc->lock);
1482                                 udc->driver->resume(&udc->gadget);
1483                                 spin_lock(&udc->lock);
1484                         }
1485
1486                 /* endpoint IRQs are cleared by handling them */
1487                 } else {
1488                         int             i;
1489                         unsigned        mask = 1;
1490                         struct at91_ep  *ep = &udc->ep[1];
1491
1492                         if (status & mask)
1493                                 handle_ep0(udc);
1494                         for (i = 1; i < NUM_ENDPOINTS; i++) {
1495                                 mask <<= 1;
1496                                 if (status & mask)
1497                                         handle_ep(ep);
1498                                 ep++;
1499                         }
1500                 }
1501         }
1502
1503         if (disable_clock)
1504                 clk_off(udc);
1505
1506         spin_unlock_irqrestore(&udc->lock, flags);
1507
1508         return IRQ_HANDLED;
1509 }
1510
1511 /*-------------------------------------------------------------------------*/
1512
1513 static void at91_vbus_update(struct at91_udc *udc, unsigned value)
1514 {
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, gpiod_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, gpiod_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 i;
1600
1601         for (i = 0; i < NUM_ENDPOINTS; i++) {
1602                 ep = &udc->ep[i];
1603
1604                 switch (i) {
1605                 case 0:
1606                 case 3:
1607                         ep->maxpacket = 8;
1608                         break;
1609                 case 1 ... 2:
1610                         ep->maxpacket = 64;
1611                         break;
1612                 case 4 ... 5:
1613                         ep->maxpacket = 256;
1614                         break;
1615                 }
1616         }
1617
1618         if (!udc->board.pullup_pin) {
1619                 DBG("no D+ pullup?\n");
1620                 return -ENODEV;
1621         }
1622
1623         gpiod_direction_output(udc->board.pullup_pin,
1624                                gpiod_is_active_low(udc->board.pullup_pin));
1625
1626         return 0;
1627 }
1628
1629 static void at91rm9200_udc_pullup(struct at91_udc *udc, int is_on)
1630 {
1631         if (is_on)
1632                 gpiod_set_value(udc->board.pullup_pin, 1);
1633         else
1634                 gpiod_set_value(udc->board.pullup_pin, 0);
1635 }
1636
1637 static const struct at91_udc_caps at91rm9200_udc_caps = {
1638         .init = at91rm9200_udc_init,
1639         .pullup = at91rm9200_udc_pullup,
1640 };
1641
1642 static int at91sam9260_udc_init(struct at91_udc *udc)
1643 {
1644         struct at91_ep *ep;
1645         int i;
1646
1647         for (i = 0; i < NUM_ENDPOINTS; i++) {
1648                 ep = &udc->ep[i];
1649
1650                 switch (i) {
1651                 case 0 ... 3:
1652                         ep->maxpacket = 64;
1653                         break;
1654                 case 4 ... 5:
1655                         ep->maxpacket = 512;
1656                         break;
1657                 }
1658         }
1659
1660         return 0;
1661 }
1662
1663 static void at91sam9260_udc_pullup(struct at91_udc *udc, int is_on)
1664 {
1665         u32 txvc = at91_udp_read(udc, AT91_UDP_TXVC);
1666
1667         if (is_on)
1668                 txvc |= AT91_UDP_TXVC_PUON;
1669         else
1670                 txvc &= ~AT91_UDP_TXVC_PUON;
1671
1672         at91_udp_write(udc, AT91_UDP_TXVC, txvc);
1673 }
1674
1675 static const struct at91_udc_caps at91sam9260_udc_caps = {
1676         .init = at91sam9260_udc_init,
1677         .pullup = at91sam9260_udc_pullup,
1678 };
1679
1680 static int at91sam9261_udc_init(struct at91_udc *udc)
1681 {
1682         struct at91_ep *ep;
1683         int i;
1684
1685         for (i = 0; i < NUM_ENDPOINTS; i++) {
1686                 ep = &udc->ep[i];
1687
1688                 switch (i) {
1689                 case 0:
1690                         ep->maxpacket = 8;
1691                         break;
1692                 case 1 ... 3:
1693                         ep->maxpacket = 64;
1694                         break;
1695                 case 4 ... 5:
1696                         ep->maxpacket = 256;
1697                         break;
1698                 }
1699         }
1700
1701         udc->matrix = syscon_regmap_lookup_by_phandle(udc->pdev->dev.of_node,
1702                                                       "atmel,matrix");
1703         return PTR_ERR_OR_ZERO(udc->matrix);
1704 }
1705
1706 static void at91sam9261_udc_pullup(struct at91_udc *udc, int is_on)
1707 {
1708         u32 usbpucr = 0;
1709
1710         if (is_on)
1711                 usbpucr = AT91_MATRIX_USBPUCR_PUON;
1712
1713         regmap_update_bits(udc->matrix, AT91SAM9261_MATRIX_USBPUCR,
1714                            AT91_MATRIX_USBPUCR_PUON, usbpucr);
1715 }
1716
1717 static const struct at91_udc_caps at91sam9261_udc_caps = {
1718         .init = at91sam9261_udc_init,
1719         .pullup = at91sam9261_udc_pullup,
1720 };
1721
1722 static int at91sam9263_udc_init(struct at91_udc *udc)
1723 {
1724         struct at91_ep *ep;
1725         int i;
1726
1727         for (i = 0; i < NUM_ENDPOINTS; i++) {
1728                 ep = &udc->ep[i];
1729
1730                 switch (i) {
1731                 case 0:
1732                 case 1:
1733                 case 2:
1734                 case 3:
1735                         ep->maxpacket = 64;
1736                         break;
1737                 case 4:
1738                 case 5:
1739                         ep->maxpacket = 256;
1740                         break;
1741                 }
1742         }
1743
1744         return 0;
1745 }
1746
1747 static const struct at91_udc_caps at91sam9263_udc_caps = {
1748         .init = at91sam9263_udc_init,
1749         .pullup = at91sam9260_udc_pullup,
1750 };
1751
1752 static const struct of_device_id at91_udc_dt_ids[] = {
1753         {
1754                 .compatible = "atmel,at91rm9200-udc",
1755                 .data = &at91rm9200_udc_caps,
1756         },
1757         {
1758                 .compatible = "atmel,at91sam9260-udc",
1759                 .data = &at91sam9260_udc_caps,
1760         },
1761         {
1762                 .compatible = "atmel,at91sam9261-udc",
1763                 .data = &at91sam9261_udc_caps,
1764         },
1765         {
1766                 .compatible = "atmel,at91sam9263-udc",
1767                 .data = &at91sam9263_udc_caps,
1768         },
1769         { /* sentinel */ }
1770 };
1771 MODULE_DEVICE_TABLE(of, at91_udc_dt_ids);
1772
1773 static void at91udc_of_init(struct at91_udc *udc, struct device_node *np)
1774 {
1775         struct at91_udc_data *board = &udc->board;
1776         const struct of_device_id *match;
1777         u32 val;
1778
1779         if (of_property_read_u32(np, "atmel,vbus-polled", &val) == 0)
1780                 board->vbus_polled = 1;
1781
1782         board->vbus_pin = gpiod_get_from_of_node(np, "atmel,vbus-gpio", 0,
1783                                                  GPIOD_IN, "udc_vbus");
1784         if (IS_ERR(board->vbus_pin))
1785                 board->vbus_pin = NULL;
1786
1787         board->pullup_pin = gpiod_get_from_of_node(np, "atmel,pullup-gpio", 0,
1788                                                    GPIOD_ASIS, "udc_pullup");
1789         if (IS_ERR(board->pullup_pin))
1790                 board->pullup_pin = NULL;
1791
1792         match = of_match_node(at91_udc_dt_ids, np);
1793         if (match)
1794                 udc->caps = match->data;
1795 }
1796
1797 static int at91udc_probe(struct platform_device *pdev)
1798 {
1799         struct device   *dev = &pdev->dev;
1800         struct at91_udc *udc;
1801         int             retval;
1802         struct at91_ep  *ep;
1803         int             i;
1804
1805         udc = devm_kzalloc(dev, sizeof(*udc), GFP_KERNEL);
1806         if (!udc)
1807                 return -ENOMEM;
1808
1809         /* init software state */
1810         udc->gadget.dev.parent = dev;
1811         at91udc_of_init(udc, pdev->dev.of_node);
1812         udc->pdev = pdev;
1813         udc->enabled = 0;
1814         spin_lock_init(&udc->lock);
1815
1816         udc->gadget.ops = &at91_udc_ops;
1817         udc->gadget.ep0 = &udc->ep[0].ep;
1818         udc->gadget.name = driver_name;
1819         udc->gadget.dev.init_name = "gadget";
1820
1821         for (i = 0; i < NUM_ENDPOINTS; i++) {
1822                 ep = &udc->ep[i];
1823                 ep->ep.name = ep_info[i].name;
1824                 ep->ep.caps = ep_info[i].caps;
1825                 ep->ep.ops = &at91_ep_ops;
1826                 ep->udc = udc;
1827                 ep->int_mask = BIT(i);
1828                 if (i != 0 && i != 3)
1829                         ep->is_pingpong = 1;
1830         }
1831
1832         udc->udp_baseaddr = devm_platform_ioremap_resource(pdev, 0);
1833         if (IS_ERR(udc->udp_baseaddr))
1834                 return PTR_ERR(udc->udp_baseaddr);
1835
1836         if (udc->caps && udc->caps->init) {
1837                 retval = udc->caps->init(udc);
1838                 if (retval)
1839                         return retval;
1840         }
1841
1842         udc_reinit(udc);
1843
1844         /* get interface and function clocks */
1845         udc->iclk = devm_clk_get(dev, "pclk");
1846         if (IS_ERR(udc->iclk))
1847                 return PTR_ERR(udc->iclk);
1848
1849         udc->fclk = devm_clk_get(dev, "hclk");
1850         if (IS_ERR(udc->fclk))
1851                 return PTR_ERR(udc->fclk);
1852
1853         /* don't do anything until we have both gadget driver and VBUS */
1854         clk_set_rate(udc->fclk, 48000000);
1855         retval = clk_prepare(udc->fclk);
1856         if (retval)
1857                 return retval;
1858
1859         retval = clk_prepare_enable(udc->iclk);
1860         if (retval)
1861                 goto err_unprepare_fclk;
1862
1863         at91_udp_write(udc, AT91_UDP_TXVC, AT91_UDP_TXVC_TXVDIS);
1864         at91_udp_write(udc, AT91_UDP_IDR, 0xffffffff);
1865         /* Clear all pending interrupts - UDP may be used by bootloader. */
1866         at91_udp_write(udc, AT91_UDP_ICR, 0xffffffff);
1867         clk_disable(udc->iclk);
1868
1869         /* request UDC and maybe VBUS irqs */
1870         udc->udp_irq = retval = platform_get_irq(pdev, 0);
1871         if (retval < 0)
1872                 goto err_unprepare_iclk;
1873         retval = devm_request_irq(dev, udc->udp_irq, at91_udc_irq, 0,
1874                                   driver_name, udc);
1875         if (retval) {
1876                 DBG("request irq %d failed\n", udc->udp_irq);
1877                 goto err_unprepare_iclk;
1878         }
1879
1880         if (udc->board.vbus_pin) {
1881                 gpiod_direction_input(udc->board.vbus_pin);
1882
1883                 /*
1884                  * Get the initial state of VBUS - we cannot expect
1885                  * a pending interrupt.
1886                  */
1887                 udc->vbus = gpiod_get_value_cansleep(udc->board.vbus_pin);
1888
1889                 if (udc->board.vbus_polled) {
1890                         INIT_WORK(&udc->vbus_timer_work, at91_vbus_timer_work);
1891                         timer_setup(&udc->vbus_timer, at91_vbus_timer, 0);
1892                         mod_timer(&udc->vbus_timer,
1893                                   jiffies + VBUS_POLL_TIMEOUT);
1894                 } else {
1895                         retval = devm_request_irq(dev,
1896                                         gpiod_to_irq(udc->board.vbus_pin),
1897                                         at91_vbus_irq, 0, driver_name, udc);
1898                         if (retval) {
1899                                 DBG("request vbus irq %d failed\n",
1900                                     desc_to_gpio(udc->board.vbus_pin));
1901                                 goto err_unprepare_iclk;
1902                         }
1903                 }
1904         } else {
1905                 DBG("no VBUS detection, assuming always-on\n");
1906                 udc->vbus = 1;
1907         }
1908         retval = usb_add_gadget_udc(dev, &udc->gadget);
1909         if (retval)
1910                 goto err_unprepare_iclk;
1911         dev_set_drvdata(dev, udc);
1912         device_init_wakeup(dev, 1);
1913         create_debug_file(udc);
1914
1915         INFO("%s version %s\n", driver_name, DRIVER_VERSION);
1916         return 0;
1917
1918 err_unprepare_iclk:
1919         clk_unprepare(udc->iclk);
1920 err_unprepare_fclk:
1921         clk_unprepare(udc->fclk);
1922
1923         DBG("%s probe failed, %d\n", driver_name, retval);
1924
1925         return retval;
1926 }
1927
1928 static int at91udc_remove(struct platform_device *pdev)
1929 {
1930         struct at91_udc *udc = platform_get_drvdata(pdev);
1931         unsigned long   flags;
1932
1933         DBG("remove\n");
1934
1935         usb_del_gadget_udc(&udc->gadget);
1936         if (udc->driver)
1937                 return -EBUSY;
1938
1939         spin_lock_irqsave(&udc->lock, flags);
1940         pullup(udc, 0);
1941         spin_unlock_irqrestore(&udc->lock, flags);
1942
1943         device_init_wakeup(&pdev->dev, 0);
1944         remove_debug_file(udc);
1945         clk_unprepare(udc->fclk);
1946         clk_unprepare(udc->iclk);
1947
1948         return 0;
1949 }
1950
1951 #ifdef CONFIG_PM
1952 static int at91udc_suspend(struct platform_device *pdev, pm_message_t mesg)
1953 {
1954         struct at91_udc *udc = platform_get_drvdata(pdev);
1955         int             wake = udc->driver && device_may_wakeup(&pdev->dev);
1956         unsigned long   flags;
1957
1958         /* Unless we can act normally to the host (letting it wake us up
1959          * whenever it has work for us) force disconnect.  Wakeup requires
1960          * PLLB for USB events (signaling for reset, wakeup, or incoming
1961          * tokens) and VBUS irqs (on systems which support them).
1962          */
1963         if ((!udc->suspended && udc->addr)
1964                         || !wake
1965                         || at91_suspend_entering_slow_clock()) {
1966                 spin_lock_irqsave(&udc->lock, flags);
1967                 pullup(udc, 0);
1968                 wake = 0;
1969                 spin_unlock_irqrestore(&udc->lock, flags);
1970         } else
1971                 enable_irq_wake(udc->udp_irq);
1972
1973         udc->active_suspend = wake;
1974         if (udc->board.vbus_pin && !udc->board.vbus_polled && wake)
1975                 enable_irq_wake(gpiod_to_irq(udc->board.vbus_pin));
1976         return 0;
1977 }
1978
1979 static int at91udc_resume(struct platform_device *pdev)
1980 {
1981         struct at91_udc *udc = platform_get_drvdata(pdev);
1982         unsigned long   flags;
1983
1984         if (udc->board.vbus_pin && !udc->board.vbus_polled &&
1985             udc->active_suspend)
1986                 disable_irq_wake(gpiod_to_irq(udc->board.vbus_pin));
1987
1988         /* maybe reconnect to host; if so, clocks on */
1989         if (udc->active_suspend)
1990                 disable_irq_wake(udc->udp_irq);
1991         else {
1992                 spin_lock_irqsave(&udc->lock, flags);
1993                 pullup(udc, 1);
1994                 spin_unlock_irqrestore(&udc->lock, flags);
1995         }
1996         return 0;
1997 }
1998 #else
1999 #define at91udc_suspend NULL
2000 #define at91udc_resume  NULL
2001 #endif
2002
2003 static struct platform_driver at91_udc_driver = {
2004         .remove         = at91udc_remove,
2005         .shutdown       = at91udc_shutdown,
2006         .suspend        = at91udc_suspend,
2007         .resume         = at91udc_resume,
2008         .driver         = {
2009                 .name   = driver_name,
2010                 .of_match_table = at91_udc_dt_ids,
2011         },
2012 };
2013
2014 module_platform_driver_probe(at91_udc_driver, at91udc_probe);
2015
2016 MODULE_DESCRIPTION("AT91 udc driver");
2017 MODULE_AUTHOR("Thomas Rathbone, David Brownell");
2018 MODULE_LICENSE("GPL");
2019 MODULE_ALIAS("platform:at91_udc");