1 /* 2 * Driver for the PLX NET2280 USB device controller. 3 * Specs and errata are available from <http://www.plxtech.com>. 4 * 5 * PLX Technology Inc. (formerly NetChip Technology) supported the 6 * development of this driver. 7 * 8 * 9 * CODE STATUS HIGHLIGHTS 10 * 11 * This driver should work well with most "gadget" drivers, including 12 * the Mass Storage, Serial, and Ethernet/RNDIS gadget drivers 13 * as well as Gadget Zero and Gadgetfs. 14 * 15 * DMA is enabled by default. 16 * 17 * MSI is enabled by default. The legacy IRQ is used if MSI couldn't 18 * be enabled. 19 * 20 * Note that almost all the errata workarounds here are only needed for 21 * rev1 chips. Rev1a silicon (0110) fixes almost all of them. 22 */ 23 24 /* 25 * Copyright (C) 2003 David Brownell 26 * Copyright (C) 2003-2005 PLX Technology, Inc. 27 * Copyright (C) 2014 Ricardo Ribalda - Qtechnology/AS 28 * 29 * Modified Seth Levy 2005 PLX Technology, Inc. to provide compatibility 30 * with 2282 chip 31 * 32 * Modified Ricardo Ribalda Qtechnology AS to provide compatibility 33 * with usb 338x chip. Based on PLX driver 34 * 35 * This program is free software; you can redistribute it and/or modify 36 * it under the terms of the GNU General Public License as published by 37 * the Free Software Foundation; either version 2 of the License, or 38 * (at your option) any later version. 39 */ 40 41 #include <linux/module.h> 42 #include <linux/pci.h> 43 #include <linux/dma-mapping.h> 44 #include <linux/kernel.h> 45 #include <linux/delay.h> 46 #include <linux/ioport.h> 47 #include <linux/slab.h> 48 #include <linux/errno.h> 49 #include <linux/init.h> 50 #include <linux/timer.h> 51 #include <linux/list.h> 52 #include <linux/interrupt.h> 53 #include <linux/moduleparam.h> 54 #include <linux/device.h> 55 #include <linux/usb/ch9.h> 56 #include <linux/usb/gadget.h> 57 #include <linux/prefetch.h> 58 #include <linux/io.h> 59 60 #include <asm/byteorder.h> 61 #include <asm/irq.h> 62 #include <asm/unaligned.h> 63 64 #define DRIVER_DESC "PLX NET228x/USB338x USB Peripheral Controller" 65 #define DRIVER_VERSION "2005 Sept 27/v3.0" 66 67 #define EP_DONTUSE 13 /* nonzero */ 68 69 #define USE_RDK_LEDS /* GPIO pins control three LEDs */ 70 71 72 static const char driver_name[] = "net2280"; 73 static const char driver_desc[] = DRIVER_DESC; 74 75 static const u32 ep_bit[9] = { 0, 17, 2, 19, 4, 1, 18, 3, 20 }; 76 static const char ep0name[] = "ep0"; 77 static const char *const ep_name[] = { 78 ep0name, 79 "ep-a", "ep-b", "ep-c", "ep-d", 80 "ep-e", "ep-f", "ep-g", "ep-h", 81 }; 82 83 /* mode 0 == ep-{a,b,c,d} 1K fifo each 84 * mode 1 == ep-{a,b} 2K fifo each, ep-{c,d} unavailable 85 * mode 2 == ep-a 2K fifo, ep-{b,c} 1K each, ep-d unavailable 86 */ 87 static ushort fifo_mode; 88 89 /* "modprobe net2280 fifo_mode=1" etc */ 90 module_param(fifo_mode, ushort, 0644); 91 92 /* enable_suspend -- When enabled, the driver will respond to 93 * USB suspend requests by powering down the NET2280. Otherwise, 94 * USB suspend requests will be ignored. This is acceptable for 95 * self-powered devices 96 */ 97 static bool enable_suspend; 98 99 /* "modprobe net2280 enable_suspend=1" etc */ 100 module_param(enable_suspend, bool, 0444); 101 102 #define DIR_STRING(bAddress) (((bAddress) & USB_DIR_IN) ? "in" : "out") 103 104 static char *type_string(u8 bmAttributes) 105 { 106 switch ((bmAttributes) & USB_ENDPOINT_XFERTYPE_MASK) { 107 case USB_ENDPOINT_XFER_BULK: return "bulk"; 108 case USB_ENDPOINT_XFER_ISOC: return "iso"; 109 case USB_ENDPOINT_XFER_INT: return "intr"; 110 } 111 return "control"; 112 } 113 114 #include "net2280.h" 115 116 #define valid_bit cpu_to_le32(BIT(VALID_BIT)) 117 #define dma_done_ie cpu_to_le32(BIT(DMA_DONE_INTERRUPT_ENABLE)) 118 119 /*-------------------------------------------------------------------------*/ 120 static inline void enable_pciirqenb(struct net2280_ep *ep) 121 { 122 u32 tmp = readl(&ep->dev->regs->pciirqenb0); 123 124 if (ep->dev->quirks & PLX_LEGACY) 125 tmp |= BIT(ep->num); 126 else 127 tmp |= BIT(ep_bit[ep->num]); 128 writel(tmp, &ep->dev->regs->pciirqenb0); 129 130 return; 131 } 132 133 static int 134 net2280_enable(struct usb_ep *_ep, const struct usb_endpoint_descriptor *desc) 135 { 136 struct net2280 *dev; 137 struct net2280_ep *ep; 138 u32 max, tmp; 139 unsigned long flags; 140 static const u32 ep_key[9] = { 1, 0, 1, 0, 1, 1, 0, 1, 0 }; 141 142 ep = container_of(_ep, struct net2280_ep, ep); 143 if (!_ep || !desc || ep->desc || _ep->name == ep0name || 144 desc->bDescriptorType != USB_DT_ENDPOINT) 145 return -EINVAL; 146 dev = ep->dev; 147 if (!dev->driver || dev->gadget.speed == USB_SPEED_UNKNOWN) 148 return -ESHUTDOWN; 149 150 /* erratum 0119 workaround ties up an endpoint number */ 151 if ((desc->bEndpointAddress & 0x0f) == EP_DONTUSE) 152 return -EDOM; 153 154 if (dev->quirks & PLX_SUPERSPEED) { 155 if ((desc->bEndpointAddress & 0x0f) >= 0x0c) 156 return -EDOM; 157 ep->is_in = !!usb_endpoint_dir_in(desc); 158 if (dev->enhanced_mode && ep->is_in && ep_key[ep->num]) 159 return -EINVAL; 160 } 161 162 /* sanity check ep-e/ep-f since their fifos are small */ 163 max = usb_endpoint_maxp(desc) & 0x1fff; 164 if (ep->num > 4 && max > 64 && (dev->quirks & PLX_LEGACY)) 165 return -ERANGE; 166 167 spin_lock_irqsave(&dev->lock, flags); 168 _ep->maxpacket = max & 0x7ff; 169 ep->desc = desc; 170 171 /* ep_reset() has already been called */ 172 ep->stopped = 0; 173 ep->wedged = 0; 174 ep->out_overflow = 0; 175 176 /* set speed-dependent max packet; may kick in high bandwidth */ 177 set_max_speed(ep, max); 178 179 /* set type, direction, address; reset fifo counters */ 180 writel(BIT(FIFO_FLUSH), &ep->regs->ep_stat); 181 tmp = (desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK); 182 if (tmp == USB_ENDPOINT_XFER_INT) { 183 /* erratum 0105 workaround prevents hs NYET */ 184 if (dev->chiprev == 0100 && 185 dev->gadget.speed == USB_SPEED_HIGH && 186 !(desc->bEndpointAddress & USB_DIR_IN)) 187 writel(BIT(CLEAR_NAK_OUT_PACKETS_MODE), 188 &ep->regs->ep_rsp); 189 } else if (tmp == USB_ENDPOINT_XFER_BULK) { 190 /* catch some particularly blatant driver bugs */ 191 if ((dev->gadget.speed == USB_SPEED_SUPER && max != 1024) || 192 (dev->gadget.speed == USB_SPEED_HIGH && max != 512) || 193 (dev->gadget.speed == USB_SPEED_FULL && max > 64)) { 194 spin_unlock_irqrestore(&dev->lock, flags); 195 return -ERANGE; 196 } 197 } 198 ep->is_iso = (tmp == USB_ENDPOINT_XFER_ISOC); 199 /* Enable this endpoint */ 200 if (dev->quirks & PLX_LEGACY) { 201 tmp <<= ENDPOINT_TYPE; 202 tmp |= desc->bEndpointAddress; 203 /* default full fifo lines */ 204 tmp |= (4 << ENDPOINT_BYTE_COUNT); 205 tmp |= BIT(ENDPOINT_ENABLE); 206 ep->is_in = (tmp & USB_DIR_IN) != 0; 207 } else { 208 /* In Legacy mode, only OUT endpoints are used */ 209 if (dev->enhanced_mode && ep->is_in) { 210 tmp <<= IN_ENDPOINT_TYPE; 211 tmp |= BIT(IN_ENDPOINT_ENABLE); 212 /* Not applicable to Legacy */ 213 tmp |= BIT(ENDPOINT_DIRECTION); 214 } else { 215 tmp <<= OUT_ENDPOINT_TYPE; 216 tmp |= BIT(OUT_ENDPOINT_ENABLE); 217 tmp |= (ep->is_in << ENDPOINT_DIRECTION); 218 } 219 220 tmp |= usb_endpoint_num(desc); 221 tmp |= (ep->ep.maxburst << MAX_BURST_SIZE); 222 } 223 224 /* Make sure all the registers are written before ep_rsp*/ 225 wmb(); 226 227 /* for OUT transfers, block the rx fifo until a read is posted */ 228 if (!ep->is_in) 229 writel(BIT(SET_NAK_OUT_PACKETS), &ep->regs->ep_rsp); 230 else if (!(dev->quirks & PLX_2280)) { 231 /* Added for 2282, Don't use nak packets on an in endpoint, 232 * this was ignored on 2280 233 */ 234 writel(BIT(CLEAR_NAK_OUT_PACKETS) | 235 BIT(CLEAR_NAK_OUT_PACKETS_MODE), &ep->regs->ep_rsp); 236 } 237 238 writel(tmp, &ep->cfg->ep_cfg); 239 240 /* enable irqs */ 241 if (!ep->dma) { /* pio, per-packet */ 242 enable_pciirqenb(ep); 243 244 tmp = BIT(DATA_PACKET_RECEIVED_INTERRUPT_ENABLE) | 245 BIT(DATA_PACKET_TRANSMITTED_INTERRUPT_ENABLE); 246 if (dev->quirks & PLX_2280) 247 tmp |= readl(&ep->regs->ep_irqenb); 248 writel(tmp, &ep->regs->ep_irqenb); 249 } else { /* dma, per-request */ 250 tmp = BIT((8 + ep->num)); /* completion */ 251 tmp |= readl(&dev->regs->pciirqenb1); 252 writel(tmp, &dev->regs->pciirqenb1); 253 254 /* for short OUT transfers, dma completions can't 255 * advance the queue; do it pio-style, by hand. 256 * NOTE erratum 0112 workaround #2 257 */ 258 if ((desc->bEndpointAddress & USB_DIR_IN) == 0) { 259 tmp = BIT(SHORT_PACKET_TRANSFERRED_INTERRUPT_ENABLE); 260 writel(tmp, &ep->regs->ep_irqenb); 261 262 enable_pciirqenb(ep); 263 } 264 } 265 266 tmp = desc->bEndpointAddress; 267 ep_dbg(dev, "enabled %s (ep%d%s-%s) %s max %04x\n", 268 _ep->name, tmp & 0x0f, DIR_STRING(tmp), 269 type_string(desc->bmAttributes), 270 ep->dma ? "dma" : "pio", max); 271 272 /* pci writes may still be posted */ 273 spin_unlock_irqrestore(&dev->lock, flags); 274 return 0; 275 } 276 277 static int handshake(u32 __iomem *ptr, u32 mask, u32 done, int usec) 278 { 279 u32 result; 280 281 do { 282 result = readl(ptr); 283 if (result == ~(u32)0) /* "device unplugged" */ 284 return -ENODEV; 285 result &= mask; 286 if (result == done) 287 return 0; 288 udelay(1); 289 usec--; 290 } while (usec > 0); 291 return -ETIMEDOUT; 292 } 293 294 static const struct usb_ep_ops net2280_ep_ops; 295 296 static void ep_reset_228x(struct net2280_regs __iomem *regs, 297 struct net2280_ep *ep) 298 { 299 u32 tmp; 300 301 ep->desc = NULL; 302 INIT_LIST_HEAD(&ep->queue); 303 304 usb_ep_set_maxpacket_limit(&ep->ep, ~0); 305 ep->ep.ops = &net2280_ep_ops; 306 307 /* disable the dma, irqs, endpoint... */ 308 if (ep->dma) { 309 writel(0, &ep->dma->dmactl); 310 writel(BIT(DMA_SCATTER_GATHER_DONE_INTERRUPT) | 311 BIT(DMA_TRANSACTION_DONE_INTERRUPT) | 312 BIT(DMA_ABORT), 313 &ep->dma->dmastat); 314 315 tmp = readl(®s->pciirqenb0); 316 tmp &= ~BIT(ep->num); 317 writel(tmp, ®s->pciirqenb0); 318 } else { 319 tmp = readl(®s->pciirqenb1); 320 tmp &= ~BIT((8 + ep->num)); /* completion */ 321 writel(tmp, ®s->pciirqenb1); 322 } 323 writel(0, &ep->regs->ep_irqenb); 324 325 /* init to our chosen defaults, notably so that we NAK OUT 326 * packets until the driver queues a read (+note erratum 0112) 327 */ 328 if (!ep->is_in || (ep->dev->quirks & PLX_2280)) { 329 tmp = BIT(SET_NAK_OUT_PACKETS_MODE) | 330 BIT(SET_NAK_OUT_PACKETS) | 331 BIT(CLEAR_EP_HIDE_STATUS_PHASE) | 332 BIT(CLEAR_INTERRUPT_MODE); 333 } else { 334 /* added for 2282 */ 335 tmp = BIT(CLEAR_NAK_OUT_PACKETS_MODE) | 336 BIT(CLEAR_NAK_OUT_PACKETS) | 337 BIT(CLEAR_EP_HIDE_STATUS_PHASE) | 338 BIT(CLEAR_INTERRUPT_MODE); 339 } 340 341 if (ep->num != 0) { 342 tmp |= BIT(CLEAR_ENDPOINT_TOGGLE) | 343 BIT(CLEAR_ENDPOINT_HALT); 344 } 345 writel(tmp, &ep->regs->ep_rsp); 346 347 /* scrub most status bits, and flush any fifo state */ 348 if (ep->dev->quirks & PLX_2280) 349 tmp = BIT(FIFO_OVERFLOW) | 350 BIT(FIFO_UNDERFLOW); 351 else 352 tmp = 0; 353 354 writel(tmp | BIT(TIMEOUT) | 355 BIT(USB_STALL_SENT) | 356 BIT(USB_IN_NAK_SENT) | 357 BIT(USB_IN_ACK_RCVD) | 358 BIT(USB_OUT_PING_NAK_SENT) | 359 BIT(USB_OUT_ACK_SENT) | 360 BIT(FIFO_FLUSH) | 361 BIT(SHORT_PACKET_OUT_DONE_INTERRUPT) | 362 BIT(SHORT_PACKET_TRANSFERRED_INTERRUPT) | 363 BIT(DATA_PACKET_RECEIVED_INTERRUPT) | 364 BIT(DATA_PACKET_TRANSMITTED_INTERRUPT) | 365 BIT(DATA_OUT_PING_TOKEN_INTERRUPT) | 366 BIT(DATA_IN_TOKEN_INTERRUPT), 367 &ep->regs->ep_stat); 368 369 /* fifo size is handled separately */ 370 } 371 372 static void ep_reset_338x(struct net2280_regs __iomem *regs, 373 struct net2280_ep *ep) 374 { 375 u32 tmp, dmastat; 376 377 ep->desc = NULL; 378 INIT_LIST_HEAD(&ep->queue); 379 380 usb_ep_set_maxpacket_limit(&ep->ep, ~0); 381 ep->ep.ops = &net2280_ep_ops; 382 383 /* disable the dma, irqs, endpoint... */ 384 if (ep->dma) { 385 writel(0, &ep->dma->dmactl); 386 writel(BIT(DMA_ABORT_DONE_INTERRUPT) | 387 BIT(DMA_PAUSE_DONE_INTERRUPT) | 388 BIT(DMA_SCATTER_GATHER_DONE_INTERRUPT) | 389 BIT(DMA_TRANSACTION_DONE_INTERRUPT), 390 /* | BIT(DMA_ABORT), */ 391 &ep->dma->dmastat); 392 393 dmastat = readl(&ep->dma->dmastat); 394 if (dmastat == 0x5002) { 395 ep_warn(ep->dev, "The dmastat return = %x!!\n", 396 dmastat); 397 writel(0x5a, &ep->dma->dmastat); 398 } 399 400 tmp = readl(®s->pciirqenb0); 401 tmp &= ~BIT(ep_bit[ep->num]); 402 writel(tmp, ®s->pciirqenb0); 403 } else { 404 if (ep->num < 5) { 405 tmp = readl(®s->pciirqenb1); 406 tmp &= ~BIT((8 + ep->num)); /* completion */ 407 writel(tmp, ®s->pciirqenb1); 408 } 409 } 410 writel(0, &ep->regs->ep_irqenb); 411 412 writel(BIT(SHORT_PACKET_OUT_DONE_INTERRUPT) | 413 BIT(SHORT_PACKET_TRANSFERRED_INTERRUPT) | 414 BIT(FIFO_OVERFLOW) | 415 BIT(DATA_PACKET_RECEIVED_INTERRUPT) | 416 BIT(DATA_PACKET_TRANSMITTED_INTERRUPT) | 417 BIT(DATA_OUT_PING_TOKEN_INTERRUPT) | 418 BIT(DATA_IN_TOKEN_INTERRUPT), &ep->regs->ep_stat); 419 } 420 421 static void nuke(struct net2280_ep *); 422 423 static int net2280_disable(struct usb_ep *_ep) 424 { 425 struct net2280_ep *ep; 426 unsigned long flags; 427 428 ep = container_of(_ep, struct net2280_ep, ep); 429 if (!_ep || !ep->desc || _ep->name == ep0name) 430 return -EINVAL; 431 432 spin_lock_irqsave(&ep->dev->lock, flags); 433 nuke(ep); 434 435 if (ep->dev->quirks & PLX_SUPERSPEED) 436 ep_reset_338x(ep->dev->regs, ep); 437 else 438 ep_reset_228x(ep->dev->regs, ep); 439 440 ep_vdbg(ep->dev, "disabled %s %s\n", 441 ep->dma ? "dma" : "pio", _ep->name); 442 443 /* synch memory views with the device */ 444 (void)readl(&ep->cfg->ep_cfg); 445 446 if (!ep->dma && ep->num >= 1 && ep->num <= 4) 447 ep->dma = &ep->dev->dma[ep->num - 1]; 448 449 spin_unlock_irqrestore(&ep->dev->lock, flags); 450 return 0; 451 } 452 453 /*-------------------------------------------------------------------------*/ 454 455 static struct usb_request 456 *net2280_alloc_request(struct usb_ep *_ep, gfp_t gfp_flags) 457 { 458 struct net2280_ep *ep; 459 struct net2280_request *req; 460 461 if (!_ep) 462 return NULL; 463 ep = container_of(_ep, struct net2280_ep, ep); 464 465 req = kzalloc(sizeof(*req), gfp_flags); 466 if (!req) 467 return NULL; 468 469 INIT_LIST_HEAD(&req->queue); 470 471 /* this dma descriptor may be swapped with the previous dummy */ 472 if (ep->dma) { 473 struct net2280_dma *td; 474 475 td = pci_pool_alloc(ep->dev->requests, gfp_flags, 476 &req->td_dma); 477 if (!td) { 478 kfree(req); 479 return NULL; 480 } 481 td->dmacount = 0; /* not VALID */ 482 td->dmadesc = td->dmaaddr; 483 req->td = td; 484 } 485 return &req->req; 486 } 487 488 static void net2280_free_request(struct usb_ep *_ep, struct usb_request *_req) 489 { 490 struct net2280_ep *ep; 491 struct net2280_request *req; 492 493 ep = container_of(_ep, struct net2280_ep, ep); 494 if (!_ep || !_req) 495 return; 496 497 req = container_of(_req, struct net2280_request, req); 498 WARN_ON(!list_empty(&req->queue)); 499 if (req->td) 500 pci_pool_free(ep->dev->requests, req->td, req->td_dma); 501 kfree(req); 502 } 503 504 /*-------------------------------------------------------------------------*/ 505 506 /* load a packet into the fifo we use for usb IN transfers. 507 * works for all endpoints. 508 * 509 * NOTE: pio with ep-a..ep-d could stuff multiple packets into the fifo 510 * at a time, but this code is simpler because it knows it only writes 511 * one packet. ep-a..ep-d should use dma instead. 512 */ 513 static void write_fifo(struct net2280_ep *ep, struct usb_request *req) 514 { 515 struct net2280_ep_regs __iomem *regs = ep->regs; 516 u8 *buf; 517 u32 tmp; 518 unsigned count, total; 519 520 /* INVARIANT: fifo is currently empty. (testable) */ 521 522 if (req) { 523 buf = req->buf + req->actual; 524 prefetch(buf); 525 total = req->length - req->actual; 526 } else { 527 total = 0; 528 buf = NULL; 529 } 530 531 /* write just one packet at a time */ 532 count = ep->ep.maxpacket; 533 if (count > total) /* min() cannot be used on a bitfield */ 534 count = total; 535 536 ep_vdbg(ep->dev, "write %s fifo (IN) %d bytes%s req %p\n", 537 ep->ep.name, count, 538 (count != ep->ep.maxpacket) ? " (short)" : "", 539 req); 540 while (count >= 4) { 541 /* NOTE be careful if you try to align these. fifo lines 542 * should normally be full (4 bytes) and successive partial 543 * lines are ok only in certain cases. 544 */ 545 tmp = get_unaligned((u32 *)buf); 546 cpu_to_le32s(&tmp); 547 writel(tmp, ®s->ep_data); 548 buf += 4; 549 count -= 4; 550 } 551 552 /* last fifo entry is "short" unless we wrote a full packet. 553 * also explicitly validate last word in (periodic) transfers 554 * when maxpacket is not a multiple of 4 bytes. 555 */ 556 if (count || total < ep->ep.maxpacket) { 557 tmp = count ? get_unaligned((u32 *)buf) : count; 558 cpu_to_le32s(&tmp); 559 set_fifo_bytecount(ep, count & 0x03); 560 writel(tmp, ®s->ep_data); 561 } 562 563 /* pci writes may still be posted */ 564 } 565 566 /* work around erratum 0106: PCI and USB race over the OUT fifo. 567 * caller guarantees chiprev 0100, out endpoint is NAKing, and 568 * there's no real data in the fifo. 569 * 570 * NOTE: also used in cases where that erratum doesn't apply: 571 * where the host wrote "too much" data to us. 572 */ 573 static void out_flush(struct net2280_ep *ep) 574 { 575 u32 __iomem *statp; 576 u32 tmp; 577 578 statp = &ep->regs->ep_stat; 579 580 tmp = readl(statp); 581 if (tmp & BIT(NAK_OUT_PACKETS)) { 582 ep_dbg(ep->dev, "%s %s %08x !NAK\n", 583 ep->ep.name, __func__, tmp); 584 writel(BIT(SET_NAK_OUT_PACKETS), &ep->regs->ep_rsp); 585 } 586 587 writel(BIT(DATA_OUT_PING_TOKEN_INTERRUPT) | 588 BIT(DATA_PACKET_RECEIVED_INTERRUPT), 589 statp); 590 writel(BIT(FIFO_FLUSH), statp); 591 /* Make sure that stap is written */ 592 mb(); 593 tmp = readl(statp); 594 if (tmp & BIT(DATA_OUT_PING_TOKEN_INTERRUPT) && 595 /* high speed did bulk NYET; fifo isn't filling */ 596 ep->dev->gadget.speed == USB_SPEED_FULL) { 597 unsigned usec; 598 599 usec = 50; /* 64 byte bulk/interrupt */ 600 handshake(statp, BIT(USB_OUT_PING_NAK_SENT), 601 BIT(USB_OUT_PING_NAK_SENT), usec); 602 /* NAK done; now CLEAR_NAK_OUT_PACKETS is safe */ 603 } 604 } 605 606 /* unload packet(s) from the fifo we use for usb OUT transfers. 607 * returns true iff the request completed, because of short packet 608 * or the request buffer having filled with full packets. 609 * 610 * for ep-a..ep-d this will read multiple packets out when they 611 * have been accepted. 612 */ 613 static int read_fifo(struct net2280_ep *ep, struct net2280_request *req) 614 { 615 struct net2280_ep_regs __iomem *regs = ep->regs; 616 u8 *buf = req->req.buf + req->req.actual; 617 unsigned count, tmp, is_short; 618 unsigned cleanup = 0, prevent = 0; 619 620 /* erratum 0106 ... packets coming in during fifo reads might 621 * be incompletely rejected. not all cases have workarounds. 622 */ 623 if (ep->dev->chiprev == 0x0100 && 624 ep->dev->gadget.speed == USB_SPEED_FULL) { 625 udelay(1); 626 tmp = readl(&ep->regs->ep_stat); 627 if ((tmp & BIT(NAK_OUT_PACKETS))) 628 cleanup = 1; 629 else if ((tmp & BIT(FIFO_FULL))) { 630 start_out_naking(ep); 631 prevent = 1; 632 } 633 /* else: hope we don't see the problem */ 634 } 635 636 /* never overflow the rx buffer. the fifo reads packets until 637 * it sees a short one; we might not be ready for them all. 638 */ 639 prefetchw(buf); 640 count = readl(®s->ep_avail); 641 if (unlikely(count == 0)) { 642 udelay(1); 643 tmp = readl(&ep->regs->ep_stat); 644 count = readl(®s->ep_avail); 645 /* handled that data already? */ 646 if (count == 0 && (tmp & BIT(NAK_OUT_PACKETS)) == 0) 647 return 0; 648 } 649 650 tmp = req->req.length - req->req.actual; 651 if (count > tmp) { 652 /* as with DMA, data overflow gets flushed */ 653 if ((tmp % ep->ep.maxpacket) != 0) { 654 ep_err(ep->dev, 655 "%s out fifo %d bytes, expected %d\n", 656 ep->ep.name, count, tmp); 657 req->req.status = -EOVERFLOW; 658 cleanup = 1; 659 /* NAK_OUT_PACKETS will be set, so flushing is safe; 660 * the next read will start with the next packet 661 */ 662 } /* else it's a ZLP, no worries */ 663 count = tmp; 664 } 665 req->req.actual += count; 666 667 is_short = (count == 0) || ((count % ep->ep.maxpacket) != 0); 668 669 ep_vdbg(ep->dev, "read %s fifo (OUT) %d bytes%s%s%s req %p %d/%d\n", 670 ep->ep.name, count, is_short ? " (short)" : "", 671 cleanup ? " flush" : "", prevent ? " nak" : "", 672 req, req->req.actual, req->req.length); 673 674 while (count >= 4) { 675 tmp = readl(®s->ep_data); 676 cpu_to_le32s(&tmp); 677 put_unaligned(tmp, (u32 *)buf); 678 buf += 4; 679 count -= 4; 680 } 681 if (count) { 682 tmp = readl(®s->ep_data); 683 /* LE conversion is implicit here: */ 684 do { 685 *buf++ = (u8) tmp; 686 tmp >>= 8; 687 } while (--count); 688 } 689 if (cleanup) 690 out_flush(ep); 691 if (prevent) { 692 writel(BIT(CLEAR_NAK_OUT_PACKETS), &ep->regs->ep_rsp); 693 (void) readl(&ep->regs->ep_rsp); 694 } 695 696 return is_short || ((req->req.actual == req->req.length) && 697 !req->req.zero); 698 } 699 700 /* fill out dma descriptor to match a given request */ 701 static void fill_dma_desc(struct net2280_ep *ep, 702 struct net2280_request *req, int valid) 703 { 704 struct net2280_dma *td = req->td; 705 u32 dmacount = req->req.length; 706 707 /* don't let DMA continue after a short OUT packet, 708 * so overruns can't affect the next transfer. 709 * in case of overruns on max-size packets, we can't 710 * stop the fifo from filling but we can flush it. 711 */ 712 if (ep->is_in) 713 dmacount |= BIT(DMA_DIRECTION); 714 if ((!ep->is_in && (dmacount % ep->ep.maxpacket) != 0) || 715 !(ep->dev->quirks & PLX_2280)) 716 dmacount |= BIT(END_OF_CHAIN); 717 718 req->valid = valid; 719 if (valid) 720 dmacount |= BIT(VALID_BIT); 721 dmacount |= BIT(DMA_DONE_INTERRUPT_ENABLE); 722 723 /* td->dmadesc = previously set by caller */ 724 td->dmaaddr = cpu_to_le32 (req->req.dma); 725 726 /* 2280 may be polling VALID_BIT through ep->dma->dmadesc */ 727 wmb(); 728 td->dmacount = cpu_to_le32(dmacount); 729 } 730 731 static const u32 dmactl_default = 732 BIT(DMA_SCATTER_GATHER_DONE_INTERRUPT) | 733 BIT(DMA_CLEAR_COUNT_ENABLE) | 734 /* erratum 0116 workaround part 1 (use POLLING) */ 735 (POLL_100_USEC << DESCRIPTOR_POLLING_RATE) | 736 BIT(DMA_VALID_BIT_POLLING_ENABLE) | 737 BIT(DMA_VALID_BIT_ENABLE) | 738 BIT(DMA_SCATTER_GATHER_ENABLE) | 739 /* erratum 0116 workaround part 2 (no AUTOSTART) */ 740 BIT(DMA_ENABLE); 741 742 static inline void spin_stop_dma(struct net2280_dma_regs __iomem *dma) 743 { 744 handshake(&dma->dmactl, BIT(DMA_ENABLE), 0, 50); 745 } 746 747 static inline void stop_dma(struct net2280_dma_regs __iomem *dma) 748 { 749 writel(readl(&dma->dmactl) & ~BIT(DMA_ENABLE), &dma->dmactl); 750 spin_stop_dma(dma); 751 } 752 753 static void start_queue(struct net2280_ep *ep, u32 dmactl, u32 td_dma) 754 { 755 struct net2280_dma_regs __iomem *dma = ep->dma; 756 unsigned int tmp = BIT(VALID_BIT) | (ep->is_in << DMA_DIRECTION); 757 758 if (!(ep->dev->quirks & PLX_2280)) 759 tmp |= BIT(END_OF_CHAIN); 760 761 writel(tmp, &dma->dmacount); 762 writel(readl(&dma->dmastat), &dma->dmastat); 763 764 writel(td_dma, &dma->dmadesc); 765 if (ep->dev->quirks & PLX_SUPERSPEED) 766 dmactl |= BIT(DMA_REQUEST_OUTSTANDING); 767 writel(dmactl, &dma->dmactl); 768 769 /* erratum 0116 workaround part 3: pci arbiter away from net2280 */ 770 (void) readl(&ep->dev->pci->pcimstctl); 771 772 writel(BIT(DMA_START), &dma->dmastat); 773 774 if (!ep->is_in) 775 stop_out_naking(ep); 776 } 777 778 static void start_dma(struct net2280_ep *ep, struct net2280_request *req) 779 { 780 u32 tmp; 781 struct net2280_dma_regs __iomem *dma = ep->dma; 782 783 /* FIXME can't use DMA for ZLPs */ 784 785 /* on this path we "know" there's no dma active (yet) */ 786 WARN_ON(readl(&dma->dmactl) & BIT(DMA_ENABLE)); 787 writel(0, &ep->dma->dmactl); 788 789 /* previous OUT packet might have been short */ 790 if (!ep->is_in && (readl(&ep->regs->ep_stat) & 791 BIT(NAK_OUT_PACKETS))) { 792 writel(BIT(SHORT_PACKET_TRANSFERRED_INTERRUPT), 793 &ep->regs->ep_stat); 794 795 tmp = readl(&ep->regs->ep_avail); 796 if (tmp) { 797 writel(readl(&dma->dmastat), &dma->dmastat); 798 799 /* transfer all/some fifo data */ 800 writel(req->req.dma, &dma->dmaaddr); 801 tmp = min(tmp, req->req.length); 802 803 /* dma irq, faking scatterlist status */ 804 req->td->dmacount = cpu_to_le32(req->req.length - tmp); 805 writel(BIT(DMA_DONE_INTERRUPT_ENABLE) | tmp, 806 &dma->dmacount); 807 req->td->dmadesc = 0; 808 req->valid = 1; 809 810 writel(BIT(DMA_ENABLE), &dma->dmactl); 811 writel(BIT(DMA_START), &dma->dmastat); 812 return; 813 } 814 } 815 816 tmp = dmactl_default; 817 818 /* force packet boundaries between dma requests, but prevent the 819 * controller from automagically writing a last "short" packet 820 * (zero length) unless the driver explicitly said to do that. 821 */ 822 if (ep->is_in) { 823 if (likely((req->req.length % ep->ep.maxpacket) || 824 req->req.zero)){ 825 tmp |= BIT(DMA_FIFO_VALIDATE); 826 ep->in_fifo_validate = 1; 827 } else 828 ep->in_fifo_validate = 0; 829 } 830 831 /* init req->td, pointing to the current dummy */ 832 req->td->dmadesc = cpu_to_le32 (ep->td_dma); 833 fill_dma_desc(ep, req, 1); 834 835 req->td->dmacount |= cpu_to_le32(BIT(END_OF_CHAIN)); 836 837 start_queue(ep, tmp, req->td_dma); 838 } 839 840 static inline void 841 queue_dma(struct net2280_ep *ep, struct net2280_request *req, int valid) 842 { 843 struct net2280_dma *end; 844 dma_addr_t tmp; 845 846 /* swap new dummy for old, link; fill and maybe activate */ 847 end = ep->dummy; 848 ep->dummy = req->td; 849 req->td = end; 850 851 tmp = ep->td_dma; 852 ep->td_dma = req->td_dma; 853 req->td_dma = tmp; 854 855 end->dmadesc = cpu_to_le32 (ep->td_dma); 856 857 fill_dma_desc(ep, req, valid); 858 } 859 860 static void 861 done(struct net2280_ep *ep, struct net2280_request *req, int status) 862 { 863 struct net2280 *dev; 864 unsigned stopped = ep->stopped; 865 866 list_del_init(&req->queue); 867 868 if (req->req.status == -EINPROGRESS) 869 req->req.status = status; 870 else 871 status = req->req.status; 872 873 dev = ep->dev; 874 if (ep->dma) 875 usb_gadget_unmap_request(&dev->gadget, &req->req, ep->is_in); 876 877 if (status && status != -ESHUTDOWN) 878 ep_vdbg(dev, "complete %s req %p stat %d len %u/%u\n", 879 ep->ep.name, &req->req, status, 880 req->req.actual, req->req.length); 881 882 /* don't modify queue heads during completion callback */ 883 ep->stopped = 1; 884 spin_unlock(&dev->lock); 885 usb_gadget_giveback_request(&ep->ep, &req->req); 886 spin_lock(&dev->lock); 887 ep->stopped = stopped; 888 } 889 890 /*-------------------------------------------------------------------------*/ 891 892 static int 893 net2280_queue(struct usb_ep *_ep, struct usb_request *_req, gfp_t gfp_flags) 894 { 895 struct net2280_request *req; 896 struct net2280_ep *ep; 897 struct net2280 *dev; 898 unsigned long flags; 899 900 /* we always require a cpu-view buffer, so that we can 901 * always use pio (as fallback or whatever). 902 */ 903 req = container_of(_req, struct net2280_request, req); 904 if (!_req || !_req->complete || !_req->buf || 905 !list_empty(&req->queue)) 906 return -EINVAL; 907 if (_req->length > (~0 & DMA_BYTE_COUNT_MASK)) 908 return -EDOM; 909 ep = container_of(_ep, struct net2280_ep, ep); 910 if (!_ep || (!ep->desc && ep->num != 0)) 911 return -EINVAL; 912 dev = ep->dev; 913 if (!dev->driver || dev->gadget.speed == USB_SPEED_UNKNOWN) 914 return -ESHUTDOWN; 915 916 /* FIXME implement PIO fallback for ZLPs with DMA */ 917 if (ep->dma && _req->length == 0) 918 return -EOPNOTSUPP; 919 920 /* set up dma mapping in case the caller didn't */ 921 if (ep->dma) { 922 int ret; 923 924 ret = usb_gadget_map_request(&dev->gadget, _req, 925 ep->is_in); 926 if (ret) 927 return ret; 928 } 929 930 ep_vdbg(dev, "%s queue req %p, len %d buf %p\n", 931 _ep->name, _req, _req->length, _req->buf); 932 933 spin_lock_irqsave(&dev->lock, flags); 934 935 _req->status = -EINPROGRESS; 936 _req->actual = 0; 937 938 /* kickstart this i/o queue? */ 939 if (list_empty(&ep->queue) && !ep->stopped && 940 !((dev->quirks & PLX_SUPERSPEED) && ep->dma && 941 (readl(&ep->regs->ep_rsp) & BIT(CLEAR_ENDPOINT_HALT)))) { 942 943 /* use DMA if the endpoint supports it, else pio */ 944 if (ep->dma) 945 start_dma(ep, req); 946 else { 947 /* maybe there's no control data, just status ack */ 948 if (ep->num == 0 && _req->length == 0) { 949 allow_status(ep); 950 done(ep, req, 0); 951 ep_vdbg(dev, "%s status ack\n", ep->ep.name); 952 goto done; 953 } 954 955 /* PIO ... stuff the fifo, or unblock it. */ 956 if (ep->is_in) 957 write_fifo(ep, _req); 958 else if (list_empty(&ep->queue)) { 959 u32 s; 960 961 /* OUT FIFO might have packet(s) buffered */ 962 s = readl(&ep->regs->ep_stat); 963 if ((s & BIT(FIFO_EMPTY)) == 0) { 964 /* note: _req->short_not_ok is 965 * ignored here since PIO _always_ 966 * stops queue advance here, and 967 * _req->status doesn't change for 968 * short reads (only _req->actual) 969 */ 970 if (read_fifo(ep, req) && 971 ep->num == 0) { 972 done(ep, req, 0); 973 allow_status(ep); 974 /* don't queue it */ 975 req = NULL; 976 } else if (read_fifo(ep, req) && 977 ep->num != 0) { 978 done(ep, req, 0); 979 req = NULL; 980 } else 981 s = readl(&ep->regs->ep_stat); 982 } 983 984 /* don't NAK, let the fifo fill */ 985 if (req && (s & BIT(NAK_OUT_PACKETS))) 986 writel(BIT(CLEAR_NAK_OUT_PACKETS), 987 &ep->regs->ep_rsp); 988 } 989 } 990 991 } else if (ep->dma) { 992 int valid = 1; 993 994 if (ep->is_in) { 995 int expect; 996 997 /* preventing magic zlps is per-engine state, not 998 * per-transfer; irq logic must recover hiccups. 999 */ 1000 expect = likely(req->req.zero || 1001 (req->req.length % ep->ep.maxpacket)); 1002 if (expect != ep->in_fifo_validate) 1003 valid = 0; 1004 } 1005 queue_dma(ep, req, valid); 1006 1007 } /* else the irq handler advances the queue. */ 1008 1009 ep->responded = 1; 1010 if (req) 1011 list_add_tail(&req->queue, &ep->queue); 1012 done: 1013 spin_unlock_irqrestore(&dev->lock, flags); 1014 1015 /* pci writes may still be posted */ 1016 return 0; 1017 } 1018 1019 static inline void 1020 dma_done(struct net2280_ep *ep, struct net2280_request *req, u32 dmacount, 1021 int status) 1022 { 1023 req->req.actual = req->req.length - (DMA_BYTE_COUNT_MASK & dmacount); 1024 done(ep, req, status); 1025 } 1026 1027 static void scan_dma_completions(struct net2280_ep *ep) 1028 { 1029 /* only look at descriptors that were "naturally" retired, 1030 * so fifo and list head state won't matter 1031 */ 1032 while (!list_empty(&ep->queue)) { 1033 struct net2280_request *req; 1034 u32 tmp; 1035 1036 req = list_entry(ep->queue.next, 1037 struct net2280_request, queue); 1038 if (!req->valid) 1039 break; 1040 rmb(); 1041 tmp = le32_to_cpup(&req->td->dmacount); 1042 if ((tmp & BIT(VALID_BIT)) != 0) 1043 break; 1044 1045 /* SHORT_PACKET_TRANSFERRED_INTERRUPT handles "usb-short" 1046 * cases where DMA must be aborted; this code handles 1047 * all non-abort DMA completions. 1048 */ 1049 if (unlikely(req->td->dmadesc == 0)) { 1050 /* paranoia */ 1051 tmp = readl(&ep->dma->dmacount); 1052 if (tmp & DMA_BYTE_COUNT_MASK) 1053 break; 1054 /* single transfer mode */ 1055 dma_done(ep, req, tmp, 0); 1056 break; 1057 } else if (!ep->is_in && 1058 (req->req.length % ep->ep.maxpacket) && 1059 !(ep->dev->quirks & PLX_SUPERSPEED)) { 1060 1061 tmp = readl(&ep->regs->ep_stat); 1062 /* AVOID TROUBLE HERE by not issuing short reads from 1063 * your gadget driver. That helps avoids errata 0121, 1064 * 0122, and 0124; not all cases trigger the warning. 1065 */ 1066 if ((tmp & BIT(NAK_OUT_PACKETS)) == 0) { 1067 ep_warn(ep->dev, "%s lost packet sync!\n", 1068 ep->ep.name); 1069 req->req.status = -EOVERFLOW; 1070 } else { 1071 tmp = readl(&ep->regs->ep_avail); 1072 if (tmp) { 1073 /* fifo gets flushed later */ 1074 ep->out_overflow = 1; 1075 ep_dbg(ep->dev, 1076 "%s dma, discard %d len %d\n", 1077 ep->ep.name, tmp, 1078 req->req.length); 1079 req->req.status = -EOVERFLOW; 1080 } 1081 } 1082 } 1083 dma_done(ep, req, tmp, 0); 1084 } 1085 } 1086 1087 static void restart_dma(struct net2280_ep *ep) 1088 { 1089 struct net2280_request *req; 1090 1091 if (ep->stopped) 1092 return; 1093 req = list_entry(ep->queue.next, struct net2280_request, queue); 1094 1095 start_dma(ep, req); 1096 } 1097 1098 static void abort_dma(struct net2280_ep *ep) 1099 { 1100 /* abort the current transfer */ 1101 if (likely(!list_empty(&ep->queue))) { 1102 /* FIXME work around errata 0121, 0122, 0124 */ 1103 writel(BIT(DMA_ABORT), &ep->dma->dmastat); 1104 spin_stop_dma(ep->dma); 1105 } else 1106 stop_dma(ep->dma); 1107 scan_dma_completions(ep); 1108 } 1109 1110 /* dequeue ALL requests */ 1111 static void nuke(struct net2280_ep *ep) 1112 { 1113 struct net2280_request *req; 1114 1115 /* called with spinlock held */ 1116 ep->stopped = 1; 1117 if (ep->dma) 1118 abort_dma(ep); 1119 while (!list_empty(&ep->queue)) { 1120 req = list_entry(ep->queue.next, 1121 struct net2280_request, 1122 queue); 1123 done(ep, req, -ESHUTDOWN); 1124 } 1125 } 1126 1127 /* dequeue JUST ONE request */ 1128 static int net2280_dequeue(struct usb_ep *_ep, struct usb_request *_req) 1129 { 1130 struct net2280_ep *ep; 1131 struct net2280_request *req; 1132 unsigned long flags; 1133 u32 dmactl; 1134 int stopped; 1135 1136 ep = container_of(_ep, struct net2280_ep, ep); 1137 if (!_ep || (!ep->desc && ep->num != 0) || !_req) 1138 return -EINVAL; 1139 1140 spin_lock_irqsave(&ep->dev->lock, flags); 1141 stopped = ep->stopped; 1142 1143 /* quiesce dma while we patch the queue */ 1144 dmactl = 0; 1145 ep->stopped = 1; 1146 if (ep->dma) { 1147 dmactl = readl(&ep->dma->dmactl); 1148 /* WARNING erratum 0127 may kick in ... */ 1149 stop_dma(ep->dma); 1150 scan_dma_completions(ep); 1151 } 1152 1153 /* make sure it's still queued on this endpoint */ 1154 list_for_each_entry(req, &ep->queue, queue) { 1155 if (&req->req == _req) 1156 break; 1157 } 1158 if (&req->req != _req) { 1159 spin_unlock_irqrestore(&ep->dev->lock, flags); 1160 return -EINVAL; 1161 } 1162 1163 /* queue head may be partially complete. */ 1164 if (ep->queue.next == &req->queue) { 1165 if (ep->dma) { 1166 ep_dbg(ep->dev, "unlink (%s) dma\n", _ep->name); 1167 _req->status = -ECONNRESET; 1168 abort_dma(ep); 1169 if (likely(ep->queue.next == &req->queue)) { 1170 /* NOTE: misreports single-transfer mode*/ 1171 req->td->dmacount = 0; /* invalidate */ 1172 dma_done(ep, req, 1173 readl(&ep->dma->dmacount), 1174 -ECONNRESET); 1175 } 1176 } else { 1177 ep_dbg(ep->dev, "unlink (%s) pio\n", _ep->name); 1178 done(ep, req, -ECONNRESET); 1179 } 1180 req = NULL; 1181 } 1182 1183 if (req) 1184 done(ep, req, -ECONNRESET); 1185 ep->stopped = stopped; 1186 1187 if (ep->dma) { 1188 /* turn off dma on inactive queues */ 1189 if (list_empty(&ep->queue)) 1190 stop_dma(ep->dma); 1191 else if (!ep->stopped) { 1192 /* resume current request, or start new one */ 1193 if (req) 1194 writel(dmactl, &ep->dma->dmactl); 1195 else 1196 start_dma(ep, list_entry(ep->queue.next, 1197 struct net2280_request, queue)); 1198 } 1199 } 1200 1201 spin_unlock_irqrestore(&ep->dev->lock, flags); 1202 return 0; 1203 } 1204 1205 /*-------------------------------------------------------------------------*/ 1206 1207 static int net2280_fifo_status(struct usb_ep *_ep); 1208 1209 static int 1210 net2280_set_halt_and_wedge(struct usb_ep *_ep, int value, int wedged) 1211 { 1212 struct net2280_ep *ep; 1213 unsigned long flags; 1214 int retval = 0; 1215 1216 ep = container_of(_ep, struct net2280_ep, ep); 1217 if (!_ep || (!ep->desc && ep->num != 0)) 1218 return -EINVAL; 1219 if (!ep->dev->driver || ep->dev->gadget.speed == USB_SPEED_UNKNOWN) 1220 return -ESHUTDOWN; 1221 if (ep->desc /* not ep0 */ && (ep->desc->bmAttributes & 0x03) 1222 == USB_ENDPOINT_XFER_ISOC) 1223 return -EINVAL; 1224 1225 spin_lock_irqsave(&ep->dev->lock, flags); 1226 if (!list_empty(&ep->queue)) 1227 retval = -EAGAIN; 1228 else if (ep->is_in && value && net2280_fifo_status(_ep) != 0) 1229 retval = -EAGAIN; 1230 else { 1231 ep_vdbg(ep->dev, "%s %s %s\n", _ep->name, 1232 value ? "set" : "clear", 1233 wedged ? "wedge" : "halt"); 1234 /* set/clear, then synch memory views with the device */ 1235 if (value) { 1236 if (ep->num == 0) 1237 ep->dev->protocol_stall = 1; 1238 else 1239 set_halt(ep); 1240 if (wedged) 1241 ep->wedged = 1; 1242 } else { 1243 clear_halt(ep); 1244 if (ep->dev->quirks & PLX_SUPERSPEED && 1245 !list_empty(&ep->queue) && ep->td_dma) 1246 restart_dma(ep); 1247 ep->wedged = 0; 1248 } 1249 (void) readl(&ep->regs->ep_rsp); 1250 } 1251 spin_unlock_irqrestore(&ep->dev->lock, flags); 1252 1253 return retval; 1254 } 1255 1256 static int net2280_set_halt(struct usb_ep *_ep, int value) 1257 { 1258 return net2280_set_halt_and_wedge(_ep, value, 0); 1259 } 1260 1261 static int net2280_set_wedge(struct usb_ep *_ep) 1262 { 1263 if (!_ep || _ep->name == ep0name) 1264 return -EINVAL; 1265 return net2280_set_halt_and_wedge(_ep, 1, 1); 1266 } 1267 1268 static int net2280_fifo_status(struct usb_ep *_ep) 1269 { 1270 struct net2280_ep *ep; 1271 u32 avail; 1272 1273 ep = container_of(_ep, struct net2280_ep, ep); 1274 if (!_ep || (!ep->desc && ep->num != 0)) 1275 return -ENODEV; 1276 if (!ep->dev->driver || ep->dev->gadget.speed == USB_SPEED_UNKNOWN) 1277 return -ESHUTDOWN; 1278 1279 avail = readl(&ep->regs->ep_avail) & (BIT(12) - 1); 1280 if (avail > ep->fifo_size) 1281 return -EOVERFLOW; 1282 if (ep->is_in) 1283 avail = ep->fifo_size - avail; 1284 return avail; 1285 } 1286 1287 static void net2280_fifo_flush(struct usb_ep *_ep) 1288 { 1289 struct net2280_ep *ep; 1290 1291 ep = container_of(_ep, struct net2280_ep, ep); 1292 if (!_ep || (!ep->desc && ep->num != 0)) 1293 return; 1294 if (!ep->dev->driver || ep->dev->gadget.speed == USB_SPEED_UNKNOWN) 1295 return; 1296 1297 writel(BIT(FIFO_FLUSH), &ep->regs->ep_stat); 1298 (void) readl(&ep->regs->ep_rsp); 1299 } 1300 1301 static const struct usb_ep_ops net2280_ep_ops = { 1302 .enable = net2280_enable, 1303 .disable = net2280_disable, 1304 1305 .alloc_request = net2280_alloc_request, 1306 .free_request = net2280_free_request, 1307 1308 .queue = net2280_queue, 1309 .dequeue = net2280_dequeue, 1310 1311 .set_halt = net2280_set_halt, 1312 .set_wedge = net2280_set_wedge, 1313 .fifo_status = net2280_fifo_status, 1314 .fifo_flush = net2280_fifo_flush, 1315 }; 1316 1317 /*-------------------------------------------------------------------------*/ 1318 1319 static int net2280_get_frame(struct usb_gadget *_gadget) 1320 { 1321 struct net2280 *dev; 1322 unsigned long flags; 1323 u16 retval; 1324 1325 if (!_gadget) 1326 return -ENODEV; 1327 dev = container_of(_gadget, struct net2280, gadget); 1328 spin_lock_irqsave(&dev->lock, flags); 1329 retval = get_idx_reg(dev->regs, REG_FRAME) & 0x03ff; 1330 spin_unlock_irqrestore(&dev->lock, flags); 1331 return retval; 1332 } 1333 1334 static int net2280_wakeup(struct usb_gadget *_gadget) 1335 { 1336 struct net2280 *dev; 1337 u32 tmp; 1338 unsigned long flags; 1339 1340 if (!_gadget) 1341 return 0; 1342 dev = container_of(_gadget, struct net2280, gadget); 1343 1344 spin_lock_irqsave(&dev->lock, flags); 1345 tmp = readl(&dev->usb->usbctl); 1346 if (tmp & BIT(DEVICE_REMOTE_WAKEUP_ENABLE)) 1347 writel(BIT(GENERATE_RESUME), &dev->usb->usbstat); 1348 spin_unlock_irqrestore(&dev->lock, flags); 1349 1350 /* pci writes may still be posted */ 1351 return 0; 1352 } 1353 1354 static int net2280_set_selfpowered(struct usb_gadget *_gadget, int value) 1355 { 1356 struct net2280 *dev; 1357 u32 tmp; 1358 unsigned long flags; 1359 1360 if (!_gadget) 1361 return 0; 1362 dev = container_of(_gadget, struct net2280, gadget); 1363 1364 spin_lock_irqsave(&dev->lock, flags); 1365 tmp = readl(&dev->usb->usbctl); 1366 if (value) { 1367 tmp |= BIT(SELF_POWERED_STATUS); 1368 _gadget->is_selfpowered = 1; 1369 } else { 1370 tmp &= ~BIT(SELF_POWERED_STATUS); 1371 _gadget->is_selfpowered = 0; 1372 } 1373 writel(tmp, &dev->usb->usbctl); 1374 spin_unlock_irqrestore(&dev->lock, flags); 1375 1376 return 0; 1377 } 1378 1379 static int net2280_pullup(struct usb_gadget *_gadget, int is_on) 1380 { 1381 struct net2280 *dev; 1382 u32 tmp; 1383 unsigned long flags; 1384 1385 if (!_gadget) 1386 return -ENODEV; 1387 dev = container_of(_gadget, struct net2280, gadget); 1388 1389 spin_lock_irqsave(&dev->lock, flags); 1390 tmp = readl(&dev->usb->usbctl); 1391 dev->softconnect = (is_on != 0); 1392 if (is_on) 1393 tmp |= BIT(USB_DETECT_ENABLE); 1394 else 1395 tmp &= ~BIT(USB_DETECT_ENABLE); 1396 writel(tmp, &dev->usb->usbctl); 1397 spin_unlock_irqrestore(&dev->lock, flags); 1398 1399 return 0; 1400 } 1401 1402 static int net2280_start(struct usb_gadget *_gadget, 1403 struct usb_gadget_driver *driver); 1404 static int net2280_stop(struct usb_gadget *_gadget); 1405 1406 static const struct usb_gadget_ops net2280_ops = { 1407 .get_frame = net2280_get_frame, 1408 .wakeup = net2280_wakeup, 1409 .set_selfpowered = net2280_set_selfpowered, 1410 .pullup = net2280_pullup, 1411 .udc_start = net2280_start, 1412 .udc_stop = net2280_stop, 1413 }; 1414 1415 /*-------------------------------------------------------------------------*/ 1416 1417 #ifdef CONFIG_USB_GADGET_DEBUG_FILES 1418 1419 /* FIXME move these into procfs, and use seq_file. 1420 * Sysfs _still_ doesn't behave for arbitrarily sized files, 1421 * and also doesn't help products using this with 2.4 kernels. 1422 */ 1423 1424 /* "function" sysfs attribute */ 1425 static ssize_t function_show(struct device *_dev, struct device_attribute *attr, 1426 char *buf) 1427 { 1428 struct net2280 *dev = dev_get_drvdata(_dev); 1429 1430 if (!dev->driver || !dev->driver->function || 1431 strlen(dev->driver->function) > PAGE_SIZE) 1432 return 0; 1433 return scnprintf(buf, PAGE_SIZE, "%s\n", dev->driver->function); 1434 } 1435 static DEVICE_ATTR_RO(function); 1436 1437 static ssize_t registers_show(struct device *_dev, 1438 struct device_attribute *attr, char *buf) 1439 { 1440 struct net2280 *dev; 1441 char *next; 1442 unsigned size, t; 1443 unsigned long flags; 1444 int i; 1445 u32 t1, t2; 1446 const char *s; 1447 1448 dev = dev_get_drvdata(_dev); 1449 next = buf; 1450 size = PAGE_SIZE; 1451 spin_lock_irqsave(&dev->lock, flags); 1452 1453 if (dev->driver) 1454 s = dev->driver->driver.name; 1455 else 1456 s = "(none)"; 1457 1458 /* Main Control Registers */ 1459 t = scnprintf(next, size, "%s version " DRIVER_VERSION 1460 ", chiprev %04x\n\n" 1461 "devinit %03x fifoctl %08x gadget '%s'\n" 1462 "pci irqenb0 %02x irqenb1 %08x " 1463 "irqstat0 %04x irqstat1 %08x\n", 1464 driver_name, dev->chiprev, 1465 readl(&dev->regs->devinit), 1466 readl(&dev->regs->fifoctl), 1467 s, 1468 readl(&dev->regs->pciirqenb0), 1469 readl(&dev->regs->pciirqenb1), 1470 readl(&dev->regs->irqstat0), 1471 readl(&dev->regs->irqstat1)); 1472 size -= t; 1473 next += t; 1474 1475 /* USB Control Registers */ 1476 t1 = readl(&dev->usb->usbctl); 1477 t2 = readl(&dev->usb->usbstat); 1478 if (t1 & BIT(VBUS_PIN)) { 1479 if (t2 & BIT(HIGH_SPEED)) 1480 s = "high speed"; 1481 else if (dev->gadget.speed == USB_SPEED_UNKNOWN) 1482 s = "powered"; 1483 else 1484 s = "full speed"; 1485 /* full speed bit (6) not working?? */ 1486 } else 1487 s = "not attached"; 1488 t = scnprintf(next, size, 1489 "stdrsp %08x usbctl %08x usbstat %08x " 1490 "addr 0x%02x (%s)\n", 1491 readl(&dev->usb->stdrsp), t1, t2, 1492 readl(&dev->usb->ouraddr), s); 1493 size -= t; 1494 next += t; 1495 1496 /* PCI Master Control Registers */ 1497 1498 /* DMA Control Registers */ 1499 1500 /* Configurable EP Control Registers */ 1501 for (i = 0; i < dev->n_ep; i++) { 1502 struct net2280_ep *ep; 1503 1504 ep = &dev->ep[i]; 1505 if (i && !ep->desc) 1506 continue; 1507 1508 t1 = readl(&ep->cfg->ep_cfg); 1509 t2 = readl(&ep->regs->ep_rsp) & 0xff; 1510 t = scnprintf(next, size, 1511 "\n%s\tcfg %05x rsp (%02x) %s%s%s%s%s%s%s%s" 1512 "irqenb %02x\n", 1513 ep->ep.name, t1, t2, 1514 (t2 & BIT(CLEAR_NAK_OUT_PACKETS)) 1515 ? "NAK " : "", 1516 (t2 & BIT(CLEAR_EP_HIDE_STATUS_PHASE)) 1517 ? "hide " : "", 1518 (t2 & BIT(CLEAR_EP_FORCE_CRC_ERROR)) 1519 ? "CRC " : "", 1520 (t2 & BIT(CLEAR_INTERRUPT_MODE)) 1521 ? "interrupt " : "", 1522 (t2 & BIT(CLEAR_CONTROL_STATUS_PHASE_HANDSHAKE)) 1523 ? "status " : "", 1524 (t2 & BIT(CLEAR_NAK_OUT_PACKETS_MODE)) 1525 ? "NAKmode " : "", 1526 (t2 & BIT(CLEAR_ENDPOINT_TOGGLE)) 1527 ? "DATA1 " : "DATA0 ", 1528 (t2 & BIT(CLEAR_ENDPOINT_HALT)) 1529 ? "HALT " : "", 1530 readl(&ep->regs->ep_irqenb)); 1531 size -= t; 1532 next += t; 1533 1534 t = scnprintf(next, size, 1535 "\tstat %08x avail %04x " 1536 "(ep%d%s-%s)%s\n", 1537 readl(&ep->regs->ep_stat), 1538 readl(&ep->regs->ep_avail), 1539 t1 & 0x0f, DIR_STRING(t1), 1540 type_string(t1 >> 8), 1541 ep->stopped ? "*" : ""); 1542 size -= t; 1543 next += t; 1544 1545 if (!ep->dma) 1546 continue; 1547 1548 t = scnprintf(next, size, 1549 " dma\tctl %08x stat %08x count %08x\n" 1550 "\taddr %08x desc %08x\n", 1551 readl(&ep->dma->dmactl), 1552 readl(&ep->dma->dmastat), 1553 readl(&ep->dma->dmacount), 1554 readl(&ep->dma->dmaaddr), 1555 readl(&ep->dma->dmadesc)); 1556 size -= t; 1557 next += t; 1558 1559 } 1560 1561 /* Indexed Registers (none yet) */ 1562 1563 /* Statistics */ 1564 t = scnprintf(next, size, "\nirqs: "); 1565 size -= t; 1566 next += t; 1567 for (i = 0; i < dev->n_ep; i++) { 1568 struct net2280_ep *ep; 1569 1570 ep = &dev->ep[i]; 1571 if (i && !ep->irqs) 1572 continue; 1573 t = scnprintf(next, size, " %s/%lu", ep->ep.name, ep->irqs); 1574 size -= t; 1575 next += t; 1576 1577 } 1578 t = scnprintf(next, size, "\n"); 1579 size -= t; 1580 next += t; 1581 1582 spin_unlock_irqrestore(&dev->lock, flags); 1583 1584 return PAGE_SIZE - size; 1585 } 1586 static DEVICE_ATTR_RO(registers); 1587 1588 static ssize_t queues_show(struct device *_dev, struct device_attribute *attr, 1589 char *buf) 1590 { 1591 struct net2280 *dev; 1592 char *next; 1593 unsigned size; 1594 unsigned long flags; 1595 int i; 1596 1597 dev = dev_get_drvdata(_dev); 1598 next = buf; 1599 size = PAGE_SIZE; 1600 spin_lock_irqsave(&dev->lock, flags); 1601 1602 for (i = 0; i < dev->n_ep; i++) { 1603 struct net2280_ep *ep = &dev->ep[i]; 1604 struct net2280_request *req; 1605 int t; 1606 1607 if (i != 0) { 1608 const struct usb_endpoint_descriptor *d; 1609 1610 d = ep->desc; 1611 if (!d) 1612 continue; 1613 t = d->bEndpointAddress; 1614 t = scnprintf(next, size, 1615 "\n%s (ep%d%s-%s) max %04x %s fifo %d\n", 1616 ep->ep.name, t & USB_ENDPOINT_NUMBER_MASK, 1617 (t & USB_DIR_IN) ? "in" : "out", 1618 type_string(d->bmAttributes), 1619 usb_endpoint_maxp(d) & 0x1fff, 1620 ep->dma ? "dma" : "pio", ep->fifo_size 1621 ); 1622 } else /* ep0 should only have one transfer queued */ 1623 t = scnprintf(next, size, "ep0 max 64 pio %s\n", 1624 ep->is_in ? "in" : "out"); 1625 if (t <= 0 || t > size) 1626 goto done; 1627 size -= t; 1628 next += t; 1629 1630 if (list_empty(&ep->queue)) { 1631 t = scnprintf(next, size, "\t(nothing queued)\n"); 1632 if (t <= 0 || t > size) 1633 goto done; 1634 size -= t; 1635 next += t; 1636 continue; 1637 } 1638 list_for_each_entry(req, &ep->queue, queue) { 1639 if (ep->dma && req->td_dma == readl(&ep->dma->dmadesc)) 1640 t = scnprintf(next, size, 1641 "\treq %p len %d/%d " 1642 "buf %p (dmacount %08x)\n", 1643 &req->req, req->req.actual, 1644 req->req.length, req->req.buf, 1645 readl(&ep->dma->dmacount)); 1646 else 1647 t = scnprintf(next, size, 1648 "\treq %p len %d/%d buf %p\n", 1649 &req->req, req->req.actual, 1650 req->req.length, req->req.buf); 1651 if (t <= 0 || t > size) 1652 goto done; 1653 size -= t; 1654 next += t; 1655 1656 if (ep->dma) { 1657 struct net2280_dma *td; 1658 1659 td = req->td; 1660 t = scnprintf(next, size, "\t td %08x " 1661 " count %08x buf %08x desc %08x\n", 1662 (u32) req->td_dma, 1663 le32_to_cpu(td->dmacount), 1664 le32_to_cpu(td->dmaaddr), 1665 le32_to_cpu(td->dmadesc)); 1666 if (t <= 0 || t > size) 1667 goto done; 1668 size -= t; 1669 next += t; 1670 } 1671 } 1672 } 1673 1674 done: 1675 spin_unlock_irqrestore(&dev->lock, flags); 1676 return PAGE_SIZE - size; 1677 } 1678 static DEVICE_ATTR_RO(queues); 1679 1680 1681 #else 1682 1683 #define device_create_file(a, b) (0) 1684 #define device_remove_file(a, b) do { } while (0) 1685 1686 #endif 1687 1688 /*-------------------------------------------------------------------------*/ 1689 1690 /* another driver-specific mode might be a request type doing dma 1691 * to/from another device fifo instead of to/from memory. 1692 */ 1693 1694 static void set_fifo_mode(struct net2280 *dev, int mode) 1695 { 1696 /* keeping high bits preserves BAR2 */ 1697 writel((0xffff << PCI_BASE2_RANGE) | mode, &dev->regs->fifoctl); 1698 1699 /* always ep-{a,b,e,f} ... maybe not ep-c or ep-d */ 1700 INIT_LIST_HEAD(&dev->gadget.ep_list); 1701 list_add_tail(&dev->ep[1].ep.ep_list, &dev->gadget.ep_list); 1702 list_add_tail(&dev->ep[2].ep.ep_list, &dev->gadget.ep_list); 1703 switch (mode) { 1704 case 0: 1705 list_add_tail(&dev->ep[3].ep.ep_list, &dev->gadget.ep_list); 1706 list_add_tail(&dev->ep[4].ep.ep_list, &dev->gadget.ep_list); 1707 dev->ep[1].fifo_size = dev->ep[2].fifo_size = 1024; 1708 break; 1709 case 1: 1710 dev->ep[1].fifo_size = dev->ep[2].fifo_size = 2048; 1711 break; 1712 case 2: 1713 list_add_tail(&dev->ep[3].ep.ep_list, &dev->gadget.ep_list); 1714 dev->ep[1].fifo_size = 2048; 1715 dev->ep[2].fifo_size = 1024; 1716 break; 1717 } 1718 /* fifo sizes for ep0, ep-c, ep-d, ep-e, and ep-f never change */ 1719 list_add_tail(&dev->ep[5].ep.ep_list, &dev->gadget.ep_list); 1720 list_add_tail(&dev->ep[6].ep.ep_list, &dev->gadget.ep_list); 1721 } 1722 1723 static void defect7374_disable_data_eps(struct net2280 *dev) 1724 { 1725 /* 1726 * For Defect 7374, disable data EPs (and more): 1727 * - This phase undoes the earlier phase of the Defect 7374 workaround, 1728 * returing ep regs back to normal. 1729 */ 1730 struct net2280_ep *ep; 1731 int i; 1732 unsigned char ep_sel; 1733 u32 tmp_reg; 1734 1735 for (i = 1; i < 5; i++) { 1736 ep = &dev->ep[i]; 1737 writel(0, &ep->cfg->ep_cfg); 1738 } 1739 1740 /* CSROUT, CSRIN, PCIOUT, PCIIN, STATIN, RCIN */ 1741 for (i = 0; i < 6; i++) 1742 writel(0, &dev->dep[i].dep_cfg); 1743 1744 for (ep_sel = 0; ep_sel <= 21; ep_sel++) { 1745 /* Select an endpoint for subsequent operations: */ 1746 tmp_reg = readl(&dev->plregs->pl_ep_ctrl); 1747 writel(((tmp_reg & ~0x1f) | ep_sel), &dev->plregs->pl_ep_ctrl); 1748 1749 if (ep_sel < 2 || (ep_sel > 9 && ep_sel < 14) || 1750 ep_sel == 18 || ep_sel == 20) 1751 continue; 1752 1753 /* Change settings on some selected endpoints */ 1754 tmp_reg = readl(&dev->plregs->pl_ep_cfg_4); 1755 tmp_reg &= ~BIT(NON_CTRL_IN_TOLERATE_BAD_DIR); 1756 writel(tmp_reg, &dev->plregs->pl_ep_cfg_4); 1757 tmp_reg = readl(&dev->plregs->pl_ep_ctrl); 1758 tmp_reg |= BIT(EP_INITIALIZED); 1759 writel(tmp_reg, &dev->plregs->pl_ep_ctrl); 1760 } 1761 } 1762 1763 static void defect7374_enable_data_eps_zero(struct net2280 *dev) 1764 { 1765 u32 tmp = 0, tmp_reg; 1766 u32 scratch; 1767 int i; 1768 unsigned char ep_sel; 1769 1770 scratch = get_idx_reg(dev->regs, SCRATCH); 1771 1772 WARN_ON((scratch & (0xf << DEFECT7374_FSM_FIELD)) 1773 == DEFECT7374_FSM_SS_CONTROL_READ); 1774 1775 scratch &= ~(0xf << DEFECT7374_FSM_FIELD); 1776 1777 ep_warn(dev, "Operate Defect 7374 workaround soft this time"); 1778 ep_warn(dev, "It will operate on cold-reboot and SS connect"); 1779 1780 /*GPEPs:*/ 1781 tmp = ((0 << ENDPOINT_NUMBER) | BIT(ENDPOINT_DIRECTION) | 1782 (2 << OUT_ENDPOINT_TYPE) | (2 << IN_ENDPOINT_TYPE) | 1783 ((dev->enhanced_mode) ? 1784 BIT(OUT_ENDPOINT_ENABLE) : BIT(ENDPOINT_ENABLE)) | 1785 BIT(IN_ENDPOINT_ENABLE)); 1786 1787 for (i = 1; i < 5; i++) 1788 writel(tmp, &dev->ep[i].cfg->ep_cfg); 1789 1790 /* CSRIN, PCIIN, STATIN, RCIN*/ 1791 tmp = ((0 << ENDPOINT_NUMBER) | BIT(ENDPOINT_ENABLE)); 1792 writel(tmp, &dev->dep[1].dep_cfg); 1793 writel(tmp, &dev->dep[3].dep_cfg); 1794 writel(tmp, &dev->dep[4].dep_cfg); 1795 writel(tmp, &dev->dep[5].dep_cfg); 1796 1797 /*Implemented for development and debug. 1798 * Can be refined/tuned later.*/ 1799 for (ep_sel = 0; ep_sel <= 21; ep_sel++) { 1800 /* Select an endpoint for subsequent operations: */ 1801 tmp_reg = readl(&dev->plregs->pl_ep_ctrl); 1802 writel(((tmp_reg & ~0x1f) | ep_sel), 1803 &dev->plregs->pl_ep_ctrl); 1804 1805 if (ep_sel == 1) { 1806 tmp = 1807 (readl(&dev->plregs->pl_ep_ctrl) | 1808 BIT(CLEAR_ACK_ERROR_CODE) | 0); 1809 writel(tmp, &dev->plregs->pl_ep_ctrl); 1810 continue; 1811 } 1812 1813 if (ep_sel == 0 || (ep_sel > 9 && ep_sel < 14) || 1814 ep_sel == 18 || ep_sel == 20) 1815 continue; 1816 1817 tmp = (readl(&dev->plregs->pl_ep_cfg_4) | 1818 BIT(NON_CTRL_IN_TOLERATE_BAD_DIR) | 0); 1819 writel(tmp, &dev->plregs->pl_ep_cfg_4); 1820 1821 tmp = readl(&dev->plregs->pl_ep_ctrl) & 1822 ~BIT(EP_INITIALIZED); 1823 writel(tmp, &dev->plregs->pl_ep_ctrl); 1824 1825 } 1826 1827 /* Set FSM to focus on the first Control Read: 1828 * - Tip: Connection speed is known upon the first 1829 * setup request.*/ 1830 scratch |= DEFECT7374_FSM_WAITING_FOR_CONTROL_READ; 1831 set_idx_reg(dev->regs, SCRATCH, scratch); 1832 1833 } 1834 1835 /* keeping it simple: 1836 * - one bus driver, initted first; 1837 * - one function driver, initted second 1838 * 1839 * most of the work to support multiple net2280 controllers would 1840 * be to associate this gadget driver (yes?) with all of them, or 1841 * perhaps to bind specific drivers to specific devices. 1842 */ 1843 1844 static void usb_reset_228x(struct net2280 *dev) 1845 { 1846 u32 tmp; 1847 1848 dev->gadget.speed = USB_SPEED_UNKNOWN; 1849 (void) readl(&dev->usb->usbctl); 1850 1851 net2280_led_init(dev); 1852 1853 /* disable automatic responses, and irqs */ 1854 writel(0, &dev->usb->stdrsp); 1855 writel(0, &dev->regs->pciirqenb0); 1856 writel(0, &dev->regs->pciirqenb1); 1857 1858 /* clear old dma and irq state */ 1859 for (tmp = 0; tmp < 4; tmp++) { 1860 struct net2280_ep *ep = &dev->ep[tmp + 1]; 1861 if (ep->dma) 1862 abort_dma(ep); 1863 } 1864 1865 writel(~0, &dev->regs->irqstat0), 1866 writel(~(u32)BIT(SUSPEND_REQUEST_INTERRUPT), &dev->regs->irqstat1), 1867 1868 /* reset, and enable pci */ 1869 tmp = readl(&dev->regs->devinit) | 1870 BIT(PCI_ENABLE) | 1871 BIT(FIFO_SOFT_RESET) | 1872 BIT(USB_SOFT_RESET) | 1873 BIT(M8051_RESET); 1874 writel(tmp, &dev->regs->devinit); 1875 1876 /* standard fifo and endpoint allocations */ 1877 set_fifo_mode(dev, (fifo_mode <= 2) ? fifo_mode : 0); 1878 } 1879 1880 static void usb_reset_338x(struct net2280 *dev) 1881 { 1882 u32 tmp; 1883 1884 dev->gadget.speed = USB_SPEED_UNKNOWN; 1885 (void)readl(&dev->usb->usbctl); 1886 1887 net2280_led_init(dev); 1888 1889 if (dev->bug7734_patched) { 1890 /* disable automatic responses, and irqs */ 1891 writel(0, &dev->usb->stdrsp); 1892 writel(0, &dev->regs->pciirqenb0); 1893 writel(0, &dev->regs->pciirqenb1); 1894 } 1895 1896 /* clear old dma and irq state */ 1897 for (tmp = 0; tmp < 4; tmp++) { 1898 struct net2280_ep *ep = &dev->ep[tmp + 1]; 1899 1900 if (ep->dma) 1901 abort_dma(ep); 1902 } 1903 1904 writel(~0, &dev->regs->irqstat0), writel(~0, &dev->regs->irqstat1); 1905 1906 if (dev->bug7734_patched) { 1907 /* reset, and enable pci */ 1908 tmp = readl(&dev->regs->devinit) | 1909 BIT(PCI_ENABLE) | 1910 BIT(FIFO_SOFT_RESET) | 1911 BIT(USB_SOFT_RESET) | 1912 BIT(M8051_RESET); 1913 1914 writel(tmp, &dev->regs->devinit); 1915 } 1916 1917 /* always ep-{1,2,3,4} ... maybe not ep-3 or ep-4 */ 1918 INIT_LIST_HEAD(&dev->gadget.ep_list); 1919 1920 for (tmp = 1; tmp < dev->n_ep; tmp++) 1921 list_add_tail(&dev->ep[tmp].ep.ep_list, &dev->gadget.ep_list); 1922 1923 } 1924 1925 static void usb_reset(struct net2280 *dev) 1926 { 1927 if (dev->quirks & PLX_LEGACY) 1928 return usb_reset_228x(dev); 1929 return usb_reset_338x(dev); 1930 } 1931 1932 static void usb_reinit_228x(struct net2280 *dev) 1933 { 1934 u32 tmp; 1935 1936 /* basic endpoint init */ 1937 for (tmp = 0; tmp < 7; tmp++) { 1938 struct net2280_ep *ep = &dev->ep[tmp]; 1939 1940 ep->ep.name = ep_name[tmp]; 1941 ep->dev = dev; 1942 ep->num = tmp; 1943 1944 if (tmp > 0 && tmp <= 4) { 1945 ep->fifo_size = 1024; 1946 ep->dma = &dev->dma[tmp - 1]; 1947 } else 1948 ep->fifo_size = 64; 1949 ep->regs = &dev->epregs[tmp]; 1950 ep->cfg = &dev->epregs[tmp]; 1951 ep_reset_228x(dev->regs, ep); 1952 } 1953 usb_ep_set_maxpacket_limit(&dev->ep[0].ep, 64); 1954 usb_ep_set_maxpacket_limit(&dev->ep[5].ep, 64); 1955 usb_ep_set_maxpacket_limit(&dev->ep[6].ep, 64); 1956 1957 dev->gadget.ep0 = &dev->ep[0].ep; 1958 dev->ep[0].stopped = 0; 1959 INIT_LIST_HEAD(&dev->gadget.ep0->ep_list); 1960 1961 /* we want to prevent lowlevel/insecure access from the USB host, 1962 * but erratum 0119 means this enable bit is ignored 1963 */ 1964 for (tmp = 0; tmp < 5; tmp++) 1965 writel(EP_DONTUSE, &dev->dep[tmp].dep_cfg); 1966 } 1967 1968 static void usb_reinit_338x(struct net2280 *dev) 1969 { 1970 int i; 1971 u32 tmp, val; 1972 static const u32 ne[9] = { 0, 1, 2, 3, 4, 1, 2, 3, 4 }; 1973 static const u32 ep_reg_addr[9] = { 0x00, 0xC0, 0x00, 0xC0, 0x00, 1974 0x00, 0xC0, 0x00, 0xC0 }; 1975 1976 /* basic endpoint init */ 1977 for (i = 0; i < dev->n_ep; i++) { 1978 struct net2280_ep *ep = &dev->ep[i]; 1979 1980 ep->ep.name = ep_name[i]; 1981 ep->dev = dev; 1982 ep->num = i; 1983 1984 if (i > 0 && i <= 4) 1985 ep->dma = &dev->dma[i - 1]; 1986 1987 if (dev->enhanced_mode) { 1988 ep->cfg = &dev->epregs[ne[i]]; 1989 ep->regs = (struct net2280_ep_regs __iomem *) 1990 (((void __iomem *)&dev->epregs[ne[i]]) + 1991 ep_reg_addr[i]); 1992 ep->fiforegs = &dev->fiforegs[i]; 1993 } else { 1994 ep->cfg = &dev->epregs[i]; 1995 ep->regs = &dev->epregs[i]; 1996 ep->fiforegs = &dev->fiforegs[i]; 1997 } 1998 1999 ep->fifo_size = (i != 0) ? 2048 : 512; 2000 2001 ep_reset_338x(dev->regs, ep); 2002 } 2003 usb_ep_set_maxpacket_limit(&dev->ep[0].ep, 512); 2004 2005 dev->gadget.ep0 = &dev->ep[0].ep; 2006 dev->ep[0].stopped = 0; 2007 2008 /* Link layer set up */ 2009 if (dev->bug7734_patched) { 2010 tmp = readl(&dev->usb_ext->usbctl2) & 2011 ~(BIT(U1_ENABLE) | BIT(U2_ENABLE) | BIT(LTM_ENABLE)); 2012 writel(tmp, &dev->usb_ext->usbctl2); 2013 } 2014 2015 /* Hardware Defect and Workaround */ 2016 val = readl(&dev->ll_lfps_regs->ll_lfps_5); 2017 val &= ~(0xf << TIMER_LFPS_6US); 2018 val |= 0x5 << TIMER_LFPS_6US; 2019 writel(val, &dev->ll_lfps_regs->ll_lfps_5); 2020 2021 val = readl(&dev->ll_lfps_regs->ll_lfps_6); 2022 val &= ~(0xffff << TIMER_LFPS_80US); 2023 val |= 0x0100 << TIMER_LFPS_80US; 2024 writel(val, &dev->ll_lfps_regs->ll_lfps_6); 2025 2026 /* 2027 * AA_AB Errata. Issue 4. Workaround for SuperSpeed USB 2028 * Hot Reset Exit Handshake may Fail in Specific Case using 2029 * Default Register Settings. Workaround for Enumeration test. 2030 */ 2031 val = readl(&dev->ll_tsn_regs->ll_tsn_counters_2); 2032 val &= ~(0x1f << HOT_TX_NORESET_TS2); 2033 val |= 0x10 << HOT_TX_NORESET_TS2; 2034 writel(val, &dev->ll_tsn_regs->ll_tsn_counters_2); 2035 2036 val = readl(&dev->ll_tsn_regs->ll_tsn_counters_3); 2037 val &= ~(0x1f << HOT_RX_RESET_TS2); 2038 val |= 0x3 << HOT_RX_RESET_TS2; 2039 writel(val, &dev->ll_tsn_regs->ll_tsn_counters_3); 2040 2041 /* 2042 * Set Recovery Idle to Recover bit: 2043 * - On SS connections, setting Recovery Idle to Recover Fmw improves 2044 * link robustness with various hosts and hubs. 2045 * - It is safe to set for all connection speeds; all chip revisions. 2046 * - R-M-W to leave other bits undisturbed. 2047 * - Reference PLX TT-7372 2048 */ 2049 val = readl(&dev->ll_chicken_reg->ll_tsn_chicken_bit); 2050 val |= BIT(RECOVERY_IDLE_TO_RECOVER_FMW); 2051 writel(val, &dev->ll_chicken_reg->ll_tsn_chicken_bit); 2052 2053 INIT_LIST_HEAD(&dev->gadget.ep0->ep_list); 2054 2055 /* disable dedicated endpoints */ 2056 writel(0x0D, &dev->dep[0].dep_cfg); 2057 writel(0x0D, &dev->dep[1].dep_cfg); 2058 writel(0x0E, &dev->dep[2].dep_cfg); 2059 writel(0x0E, &dev->dep[3].dep_cfg); 2060 writel(0x0F, &dev->dep[4].dep_cfg); 2061 writel(0x0C, &dev->dep[5].dep_cfg); 2062 } 2063 2064 static void usb_reinit(struct net2280 *dev) 2065 { 2066 if (dev->quirks & PLX_LEGACY) 2067 return usb_reinit_228x(dev); 2068 return usb_reinit_338x(dev); 2069 } 2070 2071 static void ep0_start_228x(struct net2280 *dev) 2072 { 2073 writel(BIT(CLEAR_EP_HIDE_STATUS_PHASE) | 2074 BIT(CLEAR_NAK_OUT_PACKETS) | 2075 BIT(CLEAR_CONTROL_STATUS_PHASE_HANDSHAKE), 2076 &dev->epregs[0].ep_rsp); 2077 2078 /* 2079 * hardware optionally handles a bunch of standard requests 2080 * that the API hides from drivers anyway. have it do so. 2081 * endpoint status/features are handled in software, to 2082 * help pass tests for some dubious behavior. 2083 */ 2084 writel(BIT(SET_TEST_MODE) | 2085 BIT(SET_ADDRESS) | 2086 BIT(DEVICE_SET_CLEAR_DEVICE_REMOTE_WAKEUP) | 2087 BIT(GET_DEVICE_STATUS) | 2088 BIT(GET_INTERFACE_STATUS), 2089 &dev->usb->stdrsp); 2090 writel(BIT(USB_ROOT_PORT_WAKEUP_ENABLE) | 2091 BIT(SELF_POWERED_USB_DEVICE) | 2092 BIT(REMOTE_WAKEUP_SUPPORT) | 2093 (dev->softconnect << USB_DETECT_ENABLE) | 2094 BIT(SELF_POWERED_STATUS), 2095 &dev->usb->usbctl); 2096 2097 /* enable irqs so we can see ep0 and general operation */ 2098 writel(BIT(SETUP_PACKET_INTERRUPT_ENABLE) | 2099 BIT(ENDPOINT_0_INTERRUPT_ENABLE), 2100 &dev->regs->pciirqenb0); 2101 writel(BIT(PCI_INTERRUPT_ENABLE) | 2102 BIT(PCI_MASTER_ABORT_RECEIVED_INTERRUPT_ENABLE) | 2103 BIT(PCI_TARGET_ABORT_RECEIVED_INTERRUPT_ENABLE) | 2104 BIT(PCI_RETRY_ABORT_INTERRUPT_ENABLE) | 2105 BIT(VBUS_INTERRUPT_ENABLE) | 2106 BIT(ROOT_PORT_RESET_INTERRUPT_ENABLE) | 2107 BIT(SUSPEND_REQUEST_CHANGE_INTERRUPT_ENABLE), 2108 &dev->regs->pciirqenb1); 2109 2110 /* don't leave any writes posted */ 2111 (void) readl(&dev->usb->usbctl); 2112 } 2113 2114 static void ep0_start_338x(struct net2280 *dev) 2115 { 2116 2117 if (dev->bug7734_patched) 2118 writel(BIT(CLEAR_NAK_OUT_PACKETS_MODE) | 2119 BIT(SET_EP_HIDE_STATUS_PHASE), 2120 &dev->epregs[0].ep_rsp); 2121 2122 /* 2123 * hardware optionally handles a bunch of standard requests 2124 * that the API hides from drivers anyway. have it do so. 2125 * endpoint status/features are handled in software, to 2126 * help pass tests for some dubious behavior. 2127 */ 2128 writel(BIT(SET_ISOCHRONOUS_DELAY) | 2129 BIT(SET_SEL) | 2130 BIT(SET_TEST_MODE) | 2131 BIT(SET_ADDRESS) | 2132 BIT(GET_INTERFACE_STATUS) | 2133 BIT(GET_DEVICE_STATUS), 2134 &dev->usb->stdrsp); 2135 dev->wakeup_enable = 1; 2136 writel(BIT(USB_ROOT_PORT_WAKEUP_ENABLE) | 2137 (dev->softconnect << USB_DETECT_ENABLE) | 2138 BIT(DEVICE_REMOTE_WAKEUP_ENABLE), 2139 &dev->usb->usbctl); 2140 2141 /* enable irqs so we can see ep0 and general operation */ 2142 writel(BIT(SETUP_PACKET_INTERRUPT_ENABLE) | 2143 BIT(ENDPOINT_0_INTERRUPT_ENABLE), 2144 &dev->regs->pciirqenb0); 2145 writel(BIT(PCI_INTERRUPT_ENABLE) | 2146 BIT(ROOT_PORT_RESET_INTERRUPT_ENABLE) | 2147 BIT(SUSPEND_REQUEST_CHANGE_INTERRUPT_ENABLE) | 2148 BIT(VBUS_INTERRUPT_ENABLE), 2149 &dev->regs->pciirqenb1); 2150 2151 /* don't leave any writes posted */ 2152 (void)readl(&dev->usb->usbctl); 2153 } 2154 2155 static void ep0_start(struct net2280 *dev) 2156 { 2157 if (dev->quirks & PLX_LEGACY) 2158 return ep0_start_228x(dev); 2159 return ep0_start_338x(dev); 2160 } 2161 2162 /* when a driver is successfully registered, it will receive 2163 * control requests including set_configuration(), which enables 2164 * non-control requests. then usb traffic follows until a 2165 * disconnect is reported. then a host may connect again, or 2166 * the driver might get unbound. 2167 */ 2168 static int net2280_start(struct usb_gadget *_gadget, 2169 struct usb_gadget_driver *driver) 2170 { 2171 struct net2280 *dev; 2172 int retval; 2173 unsigned i; 2174 2175 /* insist on high speed support from the driver, since 2176 * (dev->usb->xcvrdiag & FORCE_FULL_SPEED_MODE) 2177 * "must not be used in normal operation" 2178 */ 2179 if (!driver || driver->max_speed < USB_SPEED_HIGH || 2180 !driver->setup) 2181 return -EINVAL; 2182 2183 dev = container_of(_gadget, struct net2280, gadget); 2184 2185 for (i = 0; i < dev->n_ep; i++) 2186 dev->ep[i].irqs = 0; 2187 2188 /* hook up the driver ... */ 2189 dev->softconnect = 1; 2190 driver->driver.bus = NULL; 2191 dev->driver = driver; 2192 2193 retval = device_create_file(&dev->pdev->dev, &dev_attr_function); 2194 if (retval) 2195 goto err_unbind; 2196 retval = device_create_file(&dev->pdev->dev, &dev_attr_queues); 2197 if (retval) 2198 goto err_func; 2199 2200 /* enable host detection and ep0; and we're ready 2201 * for set_configuration as well as eventual disconnect. 2202 */ 2203 net2280_led_active(dev, 1); 2204 2205 if ((dev->quirks & PLX_SUPERSPEED) && !dev->bug7734_patched) 2206 defect7374_enable_data_eps_zero(dev); 2207 2208 ep0_start(dev); 2209 2210 /* pci writes may still be posted */ 2211 return 0; 2212 2213 err_func: 2214 device_remove_file(&dev->pdev->dev, &dev_attr_function); 2215 err_unbind: 2216 dev->driver = NULL; 2217 return retval; 2218 } 2219 2220 static void stop_activity(struct net2280 *dev, struct usb_gadget_driver *driver) 2221 { 2222 int i; 2223 2224 /* don't disconnect if it's not connected */ 2225 if (dev->gadget.speed == USB_SPEED_UNKNOWN) 2226 driver = NULL; 2227 2228 /* stop hardware; prevent new request submissions; 2229 * and kill any outstanding requests. 2230 */ 2231 usb_reset(dev); 2232 for (i = 0; i < dev->n_ep; i++) 2233 nuke(&dev->ep[i]); 2234 2235 /* report disconnect; the driver is already quiesced */ 2236 if (driver) { 2237 spin_unlock(&dev->lock); 2238 driver->disconnect(&dev->gadget); 2239 spin_lock(&dev->lock); 2240 } 2241 2242 usb_reinit(dev); 2243 } 2244 2245 static int net2280_stop(struct usb_gadget *_gadget) 2246 { 2247 struct net2280 *dev; 2248 unsigned long flags; 2249 2250 dev = container_of(_gadget, struct net2280, gadget); 2251 2252 spin_lock_irqsave(&dev->lock, flags); 2253 stop_activity(dev, NULL); 2254 spin_unlock_irqrestore(&dev->lock, flags); 2255 2256 net2280_led_active(dev, 0); 2257 2258 device_remove_file(&dev->pdev->dev, &dev_attr_function); 2259 device_remove_file(&dev->pdev->dev, &dev_attr_queues); 2260 2261 dev->driver = NULL; 2262 2263 return 0; 2264 } 2265 2266 /*-------------------------------------------------------------------------*/ 2267 2268 /* handle ep0, ep-e, ep-f with 64 byte packets: packet per irq. 2269 * also works for dma-capable endpoints, in pio mode or just 2270 * to manually advance the queue after short OUT transfers. 2271 */ 2272 static void handle_ep_small(struct net2280_ep *ep) 2273 { 2274 struct net2280_request *req; 2275 u32 t; 2276 /* 0 error, 1 mid-data, 2 done */ 2277 int mode = 1; 2278 2279 if (!list_empty(&ep->queue)) 2280 req = list_entry(ep->queue.next, 2281 struct net2280_request, queue); 2282 else 2283 req = NULL; 2284 2285 /* ack all, and handle what we care about */ 2286 t = readl(&ep->regs->ep_stat); 2287 ep->irqs++; 2288 2289 ep_vdbg(ep->dev, "%s ack ep_stat %08x, req %p\n", 2290 ep->ep.name, t, req ? &req->req : NULL); 2291 2292 if (!ep->is_in || (ep->dev->quirks & PLX_2280)) 2293 writel(t & ~BIT(NAK_OUT_PACKETS), &ep->regs->ep_stat); 2294 else 2295 /* Added for 2282 */ 2296 writel(t, &ep->regs->ep_stat); 2297 2298 /* for ep0, monitor token irqs to catch data stage length errors 2299 * and to synchronize on status. 2300 * 2301 * also, to defer reporting of protocol stalls ... here's where 2302 * data or status first appears, handling stalls here should never 2303 * cause trouble on the host side.. 2304 * 2305 * control requests could be slightly faster without token synch for 2306 * status, but status can jam up that way. 2307 */ 2308 if (unlikely(ep->num == 0)) { 2309 if (ep->is_in) { 2310 /* status; stop NAKing */ 2311 if (t & BIT(DATA_OUT_PING_TOKEN_INTERRUPT)) { 2312 if (ep->dev->protocol_stall) { 2313 ep->stopped = 1; 2314 set_halt(ep); 2315 } 2316 if (!req) 2317 allow_status(ep); 2318 mode = 2; 2319 /* reply to extra IN data tokens with a zlp */ 2320 } else if (t & BIT(DATA_IN_TOKEN_INTERRUPT)) { 2321 if (ep->dev->protocol_stall) { 2322 ep->stopped = 1; 2323 set_halt(ep); 2324 mode = 2; 2325 } else if (ep->responded && 2326 !req && !ep->stopped) 2327 write_fifo(ep, NULL); 2328 } 2329 } else { 2330 /* status; stop NAKing */ 2331 if (t & BIT(DATA_IN_TOKEN_INTERRUPT)) { 2332 if (ep->dev->protocol_stall) { 2333 ep->stopped = 1; 2334 set_halt(ep); 2335 } 2336 mode = 2; 2337 /* an extra OUT token is an error */ 2338 } else if (((t & BIT(DATA_OUT_PING_TOKEN_INTERRUPT)) && 2339 req && 2340 req->req.actual == req->req.length) || 2341 (ep->responded && !req)) { 2342 ep->dev->protocol_stall = 1; 2343 set_halt(ep); 2344 ep->stopped = 1; 2345 if (req) 2346 done(ep, req, -EOVERFLOW); 2347 req = NULL; 2348 } 2349 } 2350 } 2351 2352 if (unlikely(!req)) 2353 return; 2354 2355 /* manual DMA queue advance after short OUT */ 2356 if (likely(ep->dma)) { 2357 if (t & BIT(SHORT_PACKET_TRANSFERRED_INTERRUPT)) { 2358 u32 count; 2359 int stopped = ep->stopped; 2360 2361 /* TRANSFERRED works around OUT_DONE erratum 0112. 2362 * we expect (N <= maxpacket) bytes; host wrote M. 2363 * iff (M < N) we won't ever see a DMA interrupt. 2364 */ 2365 ep->stopped = 1; 2366 for (count = 0; ; t = readl(&ep->regs->ep_stat)) { 2367 2368 /* any preceding dma transfers must finish. 2369 * dma handles (M >= N), may empty the queue 2370 */ 2371 scan_dma_completions(ep); 2372 if (unlikely(list_empty(&ep->queue) || 2373 ep->out_overflow)) { 2374 req = NULL; 2375 break; 2376 } 2377 req = list_entry(ep->queue.next, 2378 struct net2280_request, queue); 2379 2380 /* here either (M < N), a "real" short rx; 2381 * or (M == N) and the queue didn't empty 2382 */ 2383 if (likely(t & BIT(FIFO_EMPTY))) { 2384 count = readl(&ep->dma->dmacount); 2385 count &= DMA_BYTE_COUNT_MASK; 2386 if (readl(&ep->dma->dmadesc) 2387 != req->td_dma) 2388 req = NULL; 2389 break; 2390 } 2391 udelay(1); 2392 } 2393 2394 /* stop DMA, leave ep NAKing */ 2395 writel(BIT(DMA_ABORT), &ep->dma->dmastat); 2396 spin_stop_dma(ep->dma); 2397 2398 if (likely(req)) { 2399 req->td->dmacount = 0; 2400 t = readl(&ep->regs->ep_avail); 2401 dma_done(ep, req, count, 2402 (ep->out_overflow || t) 2403 ? -EOVERFLOW : 0); 2404 } 2405 2406 /* also flush to prevent erratum 0106 trouble */ 2407 if (unlikely(ep->out_overflow || 2408 (ep->dev->chiprev == 0x0100 && 2409 ep->dev->gadget.speed 2410 == USB_SPEED_FULL))) { 2411 out_flush(ep); 2412 ep->out_overflow = 0; 2413 } 2414 2415 /* (re)start dma if needed, stop NAKing */ 2416 ep->stopped = stopped; 2417 if (!list_empty(&ep->queue)) 2418 restart_dma(ep); 2419 } else 2420 ep_dbg(ep->dev, "%s dma ep_stat %08x ??\n", 2421 ep->ep.name, t); 2422 return; 2423 2424 /* data packet(s) received (in the fifo, OUT) */ 2425 } else if (t & BIT(DATA_PACKET_RECEIVED_INTERRUPT)) { 2426 if (read_fifo(ep, req) && ep->num != 0) 2427 mode = 2; 2428 2429 /* data packet(s) transmitted (IN) */ 2430 } else if (t & BIT(DATA_PACKET_TRANSMITTED_INTERRUPT)) { 2431 unsigned len; 2432 2433 len = req->req.length - req->req.actual; 2434 if (len > ep->ep.maxpacket) 2435 len = ep->ep.maxpacket; 2436 req->req.actual += len; 2437 2438 /* if we wrote it all, we're usually done */ 2439 /* send zlps until the status stage */ 2440 if ((req->req.actual == req->req.length) && 2441 (!req->req.zero || len != ep->ep.maxpacket) && ep->num) 2442 mode = 2; 2443 2444 /* there was nothing to do ... */ 2445 } else if (mode == 1) 2446 return; 2447 2448 /* done */ 2449 if (mode == 2) { 2450 /* stream endpoints often resubmit/unlink in completion */ 2451 done(ep, req, 0); 2452 2453 /* maybe advance queue to next request */ 2454 if (ep->num == 0) { 2455 /* NOTE: net2280 could let gadget driver start the 2456 * status stage later. since not all controllers let 2457 * them control that, the api doesn't (yet) allow it. 2458 */ 2459 if (!ep->stopped) 2460 allow_status(ep); 2461 req = NULL; 2462 } else { 2463 if (!list_empty(&ep->queue) && !ep->stopped) 2464 req = list_entry(ep->queue.next, 2465 struct net2280_request, queue); 2466 else 2467 req = NULL; 2468 if (req && !ep->is_in) 2469 stop_out_naking(ep); 2470 } 2471 } 2472 2473 /* is there a buffer for the next packet? 2474 * for best streaming performance, make sure there is one. 2475 */ 2476 if (req && !ep->stopped) { 2477 2478 /* load IN fifo with next packet (may be zlp) */ 2479 if (t & BIT(DATA_PACKET_TRANSMITTED_INTERRUPT)) 2480 write_fifo(ep, &req->req); 2481 } 2482 } 2483 2484 static struct net2280_ep *get_ep_by_addr(struct net2280 *dev, u16 wIndex) 2485 { 2486 struct net2280_ep *ep; 2487 2488 if ((wIndex & USB_ENDPOINT_NUMBER_MASK) == 0) 2489 return &dev->ep[0]; 2490 list_for_each_entry(ep, &dev->gadget.ep_list, ep.ep_list) { 2491 u8 bEndpointAddress; 2492 2493 if (!ep->desc) 2494 continue; 2495 bEndpointAddress = ep->desc->bEndpointAddress; 2496 if ((wIndex ^ bEndpointAddress) & USB_DIR_IN) 2497 continue; 2498 if ((wIndex & 0x0f) == (bEndpointAddress & 0x0f)) 2499 return ep; 2500 } 2501 return NULL; 2502 } 2503 2504 static void defect7374_workaround(struct net2280 *dev, struct usb_ctrlrequest r) 2505 { 2506 u32 scratch, fsmvalue; 2507 u32 ack_wait_timeout, state; 2508 2509 /* Workaround for Defect 7374 (U1/U2 erroneously rejected): */ 2510 scratch = get_idx_reg(dev->regs, SCRATCH); 2511 fsmvalue = scratch & (0xf << DEFECT7374_FSM_FIELD); 2512 scratch &= ~(0xf << DEFECT7374_FSM_FIELD); 2513 2514 if (!((fsmvalue == DEFECT7374_FSM_WAITING_FOR_CONTROL_READ) && 2515 (r.bRequestType & USB_DIR_IN))) 2516 return; 2517 2518 /* This is the first Control Read for this connection: */ 2519 if (!(readl(&dev->usb->usbstat) & BIT(SUPER_SPEED_MODE))) { 2520 /* 2521 * Connection is NOT SS: 2522 * - Connection must be FS or HS. 2523 * - This FSM state should allow workaround software to 2524 * run after the next USB connection. 2525 */ 2526 scratch |= DEFECT7374_FSM_NON_SS_CONTROL_READ; 2527 dev->bug7734_patched = 1; 2528 goto restore_data_eps; 2529 } 2530 2531 /* Connection is SS: */ 2532 for (ack_wait_timeout = 0; 2533 ack_wait_timeout < DEFECT_7374_NUMBEROF_MAX_WAIT_LOOPS; 2534 ack_wait_timeout++) { 2535 2536 state = readl(&dev->plregs->pl_ep_status_1) 2537 & (0xff << STATE); 2538 if ((state >= (ACK_GOOD_NORMAL << STATE)) && 2539 (state <= (ACK_GOOD_MORE_ACKS_TO_COME << STATE))) { 2540 scratch |= DEFECT7374_FSM_SS_CONTROL_READ; 2541 dev->bug7734_patched = 1; 2542 break; 2543 } 2544 2545 /* 2546 * We have not yet received host's Data Phase ACK 2547 * - Wait and try again. 2548 */ 2549 udelay(DEFECT_7374_PROCESSOR_WAIT_TIME); 2550 2551 continue; 2552 } 2553 2554 2555 if (ack_wait_timeout >= DEFECT_7374_NUMBEROF_MAX_WAIT_LOOPS) { 2556 ep_err(dev, "FAIL: Defect 7374 workaround waited but failed " 2557 "to detect SS host's data phase ACK."); 2558 ep_err(dev, "PL_EP_STATUS_1(23:16):.Expected from 0x11 to 0x16" 2559 "got 0x%2.2x.\n", state >> STATE); 2560 } else { 2561 ep_warn(dev, "INFO: Defect 7374 workaround waited about\n" 2562 "%duSec for Control Read Data Phase ACK\n", 2563 DEFECT_7374_PROCESSOR_WAIT_TIME * ack_wait_timeout); 2564 } 2565 2566 restore_data_eps: 2567 /* 2568 * Restore data EPs to their pre-workaround settings (disabled, 2569 * initialized, and other details). 2570 */ 2571 defect7374_disable_data_eps(dev); 2572 2573 set_idx_reg(dev->regs, SCRATCH, scratch); 2574 2575 return; 2576 } 2577 2578 static void ep_clear_seqnum(struct net2280_ep *ep) 2579 { 2580 struct net2280 *dev = ep->dev; 2581 u32 val; 2582 static const u32 ep_pl[9] = { 0, 3, 4, 7, 8, 2, 5, 6, 9 }; 2583 2584 val = readl(&dev->plregs->pl_ep_ctrl) & ~0x1f; 2585 val |= ep_pl[ep->num]; 2586 writel(val, &dev->plregs->pl_ep_ctrl); 2587 val |= BIT(SEQUENCE_NUMBER_RESET); 2588 writel(val, &dev->plregs->pl_ep_ctrl); 2589 2590 return; 2591 } 2592 2593 static void handle_stat0_irqs_superspeed(struct net2280 *dev, 2594 struct net2280_ep *ep, struct usb_ctrlrequest r) 2595 { 2596 int tmp = 0; 2597 2598 #define w_value le16_to_cpu(r.wValue) 2599 #define w_index le16_to_cpu(r.wIndex) 2600 #define w_length le16_to_cpu(r.wLength) 2601 2602 switch (r.bRequest) { 2603 struct net2280_ep *e; 2604 u16 status; 2605 2606 case USB_REQ_SET_CONFIGURATION: 2607 dev->addressed_state = !w_value; 2608 goto usb3_delegate; 2609 2610 case USB_REQ_GET_STATUS: 2611 switch (r.bRequestType) { 2612 case (USB_DIR_IN | USB_TYPE_STANDARD | USB_RECIP_DEVICE): 2613 status = dev->wakeup_enable ? 0x02 : 0x00; 2614 if (dev->gadget.is_selfpowered) 2615 status |= BIT(0); 2616 status |= (dev->u1_enable << 2 | dev->u2_enable << 3 | 2617 dev->ltm_enable << 4); 2618 writel(0, &dev->epregs[0].ep_irqenb); 2619 set_fifo_bytecount(ep, sizeof(status)); 2620 writel((__force u32) status, &dev->epregs[0].ep_data); 2621 allow_status_338x(ep); 2622 break; 2623 2624 case (USB_DIR_IN | USB_TYPE_STANDARD | USB_RECIP_ENDPOINT): 2625 e = get_ep_by_addr(dev, w_index); 2626 if (!e) 2627 goto do_stall3; 2628 status = readl(&e->regs->ep_rsp) & 2629 BIT(CLEAR_ENDPOINT_HALT); 2630 writel(0, &dev->epregs[0].ep_irqenb); 2631 set_fifo_bytecount(ep, sizeof(status)); 2632 writel((__force u32) status, &dev->epregs[0].ep_data); 2633 allow_status_338x(ep); 2634 break; 2635 2636 default: 2637 goto usb3_delegate; 2638 } 2639 break; 2640 2641 case USB_REQ_CLEAR_FEATURE: 2642 switch (r.bRequestType) { 2643 case (USB_DIR_OUT | USB_TYPE_STANDARD | USB_RECIP_DEVICE): 2644 if (!dev->addressed_state) { 2645 switch (w_value) { 2646 case USB_DEVICE_U1_ENABLE: 2647 dev->u1_enable = 0; 2648 writel(readl(&dev->usb_ext->usbctl2) & 2649 ~BIT(U1_ENABLE), 2650 &dev->usb_ext->usbctl2); 2651 allow_status_338x(ep); 2652 goto next_endpoints3; 2653 2654 case USB_DEVICE_U2_ENABLE: 2655 dev->u2_enable = 0; 2656 writel(readl(&dev->usb_ext->usbctl2) & 2657 ~BIT(U2_ENABLE), 2658 &dev->usb_ext->usbctl2); 2659 allow_status_338x(ep); 2660 goto next_endpoints3; 2661 2662 case USB_DEVICE_LTM_ENABLE: 2663 dev->ltm_enable = 0; 2664 writel(readl(&dev->usb_ext->usbctl2) & 2665 ~BIT(LTM_ENABLE), 2666 &dev->usb_ext->usbctl2); 2667 allow_status_338x(ep); 2668 goto next_endpoints3; 2669 2670 default: 2671 break; 2672 } 2673 } 2674 if (w_value == USB_DEVICE_REMOTE_WAKEUP) { 2675 dev->wakeup_enable = 0; 2676 writel(readl(&dev->usb->usbctl) & 2677 ~BIT(DEVICE_REMOTE_WAKEUP_ENABLE), 2678 &dev->usb->usbctl); 2679 allow_status_338x(ep); 2680 break; 2681 } 2682 goto usb3_delegate; 2683 2684 case (USB_DIR_OUT | USB_TYPE_STANDARD | USB_RECIP_ENDPOINT): 2685 e = get_ep_by_addr(dev, w_index); 2686 if (!e) 2687 goto do_stall3; 2688 if (w_value != USB_ENDPOINT_HALT) 2689 goto do_stall3; 2690 ep_vdbg(dev, "%s clear halt\n", e->ep.name); 2691 /* 2692 * Workaround for SS SeqNum not cleared via 2693 * Endpoint Halt (Clear) bit. select endpoint 2694 */ 2695 ep_clear_seqnum(e); 2696 clear_halt(e); 2697 if (!list_empty(&e->queue) && e->td_dma) 2698 restart_dma(e); 2699 allow_status(ep); 2700 ep->stopped = 1; 2701 break; 2702 2703 default: 2704 goto usb3_delegate; 2705 } 2706 break; 2707 case USB_REQ_SET_FEATURE: 2708 switch (r.bRequestType) { 2709 case (USB_DIR_OUT | USB_TYPE_STANDARD | USB_RECIP_DEVICE): 2710 if (!dev->addressed_state) { 2711 switch (w_value) { 2712 case USB_DEVICE_U1_ENABLE: 2713 dev->u1_enable = 1; 2714 writel(readl(&dev->usb_ext->usbctl2) | 2715 BIT(U1_ENABLE), 2716 &dev->usb_ext->usbctl2); 2717 allow_status_338x(ep); 2718 goto next_endpoints3; 2719 2720 case USB_DEVICE_U2_ENABLE: 2721 dev->u2_enable = 1; 2722 writel(readl(&dev->usb_ext->usbctl2) | 2723 BIT(U2_ENABLE), 2724 &dev->usb_ext->usbctl2); 2725 allow_status_338x(ep); 2726 goto next_endpoints3; 2727 2728 case USB_DEVICE_LTM_ENABLE: 2729 dev->ltm_enable = 1; 2730 writel(readl(&dev->usb_ext->usbctl2) | 2731 BIT(LTM_ENABLE), 2732 &dev->usb_ext->usbctl2); 2733 allow_status_338x(ep); 2734 goto next_endpoints3; 2735 default: 2736 break; 2737 } 2738 } 2739 2740 if (w_value == USB_DEVICE_REMOTE_WAKEUP) { 2741 dev->wakeup_enable = 1; 2742 writel(readl(&dev->usb->usbctl) | 2743 BIT(DEVICE_REMOTE_WAKEUP_ENABLE), 2744 &dev->usb->usbctl); 2745 allow_status_338x(ep); 2746 break; 2747 } 2748 goto usb3_delegate; 2749 2750 case (USB_DIR_OUT | USB_TYPE_STANDARD | USB_RECIP_ENDPOINT): 2751 e = get_ep_by_addr(dev, w_index); 2752 if (!e || (w_value != USB_ENDPOINT_HALT)) 2753 goto do_stall3; 2754 ep->stopped = 1; 2755 if (ep->num == 0) 2756 ep->dev->protocol_stall = 1; 2757 else { 2758 if (ep->dma) 2759 abort_dma(ep); 2760 set_halt(ep); 2761 } 2762 allow_status_338x(ep); 2763 break; 2764 2765 default: 2766 goto usb3_delegate; 2767 } 2768 2769 break; 2770 default: 2771 2772 usb3_delegate: 2773 ep_vdbg(dev, "setup %02x.%02x v%04x i%04x l%04x ep_cfg %08x\n", 2774 r.bRequestType, r.bRequest, 2775 w_value, w_index, w_length, 2776 readl(&ep->cfg->ep_cfg)); 2777 2778 ep->responded = 0; 2779 spin_unlock(&dev->lock); 2780 tmp = dev->driver->setup(&dev->gadget, &r); 2781 spin_lock(&dev->lock); 2782 } 2783 do_stall3: 2784 if (tmp < 0) { 2785 ep_vdbg(dev, "req %02x.%02x protocol STALL; stat %d\n", 2786 r.bRequestType, r.bRequest, tmp); 2787 dev->protocol_stall = 1; 2788 /* TD 9.9 Halt Endpoint test. TD 9.22 Set feature test */ 2789 set_halt(ep); 2790 } 2791 2792 next_endpoints3: 2793 2794 #undef w_value 2795 #undef w_index 2796 #undef w_length 2797 2798 return; 2799 } 2800 2801 static void handle_stat0_irqs(struct net2280 *dev, u32 stat) 2802 { 2803 struct net2280_ep *ep; 2804 u32 num, scratch; 2805 2806 /* most of these don't need individual acks */ 2807 stat &= ~BIT(INTA_ASSERTED); 2808 if (!stat) 2809 return; 2810 /* ep_dbg(dev, "irqstat0 %04x\n", stat); */ 2811 2812 /* starting a control request? */ 2813 if (unlikely(stat & BIT(SETUP_PACKET_INTERRUPT))) { 2814 union { 2815 u32 raw[2]; 2816 struct usb_ctrlrequest r; 2817 } u; 2818 int tmp; 2819 struct net2280_request *req; 2820 2821 if (dev->gadget.speed == USB_SPEED_UNKNOWN) { 2822 u32 val = readl(&dev->usb->usbstat); 2823 if (val & BIT(SUPER_SPEED)) { 2824 dev->gadget.speed = USB_SPEED_SUPER; 2825 usb_ep_set_maxpacket_limit(&dev->ep[0].ep, 2826 EP0_SS_MAX_PACKET_SIZE); 2827 } else if (val & BIT(HIGH_SPEED)) { 2828 dev->gadget.speed = USB_SPEED_HIGH; 2829 usb_ep_set_maxpacket_limit(&dev->ep[0].ep, 2830 EP0_HS_MAX_PACKET_SIZE); 2831 } else { 2832 dev->gadget.speed = USB_SPEED_FULL; 2833 usb_ep_set_maxpacket_limit(&dev->ep[0].ep, 2834 EP0_HS_MAX_PACKET_SIZE); 2835 } 2836 net2280_led_speed(dev, dev->gadget.speed); 2837 ep_dbg(dev, "%s\n", 2838 usb_speed_string(dev->gadget.speed)); 2839 } 2840 2841 ep = &dev->ep[0]; 2842 ep->irqs++; 2843 2844 /* make sure any leftover request state is cleared */ 2845 stat &= ~BIT(ENDPOINT_0_INTERRUPT); 2846 while (!list_empty(&ep->queue)) { 2847 req = list_entry(ep->queue.next, 2848 struct net2280_request, queue); 2849 done(ep, req, (req->req.actual == req->req.length) 2850 ? 0 : -EPROTO); 2851 } 2852 ep->stopped = 0; 2853 dev->protocol_stall = 0; 2854 if (!(dev->quirks & PLX_SUPERSPEED)) { 2855 if (ep->dev->quirks & PLX_2280) 2856 tmp = BIT(FIFO_OVERFLOW) | 2857 BIT(FIFO_UNDERFLOW); 2858 else 2859 tmp = 0; 2860 2861 writel(tmp | BIT(TIMEOUT) | 2862 BIT(USB_STALL_SENT) | 2863 BIT(USB_IN_NAK_SENT) | 2864 BIT(USB_IN_ACK_RCVD) | 2865 BIT(USB_OUT_PING_NAK_SENT) | 2866 BIT(USB_OUT_ACK_SENT) | 2867 BIT(SHORT_PACKET_OUT_DONE_INTERRUPT) | 2868 BIT(SHORT_PACKET_TRANSFERRED_INTERRUPT) | 2869 BIT(DATA_PACKET_RECEIVED_INTERRUPT) | 2870 BIT(DATA_PACKET_TRANSMITTED_INTERRUPT) | 2871 BIT(DATA_OUT_PING_TOKEN_INTERRUPT) | 2872 BIT(DATA_IN_TOKEN_INTERRUPT), 2873 &ep->regs->ep_stat); 2874 } 2875 u.raw[0] = readl(&dev->usb->setup0123); 2876 u.raw[1] = readl(&dev->usb->setup4567); 2877 2878 cpu_to_le32s(&u.raw[0]); 2879 cpu_to_le32s(&u.raw[1]); 2880 2881 if ((dev->quirks & PLX_SUPERSPEED) && !dev->bug7734_patched) 2882 defect7374_workaround(dev, u.r); 2883 2884 tmp = 0; 2885 2886 #define w_value le16_to_cpu(u.r.wValue) 2887 #define w_index le16_to_cpu(u.r.wIndex) 2888 #define w_length le16_to_cpu(u.r.wLength) 2889 2890 /* ack the irq */ 2891 writel(BIT(SETUP_PACKET_INTERRUPT), &dev->regs->irqstat0); 2892 stat ^= BIT(SETUP_PACKET_INTERRUPT); 2893 2894 /* watch control traffic at the token level, and force 2895 * synchronization before letting the status stage happen. 2896 * FIXME ignore tokens we'll NAK, until driver responds. 2897 * that'll mean a lot less irqs for some drivers. 2898 */ 2899 ep->is_in = (u.r.bRequestType & USB_DIR_IN) != 0; 2900 if (ep->is_in) { 2901 scratch = BIT(DATA_PACKET_TRANSMITTED_INTERRUPT) | 2902 BIT(DATA_OUT_PING_TOKEN_INTERRUPT) | 2903 BIT(DATA_IN_TOKEN_INTERRUPT); 2904 stop_out_naking(ep); 2905 } else 2906 scratch = BIT(DATA_PACKET_RECEIVED_INTERRUPT) | 2907 BIT(DATA_OUT_PING_TOKEN_INTERRUPT) | 2908 BIT(DATA_IN_TOKEN_INTERRUPT); 2909 writel(scratch, &dev->epregs[0].ep_irqenb); 2910 2911 /* we made the hardware handle most lowlevel requests; 2912 * everything else goes uplevel to the gadget code. 2913 */ 2914 ep->responded = 1; 2915 2916 if (dev->gadget.speed == USB_SPEED_SUPER) { 2917 handle_stat0_irqs_superspeed(dev, ep, u.r); 2918 goto next_endpoints; 2919 } 2920 2921 switch (u.r.bRequest) { 2922 case USB_REQ_GET_STATUS: { 2923 struct net2280_ep *e; 2924 __le32 status; 2925 2926 /* hw handles device and interface status */ 2927 if (u.r.bRequestType != (USB_DIR_IN|USB_RECIP_ENDPOINT)) 2928 goto delegate; 2929 e = get_ep_by_addr(dev, w_index); 2930 if (!e || w_length > 2) 2931 goto do_stall; 2932 2933 if (readl(&e->regs->ep_rsp) & BIT(SET_ENDPOINT_HALT)) 2934 status = cpu_to_le32(1); 2935 else 2936 status = cpu_to_le32(0); 2937 2938 /* don't bother with a request object! */ 2939 writel(0, &dev->epregs[0].ep_irqenb); 2940 set_fifo_bytecount(ep, w_length); 2941 writel((__force u32)status, &dev->epregs[0].ep_data); 2942 allow_status(ep); 2943 ep_vdbg(dev, "%s stat %02x\n", ep->ep.name, status); 2944 goto next_endpoints; 2945 } 2946 break; 2947 case USB_REQ_CLEAR_FEATURE: { 2948 struct net2280_ep *e; 2949 2950 /* hw handles device features */ 2951 if (u.r.bRequestType != USB_RECIP_ENDPOINT) 2952 goto delegate; 2953 if (w_value != USB_ENDPOINT_HALT || w_length != 0) 2954 goto do_stall; 2955 e = get_ep_by_addr(dev, w_index); 2956 if (!e) 2957 goto do_stall; 2958 if (e->wedged) { 2959 ep_vdbg(dev, "%s wedged, halt not cleared\n", 2960 ep->ep.name); 2961 } else { 2962 ep_vdbg(dev, "%s clear halt\n", e->ep.name); 2963 clear_halt(e); 2964 if ((ep->dev->quirks & PLX_SUPERSPEED) && 2965 !list_empty(&e->queue) && e->td_dma) 2966 restart_dma(e); 2967 } 2968 allow_status(ep); 2969 goto next_endpoints; 2970 } 2971 break; 2972 case USB_REQ_SET_FEATURE: { 2973 struct net2280_ep *e; 2974 2975 /* hw handles device features */ 2976 if (u.r.bRequestType != USB_RECIP_ENDPOINT) 2977 goto delegate; 2978 if (w_value != USB_ENDPOINT_HALT || w_length != 0) 2979 goto do_stall; 2980 e = get_ep_by_addr(dev, w_index); 2981 if (!e) 2982 goto do_stall; 2983 if (e->ep.name == ep0name) 2984 goto do_stall; 2985 set_halt(e); 2986 if ((dev->quirks & PLX_SUPERSPEED) && e->dma) 2987 abort_dma(e); 2988 allow_status(ep); 2989 ep_vdbg(dev, "%s set halt\n", ep->ep.name); 2990 goto next_endpoints; 2991 } 2992 break; 2993 default: 2994 delegate: 2995 ep_vdbg(dev, "setup %02x.%02x v%04x i%04x l%04x " 2996 "ep_cfg %08x\n", 2997 u.r.bRequestType, u.r.bRequest, 2998 w_value, w_index, w_length, 2999 readl(&ep->cfg->ep_cfg)); 3000 ep->responded = 0; 3001 spin_unlock(&dev->lock); 3002 tmp = dev->driver->setup(&dev->gadget, &u.r); 3003 spin_lock(&dev->lock); 3004 } 3005 3006 /* stall ep0 on error */ 3007 if (tmp < 0) { 3008 do_stall: 3009 ep_vdbg(dev, "req %02x.%02x protocol STALL; stat %d\n", 3010 u.r.bRequestType, u.r.bRequest, tmp); 3011 dev->protocol_stall = 1; 3012 } 3013 3014 /* some in/out token irq should follow; maybe stall then. 3015 * driver must queue a request (even zlp) or halt ep0 3016 * before the host times out. 3017 */ 3018 } 3019 3020 #undef w_value 3021 #undef w_index 3022 #undef w_length 3023 3024 next_endpoints: 3025 /* endpoint data irq ? */ 3026 scratch = stat & 0x7f; 3027 stat &= ~0x7f; 3028 for (num = 0; scratch; num++) { 3029 u32 t; 3030 3031 /* do this endpoint's FIFO and queue need tending? */ 3032 t = BIT(num); 3033 if ((scratch & t) == 0) 3034 continue; 3035 scratch ^= t; 3036 3037 ep = &dev->ep[num]; 3038 handle_ep_small(ep); 3039 } 3040 3041 if (stat) 3042 ep_dbg(dev, "unhandled irqstat0 %08x\n", stat); 3043 } 3044 3045 #define DMA_INTERRUPTS (BIT(DMA_D_INTERRUPT) | \ 3046 BIT(DMA_C_INTERRUPT) | \ 3047 BIT(DMA_B_INTERRUPT) | \ 3048 BIT(DMA_A_INTERRUPT)) 3049 #define PCI_ERROR_INTERRUPTS ( \ 3050 BIT(PCI_MASTER_ABORT_RECEIVED_INTERRUPT) | \ 3051 BIT(PCI_TARGET_ABORT_RECEIVED_INTERRUPT) | \ 3052 BIT(PCI_RETRY_ABORT_INTERRUPT)) 3053 3054 static void handle_stat1_irqs(struct net2280 *dev, u32 stat) 3055 { 3056 struct net2280_ep *ep; 3057 u32 tmp, num, mask, scratch; 3058 3059 /* after disconnect there's nothing else to do! */ 3060 tmp = BIT(VBUS_INTERRUPT) | BIT(ROOT_PORT_RESET_INTERRUPT); 3061 mask = BIT(SUPER_SPEED) | BIT(HIGH_SPEED) | BIT(FULL_SPEED); 3062 3063 /* VBUS disconnect is indicated by VBUS_PIN and VBUS_INTERRUPT set. 3064 * Root Port Reset is indicated by ROOT_PORT_RESET_INTERRUPT set and 3065 * both HIGH_SPEED and FULL_SPEED clear (as ROOT_PORT_RESET_INTERRUPT 3066 * only indicates a change in the reset state). 3067 */ 3068 if (stat & tmp) { 3069 bool reset = false; 3070 bool disconnect = false; 3071 3072 /* 3073 * Ignore disconnects and resets if the speed hasn't been set. 3074 * VBUS can bounce and there's always an initial reset. 3075 */ 3076 writel(tmp, &dev->regs->irqstat1); 3077 if (dev->gadget.speed != USB_SPEED_UNKNOWN) { 3078 if ((stat & BIT(VBUS_INTERRUPT)) && 3079 (readl(&dev->usb->usbctl) & 3080 BIT(VBUS_PIN)) == 0) { 3081 disconnect = true; 3082 ep_dbg(dev, "disconnect %s\n", 3083 dev->driver->driver.name); 3084 } else if ((stat & BIT(ROOT_PORT_RESET_INTERRUPT)) && 3085 (readl(&dev->usb->usbstat) & mask) 3086 == 0) { 3087 reset = true; 3088 ep_dbg(dev, "reset %s\n", 3089 dev->driver->driver.name); 3090 } 3091 3092 if (disconnect || reset) { 3093 stop_activity(dev, dev->driver); 3094 ep0_start(dev); 3095 spin_unlock(&dev->lock); 3096 if (reset) 3097 usb_gadget_udc_reset 3098 (&dev->gadget, dev->driver); 3099 else 3100 (dev->driver->disconnect) 3101 (&dev->gadget); 3102 spin_lock(&dev->lock); 3103 return; 3104 } 3105 } 3106 stat &= ~tmp; 3107 3108 /* vBUS can bounce ... one of many reasons to ignore the 3109 * notion of hotplug events on bus connect/disconnect! 3110 */ 3111 if (!stat) 3112 return; 3113 } 3114 3115 /* NOTE: chip stays in PCI D0 state for now, but it could 3116 * enter D1 to save more power 3117 */ 3118 tmp = BIT(SUSPEND_REQUEST_CHANGE_INTERRUPT); 3119 if (stat & tmp) { 3120 writel(tmp, &dev->regs->irqstat1); 3121 if (stat & BIT(SUSPEND_REQUEST_INTERRUPT)) { 3122 if (dev->driver->suspend) 3123 dev->driver->suspend(&dev->gadget); 3124 if (!enable_suspend) 3125 stat &= ~BIT(SUSPEND_REQUEST_INTERRUPT); 3126 } else { 3127 if (dev->driver->resume) 3128 dev->driver->resume(&dev->gadget); 3129 /* at high speed, note erratum 0133 */ 3130 } 3131 stat &= ~tmp; 3132 } 3133 3134 /* clear any other status/irqs */ 3135 if (stat) 3136 writel(stat, &dev->regs->irqstat1); 3137 3138 /* some status we can just ignore */ 3139 if (dev->quirks & PLX_2280) 3140 stat &= ~(BIT(CONTROL_STATUS_INTERRUPT) | 3141 BIT(SUSPEND_REQUEST_INTERRUPT) | 3142 BIT(RESUME_INTERRUPT) | 3143 BIT(SOF_INTERRUPT)); 3144 else 3145 stat &= ~(BIT(CONTROL_STATUS_INTERRUPT) | 3146 BIT(RESUME_INTERRUPT) | 3147 BIT(SOF_DOWN_INTERRUPT) | 3148 BIT(SOF_INTERRUPT)); 3149 3150 if (!stat) 3151 return; 3152 /* ep_dbg(dev, "irqstat1 %08x\n", stat);*/ 3153 3154 /* DMA status, for ep-{a,b,c,d} */ 3155 scratch = stat & DMA_INTERRUPTS; 3156 stat &= ~DMA_INTERRUPTS; 3157 scratch >>= 9; 3158 for (num = 0; scratch; num++) { 3159 struct net2280_dma_regs __iomem *dma; 3160 3161 tmp = BIT(num); 3162 if ((tmp & scratch) == 0) 3163 continue; 3164 scratch ^= tmp; 3165 3166 ep = &dev->ep[num + 1]; 3167 dma = ep->dma; 3168 3169 if (!dma) 3170 continue; 3171 3172 /* clear ep's dma status */ 3173 tmp = readl(&dma->dmastat); 3174 writel(tmp, &dma->dmastat); 3175 3176 /* dma sync*/ 3177 if (dev->quirks & PLX_SUPERSPEED) { 3178 u32 r_dmacount = readl(&dma->dmacount); 3179 if (!ep->is_in && (r_dmacount & 0x00FFFFFF) && 3180 (tmp & BIT(DMA_TRANSACTION_DONE_INTERRUPT))) 3181 continue; 3182 } 3183 3184 if (!(tmp & BIT(DMA_TRANSACTION_DONE_INTERRUPT))) { 3185 ep_dbg(ep->dev, "%s no xact done? %08x\n", 3186 ep->ep.name, tmp); 3187 continue; 3188 } 3189 stop_dma(ep->dma); 3190 3191 /* OUT transfers terminate when the data from the 3192 * host is in our memory. Process whatever's done. 3193 * On this path, we know transfer's last packet wasn't 3194 * less than req->length. NAK_OUT_PACKETS may be set, 3195 * or the FIFO may already be holding new packets. 3196 * 3197 * IN transfers can linger in the FIFO for a very 3198 * long time ... we ignore that for now, accounting 3199 * precisely (like PIO does) needs per-packet irqs 3200 */ 3201 scan_dma_completions(ep); 3202 3203 /* disable dma on inactive queues; else maybe restart */ 3204 if (!list_empty(&ep->queue)) { 3205 tmp = readl(&dma->dmactl); 3206 restart_dma(ep); 3207 } 3208 ep->irqs++; 3209 } 3210 3211 /* NOTE: there are other PCI errors we might usefully notice. 3212 * if they appear very often, here's where to try recovering. 3213 */ 3214 if (stat & PCI_ERROR_INTERRUPTS) { 3215 ep_err(dev, "pci dma error; stat %08x\n", stat); 3216 stat &= ~PCI_ERROR_INTERRUPTS; 3217 /* these are fatal errors, but "maybe" they won't 3218 * happen again ... 3219 */ 3220 stop_activity(dev, dev->driver); 3221 ep0_start(dev); 3222 stat = 0; 3223 } 3224 3225 if (stat) 3226 ep_dbg(dev, "unhandled irqstat1 %08x\n", stat); 3227 } 3228 3229 static irqreturn_t net2280_irq(int irq, void *_dev) 3230 { 3231 struct net2280 *dev = _dev; 3232 3233 /* shared interrupt, not ours */ 3234 if ((dev->quirks & PLX_LEGACY) && 3235 (!(readl(&dev->regs->irqstat0) & BIT(INTA_ASSERTED)))) 3236 return IRQ_NONE; 3237 3238 spin_lock(&dev->lock); 3239 3240 /* handle disconnect, dma, and more */ 3241 handle_stat1_irqs(dev, readl(&dev->regs->irqstat1)); 3242 3243 /* control requests and PIO */ 3244 handle_stat0_irqs(dev, readl(&dev->regs->irqstat0)); 3245 3246 if (dev->quirks & PLX_SUPERSPEED) { 3247 /* re-enable interrupt to trigger any possible new interrupt */ 3248 u32 pciirqenb1 = readl(&dev->regs->pciirqenb1); 3249 writel(pciirqenb1 & 0x7FFFFFFF, &dev->regs->pciirqenb1); 3250 writel(pciirqenb1, &dev->regs->pciirqenb1); 3251 } 3252 3253 spin_unlock(&dev->lock); 3254 3255 return IRQ_HANDLED; 3256 } 3257 3258 /*-------------------------------------------------------------------------*/ 3259 3260 static void gadget_release(struct device *_dev) 3261 { 3262 struct net2280 *dev = dev_get_drvdata(_dev); 3263 3264 kfree(dev); 3265 } 3266 3267 /* tear down the binding between this driver and the pci device */ 3268 3269 static void net2280_remove(struct pci_dev *pdev) 3270 { 3271 struct net2280 *dev = pci_get_drvdata(pdev); 3272 3273 usb_del_gadget_udc(&dev->gadget); 3274 3275 BUG_ON(dev->driver); 3276 3277 /* then clean up the resources we allocated during probe() */ 3278 net2280_led_shutdown(dev); 3279 if (dev->requests) { 3280 int i; 3281 for (i = 1; i < 5; i++) { 3282 if (!dev->ep[i].dummy) 3283 continue; 3284 pci_pool_free(dev->requests, dev->ep[i].dummy, 3285 dev->ep[i].td_dma); 3286 } 3287 pci_pool_destroy(dev->requests); 3288 } 3289 if (dev->got_irq) 3290 free_irq(pdev->irq, dev); 3291 if (dev->quirks & PLX_SUPERSPEED) 3292 pci_disable_msi(pdev); 3293 if (dev->regs) 3294 iounmap(dev->regs); 3295 if (dev->region) 3296 release_mem_region(pci_resource_start(pdev, 0), 3297 pci_resource_len(pdev, 0)); 3298 if (dev->enabled) 3299 pci_disable_device(pdev); 3300 device_remove_file(&pdev->dev, &dev_attr_registers); 3301 3302 ep_info(dev, "unbind\n"); 3303 } 3304 3305 /* wrap this driver around the specified device, but 3306 * don't respond over USB until a gadget driver binds to us. 3307 */ 3308 3309 static int net2280_probe(struct pci_dev *pdev, const struct pci_device_id *id) 3310 { 3311 struct net2280 *dev; 3312 unsigned long resource, len; 3313 void __iomem *base = NULL; 3314 int retval, i; 3315 3316 /* alloc, and start init */ 3317 dev = kzalloc(sizeof(*dev), GFP_KERNEL); 3318 if (dev == NULL) { 3319 retval = -ENOMEM; 3320 goto done; 3321 } 3322 3323 pci_set_drvdata(pdev, dev); 3324 spin_lock_init(&dev->lock); 3325 dev->quirks = id->driver_data; 3326 dev->pdev = pdev; 3327 dev->gadget.ops = &net2280_ops; 3328 dev->gadget.max_speed = (dev->quirks & PLX_SUPERSPEED) ? 3329 USB_SPEED_SUPER : USB_SPEED_HIGH; 3330 3331 /* the "gadget" abstracts/virtualizes the controller */ 3332 dev->gadget.name = driver_name; 3333 3334 /* now all the pci goodies ... */ 3335 if (pci_enable_device(pdev) < 0) { 3336 retval = -ENODEV; 3337 goto done; 3338 } 3339 dev->enabled = 1; 3340 3341 /* BAR 0 holds all the registers 3342 * BAR 1 is 8051 memory; unused here (note erratum 0103) 3343 * BAR 2 is fifo memory; unused here 3344 */ 3345 resource = pci_resource_start(pdev, 0); 3346 len = pci_resource_len(pdev, 0); 3347 if (!request_mem_region(resource, len, driver_name)) { 3348 ep_dbg(dev, "controller already in use\n"); 3349 retval = -EBUSY; 3350 goto done; 3351 } 3352 dev->region = 1; 3353 3354 /* FIXME provide firmware download interface to put 3355 * 8051 code into the chip, e.g. to turn on PCI PM. 3356 */ 3357 3358 base = ioremap_nocache(resource, len); 3359 if (base == NULL) { 3360 ep_dbg(dev, "can't map memory\n"); 3361 retval = -EFAULT; 3362 goto done; 3363 } 3364 dev->regs = (struct net2280_regs __iomem *) base; 3365 dev->usb = (struct net2280_usb_regs __iomem *) (base + 0x0080); 3366 dev->pci = (struct net2280_pci_regs __iomem *) (base + 0x0100); 3367 dev->dma = (struct net2280_dma_regs __iomem *) (base + 0x0180); 3368 dev->dep = (struct net2280_dep_regs __iomem *) (base + 0x0200); 3369 dev->epregs = (struct net2280_ep_regs __iomem *) (base + 0x0300); 3370 3371 if (dev->quirks & PLX_SUPERSPEED) { 3372 u32 fsmvalue; 3373 u32 usbstat; 3374 dev->usb_ext = (struct usb338x_usb_ext_regs __iomem *) 3375 (base + 0x00b4); 3376 dev->fiforegs = (struct usb338x_fifo_regs __iomem *) 3377 (base + 0x0500); 3378 dev->llregs = (struct usb338x_ll_regs __iomem *) 3379 (base + 0x0700); 3380 dev->ll_lfps_regs = (struct usb338x_ll_lfps_regs __iomem *) 3381 (base + 0x0748); 3382 dev->ll_tsn_regs = (struct usb338x_ll_tsn_regs __iomem *) 3383 (base + 0x077c); 3384 dev->ll_chicken_reg = (struct usb338x_ll_chi_regs __iomem *) 3385 (base + 0x079c); 3386 dev->plregs = (struct usb338x_pl_regs __iomem *) 3387 (base + 0x0800); 3388 usbstat = readl(&dev->usb->usbstat); 3389 dev->enhanced_mode = !!(usbstat & BIT(11)); 3390 dev->n_ep = (dev->enhanced_mode) ? 9 : 5; 3391 /* put into initial config, link up all endpoints */ 3392 fsmvalue = get_idx_reg(dev->regs, SCRATCH) & 3393 (0xf << DEFECT7374_FSM_FIELD); 3394 /* See if firmware needs to set up for workaround: */ 3395 if (fsmvalue == DEFECT7374_FSM_SS_CONTROL_READ) { 3396 dev->bug7734_patched = 1; 3397 writel(0, &dev->usb->usbctl); 3398 } else 3399 dev->bug7734_patched = 0; 3400 } else { 3401 dev->enhanced_mode = 0; 3402 dev->n_ep = 7; 3403 /* put into initial config, link up all endpoints */ 3404 writel(0, &dev->usb->usbctl); 3405 } 3406 3407 usb_reset(dev); 3408 usb_reinit(dev); 3409 3410 /* irq setup after old hardware is cleaned up */ 3411 if (!pdev->irq) { 3412 ep_err(dev, "No IRQ. Check PCI setup!\n"); 3413 retval = -ENODEV; 3414 goto done; 3415 } 3416 3417 if (dev->quirks & PLX_SUPERSPEED) 3418 if (pci_enable_msi(pdev)) 3419 ep_err(dev, "Failed to enable MSI mode\n"); 3420 3421 if (request_irq(pdev->irq, net2280_irq, IRQF_SHARED, 3422 driver_name, dev)) { 3423 ep_err(dev, "request interrupt %d failed\n", pdev->irq); 3424 retval = -EBUSY; 3425 goto done; 3426 } 3427 dev->got_irq = 1; 3428 3429 /* DMA setup */ 3430 /* NOTE: we know only the 32 LSBs of dma addresses may be nonzero */ 3431 dev->requests = pci_pool_create("requests", pdev, 3432 sizeof(struct net2280_dma), 3433 0 /* no alignment requirements */, 3434 0 /* or page-crossing issues */); 3435 if (!dev->requests) { 3436 ep_dbg(dev, "can't get request pool\n"); 3437 retval = -ENOMEM; 3438 goto done; 3439 } 3440 for (i = 1; i < 5; i++) { 3441 struct net2280_dma *td; 3442 3443 td = pci_pool_alloc(dev->requests, GFP_KERNEL, 3444 &dev->ep[i].td_dma); 3445 if (!td) { 3446 ep_dbg(dev, "can't get dummy %d\n", i); 3447 retval = -ENOMEM; 3448 goto done; 3449 } 3450 td->dmacount = 0; /* not VALID */ 3451 td->dmadesc = td->dmaaddr; 3452 dev->ep[i].dummy = td; 3453 } 3454 3455 /* enable lower-overhead pci memory bursts during DMA */ 3456 if (dev->quirks & PLX_LEGACY) 3457 writel(BIT(DMA_MEMORY_WRITE_AND_INVALIDATE_ENABLE) | 3458 /* 3459 * 256 write retries may not be enough... 3460 BIT(PCI_RETRY_ABORT_ENABLE) | 3461 */ 3462 BIT(DMA_READ_MULTIPLE_ENABLE) | 3463 BIT(DMA_READ_LINE_ENABLE), 3464 &dev->pci->pcimstctl); 3465 /* erratum 0115 shouldn't appear: Linux inits PCI_LATENCY_TIMER */ 3466 pci_set_master(pdev); 3467 pci_try_set_mwi(pdev); 3468 3469 /* ... also flushes any posted pci writes */ 3470 dev->chiprev = get_idx_reg(dev->regs, REG_CHIPREV) & 0xffff; 3471 3472 /* done */ 3473 ep_info(dev, "%s\n", driver_desc); 3474 ep_info(dev, "irq %d, pci mem %p, chip rev %04x\n", 3475 pdev->irq, base, dev->chiprev); 3476 ep_info(dev, "version: " DRIVER_VERSION "; %s\n", 3477 dev->enhanced_mode ? "enhanced mode" : "legacy mode"); 3478 retval = device_create_file(&pdev->dev, &dev_attr_registers); 3479 if (retval) 3480 goto done; 3481 3482 retval = usb_add_gadget_udc_release(&pdev->dev, &dev->gadget, 3483 gadget_release); 3484 if (retval) 3485 goto done; 3486 return 0; 3487 3488 done: 3489 if (dev) 3490 net2280_remove(pdev); 3491 return retval; 3492 } 3493 3494 /* make sure the board is quiescent; otherwise it will continue 3495 * generating IRQs across the upcoming reboot. 3496 */ 3497 3498 static void net2280_shutdown(struct pci_dev *pdev) 3499 { 3500 struct net2280 *dev = pci_get_drvdata(pdev); 3501 3502 /* disable IRQs */ 3503 writel(0, &dev->regs->pciirqenb0); 3504 writel(0, &dev->regs->pciirqenb1); 3505 3506 /* disable the pullup so the host will think we're gone */ 3507 writel(0, &dev->usb->usbctl); 3508 3509 } 3510 3511 3512 /*-------------------------------------------------------------------------*/ 3513 3514 static const struct pci_device_id pci_ids[] = { { 3515 .class = ((PCI_CLASS_SERIAL_USB << 8) | 0xfe), 3516 .class_mask = ~0, 3517 .vendor = PCI_VENDOR_ID_PLX_LEGACY, 3518 .device = 0x2280, 3519 .subvendor = PCI_ANY_ID, 3520 .subdevice = PCI_ANY_ID, 3521 .driver_data = PLX_LEGACY | PLX_2280, 3522 }, { 3523 .class = ((PCI_CLASS_SERIAL_USB << 8) | 0xfe), 3524 .class_mask = ~0, 3525 .vendor = PCI_VENDOR_ID_PLX_LEGACY, 3526 .device = 0x2282, 3527 .subvendor = PCI_ANY_ID, 3528 .subdevice = PCI_ANY_ID, 3529 .driver_data = PLX_LEGACY, 3530 }, 3531 { 3532 .class = ((PCI_CLASS_SERIAL_USB << 8) | 0xfe), 3533 .class_mask = ~0, 3534 .vendor = PCI_VENDOR_ID_PLX, 3535 .device = 0x3380, 3536 .subvendor = PCI_ANY_ID, 3537 .subdevice = PCI_ANY_ID, 3538 .driver_data = PLX_SUPERSPEED, 3539 }, 3540 { 3541 .class = ((PCI_CLASS_SERIAL_USB << 8) | 0xfe), 3542 .class_mask = ~0, 3543 .vendor = PCI_VENDOR_ID_PLX, 3544 .device = 0x3382, 3545 .subvendor = PCI_ANY_ID, 3546 .subdevice = PCI_ANY_ID, 3547 .driver_data = PLX_SUPERSPEED, 3548 }, 3549 { /* end: all zeroes */ } 3550 }; 3551 MODULE_DEVICE_TABLE(pci, pci_ids); 3552 3553 /* pci driver glue; this is a "new style" PCI driver module */ 3554 static struct pci_driver net2280_pci_driver = { 3555 .name = (char *) driver_name, 3556 .id_table = pci_ids, 3557 3558 .probe = net2280_probe, 3559 .remove = net2280_remove, 3560 .shutdown = net2280_shutdown, 3561 3562 /* FIXME add power management support */ 3563 }; 3564 3565 module_pci_driver(net2280_pci_driver); 3566 3567 MODULE_DESCRIPTION(DRIVER_DESC); 3568 MODULE_AUTHOR("David Brownell"); 3569 MODULE_LICENSE("GPL"); 3570