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