drivers/usb/gadget/at91_udc.c

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