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