1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * Driver for PLX NET2272 USB device controller 4 * 5 * Copyright (C) 2005-2006 PLX Technology, Inc. 6 * Copyright (C) 2006-2011 Analog Devices, Inc. 7 */ 8 9 #include <linux/delay.h> 10 #include <linux/device.h> 11 #include <linux/errno.h> 12 #include <linux/init.h> 13 #include <linux/interrupt.h> 14 #include <linux/io.h> 15 #include <linux/ioport.h> 16 #include <linux/kernel.h> 17 #include <linux/list.h> 18 #include <linux/module.h> 19 #include <linux/moduleparam.h> 20 #include <linux/pci.h> 21 #include <linux/platform_device.h> 22 #include <linux/prefetch.h> 23 #include <linux/sched.h> 24 #include <linux/slab.h> 25 #include <linux/timer.h> 26 #include <linux/usb.h> 27 #include <linux/usb/ch9.h> 28 #include <linux/usb/gadget.h> 29 30 #include <asm/byteorder.h> 31 #include <asm/unaligned.h> 32 33 #include "net2272.h" 34 35 #define DRIVER_DESC "PLX NET2272 USB Peripheral Controller" 36 37 static const char driver_name[] = "net2272"; 38 static const char driver_vers[] = "2006 October 17/mainline"; 39 static const char driver_desc[] = DRIVER_DESC; 40 41 static const char ep0name[] = "ep0"; 42 static const char * const ep_name[] = { 43 ep0name, 44 "ep-a", "ep-b", "ep-c", 45 }; 46 47 #ifdef CONFIG_USB_NET2272_DMA 48 /* 49 * use_dma: the NET2272 can use an external DMA controller. 50 * Note that since there is no generic DMA api, some functions, 51 * notably request_dma, start_dma, and cancel_dma will need to be 52 * modified for your platform's particular dma controller. 53 * 54 * If use_dma is disabled, pio will be used instead. 55 */ 56 static bool use_dma = false; 57 module_param(use_dma, bool, 0644); 58 59 /* 60 * dma_ep: selects the endpoint for use with dma (1=ep-a, 2=ep-b) 61 * The NET2272 can only use dma for a single endpoint at a time. 62 * At some point this could be modified to allow either endpoint 63 * to take control of dma as it becomes available. 64 * 65 * Note that DMA should not be used on OUT endpoints unless it can 66 * be guaranteed that no short packets will arrive on an IN endpoint 67 * while the DMA operation is pending. Otherwise the OUT DMA will 68 * terminate prematurely (See NET2272 Errata 630-0213-0101) 69 */ 70 static ushort dma_ep = 1; 71 module_param(dma_ep, ushort, 0644); 72 73 /* 74 * dma_mode: net2272 dma mode setting (see LOCCTL1 definition): 75 * mode 0 == Slow DREQ mode 76 * mode 1 == Fast DREQ mode 77 * mode 2 == Burst mode 78 */ 79 static ushort dma_mode = 2; 80 module_param(dma_mode, ushort, 0644); 81 #else 82 #define use_dma 0 83 #define dma_ep 1 84 #define dma_mode 2 85 #endif 86 87 /* 88 * fifo_mode: net2272 buffer configuration: 89 * mode 0 == ep-{a,b,c} 512db each 90 * mode 1 == ep-a 1k, ep-{b,c} 512db 91 * mode 2 == ep-a 1k, ep-b 1k, ep-c 512db 92 * mode 3 == ep-a 1k, ep-b disabled, ep-c 512db 93 */ 94 static ushort fifo_mode = 0; 95 module_param(fifo_mode, ushort, 0644); 96 97 /* 98 * enable_suspend: When enabled, the driver will respond to 99 * USB suspend requests by powering down the NET2272. Otherwise, 100 * USB suspend requests will be ignored. This is acceptable for 101 * self-powered devices. For bus powered devices set this to 1. 102 */ 103 static ushort enable_suspend = 0; 104 module_param(enable_suspend, ushort, 0644); 105 106 static void assert_out_naking(struct net2272_ep *ep, const char *where) 107 { 108 u8 tmp; 109 110 #ifndef DEBUG 111 return; 112 #endif 113 114 tmp = net2272_ep_read(ep, EP_STAT0); 115 if ((tmp & (1 << NAK_OUT_PACKETS)) == 0) { 116 dev_dbg(ep->dev->dev, "%s %s %02x !NAK\n", 117 ep->ep.name, where, tmp); 118 net2272_ep_write(ep, EP_RSPSET, 1 << ALT_NAK_OUT_PACKETS); 119 } 120 } 121 #define ASSERT_OUT_NAKING(ep) assert_out_naking(ep, __func__) 122 123 static void stop_out_naking(struct net2272_ep *ep) 124 { 125 u8 tmp = net2272_ep_read(ep, EP_STAT0); 126 127 if ((tmp & (1 << NAK_OUT_PACKETS)) != 0) 128 net2272_ep_write(ep, EP_RSPCLR, 1 << ALT_NAK_OUT_PACKETS); 129 } 130 131 #define PIPEDIR(bAddress) (usb_pipein(bAddress) ? "in" : "out") 132 133 static char *type_string(u8 bmAttributes) 134 { 135 switch ((bmAttributes) & USB_ENDPOINT_XFERTYPE_MASK) { 136 case USB_ENDPOINT_XFER_BULK: return "bulk"; 137 case USB_ENDPOINT_XFER_ISOC: return "iso"; 138 case USB_ENDPOINT_XFER_INT: return "intr"; 139 default: return "control"; 140 } 141 } 142 143 static char *buf_state_string(unsigned state) 144 { 145 switch (state) { 146 case BUFF_FREE: return "free"; 147 case BUFF_VALID: return "valid"; 148 case BUFF_LCL: return "local"; 149 case BUFF_USB: return "usb"; 150 default: return "unknown"; 151 } 152 } 153 154 static char *dma_mode_string(void) 155 { 156 if (!use_dma) 157 return "PIO"; 158 switch (dma_mode) { 159 case 0: return "SLOW DREQ"; 160 case 1: return "FAST DREQ"; 161 case 2: return "BURST"; 162 default: return "invalid"; 163 } 164 } 165 166 static void net2272_dequeue_all(struct net2272_ep *); 167 static int net2272_kick_dma(struct net2272_ep *, struct net2272_request *); 168 static int net2272_fifo_status(struct usb_ep *); 169 170 static const struct usb_ep_ops net2272_ep_ops; 171 172 /*---------------------------------------------------------------------------*/ 173 174 static int 175 net2272_enable(struct usb_ep *_ep, const struct usb_endpoint_descriptor *desc) 176 { 177 struct net2272 *dev; 178 struct net2272_ep *ep; 179 u32 max; 180 u8 tmp; 181 unsigned long flags; 182 183 ep = container_of(_ep, struct net2272_ep, ep); 184 if (!_ep || !desc || ep->desc || _ep->name == ep0name 185 || desc->bDescriptorType != USB_DT_ENDPOINT) 186 return -EINVAL; 187 dev = ep->dev; 188 if (!dev->driver || dev->gadget.speed == USB_SPEED_UNKNOWN) 189 return -ESHUTDOWN; 190 191 max = usb_endpoint_maxp(desc); 192 193 spin_lock_irqsave(&dev->lock, flags); 194 _ep->maxpacket = max; 195 ep->desc = desc; 196 197 /* net2272_ep_reset() has already been called */ 198 ep->stopped = 0; 199 ep->wedged = 0; 200 201 /* set speed-dependent max packet */ 202 net2272_ep_write(ep, EP_MAXPKT0, max & 0xff); 203 net2272_ep_write(ep, EP_MAXPKT1, (max & 0xff00) >> 8); 204 205 /* set type, direction, address; reset fifo counters */ 206 net2272_ep_write(ep, EP_STAT1, 1 << BUFFER_FLUSH); 207 tmp = usb_endpoint_type(desc); 208 if (usb_endpoint_xfer_bulk(desc)) { 209 /* catch some particularly blatant driver bugs */ 210 if ((dev->gadget.speed == USB_SPEED_HIGH && max != 512) || 211 (dev->gadget.speed == USB_SPEED_FULL && max > 64)) { 212 spin_unlock_irqrestore(&dev->lock, flags); 213 return -ERANGE; 214 } 215 } 216 ep->is_iso = usb_endpoint_xfer_isoc(desc) ? 1 : 0; 217 tmp <<= ENDPOINT_TYPE; 218 tmp |= ((desc->bEndpointAddress & 0x0f) << ENDPOINT_NUMBER); 219 tmp |= usb_endpoint_dir_in(desc) << ENDPOINT_DIRECTION; 220 tmp |= (1 << ENDPOINT_ENABLE); 221 222 /* for OUT transfers, block the rx fifo until a read is posted */ 223 ep->is_in = usb_endpoint_dir_in(desc); 224 if (!ep->is_in) 225 net2272_ep_write(ep, EP_RSPSET, 1 << ALT_NAK_OUT_PACKETS); 226 227 net2272_ep_write(ep, EP_CFG, tmp); 228 229 /* enable irqs */ 230 tmp = (1 << ep->num) | net2272_read(dev, IRQENB0); 231 net2272_write(dev, IRQENB0, tmp); 232 233 tmp = (1 << DATA_PACKET_RECEIVED_INTERRUPT_ENABLE) 234 | (1 << DATA_PACKET_TRANSMITTED_INTERRUPT_ENABLE) 235 | net2272_ep_read(ep, EP_IRQENB); 236 net2272_ep_write(ep, EP_IRQENB, tmp); 237 238 tmp = desc->bEndpointAddress; 239 dev_dbg(dev->dev, "enabled %s (ep%d%s-%s) max %04x cfg %02x\n", 240 _ep->name, tmp & 0x0f, PIPEDIR(tmp), 241 type_string(desc->bmAttributes), max, 242 net2272_ep_read(ep, EP_CFG)); 243 244 spin_unlock_irqrestore(&dev->lock, flags); 245 return 0; 246 } 247 248 static void net2272_ep_reset(struct net2272_ep *ep) 249 { 250 u8 tmp; 251 252 ep->desc = NULL; 253 INIT_LIST_HEAD(&ep->queue); 254 255 usb_ep_set_maxpacket_limit(&ep->ep, ~0); 256 ep->ep.ops = &net2272_ep_ops; 257 258 /* disable irqs, endpoint */ 259 net2272_ep_write(ep, EP_IRQENB, 0); 260 261 /* init to our chosen defaults, notably so that we NAK OUT 262 * packets until the driver queues a read. 263 */ 264 tmp = (1 << NAK_OUT_PACKETS_MODE) | (1 << ALT_NAK_OUT_PACKETS); 265 net2272_ep_write(ep, EP_RSPSET, tmp); 266 267 tmp = (1 << INTERRUPT_MODE) | (1 << HIDE_STATUS_PHASE); 268 if (ep->num != 0) 269 tmp |= (1 << ENDPOINT_TOGGLE) | (1 << ENDPOINT_HALT); 270 271 net2272_ep_write(ep, EP_RSPCLR, tmp); 272 273 /* scrub most status bits, and flush any fifo state */ 274 net2272_ep_write(ep, EP_STAT0, 275 (1 << DATA_IN_TOKEN_INTERRUPT) 276 | (1 << DATA_OUT_TOKEN_INTERRUPT) 277 | (1 << DATA_PACKET_TRANSMITTED_INTERRUPT) 278 | (1 << DATA_PACKET_RECEIVED_INTERRUPT) 279 | (1 << SHORT_PACKET_TRANSFERRED_INTERRUPT)); 280 281 net2272_ep_write(ep, EP_STAT1, 282 (1 << TIMEOUT) 283 | (1 << USB_OUT_ACK_SENT) 284 | (1 << USB_OUT_NAK_SENT) 285 | (1 << USB_IN_ACK_RCVD) 286 | (1 << USB_IN_NAK_SENT) 287 | (1 << USB_STALL_SENT) 288 | (1 << LOCAL_OUT_ZLP) 289 | (1 << BUFFER_FLUSH)); 290 291 /* fifo size is handled separately */ 292 } 293 294 static int net2272_disable(struct usb_ep *_ep) 295 { 296 struct net2272_ep *ep; 297 unsigned long flags; 298 299 ep = container_of(_ep, struct net2272_ep, ep); 300 if (!_ep || !ep->desc || _ep->name == ep0name) 301 return -EINVAL; 302 303 spin_lock_irqsave(&ep->dev->lock, flags); 304 net2272_dequeue_all(ep); 305 net2272_ep_reset(ep); 306 307 dev_vdbg(ep->dev->dev, "disabled %s\n", _ep->name); 308 309 spin_unlock_irqrestore(&ep->dev->lock, flags); 310 return 0; 311 } 312 313 /*---------------------------------------------------------------------------*/ 314 315 static struct usb_request * 316 net2272_alloc_request(struct usb_ep *_ep, gfp_t gfp_flags) 317 { 318 struct net2272_request *req; 319 320 if (!_ep) 321 return NULL; 322 323 req = kzalloc(sizeof(*req), gfp_flags); 324 if (!req) 325 return NULL; 326 327 INIT_LIST_HEAD(&req->queue); 328 329 return &req->req; 330 } 331 332 static void 333 net2272_free_request(struct usb_ep *_ep, struct usb_request *_req) 334 { 335 struct net2272_request *req; 336 337 if (!_ep || !_req) 338 return; 339 340 req = container_of(_req, struct net2272_request, req); 341 WARN_ON(!list_empty(&req->queue)); 342 kfree(req); 343 } 344 345 static void 346 net2272_done(struct net2272_ep *ep, struct net2272_request *req, int status) 347 { 348 struct net2272 *dev; 349 unsigned stopped = ep->stopped; 350 351 if (ep->num == 0) { 352 if (ep->dev->protocol_stall) { 353 ep->stopped = 1; 354 set_halt(ep); 355 } 356 allow_status(ep); 357 } 358 359 list_del_init(&req->queue); 360 361 if (req->req.status == -EINPROGRESS) 362 req->req.status = status; 363 else 364 status = req->req.status; 365 366 dev = ep->dev; 367 if (use_dma && ep->dma) 368 usb_gadget_unmap_request(&dev->gadget, &req->req, 369 ep->is_in); 370 371 if (status && status != -ESHUTDOWN) 372 dev_vdbg(dev->dev, "complete %s req %p stat %d len %u/%u buf %p\n", 373 ep->ep.name, &req->req, status, 374 req->req.actual, req->req.length, req->req.buf); 375 376 /* don't modify queue heads during completion callback */ 377 ep->stopped = 1; 378 spin_unlock(&dev->lock); 379 usb_gadget_giveback_request(&ep->ep, &req->req); 380 spin_lock(&dev->lock); 381 ep->stopped = stopped; 382 } 383 384 static int 385 net2272_write_packet(struct net2272_ep *ep, u8 *buf, 386 struct net2272_request *req, unsigned max) 387 { 388 u16 __iomem *ep_data = net2272_reg_addr(ep->dev, EP_DATA); 389 u16 *bufp; 390 unsigned length, count; 391 u8 tmp; 392 393 length = min(req->req.length - req->req.actual, max); 394 req->req.actual += length; 395 396 dev_vdbg(ep->dev->dev, "write packet %s req %p max %u len %u avail %u\n", 397 ep->ep.name, req, max, length, 398 (net2272_ep_read(ep, EP_AVAIL1) << 8) | net2272_ep_read(ep, EP_AVAIL0)); 399 400 count = length; 401 bufp = (u16 *)buf; 402 403 while (likely(count >= 2)) { 404 /* no byte-swap required; chip endian set during init */ 405 writew(*bufp++, ep_data); 406 count -= 2; 407 } 408 buf = (u8 *)bufp; 409 410 /* write final byte by placing the NET2272 into 8-bit mode */ 411 if (unlikely(count)) { 412 tmp = net2272_read(ep->dev, LOCCTL); 413 net2272_write(ep->dev, LOCCTL, tmp & ~(1 << DATA_WIDTH)); 414 writeb(*buf, ep_data); 415 net2272_write(ep->dev, LOCCTL, tmp); 416 } 417 return length; 418 } 419 420 /* returns: 0: still running, 1: completed, negative: errno */ 421 static int 422 net2272_write_fifo(struct net2272_ep *ep, struct net2272_request *req) 423 { 424 u8 *buf; 425 unsigned count, max; 426 int status; 427 428 dev_vdbg(ep->dev->dev, "write_fifo %s actual %d len %d\n", 429 ep->ep.name, req->req.actual, req->req.length); 430 431 /* 432 * Keep loading the endpoint until the final packet is loaded, 433 * or the endpoint buffer is full. 434 */ 435 top: 436 /* 437 * Clear interrupt status 438 * - Packet Transmitted interrupt will become set again when the 439 * host successfully takes another packet 440 */ 441 net2272_ep_write(ep, EP_STAT0, (1 << DATA_PACKET_TRANSMITTED_INTERRUPT)); 442 while (!(net2272_ep_read(ep, EP_STAT0) & (1 << BUFFER_FULL))) { 443 buf = req->req.buf + req->req.actual; 444 prefetch(buf); 445 446 /* force pagesel */ 447 net2272_ep_read(ep, EP_STAT0); 448 449 max = (net2272_ep_read(ep, EP_AVAIL1) << 8) | 450 (net2272_ep_read(ep, EP_AVAIL0)); 451 452 if (max < ep->ep.maxpacket) 453 max = (net2272_ep_read(ep, EP_AVAIL1) << 8) 454 | (net2272_ep_read(ep, EP_AVAIL0)); 455 456 count = net2272_write_packet(ep, buf, req, max); 457 /* see if we are done */ 458 if (req->req.length == req->req.actual) { 459 /* validate short or zlp packet */ 460 if (count < ep->ep.maxpacket) 461 set_fifo_bytecount(ep, 0); 462 net2272_done(ep, req, 0); 463 464 if (!list_empty(&ep->queue)) { 465 req = list_entry(ep->queue.next, 466 struct net2272_request, 467 queue); 468 status = net2272_kick_dma(ep, req); 469 470 if (status < 0) 471 if ((net2272_ep_read(ep, EP_STAT0) 472 & (1 << BUFFER_EMPTY))) 473 goto top; 474 } 475 return 1; 476 } 477 net2272_ep_write(ep, EP_STAT0, (1 << DATA_PACKET_TRANSMITTED_INTERRUPT)); 478 } 479 return 0; 480 } 481 482 static void 483 net2272_out_flush(struct net2272_ep *ep) 484 { 485 ASSERT_OUT_NAKING(ep); 486 487 net2272_ep_write(ep, EP_STAT0, (1 << DATA_OUT_TOKEN_INTERRUPT) 488 | (1 << DATA_PACKET_RECEIVED_INTERRUPT)); 489 net2272_ep_write(ep, EP_STAT1, 1 << BUFFER_FLUSH); 490 } 491 492 static int 493 net2272_read_packet(struct net2272_ep *ep, u8 *buf, 494 struct net2272_request *req, unsigned avail) 495 { 496 u16 __iomem *ep_data = net2272_reg_addr(ep->dev, EP_DATA); 497 unsigned is_short; 498 u16 *bufp; 499 500 req->req.actual += avail; 501 502 dev_vdbg(ep->dev->dev, "read packet %s req %p len %u avail %u\n", 503 ep->ep.name, req, avail, 504 (net2272_ep_read(ep, EP_AVAIL1) << 8) | net2272_ep_read(ep, EP_AVAIL0)); 505 506 is_short = (avail < ep->ep.maxpacket); 507 508 if (unlikely(avail == 0)) { 509 /* remove any zlp from the buffer */ 510 (void)readw(ep_data); 511 return is_short; 512 } 513 514 /* Ensure we get the final byte */ 515 if (unlikely(avail % 2)) 516 avail++; 517 bufp = (u16 *)buf; 518 519 do { 520 *bufp++ = readw(ep_data); 521 avail -= 2; 522 } while (avail); 523 524 /* 525 * To avoid false endpoint available race condition must read 526 * ep stat0 twice in the case of a short transfer 527 */ 528 if (net2272_ep_read(ep, EP_STAT0) & (1 << SHORT_PACKET_TRANSFERRED_INTERRUPT)) 529 net2272_ep_read(ep, EP_STAT0); 530 531 return is_short; 532 } 533 534 static int 535 net2272_read_fifo(struct net2272_ep *ep, struct net2272_request *req) 536 { 537 u8 *buf; 538 unsigned is_short; 539 int count; 540 int tmp; 541 int cleanup = 0; 542 543 dev_vdbg(ep->dev->dev, "read_fifo %s actual %d len %d\n", 544 ep->ep.name, req->req.actual, req->req.length); 545 546 top: 547 do { 548 buf = req->req.buf + req->req.actual; 549 prefetchw(buf); 550 551 count = (net2272_ep_read(ep, EP_AVAIL1) << 8) 552 | net2272_ep_read(ep, EP_AVAIL0); 553 554 net2272_ep_write(ep, EP_STAT0, 555 (1 << SHORT_PACKET_TRANSFERRED_INTERRUPT) | 556 (1 << DATA_PACKET_RECEIVED_INTERRUPT)); 557 558 tmp = req->req.length - req->req.actual; 559 560 if (count > tmp) { 561 if ((tmp % ep->ep.maxpacket) != 0) { 562 dev_err(ep->dev->dev, 563 "%s out fifo %d bytes, expected %d\n", 564 ep->ep.name, count, tmp); 565 cleanup = 1; 566 } 567 count = (tmp > 0) ? tmp : 0; 568 } 569 570 is_short = net2272_read_packet(ep, buf, req, count); 571 572 /* completion */ 573 if (unlikely(cleanup || is_short || 574 req->req.actual == req->req.length)) { 575 576 if (cleanup) { 577 net2272_out_flush(ep); 578 net2272_done(ep, req, -EOVERFLOW); 579 } else 580 net2272_done(ep, req, 0); 581 582 /* re-initialize endpoint transfer registers 583 * otherwise they may result in erroneous pre-validation 584 * for subsequent control reads 585 */ 586 if (unlikely(ep->num == 0)) { 587 net2272_ep_write(ep, EP_TRANSFER2, 0); 588 net2272_ep_write(ep, EP_TRANSFER1, 0); 589 net2272_ep_write(ep, EP_TRANSFER0, 0); 590 } 591 592 if (!list_empty(&ep->queue)) { 593 int status; 594 595 req = list_entry(ep->queue.next, 596 struct net2272_request, queue); 597 status = net2272_kick_dma(ep, req); 598 if ((status < 0) && 599 !(net2272_ep_read(ep, EP_STAT0) & (1 << BUFFER_EMPTY))) 600 goto top; 601 } 602 return 1; 603 } 604 } while (!(net2272_ep_read(ep, EP_STAT0) & (1 << BUFFER_EMPTY))); 605 606 return 0; 607 } 608 609 static void 610 net2272_pio_advance(struct net2272_ep *ep) 611 { 612 struct net2272_request *req; 613 614 if (unlikely(list_empty(&ep->queue))) 615 return; 616 617 req = list_entry(ep->queue.next, struct net2272_request, queue); 618 (ep->is_in ? net2272_write_fifo : net2272_read_fifo)(ep, req); 619 } 620 621 /* returns 0 on success, else negative errno */ 622 static int 623 net2272_request_dma(struct net2272 *dev, unsigned ep, u32 buf, 624 unsigned len, unsigned dir) 625 { 626 dev_vdbg(dev->dev, "request_dma ep %d buf %08x len %d dir %d\n", 627 ep, buf, len, dir); 628 629 /* The NET2272 only supports a single dma channel */ 630 if (dev->dma_busy) 631 return -EBUSY; 632 /* 633 * EP_TRANSFER (used to determine the number of bytes received 634 * in an OUT transfer) is 24 bits wide; don't ask for more than that. 635 */ 636 if ((dir == 1) && (len > 0x1000000)) 637 return -EINVAL; 638 639 dev->dma_busy = 1; 640 641 /* initialize platform's dma */ 642 #ifdef CONFIG_USB_PCI 643 /* NET2272 addr, buffer addr, length, etc. */ 644 switch (dev->dev_id) { 645 case PCI_DEVICE_ID_RDK1: 646 /* Setup PLX 9054 DMA mode */ 647 writel((1 << LOCAL_BUS_WIDTH) | 648 (1 << TA_READY_INPUT_ENABLE) | 649 (0 << LOCAL_BURST_ENABLE) | 650 (1 << DONE_INTERRUPT_ENABLE) | 651 (1 << LOCAL_ADDRESSING_MODE) | 652 (1 << DEMAND_MODE) | 653 (1 << DMA_EOT_ENABLE) | 654 (1 << FAST_SLOW_TERMINATE_MODE_SELECT) | 655 (1 << DMA_CHANNEL_INTERRUPT_SELECT), 656 dev->rdk1.plx9054_base_addr + DMAMODE0); 657 658 writel(0x100000, dev->rdk1.plx9054_base_addr + DMALADR0); 659 writel(buf, dev->rdk1.plx9054_base_addr + DMAPADR0); 660 writel(len, dev->rdk1.plx9054_base_addr + DMASIZ0); 661 writel((dir << DIRECTION_OF_TRANSFER) | 662 (1 << INTERRUPT_AFTER_TERMINAL_COUNT), 663 dev->rdk1.plx9054_base_addr + DMADPR0); 664 writel((1 << LOCAL_DMA_CHANNEL_0_INTERRUPT_ENABLE) | 665 readl(dev->rdk1.plx9054_base_addr + INTCSR), 666 dev->rdk1.plx9054_base_addr + INTCSR); 667 668 break; 669 } 670 #endif 671 672 net2272_write(dev, DMAREQ, 673 (0 << DMA_BUFFER_VALID) | 674 (1 << DMA_REQUEST_ENABLE) | 675 (1 << DMA_CONTROL_DACK) | 676 (dev->dma_eot_polarity << EOT_POLARITY) | 677 (dev->dma_dack_polarity << DACK_POLARITY) | 678 (dev->dma_dreq_polarity << DREQ_POLARITY) | 679 ((ep >> 1) << DMA_ENDPOINT_SELECT)); 680 681 (void) net2272_read(dev, SCRATCH); 682 683 return 0; 684 } 685 686 static void 687 net2272_start_dma(struct net2272 *dev) 688 { 689 /* start platform's dma controller */ 690 #ifdef CONFIG_USB_PCI 691 switch (dev->dev_id) { 692 case PCI_DEVICE_ID_RDK1: 693 writeb((1 << CHANNEL_ENABLE) | (1 << CHANNEL_START), 694 dev->rdk1.plx9054_base_addr + DMACSR0); 695 break; 696 } 697 #endif 698 } 699 700 /* returns 0 on success, else negative errno */ 701 static int 702 net2272_kick_dma(struct net2272_ep *ep, struct net2272_request *req) 703 { 704 unsigned size; 705 u8 tmp; 706 707 if (!use_dma || (ep->num < 1) || (ep->num > 2) || !ep->dma) 708 return -EINVAL; 709 710 /* don't use dma for odd-length transfers 711 * otherwise, we'd need to deal with the last byte with pio 712 */ 713 if (req->req.length & 1) 714 return -EINVAL; 715 716 dev_vdbg(ep->dev->dev, "kick_dma %s req %p dma %08llx\n", 717 ep->ep.name, req, (unsigned long long) req->req.dma); 718 719 net2272_ep_write(ep, EP_RSPSET, 1 << ALT_NAK_OUT_PACKETS); 720 721 /* The NET2272 can only use DMA on one endpoint at a time */ 722 if (ep->dev->dma_busy) 723 return -EBUSY; 724 725 /* Make sure we only DMA an even number of bytes (we'll use 726 * pio to complete the transfer) 727 */ 728 size = req->req.length; 729 size &= ~1; 730 731 /* device-to-host transfer */ 732 if (ep->is_in) { 733 /* initialize platform's dma controller */ 734 if (net2272_request_dma(ep->dev, ep->num, req->req.dma, size, 0)) 735 /* unable to obtain DMA channel; return error and use pio mode */ 736 return -EBUSY; 737 req->req.actual += size; 738 739 /* host-to-device transfer */ 740 } else { 741 tmp = net2272_ep_read(ep, EP_STAT0); 742 743 /* initialize platform's dma controller */ 744 if (net2272_request_dma(ep->dev, ep->num, req->req.dma, size, 1)) 745 /* unable to obtain DMA channel; return error and use pio mode */ 746 return -EBUSY; 747 748 if (!(tmp & (1 << BUFFER_EMPTY))) 749 ep->not_empty = 1; 750 else 751 ep->not_empty = 0; 752 753 754 /* allow the endpoint's buffer to fill */ 755 net2272_ep_write(ep, EP_RSPCLR, 1 << ALT_NAK_OUT_PACKETS); 756 757 /* this transfer completed and data's already in the fifo 758 * return error so pio gets used. 759 */ 760 if (tmp & (1 << SHORT_PACKET_TRANSFERRED_INTERRUPT)) { 761 762 /* deassert dreq */ 763 net2272_write(ep->dev, DMAREQ, 764 (0 << DMA_BUFFER_VALID) | 765 (0 << DMA_REQUEST_ENABLE) | 766 (1 << DMA_CONTROL_DACK) | 767 (ep->dev->dma_eot_polarity << EOT_POLARITY) | 768 (ep->dev->dma_dack_polarity << DACK_POLARITY) | 769 (ep->dev->dma_dreq_polarity << DREQ_POLARITY) | 770 ((ep->num >> 1) << DMA_ENDPOINT_SELECT)); 771 772 return -EBUSY; 773 } 774 } 775 776 /* Don't use per-packet interrupts: use dma interrupts only */ 777 net2272_ep_write(ep, EP_IRQENB, 0); 778 779 net2272_start_dma(ep->dev); 780 781 return 0; 782 } 783 784 static void net2272_cancel_dma(struct net2272 *dev) 785 { 786 #ifdef CONFIG_USB_PCI 787 switch (dev->dev_id) { 788 case PCI_DEVICE_ID_RDK1: 789 writeb(0, dev->rdk1.plx9054_base_addr + DMACSR0); 790 writeb(1 << CHANNEL_ABORT, dev->rdk1.plx9054_base_addr + DMACSR0); 791 while (!(readb(dev->rdk1.plx9054_base_addr + DMACSR0) & 792 (1 << CHANNEL_DONE))) 793 continue; /* wait for dma to stabalize */ 794 795 /* dma abort generates an interrupt */ 796 writeb(1 << CHANNEL_CLEAR_INTERRUPT, 797 dev->rdk1.plx9054_base_addr + DMACSR0); 798 break; 799 } 800 #endif 801 802 dev->dma_busy = 0; 803 } 804 805 /*---------------------------------------------------------------------------*/ 806 807 static int 808 net2272_queue(struct usb_ep *_ep, struct usb_request *_req, gfp_t gfp_flags) 809 { 810 struct net2272_request *req; 811 struct net2272_ep *ep; 812 struct net2272 *dev; 813 unsigned long flags; 814 int status = -1; 815 u8 s; 816 817 req = container_of(_req, struct net2272_request, req); 818 if (!_req || !_req->complete || !_req->buf 819 || !list_empty(&req->queue)) 820 return -EINVAL; 821 ep = container_of(_ep, struct net2272_ep, ep); 822 if (!_ep || (!ep->desc && ep->num != 0)) 823 return -EINVAL; 824 dev = ep->dev; 825 if (!dev->driver || dev->gadget.speed == USB_SPEED_UNKNOWN) 826 return -ESHUTDOWN; 827 828 /* set up dma mapping in case the caller didn't */ 829 if (use_dma && ep->dma) { 830 status = usb_gadget_map_request(&dev->gadget, _req, 831 ep->is_in); 832 if (status) 833 return status; 834 } 835 836 dev_vdbg(dev->dev, "%s queue req %p, len %d buf %p dma %08llx %s\n", 837 _ep->name, _req, _req->length, _req->buf, 838 (unsigned long long) _req->dma, _req->zero ? "zero" : "!zero"); 839 840 spin_lock_irqsave(&dev->lock, flags); 841 842 _req->status = -EINPROGRESS; 843 _req->actual = 0; 844 845 /* kickstart this i/o queue? */ 846 if (list_empty(&ep->queue) && !ep->stopped) { 847 /* maybe there's no control data, just status ack */ 848 if (ep->num == 0 && _req->length == 0) { 849 net2272_done(ep, req, 0); 850 dev_vdbg(dev->dev, "%s status ack\n", ep->ep.name); 851 goto done; 852 } 853 854 /* Return zlp, don't let it block subsequent packets */ 855 s = net2272_ep_read(ep, EP_STAT0); 856 if (s & (1 << BUFFER_EMPTY)) { 857 /* Buffer is empty check for a blocking zlp, handle it */ 858 if ((s & (1 << NAK_OUT_PACKETS)) && 859 net2272_ep_read(ep, EP_STAT1) & (1 << LOCAL_OUT_ZLP)) { 860 dev_dbg(dev->dev, "WARNING: returning ZLP short packet termination!\n"); 861 /* 862 * Request is going to terminate with a short packet ... 863 * hope the client is ready for it! 864 */ 865 status = net2272_read_fifo(ep, req); 866 /* clear short packet naking */ 867 net2272_ep_write(ep, EP_STAT0, (1 << NAK_OUT_PACKETS)); 868 goto done; 869 } 870 } 871 872 /* try dma first */ 873 status = net2272_kick_dma(ep, req); 874 875 if (status < 0) { 876 /* dma failed (most likely in use by another endpoint) 877 * fallback to pio 878 */ 879 status = 0; 880 881 if (ep->is_in) 882 status = net2272_write_fifo(ep, req); 883 else { 884 s = net2272_ep_read(ep, EP_STAT0); 885 if ((s & (1 << BUFFER_EMPTY)) == 0) 886 status = net2272_read_fifo(ep, req); 887 } 888 889 if (unlikely(status != 0)) { 890 if (status > 0) 891 status = 0; 892 req = NULL; 893 } 894 } 895 } 896 if (likely(req)) 897 list_add_tail(&req->queue, &ep->queue); 898 899 if (likely(!list_empty(&ep->queue))) 900 net2272_ep_write(ep, EP_RSPCLR, 1 << ALT_NAK_OUT_PACKETS); 901 done: 902 spin_unlock_irqrestore(&dev->lock, flags); 903 904 return 0; 905 } 906 907 /* dequeue ALL requests */ 908 static void 909 net2272_dequeue_all(struct net2272_ep *ep) 910 { 911 struct net2272_request *req; 912 913 /* called with spinlock held */ 914 ep->stopped = 1; 915 916 while (!list_empty(&ep->queue)) { 917 req = list_entry(ep->queue.next, 918 struct net2272_request, 919 queue); 920 net2272_done(ep, req, -ESHUTDOWN); 921 } 922 } 923 924 /* dequeue JUST ONE request */ 925 static int 926 net2272_dequeue(struct usb_ep *_ep, struct usb_request *_req) 927 { 928 struct net2272_ep *ep; 929 struct net2272_request *req = NULL, *iter; 930 unsigned long flags; 931 int stopped; 932 933 ep = container_of(_ep, struct net2272_ep, ep); 934 if (!_ep || (!ep->desc && ep->num != 0) || !_req) 935 return -EINVAL; 936 937 spin_lock_irqsave(&ep->dev->lock, flags); 938 stopped = ep->stopped; 939 ep->stopped = 1; 940 941 /* make sure it's still queued on this endpoint */ 942 list_for_each_entry(iter, &ep->queue, queue) { 943 if (&iter->req != _req) 944 continue; 945 req = iter; 946 break; 947 } 948 if (!req) { 949 ep->stopped = stopped; 950 spin_unlock_irqrestore(&ep->dev->lock, flags); 951 return -EINVAL; 952 } 953 954 /* queue head may be partially complete */ 955 if (ep->queue.next == &req->queue) { 956 dev_dbg(ep->dev->dev, "unlink (%s) pio\n", _ep->name); 957 net2272_done(ep, req, -ECONNRESET); 958 } 959 ep->stopped = stopped; 960 961 spin_unlock_irqrestore(&ep->dev->lock, flags); 962 return 0; 963 } 964 965 /*---------------------------------------------------------------------------*/ 966 967 static int 968 net2272_set_halt_and_wedge(struct usb_ep *_ep, int value, int wedged) 969 { 970 struct net2272_ep *ep; 971 unsigned long flags; 972 int ret = 0; 973 974 ep = container_of(_ep, struct net2272_ep, ep); 975 if (!_ep || (!ep->desc && ep->num != 0)) 976 return -EINVAL; 977 if (!ep->dev->driver || ep->dev->gadget.speed == USB_SPEED_UNKNOWN) 978 return -ESHUTDOWN; 979 if (ep->desc /* not ep0 */ && usb_endpoint_xfer_isoc(ep->desc)) 980 return -EINVAL; 981 982 spin_lock_irqsave(&ep->dev->lock, flags); 983 if (!list_empty(&ep->queue)) 984 ret = -EAGAIN; 985 else if (ep->is_in && value && net2272_fifo_status(_ep) != 0) 986 ret = -EAGAIN; 987 else { 988 dev_vdbg(ep->dev->dev, "%s %s %s\n", _ep->name, 989 value ? "set" : "clear", 990 wedged ? "wedge" : "halt"); 991 /* set/clear */ 992 if (value) { 993 if (ep->num == 0) 994 ep->dev->protocol_stall = 1; 995 else 996 set_halt(ep); 997 if (wedged) 998 ep->wedged = 1; 999 } else { 1000 clear_halt(ep); 1001 ep->wedged = 0; 1002 } 1003 } 1004 spin_unlock_irqrestore(&ep->dev->lock, flags); 1005 1006 return ret; 1007 } 1008 1009 static int 1010 net2272_set_halt(struct usb_ep *_ep, int value) 1011 { 1012 return net2272_set_halt_and_wedge(_ep, value, 0); 1013 } 1014 1015 static int 1016 net2272_set_wedge(struct usb_ep *_ep) 1017 { 1018 if (!_ep || _ep->name == ep0name) 1019 return -EINVAL; 1020 return net2272_set_halt_and_wedge(_ep, 1, 1); 1021 } 1022 1023 static int 1024 net2272_fifo_status(struct usb_ep *_ep) 1025 { 1026 struct net2272_ep *ep; 1027 u16 avail; 1028 1029 ep = container_of(_ep, struct net2272_ep, ep); 1030 if (!_ep || (!ep->desc && ep->num != 0)) 1031 return -ENODEV; 1032 if (!ep->dev->driver || ep->dev->gadget.speed == USB_SPEED_UNKNOWN) 1033 return -ESHUTDOWN; 1034 1035 avail = net2272_ep_read(ep, EP_AVAIL1) << 8; 1036 avail |= net2272_ep_read(ep, EP_AVAIL0); 1037 if (avail > ep->fifo_size) 1038 return -EOVERFLOW; 1039 if (ep->is_in) 1040 avail = ep->fifo_size - avail; 1041 return avail; 1042 } 1043 1044 static void 1045 net2272_fifo_flush(struct usb_ep *_ep) 1046 { 1047 struct net2272_ep *ep; 1048 1049 ep = container_of(_ep, struct net2272_ep, ep); 1050 if (!_ep || (!ep->desc && ep->num != 0)) 1051 return; 1052 if (!ep->dev->driver || ep->dev->gadget.speed == USB_SPEED_UNKNOWN) 1053 return; 1054 1055 net2272_ep_write(ep, EP_STAT1, 1 << BUFFER_FLUSH); 1056 } 1057 1058 static const struct usb_ep_ops net2272_ep_ops = { 1059 .enable = net2272_enable, 1060 .disable = net2272_disable, 1061 1062 .alloc_request = net2272_alloc_request, 1063 .free_request = net2272_free_request, 1064 1065 .queue = net2272_queue, 1066 .dequeue = net2272_dequeue, 1067 1068 .set_halt = net2272_set_halt, 1069 .set_wedge = net2272_set_wedge, 1070 .fifo_status = net2272_fifo_status, 1071 .fifo_flush = net2272_fifo_flush, 1072 }; 1073 1074 /*---------------------------------------------------------------------------*/ 1075 1076 static int 1077 net2272_get_frame(struct usb_gadget *_gadget) 1078 { 1079 struct net2272 *dev; 1080 unsigned long flags; 1081 u16 ret; 1082 1083 if (!_gadget) 1084 return -ENODEV; 1085 dev = container_of(_gadget, struct net2272, gadget); 1086 spin_lock_irqsave(&dev->lock, flags); 1087 1088 ret = net2272_read(dev, FRAME1) << 8; 1089 ret |= net2272_read(dev, FRAME0); 1090 1091 spin_unlock_irqrestore(&dev->lock, flags); 1092 return ret; 1093 } 1094 1095 static int 1096 net2272_wakeup(struct usb_gadget *_gadget) 1097 { 1098 struct net2272 *dev; 1099 u8 tmp; 1100 unsigned long flags; 1101 1102 if (!_gadget) 1103 return 0; 1104 dev = container_of(_gadget, struct net2272, gadget); 1105 1106 spin_lock_irqsave(&dev->lock, flags); 1107 tmp = net2272_read(dev, USBCTL0); 1108 if (tmp & (1 << IO_WAKEUP_ENABLE)) 1109 net2272_write(dev, USBCTL1, (1 << GENERATE_RESUME)); 1110 1111 spin_unlock_irqrestore(&dev->lock, flags); 1112 1113 return 0; 1114 } 1115 1116 static int 1117 net2272_set_selfpowered(struct usb_gadget *_gadget, int value) 1118 { 1119 if (!_gadget) 1120 return -ENODEV; 1121 1122 _gadget->is_selfpowered = (value != 0); 1123 1124 return 0; 1125 } 1126 1127 static int 1128 net2272_pullup(struct usb_gadget *_gadget, int is_on) 1129 { 1130 struct net2272 *dev; 1131 u8 tmp; 1132 unsigned long flags; 1133 1134 if (!_gadget) 1135 return -ENODEV; 1136 dev = container_of(_gadget, struct net2272, gadget); 1137 1138 spin_lock_irqsave(&dev->lock, flags); 1139 tmp = net2272_read(dev, USBCTL0); 1140 dev->softconnect = (is_on != 0); 1141 if (is_on) 1142 tmp |= (1 << USB_DETECT_ENABLE); 1143 else 1144 tmp &= ~(1 << USB_DETECT_ENABLE); 1145 net2272_write(dev, USBCTL0, tmp); 1146 spin_unlock_irqrestore(&dev->lock, flags); 1147 1148 return 0; 1149 } 1150 1151 static int net2272_start(struct usb_gadget *_gadget, 1152 struct usb_gadget_driver *driver); 1153 static int net2272_stop(struct usb_gadget *_gadget); 1154 static void net2272_async_callbacks(struct usb_gadget *_gadget, bool enable); 1155 1156 static const struct usb_gadget_ops net2272_ops = { 1157 .get_frame = net2272_get_frame, 1158 .wakeup = net2272_wakeup, 1159 .set_selfpowered = net2272_set_selfpowered, 1160 .pullup = net2272_pullup, 1161 .udc_start = net2272_start, 1162 .udc_stop = net2272_stop, 1163 .udc_async_callbacks = net2272_async_callbacks, 1164 }; 1165 1166 /*---------------------------------------------------------------------------*/ 1167 1168 static ssize_t 1169 registers_show(struct device *_dev, struct device_attribute *attr, char *buf) 1170 { 1171 struct net2272 *dev; 1172 char *next; 1173 unsigned size, t; 1174 unsigned long flags; 1175 u8 t1, t2; 1176 int i; 1177 const char *s; 1178 1179 dev = dev_get_drvdata(_dev); 1180 next = buf; 1181 size = PAGE_SIZE; 1182 spin_lock_irqsave(&dev->lock, flags); 1183 1184 /* Main Control Registers */ 1185 t = scnprintf(next, size, "%s version %s," 1186 "chiprev %02x, locctl %02x\n" 1187 "irqenb0 %02x irqenb1 %02x " 1188 "irqstat0 %02x irqstat1 %02x\n", 1189 driver_name, driver_vers, dev->chiprev, 1190 net2272_read(dev, LOCCTL), 1191 net2272_read(dev, IRQENB0), 1192 net2272_read(dev, IRQENB1), 1193 net2272_read(dev, IRQSTAT0), 1194 net2272_read(dev, IRQSTAT1)); 1195 size -= t; 1196 next += t; 1197 1198 /* DMA */ 1199 t1 = net2272_read(dev, DMAREQ); 1200 t = scnprintf(next, size, "\ndmareq %02x: %s %s%s%s%s\n", 1201 t1, ep_name[(t1 & 0x01) + 1], 1202 t1 & (1 << DMA_CONTROL_DACK) ? "dack " : "", 1203 t1 & (1 << DMA_REQUEST_ENABLE) ? "reqenb " : "", 1204 t1 & (1 << DMA_REQUEST) ? "req " : "", 1205 t1 & (1 << DMA_BUFFER_VALID) ? "valid " : ""); 1206 size -= t; 1207 next += t; 1208 1209 /* USB Control Registers */ 1210 t1 = net2272_read(dev, USBCTL1); 1211 if (t1 & (1 << VBUS_PIN)) { 1212 if (t1 & (1 << USB_HIGH_SPEED)) 1213 s = "high speed"; 1214 else if (dev->gadget.speed == USB_SPEED_UNKNOWN) 1215 s = "powered"; 1216 else 1217 s = "full speed"; 1218 } else 1219 s = "not attached"; 1220 t = scnprintf(next, size, 1221 "usbctl0 %02x usbctl1 %02x addr 0x%02x (%s)\n", 1222 net2272_read(dev, USBCTL0), t1, 1223 net2272_read(dev, OURADDR), s); 1224 size -= t; 1225 next += t; 1226 1227 /* Endpoint Registers */ 1228 for (i = 0; i < 4; ++i) { 1229 struct net2272_ep *ep; 1230 1231 ep = &dev->ep[i]; 1232 if (i && !ep->desc) 1233 continue; 1234 1235 t1 = net2272_ep_read(ep, EP_CFG); 1236 t2 = net2272_ep_read(ep, EP_RSPSET); 1237 t = scnprintf(next, size, 1238 "\n%s\tcfg %02x rsp (%02x) %s%s%s%s%s%s%s%s" 1239 "irqenb %02x\n", 1240 ep->ep.name, t1, t2, 1241 (t2 & (1 << ALT_NAK_OUT_PACKETS)) ? "NAK " : "", 1242 (t2 & (1 << HIDE_STATUS_PHASE)) ? "hide " : "", 1243 (t2 & (1 << AUTOVALIDATE)) ? "auto " : "", 1244 (t2 & (1 << INTERRUPT_MODE)) ? "interrupt " : "", 1245 (t2 & (1 << CONTROL_STATUS_PHASE_HANDSHAKE)) ? "status " : "", 1246 (t2 & (1 << NAK_OUT_PACKETS_MODE)) ? "NAKmode " : "", 1247 (t2 & (1 << ENDPOINT_TOGGLE)) ? "DATA1 " : "DATA0 ", 1248 (t2 & (1 << ENDPOINT_HALT)) ? "HALT " : "", 1249 net2272_ep_read(ep, EP_IRQENB)); 1250 size -= t; 1251 next += t; 1252 1253 t = scnprintf(next, size, 1254 "\tstat0 %02x stat1 %02x avail %04x " 1255 "(ep%d%s-%s)%s\n", 1256 net2272_ep_read(ep, EP_STAT0), 1257 net2272_ep_read(ep, EP_STAT1), 1258 (net2272_ep_read(ep, EP_AVAIL1) << 8) | net2272_ep_read(ep, EP_AVAIL0), 1259 t1 & 0x0f, 1260 ep->is_in ? "in" : "out", 1261 type_string(t1 >> 5), 1262 ep->stopped ? "*" : ""); 1263 size -= t; 1264 next += t; 1265 1266 t = scnprintf(next, size, 1267 "\tep_transfer %06x\n", 1268 ((net2272_ep_read(ep, EP_TRANSFER2) & 0xff) << 16) | 1269 ((net2272_ep_read(ep, EP_TRANSFER1) & 0xff) << 8) | 1270 ((net2272_ep_read(ep, EP_TRANSFER0) & 0xff))); 1271 size -= t; 1272 next += t; 1273 1274 t1 = net2272_ep_read(ep, EP_BUFF_STATES) & 0x03; 1275 t2 = (net2272_ep_read(ep, EP_BUFF_STATES) >> 2) & 0x03; 1276 t = scnprintf(next, size, 1277 "\tbuf-a %s buf-b %s\n", 1278 buf_state_string(t1), 1279 buf_state_string(t2)); 1280 size -= t; 1281 next += t; 1282 } 1283 1284 spin_unlock_irqrestore(&dev->lock, flags); 1285 1286 return PAGE_SIZE - size; 1287 } 1288 static DEVICE_ATTR_RO(registers); 1289 1290 /*---------------------------------------------------------------------------*/ 1291 1292 static void 1293 net2272_set_fifo_mode(struct net2272 *dev, int mode) 1294 { 1295 u8 tmp; 1296 1297 tmp = net2272_read(dev, LOCCTL) & 0x3f; 1298 tmp |= (mode << 6); 1299 net2272_write(dev, LOCCTL, tmp); 1300 1301 INIT_LIST_HEAD(&dev->gadget.ep_list); 1302 1303 /* always ep-a, ep-c ... maybe not ep-b */ 1304 list_add_tail(&dev->ep[1].ep.ep_list, &dev->gadget.ep_list); 1305 1306 switch (mode) { 1307 case 0: 1308 list_add_tail(&dev->ep[2].ep.ep_list, &dev->gadget.ep_list); 1309 dev->ep[1].fifo_size = dev->ep[2].fifo_size = 512; 1310 break; 1311 case 1: 1312 list_add_tail(&dev->ep[2].ep.ep_list, &dev->gadget.ep_list); 1313 dev->ep[1].fifo_size = 1024; 1314 dev->ep[2].fifo_size = 512; 1315 break; 1316 case 2: 1317 list_add_tail(&dev->ep[2].ep.ep_list, &dev->gadget.ep_list); 1318 dev->ep[1].fifo_size = dev->ep[2].fifo_size = 1024; 1319 break; 1320 case 3: 1321 dev->ep[1].fifo_size = 1024; 1322 break; 1323 } 1324 1325 /* ep-c is always 2 512 byte buffers */ 1326 list_add_tail(&dev->ep[3].ep.ep_list, &dev->gadget.ep_list); 1327 dev->ep[3].fifo_size = 512; 1328 } 1329 1330 /*---------------------------------------------------------------------------*/ 1331 1332 static void 1333 net2272_usb_reset(struct net2272 *dev) 1334 { 1335 dev->gadget.speed = USB_SPEED_UNKNOWN; 1336 1337 net2272_cancel_dma(dev); 1338 1339 net2272_write(dev, IRQENB0, 0); 1340 net2272_write(dev, IRQENB1, 0); 1341 1342 /* clear irq state */ 1343 net2272_write(dev, IRQSTAT0, 0xff); 1344 net2272_write(dev, IRQSTAT1, ~(1 << SUSPEND_REQUEST_INTERRUPT)); 1345 1346 net2272_write(dev, DMAREQ, 1347 (0 << DMA_BUFFER_VALID) | 1348 (0 << DMA_REQUEST_ENABLE) | 1349 (1 << DMA_CONTROL_DACK) | 1350 (dev->dma_eot_polarity << EOT_POLARITY) | 1351 (dev->dma_dack_polarity << DACK_POLARITY) | 1352 (dev->dma_dreq_polarity << DREQ_POLARITY) | 1353 ((dma_ep >> 1) << DMA_ENDPOINT_SELECT)); 1354 1355 net2272_cancel_dma(dev); 1356 net2272_set_fifo_mode(dev, (fifo_mode <= 3) ? fifo_mode : 0); 1357 1358 /* Set the NET2272 ep fifo data width to 16-bit mode and for correct byte swapping 1359 * note that the higher level gadget drivers are expected to convert data to little endian. 1360 * Enable byte swap for your local bus/cpu if needed by setting BYTE_SWAP in LOCCTL here 1361 */ 1362 net2272_write(dev, LOCCTL, net2272_read(dev, LOCCTL) | (1 << DATA_WIDTH)); 1363 net2272_write(dev, LOCCTL1, (dma_mode << DMA_MODE)); 1364 } 1365 1366 static void 1367 net2272_usb_reinit(struct net2272 *dev) 1368 { 1369 int i; 1370 1371 /* basic endpoint init */ 1372 for (i = 0; i < 4; ++i) { 1373 struct net2272_ep *ep = &dev->ep[i]; 1374 1375 ep->ep.name = ep_name[i]; 1376 ep->dev = dev; 1377 ep->num = i; 1378 ep->not_empty = 0; 1379 1380 if (use_dma && ep->num == dma_ep) 1381 ep->dma = 1; 1382 1383 if (i > 0 && i <= 3) 1384 ep->fifo_size = 512; 1385 else 1386 ep->fifo_size = 64; 1387 net2272_ep_reset(ep); 1388 1389 if (i == 0) { 1390 ep->ep.caps.type_control = true; 1391 } else { 1392 ep->ep.caps.type_iso = true; 1393 ep->ep.caps.type_bulk = true; 1394 ep->ep.caps.type_int = true; 1395 } 1396 1397 ep->ep.caps.dir_in = true; 1398 ep->ep.caps.dir_out = true; 1399 } 1400 usb_ep_set_maxpacket_limit(&dev->ep[0].ep, 64); 1401 1402 dev->gadget.ep0 = &dev->ep[0].ep; 1403 dev->ep[0].stopped = 0; 1404 INIT_LIST_HEAD(&dev->gadget.ep0->ep_list); 1405 } 1406 1407 static void 1408 net2272_ep0_start(struct net2272 *dev) 1409 { 1410 struct net2272_ep *ep0 = &dev->ep[0]; 1411 1412 net2272_ep_write(ep0, EP_RSPSET, 1413 (1 << NAK_OUT_PACKETS_MODE) | 1414 (1 << ALT_NAK_OUT_PACKETS)); 1415 net2272_ep_write(ep0, EP_RSPCLR, 1416 (1 << HIDE_STATUS_PHASE) | 1417 (1 << CONTROL_STATUS_PHASE_HANDSHAKE)); 1418 net2272_write(dev, USBCTL0, 1419 (dev->softconnect << USB_DETECT_ENABLE) | 1420 (1 << USB_ROOT_PORT_WAKEUP_ENABLE) | 1421 (1 << IO_WAKEUP_ENABLE)); 1422 net2272_write(dev, IRQENB0, 1423 (1 << SETUP_PACKET_INTERRUPT_ENABLE) | 1424 (1 << ENDPOINT_0_INTERRUPT_ENABLE) | 1425 (1 << DMA_DONE_INTERRUPT_ENABLE)); 1426 net2272_write(dev, IRQENB1, 1427 (1 << VBUS_INTERRUPT_ENABLE) | 1428 (1 << ROOT_PORT_RESET_INTERRUPT_ENABLE) | 1429 (1 << SUSPEND_REQUEST_CHANGE_INTERRUPT_ENABLE)); 1430 } 1431 1432 /* when a driver is successfully registered, it will receive 1433 * control requests including set_configuration(), which enables 1434 * non-control requests. then usb traffic follows until a 1435 * disconnect is reported. then a host may connect again, or 1436 * the driver might get unbound. 1437 */ 1438 static int net2272_start(struct usb_gadget *_gadget, 1439 struct usb_gadget_driver *driver) 1440 { 1441 struct net2272 *dev; 1442 unsigned i; 1443 1444 if (!driver || !driver->setup || 1445 driver->max_speed != USB_SPEED_HIGH) 1446 return -EINVAL; 1447 1448 dev = container_of(_gadget, struct net2272, gadget); 1449 1450 for (i = 0; i < 4; ++i) 1451 dev->ep[i].irqs = 0; 1452 /* hook up the driver ... */ 1453 dev->softconnect = 1; 1454 driver->driver.bus = NULL; 1455 dev->driver = driver; 1456 1457 /* ... then enable host detection and ep0; and we're ready 1458 * for set_configuration as well as eventual disconnect. 1459 */ 1460 net2272_ep0_start(dev); 1461 1462 return 0; 1463 } 1464 1465 static void 1466 stop_activity(struct net2272 *dev, struct usb_gadget_driver *driver) 1467 { 1468 int i; 1469 1470 /* don't disconnect if it's not connected */ 1471 if (dev->gadget.speed == USB_SPEED_UNKNOWN) 1472 driver = NULL; 1473 1474 /* stop hardware; prevent new request submissions; 1475 * and kill any outstanding requests. 1476 */ 1477 net2272_usb_reset(dev); 1478 for (i = 0; i < 4; ++i) 1479 net2272_dequeue_all(&dev->ep[i]); 1480 1481 /* report disconnect; the driver is already quiesced */ 1482 if (dev->async_callbacks && driver) { 1483 spin_unlock(&dev->lock); 1484 driver->disconnect(&dev->gadget); 1485 spin_lock(&dev->lock); 1486 } 1487 1488 net2272_usb_reinit(dev); 1489 } 1490 1491 static int net2272_stop(struct usb_gadget *_gadget) 1492 { 1493 struct net2272 *dev; 1494 unsigned long flags; 1495 1496 dev = container_of(_gadget, struct net2272, gadget); 1497 1498 spin_lock_irqsave(&dev->lock, flags); 1499 stop_activity(dev, NULL); 1500 spin_unlock_irqrestore(&dev->lock, flags); 1501 1502 dev->driver = NULL; 1503 1504 return 0; 1505 } 1506 1507 static void net2272_async_callbacks(struct usb_gadget *_gadget, bool enable) 1508 { 1509 struct net2272 *dev = container_of(_gadget, struct net2272, gadget); 1510 1511 spin_lock_irq(&dev->lock); 1512 dev->async_callbacks = enable; 1513 spin_unlock_irq(&dev->lock); 1514 } 1515 1516 /*---------------------------------------------------------------------------*/ 1517 /* handle ep-a/ep-b dma completions */ 1518 static void 1519 net2272_handle_dma(struct net2272_ep *ep) 1520 { 1521 struct net2272_request *req; 1522 unsigned len; 1523 int status; 1524 1525 if (!list_empty(&ep->queue)) 1526 req = list_entry(ep->queue.next, 1527 struct net2272_request, queue); 1528 else 1529 req = NULL; 1530 1531 dev_vdbg(ep->dev->dev, "handle_dma %s req %p\n", ep->ep.name, req); 1532 1533 /* Ensure DREQ is de-asserted */ 1534 net2272_write(ep->dev, DMAREQ, 1535 (0 << DMA_BUFFER_VALID) 1536 | (0 << DMA_REQUEST_ENABLE) 1537 | (1 << DMA_CONTROL_DACK) 1538 | (ep->dev->dma_eot_polarity << EOT_POLARITY) 1539 | (ep->dev->dma_dack_polarity << DACK_POLARITY) 1540 | (ep->dev->dma_dreq_polarity << DREQ_POLARITY) 1541 | (ep->dma << DMA_ENDPOINT_SELECT)); 1542 1543 ep->dev->dma_busy = 0; 1544 1545 net2272_ep_write(ep, EP_IRQENB, 1546 (1 << DATA_PACKET_RECEIVED_INTERRUPT_ENABLE) 1547 | (1 << DATA_PACKET_TRANSMITTED_INTERRUPT_ENABLE) 1548 | net2272_ep_read(ep, EP_IRQENB)); 1549 1550 /* device-to-host transfer completed */ 1551 if (ep->is_in) { 1552 /* validate a short packet or zlp if necessary */ 1553 if ((req->req.length % ep->ep.maxpacket != 0) || 1554 req->req.zero) 1555 set_fifo_bytecount(ep, 0); 1556 1557 net2272_done(ep, req, 0); 1558 if (!list_empty(&ep->queue)) { 1559 req = list_entry(ep->queue.next, 1560 struct net2272_request, queue); 1561 status = net2272_kick_dma(ep, req); 1562 if (status < 0) 1563 net2272_pio_advance(ep); 1564 } 1565 1566 /* host-to-device transfer completed */ 1567 } else { 1568 /* terminated with a short packet? */ 1569 if (net2272_read(ep->dev, IRQSTAT0) & 1570 (1 << DMA_DONE_INTERRUPT)) { 1571 /* abort system dma */ 1572 net2272_cancel_dma(ep->dev); 1573 } 1574 1575 /* EP_TRANSFER will contain the number of bytes 1576 * actually received. 1577 * NOTE: There is no overflow detection on EP_TRANSFER: 1578 * We can't deal with transfers larger than 2^24 bytes! 1579 */ 1580 len = (net2272_ep_read(ep, EP_TRANSFER2) << 16) 1581 | (net2272_ep_read(ep, EP_TRANSFER1) << 8) 1582 | (net2272_ep_read(ep, EP_TRANSFER0)); 1583 1584 if (ep->not_empty) 1585 len += 4; 1586 1587 req->req.actual += len; 1588 1589 /* get any remaining data */ 1590 net2272_pio_advance(ep); 1591 } 1592 } 1593 1594 /*---------------------------------------------------------------------------*/ 1595 1596 static void 1597 net2272_handle_ep(struct net2272_ep *ep) 1598 { 1599 struct net2272_request *req; 1600 u8 stat0, stat1; 1601 1602 if (!list_empty(&ep->queue)) 1603 req = list_entry(ep->queue.next, 1604 struct net2272_request, queue); 1605 else 1606 req = NULL; 1607 1608 /* ack all, and handle what we care about */ 1609 stat0 = net2272_ep_read(ep, EP_STAT0); 1610 stat1 = net2272_ep_read(ep, EP_STAT1); 1611 ep->irqs++; 1612 1613 dev_vdbg(ep->dev->dev, "%s ack ep_stat0 %02x, ep_stat1 %02x, req %p\n", 1614 ep->ep.name, stat0, stat1, req ? &req->req : NULL); 1615 1616 net2272_ep_write(ep, EP_STAT0, stat0 & 1617 ~((1 << NAK_OUT_PACKETS) 1618 | (1 << SHORT_PACKET_TRANSFERRED_INTERRUPT))); 1619 net2272_ep_write(ep, EP_STAT1, stat1); 1620 1621 /* data packet(s) received (in the fifo, OUT) 1622 * direction must be validated, otherwise control read status phase 1623 * could be interpreted as a valid packet 1624 */ 1625 if (!ep->is_in && (stat0 & (1 << DATA_PACKET_RECEIVED_INTERRUPT))) 1626 net2272_pio_advance(ep); 1627 /* data packet(s) transmitted (IN) */ 1628 else if (stat0 & (1 << DATA_PACKET_TRANSMITTED_INTERRUPT)) 1629 net2272_pio_advance(ep); 1630 } 1631 1632 static struct net2272_ep * 1633 net2272_get_ep_by_addr(struct net2272 *dev, u16 wIndex) 1634 { 1635 struct net2272_ep *ep; 1636 1637 if ((wIndex & USB_ENDPOINT_NUMBER_MASK) == 0) 1638 return &dev->ep[0]; 1639 1640 list_for_each_entry(ep, &dev->gadget.ep_list, ep.ep_list) { 1641 u8 bEndpointAddress; 1642 1643 if (!ep->desc) 1644 continue; 1645 bEndpointAddress = ep->desc->bEndpointAddress; 1646 if ((wIndex ^ bEndpointAddress) & USB_DIR_IN) 1647 continue; 1648 if ((wIndex & 0x0f) == (bEndpointAddress & 0x0f)) 1649 return ep; 1650 } 1651 return NULL; 1652 } 1653 1654 /* 1655 * USB Test Packet: 1656 * JKJKJKJK * 9 1657 * JJKKJJKK * 8 1658 * JJJJKKKK * 8 1659 * JJJJJJJKKKKKKK * 8 1660 * JJJJJJJK * 8 1661 * {JKKKKKKK * 10}, JK 1662 */ 1663 static const u8 net2272_test_packet[] = { 1664 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 1665 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 1666 0xEE, 0xEE, 0xEE, 0xEE, 0xEE, 0xEE, 0xEE, 0xEE, 1667 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 1668 0x7F, 0xBF, 0xDF, 0xEF, 0xF7, 0xFB, 0xFD, 1669 0xFC, 0x7E, 0xBF, 0xDF, 0xEF, 0xF7, 0xFD, 0x7E 1670 }; 1671 1672 static void 1673 net2272_set_test_mode(struct net2272 *dev, int mode) 1674 { 1675 int i; 1676 1677 /* Disable all net2272 interrupts: 1678 * Nothing but a power cycle should stop the test. 1679 */ 1680 net2272_write(dev, IRQENB0, 0x00); 1681 net2272_write(dev, IRQENB1, 0x00); 1682 1683 /* Force tranceiver to high-speed */ 1684 net2272_write(dev, XCVRDIAG, 1 << FORCE_HIGH_SPEED); 1685 1686 net2272_write(dev, PAGESEL, 0); 1687 net2272_write(dev, EP_STAT0, 1 << DATA_PACKET_TRANSMITTED_INTERRUPT); 1688 net2272_write(dev, EP_RSPCLR, 1689 (1 << CONTROL_STATUS_PHASE_HANDSHAKE) 1690 | (1 << HIDE_STATUS_PHASE)); 1691 net2272_write(dev, EP_CFG, 1 << ENDPOINT_DIRECTION); 1692 net2272_write(dev, EP_STAT1, 1 << BUFFER_FLUSH); 1693 1694 /* wait for status phase to complete */ 1695 while (!(net2272_read(dev, EP_STAT0) & 1696 (1 << DATA_PACKET_TRANSMITTED_INTERRUPT))) 1697 ; 1698 1699 /* Enable test mode */ 1700 net2272_write(dev, USBTEST, mode); 1701 1702 /* load test packet */ 1703 if (mode == USB_TEST_PACKET) { 1704 /* switch to 8 bit mode */ 1705 net2272_write(dev, LOCCTL, net2272_read(dev, LOCCTL) & 1706 ~(1 << DATA_WIDTH)); 1707 1708 for (i = 0; i < sizeof(net2272_test_packet); ++i) 1709 net2272_write(dev, EP_DATA, net2272_test_packet[i]); 1710 1711 /* Validate test packet */ 1712 net2272_write(dev, EP_TRANSFER0, 0); 1713 } 1714 } 1715 1716 static void 1717 net2272_handle_stat0_irqs(struct net2272 *dev, u8 stat) 1718 { 1719 struct net2272_ep *ep; 1720 u8 num, scratch; 1721 1722 /* starting a control request? */ 1723 if (unlikely(stat & (1 << SETUP_PACKET_INTERRUPT))) { 1724 union { 1725 u8 raw[8]; 1726 struct usb_ctrlrequest r; 1727 } u; 1728 int tmp = 0; 1729 struct net2272_request *req; 1730 1731 if (dev->gadget.speed == USB_SPEED_UNKNOWN) { 1732 if (net2272_read(dev, USBCTL1) & (1 << USB_HIGH_SPEED)) 1733 dev->gadget.speed = USB_SPEED_HIGH; 1734 else 1735 dev->gadget.speed = USB_SPEED_FULL; 1736 dev_dbg(dev->dev, "%s\n", 1737 usb_speed_string(dev->gadget.speed)); 1738 } 1739 1740 ep = &dev->ep[0]; 1741 ep->irqs++; 1742 1743 /* make sure any leftover interrupt state is cleared */ 1744 stat &= ~(1 << ENDPOINT_0_INTERRUPT); 1745 while (!list_empty(&ep->queue)) { 1746 req = list_entry(ep->queue.next, 1747 struct net2272_request, queue); 1748 net2272_done(ep, req, 1749 (req->req.actual == req->req.length) ? 0 : -EPROTO); 1750 } 1751 ep->stopped = 0; 1752 dev->protocol_stall = 0; 1753 net2272_ep_write(ep, EP_STAT0, 1754 (1 << DATA_IN_TOKEN_INTERRUPT) 1755 | (1 << DATA_OUT_TOKEN_INTERRUPT) 1756 | (1 << DATA_PACKET_TRANSMITTED_INTERRUPT) 1757 | (1 << DATA_PACKET_RECEIVED_INTERRUPT) 1758 | (1 << SHORT_PACKET_TRANSFERRED_INTERRUPT)); 1759 net2272_ep_write(ep, EP_STAT1, 1760 (1 << TIMEOUT) 1761 | (1 << USB_OUT_ACK_SENT) 1762 | (1 << USB_OUT_NAK_SENT) 1763 | (1 << USB_IN_ACK_RCVD) 1764 | (1 << USB_IN_NAK_SENT) 1765 | (1 << USB_STALL_SENT) 1766 | (1 << LOCAL_OUT_ZLP)); 1767 1768 /* 1769 * Ensure Control Read pre-validation setting is beyond maximum size 1770 * - Control Writes can leave non-zero values in EP_TRANSFER. If 1771 * an EP0 transfer following the Control Write is a Control Read, 1772 * the NET2272 sees the non-zero EP_TRANSFER as an unexpected 1773 * pre-validation count. 1774 * - Setting EP_TRANSFER beyond the maximum EP0 transfer size ensures 1775 * the pre-validation count cannot cause an unexpected validatation 1776 */ 1777 net2272_write(dev, PAGESEL, 0); 1778 net2272_write(dev, EP_TRANSFER2, 0xff); 1779 net2272_write(dev, EP_TRANSFER1, 0xff); 1780 net2272_write(dev, EP_TRANSFER0, 0xff); 1781 1782 u.raw[0] = net2272_read(dev, SETUP0); 1783 u.raw[1] = net2272_read(dev, SETUP1); 1784 u.raw[2] = net2272_read(dev, SETUP2); 1785 u.raw[3] = net2272_read(dev, SETUP3); 1786 u.raw[4] = net2272_read(dev, SETUP4); 1787 u.raw[5] = net2272_read(dev, SETUP5); 1788 u.raw[6] = net2272_read(dev, SETUP6); 1789 u.raw[7] = net2272_read(dev, SETUP7); 1790 /* 1791 * If you have a big endian cpu make sure le16_to_cpus 1792 * performs the proper byte swapping here... 1793 */ 1794 le16_to_cpus(&u.r.wValue); 1795 le16_to_cpus(&u.r.wIndex); 1796 le16_to_cpus(&u.r.wLength); 1797 1798 /* ack the irq */ 1799 net2272_write(dev, IRQSTAT0, 1 << SETUP_PACKET_INTERRUPT); 1800 stat ^= (1 << SETUP_PACKET_INTERRUPT); 1801 1802 /* watch control traffic at the token level, and force 1803 * synchronization before letting the status phase happen. 1804 */ 1805 ep->is_in = (u.r.bRequestType & USB_DIR_IN) != 0; 1806 if (ep->is_in) { 1807 scratch = (1 << DATA_PACKET_TRANSMITTED_INTERRUPT_ENABLE) 1808 | (1 << DATA_OUT_TOKEN_INTERRUPT_ENABLE) 1809 | (1 << DATA_IN_TOKEN_INTERRUPT_ENABLE); 1810 stop_out_naking(ep); 1811 } else 1812 scratch = (1 << DATA_PACKET_RECEIVED_INTERRUPT_ENABLE) 1813 | (1 << DATA_OUT_TOKEN_INTERRUPT_ENABLE) 1814 | (1 << DATA_IN_TOKEN_INTERRUPT_ENABLE); 1815 net2272_ep_write(ep, EP_IRQENB, scratch); 1816 1817 if ((u.r.bRequestType & USB_TYPE_MASK) != USB_TYPE_STANDARD) 1818 goto delegate; 1819 switch (u.r.bRequest) { 1820 case USB_REQ_GET_STATUS: { 1821 struct net2272_ep *e; 1822 u16 status = 0; 1823 1824 switch (u.r.bRequestType & USB_RECIP_MASK) { 1825 case USB_RECIP_ENDPOINT: 1826 e = net2272_get_ep_by_addr(dev, u.r.wIndex); 1827 if (!e || u.r.wLength > 2) 1828 goto do_stall; 1829 if (net2272_ep_read(e, EP_RSPSET) & (1 << ENDPOINT_HALT)) 1830 status = cpu_to_le16(1); 1831 else 1832 status = cpu_to_le16(0); 1833 1834 /* don't bother with a request object! */ 1835 net2272_ep_write(&dev->ep[0], EP_IRQENB, 0); 1836 writew(status, net2272_reg_addr(dev, EP_DATA)); 1837 set_fifo_bytecount(&dev->ep[0], 0); 1838 allow_status(ep); 1839 dev_vdbg(dev->dev, "%s stat %02x\n", 1840 ep->ep.name, status); 1841 goto next_endpoints; 1842 case USB_RECIP_DEVICE: 1843 if (u.r.wLength > 2) 1844 goto do_stall; 1845 if (dev->gadget.is_selfpowered) 1846 status = (1 << USB_DEVICE_SELF_POWERED); 1847 1848 /* don't bother with a request object! */ 1849 net2272_ep_write(&dev->ep[0], EP_IRQENB, 0); 1850 writew(status, net2272_reg_addr(dev, EP_DATA)); 1851 set_fifo_bytecount(&dev->ep[0], 0); 1852 allow_status(ep); 1853 dev_vdbg(dev->dev, "device stat %02x\n", status); 1854 goto next_endpoints; 1855 case USB_RECIP_INTERFACE: 1856 if (u.r.wLength > 2) 1857 goto do_stall; 1858 1859 /* don't bother with a request object! */ 1860 net2272_ep_write(&dev->ep[0], EP_IRQENB, 0); 1861 writew(status, net2272_reg_addr(dev, EP_DATA)); 1862 set_fifo_bytecount(&dev->ep[0], 0); 1863 allow_status(ep); 1864 dev_vdbg(dev->dev, "interface status %02x\n", status); 1865 goto next_endpoints; 1866 } 1867 1868 break; 1869 } 1870 case USB_REQ_CLEAR_FEATURE: { 1871 struct net2272_ep *e; 1872 1873 if (u.r.bRequestType != USB_RECIP_ENDPOINT) 1874 goto delegate; 1875 if (u.r.wValue != USB_ENDPOINT_HALT || 1876 u.r.wLength != 0) 1877 goto do_stall; 1878 e = net2272_get_ep_by_addr(dev, u.r.wIndex); 1879 if (!e) 1880 goto do_stall; 1881 if (e->wedged) { 1882 dev_vdbg(dev->dev, "%s wedged, halt not cleared\n", 1883 ep->ep.name); 1884 } else { 1885 dev_vdbg(dev->dev, "%s clear halt\n", ep->ep.name); 1886 clear_halt(e); 1887 } 1888 allow_status(ep); 1889 goto next_endpoints; 1890 } 1891 case USB_REQ_SET_FEATURE: { 1892 struct net2272_ep *e; 1893 1894 if (u.r.bRequestType == USB_RECIP_DEVICE) { 1895 if (u.r.wIndex != NORMAL_OPERATION) 1896 net2272_set_test_mode(dev, (u.r.wIndex >> 8)); 1897 allow_status(ep); 1898 dev_vdbg(dev->dev, "test mode: %d\n", u.r.wIndex); 1899 goto next_endpoints; 1900 } else if (u.r.bRequestType != USB_RECIP_ENDPOINT) 1901 goto delegate; 1902 if (u.r.wValue != USB_ENDPOINT_HALT || 1903 u.r.wLength != 0) 1904 goto do_stall; 1905 e = net2272_get_ep_by_addr(dev, u.r.wIndex); 1906 if (!e) 1907 goto do_stall; 1908 set_halt(e); 1909 allow_status(ep); 1910 dev_vdbg(dev->dev, "%s set halt\n", ep->ep.name); 1911 goto next_endpoints; 1912 } 1913 case USB_REQ_SET_ADDRESS: { 1914 net2272_write(dev, OURADDR, u.r.wValue & 0xff); 1915 allow_status(ep); 1916 break; 1917 } 1918 default: 1919 delegate: 1920 dev_vdbg(dev->dev, "setup %02x.%02x v%04x i%04x " 1921 "ep_cfg %08x\n", 1922 u.r.bRequestType, u.r.bRequest, 1923 u.r.wValue, u.r.wIndex, 1924 net2272_ep_read(ep, EP_CFG)); 1925 if (dev->async_callbacks) { 1926 spin_unlock(&dev->lock); 1927 tmp = dev->driver->setup(&dev->gadget, &u.r); 1928 spin_lock(&dev->lock); 1929 } 1930 } 1931 1932 /* stall ep0 on error */ 1933 if (tmp < 0) { 1934 do_stall: 1935 dev_vdbg(dev->dev, "req %02x.%02x protocol STALL; stat %d\n", 1936 u.r.bRequestType, u.r.bRequest, tmp); 1937 dev->protocol_stall = 1; 1938 } 1939 /* endpoint dma irq? */ 1940 } else if (stat & (1 << DMA_DONE_INTERRUPT)) { 1941 net2272_cancel_dma(dev); 1942 net2272_write(dev, IRQSTAT0, 1 << DMA_DONE_INTERRUPT); 1943 stat &= ~(1 << DMA_DONE_INTERRUPT); 1944 num = (net2272_read(dev, DMAREQ) & (1 << DMA_ENDPOINT_SELECT)) 1945 ? 2 : 1; 1946 1947 ep = &dev->ep[num]; 1948 net2272_handle_dma(ep); 1949 } 1950 1951 next_endpoints: 1952 /* endpoint data irq? */ 1953 scratch = stat & 0x0f; 1954 stat &= ~0x0f; 1955 for (num = 0; scratch; num++) { 1956 u8 t; 1957 1958 /* does this endpoint's FIFO and queue need tending? */ 1959 t = 1 << num; 1960 if ((scratch & t) == 0) 1961 continue; 1962 scratch ^= t; 1963 1964 ep = &dev->ep[num]; 1965 net2272_handle_ep(ep); 1966 } 1967 1968 /* some interrupts we can just ignore */ 1969 stat &= ~(1 << SOF_INTERRUPT); 1970 1971 if (stat) 1972 dev_dbg(dev->dev, "unhandled irqstat0 %02x\n", stat); 1973 } 1974 1975 static void 1976 net2272_handle_stat1_irqs(struct net2272 *dev, u8 stat) 1977 { 1978 u8 tmp, mask; 1979 1980 /* after disconnect there's nothing else to do! */ 1981 tmp = (1 << VBUS_INTERRUPT) | (1 << ROOT_PORT_RESET_INTERRUPT); 1982 mask = (1 << USB_HIGH_SPEED) | (1 << USB_FULL_SPEED); 1983 1984 if (stat & tmp) { 1985 bool reset = false; 1986 bool disconnect = false; 1987 1988 /* 1989 * Ignore disconnects and resets if the speed hasn't been set. 1990 * VBUS can bounce and there's always an initial reset. 1991 */ 1992 net2272_write(dev, IRQSTAT1, tmp); 1993 if (dev->gadget.speed != USB_SPEED_UNKNOWN) { 1994 if ((stat & (1 << VBUS_INTERRUPT)) && 1995 (net2272_read(dev, USBCTL1) & 1996 (1 << VBUS_PIN)) == 0) { 1997 disconnect = true; 1998 dev_dbg(dev->dev, "disconnect %s\n", 1999 dev->driver->driver.name); 2000 } else if ((stat & (1 << ROOT_PORT_RESET_INTERRUPT)) && 2001 (net2272_read(dev, USBCTL1) & mask) 2002 == 0) { 2003 reset = true; 2004 dev_dbg(dev->dev, "reset %s\n", 2005 dev->driver->driver.name); 2006 } 2007 2008 if (disconnect || reset) { 2009 stop_activity(dev, dev->driver); 2010 net2272_ep0_start(dev); 2011 if (dev->async_callbacks) { 2012 spin_unlock(&dev->lock); 2013 if (reset) 2014 usb_gadget_udc_reset(&dev->gadget, dev->driver); 2015 else 2016 (dev->driver->disconnect)(&dev->gadget); 2017 spin_lock(&dev->lock); 2018 } 2019 return; 2020 } 2021 } 2022 stat &= ~tmp; 2023 2024 if (!stat) 2025 return; 2026 } 2027 2028 tmp = (1 << SUSPEND_REQUEST_CHANGE_INTERRUPT); 2029 if (stat & tmp) { 2030 net2272_write(dev, IRQSTAT1, tmp); 2031 if (stat & (1 << SUSPEND_REQUEST_INTERRUPT)) { 2032 if (dev->async_callbacks && dev->driver->suspend) 2033 dev->driver->suspend(&dev->gadget); 2034 if (!enable_suspend) { 2035 stat &= ~(1 << SUSPEND_REQUEST_INTERRUPT); 2036 dev_dbg(dev->dev, "Suspend disabled, ignoring\n"); 2037 } 2038 } else { 2039 if (dev->async_callbacks && dev->driver->resume) 2040 dev->driver->resume(&dev->gadget); 2041 } 2042 stat &= ~tmp; 2043 } 2044 2045 /* clear any other status/irqs */ 2046 if (stat) 2047 net2272_write(dev, IRQSTAT1, stat); 2048 2049 /* some status we can just ignore */ 2050 stat &= ~((1 << CONTROL_STATUS_INTERRUPT) 2051 | (1 << SUSPEND_REQUEST_INTERRUPT) 2052 | (1 << RESUME_INTERRUPT)); 2053 if (!stat) 2054 return; 2055 else 2056 dev_dbg(dev->dev, "unhandled irqstat1 %02x\n", stat); 2057 } 2058 2059 static irqreturn_t net2272_irq(int irq, void *_dev) 2060 { 2061 struct net2272 *dev = _dev; 2062 #if defined(PLX_PCI_RDK) || defined(PLX_PCI_RDK2) 2063 u32 intcsr; 2064 #endif 2065 #if defined(PLX_PCI_RDK) 2066 u8 dmareq; 2067 #endif 2068 spin_lock(&dev->lock); 2069 #if defined(PLX_PCI_RDK) 2070 intcsr = readl(dev->rdk1.plx9054_base_addr + INTCSR); 2071 2072 if ((intcsr & LOCAL_INTERRUPT_TEST) == LOCAL_INTERRUPT_TEST) { 2073 writel(intcsr & ~(1 << PCI_INTERRUPT_ENABLE), 2074 dev->rdk1.plx9054_base_addr + INTCSR); 2075 net2272_handle_stat1_irqs(dev, net2272_read(dev, IRQSTAT1)); 2076 net2272_handle_stat0_irqs(dev, net2272_read(dev, IRQSTAT0)); 2077 intcsr = readl(dev->rdk1.plx9054_base_addr + INTCSR); 2078 writel(intcsr | (1 << PCI_INTERRUPT_ENABLE), 2079 dev->rdk1.plx9054_base_addr + INTCSR); 2080 } 2081 if ((intcsr & DMA_CHANNEL_0_TEST) == DMA_CHANNEL_0_TEST) { 2082 writeb((1 << CHANNEL_CLEAR_INTERRUPT | (0 << CHANNEL_ENABLE)), 2083 dev->rdk1.plx9054_base_addr + DMACSR0); 2084 2085 dmareq = net2272_read(dev, DMAREQ); 2086 if (dmareq & 0x01) 2087 net2272_handle_dma(&dev->ep[2]); 2088 else 2089 net2272_handle_dma(&dev->ep[1]); 2090 } 2091 #endif 2092 #if defined(PLX_PCI_RDK2) 2093 /* see if PCI int for us by checking irqstat */ 2094 intcsr = readl(dev->rdk2.fpga_base_addr + RDK2_IRQSTAT); 2095 if (!(intcsr & (1 << NET2272_PCI_IRQ))) { 2096 spin_unlock(&dev->lock); 2097 return IRQ_NONE; 2098 } 2099 /* check dma interrupts */ 2100 #endif 2101 /* Platform/devcice interrupt handler */ 2102 #if !defined(PLX_PCI_RDK) 2103 net2272_handle_stat1_irqs(dev, net2272_read(dev, IRQSTAT1)); 2104 net2272_handle_stat0_irqs(dev, net2272_read(dev, IRQSTAT0)); 2105 #endif 2106 spin_unlock(&dev->lock); 2107 2108 return IRQ_HANDLED; 2109 } 2110 2111 static int net2272_present(struct net2272 *dev) 2112 { 2113 /* 2114 * Quick test to see if CPU can communicate properly with the NET2272. 2115 * Verifies connection using writes and reads to write/read and 2116 * read-only registers. 2117 * 2118 * This routine is strongly recommended especially during early bring-up 2119 * of new hardware, however for designs that do not apply Power On System 2120 * Tests (POST) it may discarded (or perhaps minimized). 2121 */ 2122 unsigned int ii; 2123 u8 val, refval; 2124 2125 /* Verify NET2272 write/read SCRATCH register can write and read */ 2126 refval = net2272_read(dev, SCRATCH); 2127 for (ii = 0; ii < 0x100; ii += 7) { 2128 net2272_write(dev, SCRATCH, ii); 2129 val = net2272_read(dev, SCRATCH); 2130 if (val != ii) { 2131 dev_dbg(dev->dev, 2132 "%s: write/read SCRATCH register test failed: " 2133 "wrote:0x%2.2x, read:0x%2.2x\n", 2134 __func__, ii, val); 2135 return -EINVAL; 2136 } 2137 } 2138 /* To be nice, we write the original SCRATCH value back: */ 2139 net2272_write(dev, SCRATCH, refval); 2140 2141 /* Verify NET2272 CHIPREV register is read-only: */ 2142 refval = net2272_read(dev, CHIPREV_2272); 2143 for (ii = 0; ii < 0x100; ii += 7) { 2144 net2272_write(dev, CHIPREV_2272, ii); 2145 val = net2272_read(dev, CHIPREV_2272); 2146 if (val != refval) { 2147 dev_dbg(dev->dev, 2148 "%s: write/read CHIPREV register test failed: " 2149 "wrote 0x%2.2x, read:0x%2.2x expected:0x%2.2x\n", 2150 __func__, ii, val, refval); 2151 return -EINVAL; 2152 } 2153 } 2154 2155 /* 2156 * Verify NET2272's "NET2270 legacy revision" register 2157 * - NET2272 has two revision registers. The NET2270 legacy revision 2158 * register should read the same value, regardless of the NET2272 2159 * silicon revision. The legacy register applies to NET2270 2160 * firmware being applied to the NET2272. 2161 */ 2162 val = net2272_read(dev, CHIPREV_LEGACY); 2163 if (val != NET2270_LEGACY_REV) { 2164 /* 2165 * Unexpected legacy revision value 2166 * - Perhaps the chip is a NET2270? 2167 */ 2168 dev_dbg(dev->dev, 2169 "%s: WARNING: UNEXPECTED NET2272 LEGACY REGISTER VALUE:\n" 2170 " - CHIPREV_LEGACY: expected 0x%2.2x, got:0x%2.2x. (Not NET2272?)\n", 2171 __func__, NET2270_LEGACY_REV, val); 2172 return -EINVAL; 2173 } 2174 2175 /* 2176 * Verify NET2272 silicon revision 2177 * - This revision register is appropriate for the silicon version 2178 * of the NET2272 2179 */ 2180 val = net2272_read(dev, CHIPREV_2272); 2181 switch (val) { 2182 case CHIPREV_NET2272_R1: 2183 /* 2184 * NET2272 Rev 1 has DMA related errata: 2185 * - Newer silicon (Rev 1A or better) required 2186 */ 2187 dev_dbg(dev->dev, 2188 "%s: Rev 1 detected: newer silicon recommended for DMA support\n", 2189 __func__); 2190 break; 2191 case CHIPREV_NET2272_R1A: 2192 break; 2193 default: 2194 /* NET2272 silicon version *may* not work with this firmware */ 2195 dev_dbg(dev->dev, 2196 "%s: unexpected silicon revision register value: " 2197 " CHIPREV_2272: 0x%2.2x\n", 2198 __func__, val); 2199 /* 2200 * Return Success, even though the chip rev is not an expected value 2201 * - Older, pre-built firmware can attempt to operate on newer silicon 2202 * - Often, new silicon is perfectly compatible 2203 */ 2204 } 2205 2206 /* Success: NET2272 checks out OK */ 2207 return 0; 2208 } 2209 2210 static void 2211 net2272_gadget_release(struct device *_dev) 2212 { 2213 struct net2272 *dev = container_of(_dev, struct net2272, gadget.dev); 2214 2215 kfree(dev); 2216 } 2217 2218 /*---------------------------------------------------------------------------*/ 2219 2220 static void 2221 net2272_remove(struct net2272 *dev) 2222 { 2223 if (dev->added) 2224 usb_del_gadget(&dev->gadget); 2225 free_irq(dev->irq, dev); 2226 iounmap(dev->base_addr); 2227 device_remove_file(dev->dev, &dev_attr_registers); 2228 2229 dev_info(dev->dev, "unbind\n"); 2230 } 2231 2232 static struct net2272 *net2272_probe_init(struct device *dev, unsigned int irq) 2233 { 2234 struct net2272 *ret; 2235 2236 if (!irq) { 2237 dev_dbg(dev, "No IRQ!\n"); 2238 return ERR_PTR(-ENODEV); 2239 } 2240 2241 /* alloc, and start init */ 2242 ret = kzalloc(sizeof(*ret), GFP_KERNEL); 2243 if (!ret) 2244 return ERR_PTR(-ENOMEM); 2245 2246 spin_lock_init(&ret->lock); 2247 ret->irq = irq; 2248 ret->dev = dev; 2249 ret->gadget.ops = &net2272_ops; 2250 ret->gadget.max_speed = USB_SPEED_HIGH; 2251 2252 /* the "gadget" abstracts/virtualizes the controller */ 2253 ret->gadget.name = driver_name; 2254 usb_initialize_gadget(dev, &ret->gadget, net2272_gadget_release); 2255 2256 return ret; 2257 } 2258 2259 static int 2260 net2272_probe_fin(struct net2272 *dev, unsigned int irqflags) 2261 { 2262 int ret; 2263 2264 /* See if there... */ 2265 if (net2272_present(dev)) { 2266 dev_warn(dev->dev, "2272 not found!\n"); 2267 ret = -ENODEV; 2268 goto err; 2269 } 2270 2271 net2272_usb_reset(dev); 2272 net2272_usb_reinit(dev); 2273 2274 ret = request_irq(dev->irq, net2272_irq, irqflags, driver_name, dev); 2275 if (ret) { 2276 dev_err(dev->dev, "request interrupt %i failed\n", dev->irq); 2277 goto err; 2278 } 2279 2280 dev->chiprev = net2272_read(dev, CHIPREV_2272); 2281 2282 /* done */ 2283 dev_info(dev->dev, "%s\n", driver_desc); 2284 dev_info(dev->dev, "irq %i, mem %p, chip rev %04x, dma %s\n", 2285 dev->irq, dev->base_addr, dev->chiprev, 2286 dma_mode_string()); 2287 dev_info(dev->dev, "version: %s\n", driver_vers); 2288 2289 ret = device_create_file(dev->dev, &dev_attr_registers); 2290 if (ret) 2291 goto err_irq; 2292 2293 ret = usb_add_gadget(&dev->gadget); 2294 if (ret) 2295 goto err_add_udc; 2296 dev->added = 1; 2297 2298 return 0; 2299 2300 err_add_udc: 2301 device_remove_file(dev->dev, &dev_attr_registers); 2302 err_irq: 2303 free_irq(dev->irq, dev); 2304 err: 2305 return ret; 2306 } 2307 2308 #ifdef CONFIG_USB_PCI 2309 2310 /* 2311 * wrap this driver around the specified device, but 2312 * don't respond over USB until a gadget driver binds to us 2313 */ 2314 2315 static int 2316 net2272_rdk1_probe(struct pci_dev *pdev, struct net2272 *dev) 2317 { 2318 unsigned long resource, len, tmp; 2319 void __iomem *mem_mapped_addr[4]; 2320 int ret, i; 2321 2322 /* 2323 * BAR 0 holds PLX 9054 config registers 2324 * BAR 1 is i/o memory; unused here 2325 * BAR 2 holds EPLD config registers 2326 * BAR 3 holds NET2272 registers 2327 */ 2328 2329 /* Find and map all address spaces */ 2330 for (i = 0; i < 4; ++i) { 2331 if (i == 1) 2332 continue; /* BAR1 unused */ 2333 2334 resource = pci_resource_start(pdev, i); 2335 len = pci_resource_len(pdev, i); 2336 2337 if (!request_mem_region(resource, len, driver_name)) { 2338 dev_dbg(dev->dev, "controller already in use\n"); 2339 ret = -EBUSY; 2340 goto err; 2341 } 2342 2343 mem_mapped_addr[i] = ioremap(resource, len); 2344 if (mem_mapped_addr[i] == NULL) { 2345 release_mem_region(resource, len); 2346 dev_dbg(dev->dev, "can't map memory\n"); 2347 ret = -EFAULT; 2348 goto err; 2349 } 2350 } 2351 2352 dev->rdk1.plx9054_base_addr = mem_mapped_addr[0]; 2353 dev->rdk1.epld_base_addr = mem_mapped_addr[2]; 2354 dev->base_addr = mem_mapped_addr[3]; 2355 2356 /* Set PLX 9054 bus width (16 bits) */ 2357 tmp = readl(dev->rdk1.plx9054_base_addr + LBRD1); 2358 writel((tmp & ~(3 << MEMORY_SPACE_LOCAL_BUS_WIDTH)) | W16_BIT, 2359 dev->rdk1.plx9054_base_addr + LBRD1); 2360 2361 /* Enable PLX 9054 Interrupts */ 2362 writel(readl(dev->rdk1.plx9054_base_addr + INTCSR) | 2363 (1 << PCI_INTERRUPT_ENABLE) | 2364 (1 << LOCAL_INTERRUPT_INPUT_ENABLE), 2365 dev->rdk1.plx9054_base_addr + INTCSR); 2366 2367 writeb((1 << CHANNEL_CLEAR_INTERRUPT | (0 << CHANNEL_ENABLE)), 2368 dev->rdk1.plx9054_base_addr + DMACSR0); 2369 2370 /* reset */ 2371 writeb((1 << EPLD_DMA_ENABLE) | 2372 (1 << DMA_CTL_DACK) | 2373 (1 << DMA_TIMEOUT_ENABLE) | 2374 (1 << USER) | 2375 (0 << MPX_MODE) | 2376 (1 << BUSWIDTH) | 2377 (1 << NET2272_RESET), 2378 dev->base_addr + EPLD_IO_CONTROL_REGISTER); 2379 2380 mb(); 2381 writeb(readb(dev->base_addr + EPLD_IO_CONTROL_REGISTER) & 2382 ~(1 << NET2272_RESET), 2383 dev->base_addr + EPLD_IO_CONTROL_REGISTER); 2384 udelay(200); 2385 2386 return 0; 2387 2388 err: 2389 while (--i >= 0) { 2390 if (i == 1) 2391 continue; /* BAR1 unused */ 2392 iounmap(mem_mapped_addr[i]); 2393 release_mem_region(pci_resource_start(pdev, i), 2394 pci_resource_len(pdev, i)); 2395 } 2396 2397 return ret; 2398 } 2399 2400 static int 2401 net2272_rdk2_probe(struct pci_dev *pdev, struct net2272 *dev) 2402 { 2403 unsigned long resource, len; 2404 void __iomem *mem_mapped_addr[2]; 2405 int ret, i; 2406 2407 /* 2408 * BAR 0 holds FGPA config registers 2409 * BAR 1 holds NET2272 registers 2410 */ 2411 2412 /* Find and map all address spaces, bar2-3 unused in rdk 2 */ 2413 for (i = 0; i < 2; ++i) { 2414 resource = pci_resource_start(pdev, i); 2415 len = pci_resource_len(pdev, i); 2416 2417 if (!request_mem_region(resource, len, driver_name)) { 2418 dev_dbg(dev->dev, "controller already in use\n"); 2419 ret = -EBUSY; 2420 goto err; 2421 } 2422 2423 mem_mapped_addr[i] = ioremap(resource, len); 2424 if (mem_mapped_addr[i] == NULL) { 2425 release_mem_region(resource, len); 2426 dev_dbg(dev->dev, "can't map memory\n"); 2427 ret = -EFAULT; 2428 goto err; 2429 } 2430 } 2431 2432 dev->rdk2.fpga_base_addr = mem_mapped_addr[0]; 2433 dev->base_addr = mem_mapped_addr[1]; 2434 2435 mb(); 2436 /* Set 2272 bus width (16 bits) and reset */ 2437 writel((1 << CHIP_RESET), dev->rdk2.fpga_base_addr + RDK2_LOCCTLRDK); 2438 udelay(200); 2439 writel((1 << BUS_WIDTH), dev->rdk2.fpga_base_addr + RDK2_LOCCTLRDK); 2440 /* Print fpga version number */ 2441 dev_info(dev->dev, "RDK2 FPGA version %08x\n", 2442 readl(dev->rdk2.fpga_base_addr + RDK2_FPGAREV)); 2443 /* Enable FPGA Interrupts */ 2444 writel((1 << NET2272_PCI_IRQ), dev->rdk2.fpga_base_addr + RDK2_IRQENB); 2445 2446 return 0; 2447 2448 err: 2449 while (--i >= 0) { 2450 iounmap(mem_mapped_addr[i]); 2451 release_mem_region(pci_resource_start(pdev, i), 2452 pci_resource_len(pdev, i)); 2453 } 2454 2455 return ret; 2456 } 2457 2458 static int 2459 net2272_pci_probe(struct pci_dev *pdev, const struct pci_device_id *id) 2460 { 2461 struct net2272 *dev; 2462 int ret; 2463 2464 dev = net2272_probe_init(&pdev->dev, pdev->irq); 2465 if (IS_ERR(dev)) 2466 return PTR_ERR(dev); 2467 dev->dev_id = pdev->device; 2468 2469 if (pci_enable_device(pdev) < 0) { 2470 ret = -ENODEV; 2471 goto err_put; 2472 } 2473 2474 pci_set_master(pdev); 2475 2476 switch (pdev->device) { 2477 case PCI_DEVICE_ID_RDK1: ret = net2272_rdk1_probe(pdev, dev); break; 2478 case PCI_DEVICE_ID_RDK2: ret = net2272_rdk2_probe(pdev, dev); break; 2479 default: BUG(); 2480 } 2481 if (ret) 2482 goto err_pci; 2483 2484 ret = net2272_probe_fin(dev, 0); 2485 if (ret) 2486 goto err_pci; 2487 2488 pci_set_drvdata(pdev, dev); 2489 2490 return 0; 2491 2492 err_pci: 2493 pci_disable_device(pdev); 2494 err_put: 2495 usb_put_gadget(&dev->gadget); 2496 2497 return ret; 2498 } 2499 2500 static void 2501 net2272_rdk1_remove(struct pci_dev *pdev, struct net2272 *dev) 2502 { 2503 int i; 2504 2505 /* disable PLX 9054 interrupts */ 2506 writel(readl(dev->rdk1.plx9054_base_addr + INTCSR) & 2507 ~(1 << PCI_INTERRUPT_ENABLE), 2508 dev->rdk1.plx9054_base_addr + INTCSR); 2509 2510 /* clean up resources allocated during probe() */ 2511 iounmap(dev->rdk1.plx9054_base_addr); 2512 iounmap(dev->rdk1.epld_base_addr); 2513 2514 for (i = 0; i < 4; ++i) { 2515 if (i == 1) 2516 continue; /* BAR1 unused */ 2517 release_mem_region(pci_resource_start(pdev, i), 2518 pci_resource_len(pdev, i)); 2519 } 2520 } 2521 2522 static void 2523 net2272_rdk2_remove(struct pci_dev *pdev, struct net2272 *dev) 2524 { 2525 int i; 2526 2527 /* disable fpga interrupts 2528 writel(readl(dev->rdk1.plx9054_base_addr + INTCSR) & 2529 ~(1 << PCI_INTERRUPT_ENABLE), 2530 dev->rdk1.plx9054_base_addr + INTCSR); 2531 */ 2532 2533 /* clean up resources allocated during probe() */ 2534 iounmap(dev->rdk2.fpga_base_addr); 2535 2536 for (i = 0; i < 2; ++i) 2537 release_mem_region(pci_resource_start(pdev, i), 2538 pci_resource_len(pdev, i)); 2539 } 2540 2541 static void 2542 net2272_pci_remove(struct pci_dev *pdev) 2543 { 2544 struct net2272 *dev = pci_get_drvdata(pdev); 2545 2546 net2272_remove(dev); 2547 2548 switch (pdev->device) { 2549 case PCI_DEVICE_ID_RDK1: net2272_rdk1_remove(pdev, dev); break; 2550 case PCI_DEVICE_ID_RDK2: net2272_rdk2_remove(pdev, dev); break; 2551 default: BUG(); 2552 } 2553 2554 pci_disable_device(pdev); 2555 2556 usb_put_gadget(&dev->gadget); 2557 } 2558 2559 /* Table of matching PCI IDs */ 2560 static struct pci_device_id pci_ids[] = { 2561 { /* RDK 1 card */ 2562 .class = ((PCI_CLASS_BRIDGE_OTHER << 8) | 0xfe), 2563 .class_mask = 0, 2564 .vendor = PCI_VENDOR_ID_PLX, 2565 .device = PCI_DEVICE_ID_RDK1, 2566 .subvendor = PCI_ANY_ID, 2567 .subdevice = PCI_ANY_ID, 2568 }, 2569 { /* RDK 2 card */ 2570 .class = ((PCI_CLASS_BRIDGE_OTHER << 8) | 0xfe), 2571 .class_mask = 0, 2572 .vendor = PCI_VENDOR_ID_PLX, 2573 .device = PCI_DEVICE_ID_RDK2, 2574 .subvendor = PCI_ANY_ID, 2575 .subdevice = PCI_ANY_ID, 2576 }, 2577 { } 2578 }; 2579 MODULE_DEVICE_TABLE(pci, pci_ids); 2580 2581 static struct pci_driver net2272_pci_driver = { 2582 .name = driver_name, 2583 .id_table = pci_ids, 2584 2585 .probe = net2272_pci_probe, 2586 .remove = net2272_pci_remove, 2587 }; 2588 2589 static int net2272_pci_register(void) 2590 { 2591 return pci_register_driver(&net2272_pci_driver); 2592 } 2593 2594 static void net2272_pci_unregister(void) 2595 { 2596 pci_unregister_driver(&net2272_pci_driver); 2597 } 2598 2599 #else 2600 static inline int net2272_pci_register(void) { return 0; } 2601 static inline void net2272_pci_unregister(void) { } 2602 #endif 2603 2604 /*---------------------------------------------------------------------------*/ 2605 2606 static int 2607 net2272_plat_probe(struct platform_device *pdev) 2608 { 2609 struct net2272 *dev; 2610 int ret; 2611 unsigned int irqflags; 2612 resource_size_t base, len; 2613 struct resource *iomem, *iomem_bus, *irq_res; 2614 2615 irq_res = platform_get_resource(pdev, IORESOURCE_IRQ, 0); 2616 iomem = platform_get_resource(pdev, IORESOURCE_MEM, 0); 2617 iomem_bus = platform_get_resource(pdev, IORESOURCE_BUS, 0); 2618 if (!irq_res || !iomem) { 2619 dev_err(&pdev->dev, "must provide irq/base addr"); 2620 return -EINVAL; 2621 } 2622 2623 dev = net2272_probe_init(&pdev->dev, irq_res->start); 2624 if (IS_ERR(dev)) 2625 return PTR_ERR(dev); 2626 2627 irqflags = 0; 2628 if (irq_res->flags & IORESOURCE_IRQ_HIGHEDGE) 2629 irqflags |= IRQF_TRIGGER_RISING; 2630 if (irq_res->flags & IORESOURCE_IRQ_LOWEDGE) 2631 irqflags |= IRQF_TRIGGER_FALLING; 2632 if (irq_res->flags & IORESOURCE_IRQ_HIGHLEVEL) 2633 irqflags |= IRQF_TRIGGER_HIGH; 2634 if (irq_res->flags & IORESOURCE_IRQ_LOWLEVEL) 2635 irqflags |= IRQF_TRIGGER_LOW; 2636 2637 base = iomem->start; 2638 len = resource_size(iomem); 2639 if (iomem_bus) 2640 dev->base_shift = iomem_bus->start; 2641 2642 if (!request_mem_region(base, len, driver_name)) { 2643 dev_dbg(dev->dev, "get request memory region!\n"); 2644 ret = -EBUSY; 2645 goto err; 2646 } 2647 dev->base_addr = ioremap(base, len); 2648 if (!dev->base_addr) { 2649 dev_dbg(dev->dev, "can't map memory\n"); 2650 ret = -EFAULT; 2651 goto err_req; 2652 } 2653 2654 ret = net2272_probe_fin(dev, IRQF_TRIGGER_LOW); 2655 if (ret) 2656 goto err_io; 2657 2658 platform_set_drvdata(pdev, dev); 2659 dev_info(&pdev->dev, "running in 16-bit, %sbyte swap local bus mode\n", 2660 (net2272_read(dev, LOCCTL) & (1 << BYTE_SWAP)) ? "" : "no "); 2661 2662 return 0; 2663 2664 err_io: 2665 iounmap(dev->base_addr); 2666 err_req: 2667 release_mem_region(base, len); 2668 err: 2669 usb_put_gadget(&dev->gadget); 2670 2671 return ret; 2672 } 2673 2674 static int 2675 net2272_plat_remove(struct platform_device *pdev) 2676 { 2677 struct net2272 *dev = platform_get_drvdata(pdev); 2678 2679 net2272_remove(dev); 2680 2681 release_mem_region(pdev->resource[0].start, 2682 resource_size(&pdev->resource[0])); 2683 2684 usb_put_gadget(&dev->gadget); 2685 2686 return 0; 2687 } 2688 2689 static struct platform_driver net2272_plat_driver = { 2690 .probe = net2272_plat_probe, 2691 .remove = net2272_plat_remove, 2692 .driver = { 2693 .name = driver_name, 2694 }, 2695 /* FIXME .suspend, .resume */ 2696 }; 2697 MODULE_ALIAS("platform:net2272"); 2698 2699 static int __init net2272_init(void) 2700 { 2701 int ret; 2702 2703 ret = net2272_pci_register(); 2704 if (ret) 2705 return ret; 2706 ret = platform_driver_register(&net2272_plat_driver); 2707 if (ret) 2708 goto err_pci; 2709 return ret; 2710 2711 err_pci: 2712 net2272_pci_unregister(); 2713 return ret; 2714 } 2715 module_init(net2272_init); 2716 2717 static void __exit net2272_cleanup(void) 2718 { 2719 net2272_pci_unregister(); 2720 platform_driver_unregister(&net2272_plat_driver); 2721 } 2722 module_exit(net2272_cleanup); 2723 2724 MODULE_DESCRIPTION(DRIVER_DESC); 2725 MODULE_AUTHOR("PLX Technology, Inc."); 2726 MODULE_LICENSE("GPL"); 2727