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