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