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_VERSION "0.7" 34 #define DRV_RELDATE "Mar 17, 2004" 35 36 #include <linux/module.h> 37 #include <linux/kernel.h> 38 #include <linux/netdevice.h> 39 #include <linux/etherdevice.h> 40 #include <linux/init.h> 41 #include <linux/interrupt.h> 42 #include <linux/pci.h> 43 #include <linux/delay.h> 44 #include <linux/ethtool.h> 45 #include <linux/compiler.h> 46 #include <linux/rtnetlink.h> 47 #include <linux/crc32.h> 48 #include <linux/slab.h> 49 50 #include <asm/io.h> 51 #include <asm/irq.h> 52 #include <linux/uaccess.h> 53 #include <asm/unaligned.h> 54 55 /* These identify the driver base version and may not be removed. */ 56 static char version[] = 57 "PCI Ethernet driver v" DRV_VERSION " (" DRV_RELDATE ")"; 58 59 MODULE_AUTHOR("Jeff Garzik <jgarzik@pobox.com>"); 60 MODULE_DESCRIPTION("Intel/Digital 21040/1 series PCI Ethernet driver"); 61 MODULE_LICENSE("GPL"); 62 MODULE_VERSION(DRV_VERSION); 63 64 static int debug = -1; 65 module_param (debug, int, 0); 66 MODULE_PARM_DESC (debug, "de2104x bitmapped message enable number"); 67 68 /* Set the copy breakpoint for the copy-only-tiny-buffer Rx structure. */ 69 #if defined(__alpha__) || defined(__arm__) || defined(__hppa__) || \ 70 defined(CONFIG_SPARC) || defined(__ia64__) || \ 71 defined(__sh__) || defined(__mips__) 72 static int rx_copybreak = 1518; 73 #else 74 static int rx_copybreak = 100; 75 #endif 76 module_param (rx_copybreak, int, 0); 77 MODULE_PARM_DESC (rx_copybreak, "de2104x Breakpoint at which Rx packets are copied"); 78 79 #define DE_DEF_MSG_ENABLE (NETIF_MSG_DRV | \ 80 NETIF_MSG_PROBE | \ 81 NETIF_MSG_LINK | \ 82 NETIF_MSG_IFDOWN | \ 83 NETIF_MSG_IFUP | \ 84 NETIF_MSG_RX_ERR | \ 85 NETIF_MSG_TX_ERR) 86 87 /* Descriptor skip length in 32 bit longwords. */ 88 #ifndef CONFIG_DE2104X_DSL 89 #define DSL 0 90 #else 91 #define DSL CONFIG_DE2104X_DSL 92 #endif 93 94 #define DE_RX_RING_SIZE 64 95 #define DE_TX_RING_SIZE 64 96 #define DE_RING_BYTES \ 97 ((sizeof(struct de_desc) * DE_RX_RING_SIZE) + \ 98 (sizeof(struct de_desc) * DE_TX_RING_SIZE)) 99 #define NEXT_TX(N) (((N) + 1) & (DE_TX_RING_SIZE - 1)) 100 #define NEXT_RX(N) (((N) + 1) & (DE_RX_RING_SIZE - 1)) 101 #define TX_BUFFS_AVAIL(CP) \ 102 (((CP)->tx_tail <= (CP)->tx_head) ? \ 103 (CP)->tx_tail + (DE_TX_RING_SIZE - 1) - (CP)->tx_head : \ 104 (CP)->tx_tail - (CP)->tx_head - 1) 105 106 #define PKT_BUF_SZ 1536 /* Size of each temporary Rx buffer.*/ 107 #define RX_OFFSET 2 108 109 #define DE_SETUP_SKB ((struct sk_buff *) 1) 110 #define DE_DUMMY_SKB ((struct sk_buff *) 2) 111 #define DE_SETUP_FRAME_WORDS 96 112 #define DE_EEPROM_WORDS 256 113 #define DE_EEPROM_SIZE (DE_EEPROM_WORDS * sizeof(u16)) 114 #define DE_MAX_MEDIA 5 115 116 #define DE_MEDIA_TP_AUTO 0 117 #define DE_MEDIA_BNC 1 118 #define DE_MEDIA_AUI 2 119 #define DE_MEDIA_TP 3 120 #define DE_MEDIA_TP_FD 4 121 #define DE_MEDIA_INVALID DE_MAX_MEDIA 122 #define DE_MEDIA_FIRST 0 123 #define DE_MEDIA_LAST (DE_MAX_MEDIA - 1) 124 #define DE_AUI_BNC (SUPPORTED_AUI | SUPPORTED_BNC) 125 126 #define DE_TIMER_LINK (60 * HZ) 127 #define DE_TIMER_NO_LINK (5 * HZ) 128 129 #define DE_NUM_REGS 16 130 #define DE_REGS_SIZE (DE_NUM_REGS * sizeof(u32)) 131 #define DE_REGS_VER 1 132 133 /* Time in jiffies before concluding the transmitter is hung. */ 134 #define TX_TIMEOUT (6*HZ) 135 136 /* This is a mysterious value that can be written to CSR11 in the 21040 (only) 137 to support a pre-NWay full-duplex signaling mechanism using short frames. 138 No one knows what it should be, but if left at its default value some 139 10base2(!) packets trigger a full-duplex-request interrupt. */ 140 #define FULL_DUPLEX_MAGIC 0x6969 141 142 enum { 143 /* NIC registers */ 144 BusMode = 0x00, 145 TxPoll = 0x08, 146 RxPoll = 0x10, 147 RxRingAddr = 0x18, 148 TxRingAddr = 0x20, 149 MacStatus = 0x28, 150 MacMode = 0x30, 151 IntrMask = 0x38, 152 RxMissed = 0x40, 153 ROMCmd = 0x48, 154 CSR11 = 0x58, 155 SIAStatus = 0x60, 156 CSR13 = 0x68, 157 CSR14 = 0x70, 158 CSR15 = 0x78, 159 PCIPM = 0x40, 160 161 /* BusMode bits */ 162 CmdReset = (1 << 0), 163 CacheAlign16 = 0x00008000, 164 BurstLen4 = 0x00000400, 165 DescSkipLen = (DSL << 2), 166 167 /* Rx/TxPoll bits */ 168 NormalTxPoll = (1 << 0), 169 NormalRxPoll = (1 << 0), 170 171 /* Tx/Rx descriptor status bits */ 172 DescOwn = (1 << 31), 173 RxError = (1 << 15), 174 RxErrLong = (1 << 7), 175 RxErrCRC = (1 << 1), 176 RxErrFIFO = (1 << 0), 177 RxErrRunt = (1 << 11), 178 RxErrFrame = (1 << 14), 179 RingEnd = (1 << 25), 180 FirstFrag = (1 << 29), 181 LastFrag = (1 << 30), 182 TxError = (1 << 15), 183 TxFIFOUnder = (1 << 1), 184 TxLinkFail = (1 << 2) | (1 << 10) | (1 << 11), 185 TxMaxCol = (1 << 8), 186 TxOWC = (1 << 9), 187 TxJabber = (1 << 14), 188 SetupFrame = (1 << 27), 189 TxSwInt = (1 << 31), 190 191 /* MacStatus bits */ 192 IntrOK = (1 << 16), 193 IntrErr = (1 << 15), 194 RxIntr = (1 << 6), 195 RxEmpty = (1 << 7), 196 TxIntr = (1 << 0), 197 TxEmpty = (1 << 2), 198 PciErr = (1 << 13), 199 TxState = (1 << 22) | (1 << 21) | (1 << 20), 200 RxState = (1 << 19) | (1 << 18) | (1 << 17), 201 LinkFail = (1 << 12), 202 LinkPass = (1 << 4), 203 RxStopped = (1 << 8), 204 TxStopped = (1 << 1), 205 206 /* MacMode bits */ 207 TxEnable = (1 << 13), 208 RxEnable = (1 << 1), 209 RxTx = TxEnable | RxEnable, 210 FullDuplex = (1 << 9), 211 AcceptAllMulticast = (1 << 7), 212 AcceptAllPhys = (1 << 6), 213 BOCnt = (1 << 5), 214 MacModeClear = (1<<12) | (1<<11) | (1<<10) | (1<<8) | (1<<3) | 215 RxTx | BOCnt | AcceptAllPhys | AcceptAllMulticast, 216 217 /* ROMCmd bits */ 218 EE_SHIFT_CLK = 0x02, /* EEPROM shift clock. */ 219 EE_CS = 0x01, /* EEPROM chip select. */ 220 EE_DATA_WRITE = 0x04, /* Data from the Tulip to EEPROM. */ 221 EE_WRITE_0 = 0x01, 222 EE_WRITE_1 = 0x05, 223 EE_DATA_READ = 0x08, /* Data from the EEPROM chip. */ 224 EE_ENB = (0x4800 | EE_CS), 225 226 /* The EEPROM commands include the alway-set leading bit. */ 227 EE_READ_CMD = 6, 228 229 /* RxMissed bits */ 230 RxMissedOver = (1 << 16), 231 RxMissedMask = 0xffff, 232 233 /* SROM-related bits */ 234 SROMC0InfoLeaf = 27, 235 MediaBlockMask = 0x3f, 236 MediaCustomCSRs = (1 << 6), 237 238 /* PCIPM bits */ 239 PM_Sleep = (1 << 31), 240 PM_Snooze = (1 << 30), 241 PM_Mask = PM_Sleep | PM_Snooze, 242 243 /* SIAStatus bits */ 244 NWayState = (1 << 14) | (1 << 13) | (1 << 12), 245 NWayRestart = (1 << 12), 246 NonselPortActive = (1 << 9), 247 SelPortActive = (1 << 8), 248 LinkFailStatus = (1 << 2), 249 NetCxnErr = (1 << 1), 250 }; 251 252 static const u32 de_intr_mask = 253 IntrOK | IntrErr | RxIntr | RxEmpty | TxIntr | TxEmpty | 254 LinkPass | LinkFail | PciErr; 255 256 /* 257 * Set the programmable burst length to 4 longwords for all: 258 * DMA errors result without these values. Cache align 16 long. 259 */ 260 static const u32 de_bus_mode = CacheAlign16 | BurstLen4 | DescSkipLen; 261 262 struct de_srom_media_block { 263 u8 opts; 264 u16 csr13; 265 u16 csr14; 266 u16 csr15; 267 } __packed; 268 269 struct de_srom_info_leaf { 270 u16 default_media; 271 u8 n_blocks; 272 u8 unused; 273 } __packed; 274 275 struct de_desc { 276 __le32 opts1; 277 __le32 opts2; 278 __le32 addr1; 279 __le32 addr2; 280 #if DSL 281 __le32 skip[DSL]; 282 #endif 283 }; 284 285 struct media_info { 286 u16 type; /* DE_MEDIA_xxx */ 287 u16 csr13; 288 u16 csr14; 289 u16 csr15; 290 }; 291 292 struct ring_info { 293 struct sk_buff *skb; 294 dma_addr_t mapping; 295 }; 296 297 struct de_private { 298 unsigned tx_head; 299 unsigned tx_tail; 300 unsigned rx_tail; 301 302 void __iomem *regs; 303 struct net_device *dev; 304 spinlock_t lock; 305 306 struct de_desc *rx_ring; 307 struct de_desc *tx_ring; 308 struct ring_info tx_skb[DE_TX_RING_SIZE]; 309 struct ring_info rx_skb[DE_RX_RING_SIZE]; 310 unsigned rx_buf_sz; 311 dma_addr_t ring_dma; 312 313 u32 msg_enable; 314 315 struct pci_dev *pdev; 316 317 u16 setup_frame[DE_SETUP_FRAME_WORDS]; 318 319 u32 media_type; 320 u32 media_supported; 321 u32 media_advertise; 322 struct media_info media[DE_MAX_MEDIA]; 323 struct timer_list media_timer; 324 325 u8 *ee_data; 326 unsigned board_idx; 327 unsigned de21040 : 1; 328 unsigned media_lock : 1; 329 }; 330 331 332 static void de_set_rx_mode (struct net_device *dev); 333 static void de_tx (struct de_private *de); 334 static void de_clean_rings (struct de_private *de); 335 static void de_media_interrupt (struct de_private *de, u32 status); 336 static void de21040_media_timer (struct timer_list *t); 337 static void de21041_media_timer (struct timer_list *t); 338 static unsigned int de_ok_to_advertise (struct de_private *de, u32 new_media); 339 340 341 static const struct pci_device_id de_pci_tbl[] = { 342 { PCI_VENDOR_ID_DEC, PCI_DEVICE_ID_DEC_TULIP, 343 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 }, 344 { PCI_VENDOR_ID_DEC, PCI_DEVICE_ID_DEC_TULIP_PLUS, 345 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 1 }, 346 { }, 347 }; 348 MODULE_DEVICE_TABLE(pci, de_pci_tbl); 349 350 static const char * const media_name[DE_MAX_MEDIA] = { 351 "10baseT auto", 352 "BNC", 353 "AUI", 354 "10baseT-HD", 355 "10baseT-FD" 356 }; 357 358 /* 21040 transceiver register settings: 359 * TP AUTO(unused), BNC(unused), AUI, TP, TP FD*/ 360 static u16 t21040_csr13[] = { 0, 0, 0x8F09, 0x8F01, 0x8F01, }; 361 static u16 t21040_csr14[] = { 0, 0, 0x0705, 0xFFFF, 0xFFFD, }; 362 static u16 t21040_csr15[] = { 0, 0, 0x0006, 0x0000, 0x0000, }; 363 364 /* 21041 transceiver register settings: TP AUTO, BNC, AUI, TP, TP FD*/ 365 static u16 t21041_csr13[] = { 0xEF01, 0xEF09, 0xEF09, 0xEF01, 0xEF09, }; 366 static u16 t21041_csr14[] = { 0xFFFF, 0xF7FD, 0xF7FD, 0x7F3F, 0x7F3D, }; 367 /* If on-chip autonegotiation is broken, use half-duplex (FF3F) instead */ 368 static u16 t21041_csr14_brk[] = { 0xFF3F, 0xF7FD, 0xF7FD, 0x7F3F, 0x7F3D, }; 369 static u16 t21041_csr15[] = { 0x0008, 0x0006, 0x000E, 0x0008, 0x0008, }; 370 371 372 #define dr32(reg) ioread32(de->regs + (reg)) 373 #define dw32(reg, val) iowrite32((val), de->regs + (reg)) 374 375 376 static void de_rx_err_acct (struct de_private *de, unsigned rx_tail, 377 u32 status, u32 len) 378 { 379 netif_dbg(de, rx_err, de->dev, 380 "rx err, slot %d status 0x%x len %d\n", 381 rx_tail, status, len); 382 383 if ((status & 0x38000300) != 0x0300) { 384 /* Ingore earlier buffers. */ 385 if ((status & 0xffff) != 0x7fff) { 386 netif_warn(de, rx_err, de->dev, 387 "Oversized Ethernet frame spanned multiple buffers, status %08x!\n", 388 status); 389 de->dev->stats.rx_length_errors++; 390 } 391 } else if (status & RxError) { 392 /* There was a fatal error. */ 393 de->dev->stats.rx_errors++; /* end of a packet.*/ 394 if (status & 0x0890) de->dev->stats.rx_length_errors++; 395 if (status & RxErrCRC) de->dev->stats.rx_crc_errors++; 396 if (status & RxErrFIFO) de->dev->stats.rx_fifo_errors++; 397 } 398 } 399 400 static void de_rx (struct de_private *de) 401 { 402 unsigned rx_tail = de->rx_tail; 403 unsigned rx_work = DE_RX_RING_SIZE; 404 unsigned drop = 0; 405 int rc; 406 407 while (--rx_work) { 408 u32 status, len; 409 dma_addr_t mapping; 410 struct sk_buff *skb, *copy_skb; 411 unsigned copying_skb, buflen; 412 413 skb = de->rx_skb[rx_tail].skb; 414 BUG_ON(!skb); 415 rmb(); 416 status = le32_to_cpu(de->rx_ring[rx_tail].opts1); 417 if (status & DescOwn) 418 break; 419 420 len = ((status >> 16) & 0x7ff) - 4; 421 mapping = de->rx_skb[rx_tail].mapping; 422 423 if (unlikely(drop)) { 424 de->dev->stats.rx_dropped++; 425 goto rx_next; 426 } 427 428 if (unlikely((status & 0x38008300) != 0x0300)) { 429 de_rx_err_acct(de, rx_tail, status, len); 430 goto rx_next; 431 } 432 433 copying_skb = (len <= rx_copybreak); 434 435 netif_dbg(de, rx_status, de->dev, 436 "rx slot %d status 0x%x len %d copying? %d\n", 437 rx_tail, status, len, copying_skb); 438 439 buflen = copying_skb ? (len + RX_OFFSET) : de->rx_buf_sz; 440 copy_skb = netdev_alloc_skb(de->dev, buflen); 441 if (unlikely(!copy_skb)) { 442 de->dev->stats.rx_dropped++; 443 drop = 1; 444 rx_work = 100; 445 goto rx_next; 446 } 447 448 if (!copying_skb) { 449 pci_unmap_single(de->pdev, mapping, 450 buflen, PCI_DMA_FROMDEVICE); 451 skb_put(skb, len); 452 453 mapping = 454 de->rx_skb[rx_tail].mapping = 455 pci_map_single(de->pdev, copy_skb->data, 456 buflen, PCI_DMA_FROMDEVICE); 457 de->rx_skb[rx_tail].skb = copy_skb; 458 } else { 459 pci_dma_sync_single_for_cpu(de->pdev, mapping, len, PCI_DMA_FROMDEVICE); 460 skb_reserve(copy_skb, RX_OFFSET); 461 skb_copy_from_linear_data(skb, skb_put(copy_skb, len), 462 len); 463 pci_dma_sync_single_for_device(de->pdev, mapping, len, PCI_DMA_FROMDEVICE); 464 465 /* We'll reuse the original ring buffer. */ 466 skb = copy_skb; 467 } 468 469 skb->protocol = eth_type_trans (skb, de->dev); 470 471 de->dev->stats.rx_packets++; 472 de->dev->stats.rx_bytes += skb->len; 473 rc = netif_rx (skb); 474 if (rc == NET_RX_DROP) 475 drop = 1; 476 477 rx_next: 478 if (rx_tail == (DE_RX_RING_SIZE - 1)) 479 de->rx_ring[rx_tail].opts2 = 480 cpu_to_le32(RingEnd | de->rx_buf_sz); 481 else 482 de->rx_ring[rx_tail].opts2 = cpu_to_le32(de->rx_buf_sz); 483 de->rx_ring[rx_tail].addr1 = cpu_to_le32(mapping); 484 wmb(); 485 de->rx_ring[rx_tail].opts1 = cpu_to_le32(DescOwn); 486 rx_tail = NEXT_RX(rx_tail); 487 } 488 489 if (!rx_work) 490 netdev_warn(de->dev, "rx work limit reached\n"); 491 492 de->rx_tail = rx_tail; 493 } 494 495 static irqreturn_t de_interrupt (int irq, void *dev_instance) 496 { 497 struct net_device *dev = dev_instance; 498 struct de_private *de = netdev_priv(dev); 499 u32 status; 500 501 status = dr32(MacStatus); 502 if ((!(status & (IntrOK|IntrErr))) || (status == 0xFFFF)) 503 return IRQ_NONE; 504 505 netif_dbg(de, intr, dev, "intr, status %08x mode %08x desc %u/%u/%u\n", 506 status, dr32(MacMode), 507 de->rx_tail, de->tx_head, de->tx_tail); 508 509 dw32(MacStatus, status); 510 511 if (status & (RxIntr | RxEmpty)) { 512 de_rx(de); 513 if (status & RxEmpty) 514 dw32(RxPoll, NormalRxPoll); 515 } 516 517 spin_lock(&de->lock); 518 519 if (status & (TxIntr | TxEmpty)) 520 de_tx(de); 521 522 if (status & (LinkPass | LinkFail)) 523 de_media_interrupt(de, status); 524 525 spin_unlock(&de->lock); 526 527 if (status & PciErr) { 528 u16 pci_status; 529 530 pci_read_config_word(de->pdev, PCI_STATUS, &pci_status); 531 pci_write_config_word(de->pdev, PCI_STATUS, pci_status); 532 netdev_err(de->dev, 533 "PCI bus error, status=%08x, PCI status=%04x\n", 534 status, pci_status); 535 } 536 537 return IRQ_HANDLED; 538 } 539 540 static void de_tx (struct de_private *de) 541 { 542 unsigned tx_head = de->tx_head; 543 unsigned tx_tail = de->tx_tail; 544 545 while (tx_tail != tx_head) { 546 struct sk_buff *skb; 547 u32 status; 548 549 rmb(); 550 status = le32_to_cpu(de->tx_ring[tx_tail].opts1); 551 if (status & DescOwn) 552 break; 553 554 skb = de->tx_skb[tx_tail].skb; 555 BUG_ON(!skb); 556 if (unlikely(skb == DE_DUMMY_SKB)) 557 goto next; 558 559 if (unlikely(skb == DE_SETUP_SKB)) { 560 pci_unmap_single(de->pdev, de->tx_skb[tx_tail].mapping, 561 sizeof(de->setup_frame), PCI_DMA_TODEVICE); 562 goto next; 563 } 564 565 pci_unmap_single(de->pdev, de->tx_skb[tx_tail].mapping, 566 skb->len, PCI_DMA_TODEVICE); 567 568 if (status & LastFrag) { 569 if (status & TxError) { 570 netif_dbg(de, tx_err, de->dev, 571 "tx err, status 0x%x\n", 572 status); 573 de->dev->stats.tx_errors++; 574 if (status & TxOWC) 575 de->dev->stats.tx_window_errors++; 576 if (status & TxMaxCol) 577 de->dev->stats.tx_aborted_errors++; 578 if (status & TxLinkFail) 579 de->dev->stats.tx_carrier_errors++; 580 if (status & TxFIFOUnder) 581 de->dev->stats.tx_fifo_errors++; 582 } else { 583 de->dev->stats.tx_packets++; 584 de->dev->stats.tx_bytes += skb->len; 585 netif_dbg(de, tx_done, de->dev, 586 "tx done, slot %d\n", tx_tail); 587 } 588 dev_kfree_skb_irq(skb); 589 } 590 591 next: 592 de->tx_skb[tx_tail].skb = NULL; 593 594 tx_tail = NEXT_TX(tx_tail); 595 } 596 597 de->tx_tail = tx_tail; 598 599 if (netif_queue_stopped(de->dev) && (TX_BUFFS_AVAIL(de) > (DE_TX_RING_SIZE / 4))) 600 netif_wake_queue(de->dev); 601 } 602 603 static netdev_tx_t de_start_xmit (struct sk_buff *skb, 604 struct net_device *dev) 605 { 606 struct de_private *de = netdev_priv(dev); 607 unsigned int entry, tx_free; 608 u32 mapping, len, flags = FirstFrag | LastFrag; 609 struct de_desc *txd; 610 611 spin_lock_irq(&de->lock); 612 613 tx_free = TX_BUFFS_AVAIL(de); 614 if (tx_free == 0) { 615 netif_stop_queue(dev); 616 spin_unlock_irq(&de->lock); 617 return NETDEV_TX_BUSY; 618 } 619 tx_free--; 620 621 entry = de->tx_head; 622 623 txd = &de->tx_ring[entry]; 624 625 len = skb->len; 626 mapping = pci_map_single(de->pdev, skb->data, len, PCI_DMA_TODEVICE); 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 int i; 668 u16 *eaddrs; 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 = (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 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 = (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 pci_map_single (de->pdev, de->setup_frame, 770 sizeof (de->setup_frame), PCI_DMA_TODEVICE); 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 = from_timer(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 = from_timer(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 = pci_map_single(de->pdev, 1286 skb->data, de->rx_buf_sz, PCI_DMA_FROMDEVICE); 1287 de->rx_skb[i].skb = skb; 1288 1289 de->rx_ring[i].opts1 = cpu_to_le32(DescOwn); 1290 if (i == (DE_RX_RING_SIZE - 1)) 1291 de->rx_ring[i].opts2 = 1292 cpu_to_le32(RingEnd | de->rx_buf_sz); 1293 else 1294 de->rx_ring[i].opts2 = cpu_to_le32(de->rx_buf_sz); 1295 de->rx_ring[i].addr1 = cpu_to_le32(de->rx_skb[i].mapping); 1296 de->rx_ring[i].addr2 = 0; 1297 } 1298 1299 return 0; 1300 1301 err_out: 1302 de_clean_rings(de); 1303 return -ENOMEM; 1304 } 1305 1306 static int de_init_rings (struct de_private *de) 1307 { 1308 memset(de->tx_ring, 0, sizeof(struct de_desc) * DE_TX_RING_SIZE); 1309 de->tx_ring[DE_TX_RING_SIZE - 1].opts2 = cpu_to_le32(RingEnd); 1310 1311 de->rx_tail = 0; 1312 de->tx_head = de->tx_tail = 0; 1313 1314 return de_refill_rx (de); 1315 } 1316 1317 static int de_alloc_rings (struct de_private *de) 1318 { 1319 de->rx_ring = pci_alloc_consistent(de->pdev, DE_RING_BYTES, &de->ring_dma); 1320 if (!de->rx_ring) 1321 return -ENOMEM; 1322 de->tx_ring = &de->rx_ring[DE_RX_RING_SIZE]; 1323 return de_init_rings(de); 1324 } 1325 1326 static void de_clean_rings (struct de_private *de) 1327 { 1328 unsigned i; 1329 1330 memset(de->rx_ring, 0, sizeof(struct de_desc) * DE_RX_RING_SIZE); 1331 de->rx_ring[DE_RX_RING_SIZE - 1].opts2 = cpu_to_le32(RingEnd); 1332 wmb(); 1333 memset(de->tx_ring, 0, sizeof(struct de_desc) * DE_TX_RING_SIZE); 1334 de->tx_ring[DE_TX_RING_SIZE - 1].opts2 = cpu_to_le32(RingEnd); 1335 wmb(); 1336 1337 for (i = 0; i < DE_RX_RING_SIZE; i++) { 1338 if (de->rx_skb[i].skb) { 1339 pci_unmap_single(de->pdev, de->rx_skb[i].mapping, 1340 de->rx_buf_sz, PCI_DMA_FROMDEVICE); 1341 dev_kfree_skb(de->rx_skb[i].skb); 1342 } 1343 } 1344 1345 for (i = 0; i < DE_TX_RING_SIZE; i++) { 1346 struct sk_buff *skb = de->tx_skb[i].skb; 1347 if ((skb) && (skb != DE_DUMMY_SKB)) { 1348 if (skb != DE_SETUP_SKB) { 1349 de->dev->stats.tx_dropped++; 1350 pci_unmap_single(de->pdev, 1351 de->tx_skb[i].mapping, 1352 skb->len, PCI_DMA_TODEVICE); 1353 dev_kfree_skb(skb); 1354 } else { 1355 pci_unmap_single(de->pdev, 1356 de->tx_skb[i].mapping, 1357 sizeof(de->setup_frame), 1358 PCI_DMA_TODEVICE); 1359 } 1360 } 1361 } 1362 1363 memset(&de->rx_skb, 0, sizeof(struct ring_info) * DE_RX_RING_SIZE); 1364 memset(&de->tx_skb, 0, sizeof(struct ring_info) * DE_TX_RING_SIZE); 1365 } 1366 1367 static void de_free_rings (struct de_private *de) 1368 { 1369 de_clean_rings(de); 1370 pci_free_consistent(de->pdev, DE_RING_BYTES, de->rx_ring, de->ring_dma); 1371 de->rx_ring = NULL; 1372 de->tx_ring = NULL; 1373 } 1374 1375 static int de_open (struct net_device *dev) 1376 { 1377 struct de_private *de = netdev_priv(dev); 1378 const int irq = de->pdev->irq; 1379 int rc; 1380 1381 netif_dbg(de, ifup, dev, "enabling interface\n"); 1382 1383 de->rx_buf_sz = (dev->mtu <= 1500 ? PKT_BUF_SZ : dev->mtu + 32); 1384 1385 rc = de_alloc_rings(de); 1386 if (rc) { 1387 netdev_err(dev, "ring allocation failure, err=%d\n", rc); 1388 return rc; 1389 } 1390 1391 dw32(IntrMask, 0); 1392 1393 rc = request_irq(irq, de_interrupt, IRQF_SHARED, dev->name, dev); 1394 if (rc) { 1395 netdev_err(dev, "IRQ %d request failure, err=%d\n", irq, rc); 1396 goto err_out_free; 1397 } 1398 1399 rc = de_init_hw(de); 1400 if (rc) { 1401 netdev_err(dev, "h/w init failure, err=%d\n", rc); 1402 goto err_out_free_irq; 1403 } 1404 1405 netif_start_queue(dev); 1406 mod_timer(&de->media_timer, jiffies + DE_TIMER_NO_LINK); 1407 1408 return 0; 1409 1410 err_out_free_irq: 1411 free_irq(irq, dev); 1412 err_out_free: 1413 de_free_rings(de); 1414 return rc; 1415 } 1416 1417 static int de_close (struct net_device *dev) 1418 { 1419 struct de_private *de = netdev_priv(dev); 1420 unsigned long flags; 1421 1422 netif_dbg(de, ifdown, dev, "disabling interface\n"); 1423 1424 del_timer_sync(&de->media_timer); 1425 1426 spin_lock_irqsave(&de->lock, flags); 1427 de_stop_hw(de); 1428 netif_stop_queue(dev); 1429 netif_carrier_off(dev); 1430 spin_unlock_irqrestore(&de->lock, flags); 1431 1432 free_irq(de->pdev->irq, dev); 1433 1434 de_free_rings(de); 1435 de_adapter_sleep(de); 1436 return 0; 1437 } 1438 1439 static void de_tx_timeout (struct net_device *dev) 1440 { 1441 struct de_private *de = netdev_priv(dev); 1442 const int irq = de->pdev->irq; 1443 1444 netdev_dbg(dev, "NIC status %08x mode %08x sia %08x desc %u/%u/%u\n", 1445 dr32(MacStatus), dr32(MacMode), dr32(SIAStatus), 1446 de->rx_tail, de->tx_head, de->tx_tail); 1447 1448 del_timer_sync(&de->media_timer); 1449 1450 disable_irq(irq); 1451 spin_lock_irq(&de->lock); 1452 1453 de_stop_hw(de); 1454 netif_stop_queue(dev); 1455 netif_carrier_off(dev); 1456 1457 spin_unlock_irq(&de->lock); 1458 enable_irq(irq); 1459 1460 /* Update the error counts. */ 1461 __de_get_stats(de); 1462 1463 synchronize_irq(irq); 1464 de_clean_rings(de); 1465 1466 de_init_rings(de); 1467 1468 de_init_hw(de); 1469 1470 netif_wake_queue(dev); 1471 } 1472 1473 static void __de_get_regs(struct de_private *de, u8 *buf) 1474 { 1475 int i; 1476 u32 *rbuf = (u32 *)buf; 1477 1478 /* read all CSRs */ 1479 for (i = 0; i < DE_NUM_REGS; i++) 1480 rbuf[i] = dr32(i * 8); 1481 1482 /* handle self-clearing RxMissed counter, CSR8 */ 1483 de_rx_missed(de, rbuf[8]); 1484 } 1485 1486 static void __de_get_link_ksettings(struct de_private *de, 1487 struct ethtool_link_ksettings *cmd) 1488 { 1489 ethtool_convert_legacy_u32_to_link_mode(cmd->link_modes.supported, 1490 de->media_supported); 1491 cmd->base.phy_address = 0; 1492 ethtool_convert_legacy_u32_to_link_mode(cmd->link_modes.advertising, 1493 de->media_advertise); 1494 1495 switch (de->media_type) { 1496 case DE_MEDIA_AUI: 1497 cmd->base.port = PORT_AUI; 1498 break; 1499 case DE_MEDIA_BNC: 1500 cmd->base.port = PORT_BNC; 1501 break; 1502 default: 1503 cmd->base.port = PORT_TP; 1504 break; 1505 } 1506 1507 cmd->base.speed = 10; 1508 1509 if (dr32(MacMode) & FullDuplex) 1510 cmd->base.duplex = DUPLEX_FULL; 1511 else 1512 cmd->base.duplex = DUPLEX_HALF; 1513 1514 if (de->media_lock) 1515 cmd->base.autoneg = AUTONEG_DISABLE; 1516 else 1517 cmd->base.autoneg = AUTONEG_ENABLE; 1518 1519 /* ignore maxtxpkt, maxrxpkt for now */ 1520 } 1521 1522 static int __de_set_link_ksettings(struct de_private *de, 1523 const struct ethtool_link_ksettings *cmd) 1524 { 1525 u32 new_media; 1526 unsigned int media_lock; 1527 u8 duplex = cmd->base.duplex; 1528 u8 port = cmd->base.port; 1529 u8 autoneg = cmd->base.autoneg; 1530 u32 advertising; 1531 1532 ethtool_convert_link_mode_to_legacy_u32(&advertising, 1533 cmd->link_modes.advertising); 1534 1535 if (cmd->base.speed != 10) 1536 return -EINVAL; 1537 if (duplex != DUPLEX_HALF && duplex != DUPLEX_FULL) 1538 return -EINVAL; 1539 if (port != PORT_TP && port != PORT_AUI && port != PORT_BNC) 1540 return -EINVAL; 1541 if (de->de21040 && port == PORT_BNC) 1542 return -EINVAL; 1543 if (autoneg != AUTONEG_DISABLE && autoneg != AUTONEG_ENABLE) 1544 return -EINVAL; 1545 if (advertising & ~de->media_supported) 1546 return -EINVAL; 1547 if (autoneg == AUTONEG_ENABLE && 1548 (!(advertising & ADVERTISED_Autoneg))) 1549 return -EINVAL; 1550 1551 switch (port) { 1552 case PORT_AUI: 1553 new_media = DE_MEDIA_AUI; 1554 if (!(advertising & ADVERTISED_AUI)) 1555 return -EINVAL; 1556 break; 1557 case PORT_BNC: 1558 new_media = DE_MEDIA_BNC; 1559 if (!(advertising & ADVERTISED_BNC)) 1560 return -EINVAL; 1561 break; 1562 default: 1563 if (autoneg == AUTONEG_ENABLE) 1564 new_media = DE_MEDIA_TP_AUTO; 1565 else if (duplex == DUPLEX_FULL) 1566 new_media = DE_MEDIA_TP_FD; 1567 else 1568 new_media = DE_MEDIA_TP; 1569 if (!(advertising & ADVERTISED_TP)) 1570 return -EINVAL; 1571 if (!(advertising & (ADVERTISED_10baseT_Full | 1572 ADVERTISED_10baseT_Half))) 1573 return -EINVAL; 1574 break; 1575 } 1576 1577 media_lock = (autoneg == AUTONEG_ENABLE) ? 0 : 1; 1578 1579 if ((new_media == de->media_type) && 1580 (media_lock == de->media_lock) && 1581 (advertising == de->media_advertise)) 1582 return 0; /* nothing to change */ 1583 1584 de_link_down(de); 1585 mod_timer(&de->media_timer, jiffies + DE_TIMER_NO_LINK); 1586 de_stop_rxtx(de); 1587 1588 de->media_type = new_media; 1589 de->media_lock = media_lock; 1590 de->media_advertise = advertising; 1591 de_set_media(de); 1592 if (netif_running(de->dev)) 1593 de_start_rxtx(de); 1594 1595 return 0; 1596 } 1597 1598 static void de_get_drvinfo (struct net_device *dev,struct ethtool_drvinfo *info) 1599 { 1600 struct de_private *de = netdev_priv(dev); 1601 1602 strlcpy(info->driver, DRV_NAME, sizeof(info->driver)); 1603 strlcpy(info->version, DRV_VERSION, sizeof(info->version)); 1604 strlcpy(info->bus_info, pci_name(de->pdev), sizeof(info->bus_info)); 1605 } 1606 1607 static int de_get_regs_len(struct net_device *dev) 1608 { 1609 return DE_REGS_SIZE; 1610 } 1611 1612 static int de_get_link_ksettings(struct net_device *dev, 1613 struct ethtool_link_ksettings *cmd) 1614 { 1615 struct de_private *de = netdev_priv(dev); 1616 1617 spin_lock_irq(&de->lock); 1618 __de_get_link_ksettings(de, cmd); 1619 spin_unlock_irq(&de->lock); 1620 1621 return 0; 1622 } 1623 1624 static int de_set_link_ksettings(struct net_device *dev, 1625 const struct ethtool_link_ksettings *cmd) 1626 { 1627 struct de_private *de = netdev_priv(dev); 1628 int rc; 1629 1630 spin_lock_irq(&de->lock); 1631 rc = __de_set_link_ksettings(de, cmd); 1632 spin_unlock_irq(&de->lock); 1633 1634 return rc; 1635 } 1636 1637 static u32 de_get_msglevel(struct net_device *dev) 1638 { 1639 struct de_private *de = netdev_priv(dev); 1640 1641 return de->msg_enable; 1642 } 1643 1644 static void de_set_msglevel(struct net_device *dev, u32 msglvl) 1645 { 1646 struct de_private *de = netdev_priv(dev); 1647 1648 de->msg_enable = msglvl; 1649 } 1650 1651 static int de_get_eeprom(struct net_device *dev, 1652 struct ethtool_eeprom *eeprom, u8 *data) 1653 { 1654 struct de_private *de = netdev_priv(dev); 1655 1656 if (!de->ee_data) 1657 return -EOPNOTSUPP; 1658 if ((eeprom->offset != 0) || (eeprom->magic != 0) || 1659 (eeprom->len != DE_EEPROM_SIZE)) 1660 return -EINVAL; 1661 memcpy(data, de->ee_data, eeprom->len); 1662 1663 return 0; 1664 } 1665 1666 static int de_nway_reset(struct net_device *dev) 1667 { 1668 struct de_private *de = netdev_priv(dev); 1669 u32 status; 1670 1671 if (de->media_type != DE_MEDIA_TP_AUTO) 1672 return -EINVAL; 1673 if (netif_carrier_ok(de->dev)) 1674 de_link_down(de); 1675 1676 status = dr32(SIAStatus); 1677 dw32(SIAStatus, (status & ~NWayState) | NWayRestart); 1678 netif_info(de, link, dev, "link nway restart, status %x,%x\n", 1679 status, dr32(SIAStatus)); 1680 return 0; 1681 } 1682 1683 static void de_get_regs(struct net_device *dev, struct ethtool_regs *regs, 1684 void *data) 1685 { 1686 struct de_private *de = netdev_priv(dev); 1687 1688 regs->version = (DE_REGS_VER << 2) | de->de21040; 1689 1690 spin_lock_irq(&de->lock); 1691 __de_get_regs(de, data); 1692 spin_unlock_irq(&de->lock); 1693 } 1694 1695 static const struct ethtool_ops de_ethtool_ops = { 1696 .get_link = ethtool_op_get_link, 1697 .get_drvinfo = de_get_drvinfo, 1698 .get_regs_len = de_get_regs_len, 1699 .get_msglevel = de_get_msglevel, 1700 .set_msglevel = de_set_msglevel, 1701 .get_eeprom = de_get_eeprom, 1702 .nway_reset = de_nway_reset, 1703 .get_regs = de_get_regs, 1704 .get_link_ksettings = de_get_link_ksettings, 1705 .set_link_ksettings = de_set_link_ksettings, 1706 }; 1707 1708 static void de21040_get_mac_address(struct de_private *de) 1709 { 1710 unsigned i; 1711 1712 dw32 (ROMCmd, 0); /* Reset the pointer with a dummy write. */ 1713 udelay(5); 1714 1715 for (i = 0; i < 6; i++) { 1716 int value, boguscnt = 100000; 1717 do { 1718 value = dr32(ROMCmd); 1719 rmb(); 1720 } while (value < 0 && --boguscnt > 0); 1721 de->dev->dev_addr[i] = value; 1722 udelay(1); 1723 if (boguscnt <= 0) 1724 pr_warn("timeout reading 21040 MAC address byte %u\n", 1725 i); 1726 } 1727 } 1728 1729 static void de21040_get_media_info(struct de_private *de) 1730 { 1731 unsigned int i; 1732 1733 de->media_type = DE_MEDIA_TP; 1734 de->media_supported |= SUPPORTED_TP | SUPPORTED_10baseT_Full | 1735 SUPPORTED_10baseT_Half | SUPPORTED_AUI; 1736 de->media_advertise = de->media_supported; 1737 1738 for (i = 0; i < DE_MAX_MEDIA; i++) { 1739 switch (i) { 1740 case DE_MEDIA_AUI: 1741 case DE_MEDIA_TP: 1742 case DE_MEDIA_TP_FD: 1743 de->media[i].type = i; 1744 de->media[i].csr13 = t21040_csr13[i]; 1745 de->media[i].csr14 = t21040_csr14[i]; 1746 de->media[i].csr15 = t21040_csr15[i]; 1747 break; 1748 default: 1749 de->media[i].type = DE_MEDIA_INVALID; 1750 break; 1751 } 1752 } 1753 } 1754 1755 /* Note: this routine returns extra data bits for size detection. */ 1756 static unsigned tulip_read_eeprom(void __iomem *regs, int location, 1757 int addr_len) 1758 { 1759 int i; 1760 unsigned retval = 0; 1761 void __iomem *ee_addr = regs + ROMCmd; 1762 int read_cmd = location | (EE_READ_CMD << addr_len); 1763 1764 writel(EE_ENB & ~EE_CS, ee_addr); 1765 writel(EE_ENB, ee_addr); 1766 1767 /* Shift the read command bits out. */ 1768 for (i = 4 + addr_len; i >= 0; i--) { 1769 short dataval = (read_cmd & (1 << i)) ? EE_DATA_WRITE : 0; 1770 writel(EE_ENB | dataval, ee_addr); 1771 readl(ee_addr); 1772 writel(EE_ENB | dataval | EE_SHIFT_CLK, ee_addr); 1773 readl(ee_addr); 1774 retval = (retval << 1) | ((readl(ee_addr) & EE_DATA_READ) ? 1 : 0); 1775 } 1776 writel(EE_ENB, ee_addr); 1777 readl(ee_addr); 1778 1779 for (i = 16; i > 0; i--) { 1780 writel(EE_ENB | EE_SHIFT_CLK, ee_addr); 1781 readl(ee_addr); 1782 retval = (retval << 1) | ((readl(ee_addr) & EE_DATA_READ) ? 1 : 0); 1783 writel(EE_ENB, ee_addr); 1784 readl(ee_addr); 1785 } 1786 1787 /* Terminate the EEPROM access. */ 1788 writel(EE_ENB & ~EE_CS, ee_addr); 1789 return retval; 1790 } 1791 1792 static void de21041_get_srom_info(struct de_private *de) 1793 { 1794 unsigned i, sa_offset = 0, ofs; 1795 u8 ee_data[DE_EEPROM_SIZE + 6] = {}; 1796 unsigned ee_addr_size = tulip_read_eeprom(de->regs, 0xff, 8) & 0x40000 ? 8 : 6; 1797 struct de_srom_info_leaf *il; 1798 void *bufp; 1799 1800 /* download entire eeprom */ 1801 for (i = 0; i < DE_EEPROM_WORDS; i++) 1802 ((__le16 *)ee_data)[i] = 1803 cpu_to_le16(tulip_read_eeprom(de->regs, i, ee_addr_size)); 1804 1805 /* DEC now has a specification but early board makers 1806 just put the address in the first EEPROM locations. */ 1807 /* This does memcmp(eedata, eedata+16, 8) */ 1808 1809 #ifndef CONFIG_MIPS_COBALT 1810 1811 for (i = 0; i < 8; i ++) 1812 if (ee_data[i] != ee_data[16+i]) 1813 sa_offset = 20; 1814 1815 #endif 1816 1817 /* store MAC address */ 1818 for (i = 0; i < 6; i ++) 1819 de->dev->dev_addr[i] = ee_data[i + sa_offset]; 1820 1821 /* get offset of controller 0 info leaf. ignore 2nd byte. */ 1822 ofs = ee_data[SROMC0InfoLeaf]; 1823 if (ofs >= (sizeof(ee_data) - sizeof(struct de_srom_info_leaf) - sizeof(struct de_srom_media_block))) 1824 goto bad_srom; 1825 1826 /* get pointer to info leaf */ 1827 il = (struct de_srom_info_leaf *) &ee_data[ofs]; 1828 1829 /* paranoia checks */ 1830 if (il->n_blocks == 0) 1831 goto bad_srom; 1832 if ((sizeof(ee_data) - ofs) < 1833 (sizeof(struct de_srom_info_leaf) + (sizeof(struct de_srom_media_block) * il->n_blocks))) 1834 goto bad_srom; 1835 1836 /* get default media type */ 1837 switch (get_unaligned(&il->default_media)) { 1838 case 0x0001: de->media_type = DE_MEDIA_BNC; break; 1839 case 0x0002: de->media_type = DE_MEDIA_AUI; break; 1840 case 0x0204: de->media_type = DE_MEDIA_TP_FD; break; 1841 default: de->media_type = DE_MEDIA_TP_AUTO; break; 1842 } 1843 1844 if (netif_msg_probe(de)) 1845 pr_info("de%d: SROM leaf offset %u, default media %s\n", 1846 de->board_idx, ofs, media_name[de->media_type]); 1847 1848 /* init SIA register values to defaults */ 1849 for (i = 0; i < DE_MAX_MEDIA; i++) { 1850 de->media[i].type = DE_MEDIA_INVALID; 1851 de->media[i].csr13 = 0xffff; 1852 de->media[i].csr14 = 0xffff; 1853 de->media[i].csr15 = 0xffff; 1854 } 1855 1856 /* parse media blocks to see what medias are supported, 1857 * and if any custom CSR values are provided 1858 */ 1859 bufp = ((void *)il) + sizeof(*il); 1860 for (i = 0; i < il->n_blocks; i++) { 1861 struct de_srom_media_block *ib = bufp; 1862 unsigned idx; 1863 1864 /* index based on media type in media block */ 1865 switch(ib->opts & MediaBlockMask) { 1866 case 0: /* 10baseT */ 1867 de->media_supported |= SUPPORTED_TP | SUPPORTED_10baseT_Half 1868 | SUPPORTED_Autoneg; 1869 idx = DE_MEDIA_TP; 1870 de->media[DE_MEDIA_TP_AUTO].type = DE_MEDIA_TP_AUTO; 1871 break; 1872 case 1: /* BNC */ 1873 de->media_supported |= SUPPORTED_BNC; 1874 idx = DE_MEDIA_BNC; 1875 break; 1876 case 2: /* AUI */ 1877 de->media_supported |= SUPPORTED_AUI; 1878 idx = DE_MEDIA_AUI; 1879 break; 1880 case 4: /* 10baseT-FD */ 1881 de->media_supported |= SUPPORTED_TP | SUPPORTED_10baseT_Full 1882 | SUPPORTED_Autoneg; 1883 idx = DE_MEDIA_TP_FD; 1884 de->media[DE_MEDIA_TP_AUTO].type = DE_MEDIA_TP_AUTO; 1885 break; 1886 default: 1887 goto bad_srom; 1888 } 1889 1890 de->media[idx].type = idx; 1891 1892 if (netif_msg_probe(de)) 1893 pr_info("de%d: media block #%u: %s", 1894 de->board_idx, i, 1895 media_name[de->media[idx].type]); 1896 1897 bufp += sizeof (ib->opts); 1898 1899 if (ib->opts & MediaCustomCSRs) { 1900 de->media[idx].csr13 = get_unaligned(&ib->csr13); 1901 de->media[idx].csr14 = get_unaligned(&ib->csr14); 1902 de->media[idx].csr15 = get_unaligned(&ib->csr15); 1903 bufp += sizeof(ib->csr13) + sizeof(ib->csr14) + 1904 sizeof(ib->csr15); 1905 1906 if (netif_msg_probe(de)) 1907 pr_cont(" (%x,%x,%x)\n", 1908 de->media[idx].csr13, 1909 de->media[idx].csr14, 1910 de->media[idx].csr15); 1911 1912 } else { 1913 if (netif_msg_probe(de)) 1914 pr_cont("\n"); 1915 } 1916 1917 if (bufp > ((void *)&ee_data[DE_EEPROM_SIZE - 3])) 1918 break; 1919 } 1920 1921 de->media_advertise = de->media_supported; 1922 1923 fill_defaults: 1924 /* fill in defaults, for cases where custom CSRs not used */ 1925 for (i = 0; i < DE_MAX_MEDIA; i++) { 1926 if (de->media[i].csr13 == 0xffff) 1927 de->media[i].csr13 = t21041_csr13[i]; 1928 if (de->media[i].csr14 == 0xffff) { 1929 /* autonegotiation is broken at least on some chip 1930 revisions - rev. 0x21 works, 0x11 does not */ 1931 if (de->pdev->revision < 0x20) 1932 de->media[i].csr14 = t21041_csr14_brk[i]; 1933 else 1934 de->media[i].csr14 = t21041_csr14[i]; 1935 } 1936 if (de->media[i].csr15 == 0xffff) 1937 de->media[i].csr15 = t21041_csr15[i]; 1938 } 1939 1940 de->ee_data = kmemdup(&ee_data[0], DE_EEPROM_SIZE, GFP_KERNEL); 1941 1942 return; 1943 1944 bad_srom: 1945 /* for error cases, it's ok to assume we support all these */ 1946 for (i = 0; i < DE_MAX_MEDIA; i++) 1947 de->media[i].type = i; 1948 de->media_supported = 1949 SUPPORTED_10baseT_Half | 1950 SUPPORTED_10baseT_Full | 1951 SUPPORTED_Autoneg | 1952 SUPPORTED_TP | 1953 SUPPORTED_AUI | 1954 SUPPORTED_BNC; 1955 goto fill_defaults; 1956 } 1957 1958 static const struct net_device_ops de_netdev_ops = { 1959 .ndo_open = de_open, 1960 .ndo_stop = de_close, 1961 .ndo_set_rx_mode = de_set_rx_mode, 1962 .ndo_start_xmit = de_start_xmit, 1963 .ndo_get_stats = de_get_stats, 1964 .ndo_tx_timeout = de_tx_timeout, 1965 .ndo_set_mac_address = eth_mac_addr, 1966 .ndo_validate_addr = eth_validate_addr, 1967 }; 1968 1969 static int de_init_one(struct pci_dev *pdev, const struct pci_device_id *ent) 1970 { 1971 struct net_device *dev; 1972 struct de_private *de; 1973 int rc; 1974 void __iomem *regs; 1975 unsigned long pciaddr; 1976 static int board_idx = -1; 1977 1978 board_idx++; 1979 1980 #ifndef MODULE 1981 if (board_idx == 0) 1982 pr_info("%s\n", version); 1983 #endif 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_nocache(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 #ifdef CONFIG_PM 2118 2119 static int de_suspend (struct pci_dev *pdev, pm_message_t state) 2120 { 2121 struct net_device *dev = pci_get_drvdata (pdev); 2122 struct de_private *de = netdev_priv(dev); 2123 2124 rtnl_lock(); 2125 if (netif_running (dev)) { 2126 const int irq = pdev->irq; 2127 2128 del_timer_sync(&de->media_timer); 2129 2130 disable_irq(irq); 2131 spin_lock_irq(&de->lock); 2132 2133 de_stop_hw(de); 2134 netif_stop_queue(dev); 2135 netif_device_detach(dev); 2136 netif_carrier_off(dev); 2137 2138 spin_unlock_irq(&de->lock); 2139 enable_irq(irq); 2140 2141 /* Update the error counts. */ 2142 __de_get_stats(de); 2143 2144 synchronize_irq(irq); 2145 de_clean_rings(de); 2146 2147 de_adapter_sleep(de); 2148 pci_disable_device(pdev); 2149 } else { 2150 netif_device_detach(dev); 2151 } 2152 rtnl_unlock(); 2153 return 0; 2154 } 2155 2156 static int de_resume (struct pci_dev *pdev) 2157 { 2158 struct net_device *dev = pci_get_drvdata (pdev); 2159 struct de_private *de = netdev_priv(dev); 2160 int retval = 0; 2161 2162 rtnl_lock(); 2163 if (netif_device_present(dev)) 2164 goto out; 2165 if (!netif_running(dev)) 2166 goto out_attach; 2167 if ((retval = pci_enable_device(pdev))) { 2168 netdev_err(dev, "pci_enable_device failed in resume\n"); 2169 goto out; 2170 } 2171 pci_set_master(pdev); 2172 de_init_rings(de); 2173 de_init_hw(de); 2174 out_attach: 2175 netif_device_attach(dev); 2176 out: 2177 rtnl_unlock(); 2178 return 0; 2179 } 2180 2181 #endif /* CONFIG_PM */ 2182 2183 static struct pci_driver de_driver = { 2184 .name = DRV_NAME, 2185 .id_table = de_pci_tbl, 2186 .probe = de_init_one, 2187 .remove = de_remove_one, 2188 #ifdef CONFIG_PM 2189 .suspend = de_suspend, 2190 .resume = de_resume, 2191 #endif 2192 }; 2193 2194 static int __init de_init (void) 2195 { 2196 #ifdef MODULE 2197 pr_info("%s\n", version); 2198 #endif 2199 return pci_register_driver(&de_driver); 2200 } 2201 2202 static void __exit de_exit (void) 2203 { 2204 pci_unregister_driver (&de_driver); 2205 } 2206 2207 module_init(de_init); 2208 module_exit(de_exit); 2209