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 <asm/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 64 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_VENDOR_ID_DEC, PCI_DEVICE_ID_DEC_TULIP, 337 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 }, 338 { PCI_VENDOR_ID_DEC, PCI_DEVICE_ID_DEC_TULIP_PLUS, 339 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 1 }, 340 { }, 341 }; 342 MODULE_DEVICE_TABLE(pci, de_pci_tbl); 343 344 static const char * const media_name[DE_MAX_MEDIA] = { 345 "10baseT auto", 346 "BNC", 347 "AUI", 348 "10baseT-HD", 349 "10baseT-FD" 350 }; 351 352 /* 21040 transceiver register settings: 353 * TP AUTO(unused), BNC(unused), AUI, TP, TP FD*/ 354 static u16 t21040_csr13[] = { 0, 0, 0x8F09, 0x8F01, 0x8F01, }; 355 static u16 t21040_csr14[] = { 0, 0, 0x0705, 0xFFFF, 0xFFFD, }; 356 static u16 t21040_csr15[] = { 0, 0, 0x0006, 0x0000, 0x0000, }; 357 358 /* 21041 transceiver register settings: TP AUTO, BNC, AUI, TP, TP FD*/ 359 static u16 t21041_csr13[] = { 0xEF01, 0xEF09, 0xEF09, 0xEF01, 0xEF09, }; 360 static u16 t21041_csr14[] = { 0xFFFF, 0xF7FD, 0xF7FD, 0x7F3F, 0x7F3D, }; 361 /* If on-chip autonegotiation is broken, use half-duplex (FF3F) instead */ 362 static u16 t21041_csr14_brk[] = { 0xFF3F, 0xF7FD, 0xF7FD, 0x7F3F, 0x7F3D, }; 363 static u16 t21041_csr15[] = { 0x0008, 0x0006, 0x000E, 0x0008, 0x0008, }; 364 365 366 #define dr32(reg) ioread32(de->regs + (reg)) 367 #define dw32(reg, val) iowrite32((val), de->regs + (reg)) 368 369 370 static void de_rx_err_acct (struct de_private *de, unsigned rx_tail, 371 u32 status, u32 len) 372 { 373 netif_dbg(de, rx_err, de->dev, 374 "rx err, slot %d status 0x%x len %d\n", 375 rx_tail, status, len); 376 377 if ((status & 0x38000300) != 0x0300) { 378 /* Ingore earlier buffers. */ 379 if ((status & 0xffff) != 0x7fff) { 380 netif_warn(de, rx_err, de->dev, 381 "Oversized Ethernet frame spanned multiple buffers, status %08x!\n", 382 status); 383 de->dev->stats.rx_length_errors++; 384 } 385 } else if (status & RxError) { 386 /* There was a fatal error. */ 387 de->dev->stats.rx_errors++; /* end of a packet.*/ 388 if (status & 0x0890) de->dev->stats.rx_length_errors++; 389 if (status & RxErrCRC) de->dev->stats.rx_crc_errors++; 390 if (status & RxErrFIFO) de->dev->stats.rx_fifo_errors++; 391 } 392 } 393 394 static void de_rx (struct de_private *de) 395 { 396 unsigned rx_tail = de->rx_tail; 397 unsigned rx_work = DE_RX_RING_SIZE; 398 unsigned drop = 0; 399 int rc; 400 401 while (--rx_work) { 402 u32 status, len; 403 dma_addr_t mapping; 404 struct sk_buff *skb, *copy_skb; 405 unsigned copying_skb, buflen; 406 407 skb = de->rx_skb[rx_tail].skb; 408 BUG_ON(!skb); 409 rmb(); 410 status = le32_to_cpu(de->rx_ring[rx_tail].opts1); 411 if (status & DescOwn) 412 break; 413 414 /* the length is actually a 15 bit value here according 415 * to Table 4-1 in the DE2104x spec so mask is 0x7fff 416 */ 417 len = ((status >> 16) & 0x7fff) - 4; 418 mapping = de->rx_skb[rx_tail].mapping; 419 420 if (unlikely(drop)) { 421 de->dev->stats.rx_dropped++; 422 goto rx_next; 423 } 424 425 if (unlikely((status & 0x38008300) != 0x0300)) { 426 de_rx_err_acct(de, rx_tail, status, len); 427 goto rx_next; 428 } 429 430 copying_skb = (len <= rx_copybreak); 431 432 netif_dbg(de, rx_status, de->dev, 433 "rx slot %d status 0x%x len %d copying? %d\n", 434 rx_tail, status, len, copying_skb); 435 436 buflen = copying_skb ? (len + RX_OFFSET) : de->rx_buf_sz; 437 copy_skb = netdev_alloc_skb(de->dev, buflen); 438 if (unlikely(!copy_skb)) { 439 de->dev->stats.rx_dropped++; 440 drop = 1; 441 rx_work = 100; 442 goto rx_next; 443 } 444 445 if (!copying_skb) { 446 pci_unmap_single(de->pdev, mapping, 447 buflen, PCI_DMA_FROMDEVICE); 448 skb_put(skb, len); 449 450 mapping = 451 de->rx_skb[rx_tail].mapping = 452 pci_map_single(de->pdev, copy_skb->data, 453 buflen, PCI_DMA_FROMDEVICE); 454 de->rx_skb[rx_tail].skb = copy_skb; 455 } else { 456 pci_dma_sync_single_for_cpu(de->pdev, mapping, len, PCI_DMA_FROMDEVICE); 457 skb_reserve(copy_skb, RX_OFFSET); 458 skb_copy_from_linear_data(skb, skb_put(copy_skb, len), 459 len); 460 pci_dma_sync_single_for_device(de->pdev, mapping, len, PCI_DMA_FROMDEVICE); 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 pci_unmap_single(de->pdev, de->tx_skb[tx_tail].mapping, 558 sizeof(de->setup_frame), PCI_DMA_TODEVICE); 559 goto next; 560 } 561 562 pci_unmap_single(de->pdev, de->tx_skb[tx_tail].mapping, 563 skb->len, PCI_DMA_TODEVICE); 564 565 if (status & LastFrag) { 566 if (status & TxError) { 567 netif_dbg(de, tx_err, de->dev, 568 "tx err, status 0x%x\n", 569 status); 570 de->dev->stats.tx_errors++; 571 if (status & TxOWC) 572 de->dev->stats.tx_window_errors++; 573 if (status & TxMaxCol) 574 de->dev->stats.tx_aborted_errors++; 575 if (status & TxLinkFail) 576 de->dev->stats.tx_carrier_errors++; 577 if (status & TxFIFOUnder) 578 de->dev->stats.tx_fifo_errors++; 579 } else { 580 de->dev->stats.tx_packets++; 581 de->dev->stats.tx_bytes += skb->len; 582 netif_dbg(de, tx_done, de->dev, 583 "tx done, slot %d\n", tx_tail); 584 } 585 dev_consume_skb_irq(skb); 586 } 587 588 next: 589 de->tx_skb[tx_tail].skb = NULL; 590 591 tx_tail = NEXT_TX(tx_tail); 592 } 593 594 de->tx_tail = tx_tail; 595 596 if (netif_queue_stopped(de->dev) && (TX_BUFFS_AVAIL(de) > (DE_TX_RING_SIZE / 4))) 597 netif_wake_queue(de->dev); 598 } 599 600 static netdev_tx_t de_start_xmit (struct sk_buff *skb, 601 struct net_device *dev) 602 { 603 struct de_private *de = netdev_priv(dev); 604 unsigned int entry, tx_free; 605 u32 mapping, len, flags = FirstFrag | LastFrag; 606 struct de_desc *txd; 607 608 spin_lock_irq(&de->lock); 609 610 tx_free = TX_BUFFS_AVAIL(de); 611 if (tx_free == 0) { 612 netif_stop_queue(dev); 613 spin_unlock_irq(&de->lock); 614 return NETDEV_TX_BUSY; 615 } 616 tx_free--; 617 618 entry = de->tx_head; 619 620 txd = &de->tx_ring[entry]; 621 622 len = skb->len; 623 mapping = pci_map_single(de->pdev, skb->data, len, PCI_DMA_TODEVICE); 624 if (entry == (DE_TX_RING_SIZE - 1)) 625 flags |= RingEnd; 626 if (!tx_free || (tx_free == (DE_TX_RING_SIZE / 2))) 627 flags |= TxSwInt; 628 flags |= len; 629 txd->opts2 = cpu_to_le32(flags); 630 txd->addr1 = cpu_to_le32(mapping); 631 632 de->tx_skb[entry].skb = skb; 633 de->tx_skb[entry].mapping = mapping; 634 wmb(); 635 636 txd->opts1 = cpu_to_le32(DescOwn); 637 wmb(); 638 639 de->tx_head = NEXT_TX(entry); 640 netif_dbg(de, tx_queued, dev, "tx queued, slot %d, skblen %d\n", 641 entry, skb->len); 642 643 if (tx_free == 0) 644 netif_stop_queue(dev); 645 646 spin_unlock_irq(&de->lock); 647 648 /* Trigger an immediate transmit demand. */ 649 dw32(TxPoll, NormalTxPoll); 650 651 return NETDEV_TX_OK; 652 } 653 654 /* Set or clear the multicast filter for this adaptor. 655 Note that we only use exclusion around actually queueing the 656 new frame, not around filling de->setup_frame. This is non-deterministic 657 when re-entered but still correct. */ 658 659 static void build_setup_frame_hash(u16 *setup_frm, struct net_device *dev) 660 { 661 struct de_private *de = netdev_priv(dev); 662 u16 hash_table[32]; 663 struct netdev_hw_addr *ha; 664 int i; 665 u16 *eaddrs; 666 667 memset(hash_table, 0, sizeof(hash_table)); 668 __set_bit_le(255, hash_table); /* Broadcast entry */ 669 /* This should work on big-endian machines as well. */ 670 netdev_for_each_mc_addr(ha, dev) { 671 int index = ether_crc_le(ETH_ALEN, ha->addr) & 0x1ff; 672 673 __set_bit_le(index, hash_table); 674 } 675 676 for (i = 0; i < 32; i++) { 677 *setup_frm++ = hash_table[i]; 678 *setup_frm++ = hash_table[i]; 679 } 680 setup_frm = &de->setup_frame[13*6]; 681 682 /* Fill the final entry with our physical address. */ 683 eaddrs = (u16 *)dev->dev_addr; 684 *setup_frm++ = eaddrs[0]; *setup_frm++ = eaddrs[0]; 685 *setup_frm++ = eaddrs[1]; *setup_frm++ = eaddrs[1]; 686 *setup_frm++ = eaddrs[2]; *setup_frm++ = eaddrs[2]; 687 } 688 689 static void build_setup_frame_perfect(u16 *setup_frm, struct net_device *dev) 690 { 691 struct de_private *de = netdev_priv(dev); 692 struct netdev_hw_addr *ha; 693 u16 *eaddrs; 694 695 /* We have <= 14 addresses so we can use the wonderful 696 16 address perfect filtering of the Tulip. */ 697 netdev_for_each_mc_addr(ha, dev) { 698 eaddrs = (u16 *) ha->addr; 699 *setup_frm++ = *eaddrs; *setup_frm++ = *eaddrs++; 700 *setup_frm++ = *eaddrs; *setup_frm++ = *eaddrs++; 701 *setup_frm++ = *eaddrs; *setup_frm++ = *eaddrs++; 702 } 703 /* Fill the unused entries with the broadcast address. */ 704 memset(setup_frm, 0xff, (15 - netdev_mc_count(dev)) * 12); 705 setup_frm = &de->setup_frame[15*6]; 706 707 /* Fill the final entry with our physical address. */ 708 eaddrs = (u16 *)dev->dev_addr; 709 *setup_frm++ = eaddrs[0]; *setup_frm++ = eaddrs[0]; 710 *setup_frm++ = eaddrs[1]; *setup_frm++ = eaddrs[1]; 711 *setup_frm++ = eaddrs[2]; *setup_frm++ = eaddrs[2]; 712 } 713 714 715 static void __de_set_rx_mode (struct net_device *dev) 716 { 717 struct de_private *de = netdev_priv(dev); 718 u32 macmode; 719 unsigned int entry; 720 u32 mapping; 721 struct de_desc *txd; 722 struct de_desc *dummy_txd = NULL; 723 724 macmode = dr32(MacMode) & ~(AcceptAllMulticast | AcceptAllPhys); 725 726 if (dev->flags & IFF_PROMISC) { /* Set promiscuous. */ 727 macmode |= AcceptAllMulticast | AcceptAllPhys; 728 goto out; 729 } 730 731 if ((netdev_mc_count(dev) > 1000) || (dev->flags & IFF_ALLMULTI)) { 732 /* Too many to filter well -- accept all multicasts. */ 733 macmode |= AcceptAllMulticast; 734 goto out; 735 } 736 737 /* Note that only the low-address shortword of setup_frame is valid! 738 The values are doubled for big-endian architectures. */ 739 if (netdev_mc_count(dev) > 14) /* Must use a multicast hash table. */ 740 build_setup_frame_hash (de->setup_frame, dev); 741 else 742 build_setup_frame_perfect (de->setup_frame, dev); 743 744 /* 745 * Now add this frame to the Tx list. 746 */ 747 748 entry = de->tx_head; 749 750 /* Avoid a chip errata by prefixing a dummy entry. */ 751 if (entry != 0) { 752 de->tx_skb[entry].skb = DE_DUMMY_SKB; 753 754 dummy_txd = &de->tx_ring[entry]; 755 dummy_txd->opts2 = (entry == (DE_TX_RING_SIZE - 1)) ? 756 cpu_to_le32(RingEnd) : 0; 757 dummy_txd->addr1 = 0; 758 759 /* Must set DescOwned later to avoid race with chip */ 760 761 entry = NEXT_TX(entry); 762 } 763 764 de->tx_skb[entry].skb = DE_SETUP_SKB; 765 de->tx_skb[entry].mapping = mapping = 766 pci_map_single (de->pdev, de->setup_frame, 767 sizeof (de->setup_frame), PCI_DMA_TODEVICE); 768 769 /* Put the setup frame on the Tx list. */ 770 txd = &de->tx_ring[entry]; 771 if (entry == (DE_TX_RING_SIZE - 1)) 772 txd->opts2 = cpu_to_le32(SetupFrame | RingEnd | sizeof (de->setup_frame)); 773 else 774 txd->opts2 = cpu_to_le32(SetupFrame | sizeof (de->setup_frame)); 775 txd->addr1 = cpu_to_le32(mapping); 776 wmb(); 777 778 txd->opts1 = cpu_to_le32(DescOwn); 779 wmb(); 780 781 if (dummy_txd) { 782 dummy_txd->opts1 = cpu_to_le32(DescOwn); 783 wmb(); 784 } 785 786 de->tx_head = NEXT_TX(entry); 787 788 if (TX_BUFFS_AVAIL(de) == 0) 789 netif_stop_queue(dev); 790 791 /* Trigger an immediate transmit demand. */ 792 dw32(TxPoll, NormalTxPoll); 793 794 out: 795 if (macmode != dr32(MacMode)) 796 dw32(MacMode, macmode); 797 } 798 799 static void de_set_rx_mode (struct net_device *dev) 800 { 801 unsigned long flags; 802 struct de_private *de = netdev_priv(dev); 803 804 spin_lock_irqsave (&de->lock, flags); 805 __de_set_rx_mode(dev); 806 spin_unlock_irqrestore (&de->lock, flags); 807 } 808 809 static inline void de_rx_missed(struct de_private *de, u32 rx_missed) 810 { 811 if (unlikely(rx_missed & RxMissedOver)) 812 de->dev->stats.rx_missed_errors += RxMissedMask; 813 else 814 de->dev->stats.rx_missed_errors += (rx_missed & RxMissedMask); 815 } 816 817 static void __de_get_stats(struct de_private *de) 818 { 819 u32 tmp = dr32(RxMissed); /* self-clearing */ 820 821 de_rx_missed(de, tmp); 822 } 823 824 static struct net_device_stats *de_get_stats(struct net_device *dev) 825 { 826 struct de_private *de = netdev_priv(dev); 827 828 /* The chip only need report frame silently dropped. */ 829 spin_lock_irq(&de->lock); 830 if (netif_running(dev) && netif_device_present(dev)) 831 __de_get_stats(de); 832 spin_unlock_irq(&de->lock); 833 834 return &dev->stats; 835 } 836 837 static inline int de_is_running (struct de_private *de) 838 { 839 return (dr32(MacStatus) & (RxState | TxState)) ? 1 : 0; 840 } 841 842 static void de_stop_rxtx (struct de_private *de) 843 { 844 u32 macmode; 845 unsigned int i = 1300/100; 846 847 macmode = dr32(MacMode); 848 if (macmode & RxTx) { 849 dw32(MacMode, macmode & ~RxTx); 850 dr32(MacMode); 851 } 852 853 /* wait until in-flight frame completes. 854 * Max time @ 10BT: 1500*8b/10Mbps == 1200us (+ 100us margin) 855 * Typically expect this loop to end in < 50 us on 100BT. 856 */ 857 while (--i) { 858 if (!de_is_running(de)) 859 return; 860 udelay(100); 861 } 862 863 netdev_warn(de->dev, "timeout expired, stopping DMA\n"); 864 } 865 866 static inline void de_start_rxtx (struct de_private *de) 867 { 868 u32 macmode; 869 870 macmode = dr32(MacMode); 871 if ((macmode & RxTx) != RxTx) { 872 dw32(MacMode, macmode | RxTx); 873 dr32(MacMode); 874 } 875 } 876 877 static void de_stop_hw (struct de_private *de) 878 { 879 880 udelay(5); 881 dw32(IntrMask, 0); 882 883 de_stop_rxtx(de); 884 885 dw32(MacStatus, dr32(MacStatus)); 886 887 udelay(10); 888 889 de->rx_tail = 0; 890 de->tx_head = de->tx_tail = 0; 891 } 892 893 static void de_link_up(struct de_private *de) 894 { 895 if (!netif_carrier_ok(de->dev)) { 896 netif_carrier_on(de->dev); 897 netif_info(de, link, de->dev, "link up, media %s\n", 898 media_name[de->media_type]); 899 } 900 } 901 902 static void de_link_down(struct de_private *de) 903 { 904 if (netif_carrier_ok(de->dev)) { 905 netif_carrier_off(de->dev); 906 netif_info(de, link, de->dev, "link down\n"); 907 } 908 } 909 910 static void de_set_media (struct de_private *de) 911 { 912 unsigned media = de->media_type; 913 u32 macmode = dr32(MacMode); 914 915 if (de_is_running(de)) 916 netdev_warn(de->dev, "chip is running while changing media!\n"); 917 918 if (de->de21040) 919 dw32(CSR11, FULL_DUPLEX_MAGIC); 920 dw32(CSR13, 0); /* Reset phy */ 921 dw32(CSR14, de->media[media].csr14); 922 dw32(CSR15, de->media[media].csr15); 923 dw32(CSR13, de->media[media].csr13); 924 925 /* must delay 10ms before writing to other registers, 926 * especially CSR6 927 */ 928 mdelay(10); 929 930 if (media == DE_MEDIA_TP_FD) 931 macmode |= FullDuplex; 932 else 933 macmode &= ~FullDuplex; 934 935 netif_info(de, link, de->dev, "set link %s\n", media_name[media]); 936 netif_info(de, hw, de->dev, "mode 0x%x, sia 0x%x,0x%x,0x%x,0x%x\n", 937 dr32(MacMode), dr32(SIAStatus), 938 dr32(CSR13), dr32(CSR14), dr32(CSR15)); 939 netif_info(de, hw, de->dev, "set mode 0x%x, set sia 0x%x,0x%x,0x%x\n", 940 macmode, de->media[media].csr13, 941 de->media[media].csr14, de->media[media].csr15); 942 if (macmode != dr32(MacMode)) 943 dw32(MacMode, macmode); 944 } 945 946 static void de_next_media (struct de_private *de, const u32 *media, 947 unsigned int n_media) 948 { 949 unsigned int i; 950 951 for (i = 0; i < n_media; i++) { 952 if (de_ok_to_advertise(de, media[i])) { 953 de->media_type = media[i]; 954 return; 955 } 956 } 957 } 958 959 static void de21040_media_timer (struct timer_list *t) 960 { 961 struct de_private *de = from_timer(de, t, media_timer); 962 struct net_device *dev = de->dev; 963 u32 status = dr32(SIAStatus); 964 unsigned int carrier; 965 unsigned long flags; 966 967 carrier = (status & NetCxnErr) ? 0 : 1; 968 969 if (carrier) { 970 if (de->media_type != DE_MEDIA_AUI && (status & LinkFailStatus)) 971 goto no_link_yet; 972 973 de->media_timer.expires = jiffies + DE_TIMER_LINK; 974 add_timer(&de->media_timer); 975 if (!netif_carrier_ok(dev)) 976 de_link_up(de); 977 else 978 netif_info(de, timer, dev, "%s link ok, status %x\n", 979 media_name[de->media_type], status); 980 return; 981 } 982 983 de_link_down(de); 984 985 if (de->media_lock) 986 return; 987 988 if (de->media_type == DE_MEDIA_AUI) { 989 static const u32 next_state = DE_MEDIA_TP; 990 de_next_media(de, &next_state, 1); 991 } else { 992 static const u32 next_state = DE_MEDIA_AUI; 993 de_next_media(de, &next_state, 1); 994 } 995 996 spin_lock_irqsave(&de->lock, flags); 997 de_stop_rxtx(de); 998 spin_unlock_irqrestore(&de->lock, flags); 999 de_set_media(de); 1000 de_start_rxtx(de); 1001 1002 no_link_yet: 1003 de->media_timer.expires = jiffies + DE_TIMER_NO_LINK; 1004 add_timer(&de->media_timer); 1005 1006 netif_info(de, timer, dev, "no link, trying media %s, status %x\n", 1007 media_name[de->media_type], status); 1008 } 1009 1010 static unsigned int de_ok_to_advertise (struct de_private *de, u32 new_media) 1011 { 1012 switch (new_media) { 1013 case DE_MEDIA_TP_AUTO: 1014 if (!(de->media_advertise & ADVERTISED_Autoneg)) 1015 return 0; 1016 if (!(de->media_advertise & (ADVERTISED_10baseT_Half | ADVERTISED_10baseT_Full))) 1017 return 0; 1018 break; 1019 case DE_MEDIA_BNC: 1020 if (!(de->media_advertise & ADVERTISED_BNC)) 1021 return 0; 1022 break; 1023 case DE_MEDIA_AUI: 1024 if (!(de->media_advertise & ADVERTISED_AUI)) 1025 return 0; 1026 break; 1027 case DE_MEDIA_TP: 1028 if (!(de->media_advertise & ADVERTISED_10baseT_Half)) 1029 return 0; 1030 break; 1031 case DE_MEDIA_TP_FD: 1032 if (!(de->media_advertise & ADVERTISED_10baseT_Full)) 1033 return 0; 1034 break; 1035 } 1036 1037 return 1; 1038 } 1039 1040 static void de21041_media_timer (struct timer_list *t) 1041 { 1042 struct de_private *de = from_timer(de, t, media_timer); 1043 struct net_device *dev = de->dev; 1044 u32 status = dr32(SIAStatus); 1045 unsigned int carrier; 1046 unsigned long flags; 1047 1048 /* clear port active bits */ 1049 dw32(SIAStatus, NonselPortActive | SelPortActive); 1050 1051 carrier = (status & NetCxnErr) ? 0 : 1; 1052 1053 if (carrier) { 1054 if ((de->media_type == DE_MEDIA_TP_AUTO || 1055 de->media_type == DE_MEDIA_TP || 1056 de->media_type == DE_MEDIA_TP_FD) && 1057 (status & LinkFailStatus)) 1058 goto no_link_yet; 1059 1060 de->media_timer.expires = jiffies + DE_TIMER_LINK; 1061 add_timer(&de->media_timer); 1062 if (!netif_carrier_ok(dev)) 1063 de_link_up(de); 1064 else 1065 netif_info(de, timer, dev, 1066 "%s link ok, mode %x status %x\n", 1067 media_name[de->media_type], 1068 dr32(MacMode), status); 1069 return; 1070 } 1071 1072 de_link_down(de); 1073 1074 /* if media type locked, don't switch media */ 1075 if (de->media_lock) 1076 goto set_media; 1077 1078 /* if activity detected, use that as hint for new media type */ 1079 if (status & NonselPortActive) { 1080 unsigned int have_media = 1; 1081 1082 /* if AUI/BNC selected, then activity is on TP port */ 1083 if (de->media_type == DE_MEDIA_AUI || 1084 de->media_type == DE_MEDIA_BNC) { 1085 if (de_ok_to_advertise(de, DE_MEDIA_TP_AUTO)) 1086 de->media_type = DE_MEDIA_TP_AUTO; 1087 else 1088 have_media = 0; 1089 } 1090 1091 /* TP selected. If there is only TP and BNC, then it's BNC */ 1092 else if (((de->media_supported & DE_AUI_BNC) == SUPPORTED_BNC) && 1093 de_ok_to_advertise(de, DE_MEDIA_BNC)) 1094 de->media_type = DE_MEDIA_BNC; 1095 1096 /* TP selected. If there is only TP and AUI, then it's AUI */ 1097 else if (((de->media_supported & DE_AUI_BNC) == SUPPORTED_AUI) && 1098 de_ok_to_advertise(de, DE_MEDIA_AUI)) 1099 de->media_type = DE_MEDIA_AUI; 1100 1101 /* otherwise, ignore the hint */ 1102 else 1103 have_media = 0; 1104 1105 if (have_media) 1106 goto set_media; 1107 } 1108 1109 /* 1110 * Absent or ambiguous activity hint, move to next advertised 1111 * media state. If de->media_type is left unchanged, this 1112 * simply resets the PHY and reloads the current media settings. 1113 */ 1114 if (de->media_type == DE_MEDIA_AUI) { 1115 static const u32 next_states[] = { 1116 DE_MEDIA_BNC, DE_MEDIA_TP_AUTO 1117 }; 1118 de_next_media(de, next_states, ARRAY_SIZE(next_states)); 1119 } else if (de->media_type == DE_MEDIA_BNC) { 1120 static const u32 next_states[] = { 1121 DE_MEDIA_TP_AUTO, DE_MEDIA_AUI 1122 }; 1123 de_next_media(de, next_states, ARRAY_SIZE(next_states)); 1124 } else { 1125 static const u32 next_states[] = { 1126 DE_MEDIA_AUI, DE_MEDIA_BNC, DE_MEDIA_TP_AUTO 1127 }; 1128 de_next_media(de, next_states, ARRAY_SIZE(next_states)); 1129 } 1130 1131 set_media: 1132 spin_lock_irqsave(&de->lock, flags); 1133 de_stop_rxtx(de); 1134 spin_unlock_irqrestore(&de->lock, flags); 1135 de_set_media(de); 1136 de_start_rxtx(de); 1137 1138 no_link_yet: 1139 de->media_timer.expires = jiffies + DE_TIMER_NO_LINK; 1140 add_timer(&de->media_timer); 1141 1142 netif_info(de, timer, dev, "no link, trying media %s, status %x\n", 1143 media_name[de->media_type], status); 1144 } 1145 1146 static void de_media_interrupt (struct de_private *de, u32 status) 1147 { 1148 if (status & LinkPass) { 1149 /* Ignore if current media is AUI or BNC and we can't use TP */ 1150 if ((de->media_type == DE_MEDIA_AUI || 1151 de->media_type == DE_MEDIA_BNC) && 1152 (de->media_lock || 1153 !de_ok_to_advertise(de, DE_MEDIA_TP_AUTO))) 1154 return; 1155 /* If current media is not TP, change it to TP */ 1156 if ((de->media_type == DE_MEDIA_AUI || 1157 de->media_type == DE_MEDIA_BNC)) { 1158 de->media_type = DE_MEDIA_TP_AUTO; 1159 de_stop_rxtx(de); 1160 de_set_media(de); 1161 de_start_rxtx(de); 1162 } 1163 de_link_up(de); 1164 mod_timer(&de->media_timer, jiffies + DE_TIMER_LINK); 1165 return; 1166 } 1167 1168 BUG_ON(!(status & LinkFail)); 1169 /* Mark the link as down only if current media is TP */ 1170 if (netif_carrier_ok(de->dev) && de->media_type != DE_MEDIA_AUI && 1171 de->media_type != DE_MEDIA_BNC) { 1172 de_link_down(de); 1173 mod_timer(&de->media_timer, jiffies + DE_TIMER_NO_LINK); 1174 } 1175 } 1176 1177 static int de_reset_mac (struct de_private *de) 1178 { 1179 u32 status, tmp; 1180 1181 /* 1182 * Reset MAC. de4x5.c and tulip.c examined for "advice" 1183 * in this area. 1184 */ 1185 1186 if (dr32(BusMode) == 0xffffffff) 1187 return -EBUSY; 1188 1189 /* Reset the chip, holding bit 0 set at least 50 PCI cycles. */ 1190 dw32 (BusMode, CmdReset); 1191 mdelay (1); 1192 1193 dw32 (BusMode, de_bus_mode); 1194 mdelay (1); 1195 1196 for (tmp = 0; tmp < 5; tmp++) { 1197 dr32 (BusMode); 1198 mdelay (1); 1199 } 1200 1201 mdelay (1); 1202 1203 status = dr32(MacStatus); 1204 if (status & (RxState | TxState)) 1205 return -EBUSY; 1206 if (status == 0xffffffff) 1207 return -ENODEV; 1208 return 0; 1209 } 1210 1211 static void de_adapter_wake (struct de_private *de) 1212 { 1213 u32 pmctl; 1214 1215 if (de->de21040) 1216 return; 1217 1218 pci_read_config_dword(de->pdev, PCIPM, &pmctl); 1219 if (pmctl & PM_Mask) { 1220 pmctl &= ~PM_Mask; 1221 pci_write_config_dword(de->pdev, PCIPM, pmctl); 1222 1223 /* de4x5.c delays, so we do too */ 1224 msleep(10); 1225 } 1226 } 1227 1228 static void de_adapter_sleep (struct de_private *de) 1229 { 1230 u32 pmctl; 1231 1232 if (de->de21040) 1233 return; 1234 1235 dw32(CSR13, 0); /* Reset phy */ 1236 pci_read_config_dword(de->pdev, PCIPM, &pmctl); 1237 pmctl |= PM_Sleep; 1238 pci_write_config_dword(de->pdev, PCIPM, pmctl); 1239 } 1240 1241 static int de_init_hw (struct de_private *de) 1242 { 1243 struct net_device *dev = de->dev; 1244 u32 macmode; 1245 int rc; 1246 1247 de_adapter_wake(de); 1248 1249 macmode = dr32(MacMode) & ~MacModeClear; 1250 1251 rc = de_reset_mac(de); 1252 if (rc) 1253 return rc; 1254 1255 de_set_media(de); /* reset phy */ 1256 1257 dw32(RxRingAddr, de->ring_dma); 1258 dw32(TxRingAddr, de->ring_dma + (sizeof(struct de_desc) * DE_RX_RING_SIZE)); 1259 1260 dw32(MacMode, RxTx | macmode); 1261 1262 dr32(RxMissed); /* self-clearing */ 1263 1264 dw32(IntrMask, de_intr_mask); 1265 1266 de_set_rx_mode(dev); 1267 1268 return 0; 1269 } 1270 1271 static int de_refill_rx (struct de_private *de) 1272 { 1273 unsigned i; 1274 1275 for (i = 0; i < DE_RX_RING_SIZE; i++) { 1276 struct sk_buff *skb; 1277 1278 skb = netdev_alloc_skb(de->dev, de->rx_buf_sz); 1279 if (!skb) 1280 goto err_out; 1281 1282 de->rx_skb[i].mapping = pci_map_single(de->pdev, 1283 skb->data, de->rx_buf_sz, PCI_DMA_FROMDEVICE); 1284 de->rx_skb[i].skb = skb; 1285 1286 de->rx_ring[i].opts1 = cpu_to_le32(DescOwn); 1287 if (i == (DE_RX_RING_SIZE - 1)) 1288 de->rx_ring[i].opts2 = 1289 cpu_to_le32(RingEnd | de->rx_buf_sz); 1290 else 1291 de->rx_ring[i].opts2 = cpu_to_le32(de->rx_buf_sz); 1292 de->rx_ring[i].addr1 = cpu_to_le32(de->rx_skb[i].mapping); 1293 de->rx_ring[i].addr2 = 0; 1294 } 1295 1296 return 0; 1297 1298 err_out: 1299 de_clean_rings(de); 1300 return -ENOMEM; 1301 } 1302 1303 static int de_init_rings (struct de_private *de) 1304 { 1305 memset(de->tx_ring, 0, sizeof(struct de_desc) * DE_TX_RING_SIZE); 1306 de->tx_ring[DE_TX_RING_SIZE - 1].opts2 = cpu_to_le32(RingEnd); 1307 1308 de->rx_tail = 0; 1309 de->tx_head = de->tx_tail = 0; 1310 1311 return de_refill_rx (de); 1312 } 1313 1314 static int de_alloc_rings (struct de_private *de) 1315 { 1316 de->rx_ring = pci_alloc_consistent(de->pdev, DE_RING_BYTES, &de->ring_dma); 1317 if (!de->rx_ring) 1318 return -ENOMEM; 1319 de->tx_ring = &de->rx_ring[DE_RX_RING_SIZE]; 1320 return de_init_rings(de); 1321 } 1322 1323 static void de_clean_rings (struct de_private *de) 1324 { 1325 unsigned i; 1326 1327 memset(de->rx_ring, 0, sizeof(struct de_desc) * DE_RX_RING_SIZE); 1328 de->rx_ring[DE_RX_RING_SIZE - 1].opts2 = cpu_to_le32(RingEnd); 1329 wmb(); 1330 memset(de->tx_ring, 0, sizeof(struct de_desc) * DE_TX_RING_SIZE); 1331 de->tx_ring[DE_TX_RING_SIZE - 1].opts2 = cpu_to_le32(RingEnd); 1332 wmb(); 1333 1334 for (i = 0; i < DE_RX_RING_SIZE; i++) { 1335 if (de->rx_skb[i].skb) { 1336 pci_unmap_single(de->pdev, de->rx_skb[i].mapping, 1337 de->rx_buf_sz, PCI_DMA_FROMDEVICE); 1338 dev_kfree_skb(de->rx_skb[i].skb); 1339 } 1340 } 1341 1342 for (i = 0; i < DE_TX_RING_SIZE; i++) { 1343 struct sk_buff *skb = de->tx_skb[i].skb; 1344 if ((skb) && (skb != DE_DUMMY_SKB)) { 1345 if (skb != DE_SETUP_SKB) { 1346 de->dev->stats.tx_dropped++; 1347 pci_unmap_single(de->pdev, 1348 de->tx_skb[i].mapping, 1349 skb->len, PCI_DMA_TODEVICE); 1350 dev_kfree_skb(skb); 1351 } else { 1352 pci_unmap_single(de->pdev, 1353 de->tx_skb[i].mapping, 1354 sizeof(de->setup_frame), 1355 PCI_DMA_TODEVICE); 1356 } 1357 } 1358 } 1359 1360 memset(&de->rx_skb, 0, sizeof(struct ring_info) * DE_RX_RING_SIZE); 1361 memset(&de->tx_skb, 0, sizeof(struct ring_info) * DE_TX_RING_SIZE); 1362 } 1363 1364 static void de_free_rings (struct de_private *de) 1365 { 1366 de_clean_rings(de); 1367 pci_free_consistent(de->pdev, DE_RING_BYTES, de->rx_ring, de->ring_dma); 1368 de->rx_ring = NULL; 1369 de->tx_ring = NULL; 1370 } 1371 1372 static int de_open (struct net_device *dev) 1373 { 1374 struct de_private *de = netdev_priv(dev); 1375 const int irq = de->pdev->irq; 1376 int rc; 1377 1378 netif_dbg(de, ifup, dev, "enabling interface\n"); 1379 1380 de->rx_buf_sz = (dev->mtu <= 1500 ? PKT_BUF_SZ : dev->mtu + 32); 1381 1382 rc = de_alloc_rings(de); 1383 if (rc) { 1384 netdev_err(dev, "ring allocation failure, err=%d\n", rc); 1385 return rc; 1386 } 1387 1388 dw32(IntrMask, 0); 1389 1390 rc = request_irq(irq, de_interrupt, IRQF_SHARED, dev->name, dev); 1391 if (rc) { 1392 netdev_err(dev, "IRQ %d request failure, err=%d\n", irq, rc); 1393 goto err_out_free; 1394 } 1395 1396 rc = de_init_hw(de); 1397 if (rc) { 1398 netdev_err(dev, "h/w init failure, err=%d\n", rc); 1399 goto err_out_free_irq; 1400 } 1401 1402 netif_start_queue(dev); 1403 mod_timer(&de->media_timer, jiffies + DE_TIMER_NO_LINK); 1404 1405 return 0; 1406 1407 err_out_free_irq: 1408 free_irq(irq, dev); 1409 err_out_free: 1410 de_free_rings(de); 1411 return rc; 1412 } 1413 1414 static int de_close (struct net_device *dev) 1415 { 1416 struct de_private *de = netdev_priv(dev); 1417 unsigned long flags; 1418 1419 netif_dbg(de, ifdown, dev, "disabling interface\n"); 1420 1421 del_timer_sync(&de->media_timer); 1422 1423 spin_lock_irqsave(&de->lock, flags); 1424 de_stop_hw(de); 1425 netif_stop_queue(dev); 1426 netif_carrier_off(dev); 1427 spin_unlock_irqrestore(&de->lock, flags); 1428 1429 free_irq(de->pdev->irq, dev); 1430 1431 de_free_rings(de); 1432 de_adapter_sleep(de); 1433 return 0; 1434 } 1435 1436 static void de_tx_timeout (struct net_device *dev, unsigned int txqueue) 1437 { 1438 struct de_private *de = netdev_priv(dev); 1439 const int irq = de->pdev->irq; 1440 1441 netdev_dbg(dev, "NIC status %08x mode %08x sia %08x desc %u/%u/%u\n", 1442 dr32(MacStatus), dr32(MacMode), dr32(SIAStatus), 1443 de->rx_tail, de->tx_head, de->tx_tail); 1444 1445 del_timer_sync(&de->media_timer); 1446 1447 disable_irq(irq); 1448 spin_lock_irq(&de->lock); 1449 1450 de_stop_hw(de); 1451 netif_stop_queue(dev); 1452 netif_carrier_off(dev); 1453 1454 spin_unlock_irq(&de->lock); 1455 enable_irq(irq); 1456 1457 /* Update the error counts. */ 1458 __de_get_stats(de); 1459 1460 synchronize_irq(irq); 1461 de_clean_rings(de); 1462 1463 de_init_rings(de); 1464 1465 de_init_hw(de); 1466 1467 netif_wake_queue(dev); 1468 } 1469 1470 static void __de_get_regs(struct de_private *de, u8 *buf) 1471 { 1472 int i; 1473 u32 *rbuf = (u32 *)buf; 1474 1475 /* read all CSRs */ 1476 for (i = 0; i < DE_NUM_REGS; i++) 1477 rbuf[i] = dr32(i * 8); 1478 1479 /* handle self-clearing RxMissed counter, CSR8 */ 1480 de_rx_missed(de, rbuf[8]); 1481 } 1482 1483 static void __de_get_link_ksettings(struct de_private *de, 1484 struct ethtool_link_ksettings *cmd) 1485 { 1486 ethtool_convert_legacy_u32_to_link_mode(cmd->link_modes.supported, 1487 de->media_supported); 1488 cmd->base.phy_address = 0; 1489 ethtool_convert_legacy_u32_to_link_mode(cmd->link_modes.advertising, 1490 de->media_advertise); 1491 1492 switch (de->media_type) { 1493 case DE_MEDIA_AUI: 1494 cmd->base.port = PORT_AUI; 1495 break; 1496 case DE_MEDIA_BNC: 1497 cmd->base.port = PORT_BNC; 1498 break; 1499 default: 1500 cmd->base.port = PORT_TP; 1501 break; 1502 } 1503 1504 cmd->base.speed = 10; 1505 1506 if (dr32(MacMode) & FullDuplex) 1507 cmd->base.duplex = DUPLEX_FULL; 1508 else 1509 cmd->base.duplex = DUPLEX_HALF; 1510 1511 if (de->media_lock) 1512 cmd->base.autoneg = AUTONEG_DISABLE; 1513 else 1514 cmd->base.autoneg = AUTONEG_ENABLE; 1515 1516 /* ignore maxtxpkt, maxrxpkt for now */ 1517 } 1518 1519 static int __de_set_link_ksettings(struct de_private *de, 1520 const struct ethtool_link_ksettings *cmd) 1521 { 1522 u32 new_media; 1523 unsigned int media_lock; 1524 u8 duplex = cmd->base.duplex; 1525 u8 port = cmd->base.port; 1526 u8 autoneg = cmd->base.autoneg; 1527 u32 advertising; 1528 1529 ethtool_convert_link_mode_to_legacy_u32(&advertising, 1530 cmd->link_modes.advertising); 1531 1532 if (cmd->base.speed != 10) 1533 return -EINVAL; 1534 if (duplex != DUPLEX_HALF && duplex != DUPLEX_FULL) 1535 return -EINVAL; 1536 if (port != PORT_TP && port != PORT_AUI && port != PORT_BNC) 1537 return -EINVAL; 1538 if (de->de21040 && port == PORT_BNC) 1539 return -EINVAL; 1540 if (autoneg != AUTONEG_DISABLE && autoneg != AUTONEG_ENABLE) 1541 return -EINVAL; 1542 if (advertising & ~de->media_supported) 1543 return -EINVAL; 1544 if (autoneg == AUTONEG_ENABLE && 1545 (!(advertising & ADVERTISED_Autoneg))) 1546 return -EINVAL; 1547 1548 switch (port) { 1549 case PORT_AUI: 1550 new_media = DE_MEDIA_AUI; 1551 if (!(advertising & ADVERTISED_AUI)) 1552 return -EINVAL; 1553 break; 1554 case PORT_BNC: 1555 new_media = DE_MEDIA_BNC; 1556 if (!(advertising & ADVERTISED_BNC)) 1557 return -EINVAL; 1558 break; 1559 default: 1560 if (autoneg == AUTONEG_ENABLE) 1561 new_media = DE_MEDIA_TP_AUTO; 1562 else if (duplex == DUPLEX_FULL) 1563 new_media = DE_MEDIA_TP_FD; 1564 else 1565 new_media = DE_MEDIA_TP; 1566 if (!(advertising & ADVERTISED_TP)) 1567 return -EINVAL; 1568 if (!(advertising & (ADVERTISED_10baseT_Full | 1569 ADVERTISED_10baseT_Half))) 1570 return -EINVAL; 1571 break; 1572 } 1573 1574 media_lock = (autoneg == AUTONEG_ENABLE) ? 0 : 1; 1575 1576 if ((new_media == de->media_type) && 1577 (media_lock == de->media_lock) && 1578 (advertising == de->media_advertise)) 1579 return 0; /* nothing to change */ 1580 1581 de_link_down(de); 1582 mod_timer(&de->media_timer, jiffies + DE_TIMER_NO_LINK); 1583 de_stop_rxtx(de); 1584 1585 de->media_type = new_media; 1586 de->media_lock = media_lock; 1587 de->media_advertise = advertising; 1588 de_set_media(de); 1589 if (netif_running(de->dev)) 1590 de_start_rxtx(de); 1591 1592 return 0; 1593 } 1594 1595 static void de_get_drvinfo (struct net_device *dev,struct ethtool_drvinfo *info) 1596 { 1597 struct de_private *de = netdev_priv(dev); 1598 1599 strlcpy(info->driver, DRV_NAME, sizeof(info->driver)); 1600 strlcpy(info->bus_info, pci_name(de->pdev), sizeof(info->bus_info)); 1601 } 1602 1603 static int de_get_regs_len(struct net_device *dev) 1604 { 1605 return DE_REGS_SIZE; 1606 } 1607 1608 static int de_get_link_ksettings(struct net_device *dev, 1609 struct ethtool_link_ksettings *cmd) 1610 { 1611 struct de_private *de = netdev_priv(dev); 1612 1613 spin_lock_irq(&de->lock); 1614 __de_get_link_ksettings(de, cmd); 1615 spin_unlock_irq(&de->lock); 1616 1617 return 0; 1618 } 1619 1620 static int de_set_link_ksettings(struct net_device *dev, 1621 const struct ethtool_link_ksettings *cmd) 1622 { 1623 struct de_private *de = netdev_priv(dev); 1624 int rc; 1625 1626 spin_lock_irq(&de->lock); 1627 rc = __de_set_link_ksettings(de, cmd); 1628 spin_unlock_irq(&de->lock); 1629 1630 return rc; 1631 } 1632 1633 static u32 de_get_msglevel(struct net_device *dev) 1634 { 1635 struct de_private *de = netdev_priv(dev); 1636 1637 return de->msg_enable; 1638 } 1639 1640 static void de_set_msglevel(struct net_device *dev, u32 msglvl) 1641 { 1642 struct de_private *de = netdev_priv(dev); 1643 1644 de->msg_enable = msglvl; 1645 } 1646 1647 static int de_get_eeprom(struct net_device *dev, 1648 struct ethtool_eeprom *eeprom, u8 *data) 1649 { 1650 struct de_private *de = netdev_priv(dev); 1651 1652 if (!de->ee_data) 1653 return -EOPNOTSUPP; 1654 if ((eeprom->offset != 0) || (eeprom->magic != 0) || 1655 (eeprom->len != DE_EEPROM_SIZE)) 1656 return -EINVAL; 1657 memcpy(data, de->ee_data, eeprom->len); 1658 1659 return 0; 1660 } 1661 1662 static int de_nway_reset(struct net_device *dev) 1663 { 1664 struct de_private *de = netdev_priv(dev); 1665 u32 status; 1666 1667 if (de->media_type != DE_MEDIA_TP_AUTO) 1668 return -EINVAL; 1669 if (netif_carrier_ok(de->dev)) 1670 de_link_down(de); 1671 1672 status = dr32(SIAStatus); 1673 dw32(SIAStatus, (status & ~NWayState) | NWayRestart); 1674 netif_info(de, link, dev, "link nway restart, status %x,%x\n", 1675 status, dr32(SIAStatus)); 1676 return 0; 1677 } 1678 1679 static void de_get_regs(struct net_device *dev, struct ethtool_regs *regs, 1680 void *data) 1681 { 1682 struct de_private *de = netdev_priv(dev); 1683 1684 regs->version = (DE_REGS_VER << 2) | de->de21040; 1685 1686 spin_lock_irq(&de->lock); 1687 __de_get_regs(de, data); 1688 spin_unlock_irq(&de->lock); 1689 } 1690 1691 static const struct ethtool_ops de_ethtool_ops = { 1692 .get_link = ethtool_op_get_link, 1693 .get_drvinfo = de_get_drvinfo, 1694 .get_regs_len = de_get_regs_len, 1695 .get_msglevel = de_get_msglevel, 1696 .set_msglevel = de_set_msglevel, 1697 .get_eeprom = de_get_eeprom, 1698 .nway_reset = de_nway_reset, 1699 .get_regs = de_get_regs, 1700 .get_link_ksettings = de_get_link_ksettings, 1701 .set_link_ksettings = de_set_link_ksettings, 1702 }; 1703 1704 static void de21040_get_mac_address(struct de_private *de) 1705 { 1706 unsigned i; 1707 1708 dw32 (ROMCmd, 0); /* Reset the pointer with a dummy write. */ 1709 udelay(5); 1710 1711 for (i = 0; i < 6; i++) { 1712 int value, boguscnt = 100000; 1713 do { 1714 value = dr32(ROMCmd); 1715 rmb(); 1716 } while (value < 0 && --boguscnt > 0); 1717 de->dev->dev_addr[i] = value; 1718 udelay(1); 1719 if (boguscnt <= 0) 1720 pr_warn("timeout reading 21040 MAC address byte %u\n", 1721 i); 1722 } 1723 } 1724 1725 static void de21040_get_media_info(struct de_private *de) 1726 { 1727 unsigned int i; 1728 1729 de->media_type = DE_MEDIA_TP; 1730 de->media_supported |= SUPPORTED_TP | SUPPORTED_10baseT_Full | 1731 SUPPORTED_10baseT_Half | SUPPORTED_AUI; 1732 de->media_advertise = de->media_supported; 1733 1734 for (i = 0; i < DE_MAX_MEDIA; i++) { 1735 switch (i) { 1736 case DE_MEDIA_AUI: 1737 case DE_MEDIA_TP: 1738 case DE_MEDIA_TP_FD: 1739 de->media[i].type = i; 1740 de->media[i].csr13 = t21040_csr13[i]; 1741 de->media[i].csr14 = t21040_csr14[i]; 1742 de->media[i].csr15 = t21040_csr15[i]; 1743 break; 1744 default: 1745 de->media[i].type = DE_MEDIA_INVALID; 1746 break; 1747 } 1748 } 1749 } 1750 1751 /* Note: this routine returns extra data bits for size detection. */ 1752 static unsigned tulip_read_eeprom(void __iomem *regs, int location, 1753 int addr_len) 1754 { 1755 int i; 1756 unsigned retval = 0; 1757 void __iomem *ee_addr = regs + ROMCmd; 1758 int read_cmd = location | (EE_READ_CMD << addr_len); 1759 1760 writel(EE_ENB & ~EE_CS, ee_addr); 1761 writel(EE_ENB, ee_addr); 1762 1763 /* Shift the read command bits out. */ 1764 for (i = 4 + addr_len; i >= 0; i--) { 1765 short dataval = (read_cmd & (1 << i)) ? EE_DATA_WRITE : 0; 1766 writel(EE_ENB | dataval, ee_addr); 1767 readl(ee_addr); 1768 writel(EE_ENB | dataval | EE_SHIFT_CLK, ee_addr); 1769 readl(ee_addr); 1770 retval = (retval << 1) | ((readl(ee_addr) & EE_DATA_READ) ? 1 : 0); 1771 } 1772 writel(EE_ENB, ee_addr); 1773 readl(ee_addr); 1774 1775 for (i = 16; i > 0; i--) { 1776 writel(EE_ENB | EE_SHIFT_CLK, ee_addr); 1777 readl(ee_addr); 1778 retval = (retval << 1) | ((readl(ee_addr) & EE_DATA_READ) ? 1 : 0); 1779 writel(EE_ENB, ee_addr); 1780 readl(ee_addr); 1781 } 1782 1783 /* Terminate the EEPROM access. */ 1784 writel(EE_ENB & ~EE_CS, ee_addr); 1785 return retval; 1786 } 1787 1788 static void de21041_get_srom_info(struct de_private *de) 1789 { 1790 unsigned i, sa_offset = 0, ofs; 1791 u8 ee_data[DE_EEPROM_SIZE + 6] = {}; 1792 unsigned ee_addr_size = tulip_read_eeprom(de->regs, 0xff, 8) & 0x40000 ? 8 : 6; 1793 struct de_srom_info_leaf *il; 1794 void *bufp; 1795 1796 /* download entire eeprom */ 1797 for (i = 0; i < DE_EEPROM_WORDS; i++) 1798 ((__le16 *)ee_data)[i] = 1799 cpu_to_le16(tulip_read_eeprom(de->regs, i, ee_addr_size)); 1800 1801 /* DEC now has a specification but early board makers 1802 just put the address in the first EEPROM locations. */ 1803 /* This does memcmp(eedata, eedata+16, 8) */ 1804 1805 #ifndef CONFIG_MIPS_COBALT 1806 1807 for (i = 0; i < 8; i ++) 1808 if (ee_data[i] != ee_data[16+i]) 1809 sa_offset = 20; 1810 1811 #endif 1812 1813 /* store MAC address */ 1814 for (i = 0; i < 6; i ++) 1815 de->dev->dev_addr[i] = ee_data[i + sa_offset]; 1816 1817 /* get offset of controller 0 info leaf. ignore 2nd byte. */ 1818 ofs = ee_data[SROMC0InfoLeaf]; 1819 if (ofs >= (sizeof(ee_data) - sizeof(struct de_srom_info_leaf) - sizeof(struct de_srom_media_block))) 1820 goto bad_srom; 1821 1822 /* get pointer to info leaf */ 1823 il = (struct de_srom_info_leaf *) &ee_data[ofs]; 1824 1825 /* paranoia checks */ 1826 if (il->n_blocks == 0) 1827 goto bad_srom; 1828 if ((sizeof(ee_data) - ofs) < 1829 (sizeof(struct de_srom_info_leaf) + (sizeof(struct de_srom_media_block) * il->n_blocks))) 1830 goto bad_srom; 1831 1832 /* get default media type */ 1833 switch (get_unaligned(&il->default_media)) { 1834 case 0x0001: de->media_type = DE_MEDIA_BNC; break; 1835 case 0x0002: de->media_type = DE_MEDIA_AUI; break; 1836 case 0x0204: de->media_type = DE_MEDIA_TP_FD; break; 1837 default: de->media_type = DE_MEDIA_TP_AUTO; break; 1838 } 1839 1840 if (netif_msg_probe(de)) 1841 pr_info("de%d: SROM leaf offset %u, default media %s\n", 1842 de->board_idx, ofs, media_name[de->media_type]); 1843 1844 /* init SIA register values to defaults */ 1845 for (i = 0; i < DE_MAX_MEDIA; i++) { 1846 de->media[i].type = DE_MEDIA_INVALID; 1847 de->media[i].csr13 = 0xffff; 1848 de->media[i].csr14 = 0xffff; 1849 de->media[i].csr15 = 0xffff; 1850 } 1851 1852 /* parse media blocks to see what medias are supported, 1853 * and if any custom CSR values are provided 1854 */ 1855 bufp = ((void *)il) + sizeof(*il); 1856 for (i = 0; i < il->n_blocks; i++) { 1857 struct de_srom_media_block *ib = bufp; 1858 unsigned idx; 1859 1860 /* index based on media type in media block */ 1861 switch(ib->opts & MediaBlockMask) { 1862 case 0: /* 10baseT */ 1863 de->media_supported |= SUPPORTED_TP | SUPPORTED_10baseT_Half 1864 | SUPPORTED_Autoneg; 1865 idx = DE_MEDIA_TP; 1866 de->media[DE_MEDIA_TP_AUTO].type = DE_MEDIA_TP_AUTO; 1867 break; 1868 case 1: /* BNC */ 1869 de->media_supported |= SUPPORTED_BNC; 1870 idx = DE_MEDIA_BNC; 1871 break; 1872 case 2: /* AUI */ 1873 de->media_supported |= SUPPORTED_AUI; 1874 idx = DE_MEDIA_AUI; 1875 break; 1876 case 4: /* 10baseT-FD */ 1877 de->media_supported |= SUPPORTED_TP | SUPPORTED_10baseT_Full 1878 | SUPPORTED_Autoneg; 1879 idx = DE_MEDIA_TP_FD; 1880 de->media[DE_MEDIA_TP_AUTO].type = DE_MEDIA_TP_AUTO; 1881 break; 1882 default: 1883 goto bad_srom; 1884 } 1885 1886 de->media[idx].type = idx; 1887 1888 if (netif_msg_probe(de)) 1889 pr_info("de%d: media block #%u: %s", 1890 de->board_idx, i, 1891 media_name[de->media[idx].type]); 1892 1893 bufp += sizeof (ib->opts); 1894 1895 if (ib->opts & MediaCustomCSRs) { 1896 de->media[idx].csr13 = get_unaligned(&ib->csr13); 1897 de->media[idx].csr14 = get_unaligned(&ib->csr14); 1898 de->media[idx].csr15 = get_unaligned(&ib->csr15); 1899 bufp += sizeof(ib->csr13) + sizeof(ib->csr14) + 1900 sizeof(ib->csr15); 1901 1902 if (netif_msg_probe(de)) 1903 pr_cont(" (%x,%x,%x)\n", 1904 de->media[idx].csr13, 1905 de->media[idx].csr14, 1906 de->media[idx].csr15); 1907 1908 } else { 1909 if (netif_msg_probe(de)) 1910 pr_cont("\n"); 1911 } 1912 1913 if (bufp > ((void *)&ee_data[DE_EEPROM_SIZE - 3])) 1914 break; 1915 } 1916 1917 de->media_advertise = de->media_supported; 1918 1919 fill_defaults: 1920 /* fill in defaults, for cases where custom CSRs not used */ 1921 for (i = 0; i < DE_MAX_MEDIA; i++) { 1922 if (de->media[i].csr13 == 0xffff) 1923 de->media[i].csr13 = t21041_csr13[i]; 1924 if (de->media[i].csr14 == 0xffff) { 1925 /* autonegotiation is broken at least on some chip 1926 revisions - rev. 0x21 works, 0x11 does not */ 1927 if (de->pdev->revision < 0x20) 1928 de->media[i].csr14 = t21041_csr14_brk[i]; 1929 else 1930 de->media[i].csr14 = t21041_csr14[i]; 1931 } 1932 if (de->media[i].csr15 == 0xffff) 1933 de->media[i].csr15 = t21041_csr15[i]; 1934 } 1935 1936 de->ee_data = kmemdup(&ee_data[0], DE_EEPROM_SIZE, GFP_KERNEL); 1937 1938 return; 1939 1940 bad_srom: 1941 /* for error cases, it's ok to assume we support all these */ 1942 for (i = 0; i < DE_MAX_MEDIA; i++) 1943 de->media[i].type = i; 1944 de->media_supported = 1945 SUPPORTED_10baseT_Half | 1946 SUPPORTED_10baseT_Full | 1947 SUPPORTED_Autoneg | 1948 SUPPORTED_TP | 1949 SUPPORTED_AUI | 1950 SUPPORTED_BNC; 1951 goto fill_defaults; 1952 } 1953 1954 static const struct net_device_ops de_netdev_ops = { 1955 .ndo_open = de_open, 1956 .ndo_stop = de_close, 1957 .ndo_set_rx_mode = de_set_rx_mode, 1958 .ndo_start_xmit = de_start_xmit, 1959 .ndo_get_stats = de_get_stats, 1960 .ndo_tx_timeout = de_tx_timeout, 1961 .ndo_set_mac_address = eth_mac_addr, 1962 .ndo_validate_addr = eth_validate_addr, 1963 }; 1964 1965 static int de_init_one(struct pci_dev *pdev, const struct pci_device_id *ent) 1966 { 1967 struct net_device *dev; 1968 struct de_private *de; 1969 int rc; 1970 void __iomem *regs; 1971 unsigned long pciaddr; 1972 static int board_idx = -1; 1973 1974 board_idx++; 1975 1976 /* allocate a new ethernet device structure, and fill in defaults */ 1977 dev = alloc_etherdev(sizeof(struct de_private)); 1978 if (!dev) 1979 return -ENOMEM; 1980 1981 dev->netdev_ops = &de_netdev_ops; 1982 SET_NETDEV_DEV(dev, &pdev->dev); 1983 dev->ethtool_ops = &de_ethtool_ops; 1984 dev->watchdog_timeo = TX_TIMEOUT; 1985 1986 de = netdev_priv(dev); 1987 de->de21040 = ent->driver_data == 0 ? 1 : 0; 1988 de->pdev = pdev; 1989 de->dev = dev; 1990 de->msg_enable = (debug < 0 ? DE_DEF_MSG_ENABLE : debug); 1991 de->board_idx = board_idx; 1992 spin_lock_init (&de->lock); 1993 timer_setup(&de->media_timer, 1994 de->de21040 ? de21040_media_timer : de21041_media_timer, 1995 0); 1996 1997 netif_carrier_off(dev); 1998 1999 /* wake up device, assign resources */ 2000 rc = pci_enable_device(pdev); 2001 if (rc) 2002 goto err_out_free; 2003 2004 /* reserve PCI resources to ensure driver atomicity */ 2005 rc = pci_request_regions(pdev, DRV_NAME); 2006 if (rc) 2007 goto err_out_disable; 2008 2009 /* check for invalid IRQ value */ 2010 if (pdev->irq < 2) { 2011 rc = -EIO; 2012 pr_err("invalid irq (%d) for pci dev %s\n", 2013 pdev->irq, pci_name(pdev)); 2014 goto err_out_res; 2015 } 2016 2017 /* obtain and check validity of PCI I/O address */ 2018 pciaddr = pci_resource_start(pdev, 1); 2019 if (!pciaddr) { 2020 rc = -EIO; 2021 pr_err("no MMIO resource for pci dev %s\n", pci_name(pdev)); 2022 goto err_out_res; 2023 } 2024 if (pci_resource_len(pdev, 1) < DE_REGS_SIZE) { 2025 rc = -EIO; 2026 pr_err("MMIO resource (%llx) too small on pci dev %s\n", 2027 (unsigned long long)pci_resource_len(pdev, 1), 2028 pci_name(pdev)); 2029 goto err_out_res; 2030 } 2031 2032 /* remap CSR registers */ 2033 regs = ioremap(pciaddr, DE_REGS_SIZE); 2034 if (!regs) { 2035 rc = -EIO; 2036 pr_err("Cannot map PCI MMIO (%llx@%lx) on pci dev %s\n", 2037 (unsigned long long)pci_resource_len(pdev, 1), 2038 pciaddr, pci_name(pdev)); 2039 goto err_out_res; 2040 } 2041 de->regs = regs; 2042 2043 de_adapter_wake(de); 2044 2045 /* make sure hardware is not running */ 2046 rc = de_reset_mac(de); 2047 if (rc) { 2048 pr_err("Cannot reset MAC, pci dev %s\n", pci_name(pdev)); 2049 goto err_out_iomap; 2050 } 2051 2052 /* get MAC address, initialize default media type and 2053 * get list of supported media 2054 */ 2055 if (de->de21040) { 2056 de21040_get_mac_address(de); 2057 de21040_get_media_info(de); 2058 } else { 2059 de21041_get_srom_info(de); 2060 } 2061 2062 /* register new network interface with kernel */ 2063 rc = register_netdev(dev); 2064 if (rc) 2065 goto err_out_iomap; 2066 2067 /* print info about board and interface just registered */ 2068 netdev_info(dev, "%s at %p, %pM, IRQ %d\n", 2069 de->de21040 ? "21040" : "21041", 2070 regs, dev->dev_addr, pdev->irq); 2071 2072 pci_set_drvdata(pdev, dev); 2073 2074 /* enable busmastering */ 2075 pci_set_master(pdev); 2076 2077 /* put adapter to sleep */ 2078 de_adapter_sleep(de); 2079 2080 return 0; 2081 2082 err_out_iomap: 2083 kfree(de->ee_data); 2084 iounmap(regs); 2085 err_out_res: 2086 pci_release_regions(pdev); 2087 err_out_disable: 2088 pci_disable_device(pdev); 2089 err_out_free: 2090 free_netdev(dev); 2091 return rc; 2092 } 2093 2094 static void de_remove_one(struct pci_dev *pdev) 2095 { 2096 struct net_device *dev = pci_get_drvdata(pdev); 2097 struct de_private *de = netdev_priv(dev); 2098 2099 BUG_ON(!dev); 2100 unregister_netdev(dev); 2101 kfree(de->ee_data); 2102 iounmap(de->regs); 2103 pci_release_regions(pdev); 2104 pci_disable_device(pdev); 2105 free_netdev(dev); 2106 } 2107 2108 static int __maybe_unused de_suspend(struct device *dev_d) 2109 { 2110 struct pci_dev *pdev = to_pci_dev(dev_d); 2111 struct net_device *dev = pci_get_drvdata(pdev); 2112 struct de_private *de = netdev_priv(dev); 2113 2114 rtnl_lock(); 2115 if (netif_running (dev)) { 2116 const int irq = pdev->irq; 2117 2118 del_timer_sync(&de->media_timer); 2119 2120 disable_irq(irq); 2121 spin_lock_irq(&de->lock); 2122 2123 de_stop_hw(de); 2124 netif_stop_queue(dev); 2125 netif_device_detach(dev); 2126 netif_carrier_off(dev); 2127 2128 spin_unlock_irq(&de->lock); 2129 enable_irq(irq); 2130 2131 /* Update the error counts. */ 2132 __de_get_stats(de); 2133 2134 synchronize_irq(irq); 2135 de_clean_rings(de); 2136 2137 de_adapter_sleep(de); 2138 } else { 2139 netif_device_detach(dev); 2140 } 2141 rtnl_unlock(); 2142 return 0; 2143 } 2144 2145 static int __maybe_unused de_resume(struct device *dev_d) 2146 { 2147 struct pci_dev *pdev = to_pci_dev(dev_d); 2148 struct net_device *dev = pci_get_drvdata(pdev); 2149 struct de_private *de = netdev_priv(dev); 2150 2151 rtnl_lock(); 2152 if (netif_device_present(dev)) 2153 goto out; 2154 if (!netif_running(dev)) 2155 goto out_attach; 2156 pci_set_master(pdev); 2157 de_init_rings(de); 2158 de_init_hw(de); 2159 out_attach: 2160 netif_device_attach(dev); 2161 out: 2162 rtnl_unlock(); 2163 return 0; 2164 } 2165 2166 static SIMPLE_DEV_PM_OPS(de_pm_ops, de_suspend, de_resume); 2167 2168 static struct pci_driver de_driver = { 2169 .name = DRV_NAME, 2170 .id_table = de_pci_tbl, 2171 .probe = de_init_one, 2172 .remove = de_remove_one, 2173 .driver.pm = &de_pm_ops, 2174 }; 2175 2176 static int __init de_init (void) 2177 { 2178 return pci_register_driver(&de_driver); 2179 } 2180 2181 static void __exit de_exit (void) 2182 { 2183 pci_unregister_driver (&de_driver); 2184 } 2185 2186 module_init(de_init); 2187 module_exit(de_exit); 2188