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