1 /* de2104x.c: A Linux PCI Ethernet driver for Intel/Digital 21040/1 chips. */ 2 /* 3 Copyright 2001,2003 Jeff Garzik <jgarzik@pobox.com> 4 5 Copyright 1994, 1995 Digital Equipment Corporation. [de4x5.c] 6 Written/copyright 1994-2001 by Donald Becker. [tulip.c] 7 8 This software may be used and distributed according to the terms of 9 the GNU General Public License (GPL), incorporated herein by reference. 10 Drivers based on or derived from this code fall under the GPL and must 11 retain the authorship, copyright and license notice. This file is not 12 a complete program and may only be used when the entire operating 13 system is licensed under the GPL. 14 15 See the file COPYING in this distribution for more information. 16 17 TODO, in rough priority order: 18 * Support forcing media type with a module parameter, 19 like dl2k.c/sundance.c 20 * Constants (module parms?) for Rx work limit 21 * Complete reset on PciErr 22 * Jumbo frames / dev->change_mtu 23 * Adjust Rx FIFO threshold and Max Rx DMA burst on Rx FIFO error 24 * Adjust Tx FIFO threshold and Max Tx DMA burst on Tx FIFO error 25 * Implement Tx software interrupt mitigation via 26 Tx descriptor bit 27 28 */ 29 30 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 31 32 #define DRV_NAME "de2104x" 33 #define DRV_RELDATE "Mar 17, 2004" 34 35 #include <linux/module.h> 36 #include <linux/kernel.h> 37 #include <linux/netdevice.h> 38 #include <linux/etherdevice.h> 39 #include <linux/init.h> 40 #include <linux/interrupt.h> 41 #include <linux/pci.h> 42 #include <linux/delay.h> 43 #include <linux/ethtool.h> 44 #include <linux/compiler.h> 45 #include <linux/rtnetlink.h> 46 #include <linux/crc32.h> 47 #include <linux/slab.h> 48 49 #include <asm/io.h> 50 #include <asm/irq.h> 51 #include <linux/uaccess.h> 52 #include <linux/unaligned.h> 53 54 MODULE_AUTHOR("Jeff Garzik <jgarzik@pobox.com>"); 55 MODULE_DESCRIPTION("Intel/Digital 21040/1 series PCI Ethernet driver"); 56 MODULE_LICENSE("GPL"); 57 58 static int debug = -1; 59 module_param (debug, int, 0); 60 MODULE_PARM_DESC (debug, "de2104x bitmapped message enable number"); 61 62 /* Set the copy breakpoint for the copy-only-tiny-buffer Rx structure. */ 63 #if defined(__alpha__) || defined(__arm__) || defined(__hppa__) || \ 64 defined(CONFIG_SPARC) || defined(__ia64__) || \ 65 defined(__sh__) || defined(__mips__) 66 static int rx_copybreak = 1518; 67 #else 68 static int rx_copybreak = 100; 69 #endif 70 module_param (rx_copybreak, int, 0); 71 MODULE_PARM_DESC (rx_copybreak, "de2104x Breakpoint at which Rx packets are copied"); 72 73 #define DE_DEF_MSG_ENABLE (NETIF_MSG_DRV | \ 74 NETIF_MSG_PROBE | \ 75 NETIF_MSG_LINK | \ 76 NETIF_MSG_IFDOWN | \ 77 NETIF_MSG_IFUP | \ 78 NETIF_MSG_RX_ERR | \ 79 NETIF_MSG_TX_ERR) 80 81 /* Descriptor skip length in 32 bit longwords. */ 82 #ifndef CONFIG_DE2104X_DSL 83 #define DSL 0 84 #else 85 #define DSL CONFIG_DE2104X_DSL 86 #endif 87 88 #define DE_RX_RING_SIZE 128 89 #define DE_TX_RING_SIZE 64 90 #define DE_RING_BYTES \ 91 ((sizeof(struct de_desc) * DE_RX_RING_SIZE) + \ 92 (sizeof(struct de_desc) * DE_TX_RING_SIZE)) 93 #define NEXT_TX(N) (((N) + 1) & (DE_TX_RING_SIZE - 1)) 94 #define NEXT_RX(N) (((N) + 1) & (DE_RX_RING_SIZE - 1)) 95 #define TX_BUFFS_AVAIL(CP) \ 96 (((CP)->tx_tail <= (CP)->tx_head) ? \ 97 (CP)->tx_tail + (DE_TX_RING_SIZE - 1) - (CP)->tx_head : \ 98 (CP)->tx_tail - (CP)->tx_head - 1) 99 100 #define PKT_BUF_SZ 1536 /* Size of each temporary Rx buffer.*/ 101 #define RX_OFFSET 2 102 103 #define DE_SETUP_SKB ((struct sk_buff *) 1) 104 #define DE_DUMMY_SKB ((struct sk_buff *) 2) 105 #define DE_SETUP_FRAME_WORDS 96 106 #define DE_EEPROM_WORDS 256 107 #define DE_EEPROM_SIZE (DE_EEPROM_WORDS * sizeof(u16)) 108 #define DE_MAX_MEDIA 5 109 110 #define DE_MEDIA_TP_AUTO 0 111 #define DE_MEDIA_BNC 1 112 #define DE_MEDIA_AUI 2 113 #define DE_MEDIA_TP 3 114 #define DE_MEDIA_TP_FD 4 115 #define DE_MEDIA_INVALID DE_MAX_MEDIA 116 #define DE_MEDIA_FIRST 0 117 #define DE_MEDIA_LAST (DE_MAX_MEDIA - 1) 118 #define DE_AUI_BNC (SUPPORTED_AUI | SUPPORTED_BNC) 119 120 #define DE_TIMER_LINK (60 * HZ) 121 #define DE_TIMER_NO_LINK (5 * HZ) 122 123 #define DE_NUM_REGS 16 124 #define DE_REGS_SIZE (DE_NUM_REGS * sizeof(u32)) 125 #define DE_REGS_VER 1 126 127 /* Time in jiffies before concluding the transmitter is hung. */ 128 #define TX_TIMEOUT (6*HZ) 129 130 /* This is a mysterious value that can be written to CSR11 in the 21040 (only) 131 to support a pre-NWay full-duplex signaling mechanism using short frames. 132 No one knows what it should be, but if left at its default value some 133 10base2(!) packets trigger a full-duplex-request interrupt. */ 134 #define FULL_DUPLEX_MAGIC 0x6969 135 136 enum { 137 /* NIC registers */ 138 BusMode = 0x00, 139 TxPoll = 0x08, 140 RxPoll = 0x10, 141 RxRingAddr = 0x18, 142 TxRingAddr = 0x20, 143 MacStatus = 0x28, 144 MacMode = 0x30, 145 IntrMask = 0x38, 146 RxMissed = 0x40, 147 ROMCmd = 0x48, 148 CSR11 = 0x58, 149 SIAStatus = 0x60, 150 CSR13 = 0x68, 151 CSR14 = 0x70, 152 CSR15 = 0x78, 153 PCIPM = 0x40, 154 155 /* BusMode bits */ 156 CmdReset = (1 << 0), 157 CacheAlign16 = 0x00008000, 158 BurstLen4 = 0x00000400, 159 DescSkipLen = (DSL << 2), 160 161 /* Rx/TxPoll bits */ 162 NormalTxPoll = (1 << 0), 163 NormalRxPoll = (1 << 0), 164 165 /* Tx/Rx descriptor status bits */ 166 DescOwn = (1 << 31), 167 RxError = (1 << 15), 168 RxErrLong = (1 << 7), 169 RxErrCRC = (1 << 1), 170 RxErrFIFO = (1 << 0), 171 RxErrRunt = (1 << 11), 172 RxErrFrame = (1 << 14), 173 RingEnd = (1 << 25), 174 FirstFrag = (1 << 29), 175 LastFrag = (1 << 30), 176 TxError = (1 << 15), 177 TxFIFOUnder = (1 << 1), 178 TxLinkFail = (1 << 2) | (1 << 10) | (1 << 11), 179 TxMaxCol = (1 << 8), 180 TxOWC = (1 << 9), 181 TxJabber = (1 << 14), 182 SetupFrame = (1 << 27), 183 TxSwInt = (1 << 31), 184 185 /* MacStatus bits */ 186 IntrOK = (1 << 16), 187 IntrErr = (1 << 15), 188 RxIntr = (1 << 6), 189 RxEmpty = (1 << 7), 190 TxIntr = (1 << 0), 191 TxEmpty = (1 << 2), 192 PciErr = (1 << 13), 193 TxState = (1 << 22) | (1 << 21) | (1 << 20), 194 RxState = (1 << 19) | (1 << 18) | (1 << 17), 195 LinkFail = (1 << 12), 196 LinkPass = (1 << 4), 197 RxStopped = (1 << 8), 198 TxStopped = (1 << 1), 199 200 /* MacMode bits */ 201 TxEnable = (1 << 13), 202 RxEnable = (1 << 1), 203 RxTx = TxEnable | RxEnable, 204 FullDuplex = (1 << 9), 205 AcceptAllMulticast = (1 << 7), 206 AcceptAllPhys = (1 << 6), 207 BOCnt = (1 << 5), 208 MacModeClear = (1<<12) | (1<<11) | (1<<10) | (1<<8) | (1<<3) | 209 RxTx | BOCnt | AcceptAllPhys | AcceptAllMulticast, 210 211 /* ROMCmd bits */ 212 EE_SHIFT_CLK = 0x02, /* EEPROM shift clock. */ 213 EE_CS = 0x01, /* EEPROM chip select. */ 214 EE_DATA_WRITE = 0x04, /* Data from the Tulip to EEPROM. */ 215 EE_WRITE_0 = 0x01, 216 EE_WRITE_1 = 0x05, 217 EE_DATA_READ = 0x08, /* Data from the EEPROM chip. */ 218 EE_ENB = (0x4800 | EE_CS), 219 220 /* The EEPROM commands include the alway-set leading bit. */ 221 EE_READ_CMD = 6, 222 223 /* RxMissed bits */ 224 RxMissedOver = (1 << 16), 225 RxMissedMask = 0xffff, 226 227 /* SROM-related bits */ 228 SROMC0InfoLeaf = 27, 229 MediaBlockMask = 0x3f, 230 MediaCustomCSRs = (1 << 6), 231 232 /* PCIPM bits */ 233 PM_Sleep = (1 << 31), 234 PM_Snooze = (1 << 30), 235 PM_Mask = PM_Sleep | PM_Snooze, 236 237 /* SIAStatus bits */ 238 NWayState = (1 << 14) | (1 << 13) | (1 << 12), 239 NWayRestart = (1 << 12), 240 NonselPortActive = (1 << 9), 241 SelPortActive = (1 << 8), 242 LinkFailStatus = (1 << 2), 243 NetCxnErr = (1 << 1), 244 }; 245 246 static const u32 de_intr_mask = 247 IntrOK | IntrErr | RxIntr | RxEmpty | TxIntr | TxEmpty | 248 LinkPass | LinkFail | PciErr; 249 250 /* 251 * Set the programmable burst length to 4 longwords for all: 252 * DMA errors result without these values. Cache align 16 long. 253 */ 254 static const u32 de_bus_mode = CacheAlign16 | BurstLen4 | DescSkipLen; 255 256 struct de_srom_media_block { 257 u8 opts; 258 u16 csr13; 259 u16 csr14; 260 u16 csr15; 261 } __packed; 262 263 struct de_srom_info_leaf { 264 u16 default_media; 265 u8 n_blocks; 266 u8 unused; 267 } __packed; 268 269 struct de_desc { 270 __le32 opts1; 271 __le32 opts2; 272 __le32 addr1; 273 __le32 addr2; 274 #if DSL 275 __le32 skip[DSL]; 276 #endif 277 }; 278 279 struct media_info { 280 u16 type; /* DE_MEDIA_xxx */ 281 u16 csr13; 282 u16 csr14; 283 u16 csr15; 284 }; 285 286 struct ring_info { 287 struct sk_buff *skb; 288 dma_addr_t mapping; 289 }; 290 291 struct de_private { 292 unsigned tx_head; 293 unsigned tx_tail; 294 unsigned rx_tail; 295 296 void __iomem *regs; 297 struct net_device *dev; 298 spinlock_t lock; 299 300 struct de_desc *rx_ring; 301 struct de_desc *tx_ring; 302 struct ring_info tx_skb[DE_TX_RING_SIZE]; 303 struct ring_info rx_skb[DE_RX_RING_SIZE]; 304 unsigned rx_buf_sz; 305 dma_addr_t ring_dma; 306 307 u32 msg_enable; 308 309 struct pci_dev *pdev; 310 311 u16 setup_frame[DE_SETUP_FRAME_WORDS]; 312 313 u32 media_type; 314 u32 media_supported; 315 u32 media_advertise; 316 struct media_info media[DE_MAX_MEDIA]; 317 struct timer_list media_timer; 318 319 u8 *ee_data; 320 unsigned board_idx; 321 unsigned de21040 : 1; 322 unsigned media_lock : 1; 323 }; 324 325 326 static void de_set_rx_mode (struct net_device *dev); 327 static void de_tx (struct de_private *de); 328 static void de_clean_rings (struct de_private *de); 329 static void de_media_interrupt (struct de_private *de, u32 status); 330 static void de21040_media_timer (struct timer_list *t); 331 static void de21041_media_timer (struct timer_list *t); 332 static unsigned int de_ok_to_advertise (struct de_private *de, u32 new_media); 333 334 335 static const struct pci_device_id de_pci_tbl[] = { 336 { PCI_VDEVICE(DEC, PCI_DEVICE_ID_DEC_TULIP), .driver_data = 0 }, 337 { PCI_VDEVICE(DEC, PCI_DEVICE_ID_DEC_TULIP_PLUS), .driver_data = 1 }, 338 { }, 339 }; 340 MODULE_DEVICE_TABLE(pci, de_pci_tbl); 341 342 static const char * const media_name[DE_MAX_MEDIA] = { 343 "10baseT auto", 344 "BNC", 345 "AUI", 346 "10baseT-HD", 347 "10baseT-FD" 348 }; 349 350 /* 21040 transceiver register settings: 351 * TP AUTO(unused), BNC(unused), AUI, TP, TP FD*/ 352 static u16 t21040_csr13[] = { 0, 0, 0x8F09, 0x8F01, 0x8F01, }; 353 static u16 t21040_csr14[] = { 0, 0, 0x0705, 0xFFFF, 0xFFFD, }; 354 static u16 t21040_csr15[] = { 0, 0, 0x0006, 0x0000, 0x0000, }; 355 356 /* 21041 transceiver register settings: TP AUTO, BNC, AUI, TP, TP FD*/ 357 static u16 t21041_csr13[] = { 0xEF01, 0xEF09, 0xEF09, 0xEF01, 0xEF09, }; 358 static u16 t21041_csr14[] = { 0xFFFF, 0xF7FD, 0xF7FD, 0x7F3F, 0x7F3D, }; 359 /* If on-chip autonegotiation is broken, use half-duplex (FF3F) instead */ 360 static u16 t21041_csr14_brk[] = { 0xFF3F, 0xF7FD, 0xF7FD, 0x7F3F, 0x7F3D, }; 361 static u16 t21041_csr15[] = { 0x0008, 0x0006, 0x000E, 0x0008, 0x0008, }; 362 363 364 #define dr32(reg) ioread32(de->regs + (reg)) 365 #define dw32(reg, val) iowrite32((val), de->regs + (reg)) 366 367 368 static void de_rx_err_acct (struct de_private *de, unsigned rx_tail, 369 u32 status, u32 len) 370 { 371 netif_dbg(de, rx_err, de->dev, 372 "rx err, slot %d status 0x%x len %d\n", 373 rx_tail, status, len); 374 375 if ((status & 0x38000300) != 0x0300) { 376 /* Ingore earlier buffers. */ 377 if ((status & 0xffff) != 0x7fff) { 378 netif_warn(de, rx_err, de->dev, 379 "Oversized Ethernet frame spanned multiple buffers, status %08x!\n", 380 status); 381 de->dev->stats.rx_length_errors++; 382 } 383 } else if (status & RxError) { 384 /* There was a fatal error. */ 385 de->dev->stats.rx_errors++; /* end of a packet.*/ 386 if (status & 0x0890) de->dev->stats.rx_length_errors++; 387 if (status & RxErrCRC) de->dev->stats.rx_crc_errors++; 388 if (status & RxErrFIFO) de->dev->stats.rx_fifo_errors++; 389 } 390 } 391 392 static void de_rx (struct de_private *de) 393 { 394 unsigned rx_tail = de->rx_tail; 395 unsigned rx_work = DE_RX_RING_SIZE; 396 unsigned drop = 0; 397 int rc; 398 399 while (--rx_work) { 400 u32 status, len; 401 dma_addr_t mapping; 402 struct sk_buff *skb, *copy_skb; 403 unsigned copying_skb, buflen; 404 405 skb = de->rx_skb[rx_tail].skb; 406 BUG_ON(!skb); 407 rmb(); 408 status = le32_to_cpu(de->rx_ring[rx_tail].opts1); 409 if (status & DescOwn) 410 break; 411 412 /* the length is actually a 15 bit value here according 413 * to Table 4-1 in the DE2104x spec so mask is 0x7fff 414 */ 415 len = ((status >> 16) & 0x7fff) - 4; 416 mapping = de->rx_skb[rx_tail].mapping; 417 418 if (unlikely(drop)) { 419 de->dev->stats.rx_dropped++; 420 goto rx_next; 421 } 422 423 if (unlikely((status & 0x38008300) != 0x0300)) { 424 de_rx_err_acct(de, rx_tail, status, len); 425 goto rx_next; 426 } 427 428 copying_skb = (len <= rx_copybreak); 429 430 netif_dbg(de, rx_status, de->dev, 431 "rx slot %d status 0x%x len %d copying? %d\n", 432 rx_tail, status, len, copying_skb); 433 434 buflen = copying_skb ? (len + RX_OFFSET) : de->rx_buf_sz; 435 copy_skb = netdev_alloc_skb(de->dev, buflen); 436 if (unlikely(!copy_skb)) { 437 de->dev->stats.rx_dropped++; 438 drop = 1; 439 rx_work = 100; 440 goto rx_next; 441 } 442 443 if (!copying_skb) { 444 dma_unmap_single(&de->pdev->dev, mapping, buflen, 445 DMA_FROM_DEVICE); 446 skb_put(skb, len); 447 448 mapping = 449 de->rx_skb[rx_tail].mapping = 450 dma_map_single(&de->pdev->dev, copy_skb->data, 451 buflen, DMA_FROM_DEVICE); 452 de->rx_skb[rx_tail].skb = copy_skb; 453 } else { 454 dma_sync_single_for_cpu(&de->pdev->dev, mapping, len, 455 DMA_FROM_DEVICE); 456 skb_reserve(copy_skb, RX_OFFSET); 457 skb_copy_from_linear_data(skb, skb_put(copy_skb, len), 458 len); 459 dma_sync_single_for_device(&de->pdev->dev, mapping, 460 len, DMA_FROM_DEVICE); 461 462 /* We'll reuse the original ring buffer. */ 463 skb = copy_skb; 464 } 465 466 skb->protocol = eth_type_trans (skb, de->dev); 467 468 de->dev->stats.rx_packets++; 469 de->dev->stats.rx_bytes += skb->len; 470 rc = netif_rx (skb); 471 if (rc == NET_RX_DROP) 472 drop = 1; 473 474 rx_next: 475 if (rx_tail == (DE_RX_RING_SIZE - 1)) 476 de->rx_ring[rx_tail].opts2 = 477 cpu_to_le32(RingEnd | de->rx_buf_sz); 478 else 479 de->rx_ring[rx_tail].opts2 = cpu_to_le32(de->rx_buf_sz); 480 de->rx_ring[rx_tail].addr1 = cpu_to_le32(mapping); 481 wmb(); 482 de->rx_ring[rx_tail].opts1 = cpu_to_le32(DescOwn); 483 rx_tail = NEXT_RX(rx_tail); 484 } 485 486 if (!rx_work) 487 netdev_warn(de->dev, "rx work limit reached\n"); 488 489 de->rx_tail = rx_tail; 490 } 491 492 static irqreturn_t de_interrupt (int irq, void *dev_instance) 493 { 494 struct net_device *dev = dev_instance; 495 struct de_private *de = netdev_priv(dev); 496 u32 status; 497 498 status = dr32(MacStatus); 499 if ((!(status & (IntrOK|IntrErr))) || (status == 0xFFFF)) 500 return IRQ_NONE; 501 502 netif_dbg(de, intr, dev, "intr, status %08x mode %08x desc %u/%u/%u\n", 503 status, dr32(MacMode), 504 de->rx_tail, de->tx_head, de->tx_tail); 505 506 dw32(MacStatus, status); 507 508 if (status & (RxIntr | RxEmpty)) { 509 de_rx(de); 510 if (status & RxEmpty) 511 dw32(RxPoll, NormalRxPoll); 512 } 513 514 spin_lock(&de->lock); 515 516 if (status & (TxIntr | TxEmpty)) 517 de_tx(de); 518 519 if (status & (LinkPass | LinkFail)) 520 de_media_interrupt(de, status); 521 522 spin_unlock(&de->lock); 523 524 if (status & PciErr) { 525 u16 pci_status; 526 527 pci_read_config_word(de->pdev, PCI_STATUS, &pci_status); 528 pci_write_config_word(de->pdev, PCI_STATUS, pci_status); 529 netdev_err(de->dev, 530 "PCI bus error, status=%08x, PCI status=%04x\n", 531 status, pci_status); 532 } 533 534 return IRQ_HANDLED; 535 } 536 537 static void de_tx (struct de_private *de) 538 { 539 unsigned tx_head = de->tx_head; 540 unsigned tx_tail = de->tx_tail; 541 542 while (tx_tail != tx_head) { 543 struct sk_buff *skb; 544 u32 status; 545 546 rmb(); 547 status = le32_to_cpu(de->tx_ring[tx_tail].opts1); 548 if (status & DescOwn) 549 break; 550 551 skb = de->tx_skb[tx_tail].skb; 552 BUG_ON(!skb); 553 if (unlikely(skb == DE_DUMMY_SKB)) 554 goto next; 555 556 if (unlikely(skb == DE_SETUP_SKB)) { 557 dma_unmap_single(&de->pdev->dev, 558 de->tx_skb[tx_tail].mapping, 559 sizeof(de->setup_frame), 560 DMA_TO_DEVICE); 561 goto next; 562 } 563 564 dma_unmap_single(&de->pdev->dev, de->tx_skb[tx_tail].mapping, 565 skb->len, DMA_TO_DEVICE); 566 567 if (status & LastFrag) { 568 if (status & TxError) { 569 netif_dbg(de, tx_err, de->dev, 570 "tx err, status 0x%x\n", 571 status); 572 de->dev->stats.tx_errors++; 573 if (status & TxOWC) 574 de->dev->stats.tx_window_errors++; 575 if (status & TxMaxCol) 576 de->dev->stats.tx_aborted_errors++; 577 if (status & TxLinkFail) 578 de->dev->stats.tx_carrier_errors++; 579 if (status & TxFIFOUnder) 580 de->dev->stats.tx_fifo_errors++; 581 } else { 582 de->dev->stats.tx_packets++; 583 de->dev->stats.tx_bytes += skb->len; 584 netif_dbg(de, tx_done, de->dev, 585 "tx done, slot %d\n", tx_tail); 586 } 587 dev_consume_skb_irq(skb); 588 } 589 590 next: 591 de->tx_skb[tx_tail].skb = NULL; 592 593 tx_tail = NEXT_TX(tx_tail); 594 } 595 596 de->tx_tail = tx_tail; 597 598 if (netif_queue_stopped(de->dev) && (TX_BUFFS_AVAIL(de) > (DE_TX_RING_SIZE / 4))) 599 netif_wake_queue(de->dev); 600 } 601 602 static netdev_tx_t de_start_xmit (struct sk_buff *skb, 603 struct net_device *dev) 604 { 605 struct de_private *de = netdev_priv(dev); 606 unsigned int entry, tx_free; 607 u32 mapping, len, flags = FirstFrag | LastFrag; 608 struct de_desc *txd; 609 610 spin_lock_irq(&de->lock); 611 612 tx_free = TX_BUFFS_AVAIL(de); 613 if (tx_free == 0) { 614 netif_stop_queue(dev); 615 spin_unlock_irq(&de->lock); 616 return NETDEV_TX_BUSY; 617 } 618 tx_free--; 619 620 entry = de->tx_head; 621 622 txd = &de->tx_ring[entry]; 623 624 len = skb->len; 625 mapping = dma_map_single(&de->pdev->dev, skb->data, len, 626 DMA_TO_DEVICE); 627 if (entry == (DE_TX_RING_SIZE - 1)) 628 flags |= RingEnd; 629 if (!tx_free || (tx_free == (DE_TX_RING_SIZE / 2))) 630 flags |= TxSwInt; 631 flags |= len; 632 txd->opts2 = cpu_to_le32(flags); 633 txd->addr1 = cpu_to_le32(mapping); 634 635 de->tx_skb[entry].skb = skb; 636 de->tx_skb[entry].mapping = mapping; 637 wmb(); 638 639 txd->opts1 = cpu_to_le32(DescOwn); 640 wmb(); 641 642 de->tx_head = NEXT_TX(entry); 643 netif_dbg(de, tx_queued, dev, "tx queued, slot %d, skblen %d\n", 644 entry, skb->len); 645 646 if (tx_free == 0) 647 netif_stop_queue(dev); 648 649 spin_unlock_irq(&de->lock); 650 651 /* Trigger an immediate transmit demand. */ 652 dw32(TxPoll, NormalTxPoll); 653 654 return NETDEV_TX_OK; 655 } 656 657 /* Set or clear the multicast filter for this adaptor. 658 Note that we only use exclusion around actually queueing the 659 new frame, not around filling de->setup_frame. This is non-deterministic 660 when re-entered but still correct. */ 661 662 static void build_setup_frame_hash(u16 *setup_frm, struct net_device *dev) 663 { 664 struct de_private *de = netdev_priv(dev); 665 u16 hash_table[32]; 666 struct netdev_hw_addr *ha; 667 const u16 *eaddrs; 668 int i; 669 670 memset(hash_table, 0, sizeof(hash_table)); 671 __set_bit_le(255, hash_table); /* Broadcast entry */ 672 /* This should work on big-endian machines as well. */ 673 netdev_for_each_mc_addr(ha, dev) { 674 int index = ether_crc_le(ETH_ALEN, ha->addr) & 0x1ff; 675 676 __set_bit_le(index, hash_table); 677 } 678 679 for (i = 0; i < 32; i++) { 680 *setup_frm++ = hash_table[i]; 681 *setup_frm++ = hash_table[i]; 682 } 683 setup_frm = &de->setup_frame[13*6]; 684 685 /* Fill the final entry with our physical address. */ 686 eaddrs = (const u16 *)dev->dev_addr; 687 *setup_frm++ = eaddrs[0]; *setup_frm++ = eaddrs[0]; 688 *setup_frm++ = eaddrs[1]; *setup_frm++ = eaddrs[1]; 689 *setup_frm++ = eaddrs[2]; *setup_frm++ = eaddrs[2]; 690 } 691 692 static void build_setup_frame_perfect(u16 *setup_frm, struct net_device *dev) 693 { 694 struct de_private *de = netdev_priv(dev); 695 struct netdev_hw_addr *ha; 696 const u16 *eaddrs; 697 698 /* We have <= 14 addresses so we can use the wonderful 699 16 address perfect filtering of the Tulip. */ 700 netdev_for_each_mc_addr(ha, dev) { 701 eaddrs = (u16 *) ha->addr; 702 *setup_frm++ = *eaddrs; *setup_frm++ = *eaddrs++; 703 *setup_frm++ = *eaddrs; *setup_frm++ = *eaddrs++; 704 *setup_frm++ = *eaddrs; *setup_frm++ = *eaddrs++; 705 } 706 /* Fill the unused entries with the broadcast address. */ 707 memset(setup_frm, 0xff, (15 - netdev_mc_count(dev)) * 12); 708 setup_frm = &de->setup_frame[15*6]; 709 710 /* Fill the final entry with our physical address. */ 711 eaddrs = (const u16 *)dev->dev_addr; 712 *setup_frm++ = eaddrs[0]; *setup_frm++ = eaddrs[0]; 713 *setup_frm++ = eaddrs[1]; *setup_frm++ = eaddrs[1]; 714 *setup_frm++ = eaddrs[2]; *setup_frm++ = eaddrs[2]; 715 } 716 717 718 static void __de_set_rx_mode (struct net_device *dev) 719 { 720 struct de_private *de = netdev_priv(dev); 721 u32 macmode; 722 unsigned int entry; 723 u32 mapping; 724 struct de_desc *txd; 725 struct de_desc *dummy_txd = NULL; 726 727 macmode = dr32(MacMode) & ~(AcceptAllMulticast | AcceptAllPhys); 728 729 if (dev->flags & IFF_PROMISC) { /* Set promiscuous. */ 730 macmode |= AcceptAllMulticast | AcceptAllPhys; 731 goto out; 732 } 733 734 if ((netdev_mc_count(dev) > 1000) || (dev->flags & IFF_ALLMULTI)) { 735 /* Too many to filter well -- accept all multicasts. */ 736 macmode |= AcceptAllMulticast; 737 goto out; 738 } 739 740 /* Note that only the low-address shortword of setup_frame is valid! 741 The values are doubled for big-endian architectures. */ 742 if (netdev_mc_count(dev) > 14) /* Must use a multicast hash table. */ 743 build_setup_frame_hash (de->setup_frame, dev); 744 else 745 build_setup_frame_perfect (de->setup_frame, dev); 746 747 /* 748 * Now add this frame to the Tx list. 749 */ 750 751 entry = de->tx_head; 752 753 /* Avoid a chip errata by prefixing a dummy entry. */ 754 if (entry != 0) { 755 de->tx_skb[entry].skb = DE_DUMMY_SKB; 756 757 dummy_txd = &de->tx_ring[entry]; 758 dummy_txd->opts2 = (entry == (DE_TX_RING_SIZE - 1)) ? 759 cpu_to_le32(RingEnd) : 0; 760 dummy_txd->addr1 = 0; 761 762 /* Must set DescOwned later to avoid race with chip */ 763 764 entry = NEXT_TX(entry); 765 } 766 767 de->tx_skb[entry].skb = DE_SETUP_SKB; 768 de->tx_skb[entry].mapping = mapping = 769 dma_map_single(&de->pdev->dev, de->setup_frame, 770 sizeof(de->setup_frame), DMA_TO_DEVICE); 771 772 /* Put the setup frame on the Tx list. */ 773 txd = &de->tx_ring[entry]; 774 if (entry == (DE_TX_RING_SIZE - 1)) 775 txd->opts2 = cpu_to_le32(SetupFrame | RingEnd | sizeof (de->setup_frame)); 776 else 777 txd->opts2 = cpu_to_le32(SetupFrame | sizeof (de->setup_frame)); 778 txd->addr1 = cpu_to_le32(mapping); 779 wmb(); 780 781 txd->opts1 = cpu_to_le32(DescOwn); 782 wmb(); 783 784 if (dummy_txd) { 785 dummy_txd->opts1 = cpu_to_le32(DescOwn); 786 wmb(); 787 } 788 789 de->tx_head = NEXT_TX(entry); 790 791 if (TX_BUFFS_AVAIL(de) == 0) 792 netif_stop_queue(dev); 793 794 /* Trigger an immediate transmit demand. */ 795 dw32(TxPoll, NormalTxPoll); 796 797 out: 798 if (macmode != dr32(MacMode)) 799 dw32(MacMode, macmode); 800 } 801 802 static void de_set_rx_mode (struct net_device *dev) 803 { 804 unsigned long flags; 805 struct de_private *de = netdev_priv(dev); 806 807 spin_lock_irqsave (&de->lock, flags); 808 __de_set_rx_mode(dev); 809 spin_unlock_irqrestore (&de->lock, flags); 810 } 811 812 static inline void de_rx_missed(struct de_private *de, u32 rx_missed) 813 { 814 if (unlikely(rx_missed & RxMissedOver)) 815 de->dev->stats.rx_missed_errors += RxMissedMask; 816 else 817 de->dev->stats.rx_missed_errors += (rx_missed & RxMissedMask); 818 } 819 820 static void __de_get_stats(struct de_private *de) 821 { 822 u32 tmp = dr32(RxMissed); /* self-clearing */ 823 824 de_rx_missed(de, tmp); 825 } 826 827 static struct net_device_stats *de_get_stats(struct net_device *dev) 828 { 829 struct de_private *de = netdev_priv(dev); 830 831 /* The chip only need report frame silently dropped. */ 832 spin_lock_irq(&de->lock); 833 if (netif_running(dev) && netif_device_present(dev)) 834 __de_get_stats(de); 835 spin_unlock_irq(&de->lock); 836 837 return &dev->stats; 838 } 839 840 static inline int de_is_running (struct de_private *de) 841 { 842 return (dr32(MacStatus) & (RxState | TxState)) ? 1 : 0; 843 } 844 845 static void de_stop_rxtx (struct de_private *de) 846 { 847 u32 macmode; 848 unsigned int i = 1300/100; 849 850 macmode = dr32(MacMode); 851 if (macmode & RxTx) { 852 dw32(MacMode, macmode & ~RxTx); 853 dr32(MacMode); 854 } 855 856 /* wait until in-flight frame completes. 857 * Max time @ 10BT: 1500*8b/10Mbps == 1200us (+ 100us margin) 858 * Typically expect this loop to end in < 50 us on 100BT. 859 */ 860 while (--i) { 861 if (!de_is_running(de)) 862 return; 863 udelay(100); 864 } 865 866 netdev_warn(de->dev, "timeout expired, stopping DMA\n"); 867 } 868 869 static inline void de_start_rxtx (struct de_private *de) 870 { 871 u32 macmode; 872 873 macmode = dr32(MacMode); 874 if ((macmode & RxTx) != RxTx) { 875 dw32(MacMode, macmode | RxTx); 876 dr32(MacMode); 877 } 878 } 879 880 static void de_stop_hw (struct de_private *de) 881 { 882 883 udelay(5); 884 dw32(IntrMask, 0); 885 886 de_stop_rxtx(de); 887 888 dw32(MacStatus, dr32(MacStatus)); 889 890 udelay(10); 891 892 de->rx_tail = 0; 893 de->tx_head = de->tx_tail = 0; 894 } 895 896 static void de_link_up(struct de_private *de) 897 { 898 if (!netif_carrier_ok(de->dev)) { 899 netif_carrier_on(de->dev); 900 netif_info(de, link, de->dev, "link up, media %s\n", 901 media_name[de->media_type]); 902 } 903 } 904 905 static void de_link_down(struct de_private *de) 906 { 907 if (netif_carrier_ok(de->dev)) { 908 netif_carrier_off(de->dev); 909 netif_info(de, link, de->dev, "link down\n"); 910 } 911 } 912 913 static void de_set_media (struct de_private *de) 914 { 915 unsigned media = de->media_type; 916 u32 macmode = dr32(MacMode); 917 918 if (de_is_running(de)) 919 netdev_warn(de->dev, "chip is running while changing media!\n"); 920 921 if (de->de21040) 922 dw32(CSR11, FULL_DUPLEX_MAGIC); 923 dw32(CSR13, 0); /* Reset phy */ 924 dw32(CSR14, de->media[media].csr14); 925 dw32(CSR15, de->media[media].csr15); 926 dw32(CSR13, de->media[media].csr13); 927 928 /* must delay 10ms before writing to other registers, 929 * especially CSR6 930 */ 931 mdelay(10); 932 933 if (media == DE_MEDIA_TP_FD) 934 macmode |= FullDuplex; 935 else 936 macmode &= ~FullDuplex; 937 938 netif_info(de, link, de->dev, "set link %s\n", media_name[media]); 939 netif_info(de, hw, de->dev, "mode 0x%x, sia 0x%x,0x%x,0x%x,0x%x\n", 940 dr32(MacMode), dr32(SIAStatus), 941 dr32(CSR13), dr32(CSR14), dr32(CSR15)); 942 netif_info(de, hw, de->dev, "set mode 0x%x, set sia 0x%x,0x%x,0x%x\n", 943 macmode, de->media[media].csr13, 944 de->media[media].csr14, de->media[media].csr15); 945 if (macmode != dr32(MacMode)) 946 dw32(MacMode, macmode); 947 } 948 949 static void de_next_media (struct de_private *de, const u32 *media, 950 unsigned int n_media) 951 { 952 unsigned int i; 953 954 for (i = 0; i < n_media; i++) { 955 if (de_ok_to_advertise(de, media[i])) { 956 de->media_type = media[i]; 957 return; 958 } 959 } 960 } 961 962 static void de21040_media_timer (struct timer_list *t) 963 { 964 struct de_private *de = timer_container_of(de, t, media_timer); 965 struct net_device *dev = de->dev; 966 u32 status = dr32(SIAStatus); 967 unsigned int carrier; 968 unsigned long flags; 969 970 carrier = (status & NetCxnErr) ? 0 : 1; 971 972 if (carrier) { 973 if (de->media_type != DE_MEDIA_AUI && (status & LinkFailStatus)) 974 goto no_link_yet; 975 976 de->media_timer.expires = jiffies + DE_TIMER_LINK; 977 add_timer(&de->media_timer); 978 if (!netif_carrier_ok(dev)) 979 de_link_up(de); 980 else 981 netif_info(de, timer, dev, "%s link ok, status %x\n", 982 media_name[de->media_type], status); 983 return; 984 } 985 986 de_link_down(de); 987 988 if (de->media_lock) 989 return; 990 991 if (de->media_type == DE_MEDIA_AUI) { 992 static const u32 next_state = DE_MEDIA_TP; 993 de_next_media(de, &next_state, 1); 994 } else { 995 static const u32 next_state = DE_MEDIA_AUI; 996 de_next_media(de, &next_state, 1); 997 } 998 999 spin_lock_irqsave(&de->lock, flags); 1000 de_stop_rxtx(de); 1001 spin_unlock_irqrestore(&de->lock, flags); 1002 de_set_media(de); 1003 de_start_rxtx(de); 1004 1005 no_link_yet: 1006 de->media_timer.expires = jiffies + DE_TIMER_NO_LINK; 1007 add_timer(&de->media_timer); 1008 1009 netif_info(de, timer, dev, "no link, trying media %s, status %x\n", 1010 media_name[de->media_type], status); 1011 } 1012 1013 static unsigned int de_ok_to_advertise (struct de_private *de, u32 new_media) 1014 { 1015 switch (new_media) { 1016 case DE_MEDIA_TP_AUTO: 1017 if (!(de->media_advertise & ADVERTISED_Autoneg)) 1018 return 0; 1019 if (!(de->media_advertise & (ADVERTISED_10baseT_Half | ADVERTISED_10baseT_Full))) 1020 return 0; 1021 break; 1022 case DE_MEDIA_BNC: 1023 if (!(de->media_advertise & ADVERTISED_BNC)) 1024 return 0; 1025 break; 1026 case DE_MEDIA_AUI: 1027 if (!(de->media_advertise & ADVERTISED_AUI)) 1028 return 0; 1029 break; 1030 case DE_MEDIA_TP: 1031 if (!(de->media_advertise & ADVERTISED_10baseT_Half)) 1032 return 0; 1033 break; 1034 case DE_MEDIA_TP_FD: 1035 if (!(de->media_advertise & ADVERTISED_10baseT_Full)) 1036 return 0; 1037 break; 1038 } 1039 1040 return 1; 1041 } 1042 1043 static void de21041_media_timer (struct timer_list *t) 1044 { 1045 struct de_private *de = timer_container_of(de, t, media_timer); 1046 struct net_device *dev = de->dev; 1047 u32 status = dr32(SIAStatus); 1048 unsigned int carrier; 1049 unsigned long flags; 1050 1051 /* clear port active bits */ 1052 dw32(SIAStatus, NonselPortActive | SelPortActive); 1053 1054 carrier = (status & NetCxnErr) ? 0 : 1; 1055 1056 if (carrier) { 1057 if ((de->media_type == DE_MEDIA_TP_AUTO || 1058 de->media_type == DE_MEDIA_TP || 1059 de->media_type == DE_MEDIA_TP_FD) && 1060 (status & LinkFailStatus)) 1061 goto no_link_yet; 1062 1063 de->media_timer.expires = jiffies + DE_TIMER_LINK; 1064 add_timer(&de->media_timer); 1065 if (!netif_carrier_ok(dev)) 1066 de_link_up(de); 1067 else 1068 netif_info(de, timer, dev, 1069 "%s link ok, mode %x status %x\n", 1070 media_name[de->media_type], 1071 dr32(MacMode), status); 1072 return; 1073 } 1074 1075 de_link_down(de); 1076 1077 /* if media type locked, don't switch media */ 1078 if (de->media_lock) 1079 goto set_media; 1080 1081 /* if activity detected, use that as hint for new media type */ 1082 if (status & NonselPortActive) { 1083 unsigned int have_media = 1; 1084 1085 /* if AUI/BNC selected, then activity is on TP port */ 1086 if (de->media_type == DE_MEDIA_AUI || 1087 de->media_type == DE_MEDIA_BNC) { 1088 if (de_ok_to_advertise(de, DE_MEDIA_TP_AUTO)) 1089 de->media_type = DE_MEDIA_TP_AUTO; 1090 else 1091 have_media = 0; 1092 } 1093 1094 /* TP selected. If there is only TP and BNC, then it's BNC */ 1095 else if (((de->media_supported & DE_AUI_BNC) == SUPPORTED_BNC) && 1096 de_ok_to_advertise(de, DE_MEDIA_BNC)) 1097 de->media_type = DE_MEDIA_BNC; 1098 1099 /* TP selected. If there is only TP and AUI, then it's AUI */ 1100 else if (((de->media_supported & DE_AUI_BNC) == SUPPORTED_AUI) && 1101 de_ok_to_advertise(de, DE_MEDIA_AUI)) 1102 de->media_type = DE_MEDIA_AUI; 1103 1104 /* otherwise, ignore the hint */ 1105 else 1106 have_media = 0; 1107 1108 if (have_media) 1109 goto set_media; 1110 } 1111 1112 /* 1113 * Absent or ambiguous activity hint, move to next advertised 1114 * media state. If de->media_type is left unchanged, this 1115 * simply resets the PHY and reloads the current media settings. 1116 */ 1117 if (de->media_type == DE_MEDIA_AUI) { 1118 static const u32 next_states[] = { 1119 DE_MEDIA_BNC, DE_MEDIA_TP_AUTO 1120 }; 1121 de_next_media(de, next_states, ARRAY_SIZE(next_states)); 1122 } else if (de->media_type == DE_MEDIA_BNC) { 1123 static const u32 next_states[] = { 1124 DE_MEDIA_TP_AUTO, DE_MEDIA_AUI 1125 }; 1126 de_next_media(de, next_states, ARRAY_SIZE(next_states)); 1127 } else { 1128 static const u32 next_states[] = { 1129 DE_MEDIA_AUI, DE_MEDIA_BNC, DE_MEDIA_TP_AUTO 1130 }; 1131 de_next_media(de, next_states, ARRAY_SIZE(next_states)); 1132 } 1133 1134 set_media: 1135 spin_lock_irqsave(&de->lock, flags); 1136 de_stop_rxtx(de); 1137 spin_unlock_irqrestore(&de->lock, flags); 1138 de_set_media(de); 1139 de_start_rxtx(de); 1140 1141 no_link_yet: 1142 de->media_timer.expires = jiffies + DE_TIMER_NO_LINK; 1143 add_timer(&de->media_timer); 1144 1145 netif_info(de, timer, dev, "no link, trying media %s, status %x\n", 1146 media_name[de->media_type], status); 1147 } 1148 1149 static void de_media_interrupt (struct de_private *de, u32 status) 1150 { 1151 if (status & LinkPass) { 1152 /* Ignore if current media is AUI or BNC and we can't use TP */ 1153 if ((de->media_type == DE_MEDIA_AUI || 1154 de->media_type == DE_MEDIA_BNC) && 1155 (de->media_lock || 1156 !de_ok_to_advertise(de, DE_MEDIA_TP_AUTO))) 1157 return; 1158 /* If current media is not TP, change it to TP */ 1159 if ((de->media_type == DE_MEDIA_AUI || 1160 de->media_type == DE_MEDIA_BNC)) { 1161 de->media_type = DE_MEDIA_TP_AUTO; 1162 de_stop_rxtx(de); 1163 de_set_media(de); 1164 de_start_rxtx(de); 1165 } 1166 de_link_up(de); 1167 mod_timer(&de->media_timer, jiffies + DE_TIMER_LINK); 1168 return; 1169 } 1170 1171 BUG_ON(!(status & LinkFail)); 1172 /* Mark the link as down only if current media is TP */ 1173 if (netif_carrier_ok(de->dev) && de->media_type != DE_MEDIA_AUI && 1174 de->media_type != DE_MEDIA_BNC) { 1175 de_link_down(de); 1176 mod_timer(&de->media_timer, jiffies + DE_TIMER_NO_LINK); 1177 } 1178 } 1179 1180 static int de_reset_mac (struct de_private *de) 1181 { 1182 u32 status, tmp; 1183 1184 /* 1185 * Reset MAC. de4x5.c and tulip.c examined for "advice" 1186 * in this area. 1187 */ 1188 1189 if (dr32(BusMode) == 0xffffffff) 1190 return -EBUSY; 1191 1192 /* Reset the chip, holding bit 0 set at least 50 PCI cycles. */ 1193 dw32 (BusMode, CmdReset); 1194 mdelay (1); 1195 1196 dw32 (BusMode, de_bus_mode); 1197 mdelay (1); 1198 1199 for (tmp = 0; tmp < 5; tmp++) { 1200 dr32 (BusMode); 1201 mdelay (1); 1202 } 1203 1204 mdelay (1); 1205 1206 status = dr32(MacStatus); 1207 if (status & (RxState | TxState)) 1208 return -EBUSY; 1209 if (status == 0xffffffff) 1210 return -ENODEV; 1211 return 0; 1212 } 1213 1214 static void de_adapter_wake (struct de_private *de) 1215 { 1216 u32 pmctl; 1217 1218 if (de->de21040) 1219 return; 1220 1221 pci_read_config_dword(de->pdev, PCIPM, &pmctl); 1222 if (pmctl & PM_Mask) { 1223 pmctl &= ~PM_Mask; 1224 pci_write_config_dword(de->pdev, PCIPM, pmctl); 1225 1226 /* de4x5.c delays, so we do too */ 1227 msleep(10); 1228 } 1229 } 1230 1231 static void de_adapter_sleep (struct de_private *de) 1232 { 1233 u32 pmctl; 1234 1235 if (de->de21040) 1236 return; 1237 1238 dw32(CSR13, 0); /* Reset phy */ 1239 pci_read_config_dword(de->pdev, PCIPM, &pmctl); 1240 pmctl |= PM_Sleep; 1241 pci_write_config_dword(de->pdev, PCIPM, pmctl); 1242 } 1243 1244 static int de_init_hw (struct de_private *de) 1245 { 1246 struct net_device *dev = de->dev; 1247 u32 macmode; 1248 int rc; 1249 1250 de_adapter_wake(de); 1251 1252 macmode = dr32(MacMode) & ~MacModeClear; 1253 1254 rc = de_reset_mac(de); 1255 if (rc) 1256 return rc; 1257 1258 de_set_media(de); /* reset phy */ 1259 1260 dw32(RxRingAddr, de->ring_dma); 1261 dw32(TxRingAddr, de->ring_dma + (sizeof(struct de_desc) * DE_RX_RING_SIZE)); 1262 1263 dw32(MacMode, RxTx | macmode); 1264 1265 dr32(RxMissed); /* self-clearing */ 1266 1267 dw32(IntrMask, de_intr_mask); 1268 1269 de_set_rx_mode(dev); 1270 1271 return 0; 1272 } 1273 1274 static int de_refill_rx (struct de_private *de) 1275 { 1276 unsigned i; 1277 1278 for (i = 0; i < DE_RX_RING_SIZE; i++) { 1279 struct sk_buff *skb; 1280 1281 skb = netdev_alloc_skb(de->dev, de->rx_buf_sz); 1282 if (!skb) 1283 goto err_out; 1284 1285 de->rx_skb[i].mapping = dma_map_single(&de->pdev->dev, 1286 skb->data, 1287 de->rx_buf_sz, 1288 DMA_FROM_DEVICE); 1289 de->rx_skb[i].skb = skb; 1290 1291 de->rx_ring[i].opts1 = cpu_to_le32(DescOwn); 1292 if (i == (DE_RX_RING_SIZE - 1)) 1293 de->rx_ring[i].opts2 = 1294 cpu_to_le32(RingEnd | de->rx_buf_sz); 1295 else 1296 de->rx_ring[i].opts2 = cpu_to_le32(de->rx_buf_sz); 1297 de->rx_ring[i].addr1 = cpu_to_le32(de->rx_skb[i].mapping); 1298 de->rx_ring[i].addr2 = 0; 1299 } 1300 1301 return 0; 1302 1303 err_out: 1304 de_clean_rings(de); 1305 return -ENOMEM; 1306 } 1307 1308 static int de_init_rings (struct de_private *de) 1309 { 1310 memset(de->tx_ring, 0, sizeof(struct de_desc) * DE_TX_RING_SIZE); 1311 de->tx_ring[DE_TX_RING_SIZE - 1].opts2 = cpu_to_le32(RingEnd); 1312 1313 de->rx_tail = 0; 1314 de->tx_head = de->tx_tail = 0; 1315 1316 return de_refill_rx (de); 1317 } 1318 1319 static int de_alloc_rings (struct de_private *de) 1320 { 1321 de->rx_ring = dma_alloc_coherent(&de->pdev->dev, DE_RING_BYTES, 1322 &de->ring_dma, GFP_KERNEL); 1323 if (!de->rx_ring) 1324 return -ENOMEM; 1325 de->tx_ring = &de->rx_ring[DE_RX_RING_SIZE]; 1326 return de_init_rings(de); 1327 } 1328 1329 static void de_clean_rings (struct de_private *de) 1330 { 1331 unsigned i; 1332 1333 memset(de->rx_ring, 0, sizeof(struct de_desc) * DE_RX_RING_SIZE); 1334 de->rx_ring[DE_RX_RING_SIZE - 1].opts2 = cpu_to_le32(RingEnd); 1335 wmb(); 1336 memset(de->tx_ring, 0, sizeof(struct de_desc) * DE_TX_RING_SIZE); 1337 de->tx_ring[DE_TX_RING_SIZE - 1].opts2 = cpu_to_le32(RingEnd); 1338 wmb(); 1339 1340 for (i = 0; i < DE_RX_RING_SIZE; i++) { 1341 if (de->rx_skb[i].skb) { 1342 dma_unmap_single(&de->pdev->dev, 1343 de->rx_skb[i].mapping, de->rx_buf_sz, 1344 DMA_FROM_DEVICE); 1345 dev_kfree_skb(de->rx_skb[i].skb); 1346 } 1347 } 1348 1349 for (i = 0; i < DE_TX_RING_SIZE; i++) { 1350 struct sk_buff *skb = de->tx_skb[i].skb; 1351 if ((skb) && (skb != DE_DUMMY_SKB)) { 1352 if (skb != DE_SETUP_SKB) { 1353 de->dev->stats.tx_dropped++; 1354 dma_unmap_single(&de->pdev->dev, 1355 de->tx_skb[i].mapping, 1356 skb->len, DMA_TO_DEVICE); 1357 dev_kfree_skb(skb); 1358 } else { 1359 dma_unmap_single(&de->pdev->dev, 1360 de->tx_skb[i].mapping, 1361 sizeof(de->setup_frame), 1362 DMA_TO_DEVICE); 1363 } 1364 } 1365 } 1366 1367 memset(&de->rx_skb, 0, sizeof(struct ring_info) * DE_RX_RING_SIZE); 1368 memset(&de->tx_skb, 0, sizeof(struct ring_info) * DE_TX_RING_SIZE); 1369 } 1370 1371 static void de_free_rings (struct de_private *de) 1372 { 1373 de_clean_rings(de); 1374 dma_free_coherent(&de->pdev->dev, DE_RING_BYTES, de->rx_ring, 1375 de->ring_dma); 1376 de->rx_ring = NULL; 1377 de->tx_ring = NULL; 1378 } 1379 1380 static int de_open (struct net_device *dev) 1381 { 1382 struct de_private *de = netdev_priv(dev); 1383 const int irq = de->pdev->irq; 1384 int rc; 1385 1386 netif_dbg(de, ifup, dev, "enabling interface\n"); 1387 1388 de->rx_buf_sz = (dev->mtu <= 1500 ? PKT_BUF_SZ : dev->mtu + 32); 1389 1390 rc = de_alloc_rings(de); 1391 if (rc) { 1392 netdev_err(dev, "ring allocation failure, err=%d\n", rc); 1393 return rc; 1394 } 1395 1396 dw32(IntrMask, 0); 1397 1398 rc = request_irq(irq, de_interrupt, IRQF_SHARED, dev->name, dev); 1399 if (rc) { 1400 netdev_err(dev, "IRQ %d request failure, err=%d\n", irq, rc); 1401 goto err_out_free; 1402 } 1403 1404 rc = de_init_hw(de); 1405 if (rc) { 1406 netdev_err(dev, "h/w init failure, err=%d\n", rc); 1407 goto err_out_free_irq; 1408 } 1409 1410 netif_start_queue(dev); 1411 mod_timer(&de->media_timer, jiffies + DE_TIMER_NO_LINK); 1412 1413 return 0; 1414 1415 err_out_free_irq: 1416 free_irq(irq, dev); 1417 err_out_free: 1418 de_free_rings(de); 1419 return rc; 1420 } 1421 1422 static int de_close (struct net_device *dev) 1423 { 1424 struct de_private *de = netdev_priv(dev); 1425 unsigned long flags; 1426 1427 netif_dbg(de, ifdown, dev, "disabling interface\n"); 1428 1429 timer_delete_sync(&de->media_timer); 1430 1431 spin_lock_irqsave(&de->lock, flags); 1432 de_stop_hw(de); 1433 netif_stop_queue(dev); 1434 netif_carrier_off(dev); 1435 spin_unlock_irqrestore(&de->lock, flags); 1436 1437 free_irq(de->pdev->irq, dev); 1438 1439 de_free_rings(de); 1440 de_adapter_sleep(de); 1441 return 0; 1442 } 1443 1444 static void de_tx_timeout (struct net_device *dev, unsigned int txqueue) 1445 { 1446 struct de_private *de = netdev_priv(dev); 1447 const int irq = de->pdev->irq; 1448 1449 netdev_dbg(dev, "NIC status %08x mode %08x sia %08x desc %u/%u/%u\n", 1450 dr32(MacStatus), dr32(MacMode), dr32(SIAStatus), 1451 de->rx_tail, de->tx_head, de->tx_tail); 1452 1453 timer_delete_sync(&de->media_timer); 1454 1455 disable_irq(irq); 1456 spin_lock_irq(&de->lock); 1457 1458 de_stop_hw(de); 1459 netif_stop_queue(dev); 1460 netif_carrier_off(dev); 1461 1462 spin_unlock_irq(&de->lock); 1463 enable_irq(irq); 1464 1465 /* Update the error counts. */ 1466 __de_get_stats(de); 1467 1468 synchronize_irq(irq); 1469 de_clean_rings(de); 1470 1471 de_init_rings(de); 1472 1473 de_init_hw(de); 1474 1475 netif_wake_queue(dev); 1476 } 1477 1478 static void __de_get_regs(struct de_private *de, u8 *buf) 1479 { 1480 int i; 1481 u32 *rbuf = (u32 *)buf; 1482 1483 /* read all CSRs */ 1484 for (i = 0; i < DE_NUM_REGS; i++) 1485 rbuf[i] = dr32(i * 8); 1486 1487 /* handle self-clearing RxMissed counter, CSR8 */ 1488 de_rx_missed(de, rbuf[8]); 1489 } 1490 1491 static void __de_get_link_ksettings(struct de_private *de, 1492 struct ethtool_link_ksettings *cmd) 1493 { 1494 ethtool_convert_legacy_u32_to_link_mode(cmd->link_modes.supported, 1495 de->media_supported); 1496 cmd->base.phy_address = 0; 1497 ethtool_convert_legacy_u32_to_link_mode(cmd->link_modes.advertising, 1498 de->media_advertise); 1499 1500 switch (de->media_type) { 1501 case DE_MEDIA_AUI: 1502 cmd->base.port = PORT_AUI; 1503 break; 1504 case DE_MEDIA_BNC: 1505 cmd->base.port = PORT_BNC; 1506 break; 1507 default: 1508 cmd->base.port = PORT_TP; 1509 break; 1510 } 1511 1512 cmd->base.speed = 10; 1513 1514 if (dr32(MacMode) & FullDuplex) 1515 cmd->base.duplex = DUPLEX_FULL; 1516 else 1517 cmd->base.duplex = DUPLEX_HALF; 1518 1519 if (de->media_lock) 1520 cmd->base.autoneg = AUTONEG_DISABLE; 1521 else 1522 cmd->base.autoneg = AUTONEG_ENABLE; 1523 1524 /* ignore maxtxpkt, maxrxpkt for now */ 1525 } 1526 1527 static int __de_set_link_ksettings(struct de_private *de, 1528 const struct ethtool_link_ksettings *cmd) 1529 { 1530 u32 new_media; 1531 unsigned int media_lock; 1532 u8 duplex = cmd->base.duplex; 1533 u8 port = cmd->base.port; 1534 u8 autoneg = cmd->base.autoneg; 1535 u32 advertising; 1536 1537 ethtool_convert_link_mode_to_legacy_u32(&advertising, 1538 cmd->link_modes.advertising); 1539 1540 if (cmd->base.speed != 10) 1541 return -EINVAL; 1542 if (duplex != DUPLEX_HALF && duplex != DUPLEX_FULL) 1543 return -EINVAL; 1544 if (port != PORT_TP && port != PORT_AUI && port != PORT_BNC) 1545 return -EINVAL; 1546 if (de->de21040 && port == PORT_BNC) 1547 return -EINVAL; 1548 if (autoneg != AUTONEG_DISABLE && autoneg != AUTONEG_ENABLE) 1549 return -EINVAL; 1550 if (advertising & ~de->media_supported) 1551 return -EINVAL; 1552 if (autoneg == AUTONEG_ENABLE && 1553 (!(advertising & ADVERTISED_Autoneg))) 1554 return -EINVAL; 1555 1556 switch (port) { 1557 case PORT_AUI: 1558 new_media = DE_MEDIA_AUI; 1559 if (!(advertising & ADVERTISED_AUI)) 1560 return -EINVAL; 1561 break; 1562 case PORT_BNC: 1563 new_media = DE_MEDIA_BNC; 1564 if (!(advertising & ADVERTISED_BNC)) 1565 return -EINVAL; 1566 break; 1567 default: 1568 if (autoneg == AUTONEG_ENABLE) 1569 new_media = DE_MEDIA_TP_AUTO; 1570 else if (duplex == DUPLEX_FULL) 1571 new_media = DE_MEDIA_TP_FD; 1572 else 1573 new_media = DE_MEDIA_TP; 1574 if (!(advertising & ADVERTISED_TP)) 1575 return -EINVAL; 1576 if (!(advertising & (ADVERTISED_10baseT_Full | 1577 ADVERTISED_10baseT_Half))) 1578 return -EINVAL; 1579 break; 1580 } 1581 1582 media_lock = (autoneg == AUTONEG_ENABLE) ? 0 : 1; 1583 1584 if ((new_media == de->media_type) && 1585 (media_lock == de->media_lock) && 1586 (advertising == de->media_advertise)) 1587 return 0; /* nothing to change */ 1588 1589 de_link_down(de); 1590 mod_timer(&de->media_timer, jiffies + DE_TIMER_NO_LINK); 1591 de_stop_rxtx(de); 1592 1593 de->media_type = new_media; 1594 de->media_lock = media_lock; 1595 de->media_advertise = advertising; 1596 de_set_media(de); 1597 if (netif_running(de->dev)) 1598 de_start_rxtx(de); 1599 1600 return 0; 1601 } 1602 1603 static void de_get_drvinfo (struct net_device *dev,struct ethtool_drvinfo *info) 1604 { 1605 struct de_private *de = netdev_priv(dev); 1606 1607 strscpy(info->driver, DRV_NAME, sizeof(info->driver)); 1608 strscpy(info->bus_info, pci_name(de->pdev), sizeof(info->bus_info)); 1609 } 1610 1611 static int de_get_regs_len(struct net_device *dev) 1612 { 1613 return DE_REGS_SIZE; 1614 } 1615 1616 static int de_get_link_ksettings(struct net_device *dev, 1617 struct ethtool_link_ksettings *cmd) 1618 { 1619 struct de_private *de = netdev_priv(dev); 1620 1621 spin_lock_irq(&de->lock); 1622 __de_get_link_ksettings(de, cmd); 1623 spin_unlock_irq(&de->lock); 1624 1625 return 0; 1626 } 1627 1628 static int de_set_link_ksettings(struct net_device *dev, 1629 const struct ethtool_link_ksettings *cmd) 1630 { 1631 struct de_private *de = netdev_priv(dev); 1632 int rc; 1633 1634 spin_lock_irq(&de->lock); 1635 rc = __de_set_link_ksettings(de, cmd); 1636 spin_unlock_irq(&de->lock); 1637 1638 return rc; 1639 } 1640 1641 static u32 de_get_msglevel(struct net_device *dev) 1642 { 1643 struct de_private *de = netdev_priv(dev); 1644 1645 return de->msg_enable; 1646 } 1647 1648 static void de_set_msglevel(struct net_device *dev, u32 msglvl) 1649 { 1650 struct de_private *de = netdev_priv(dev); 1651 1652 de->msg_enable = msglvl; 1653 } 1654 1655 static int de_get_eeprom(struct net_device *dev, 1656 struct ethtool_eeprom *eeprom, u8 *data) 1657 { 1658 struct de_private *de = netdev_priv(dev); 1659 1660 if (!de->ee_data) 1661 return -EOPNOTSUPP; 1662 if ((eeprom->offset != 0) || (eeprom->magic != 0) || 1663 (eeprom->len != DE_EEPROM_SIZE)) 1664 return -EINVAL; 1665 memcpy(data, de->ee_data, eeprom->len); 1666 1667 return 0; 1668 } 1669 1670 static int de_nway_reset(struct net_device *dev) 1671 { 1672 struct de_private *de = netdev_priv(dev); 1673 u32 status; 1674 1675 if (de->media_type != DE_MEDIA_TP_AUTO) 1676 return -EINVAL; 1677 if (netif_carrier_ok(de->dev)) 1678 de_link_down(de); 1679 1680 status = dr32(SIAStatus); 1681 dw32(SIAStatus, (status & ~NWayState) | NWayRestart); 1682 netif_info(de, link, dev, "link nway restart, status %x,%x\n", 1683 status, dr32(SIAStatus)); 1684 return 0; 1685 } 1686 1687 static void de_get_regs(struct net_device *dev, struct ethtool_regs *regs, 1688 void *data) 1689 { 1690 struct de_private *de = netdev_priv(dev); 1691 1692 regs->version = (DE_REGS_VER << 2) | de->de21040; 1693 1694 spin_lock_irq(&de->lock); 1695 __de_get_regs(de, data); 1696 spin_unlock_irq(&de->lock); 1697 } 1698 1699 static const struct ethtool_ops de_ethtool_ops = { 1700 .get_link = ethtool_op_get_link, 1701 .get_drvinfo = de_get_drvinfo, 1702 .get_regs_len = de_get_regs_len, 1703 .get_msglevel = de_get_msglevel, 1704 .set_msglevel = de_set_msglevel, 1705 .get_eeprom = de_get_eeprom, 1706 .nway_reset = de_nway_reset, 1707 .get_regs = de_get_regs, 1708 .get_link_ksettings = de_get_link_ksettings, 1709 .set_link_ksettings = de_set_link_ksettings, 1710 }; 1711 1712 static void de21040_get_mac_address(struct de_private *de) 1713 { 1714 u8 addr[ETH_ALEN]; 1715 unsigned i; 1716 1717 dw32 (ROMCmd, 0); /* Reset the pointer with a dummy write. */ 1718 udelay(5); 1719 1720 for (i = 0; i < 6; i++) { 1721 int value, boguscnt = 100000; 1722 do { 1723 value = dr32(ROMCmd); 1724 rmb(); 1725 } while (value < 0 && --boguscnt > 0); 1726 addr[i] = value; 1727 udelay(1); 1728 if (boguscnt <= 0) 1729 pr_warn("timeout reading 21040 MAC address byte %u\n", 1730 i); 1731 } 1732 eth_hw_addr_set(de->dev, addr); 1733 } 1734 1735 static void de21040_get_media_info(struct de_private *de) 1736 { 1737 unsigned int i; 1738 1739 de->media_type = DE_MEDIA_TP; 1740 de->media_supported |= SUPPORTED_TP | SUPPORTED_10baseT_Full | 1741 SUPPORTED_10baseT_Half | SUPPORTED_AUI; 1742 de->media_advertise = de->media_supported; 1743 1744 for (i = 0; i < DE_MAX_MEDIA; i++) { 1745 switch (i) { 1746 case DE_MEDIA_AUI: 1747 case DE_MEDIA_TP: 1748 case DE_MEDIA_TP_FD: 1749 de->media[i].type = i; 1750 de->media[i].csr13 = t21040_csr13[i]; 1751 de->media[i].csr14 = t21040_csr14[i]; 1752 de->media[i].csr15 = t21040_csr15[i]; 1753 break; 1754 default: 1755 de->media[i].type = DE_MEDIA_INVALID; 1756 break; 1757 } 1758 } 1759 } 1760 1761 /* Note: this routine returns extra data bits for size detection. */ 1762 static unsigned tulip_read_eeprom(void __iomem *regs, int location, 1763 int addr_len) 1764 { 1765 int i; 1766 unsigned retval = 0; 1767 void __iomem *ee_addr = regs + ROMCmd; 1768 int read_cmd = location | (EE_READ_CMD << addr_len); 1769 1770 writel(EE_ENB & ~EE_CS, ee_addr); 1771 writel(EE_ENB, ee_addr); 1772 1773 /* Shift the read command bits out. */ 1774 for (i = 4 + addr_len; i >= 0; i--) { 1775 short dataval = (read_cmd & (1 << i)) ? EE_DATA_WRITE : 0; 1776 writel(EE_ENB | dataval, ee_addr); 1777 readl(ee_addr); 1778 writel(EE_ENB | dataval | EE_SHIFT_CLK, ee_addr); 1779 readl(ee_addr); 1780 retval = (retval << 1) | ((readl(ee_addr) & EE_DATA_READ) ? 1 : 0); 1781 } 1782 writel(EE_ENB, ee_addr); 1783 readl(ee_addr); 1784 1785 for (i = 16; i > 0; i--) { 1786 writel(EE_ENB | EE_SHIFT_CLK, ee_addr); 1787 readl(ee_addr); 1788 retval = (retval << 1) | ((readl(ee_addr) & EE_DATA_READ) ? 1 : 0); 1789 writel(EE_ENB, ee_addr); 1790 readl(ee_addr); 1791 } 1792 1793 /* Terminate the EEPROM access. */ 1794 writel(EE_ENB & ~EE_CS, ee_addr); 1795 return retval; 1796 } 1797 1798 static void de21041_get_srom_info(struct de_private *de) 1799 { 1800 unsigned i, sa_offset = 0, ofs; 1801 u8 ee_data[DE_EEPROM_SIZE + 6] = {}; 1802 unsigned ee_addr_size = tulip_read_eeprom(de->regs, 0xff, 8) & 0x40000 ? 8 : 6; 1803 struct de_srom_info_leaf *il; 1804 void *bufp; 1805 1806 /* download entire eeprom */ 1807 for (i = 0; i < DE_EEPROM_WORDS; i++) 1808 ((__le16 *)ee_data)[i] = 1809 cpu_to_le16(tulip_read_eeprom(de->regs, i, ee_addr_size)); 1810 1811 /* DEC now has a specification but early board makers 1812 just put the address in the first EEPROM locations. */ 1813 /* This does memcmp(eedata, eedata+16, 8) */ 1814 1815 #ifndef CONFIG_MIPS_COBALT 1816 1817 for (i = 0; i < 8; i ++) 1818 if (ee_data[i] != ee_data[16+i]) 1819 sa_offset = 20; 1820 1821 #endif 1822 1823 /* store MAC address */ 1824 eth_hw_addr_set(de->dev, &ee_data[sa_offset]); 1825 1826 /* get offset of controller 0 info leaf. ignore 2nd byte. */ 1827 ofs = ee_data[SROMC0InfoLeaf]; 1828 if (ofs >= (sizeof(ee_data) - sizeof(struct de_srom_info_leaf) - sizeof(struct de_srom_media_block))) 1829 goto bad_srom; 1830 1831 /* get pointer to info leaf */ 1832 il = (struct de_srom_info_leaf *) &ee_data[ofs]; 1833 1834 /* paranoia checks */ 1835 if (il->n_blocks == 0) 1836 goto bad_srom; 1837 if ((sizeof(ee_data) - ofs) < 1838 (sizeof(struct de_srom_info_leaf) + (sizeof(struct de_srom_media_block) * il->n_blocks))) 1839 goto bad_srom; 1840 1841 /* get default media type */ 1842 switch (get_unaligned(&il->default_media)) { 1843 case 0x0001: de->media_type = DE_MEDIA_BNC; break; 1844 case 0x0002: de->media_type = DE_MEDIA_AUI; break; 1845 case 0x0204: de->media_type = DE_MEDIA_TP_FD; break; 1846 default: de->media_type = DE_MEDIA_TP_AUTO; break; 1847 } 1848 1849 if (netif_msg_probe(de)) 1850 pr_info("de%d: SROM leaf offset %u, default media %s\n", 1851 de->board_idx, ofs, media_name[de->media_type]); 1852 1853 /* init SIA register values to defaults */ 1854 for (i = 0; i < DE_MAX_MEDIA; i++) { 1855 de->media[i].type = DE_MEDIA_INVALID; 1856 de->media[i].csr13 = 0xffff; 1857 de->media[i].csr14 = 0xffff; 1858 de->media[i].csr15 = 0xffff; 1859 } 1860 1861 /* parse media blocks to see what medias are supported, 1862 * and if any custom CSR values are provided 1863 */ 1864 bufp = ((void *)il) + sizeof(*il); 1865 for (i = 0; i < il->n_blocks; i++) { 1866 struct de_srom_media_block *ib = bufp; 1867 unsigned idx; 1868 1869 /* index based on media type in media block */ 1870 switch(ib->opts & MediaBlockMask) { 1871 case 0: /* 10baseT */ 1872 de->media_supported |= SUPPORTED_TP | SUPPORTED_10baseT_Half 1873 | SUPPORTED_Autoneg; 1874 idx = DE_MEDIA_TP; 1875 de->media[DE_MEDIA_TP_AUTO].type = DE_MEDIA_TP_AUTO; 1876 break; 1877 case 1: /* BNC */ 1878 de->media_supported |= SUPPORTED_BNC; 1879 idx = DE_MEDIA_BNC; 1880 break; 1881 case 2: /* AUI */ 1882 de->media_supported |= SUPPORTED_AUI; 1883 idx = DE_MEDIA_AUI; 1884 break; 1885 case 4: /* 10baseT-FD */ 1886 de->media_supported |= SUPPORTED_TP | SUPPORTED_10baseT_Full 1887 | SUPPORTED_Autoneg; 1888 idx = DE_MEDIA_TP_FD; 1889 de->media[DE_MEDIA_TP_AUTO].type = DE_MEDIA_TP_AUTO; 1890 break; 1891 default: 1892 goto bad_srom; 1893 } 1894 1895 de->media[idx].type = idx; 1896 1897 if (netif_msg_probe(de)) 1898 pr_info("de%d: media block #%u: %s", 1899 de->board_idx, i, 1900 media_name[de->media[idx].type]); 1901 1902 bufp += sizeof (ib->opts); 1903 1904 if (ib->opts & MediaCustomCSRs) { 1905 de->media[idx].csr13 = get_unaligned(&ib->csr13); 1906 de->media[idx].csr14 = get_unaligned(&ib->csr14); 1907 de->media[idx].csr15 = get_unaligned(&ib->csr15); 1908 bufp += sizeof(ib->csr13) + sizeof(ib->csr14) + 1909 sizeof(ib->csr15); 1910 1911 if (netif_msg_probe(de)) 1912 pr_cont(" (%x,%x,%x)\n", 1913 de->media[idx].csr13, 1914 de->media[idx].csr14, 1915 de->media[idx].csr15); 1916 1917 } else { 1918 if (netif_msg_probe(de)) 1919 pr_cont("\n"); 1920 } 1921 1922 if (bufp > ((void *)&ee_data[DE_EEPROM_SIZE - 3])) 1923 break; 1924 } 1925 1926 de->media_advertise = de->media_supported; 1927 1928 fill_defaults: 1929 /* fill in defaults, for cases where custom CSRs not used */ 1930 for (i = 0; i < DE_MAX_MEDIA; i++) { 1931 if (de->media[i].csr13 == 0xffff) 1932 de->media[i].csr13 = t21041_csr13[i]; 1933 if (de->media[i].csr14 == 0xffff) { 1934 /* autonegotiation is broken at least on some chip 1935 revisions - rev. 0x21 works, 0x11 does not */ 1936 if (de->pdev->revision < 0x20) 1937 de->media[i].csr14 = t21041_csr14_brk[i]; 1938 else 1939 de->media[i].csr14 = t21041_csr14[i]; 1940 } 1941 if (de->media[i].csr15 == 0xffff) 1942 de->media[i].csr15 = t21041_csr15[i]; 1943 } 1944 1945 de->ee_data = kmemdup(&ee_data[0], DE_EEPROM_SIZE, GFP_KERNEL); 1946 1947 return; 1948 1949 bad_srom: 1950 /* for error cases, it's ok to assume we support all these */ 1951 for (i = 0; i < DE_MAX_MEDIA; i++) 1952 de->media[i].type = i; 1953 de->media_supported = 1954 SUPPORTED_10baseT_Half | 1955 SUPPORTED_10baseT_Full | 1956 SUPPORTED_Autoneg | 1957 SUPPORTED_TP | 1958 SUPPORTED_AUI | 1959 SUPPORTED_BNC; 1960 goto fill_defaults; 1961 } 1962 1963 static const struct net_device_ops de_netdev_ops = { 1964 .ndo_open = de_open, 1965 .ndo_stop = de_close, 1966 .ndo_set_rx_mode = de_set_rx_mode, 1967 .ndo_start_xmit = de_start_xmit, 1968 .ndo_get_stats = de_get_stats, 1969 .ndo_tx_timeout = de_tx_timeout, 1970 .ndo_set_mac_address = eth_mac_addr, 1971 .ndo_validate_addr = eth_validate_addr, 1972 }; 1973 1974 static int de_init_one(struct pci_dev *pdev, const struct pci_device_id *ent) 1975 { 1976 struct net_device *dev; 1977 struct de_private *de; 1978 int rc; 1979 void __iomem *regs; 1980 unsigned long pciaddr; 1981 static int board_idx = -1; 1982 1983 board_idx++; 1984 1985 /* allocate a new ethernet device structure, and fill in defaults */ 1986 dev = alloc_etherdev(sizeof(struct de_private)); 1987 if (!dev) 1988 return -ENOMEM; 1989 1990 dev->netdev_ops = &de_netdev_ops; 1991 SET_NETDEV_DEV(dev, &pdev->dev); 1992 dev->ethtool_ops = &de_ethtool_ops; 1993 dev->watchdog_timeo = TX_TIMEOUT; 1994 1995 de = netdev_priv(dev); 1996 de->de21040 = ent->driver_data == 0 ? 1 : 0; 1997 de->pdev = pdev; 1998 de->dev = dev; 1999 de->msg_enable = (debug < 0 ? DE_DEF_MSG_ENABLE : debug); 2000 de->board_idx = board_idx; 2001 spin_lock_init (&de->lock); 2002 timer_setup(&de->media_timer, 2003 de->de21040 ? de21040_media_timer : de21041_media_timer, 2004 0); 2005 2006 netif_carrier_off(dev); 2007 2008 /* wake up device, assign resources */ 2009 rc = pci_enable_device(pdev); 2010 if (rc) 2011 goto err_out_free; 2012 2013 /* reserve PCI resources to ensure driver atomicity */ 2014 rc = pci_request_regions(pdev, DRV_NAME); 2015 if (rc) 2016 goto err_out_disable; 2017 2018 /* check for invalid IRQ value */ 2019 if (pdev->irq < 2) { 2020 rc = -EIO; 2021 pr_err("invalid irq (%d) for pci dev %s\n", 2022 pdev->irq, pci_name(pdev)); 2023 goto err_out_res; 2024 } 2025 2026 /* obtain and check validity of PCI I/O address */ 2027 pciaddr = pci_resource_start(pdev, 1); 2028 if (!pciaddr) { 2029 rc = -EIO; 2030 pr_err("no MMIO resource for pci dev %s\n", pci_name(pdev)); 2031 goto err_out_res; 2032 } 2033 if (pci_resource_len(pdev, 1) < DE_REGS_SIZE) { 2034 rc = -EIO; 2035 pr_err("MMIO resource (%llx) too small on pci dev %s\n", 2036 (unsigned long long)pci_resource_len(pdev, 1), 2037 pci_name(pdev)); 2038 goto err_out_res; 2039 } 2040 2041 /* remap CSR registers */ 2042 regs = ioremap(pciaddr, DE_REGS_SIZE); 2043 if (!regs) { 2044 rc = -EIO; 2045 pr_err("Cannot map PCI MMIO (%llx@%lx) on pci dev %s\n", 2046 (unsigned long long)pci_resource_len(pdev, 1), 2047 pciaddr, pci_name(pdev)); 2048 goto err_out_res; 2049 } 2050 de->regs = regs; 2051 2052 de_adapter_wake(de); 2053 2054 /* make sure hardware is not running */ 2055 rc = de_reset_mac(de); 2056 if (rc) { 2057 pr_err("Cannot reset MAC, pci dev %s\n", pci_name(pdev)); 2058 goto err_out_iomap; 2059 } 2060 2061 /* get MAC address, initialize default media type and 2062 * get list of supported media 2063 */ 2064 if (de->de21040) { 2065 de21040_get_mac_address(de); 2066 de21040_get_media_info(de); 2067 } else { 2068 de21041_get_srom_info(de); 2069 } 2070 2071 /* register new network interface with kernel */ 2072 rc = register_netdev(dev); 2073 if (rc) 2074 goto err_out_iomap; 2075 2076 /* print info about board and interface just registered */ 2077 netdev_info(dev, "%s at %p, %pM, IRQ %d\n", 2078 de->de21040 ? "21040" : "21041", 2079 regs, dev->dev_addr, pdev->irq); 2080 2081 pci_set_drvdata(pdev, dev); 2082 2083 /* enable busmastering */ 2084 pci_set_master(pdev); 2085 2086 /* put adapter to sleep */ 2087 de_adapter_sleep(de); 2088 2089 return 0; 2090 2091 err_out_iomap: 2092 kfree(de->ee_data); 2093 iounmap(regs); 2094 err_out_res: 2095 pci_release_regions(pdev); 2096 err_out_disable: 2097 pci_disable_device(pdev); 2098 err_out_free: 2099 free_netdev(dev); 2100 return rc; 2101 } 2102 2103 static void de_remove_one(struct pci_dev *pdev) 2104 { 2105 struct net_device *dev = pci_get_drvdata(pdev); 2106 struct de_private *de = netdev_priv(dev); 2107 2108 BUG_ON(!dev); 2109 unregister_netdev(dev); 2110 kfree(de->ee_data); 2111 iounmap(de->regs); 2112 pci_release_regions(pdev); 2113 pci_disable_device(pdev); 2114 free_netdev(dev); 2115 } 2116 2117 static int __maybe_unused de_suspend(struct device *dev_d) 2118 { 2119 struct pci_dev *pdev = to_pci_dev(dev_d); 2120 struct net_device *dev = pci_get_drvdata(pdev); 2121 struct de_private *de = netdev_priv(dev); 2122 2123 rtnl_lock(); 2124 if (netif_running (dev)) { 2125 const int irq = pdev->irq; 2126 2127 timer_delete_sync(&de->media_timer); 2128 2129 disable_irq(irq); 2130 spin_lock_irq(&de->lock); 2131 2132 de_stop_hw(de); 2133 netif_stop_queue(dev); 2134 netif_device_detach(dev); 2135 netif_carrier_off(dev); 2136 2137 spin_unlock_irq(&de->lock); 2138 enable_irq(irq); 2139 2140 /* Update the error counts. */ 2141 __de_get_stats(de); 2142 2143 synchronize_irq(irq); 2144 de_clean_rings(de); 2145 2146 de_adapter_sleep(de); 2147 } else { 2148 netif_device_detach(dev); 2149 } 2150 rtnl_unlock(); 2151 return 0; 2152 } 2153 2154 static int __maybe_unused de_resume(struct device *dev_d) 2155 { 2156 struct pci_dev *pdev = to_pci_dev(dev_d); 2157 struct net_device *dev = pci_get_drvdata(pdev); 2158 struct de_private *de = netdev_priv(dev); 2159 2160 rtnl_lock(); 2161 if (netif_device_present(dev)) 2162 goto out; 2163 if (!netif_running(dev)) 2164 goto out_attach; 2165 pci_set_master(pdev); 2166 de_init_rings(de); 2167 de_init_hw(de); 2168 out_attach: 2169 netif_device_attach(dev); 2170 out: 2171 rtnl_unlock(); 2172 return 0; 2173 } 2174 2175 static SIMPLE_DEV_PM_OPS(de_pm_ops, de_suspend, de_resume); 2176 2177 static void de_shutdown(struct pci_dev *pdev) 2178 { 2179 struct net_device *dev = pci_get_drvdata(pdev); 2180 2181 rtnl_lock(); 2182 dev_close(dev); 2183 rtnl_unlock(); 2184 } 2185 2186 static struct pci_driver de_driver = { 2187 .name = DRV_NAME, 2188 .id_table = de_pci_tbl, 2189 .probe = de_init_one, 2190 .remove = de_remove_one, 2191 .shutdown = de_shutdown, 2192 .driver.pm = &de_pm_ops, 2193 }; 2194 2195 module_pci_driver(de_driver); 2196