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 definiton): 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 acceptible 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 seperately */ 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; 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(req, &ep->queue, queue) { 943 if (&req->req == _req) 944 break; 945 } 946 if (&req->req != _req) { 947 ep->stopped = stopped; 948 spin_unlock_irqrestore(&ep->dev->lock, flags); 949 return -EINVAL; 950 } 951 952 /* queue head may be partially complete */ 953 if (ep->queue.next == &req->queue) { 954 dev_dbg(ep->dev->dev, "unlink (%s) pio\n", _ep->name); 955 net2272_done(ep, req, -ECONNRESET); 956 } 957 req = NULL; 958 ep->stopped = stopped; 959 960 spin_unlock_irqrestore(&ep->dev->lock, flags); 961 return 0; 962 } 963 964 /*---------------------------------------------------------------------------*/ 965 966 static int 967 net2272_set_halt_and_wedge(struct usb_ep *_ep, int value, int wedged) 968 { 969 struct net2272_ep *ep; 970 unsigned long flags; 971 int ret = 0; 972 973 ep = container_of(_ep, struct net2272_ep, ep); 974 if (!_ep || (!ep->desc && ep->num != 0)) 975 return -EINVAL; 976 if (!ep->dev->driver || ep->dev->gadget.speed == USB_SPEED_UNKNOWN) 977 return -ESHUTDOWN; 978 if (ep->desc /* not ep0 */ && usb_endpoint_xfer_isoc(ep->desc)) 979 return -EINVAL; 980 981 spin_lock_irqsave(&ep->dev->lock, flags); 982 if (!list_empty(&ep->queue)) 983 ret = -EAGAIN; 984 else if (ep->is_in && value && net2272_fifo_status(_ep) != 0) 985 ret = -EAGAIN; 986 else { 987 dev_vdbg(ep->dev->dev, "%s %s %s\n", _ep->name, 988 value ? "set" : "clear", 989 wedged ? "wedge" : "halt"); 990 /* set/clear */ 991 if (value) { 992 if (ep->num == 0) 993 ep->dev->protocol_stall = 1; 994 else 995 set_halt(ep); 996 if (wedged) 997 ep->wedged = 1; 998 } else { 999 clear_halt(ep); 1000 ep->wedged = 0; 1001 } 1002 } 1003 spin_unlock_irqrestore(&ep->dev->lock, flags); 1004 1005 return ret; 1006 } 1007 1008 static int 1009 net2272_set_halt(struct usb_ep *_ep, int value) 1010 { 1011 return net2272_set_halt_and_wedge(_ep, value, 0); 1012 } 1013 1014 static int 1015 net2272_set_wedge(struct usb_ep *_ep) 1016 { 1017 if (!_ep || _ep->name == ep0name) 1018 return -EINVAL; 1019 return net2272_set_halt_and_wedge(_ep, 1, 1); 1020 } 1021 1022 static int 1023 net2272_fifo_status(struct usb_ep *_ep) 1024 { 1025 struct net2272_ep *ep; 1026 u16 avail; 1027 1028 ep = container_of(_ep, struct net2272_ep, ep); 1029 if (!_ep || (!ep->desc && ep->num != 0)) 1030 return -ENODEV; 1031 if (!ep->dev->driver || ep->dev->gadget.speed == USB_SPEED_UNKNOWN) 1032 return -ESHUTDOWN; 1033 1034 avail = net2272_ep_read(ep, EP_AVAIL1) << 8; 1035 avail |= net2272_ep_read(ep, EP_AVAIL0); 1036 if (avail > ep->fifo_size) 1037 return -EOVERFLOW; 1038 if (ep->is_in) 1039 avail = ep->fifo_size - avail; 1040 return avail; 1041 } 1042 1043 static void 1044 net2272_fifo_flush(struct usb_ep *_ep) 1045 { 1046 struct net2272_ep *ep; 1047 1048 ep = container_of(_ep, struct net2272_ep, ep); 1049 if (!_ep || (!ep->desc && ep->num != 0)) 1050 return; 1051 if (!ep->dev->driver || ep->dev->gadget.speed == USB_SPEED_UNKNOWN) 1052 return; 1053 1054 net2272_ep_write(ep, EP_STAT1, 1 << BUFFER_FLUSH); 1055 } 1056 1057 static const struct usb_ep_ops net2272_ep_ops = { 1058 .enable = net2272_enable, 1059 .disable = net2272_disable, 1060 1061 .alloc_request = net2272_alloc_request, 1062 .free_request = net2272_free_request, 1063 1064 .queue = net2272_queue, 1065 .dequeue = net2272_dequeue, 1066 1067 .set_halt = net2272_set_halt, 1068 .set_wedge = net2272_set_wedge, 1069 .fifo_status = net2272_fifo_status, 1070 .fifo_flush = net2272_fifo_flush, 1071 }; 1072 1073 /*---------------------------------------------------------------------------*/ 1074 1075 static int 1076 net2272_get_frame(struct usb_gadget *_gadget) 1077 { 1078 struct net2272 *dev; 1079 unsigned long flags; 1080 u16 ret; 1081 1082 if (!_gadget) 1083 return -ENODEV; 1084 dev = container_of(_gadget, struct net2272, gadget); 1085 spin_lock_irqsave(&dev->lock, flags); 1086 1087 ret = net2272_read(dev, FRAME1) << 8; 1088 ret |= net2272_read(dev, FRAME0); 1089 1090 spin_unlock_irqrestore(&dev->lock, flags); 1091 return ret; 1092 } 1093 1094 static int 1095 net2272_wakeup(struct usb_gadget *_gadget) 1096 { 1097 struct net2272 *dev; 1098 u8 tmp; 1099 unsigned long flags; 1100 1101 if (!_gadget) 1102 return 0; 1103 dev = container_of(_gadget, struct net2272, gadget); 1104 1105 spin_lock_irqsave(&dev->lock, flags); 1106 tmp = net2272_read(dev, USBCTL0); 1107 if (tmp & (1 << IO_WAKEUP_ENABLE)) 1108 net2272_write(dev, USBCTL1, (1 << GENERATE_RESUME)); 1109 1110 spin_unlock_irqrestore(&dev->lock, flags); 1111 1112 return 0; 1113 } 1114 1115 static int 1116 net2272_set_selfpowered(struct usb_gadget *_gadget, int value) 1117 { 1118 if (!_gadget) 1119 return -ENODEV; 1120 1121 _gadget->is_selfpowered = (value != 0); 1122 1123 return 0; 1124 } 1125 1126 static int 1127 net2272_pullup(struct usb_gadget *_gadget, int is_on) 1128 { 1129 struct net2272 *dev; 1130 u8 tmp; 1131 unsigned long flags; 1132 1133 if (!_gadget) 1134 return -ENODEV; 1135 dev = container_of(_gadget, struct net2272, gadget); 1136 1137 spin_lock_irqsave(&dev->lock, flags); 1138 tmp = net2272_read(dev, USBCTL0); 1139 dev->softconnect = (is_on != 0); 1140 if (is_on) 1141 tmp |= (1 << USB_DETECT_ENABLE); 1142 else 1143 tmp &= ~(1 << USB_DETECT_ENABLE); 1144 net2272_write(dev, USBCTL0, tmp); 1145 spin_unlock_irqrestore(&dev->lock, flags); 1146 1147 return 0; 1148 } 1149 1150 static int net2272_start(struct usb_gadget *_gadget, 1151 struct usb_gadget_driver *driver); 1152 static int net2272_stop(struct usb_gadget *_gadget); 1153 1154 static const struct usb_gadget_ops net2272_ops = { 1155 .get_frame = net2272_get_frame, 1156 .wakeup = net2272_wakeup, 1157 .set_selfpowered = net2272_set_selfpowered, 1158 .pullup = net2272_pullup, 1159 .udc_start = net2272_start, 1160 .udc_stop = net2272_stop, 1161 }; 1162 1163 /*---------------------------------------------------------------------------*/ 1164 1165 static ssize_t 1166 registers_show(struct device *_dev, struct device_attribute *attr, char *buf) 1167 { 1168 struct net2272 *dev; 1169 char *next; 1170 unsigned size, t; 1171 unsigned long flags; 1172 u8 t1, t2; 1173 int i; 1174 const char *s; 1175 1176 dev = dev_get_drvdata(_dev); 1177 next = buf; 1178 size = PAGE_SIZE; 1179 spin_lock_irqsave(&dev->lock, flags); 1180 1181 /* Main Control Registers */ 1182 t = scnprintf(next, size, "%s version %s," 1183 "chiprev %02x, locctl %02x\n" 1184 "irqenb0 %02x irqenb1 %02x " 1185 "irqstat0 %02x irqstat1 %02x\n", 1186 driver_name, driver_vers, dev->chiprev, 1187 net2272_read(dev, LOCCTL), 1188 net2272_read(dev, IRQENB0), 1189 net2272_read(dev, IRQENB1), 1190 net2272_read(dev, IRQSTAT0), 1191 net2272_read(dev, IRQSTAT1)); 1192 size -= t; 1193 next += t; 1194 1195 /* DMA */ 1196 t1 = net2272_read(dev, DMAREQ); 1197 t = scnprintf(next, size, "\ndmareq %02x: %s %s%s%s%s\n", 1198 t1, ep_name[(t1 & 0x01) + 1], 1199 t1 & (1 << DMA_CONTROL_DACK) ? "dack " : "", 1200 t1 & (1 << DMA_REQUEST_ENABLE) ? "reqenb " : "", 1201 t1 & (1 << DMA_REQUEST) ? "req " : "", 1202 t1 & (1 << DMA_BUFFER_VALID) ? "valid " : ""); 1203 size -= t; 1204 next += t; 1205 1206 /* USB Control Registers */ 1207 t1 = net2272_read(dev, USBCTL1); 1208 if (t1 & (1 << VBUS_PIN)) { 1209 if (t1 & (1 << USB_HIGH_SPEED)) 1210 s = "high speed"; 1211 else if (dev->gadget.speed == USB_SPEED_UNKNOWN) 1212 s = "powered"; 1213 else 1214 s = "full speed"; 1215 } else 1216 s = "not attached"; 1217 t = scnprintf(next, size, 1218 "usbctl0 %02x usbctl1 %02x addr 0x%02x (%s)\n", 1219 net2272_read(dev, USBCTL0), t1, 1220 net2272_read(dev, OURADDR), s); 1221 size -= t; 1222 next += t; 1223 1224 /* Endpoint Registers */ 1225 for (i = 0; i < 4; ++i) { 1226 struct net2272_ep *ep; 1227 1228 ep = &dev->ep[i]; 1229 if (i && !ep->desc) 1230 continue; 1231 1232 t1 = net2272_ep_read(ep, EP_CFG); 1233 t2 = net2272_ep_read(ep, EP_RSPSET); 1234 t = scnprintf(next, size, 1235 "\n%s\tcfg %02x rsp (%02x) %s%s%s%s%s%s%s%s" 1236 "irqenb %02x\n", 1237 ep->ep.name, t1, t2, 1238 (t2 & (1 << ALT_NAK_OUT_PACKETS)) ? "NAK " : "", 1239 (t2 & (1 << HIDE_STATUS_PHASE)) ? "hide " : "", 1240 (t2 & (1 << AUTOVALIDATE)) ? "auto " : "", 1241 (t2 & (1 << INTERRUPT_MODE)) ? "interrupt " : "", 1242 (t2 & (1 << CONTROL_STATUS_PHASE_HANDSHAKE)) ? "status " : "", 1243 (t2 & (1 << NAK_OUT_PACKETS_MODE)) ? "NAKmode " : "", 1244 (t2 & (1 << ENDPOINT_TOGGLE)) ? "DATA1 " : "DATA0 ", 1245 (t2 & (1 << ENDPOINT_HALT)) ? "HALT " : "", 1246 net2272_ep_read(ep, EP_IRQENB)); 1247 size -= t; 1248 next += t; 1249 1250 t = scnprintf(next, size, 1251 "\tstat0 %02x stat1 %02x avail %04x " 1252 "(ep%d%s-%s)%s\n", 1253 net2272_ep_read(ep, EP_STAT0), 1254 net2272_ep_read(ep, EP_STAT1), 1255 (net2272_ep_read(ep, EP_AVAIL1) << 8) | net2272_ep_read(ep, EP_AVAIL0), 1256 t1 & 0x0f, 1257 ep->is_in ? "in" : "out", 1258 type_string(t1 >> 5), 1259 ep->stopped ? "*" : ""); 1260 size -= t; 1261 next += t; 1262 1263 t = scnprintf(next, size, 1264 "\tep_transfer %06x\n", 1265 ((net2272_ep_read(ep, EP_TRANSFER2) & 0xff) << 16) | 1266 ((net2272_ep_read(ep, EP_TRANSFER1) & 0xff) << 8) | 1267 ((net2272_ep_read(ep, EP_TRANSFER0) & 0xff))); 1268 size -= t; 1269 next += t; 1270 1271 t1 = net2272_ep_read(ep, EP_BUFF_STATES) & 0x03; 1272 t2 = (net2272_ep_read(ep, EP_BUFF_STATES) >> 2) & 0x03; 1273 t = scnprintf(next, size, 1274 "\tbuf-a %s buf-b %s\n", 1275 buf_state_string(t1), 1276 buf_state_string(t2)); 1277 size -= t; 1278 next += t; 1279 } 1280 1281 spin_unlock_irqrestore(&dev->lock, flags); 1282 1283 return PAGE_SIZE - size; 1284 } 1285 static DEVICE_ATTR_RO(registers); 1286 1287 /*---------------------------------------------------------------------------*/ 1288 1289 static void 1290 net2272_set_fifo_mode(struct net2272 *dev, int mode) 1291 { 1292 u8 tmp; 1293 1294 tmp = net2272_read(dev, LOCCTL) & 0x3f; 1295 tmp |= (mode << 6); 1296 net2272_write(dev, LOCCTL, tmp); 1297 1298 INIT_LIST_HEAD(&dev->gadget.ep_list); 1299 1300 /* always ep-a, ep-c ... maybe not ep-b */ 1301 list_add_tail(&dev->ep[1].ep.ep_list, &dev->gadget.ep_list); 1302 1303 switch (mode) { 1304 case 0: 1305 list_add_tail(&dev->ep[2].ep.ep_list, &dev->gadget.ep_list); 1306 dev->ep[1].fifo_size = dev->ep[2].fifo_size = 512; 1307 break; 1308 case 1: 1309 list_add_tail(&dev->ep[2].ep.ep_list, &dev->gadget.ep_list); 1310 dev->ep[1].fifo_size = 1024; 1311 dev->ep[2].fifo_size = 512; 1312 break; 1313 case 2: 1314 list_add_tail(&dev->ep[2].ep.ep_list, &dev->gadget.ep_list); 1315 dev->ep[1].fifo_size = dev->ep[2].fifo_size = 1024; 1316 break; 1317 case 3: 1318 dev->ep[1].fifo_size = 1024; 1319 break; 1320 } 1321 1322 /* ep-c is always 2 512 byte buffers */ 1323 list_add_tail(&dev->ep[3].ep.ep_list, &dev->gadget.ep_list); 1324 dev->ep[3].fifo_size = 512; 1325 } 1326 1327 /*---------------------------------------------------------------------------*/ 1328 1329 static void 1330 net2272_usb_reset(struct net2272 *dev) 1331 { 1332 dev->gadget.speed = USB_SPEED_UNKNOWN; 1333 1334 net2272_cancel_dma(dev); 1335 1336 net2272_write(dev, IRQENB0, 0); 1337 net2272_write(dev, IRQENB1, 0); 1338 1339 /* clear irq state */ 1340 net2272_write(dev, IRQSTAT0, 0xff); 1341 net2272_write(dev, IRQSTAT1, ~(1 << SUSPEND_REQUEST_INTERRUPT)); 1342 1343 net2272_write(dev, DMAREQ, 1344 (0 << DMA_BUFFER_VALID) | 1345 (0 << DMA_REQUEST_ENABLE) | 1346 (1 << DMA_CONTROL_DACK) | 1347 (dev->dma_eot_polarity << EOT_POLARITY) | 1348 (dev->dma_dack_polarity << DACK_POLARITY) | 1349 (dev->dma_dreq_polarity << DREQ_POLARITY) | 1350 ((dma_ep >> 1) << DMA_ENDPOINT_SELECT)); 1351 1352 net2272_cancel_dma(dev); 1353 net2272_set_fifo_mode(dev, (fifo_mode <= 3) ? fifo_mode : 0); 1354 1355 /* Set the NET2272 ep fifo data width to 16-bit mode and for correct byte swapping 1356 * note that the higher level gadget drivers are expected to convert data to little endian. 1357 * Enable byte swap for your local bus/cpu if needed by setting BYTE_SWAP in LOCCTL here 1358 */ 1359 net2272_write(dev, LOCCTL, net2272_read(dev, LOCCTL) | (1 << DATA_WIDTH)); 1360 net2272_write(dev, LOCCTL1, (dma_mode << DMA_MODE)); 1361 } 1362 1363 static void 1364 net2272_usb_reinit(struct net2272 *dev) 1365 { 1366 int i; 1367 1368 /* basic endpoint init */ 1369 for (i = 0; i < 4; ++i) { 1370 struct net2272_ep *ep = &dev->ep[i]; 1371 1372 ep->ep.name = ep_name[i]; 1373 ep->dev = dev; 1374 ep->num = i; 1375 ep->not_empty = 0; 1376 1377 if (use_dma && ep->num == dma_ep) 1378 ep->dma = 1; 1379 1380 if (i > 0 && i <= 3) 1381 ep->fifo_size = 512; 1382 else 1383 ep->fifo_size = 64; 1384 net2272_ep_reset(ep); 1385 1386 if (i == 0) { 1387 ep->ep.caps.type_control = true; 1388 } else { 1389 ep->ep.caps.type_iso = true; 1390 ep->ep.caps.type_bulk = true; 1391 ep->ep.caps.type_int = true; 1392 } 1393 1394 ep->ep.caps.dir_in = true; 1395 ep->ep.caps.dir_out = true; 1396 } 1397 usb_ep_set_maxpacket_limit(&dev->ep[0].ep, 64); 1398 1399 dev->gadget.ep0 = &dev->ep[0].ep; 1400 dev->ep[0].stopped = 0; 1401 INIT_LIST_HEAD(&dev->gadget.ep0->ep_list); 1402 } 1403 1404 static void 1405 net2272_ep0_start(struct net2272 *dev) 1406 { 1407 struct net2272_ep *ep0 = &dev->ep[0]; 1408 1409 net2272_ep_write(ep0, EP_RSPSET, 1410 (1 << NAK_OUT_PACKETS_MODE) | 1411 (1 << ALT_NAK_OUT_PACKETS)); 1412 net2272_ep_write(ep0, EP_RSPCLR, 1413 (1 << HIDE_STATUS_PHASE) | 1414 (1 << CONTROL_STATUS_PHASE_HANDSHAKE)); 1415 net2272_write(dev, USBCTL0, 1416 (dev->softconnect << USB_DETECT_ENABLE) | 1417 (1 << USB_ROOT_PORT_WAKEUP_ENABLE) | 1418 (1 << IO_WAKEUP_ENABLE)); 1419 net2272_write(dev, IRQENB0, 1420 (1 << SETUP_PACKET_INTERRUPT_ENABLE) | 1421 (1 << ENDPOINT_0_INTERRUPT_ENABLE) | 1422 (1 << DMA_DONE_INTERRUPT_ENABLE)); 1423 net2272_write(dev, IRQENB1, 1424 (1 << VBUS_INTERRUPT_ENABLE) | 1425 (1 << ROOT_PORT_RESET_INTERRUPT_ENABLE) | 1426 (1 << SUSPEND_REQUEST_CHANGE_INTERRUPT_ENABLE)); 1427 } 1428 1429 /* when a driver is successfully registered, it will receive 1430 * control requests including set_configuration(), which enables 1431 * non-control requests. then usb traffic follows until a 1432 * disconnect is reported. then a host may connect again, or 1433 * the driver might get unbound. 1434 */ 1435 static int net2272_start(struct usb_gadget *_gadget, 1436 struct usb_gadget_driver *driver) 1437 { 1438 struct net2272 *dev; 1439 unsigned i; 1440 1441 if (!driver || !driver->setup || 1442 driver->max_speed != USB_SPEED_HIGH) 1443 return -EINVAL; 1444 1445 dev = container_of(_gadget, struct net2272, gadget); 1446 1447 for (i = 0; i < 4; ++i) 1448 dev->ep[i].irqs = 0; 1449 /* hook up the driver ... */ 1450 dev->softconnect = 1; 1451 driver->driver.bus = NULL; 1452 dev->driver = driver; 1453 1454 /* ... then enable host detection and ep0; and we're ready 1455 * for set_configuration as well as eventual disconnect. 1456 */ 1457 net2272_ep0_start(dev); 1458 1459 return 0; 1460 } 1461 1462 static void 1463 stop_activity(struct net2272 *dev, struct usb_gadget_driver *driver) 1464 { 1465 int i; 1466 1467 /* don't disconnect if it's not connected */ 1468 if (dev->gadget.speed == USB_SPEED_UNKNOWN) 1469 driver = NULL; 1470 1471 /* stop hardware; prevent new request submissions; 1472 * and kill any outstanding requests. 1473 */ 1474 net2272_usb_reset(dev); 1475 for (i = 0; i < 4; ++i) 1476 net2272_dequeue_all(&dev->ep[i]); 1477 1478 /* report disconnect; the driver is already quiesced */ 1479 if (driver) { 1480 spin_unlock(&dev->lock); 1481 driver->disconnect(&dev->gadget); 1482 spin_lock(&dev->lock); 1483 } 1484 1485 net2272_usb_reinit(dev); 1486 } 1487 1488 static int net2272_stop(struct usb_gadget *_gadget) 1489 { 1490 struct net2272 *dev; 1491 unsigned long flags; 1492 1493 dev = container_of(_gadget, struct net2272, gadget); 1494 1495 spin_lock_irqsave(&dev->lock, flags); 1496 stop_activity(dev, NULL); 1497 spin_unlock_irqrestore(&dev->lock, flags); 1498 1499 dev->driver = NULL; 1500 1501 return 0; 1502 } 1503 1504 /*---------------------------------------------------------------------------*/ 1505 /* handle ep-a/ep-b dma completions */ 1506 static void 1507 net2272_handle_dma(struct net2272_ep *ep) 1508 { 1509 struct net2272_request *req; 1510 unsigned len; 1511 int status; 1512 1513 if (!list_empty(&ep->queue)) 1514 req = list_entry(ep->queue.next, 1515 struct net2272_request, queue); 1516 else 1517 req = NULL; 1518 1519 dev_vdbg(ep->dev->dev, "handle_dma %s req %p\n", ep->ep.name, req); 1520 1521 /* Ensure DREQ is de-asserted */ 1522 net2272_write(ep->dev, DMAREQ, 1523 (0 << DMA_BUFFER_VALID) 1524 | (0 << DMA_REQUEST_ENABLE) 1525 | (1 << DMA_CONTROL_DACK) 1526 | (ep->dev->dma_eot_polarity << EOT_POLARITY) 1527 | (ep->dev->dma_dack_polarity << DACK_POLARITY) 1528 | (ep->dev->dma_dreq_polarity << DREQ_POLARITY) 1529 | (ep->dma << DMA_ENDPOINT_SELECT)); 1530 1531 ep->dev->dma_busy = 0; 1532 1533 net2272_ep_write(ep, EP_IRQENB, 1534 (1 << DATA_PACKET_RECEIVED_INTERRUPT_ENABLE) 1535 | (1 << DATA_PACKET_TRANSMITTED_INTERRUPT_ENABLE) 1536 | net2272_ep_read(ep, EP_IRQENB)); 1537 1538 /* device-to-host transfer completed */ 1539 if (ep->is_in) { 1540 /* validate a short packet or zlp if necessary */ 1541 if ((req->req.length % ep->ep.maxpacket != 0) || 1542 req->req.zero) 1543 set_fifo_bytecount(ep, 0); 1544 1545 net2272_done(ep, req, 0); 1546 if (!list_empty(&ep->queue)) { 1547 req = list_entry(ep->queue.next, 1548 struct net2272_request, queue); 1549 status = net2272_kick_dma(ep, req); 1550 if (status < 0) 1551 net2272_pio_advance(ep); 1552 } 1553 1554 /* host-to-device transfer completed */ 1555 } else { 1556 /* terminated with a short packet? */ 1557 if (net2272_read(ep->dev, IRQSTAT0) & 1558 (1 << DMA_DONE_INTERRUPT)) { 1559 /* abort system dma */ 1560 net2272_cancel_dma(ep->dev); 1561 } 1562 1563 /* EP_TRANSFER will contain the number of bytes 1564 * actually received. 1565 * NOTE: There is no overflow detection on EP_TRANSFER: 1566 * We can't deal with transfers larger than 2^24 bytes! 1567 */ 1568 len = (net2272_ep_read(ep, EP_TRANSFER2) << 16) 1569 | (net2272_ep_read(ep, EP_TRANSFER1) << 8) 1570 | (net2272_ep_read(ep, EP_TRANSFER0)); 1571 1572 if (ep->not_empty) 1573 len += 4; 1574 1575 req->req.actual += len; 1576 1577 /* get any remaining data */ 1578 net2272_pio_advance(ep); 1579 } 1580 } 1581 1582 /*---------------------------------------------------------------------------*/ 1583 1584 static void 1585 net2272_handle_ep(struct net2272_ep *ep) 1586 { 1587 struct net2272_request *req; 1588 u8 stat0, stat1; 1589 1590 if (!list_empty(&ep->queue)) 1591 req = list_entry(ep->queue.next, 1592 struct net2272_request, queue); 1593 else 1594 req = NULL; 1595 1596 /* ack all, and handle what we care about */ 1597 stat0 = net2272_ep_read(ep, EP_STAT0); 1598 stat1 = net2272_ep_read(ep, EP_STAT1); 1599 ep->irqs++; 1600 1601 dev_vdbg(ep->dev->dev, "%s ack ep_stat0 %02x, ep_stat1 %02x, req %p\n", 1602 ep->ep.name, stat0, stat1, req ? &req->req : NULL); 1603 1604 net2272_ep_write(ep, EP_STAT0, stat0 & 1605 ~((1 << NAK_OUT_PACKETS) 1606 | (1 << SHORT_PACKET_TRANSFERRED_INTERRUPT))); 1607 net2272_ep_write(ep, EP_STAT1, stat1); 1608 1609 /* data packet(s) received (in the fifo, OUT) 1610 * direction must be validated, otherwise control read status phase 1611 * could be interpreted as a valid packet 1612 */ 1613 if (!ep->is_in && (stat0 & (1 << DATA_PACKET_RECEIVED_INTERRUPT))) 1614 net2272_pio_advance(ep); 1615 /* data packet(s) transmitted (IN) */ 1616 else if (stat0 & (1 << DATA_PACKET_TRANSMITTED_INTERRUPT)) 1617 net2272_pio_advance(ep); 1618 } 1619 1620 static struct net2272_ep * 1621 net2272_get_ep_by_addr(struct net2272 *dev, u16 wIndex) 1622 { 1623 struct net2272_ep *ep; 1624 1625 if ((wIndex & USB_ENDPOINT_NUMBER_MASK) == 0) 1626 return &dev->ep[0]; 1627 1628 list_for_each_entry(ep, &dev->gadget.ep_list, ep.ep_list) { 1629 u8 bEndpointAddress; 1630 1631 if (!ep->desc) 1632 continue; 1633 bEndpointAddress = ep->desc->bEndpointAddress; 1634 if ((wIndex ^ bEndpointAddress) & USB_DIR_IN) 1635 continue; 1636 if ((wIndex & 0x0f) == (bEndpointAddress & 0x0f)) 1637 return ep; 1638 } 1639 return NULL; 1640 } 1641 1642 /* 1643 * USB Test Packet: 1644 * JKJKJKJK * 9 1645 * JJKKJJKK * 8 1646 * JJJJKKKK * 8 1647 * JJJJJJJKKKKKKK * 8 1648 * JJJJJJJK * 8 1649 * {JKKKKKKK * 10}, JK 1650 */ 1651 static const u8 net2272_test_packet[] = { 1652 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 1653 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 1654 0xEE, 0xEE, 0xEE, 0xEE, 0xEE, 0xEE, 0xEE, 0xEE, 1655 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 1656 0x7F, 0xBF, 0xDF, 0xEF, 0xF7, 0xFB, 0xFD, 1657 0xFC, 0x7E, 0xBF, 0xDF, 0xEF, 0xF7, 0xFD, 0x7E 1658 }; 1659 1660 static void 1661 net2272_set_test_mode(struct net2272 *dev, int mode) 1662 { 1663 int i; 1664 1665 /* Disable all net2272 interrupts: 1666 * Nothing but a power cycle should stop the test. 1667 */ 1668 net2272_write(dev, IRQENB0, 0x00); 1669 net2272_write(dev, IRQENB1, 0x00); 1670 1671 /* Force tranceiver to high-speed */ 1672 net2272_write(dev, XCVRDIAG, 1 << FORCE_HIGH_SPEED); 1673 1674 net2272_write(dev, PAGESEL, 0); 1675 net2272_write(dev, EP_STAT0, 1 << DATA_PACKET_TRANSMITTED_INTERRUPT); 1676 net2272_write(dev, EP_RSPCLR, 1677 (1 << CONTROL_STATUS_PHASE_HANDSHAKE) 1678 | (1 << HIDE_STATUS_PHASE)); 1679 net2272_write(dev, EP_CFG, 1 << ENDPOINT_DIRECTION); 1680 net2272_write(dev, EP_STAT1, 1 << BUFFER_FLUSH); 1681 1682 /* wait for status phase to complete */ 1683 while (!(net2272_read(dev, EP_STAT0) & 1684 (1 << DATA_PACKET_TRANSMITTED_INTERRUPT))) 1685 ; 1686 1687 /* Enable test mode */ 1688 net2272_write(dev, USBTEST, mode); 1689 1690 /* load test packet */ 1691 if (mode == USB_TEST_PACKET) { 1692 /* switch to 8 bit mode */ 1693 net2272_write(dev, LOCCTL, net2272_read(dev, LOCCTL) & 1694 ~(1 << DATA_WIDTH)); 1695 1696 for (i = 0; i < sizeof(net2272_test_packet); ++i) 1697 net2272_write(dev, EP_DATA, net2272_test_packet[i]); 1698 1699 /* Validate test packet */ 1700 net2272_write(dev, EP_TRANSFER0, 0); 1701 } 1702 } 1703 1704 static void 1705 net2272_handle_stat0_irqs(struct net2272 *dev, u8 stat) 1706 { 1707 struct net2272_ep *ep; 1708 u8 num, scratch; 1709 1710 /* starting a control request? */ 1711 if (unlikely(stat & (1 << SETUP_PACKET_INTERRUPT))) { 1712 union { 1713 u8 raw[8]; 1714 struct usb_ctrlrequest r; 1715 } u; 1716 int tmp = 0; 1717 struct net2272_request *req; 1718 1719 if (dev->gadget.speed == USB_SPEED_UNKNOWN) { 1720 if (net2272_read(dev, USBCTL1) & (1 << USB_HIGH_SPEED)) 1721 dev->gadget.speed = USB_SPEED_HIGH; 1722 else 1723 dev->gadget.speed = USB_SPEED_FULL; 1724 dev_dbg(dev->dev, "%s\n", 1725 usb_speed_string(dev->gadget.speed)); 1726 } 1727 1728 ep = &dev->ep[0]; 1729 ep->irqs++; 1730 1731 /* make sure any leftover interrupt state is cleared */ 1732 stat &= ~(1 << ENDPOINT_0_INTERRUPT); 1733 while (!list_empty(&ep->queue)) { 1734 req = list_entry(ep->queue.next, 1735 struct net2272_request, queue); 1736 net2272_done(ep, req, 1737 (req->req.actual == req->req.length) ? 0 : -EPROTO); 1738 } 1739 ep->stopped = 0; 1740 dev->protocol_stall = 0; 1741 net2272_ep_write(ep, EP_STAT0, 1742 (1 << DATA_IN_TOKEN_INTERRUPT) 1743 | (1 << DATA_OUT_TOKEN_INTERRUPT) 1744 | (1 << DATA_PACKET_TRANSMITTED_INTERRUPT) 1745 | (1 << DATA_PACKET_RECEIVED_INTERRUPT) 1746 | (1 << SHORT_PACKET_TRANSFERRED_INTERRUPT)); 1747 net2272_ep_write(ep, EP_STAT1, 1748 (1 << TIMEOUT) 1749 | (1 << USB_OUT_ACK_SENT) 1750 | (1 << USB_OUT_NAK_SENT) 1751 | (1 << USB_IN_ACK_RCVD) 1752 | (1 << USB_IN_NAK_SENT) 1753 | (1 << USB_STALL_SENT) 1754 | (1 << LOCAL_OUT_ZLP)); 1755 1756 /* 1757 * Ensure Control Read pre-validation setting is beyond maximum size 1758 * - Control Writes can leave non-zero values in EP_TRANSFER. If 1759 * an EP0 transfer following the Control Write is a Control Read, 1760 * the NET2272 sees the non-zero EP_TRANSFER as an unexpected 1761 * pre-validation count. 1762 * - Setting EP_TRANSFER beyond the maximum EP0 transfer size ensures 1763 * the pre-validation count cannot cause an unexpected validatation 1764 */ 1765 net2272_write(dev, PAGESEL, 0); 1766 net2272_write(dev, EP_TRANSFER2, 0xff); 1767 net2272_write(dev, EP_TRANSFER1, 0xff); 1768 net2272_write(dev, EP_TRANSFER0, 0xff); 1769 1770 u.raw[0] = net2272_read(dev, SETUP0); 1771 u.raw[1] = net2272_read(dev, SETUP1); 1772 u.raw[2] = net2272_read(dev, SETUP2); 1773 u.raw[3] = net2272_read(dev, SETUP3); 1774 u.raw[4] = net2272_read(dev, SETUP4); 1775 u.raw[5] = net2272_read(dev, SETUP5); 1776 u.raw[6] = net2272_read(dev, SETUP6); 1777 u.raw[7] = net2272_read(dev, SETUP7); 1778 /* 1779 * If you have a big endian cpu make sure le16_to_cpus 1780 * performs the proper byte swapping here... 1781 */ 1782 le16_to_cpus(&u.r.wValue); 1783 le16_to_cpus(&u.r.wIndex); 1784 le16_to_cpus(&u.r.wLength); 1785 1786 /* ack the irq */ 1787 net2272_write(dev, IRQSTAT0, 1 << SETUP_PACKET_INTERRUPT); 1788 stat ^= (1 << SETUP_PACKET_INTERRUPT); 1789 1790 /* watch control traffic at the token level, and force 1791 * synchronization before letting the status phase happen. 1792 */ 1793 ep->is_in = (u.r.bRequestType & USB_DIR_IN) != 0; 1794 if (ep->is_in) { 1795 scratch = (1 << DATA_PACKET_TRANSMITTED_INTERRUPT_ENABLE) 1796 | (1 << DATA_OUT_TOKEN_INTERRUPT_ENABLE) 1797 | (1 << DATA_IN_TOKEN_INTERRUPT_ENABLE); 1798 stop_out_naking(ep); 1799 } else 1800 scratch = (1 << DATA_PACKET_RECEIVED_INTERRUPT_ENABLE) 1801 | (1 << DATA_OUT_TOKEN_INTERRUPT_ENABLE) 1802 | (1 << DATA_IN_TOKEN_INTERRUPT_ENABLE); 1803 net2272_ep_write(ep, EP_IRQENB, scratch); 1804 1805 if ((u.r.bRequestType & USB_TYPE_MASK) != USB_TYPE_STANDARD) 1806 goto delegate; 1807 switch (u.r.bRequest) { 1808 case USB_REQ_GET_STATUS: { 1809 struct net2272_ep *e; 1810 u16 status = 0; 1811 1812 switch (u.r.bRequestType & USB_RECIP_MASK) { 1813 case USB_RECIP_ENDPOINT: 1814 e = net2272_get_ep_by_addr(dev, u.r.wIndex); 1815 if (!e || u.r.wLength > 2) 1816 goto do_stall; 1817 if (net2272_ep_read(e, EP_RSPSET) & (1 << ENDPOINT_HALT)) 1818 status = cpu_to_le16(1); 1819 else 1820 status = cpu_to_le16(0); 1821 1822 /* don't bother with a request object! */ 1823 net2272_ep_write(&dev->ep[0], EP_IRQENB, 0); 1824 writew(status, net2272_reg_addr(dev, EP_DATA)); 1825 set_fifo_bytecount(&dev->ep[0], 0); 1826 allow_status(ep); 1827 dev_vdbg(dev->dev, "%s stat %02x\n", 1828 ep->ep.name, status); 1829 goto next_endpoints; 1830 case USB_RECIP_DEVICE: 1831 if (u.r.wLength > 2) 1832 goto do_stall; 1833 if (dev->gadget.is_selfpowered) 1834 status = (1 << USB_DEVICE_SELF_POWERED); 1835 1836 /* don't bother with a request object! */ 1837 net2272_ep_write(&dev->ep[0], EP_IRQENB, 0); 1838 writew(status, net2272_reg_addr(dev, EP_DATA)); 1839 set_fifo_bytecount(&dev->ep[0], 0); 1840 allow_status(ep); 1841 dev_vdbg(dev->dev, "device stat %02x\n", status); 1842 goto next_endpoints; 1843 case USB_RECIP_INTERFACE: 1844 if (u.r.wLength > 2) 1845 goto do_stall; 1846 1847 /* don't bother with a request object! */ 1848 net2272_ep_write(&dev->ep[0], EP_IRQENB, 0); 1849 writew(status, net2272_reg_addr(dev, EP_DATA)); 1850 set_fifo_bytecount(&dev->ep[0], 0); 1851 allow_status(ep); 1852 dev_vdbg(dev->dev, "interface status %02x\n", status); 1853 goto next_endpoints; 1854 } 1855 1856 break; 1857 } 1858 case USB_REQ_CLEAR_FEATURE: { 1859 struct net2272_ep *e; 1860 1861 if (u.r.bRequestType != USB_RECIP_ENDPOINT) 1862 goto delegate; 1863 if (u.r.wValue != USB_ENDPOINT_HALT || 1864 u.r.wLength != 0) 1865 goto do_stall; 1866 e = net2272_get_ep_by_addr(dev, u.r.wIndex); 1867 if (!e) 1868 goto do_stall; 1869 if (e->wedged) { 1870 dev_vdbg(dev->dev, "%s wedged, halt not cleared\n", 1871 ep->ep.name); 1872 } else { 1873 dev_vdbg(dev->dev, "%s clear halt\n", ep->ep.name); 1874 clear_halt(e); 1875 } 1876 allow_status(ep); 1877 goto next_endpoints; 1878 } 1879 case USB_REQ_SET_FEATURE: { 1880 struct net2272_ep *e; 1881 1882 if (u.r.bRequestType == USB_RECIP_DEVICE) { 1883 if (u.r.wIndex != NORMAL_OPERATION) 1884 net2272_set_test_mode(dev, (u.r.wIndex >> 8)); 1885 allow_status(ep); 1886 dev_vdbg(dev->dev, "test mode: %d\n", u.r.wIndex); 1887 goto next_endpoints; 1888 } else if (u.r.bRequestType != USB_RECIP_ENDPOINT) 1889 goto delegate; 1890 if (u.r.wValue != USB_ENDPOINT_HALT || 1891 u.r.wLength != 0) 1892 goto do_stall; 1893 e = net2272_get_ep_by_addr(dev, u.r.wIndex); 1894 if (!e) 1895 goto do_stall; 1896 set_halt(e); 1897 allow_status(ep); 1898 dev_vdbg(dev->dev, "%s set halt\n", ep->ep.name); 1899 goto next_endpoints; 1900 } 1901 case USB_REQ_SET_ADDRESS: { 1902 net2272_write(dev, OURADDR, u.r.wValue & 0xff); 1903 allow_status(ep); 1904 break; 1905 } 1906 default: 1907 delegate: 1908 dev_vdbg(dev->dev, "setup %02x.%02x v%04x i%04x " 1909 "ep_cfg %08x\n", 1910 u.r.bRequestType, u.r.bRequest, 1911 u.r.wValue, u.r.wIndex, 1912 net2272_ep_read(ep, EP_CFG)); 1913 spin_unlock(&dev->lock); 1914 tmp = dev->driver->setup(&dev->gadget, &u.r); 1915 spin_lock(&dev->lock); 1916 } 1917 1918 /* stall ep0 on error */ 1919 if (tmp < 0) { 1920 do_stall: 1921 dev_vdbg(dev->dev, "req %02x.%02x protocol STALL; stat %d\n", 1922 u.r.bRequestType, u.r.bRequest, tmp); 1923 dev->protocol_stall = 1; 1924 } 1925 /* endpoint dma irq? */ 1926 } else if (stat & (1 << DMA_DONE_INTERRUPT)) { 1927 net2272_cancel_dma(dev); 1928 net2272_write(dev, IRQSTAT0, 1 << DMA_DONE_INTERRUPT); 1929 stat &= ~(1 << DMA_DONE_INTERRUPT); 1930 num = (net2272_read(dev, DMAREQ) & (1 << DMA_ENDPOINT_SELECT)) 1931 ? 2 : 1; 1932 1933 ep = &dev->ep[num]; 1934 net2272_handle_dma(ep); 1935 } 1936 1937 next_endpoints: 1938 /* endpoint data irq? */ 1939 scratch = stat & 0x0f; 1940 stat &= ~0x0f; 1941 for (num = 0; scratch; num++) { 1942 u8 t; 1943 1944 /* does this endpoint's FIFO and queue need tending? */ 1945 t = 1 << num; 1946 if ((scratch & t) == 0) 1947 continue; 1948 scratch ^= t; 1949 1950 ep = &dev->ep[num]; 1951 net2272_handle_ep(ep); 1952 } 1953 1954 /* some interrupts we can just ignore */ 1955 stat &= ~(1 << SOF_INTERRUPT); 1956 1957 if (stat) 1958 dev_dbg(dev->dev, "unhandled irqstat0 %02x\n", stat); 1959 } 1960 1961 static void 1962 net2272_handle_stat1_irqs(struct net2272 *dev, u8 stat) 1963 { 1964 u8 tmp, mask; 1965 1966 /* after disconnect there's nothing else to do! */ 1967 tmp = (1 << VBUS_INTERRUPT) | (1 << ROOT_PORT_RESET_INTERRUPT); 1968 mask = (1 << USB_HIGH_SPEED) | (1 << USB_FULL_SPEED); 1969 1970 if (stat & tmp) { 1971 bool reset = false; 1972 bool disconnect = false; 1973 1974 /* 1975 * Ignore disconnects and resets if the speed hasn't been set. 1976 * VBUS can bounce and there's always an initial reset. 1977 */ 1978 net2272_write(dev, IRQSTAT1, tmp); 1979 if (dev->gadget.speed != USB_SPEED_UNKNOWN) { 1980 if ((stat & (1 << VBUS_INTERRUPT)) && 1981 (net2272_read(dev, USBCTL1) & 1982 (1 << VBUS_PIN)) == 0) { 1983 disconnect = true; 1984 dev_dbg(dev->dev, "disconnect %s\n", 1985 dev->driver->driver.name); 1986 } else if ((stat & (1 << ROOT_PORT_RESET_INTERRUPT)) && 1987 (net2272_read(dev, USBCTL1) & mask) 1988 == 0) { 1989 reset = true; 1990 dev_dbg(dev->dev, "reset %s\n", 1991 dev->driver->driver.name); 1992 } 1993 1994 if (disconnect || reset) { 1995 stop_activity(dev, dev->driver); 1996 net2272_ep0_start(dev); 1997 spin_unlock(&dev->lock); 1998 if (reset) 1999 usb_gadget_udc_reset 2000 (&dev->gadget, dev->driver); 2001 else 2002 (dev->driver->disconnect) 2003 (&dev->gadget); 2004 spin_lock(&dev->lock); 2005 return; 2006 } 2007 } 2008 stat &= ~tmp; 2009 2010 if (!stat) 2011 return; 2012 } 2013 2014 tmp = (1 << SUSPEND_REQUEST_CHANGE_INTERRUPT); 2015 if (stat & tmp) { 2016 net2272_write(dev, IRQSTAT1, tmp); 2017 if (stat & (1 << SUSPEND_REQUEST_INTERRUPT)) { 2018 if (dev->driver->suspend) 2019 dev->driver->suspend(&dev->gadget); 2020 if (!enable_suspend) { 2021 stat &= ~(1 << SUSPEND_REQUEST_INTERRUPT); 2022 dev_dbg(dev->dev, "Suspend disabled, ignoring\n"); 2023 } 2024 } else { 2025 if (dev->driver->resume) 2026 dev->driver->resume(&dev->gadget); 2027 } 2028 stat &= ~tmp; 2029 } 2030 2031 /* clear any other status/irqs */ 2032 if (stat) 2033 net2272_write(dev, IRQSTAT1, stat); 2034 2035 /* some status we can just ignore */ 2036 stat &= ~((1 << CONTROL_STATUS_INTERRUPT) 2037 | (1 << SUSPEND_REQUEST_INTERRUPT) 2038 | (1 << RESUME_INTERRUPT)); 2039 if (!stat) 2040 return; 2041 else 2042 dev_dbg(dev->dev, "unhandled irqstat1 %02x\n", stat); 2043 } 2044 2045 static irqreturn_t net2272_irq(int irq, void *_dev) 2046 { 2047 struct net2272 *dev = _dev; 2048 #if defined(PLX_PCI_RDK) || defined(PLX_PCI_RDK2) 2049 u32 intcsr; 2050 #endif 2051 #if defined(PLX_PCI_RDK) 2052 u8 dmareq; 2053 #endif 2054 spin_lock(&dev->lock); 2055 #if defined(PLX_PCI_RDK) 2056 intcsr = readl(dev->rdk1.plx9054_base_addr + INTCSR); 2057 2058 if ((intcsr & LOCAL_INTERRUPT_TEST) == LOCAL_INTERRUPT_TEST) { 2059 writel(intcsr & ~(1 << PCI_INTERRUPT_ENABLE), 2060 dev->rdk1.plx9054_base_addr + INTCSR); 2061 net2272_handle_stat1_irqs(dev, net2272_read(dev, IRQSTAT1)); 2062 net2272_handle_stat0_irqs(dev, net2272_read(dev, IRQSTAT0)); 2063 intcsr = readl(dev->rdk1.plx9054_base_addr + INTCSR); 2064 writel(intcsr | (1 << PCI_INTERRUPT_ENABLE), 2065 dev->rdk1.plx9054_base_addr + INTCSR); 2066 } 2067 if ((intcsr & DMA_CHANNEL_0_TEST) == DMA_CHANNEL_0_TEST) { 2068 writeb((1 << CHANNEL_CLEAR_INTERRUPT | (0 << CHANNEL_ENABLE)), 2069 dev->rdk1.plx9054_base_addr + DMACSR0); 2070 2071 dmareq = net2272_read(dev, DMAREQ); 2072 if (dmareq & 0x01) 2073 net2272_handle_dma(&dev->ep[2]); 2074 else 2075 net2272_handle_dma(&dev->ep[1]); 2076 } 2077 #endif 2078 #if defined(PLX_PCI_RDK2) 2079 /* see if PCI int for us by checking irqstat */ 2080 intcsr = readl(dev->rdk2.fpga_base_addr + RDK2_IRQSTAT); 2081 if (!(intcsr & (1 << NET2272_PCI_IRQ))) { 2082 spin_unlock(&dev->lock); 2083 return IRQ_NONE; 2084 } 2085 /* check dma interrupts */ 2086 #endif 2087 /* Platform/devcice interrupt handler */ 2088 #if !defined(PLX_PCI_RDK) 2089 net2272_handle_stat1_irqs(dev, net2272_read(dev, IRQSTAT1)); 2090 net2272_handle_stat0_irqs(dev, net2272_read(dev, IRQSTAT0)); 2091 #endif 2092 spin_unlock(&dev->lock); 2093 2094 return IRQ_HANDLED; 2095 } 2096 2097 static int net2272_present(struct net2272 *dev) 2098 { 2099 /* 2100 * Quick test to see if CPU can communicate properly with the NET2272. 2101 * Verifies connection using writes and reads to write/read and 2102 * read-only registers. 2103 * 2104 * This routine is strongly recommended especially during early bring-up 2105 * of new hardware, however for designs that do not apply Power On System 2106 * Tests (POST) it may discarded (or perhaps minimized). 2107 */ 2108 unsigned int ii; 2109 u8 val, refval; 2110 2111 /* Verify NET2272 write/read SCRATCH register can write and read */ 2112 refval = net2272_read(dev, SCRATCH); 2113 for (ii = 0; ii < 0x100; ii += 7) { 2114 net2272_write(dev, SCRATCH, ii); 2115 val = net2272_read(dev, SCRATCH); 2116 if (val != ii) { 2117 dev_dbg(dev->dev, 2118 "%s: write/read SCRATCH register test failed: " 2119 "wrote:0x%2.2x, read:0x%2.2x\n", 2120 __func__, ii, val); 2121 return -EINVAL; 2122 } 2123 } 2124 /* To be nice, we write the original SCRATCH value back: */ 2125 net2272_write(dev, SCRATCH, refval); 2126 2127 /* Verify NET2272 CHIPREV register is read-only: */ 2128 refval = net2272_read(dev, CHIPREV_2272); 2129 for (ii = 0; ii < 0x100; ii += 7) { 2130 net2272_write(dev, CHIPREV_2272, ii); 2131 val = net2272_read(dev, CHIPREV_2272); 2132 if (val != refval) { 2133 dev_dbg(dev->dev, 2134 "%s: write/read CHIPREV register test failed: " 2135 "wrote 0x%2.2x, read:0x%2.2x expected:0x%2.2x\n", 2136 __func__, ii, val, refval); 2137 return -EINVAL; 2138 } 2139 } 2140 2141 /* 2142 * Verify NET2272's "NET2270 legacy revision" register 2143 * - NET2272 has two revision registers. The NET2270 legacy revision 2144 * register should read the same value, regardless of the NET2272 2145 * silicon revision. The legacy register applies to NET2270 2146 * firmware being applied to the NET2272. 2147 */ 2148 val = net2272_read(dev, CHIPREV_LEGACY); 2149 if (val != NET2270_LEGACY_REV) { 2150 /* 2151 * Unexpected legacy revision value 2152 * - Perhaps the chip is a NET2270? 2153 */ 2154 dev_dbg(dev->dev, 2155 "%s: WARNING: UNEXPECTED NET2272 LEGACY REGISTER VALUE:\n" 2156 " - CHIPREV_LEGACY: expected 0x%2.2x, got:0x%2.2x. (Not NET2272?)\n", 2157 __func__, NET2270_LEGACY_REV, val); 2158 return -EINVAL; 2159 } 2160 2161 /* 2162 * Verify NET2272 silicon revision 2163 * - This revision register is appropriate for the silicon version 2164 * of the NET2272 2165 */ 2166 val = net2272_read(dev, CHIPREV_2272); 2167 switch (val) { 2168 case CHIPREV_NET2272_R1: 2169 /* 2170 * NET2272 Rev 1 has DMA related errata: 2171 * - Newer silicon (Rev 1A or better) required 2172 */ 2173 dev_dbg(dev->dev, 2174 "%s: Rev 1 detected: newer silicon recommended for DMA support\n", 2175 __func__); 2176 break; 2177 case CHIPREV_NET2272_R1A: 2178 break; 2179 default: 2180 /* NET2272 silicon version *may* not work with this firmware */ 2181 dev_dbg(dev->dev, 2182 "%s: unexpected silicon revision register value: " 2183 " CHIPREV_2272: 0x%2.2x\n", 2184 __func__, val); 2185 /* 2186 * Return Success, even though the chip rev is not an expected value 2187 * - Older, pre-built firmware can attempt to operate on newer silicon 2188 * - Often, new silicon is perfectly compatible 2189 */ 2190 } 2191 2192 /* Success: NET2272 checks out OK */ 2193 return 0; 2194 } 2195 2196 static void 2197 net2272_gadget_release(struct device *_dev) 2198 { 2199 struct net2272 *dev = container_of(_dev, struct net2272, gadget.dev); 2200 2201 kfree(dev); 2202 } 2203 2204 /*---------------------------------------------------------------------------*/ 2205 2206 static void 2207 net2272_remove(struct net2272 *dev) 2208 { 2209 if (dev->added) 2210 usb_del_gadget(&dev->gadget); 2211 free_irq(dev->irq, dev); 2212 iounmap(dev->base_addr); 2213 device_remove_file(dev->dev, &dev_attr_registers); 2214 2215 dev_info(dev->dev, "unbind\n"); 2216 } 2217 2218 static struct net2272 *net2272_probe_init(struct device *dev, unsigned int irq) 2219 { 2220 struct net2272 *ret; 2221 2222 if (!irq) { 2223 dev_dbg(dev, "No IRQ!\n"); 2224 return ERR_PTR(-ENODEV); 2225 } 2226 2227 /* alloc, and start init */ 2228 ret = kzalloc(sizeof(*ret), GFP_KERNEL); 2229 if (!ret) 2230 return ERR_PTR(-ENOMEM); 2231 2232 spin_lock_init(&ret->lock); 2233 ret->irq = irq; 2234 ret->dev = dev; 2235 ret->gadget.ops = &net2272_ops; 2236 ret->gadget.max_speed = USB_SPEED_HIGH; 2237 2238 /* the "gadget" abstracts/virtualizes the controller */ 2239 ret->gadget.name = driver_name; 2240 usb_initialize_gadget(dev, &ret->gadget, net2272_gadget_release); 2241 2242 return ret; 2243 } 2244 2245 static int 2246 net2272_probe_fin(struct net2272 *dev, unsigned int irqflags) 2247 { 2248 int ret; 2249 2250 /* See if there... */ 2251 if (net2272_present(dev)) { 2252 dev_warn(dev->dev, "2272 not found!\n"); 2253 ret = -ENODEV; 2254 goto err; 2255 } 2256 2257 net2272_usb_reset(dev); 2258 net2272_usb_reinit(dev); 2259 2260 ret = request_irq(dev->irq, net2272_irq, irqflags, driver_name, dev); 2261 if (ret) { 2262 dev_err(dev->dev, "request interrupt %i failed\n", dev->irq); 2263 goto err; 2264 } 2265 2266 dev->chiprev = net2272_read(dev, CHIPREV_2272); 2267 2268 /* done */ 2269 dev_info(dev->dev, "%s\n", driver_desc); 2270 dev_info(dev->dev, "irq %i, mem %p, chip rev %04x, dma %s\n", 2271 dev->irq, dev->base_addr, dev->chiprev, 2272 dma_mode_string()); 2273 dev_info(dev->dev, "version: %s\n", driver_vers); 2274 2275 ret = device_create_file(dev->dev, &dev_attr_registers); 2276 if (ret) 2277 goto err_irq; 2278 2279 ret = usb_add_gadget(&dev->gadget); 2280 if (ret) 2281 goto err_add_udc; 2282 dev->added = 1; 2283 2284 return 0; 2285 2286 err_add_udc: 2287 device_remove_file(dev->dev, &dev_attr_registers); 2288 err_irq: 2289 free_irq(dev->irq, dev); 2290 err: 2291 return ret; 2292 } 2293 2294 #ifdef CONFIG_USB_PCI 2295 2296 /* 2297 * wrap this driver around the specified device, but 2298 * don't respond over USB until a gadget driver binds to us 2299 */ 2300 2301 static int 2302 net2272_rdk1_probe(struct pci_dev *pdev, struct net2272 *dev) 2303 { 2304 unsigned long resource, len, tmp; 2305 void __iomem *mem_mapped_addr[4]; 2306 int ret, i; 2307 2308 /* 2309 * BAR 0 holds PLX 9054 config registers 2310 * BAR 1 is i/o memory; unused here 2311 * BAR 2 holds EPLD config registers 2312 * BAR 3 holds NET2272 registers 2313 */ 2314 2315 /* Find and map all address spaces */ 2316 for (i = 0; i < 4; ++i) { 2317 if (i == 1) 2318 continue; /* BAR1 unused */ 2319 2320 resource = pci_resource_start(pdev, i); 2321 len = pci_resource_len(pdev, i); 2322 2323 if (!request_mem_region(resource, len, driver_name)) { 2324 dev_dbg(dev->dev, "controller already in use\n"); 2325 ret = -EBUSY; 2326 goto err; 2327 } 2328 2329 mem_mapped_addr[i] = ioremap(resource, len); 2330 if (mem_mapped_addr[i] == NULL) { 2331 release_mem_region(resource, len); 2332 dev_dbg(dev->dev, "can't map memory\n"); 2333 ret = -EFAULT; 2334 goto err; 2335 } 2336 } 2337 2338 dev->rdk1.plx9054_base_addr = mem_mapped_addr[0]; 2339 dev->rdk1.epld_base_addr = mem_mapped_addr[2]; 2340 dev->base_addr = mem_mapped_addr[3]; 2341 2342 /* Set PLX 9054 bus width (16 bits) */ 2343 tmp = readl(dev->rdk1.plx9054_base_addr + LBRD1); 2344 writel((tmp & ~(3 << MEMORY_SPACE_LOCAL_BUS_WIDTH)) | W16_BIT, 2345 dev->rdk1.plx9054_base_addr + LBRD1); 2346 2347 /* Enable PLX 9054 Interrupts */ 2348 writel(readl(dev->rdk1.plx9054_base_addr + INTCSR) | 2349 (1 << PCI_INTERRUPT_ENABLE) | 2350 (1 << LOCAL_INTERRUPT_INPUT_ENABLE), 2351 dev->rdk1.plx9054_base_addr + INTCSR); 2352 2353 writeb((1 << CHANNEL_CLEAR_INTERRUPT | (0 << CHANNEL_ENABLE)), 2354 dev->rdk1.plx9054_base_addr + DMACSR0); 2355 2356 /* reset */ 2357 writeb((1 << EPLD_DMA_ENABLE) | 2358 (1 << DMA_CTL_DACK) | 2359 (1 << DMA_TIMEOUT_ENABLE) | 2360 (1 << USER) | 2361 (0 << MPX_MODE) | 2362 (1 << BUSWIDTH) | 2363 (1 << NET2272_RESET), 2364 dev->base_addr + EPLD_IO_CONTROL_REGISTER); 2365 2366 mb(); 2367 writeb(readb(dev->base_addr + EPLD_IO_CONTROL_REGISTER) & 2368 ~(1 << NET2272_RESET), 2369 dev->base_addr + EPLD_IO_CONTROL_REGISTER); 2370 udelay(200); 2371 2372 return 0; 2373 2374 err: 2375 while (--i >= 0) { 2376 if (i == 1) 2377 continue; /* BAR1 unused */ 2378 iounmap(mem_mapped_addr[i]); 2379 release_mem_region(pci_resource_start(pdev, i), 2380 pci_resource_len(pdev, i)); 2381 } 2382 2383 return ret; 2384 } 2385 2386 static int 2387 net2272_rdk2_probe(struct pci_dev *pdev, struct net2272 *dev) 2388 { 2389 unsigned long resource, len; 2390 void __iomem *mem_mapped_addr[2]; 2391 int ret, i; 2392 2393 /* 2394 * BAR 0 holds FGPA config registers 2395 * BAR 1 holds NET2272 registers 2396 */ 2397 2398 /* Find and map all address spaces, bar2-3 unused in rdk 2 */ 2399 for (i = 0; i < 2; ++i) { 2400 resource = pci_resource_start(pdev, i); 2401 len = pci_resource_len(pdev, i); 2402 2403 if (!request_mem_region(resource, len, driver_name)) { 2404 dev_dbg(dev->dev, "controller already in use\n"); 2405 ret = -EBUSY; 2406 goto err; 2407 } 2408 2409 mem_mapped_addr[i] = ioremap(resource, len); 2410 if (mem_mapped_addr[i] == NULL) { 2411 release_mem_region(resource, len); 2412 dev_dbg(dev->dev, "can't map memory\n"); 2413 ret = -EFAULT; 2414 goto err; 2415 } 2416 } 2417 2418 dev->rdk2.fpga_base_addr = mem_mapped_addr[0]; 2419 dev->base_addr = mem_mapped_addr[1]; 2420 2421 mb(); 2422 /* Set 2272 bus width (16 bits) and reset */ 2423 writel((1 << CHIP_RESET), dev->rdk2.fpga_base_addr + RDK2_LOCCTLRDK); 2424 udelay(200); 2425 writel((1 << BUS_WIDTH), dev->rdk2.fpga_base_addr + RDK2_LOCCTLRDK); 2426 /* Print fpga version number */ 2427 dev_info(dev->dev, "RDK2 FPGA version %08x\n", 2428 readl(dev->rdk2.fpga_base_addr + RDK2_FPGAREV)); 2429 /* Enable FPGA Interrupts */ 2430 writel((1 << NET2272_PCI_IRQ), dev->rdk2.fpga_base_addr + RDK2_IRQENB); 2431 2432 return 0; 2433 2434 err: 2435 while (--i >= 0) { 2436 iounmap(mem_mapped_addr[i]); 2437 release_mem_region(pci_resource_start(pdev, i), 2438 pci_resource_len(pdev, i)); 2439 } 2440 2441 return ret; 2442 } 2443 2444 static int 2445 net2272_pci_probe(struct pci_dev *pdev, const struct pci_device_id *id) 2446 { 2447 struct net2272 *dev; 2448 int ret; 2449 2450 dev = net2272_probe_init(&pdev->dev, pdev->irq); 2451 if (IS_ERR(dev)) 2452 return PTR_ERR(dev); 2453 dev->dev_id = pdev->device; 2454 2455 if (pci_enable_device(pdev) < 0) { 2456 ret = -ENODEV; 2457 goto err_put; 2458 } 2459 2460 pci_set_master(pdev); 2461 2462 switch (pdev->device) { 2463 case PCI_DEVICE_ID_RDK1: ret = net2272_rdk1_probe(pdev, dev); break; 2464 case PCI_DEVICE_ID_RDK2: ret = net2272_rdk2_probe(pdev, dev); break; 2465 default: BUG(); 2466 } 2467 if (ret) 2468 goto err_pci; 2469 2470 ret = net2272_probe_fin(dev, 0); 2471 if (ret) 2472 goto err_pci; 2473 2474 pci_set_drvdata(pdev, dev); 2475 2476 return 0; 2477 2478 err_pci: 2479 pci_disable_device(pdev); 2480 err_put: 2481 usb_put_gadget(&dev->gadget); 2482 2483 return ret; 2484 } 2485 2486 static void 2487 net2272_rdk1_remove(struct pci_dev *pdev, struct net2272 *dev) 2488 { 2489 int i; 2490 2491 /* disable PLX 9054 interrupts */ 2492 writel(readl(dev->rdk1.plx9054_base_addr + INTCSR) & 2493 ~(1 << PCI_INTERRUPT_ENABLE), 2494 dev->rdk1.plx9054_base_addr + INTCSR); 2495 2496 /* clean up resources allocated during probe() */ 2497 iounmap(dev->rdk1.plx9054_base_addr); 2498 iounmap(dev->rdk1.epld_base_addr); 2499 2500 for (i = 0; i < 4; ++i) { 2501 if (i == 1) 2502 continue; /* BAR1 unused */ 2503 release_mem_region(pci_resource_start(pdev, i), 2504 pci_resource_len(pdev, i)); 2505 } 2506 } 2507 2508 static void 2509 net2272_rdk2_remove(struct pci_dev *pdev, struct net2272 *dev) 2510 { 2511 int i; 2512 2513 /* disable fpga interrupts 2514 writel(readl(dev->rdk1.plx9054_base_addr + INTCSR) & 2515 ~(1 << PCI_INTERRUPT_ENABLE), 2516 dev->rdk1.plx9054_base_addr + INTCSR); 2517 */ 2518 2519 /* clean up resources allocated during probe() */ 2520 iounmap(dev->rdk2.fpga_base_addr); 2521 2522 for (i = 0; i < 2; ++i) 2523 release_mem_region(pci_resource_start(pdev, i), 2524 pci_resource_len(pdev, i)); 2525 } 2526 2527 static void 2528 net2272_pci_remove(struct pci_dev *pdev) 2529 { 2530 struct net2272 *dev = pci_get_drvdata(pdev); 2531 2532 net2272_remove(dev); 2533 2534 switch (pdev->device) { 2535 case PCI_DEVICE_ID_RDK1: net2272_rdk1_remove(pdev, dev); break; 2536 case PCI_DEVICE_ID_RDK2: net2272_rdk2_remove(pdev, dev); break; 2537 default: BUG(); 2538 } 2539 2540 pci_disable_device(pdev); 2541 2542 usb_put_gadget(&dev->gadget); 2543 } 2544 2545 /* Table of matching PCI IDs */ 2546 static struct pci_device_id pci_ids[] = { 2547 { /* RDK 1 card */ 2548 .class = ((PCI_CLASS_BRIDGE_OTHER << 8) | 0xfe), 2549 .class_mask = 0, 2550 .vendor = PCI_VENDOR_ID_PLX, 2551 .device = PCI_DEVICE_ID_RDK1, 2552 .subvendor = PCI_ANY_ID, 2553 .subdevice = PCI_ANY_ID, 2554 }, 2555 { /* RDK 2 card */ 2556 .class = ((PCI_CLASS_BRIDGE_OTHER << 8) | 0xfe), 2557 .class_mask = 0, 2558 .vendor = PCI_VENDOR_ID_PLX, 2559 .device = PCI_DEVICE_ID_RDK2, 2560 .subvendor = PCI_ANY_ID, 2561 .subdevice = PCI_ANY_ID, 2562 }, 2563 { } 2564 }; 2565 MODULE_DEVICE_TABLE(pci, pci_ids); 2566 2567 static struct pci_driver net2272_pci_driver = { 2568 .name = driver_name, 2569 .id_table = pci_ids, 2570 2571 .probe = net2272_pci_probe, 2572 .remove = net2272_pci_remove, 2573 }; 2574 2575 static int net2272_pci_register(void) 2576 { 2577 return pci_register_driver(&net2272_pci_driver); 2578 } 2579 2580 static void net2272_pci_unregister(void) 2581 { 2582 pci_unregister_driver(&net2272_pci_driver); 2583 } 2584 2585 #else 2586 static inline int net2272_pci_register(void) { return 0; } 2587 static inline void net2272_pci_unregister(void) { } 2588 #endif 2589 2590 /*---------------------------------------------------------------------------*/ 2591 2592 static int 2593 net2272_plat_probe(struct platform_device *pdev) 2594 { 2595 struct net2272 *dev; 2596 int ret; 2597 unsigned int irqflags; 2598 resource_size_t base, len; 2599 struct resource *iomem, *iomem_bus, *irq_res; 2600 2601 irq_res = platform_get_resource(pdev, IORESOURCE_IRQ, 0); 2602 iomem = platform_get_resource(pdev, IORESOURCE_MEM, 0); 2603 iomem_bus = platform_get_resource(pdev, IORESOURCE_BUS, 0); 2604 if (!irq_res || !iomem) { 2605 dev_err(&pdev->dev, "must provide irq/base addr"); 2606 return -EINVAL; 2607 } 2608 2609 dev = net2272_probe_init(&pdev->dev, irq_res->start); 2610 if (IS_ERR(dev)) 2611 return PTR_ERR(dev); 2612 2613 irqflags = 0; 2614 if (irq_res->flags & IORESOURCE_IRQ_HIGHEDGE) 2615 irqflags |= IRQF_TRIGGER_RISING; 2616 if (irq_res->flags & IORESOURCE_IRQ_LOWEDGE) 2617 irqflags |= IRQF_TRIGGER_FALLING; 2618 if (irq_res->flags & IORESOURCE_IRQ_HIGHLEVEL) 2619 irqflags |= IRQF_TRIGGER_HIGH; 2620 if (irq_res->flags & IORESOURCE_IRQ_LOWLEVEL) 2621 irqflags |= IRQF_TRIGGER_LOW; 2622 2623 base = iomem->start; 2624 len = resource_size(iomem); 2625 if (iomem_bus) 2626 dev->base_shift = iomem_bus->start; 2627 2628 if (!request_mem_region(base, len, driver_name)) { 2629 dev_dbg(dev->dev, "get request memory region!\n"); 2630 ret = -EBUSY; 2631 goto err; 2632 } 2633 dev->base_addr = ioremap(base, len); 2634 if (!dev->base_addr) { 2635 dev_dbg(dev->dev, "can't map memory\n"); 2636 ret = -EFAULT; 2637 goto err_req; 2638 } 2639 2640 ret = net2272_probe_fin(dev, IRQF_TRIGGER_LOW); 2641 if (ret) 2642 goto err_io; 2643 2644 platform_set_drvdata(pdev, dev); 2645 dev_info(&pdev->dev, "running in 16-bit, %sbyte swap local bus mode\n", 2646 (net2272_read(dev, LOCCTL) & (1 << BYTE_SWAP)) ? "" : "no "); 2647 2648 return 0; 2649 2650 err_io: 2651 iounmap(dev->base_addr); 2652 err_req: 2653 release_mem_region(base, len); 2654 err: 2655 usb_put_gadget(&dev->gadget); 2656 2657 return ret; 2658 } 2659 2660 static int 2661 net2272_plat_remove(struct platform_device *pdev) 2662 { 2663 struct net2272 *dev = platform_get_drvdata(pdev); 2664 2665 net2272_remove(dev); 2666 2667 release_mem_region(pdev->resource[0].start, 2668 resource_size(&pdev->resource[0])); 2669 2670 usb_put_gadget(&dev->gadget); 2671 2672 return 0; 2673 } 2674 2675 static struct platform_driver net2272_plat_driver = { 2676 .probe = net2272_plat_probe, 2677 .remove = net2272_plat_remove, 2678 .driver = { 2679 .name = driver_name, 2680 }, 2681 /* FIXME .suspend, .resume */ 2682 }; 2683 MODULE_ALIAS("platform:net2272"); 2684 2685 static int __init net2272_init(void) 2686 { 2687 int ret; 2688 2689 ret = net2272_pci_register(); 2690 if (ret) 2691 return ret; 2692 ret = platform_driver_register(&net2272_plat_driver); 2693 if (ret) 2694 goto err_pci; 2695 return ret; 2696 2697 err_pci: 2698 net2272_pci_unregister(); 2699 return ret; 2700 } 2701 module_init(net2272_init); 2702 2703 static void __exit net2272_cleanup(void) 2704 { 2705 net2272_pci_unregister(); 2706 platform_driver_unregister(&net2272_plat_driver); 2707 } 2708 module_exit(net2272_cleanup); 2709 2710 MODULE_DESCRIPTION(DRIVER_DESC); 2711 MODULE_AUTHOR("PLX Technology, Inc."); 2712 MODULE_LICENSE("GPL"); 2713