kernel/drivers/usb/gadget/udc/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/list.h>
  25 #include <linux/interrupt.h>
  26 #include <linux/proc_fs.h>
  27 #include <linux/prefetch.h>
  28 #include <linux/clk.h>
  29 #include <linux/usb/ch9.h>
  30 #include <linux/usb/gadget.h>
  31 #include <linux/of.h>
  32 #include <linux/of_gpio.h>
  33 #include <linux/platform_data/atmel.h>
  34 #include <linux/regmap.h>
  35 #include <linux/mfd/syscon.h>
  36 #include <linux/mfd/syscon/atmel-matrix.h>
  37
  38 #include "at91_udc.h"
  39
  40
  41 /*
  42  * This controller is simple and PIO-only.  It's used in many AT91-series
  43  * full speed USB controllers, including the at91rm9200 (arm920T, with MMU),
  44  * at91sam926x (arm926ejs, with MMU), and several no-mmu versions.
  45  *
  46  * This driver expects the board has been wired with two GPIOs supporting
  47  * a VBUS sensing IRQ, and a D+ pullup.  (They may be omitted, but the
  48  * testing hasn't covered such cases.)
  49  *
  50  * The pullup is most important (so it's integrated on sam926x parts).  It
  51  * provides software control over whether the host enumerates the device.
  52  *
  53  * The VBUS sensing helps during enumeration, and allows both USB clocks
  54  * (and the transceiver) to stay gated off until they're necessary, saving
  55  * power.  During USB suspend, the 48 MHz clock is gated off in hardware;
  56  * it may also be gated off by software during some Linux sleep states.
  57  */
  58
  59 #define DRIVER_VERSION  "3 May 2006"
  60
  61 static const char driver_name [] = "at91_udc";
  62 static const char * const ep_names[] = {
  63         "ep0",
  64         "ep1",
  65         "ep2",
  66         "ep3-int",
  67         "ep4",
  68         "ep5",
  69 };
  70 #define ep0name         ep_names[0]
  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->gadget.is_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         usb_gadget_giveback_request(&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                 usb_ep_set_maxpacket_limit(&ep->ep, 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 reset_gadget(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
 857                 ep->stopped = 1;
 858                 nuke(ep, -ESHUTDOWN);
 859         }
 860         if (driver) {
 861                 spin_unlock(&udc->lock);
 862                 usb_gadget_udc_reset(&udc->gadget, driver);
 863                 spin_lock(&udc->lock);
 864         }
 865
 866         udc_reinit(udc);
 867 }
 868
 869 static void stop_activity(struct at91_udc *udc)
 870 {
 871         struct usb_gadget_driver *driver = udc->driver;
 872         int i;
 873
 874         if (udc->gadget.speed == USB_SPEED_UNKNOWN)
 875                 driver = NULL;
 876         udc->gadget.speed = USB_SPEED_UNKNOWN;
 877         udc->suspended = 0;
 878
 879         for (i = 0; i < NUM_ENDPOINTS; i++) {
 880                 struct at91_ep *ep = &udc->ep[i];
 881                 ep->stopped = 1;
 882                 nuke(ep, -ESHUTDOWN);
 883         }
 884         if (driver) {
 885                 spin_unlock(&udc->lock);
 886                 driver->disconnect(&udc->gadget);
 887                 spin_lock(&udc->lock);
 888         }
 889
 890         udc_reinit(udc);
 891 }
 892
 893 static void clk_on(struct at91_udc *udc)
 894 {
 895         if (udc->clocked)
 896                 return;
 897         udc->clocked = 1;
 898
 899         clk_enable(udc->iclk);
 900         clk_enable(udc->fclk);
 901 }
 902
 903 static void clk_off(struct at91_udc *udc)
 904 {
 905         if (!udc->clocked)
 906                 return;
 907         udc->clocked = 0;
 908         udc->gadget.speed = USB_SPEED_UNKNOWN;
 909         clk_disable(udc->fclk);
 910         clk_disable(udc->iclk);
 911 }
 912
 913 /*
 914  * activate/deactivate link with host; minimize power usage for
 915  * inactive links by cutting clocks and transceiver power.
 916  */
 917 static void pullup(struct at91_udc *udc, int is_on)
 918 {
 919         if (!udc->enabled || !udc->vbus)
 920                 is_on = 0;
 921         DBG("%sactive\n", is_on ? "" : "in");
 922
 923         if (is_on) {
 924                 clk_on(udc);
 925                 at91_udp_write(udc, AT91_UDP_ICR, AT91_UDP_RXRSM);
 926                 at91_udp_write(udc, AT91_UDP_TXVC, 0);
 927         } else {
 928                 stop_activity(udc);
 929                 at91_udp_write(udc, AT91_UDP_IDR, AT91_UDP_RXRSM);
 930                 at91_udp_write(udc, AT91_UDP_TXVC, AT91_UDP_TXVC_TXVDIS);
 931                 clk_off(udc);
 932         }
 933
 934         if (udc->caps && udc->caps->pullup)
 935                 udc->caps->pullup(udc, is_on);
 936 }
 937
 938 /* vbus is here!  turn everything on that's ready */
 939 static int at91_vbus_session(struct usb_gadget *gadget, int is_active)
 940 {
 941         struct at91_udc *udc = to_udc(gadget);
 942         unsigned long   flags;
 943
 944         /* VDBG("vbus %s\n", is_active ? "on" : "off"); */
 945         spin_lock_irqsave(&udc->lock, flags);
 946         udc->vbus = (is_active != 0);
 947         if (udc->driver)
 948                 pullup(udc, is_active);
 949         else
 950                 pullup(udc, 0);
 951         spin_unlock_irqrestore(&udc->lock, flags);
 952         return 0;
 953 }
 954
 955 static int at91_pullup(struct usb_gadget *gadget, int is_on)
 956 {
 957         struct at91_udc *udc = to_udc(gadget);
 958         unsigned long   flags;
 959
 960         spin_lock_irqsave(&udc->lock, flags);
 961         udc->enabled = is_on = !!is_on;
 962         pullup(udc, is_on);
 963         spin_unlock_irqrestore(&udc->lock, flags);
 964         return 0;
 965 }
 966
 967 static int at91_set_selfpowered(struct usb_gadget *gadget, int is_on)
 968 {
 969         struct at91_udc *udc = to_udc(gadget);
 970         unsigned long   flags;
 971
 972         spin_lock_irqsave(&udc->lock, flags);
 973         gadget->is_selfpowered = (is_on != 0);
 974         spin_unlock_irqrestore(&udc->lock, flags);
 975         return 0;
 976 }
 977
 978 static int at91_start(struct usb_gadget *gadget,
 979                 struct usb_gadget_driver *driver);
 980 static int at91_stop(struct usb_gadget *gadget);
 981
 982 static const struct usb_gadget_ops at91_udc_ops = {
 983         .get_frame              = at91_get_frame,
 984         .wakeup                 = at91_wakeup,
 985         .set_selfpowered        = at91_set_selfpowered,
 986         .vbus_session           = at91_vbus_session,
 987         .pullup                 = at91_pullup,
 988         .udc_start              = at91_start,
 989         .udc_stop               = at91_stop,
 990
 991         /*
 992          * VBUS-powered devices may also also want to support bigger
 993          * power budgets after an appropriate SET_CONFIGURATION.
 994          */
 995         /* .vbus_power          = at91_vbus_power, */
 996 };
 997
 998 /*-------------------------------------------------------------------------*/
 999
1000 static int handle_ep(struct at91_ep *ep)
1001 {
1002         struct at91_request     *req;
1003         u32 __iomem             *creg = ep->creg;
1004         u32                     csr = __raw_readl(creg);
1005
1006         if (!list_empty(&ep->queue))
1007                 req = list_entry(ep->queue.next,
1008                         struct at91_request, queue);
1009         else
1010                 req = NULL;
1011
1012         if (ep->is_in) {
1013                 if (csr & (AT91_UDP_STALLSENT | AT91_UDP_TXCOMP)) {
1014                         csr |= CLR_FX;
1015                         csr &= ~(SET_FX | AT91_UDP_STALLSENT | AT91_UDP_TXCOMP);
1016                         __raw_writel(csr, creg);
1017                 }
1018                 if (req)
1019                         return write_fifo(ep, req);
1020
1021         } else {
1022                 if (csr & AT91_UDP_STALLSENT) {
1023                         /* STALLSENT bit == ISOERR */
1024                         if (ep->is_iso && req)
1025                                 req->req.status = -EILSEQ;
1026                         csr |= CLR_FX;
1027                         csr &= ~(SET_FX | AT91_UDP_STALLSENT);
1028                         __raw_writel(csr, creg);
1029                         csr = __raw_readl(creg);
1030                 }
1031                 if (req && (csr & RX_DATA_READY))
1032                         return read_fifo(ep, req);
1033         }
1034         return 0;
1035 }
1036
1037 union setup {
1038         u8                      raw[8];
1039         struct usb_ctrlrequest  r;
1040 };
1041
1042 static void handle_setup(struct at91_udc *udc, struct at91_ep *ep, u32 csr)
1043 {
1044         u32 __iomem     *creg = ep->creg;
1045         u8 __iomem      *dreg = ep->creg + (AT91_UDP_FDR(0) - AT91_UDP_CSR(0));
1046         unsigned        rxcount, i = 0;
1047         u32             tmp;
1048         union setup     pkt;
1049         int             status = 0;
1050
1051         /* read and ack SETUP; hard-fail for bogus packets */
1052         rxcount = (csr & AT91_UDP_RXBYTECNT) >> 16;
1053         if (likely(rxcount == 8)) {
1054                 while (rxcount--)
1055                         pkt.raw[i++] = __raw_readb(dreg);
1056                 if (pkt.r.bRequestType & USB_DIR_IN) {
1057                         csr |= AT91_UDP_DIR;
1058                         ep->is_in = 1;
1059                 } else {
1060                         csr &= ~AT91_UDP_DIR;
1061                         ep->is_in = 0;
1062                 }
1063         } else {
1064                 /* REVISIT this happens sometimes under load; why?? */
1065                 ERR("SETUP len %d, csr %08x\n", rxcount, csr);
1066                 status = -EINVAL;
1067         }
1068         csr |= CLR_FX;
1069         csr &= ~(SET_FX | AT91_UDP_RXSETUP);
1070         __raw_writel(csr, creg);
1071         udc->wait_for_addr_ack = 0;
1072         udc->wait_for_config_ack = 0;
1073         ep->stopped = 0;
1074         if (unlikely(status != 0))
1075                 goto stall;
1076
1077 #define w_index         le16_to_cpu(pkt.r.wIndex)
1078 #define w_value         le16_to_cpu(pkt.r.wValue)
1079 #define w_length        le16_to_cpu(pkt.r.wLength)
1080
1081         VDBG("SETUP %02x.%02x v%04x i%04x l%04x\n",
1082                         pkt.r.bRequestType, pkt.r.bRequest,
1083                         w_value, w_index, w_length);
1084
1085         /*
1086          * A few standard requests get handled here, ones that touch
1087          * hardware ... notably for device and endpoint features.
1088          */
1089         udc->req_pending = 1;
1090         csr = __raw_readl(creg);
1091         csr |= CLR_FX;
1092         csr &= ~SET_FX;
1093         switch ((pkt.r.bRequestType << 8) | pkt.r.bRequest) {
1094
1095         case ((USB_TYPE_STANDARD|USB_RECIP_DEVICE) << 8)
1096                         | USB_REQ_SET_ADDRESS:
1097                 __raw_writel(csr | AT91_UDP_TXPKTRDY, creg);
1098                 udc->addr = w_value;
1099                 udc->wait_for_addr_ack = 1;
1100                 udc->req_pending = 0;
1101                 /* FADDR is set later, when we ack host STATUS */
1102                 return;
1103
1104         case ((USB_TYPE_STANDARD|USB_RECIP_DEVICE) << 8)
1105                         | USB_REQ_SET_CONFIGURATION:
1106                 tmp = at91_udp_read(udc, AT91_UDP_GLB_STAT) & AT91_UDP_CONFG;
1107                 if (pkt.r.wValue)
1108                         udc->wait_for_config_ack = (tmp == 0);
1109                 else
1110                         udc->wait_for_config_ack = (tmp != 0);
1111                 if (udc->wait_for_config_ack)
1112                         VDBG("wait for config\n");
1113                 /* CONFG is toggled later, if gadget driver succeeds */
1114                 break;
1115
1116         /*
1117          * Hosts may set or clear remote wakeup status, and
1118          * devices may report they're VBUS powered.
1119          */
1120         case ((USB_DIR_IN|USB_TYPE_STANDARD|USB_RECIP_DEVICE) << 8)
1121                         | USB_REQ_GET_STATUS:
1122                 tmp = (udc->gadget.is_selfpowered << USB_DEVICE_SELF_POWERED);
1123                 if (at91_udp_read(udc, AT91_UDP_GLB_STAT) & AT91_UDP_ESR)
1124                         tmp |= (1 << USB_DEVICE_REMOTE_WAKEUP);
1125                 PACKET("get device status\n");
1126                 __raw_writeb(tmp, dreg);
1127                 __raw_writeb(0, dreg);
1128                 goto write_in;
1129                 /* then STATUS starts later, automatically */
1130         case ((USB_TYPE_STANDARD|USB_RECIP_DEVICE) << 8)
1131                         | USB_REQ_SET_FEATURE:
1132                 if (w_value != USB_DEVICE_REMOTE_WAKEUP)
1133                         goto stall;
1134                 tmp = at91_udp_read(udc, AT91_UDP_GLB_STAT);
1135                 tmp |= AT91_UDP_ESR;
1136                 at91_udp_write(udc, AT91_UDP_GLB_STAT, tmp);
1137                 goto succeed;
1138         case ((USB_TYPE_STANDARD|USB_RECIP_DEVICE) << 8)
1139                         | USB_REQ_CLEAR_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
1147         /*
1148          * Interfaces have no feature settings; this is pretty useless.
1149          * we won't even insist the interface exists...
1150          */
1151         case ((USB_DIR_IN|USB_TYPE_STANDARD|USB_RECIP_INTERFACE) << 8)
1152                         | USB_REQ_GET_STATUS:
1153                 PACKET("get interface status\n");
1154                 __raw_writeb(0, dreg);
1155                 __raw_writeb(0, dreg);
1156                 goto write_in;
1157                 /* then STATUS starts later, automatically */
1158         case ((USB_TYPE_STANDARD|USB_RECIP_INTERFACE) << 8)
1159                         | USB_REQ_SET_FEATURE:
1160         case ((USB_TYPE_STANDARD|USB_RECIP_INTERFACE) << 8)
1161                         | USB_REQ_CLEAR_FEATURE:
1162                 goto stall;
1163
1164         /*
1165          * Hosts may clear bulk/intr endpoint halt after the gadget
1166          * driver sets it (not widely used); or set it (for testing)
1167          */
1168         case ((USB_DIR_IN|USB_TYPE_STANDARD|USB_RECIP_ENDPOINT) << 8)
1169                         | USB_REQ_GET_STATUS:
1170                 tmp = w_index & USB_ENDPOINT_NUMBER_MASK;
1171                 ep = &udc->ep[tmp];
1172                 if (tmp >= NUM_ENDPOINTS || (tmp && !ep->ep.desc))
1173                         goto stall;
1174
1175                 if (tmp) {
1176                         if ((w_index & USB_DIR_IN)) {
1177                                 if (!ep->is_in)
1178                                         goto stall;
1179                         } else if (ep->is_in)
1180                                 goto stall;
1181                 }
1182                 PACKET("get %s status\n", ep->ep.name);
1183                 if (__raw_readl(ep->creg) & AT91_UDP_FORCESTALL)
1184                         tmp = (1 << USB_ENDPOINT_HALT);
1185                 else
1186                         tmp = 0;
1187                 __raw_writeb(tmp, dreg);
1188                 __raw_writeb(0, dreg);
1189                 goto write_in;
1190                 /* then STATUS starts later, automatically */
1191         case ((USB_TYPE_STANDARD|USB_RECIP_ENDPOINT) << 8)
1192                         | USB_REQ_SET_FEATURE:
1193                 tmp = w_index & USB_ENDPOINT_NUMBER_MASK;
1194                 ep = &udc->ep[tmp];
1195                 if (w_value != USB_ENDPOINT_HALT || tmp >= NUM_ENDPOINTS)
1196                         goto stall;
1197                 if (!ep->ep.desc || ep->is_iso)
1198                         goto stall;
1199                 if ((w_index & USB_DIR_IN)) {
1200                         if (!ep->is_in)
1201                                 goto stall;
1202                 } else if (ep->is_in)
1203                         goto stall;
1204
1205                 tmp = __raw_readl(ep->creg);
1206                 tmp &= ~SET_FX;
1207                 tmp |= CLR_FX | AT91_UDP_FORCESTALL;
1208                 __raw_writel(tmp, ep->creg);
1209                 goto succeed;
1210         case ((USB_TYPE_STANDARD|USB_RECIP_ENDPOINT) << 8)
1211                         | USB_REQ_CLEAR_FEATURE:
1212                 tmp = w_index & USB_ENDPOINT_NUMBER_MASK;
1213                 ep = &udc->ep[tmp];
1214                 if (w_value != USB_ENDPOINT_HALT || tmp >= NUM_ENDPOINTS)
1215                         goto stall;
1216                 if (tmp == 0)
1217                         goto succeed;
1218                 if (!ep->ep.desc || ep->is_iso)
1219                         goto stall;
1220                 if ((w_index & USB_DIR_IN)) {
1221                         if (!ep->is_in)
1222                                 goto stall;
1223                 } else if (ep->is_in)
1224                         goto stall;
1225
1226                 at91_udp_write(udc, AT91_UDP_RST_EP, ep->int_mask);
1227                 at91_udp_write(udc, AT91_UDP_RST_EP, 0);
1228                 tmp = __raw_readl(ep->creg);
1229                 tmp |= CLR_FX;
1230                 tmp &= ~(SET_FX | AT91_UDP_FORCESTALL);
1231                 __raw_writel(tmp, ep->creg);
1232                 if (!list_empty(&ep->queue))
1233                         handle_ep(ep);
1234                 goto succeed;
1235         }
1236
1237 #undef w_value
1238 #undef w_index
1239 #undef w_length
1240
1241         /* pass request up to the gadget driver */
1242         if (udc->driver) {
1243                 spin_unlock(&udc->lock);
1244                 status = udc->driver->setup(&udc->gadget, &pkt.r);
1245                 spin_lock(&udc->lock);
1246         }
1247         else
1248                 status = -ENODEV;
1249         if (status < 0) {
1250 stall:
1251                 VDBG("req %02x.%02x protocol STALL; stat %d\n",
1252                                 pkt.r.bRequestType, pkt.r.bRequest, status);
1253                 csr |= AT91_UDP_FORCESTALL;
1254                 __raw_writel(csr, creg);
1255                 udc->req_pending = 0;
1256         }
1257         return;
1258
1259 succeed:
1260         /* immediate successful (IN) STATUS after zero length DATA */
1261         PACKET("ep0 in/status\n");
1262 write_in:
1263         csr |= AT91_UDP_TXPKTRDY;
1264         __raw_writel(csr, creg);
1265         udc->req_pending = 0;
1266 }
1267
1268 static void handle_ep0(struct at91_udc *udc)
1269 {
1270         struct at91_ep          *ep0 = &udc->ep[0];
1271         u32 __iomem             *creg = ep0->creg;
1272         u32                     csr = __raw_readl(creg);
1273         struct at91_request     *req;
1274
1275         if (unlikely(csr & AT91_UDP_STALLSENT)) {
1276                 nuke(ep0, -EPROTO);
1277                 udc->req_pending = 0;
1278                 csr |= CLR_FX;
1279                 csr &= ~(SET_FX | AT91_UDP_STALLSENT | AT91_UDP_FORCESTALL);
1280                 __raw_writel(csr, creg);
1281                 VDBG("ep0 stalled\n");
1282                 csr = __raw_readl(creg);
1283         }
1284         if (csr & AT91_UDP_RXSETUP) {
1285                 nuke(ep0, 0);
1286                 udc->req_pending = 0;
1287                 handle_setup(udc, ep0, csr);
1288                 return;
1289         }
1290
1291         if (list_empty(&ep0->queue))
1292                 req = NULL;
1293         else
1294                 req = list_entry(ep0->queue.next, struct at91_request, queue);
1295
1296         /* host ACKed an IN packet that we sent */
1297         if (csr & AT91_UDP_TXCOMP) {
1298                 csr |= CLR_FX;
1299                 csr &= ~(SET_FX | AT91_UDP_TXCOMP);
1300
1301                 /* write more IN DATA? */
1302                 if (req && ep0->is_in) {
1303                         if (handle_ep(ep0))
1304                                 udc->req_pending = 0;
1305
1306                 /*
1307                  * Ack after:
1308                  *  - last IN DATA packet (including GET_STATUS)
1309                  *  - IN/STATUS for OUT DATA
1310                  *  - IN/STATUS for any zero-length DATA stage
1311                  * except for the IN DATA case, the host should send
1312                  * an OUT status later, which we'll ack.
1313                  */
1314                 } else {
1315                         udc->req_pending = 0;
1316                         __raw_writel(csr, creg);
1317
1318                         /*
1319                          * SET_ADDRESS takes effect only after the STATUS
1320                          * (to the original address) gets acked.
1321                          */
1322                         if (udc->wait_for_addr_ack) {
1323                                 u32     tmp;
1324
1325                                 at91_udp_write(udc, AT91_UDP_FADDR,
1326                                                 AT91_UDP_FEN | udc->addr);
1327                                 tmp = at91_udp_read(udc, AT91_UDP_GLB_STAT);
1328                                 tmp &= ~AT91_UDP_FADDEN;
1329                                 if (udc->addr)
1330                                         tmp |= AT91_UDP_FADDEN;
1331                                 at91_udp_write(udc, AT91_UDP_GLB_STAT, tmp);
1332
1333                                 udc->wait_for_addr_ack = 0;
1334                                 VDBG("address %d\n", udc->addr);
1335                         }
1336                 }
1337         }
1338
1339         /* OUT packet arrived ... */
1340         else if (csr & AT91_UDP_RX_DATA_BK0) {
1341                 csr |= CLR_FX;
1342                 csr &= ~(SET_FX | AT91_UDP_RX_DATA_BK0);
1343
1344                 /* OUT DATA stage */
1345                 if (!ep0->is_in) {
1346                         if (req) {
1347                                 if (handle_ep(ep0)) {
1348                                         /* send IN/STATUS */
1349                                         PACKET("ep0 in/status\n");
1350                                         csr = __raw_readl(creg);
1351                                         csr &= ~SET_FX;
1352                                         csr |= CLR_FX | AT91_UDP_TXPKTRDY;
1353                                         __raw_writel(csr, creg);
1354                                         udc->req_pending = 0;
1355                                 }
1356                         } else if (udc->req_pending) {
1357                                 /*
1358                                  * AT91 hardware has a hard time with this
1359                                  * "deferred response" mode for control-OUT
1360                                  * transfers.  (For control-IN it's fine.)
1361                                  *
1362                                  * The normal solution leaves OUT data in the
1363                                  * fifo until the gadget driver is ready.
1364                                  * We couldn't do that here without disabling
1365                                  * the IRQ that tells about SETUP packets,
1366                                  * e.g. when the host gets impatient...
1367                                  *
1368                                  * Working around it by copying into a buffer
1369                                  * would almost be a non-deferred response,
1370                                  * except that it wouldn't permit reliable
1371                                  * stalling of the request.  Instead, demand
1372                                  * that gadget drivers not use this mode.
1373                                  */
1374                                 DBG("no control-OUT deferred responses!\n");
1375                                 __raw_writel(csr | AT91_UDP_FORCESTALL, creg);
1376                                 udc->req_pending = 0;
1377                         }
1378
1379                 /* STATUS stage for control-IN; ack.  */
1380                 } else {
1381                         PACKET("ep0 out/status ACK\n");
1382                         __raw_writel(csr, creg);
1383
1384                         /* "early" status stage */
1385                         if (req)
1386                                 done(ep0, req, 0);
1387                 }
1388         }
1389 }
1390
1391 static irqreturn_t at91_udc_irq (int irq, void *_udc)
1392 {
1393         struct at91_udc         *udc = _udc;
1394         u32                     rescans = 5;
1395         int                     disable_clock = 0;
1396         unsigned long           flags;
1397
1398         spin_lock_irqsave(&udc->lock, flags);
1399
1400         if (!udc->clocked) {
1401                 clk_on(udc);
1402                 disable_clock = 1;
1403         }
1404
1405         while (rescans--) {
1406                 u32 status;
1407
1408                 status = at91_udp_read(udc, AT91_UDP_ISR)
1409                         & at91_udp_read(udc, AT91_UDP_IMR);
1410                 if (!status)
1411                         break;
1412
1413                 /* USB reset irq:  not maskable */
1414                 if (status & AT91_UDP_ENDBUSRES) {
1415                         at91_udp_write(udc, AT91_UDP_IDR, ~MINIMUS_INTERRUPTUS);
1416                         at91_udp_write(udc, AT91_UDP_IER, MINIMUS_INTERRUPTUS);
1417                         /* Atmel code clears this irq twice */
1418                         at91_udp_write(udc, AT91_UDP_ICR, AT91_UDP_ENDBUSRES);
1419                         at91_udp_write(udc, AT91_UDP_ICR, AT91_UDP_ENDBUSRES);
1420                         VDBG("end bus reset\n");
1421                         udc->addr = 0;
1422                         reset_gadget(udc);
1423
1424                         /* enable ep0 */
1425                         at91_udp_write(udc, AT91_UDP_CSR(0),
1426                                         AT91_UDP_EPEDS | AT91_UDP_EPTYPE_CTRL);
1427                         udc->gadget.speed = USB_SPEED_FULL;
1428                         udc->suspended = 0;
1429                         at91_udp_write(udc, AT91_UDP_IER, AT91_UDP_EP(0));
1430
1431                         /*
1432                          * NOTE:  this driver keeps clocks off unless the
1433                          * USB host is present.  That saves power, but for
1434                          * boards that don't support VBUS detection, both
1435                          * clocks need to be active most of the time.
1436                          */
1437
1438                 /* host initiated suspend (3+ms bus idle) */
1439                 } else if (status & AT91_UDP_RXSUSP) {
1440                         at91_udp_write(udc, AT91_UDP_IDR, AT91_UDP_RXSUSP);
1441                         at91_udp_write(udc, AT91_UDP_IER, AT91_UDP_RXRSM);
1442                         at91_udp_write(udc, AT91_UDP_ICR, AT91_UDP_RXSUSP);
1443                         /* VDBG("bus suspend\n"); */
1444                         if (udc->suspended)
1445                                 continue;
1446                         udc->suspended = 1;
1447
1448                         /*
1449                          * NOTE:  when suspending a VBUS-powered device, the
1450                          * gadget driver should switch into slow clock mode
1451                          * and then into standby to avoid drawing more than
1452                          * 500uA power (2500uA for some high-power configs).
1453                          */
1454                         if (udc->driver && udc->driver->suspend) {
1455                                 spin_unlock(&udc->lock);
1456                                 udc->driver->suspend(&udc->gadget);
1457                                 spin_lock(&udc->lock);
1458                         }
1459
1460                 /* host initiated resume */
1461                 } else if (status & AT91_UDP_RXRSM) {
1462                         at91_udp_write(udc, AT91_UDP_IDR, AT91_UDP_RXRSM);
1463                         at91_udp_write(udc, AT91_UDP_IER, AT91_UDP_RXSUSP);
1464                         at91_udp_write(udc, AT91_UDP_ICR, AT91_UDP_RXRSM);
1465                         /* VDBG("bus resume\n"); */
1466                         if (!udc->suspended)
1467                                 continue;
1468                         udc->suspended = 0;
1469
1470                         /*
1471                          * NOTE:  for a VBUS-powered device, the gadget driver
1472                          * would normally want to switch out of slow clock
1473                          * mode into normal mode.
1474                          */
1475                         if (udc->driver && udc->driver->resume) {
1476                                 spin_unlock(&udc->lock);
1477                                 udc->driver->resume(&udc->gadget);
1478                                 spin_lock(&udc->lock);
1479                         }
1480
1481                 /* endpoint IRQs are cleared by handling them */
1482                 } else {
1483                         int             i;
1484                         unsigned        mask = 1;
1485                         struct at91_ep  *ep = &udc->ep[1];
1486
1487                         if (status & mask)
1488                                 handle_ep0(udc);
1489                         for (i = 1; i < NUM_ENDPOINTS; i++) {
1490                                 mask <<= 1;
1491                                 if (status & mask)
1492                                         handle_ep(ep);
1493                                 ep++;
1494                         }
1495                 }
1496         }
1497
1498         if (disable_clock)
1499                 clk_off(udc);
1500
1501         spin_unlock_irqrestore(&udc->lock, flags);
1502
1503         return IRQ_HANDLED;
1504 }
1505
1506 /*-------------------------------------------------------------------------*/
1507
1508 static void at91_vbus_update(struct at91_udc *udc, unsigned value)
1509 {
1510         value ^= udc->board.vbus_active_low;
1511         if (value != udc->vbus)
1512                 at91_vbus_session(&udc->gadget, value);
1513 }
1514
1515 static irqreturn_t at91_vbus_irq(int irq, void *_udc)
1516 {
1517         struct at91_udc *udc = _udc;
1518
1519         /* vbus needs at least brief debouncing */
1520         udelay(10);
1521         at91_vbus_update(udc, gpio_get_value(udc->board.vbus_pin));
1522
1523         return IRQ_HANDLED;
1524 }
1525
1526 static void at91_vbus_timer_work(struct work_struct *work)
1527 {
1528         struct at91_udc *udc = container_of(work, struct at91_udc,
1529                                             vbus_timer_work);
1530
1531         at91_vbus_update(udc, gpio_get_value_cansleep(udc->board.vbus_pin));
1532
1533         if (!timer_pending(&udc->vbus_timer))
1534                 mod_timer(&udc->vbus_timer, jiffies + VBUS_POLL_TIMEOUT);
1535 }
1536
1537 static void at91_vbus_timer(unsigned long data)
1538 {
1539         struct at91_udc *udc = (struct at91_udc *)data;
1540
1541         /*
1542          * If we are polling vbus it is likely that the gpio is on an
1543          * bus such as i2c or spi which may sleep, so schedule some work
1544          * to read the vbus gpio
1545          */
1546         schedule_work(&udc->vbus_timer_work);
1547 }
1548
1549 static int at91_start(struct usb_gadget *gadget,
1550                 struct usb_gadget_driver *driver)
1551 {
1552         struct at91_udc *udc;
1553
1554         udc = container_of(gadget, struct at91_udc, gadget);
1555         udc->driver = driver;
1556         udc->gadget.dev.of_node = udc->pdev->dev.of_node;
1557         udc->enabled = 1;
1558         udc->gadget.is_selfpowered = 1;
1559
1560         return 0;
1561 }
1562
1563 static int at91_stop(struct usb_gadget *gadget)
1564 {
1565         struct at91_udc *udc;
1566         unsigned long   flags;
1567
1568         udc = container_of(gadget, struct at91_udc, gadget);
1569         spin_lock_irqsave(&udc->lock, flags);
1570         udc->enabled = 0;
1571         at91_udp_write(udc, AT91_UDP_IDR, ~0);
1572         spin_unlock_irqrestore(&udc->lock, flags);
1573
1574         udc->driver = NULL;
1575
1576         return 0;
1577 }
1578
1579 /*-------------------------------------------------------------------------*/
1580
1581 static void at91udc_shutdown(struct platform_device *dev)
1582 {
1583         struct at91_udc *udc = platform_get_drvdata(dev);
1584         unsigned long   flags;
1585
1586         /* force disconnect on reboot */
1587         spin_lock_irqsave(&udc->lock, flags);
1588         pullup(platform_get_drvdata(dev), 0);
1589         spin_unlock_irqrestore(&udc->lock, flags);
1590 }
1591
1592 static int at91rm9200_udc_init(struct at91_udc *udc)
1593 {
1594         struct at91_ep *ep;
1595         int ret;
1596         int i;
1597
1598         for (i = 0; i < NUM_ENDPOINTS; i++) {
1599                 ep = &udc->ep[i];
1600
1601                 switch (i) {
1602                 case 0:
1603                 case 3:
1604                         ep->maxpacket = 8;
1605                         break;
1606                 case 1 ... 2:
1607                         ep->maxpacket = 64;
1608                         break;
1609                 case 4 ... 5:
1610                         ep->maxpacket = 256;
1611                         break;
1612                 }
1613         }
1614
1615         if (!gpio_is_valid(udc->board.pullup_pin)) {
1616                 DBG("no D+ pullup?\n");
1617                 return -ENODEV;
1618         }
1619
1620         ret = devm_gpio_request(&udc->pdev->dev, udc->board.pullup_pin,
1621                                 "udc_pullup");
1622         if (ret) {
1623                 DBG("D+ pullup is busy\n");
1624                 return ret;
1625         }
1626
1627         gpio_direction_output(udc->board.pullup_pin,
1628                               udc->board.pullup_active_low);
1629
1630         return 0;
1631 }
1632
1633 static void at91rm9200_udc_pullup(struct at91_udc *udc, int is_on)
1634 {
1635         int active = !udc->board.pullup_active_low;
1636
1637         if (is_on)
1638                 gpio_set_value(udc->board.pullup_pin, active);
1639         else
1640                 gpio_set_value(udc->board.pullup_pin, !active);
1641 }
1642
1643 static const struct at91_udc_caps at91rm9200_udc_caps = {
1644         .init = at91rm9200_udc_init,
1645         .pullup = at91rm9200_udc_pullup,
1646 };
1647
1648 static int at91sam9260_udc_init(struct at91_udc *udc)
1649 {
1650         struct at91_ep *ep;
1651         int i;
1652
1653         for (i = 0; i < NUM_ENDPOINTS; i++) {
1654                 ep = &udc->ep[i];
1655
1656                 switch (i) {
1657                 case 0 ... 3:
1658                         ep->maxpacket = 64;
1659                         break;
1660                 case 4 ... 5:
1661                         ep->maxpacket = 512;
1662                         break;
1663                 }
1664         }
1665
1666         return 0;
1667 }
1668
1669 static void at91sam9260_udc_pullup(struct at91_udc *udc, int is_on)
1670 {
1671         u32 txvc = at91_udp_read(udc, AT91_UDP_TXVC);
1672
1673         if (is_on)
1674                 txvc |= AT91_UDP_TXVC_PUON;
1675         else
1676                 txvc &= ~AT91_UDP_TXVC_PUON;
1677
1678         at91_udp_write(udc, AT91_UDP_TXVC, txvc);
1679 }
1680
1681 static const struct at91_udc_caps at91sam9260_udc_caps = {
1682         .init = at91sam9260_udc_init,
1683         .pullup = at91sam9260_udc_pullup,
1684 };
1685
1686 static int at91sam9261_udc_init(struct at91_udc *udc)
1687 {
1688         struct at91_ep *ep;
1689         int i;
1690
1691         for (i = 0; i < NUM_ENDPOINTS; i++) {
1692                 ep = &udc->ep[i];
1693
1694                 switch (i) {
1695                 case 0:
1696                         ep->maxpacket = 8;
1697                         break;
1698                 case 1 ... 3:
1699                         ep->maxpacket = 64;
1700                         break;
1701                 case 4 ... 5:
1702                         ep->maxpacket = 256;
1703                         break;
1704                 }
1705         }
1706
1707         udc->matrix = syscon_regmap_lookup_by_phandle(udc->pdev->dev.of_node,
1708                                                       "atmel,matrix");
1709         if (IS_ERR(udc->matrix))
1710                 return PTR_ERR(udc->matrix);
1711
1712         return 0;
1713 }
1714
1715 static void at91sam9261_udc_pullup(struct at91_udc *udc, int is_on)
1716 {
1717         u32 usbpucr = 0;
1718
1719         if (is_on)
1720                 usbpucr = AT91_MATRIX_USBPUCR_PUON;
1721
1722         regmap_update_bits(udc->matrix, AT91SAM9261_MATRIX_USBPUCR,
1723                            AT91_MATRIX_USBPUCR_PUON, usbpucr);
1724 }
1725
1726 static const struct at91_udc_caps at91sam9261_udc_caps = {
1727         .init = at91sam9261_udc_init,
1728         .pullup = at91sam9261_udc_pullup,
1729 };
1730
1731 static int at91sam9263_udc_init(struct at91_udc *udc)
1732 {
1733         struct at91_ep *ep;
1734         int i;
1735
1736         for (i = 0; i < NUM_ENDPOINTS; i++) {
1737                 ep = &udc->ep[i];
1738
1739                 switch (i) {
1740                 case 0:
1741                 case 1:
1742                 case 2:
1743                 case 3:
1744                         ep->maxpacket = 64;
1745                         break;
1746                 case 4:
1747                 case 5:
1748                         ep->maxpacket = 256;
1749                         break;
1750                 }
1751         }
1752
1753         return 0;
1754 }
1755
1756 static const struct at91_udc_caps at91sam9263_udc_caps = {
1757         .init = at91sam9263_udc_init,
1758         .pullup = at91sam9260_udc_pullup,
1759 };
1760
1761 static const struct of_device_id at91_udc_dt_ids[] = {
1762         {
1763                 .compatible = "atmel,at91rm9200-udc",
1764                 .data = &at91rm9200_udc_caps,
1765         },
1766         {
1767                 .compatible = "atmel,at91sam9260-udc",
1768                 .data = &at91sam9260_udc_caps,
1769         },
1770         {
1771                 .compatible = "atmel,at91sam9261-udc",
1772                 .data = &at91sam9261_udc_caps,
1773         },
1774         {
1775                 .compatible = "atmel,at91sam9263-udc",
1776                 .data = &at91sam9263_udc_caps,
1777         },
1778         { /* sentinel */ }
1779 };
1780 MODULE_DEVICE_TABLE(of, at91_udc_dt_ids);
1781
1782 static void at91udc_of_init(struct at91_udc *udc, struct device_node *np)
1783 {
1784         struct at91_udc_data *board = &udc->board;
1785         const struct of_device_id *match;
1786         enum of_gpio_flags flags;
1787         u32 val;
1788
1789         if (of_property_read_u32(np, "atmel,vbus-polled", &val) == 0)
1790                 board->vbus_polled = 1;
1791
1792         board->vbus_pin = of_get_named_gpio_flags(np, "atmel,vbus-gpio", 0,
1793                                                   &flags);
1794         board->vbus_active_low = (flags & OF_GPIO_ACTIVE_LOW) ? 1 : 0;
1795
1796         board->pullup_pin = of_get_named_gpio_flags(np, "atmel,pullup-gpio", 0,
1797                                                   &flags);
1798
1799         board->pullup_active_low = (flags & OF_GPIO_ACTIVE_LOW) ? 1 : 0;
1800
1801         match = of_match_node(at91_udc_dt_ids, np);
1802         if (match)
1803                 udc->caps = match->data;
1804 }
1805
1806 static int at91udc_probe(struct platform_device *pdev)
1807 {
1808         struct device   *dev = &pdev->dev;
1809         struct at91_udc *udc;
1810         int             retval;
1811         struct resource *res;
1812         struct at91_ep  *ep;
1813         int             i;
1814
1815         udc = devm_kzalloc(dev, sizeof(*udc), GFP_KERNEL);
1816         if (!udc)
1817                 return -ENOMEM;
1818
1819         /* init software state */
1820         udc->gadget.dev.parent = dev;
1821         at91udc_of_init(udc, pdev->dev.of_node);
1822         udc->pdev = pdev;
1823         udc->enabled = 0;
1824         spin_lock_init(&udc->lock);
1825
1826         udc->gadget.ops = &at91_udc_ops;
1827         udc->gadget.ep0 = &udc->ep[0].ep;
1828         udc->gadget.name = driver_name;
1829         udc->gadget.dev.init_name = "gadget";
1830
1831         for (i = 0; i < NUM_ENDPOINTS; i++) {
1832                 ep = &udc->ep[i];
1833                 ep->ep.name = ep_names[i];
1834                 ep->ep.ops = &at91_ep_ops;
1835                 ep->udc = udc;
1836                 ep->int_mask = BIT(i);
1837                 if (i != 0 && i != 3)
1838                         ep->is_pingpong = 1;
1839         }
1840
1841         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1842         udc->udp_baseaddr = devm_ioremap_resource(dev, res);
1843         if (IS_ERR(udc->udp_baseaddr))
1844                 return PTR_ERR(udc->udp_baseaddr);
1845
1846         if (udc->caps && udc->caps->init) {
1847                 retval = udc->caps->init(udc);
1848                 if (retval)
1849                         return retval;
1850         }
1851
1852         udc_reinit(udc);
1853
1854         /* get interface and function clocks */
1855         udc->iclk = devm_clk_get(dev, "pclk");
1856         if (IS_ERR(udc->iclk))
1857                 return PTR_ERR(udc->iclk);
1858
1859         udc->fclk = devm_clk_get(dev, "hclk");
1860         if (IS_ERR(udc->fclk))
1861                 return PTR_ERR(udc->fclk);
1862
1863         /* don't do anything until we have both gadget driver and VBUS */
1864         clk_set_rate(udc->fclk, 48000000);
1865         retval = clk_prepare(udc->fclk);
1866         if (retval)
1867                 return retval;
1868
1869         retval = clk_prepare_enable(udc->iclk);
1870         if (retval)
1871                 goto err_unprepare_fclk;
1872
1873         at91_udp_write(udc, AT91_UDP_TXVC, AT91_UDP_TXVC_TXVDIS);
1874         at91_udp_write(udc, AT91_UDP_IDR, 0xffffffff);
1875         /* Clear all pending interrupts - UDP may be used by bootloader. */
1876         at91_udp_write(udc, AT91_UDP_ICR, 0xffffffff);
1877         clk_disable(udc->iclk);
1878
1879         /* request UDC and maybe VBUS irqs */
1880         udc->udp_irq = platform_get_irq(pdev, 0);
1881         retval = devm_request_irq(dev, udc->udp_irq, at91_udc_irq, 0,
1882                                   driver_name, udc);
1883         if (retval) {
1884                 DBG("request irq %d failed\n", udc->udp_irq);
1885                 goto err_unprepare_iclk;
1886         }
1887
1888         if (gpio_is_valid(udc->board.vbus_pin)) {
1889                 retval = devm_gpio_request(dev, udc->board.vbus_pin,
1890                                            "udc_vbus");
1891                 if (retval) {
1892                         DBG("request vbus pin failed\n");
1893                         goto err_unprepare_iclk;
1894                 }
1895
1896                 gpio_direction_input(udc->board.vbus_pin);
1897
1898                 /*
1899                  * Get the initial state of VBUS - we cannot expect
1900                  * a pending interrupt.
1901                  */
1902                 udc->vbus = gpio_get_value_cansleep(udc->board.vbus_pin) ^
1903                         udc->board.vbus_active_low;
1904
1905                 if (udc->board.vbus_polled) {
1906                         INIT_WORK(&udc->vbus_timer_work, at91_vbus_timer_work);
1907                         setup_timer(&udc->vbus_timer, at91_vbus_timer,
1908                                     (unsigned long)udc);
1909                         mod_timer(&udc->vbus_timer,
1910                                   jiffies + VBUS_POLL_TIMEOUT);
1911                 } else {
1912                         retval = devm_request_irq(dev,
1913                                         gpio_to_irq(udc->board.vbus_pin),
1914                                         at91_vbus_irq, 0, driver_name, udc);
1915                         if (retval) {
1916                                 DBG("request vbus irq %d failed\n",
1917                                     udc->board.vbus_pin);
1918                                 goto err_unprepare_iclk;
1919                         }
1920                 }
1921         } else {
1922                 DBG("no VBUS detection, assuming always-on\n");
1923                 udc->vbus = 1;
1924         }
1925         retval = usb_add_gadget_udc(dev, &udc->gadget);
1926         if (retval)
1927                 goto err_unprepare_iclk;
1928         dev_set_drvdata(dev, udc);
1929         device_init_wakeup(dev, 1);
1930         create_debug_file(udc);
1931
1932         INFO("%s version %s\n", driver_name, DRIVER_VERSION);
1933         return 0;
1934
1935 err_unprepare_iclk:
1936         clk_unprepare(udc->iclk);
1937 err_unprepare_fclk:
1938         clk_unprepare(udc->fclk);
1939
1940         DBG("%s probe failed, %d\n", driver_name, retval);
1941
1942         return retval;
1943 }
1944
1945 static int at91udc_remove(struct platform_device *pdev)
1946 {
1947         struct at91_udc *udc = platform_get_drvdata(pdev);
1948         unsigned long   flags;
1949
1950         DBG("remove\n");
1951
1952         usb_del_gadget_udc(&udc->gadget);
1953         if (udc->driver)
1954                 return -EBUSY;
1955
1956         spin_lock_irqsave(&udc->lock, flags);
1957         pullup(udc, 0);
1958         spin_unlock_irqrestore(&udc->lock, flags);
1959
1960         device_init_wakeup(&pdev->dev, 0);
1961         remove_debug_file(udc);
1962         clk_unprepare(udc->fclk);
1963         clk_unprepare(udc->iclk);
1964
1965         return 0;
1966 }
1967
1968 #ifdef CONFIG_PM
1969 static int at91udc_suspend(struct platform_device *pdev, pm_message_t mesg)
1970 {
1971         struct at91_udc *udc = platform_get_drvdata(pdev);
1972         int             wake = udc->driver && device_may_wakeup(&pdev->dev);
1973         unsigned long   flags;
1974
1975         /* Unless we can act normally to the host (letting it wake us up
1976          * whenever it has work for us) force disconnect.  Wakeup requires
1977          * PLLB for USB events (signaling for reset, wakeup, or incoming
1978          * tokens) and VBUS irqs (on systems which support them).
1979          */
1980         if ((!udc->suspended && udc->addr)
1981                         || !wake
1982                         || at91_suspend_entering_slow_clock()) {
1983                 spin_lock_irqsave(&udc->lock, flags);
1984                 pullup(udc, 0);
1985                 wake = 0;
1986                 spin_unlock_irqrestore(&udc->lock, flags);
1987         } else
1988                 enable_irq_wake(udc->udp_irq);
1989
1990         udc->active_suspend = wake;
1991         if (gpio_is_valid(udc->board.vbus_pin) && !udc->board.vbus_polled && wake)
1992                 enable_irq_wake(udc->board.vbus_pin);
1993         return 0;
1994 }
1995
1996 static int at91udc_resume(struct platform_device *pdev)
1997 {
1998         struct at91_udc *udc = platform_get_drvdata(pdev);
1999         unsigned long   flags;
2000
2001         if (gpio_is_valid(udc->board.vbus_pin) && !udc->board.vbus_polled &&
2002             udc->active_suspend)
2003                 disable_irq_wake(udc->board.vbus_pin);
2004
2005         /* maybe reconnect to host; if so, clocks on */
2006         if (udc->active_suspend)
2007                 disable_irq_wake(udc->udp_irq);
2008         else {
2009                 spin_lock_irqsave(&udc->lock, flags);
2010                 pullup(udc, 1);
2011                 spin_unlock_irqrestore(&udc->lock, flags);
2012         }
2013         return 0;
2014 }
2015 #else
2016 #define at91udc_suspend NULL
2017 #define at91udc_resume  NULL
2018 #endif
2019
2020 static struct platform_driver at91_udc_driver = {
2021         .remove         = at91udc_remove,
2022         .shutdown       = at91udc_shutdown,
2023         .suspend        = at91udc_suspend,
2024         .resume         = at91udc_resume,
2025         .driver         = {
2026                 .name   = (char *) driver_name,
2027                 .of_match_table = at91_udc_dt_ids,
2028         },
2029 };
2030
2031 module_platform_driver_probe(at91_udc_driver, at91udc_probe);
2032
2033 MODULE_DESCRIPTION("AT91 udc driver");
2034 MODULE_AUTHOR("Thomas Rathbone, David Brownell");
2035 MODULE_LICENSE("GPL");
2036 MODULE_ALIAS("platform:at91_udc");