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