drivers/usb/gadget/udc/at91

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

DEFINITIONS
