1 /* de2104x.c: A Linux PCI Ethernet driver for Intel/Digital 21040/1 chips. */
3 Copyright 2001,2003 Jeff Garzik <jgarzik@pobox.com>
5 Copyright 1994, 1995 Digital Equipment Corporation. [de4x5.c]
6 Written/copyright 1994-2001 by Donald Becker. [tulip.c]
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.
15 See the file COPYING in this distribution for more information.
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
30 #define DRV_NAME "de2104x"
31 #define DRV_VERSION "0.7"
32 #define DRV_RELDATE "Mar 17, 2004"
34 #include <linux/module.h>
35 #include <linux/kernel.h>
36 #include <linux/netdevice.h>
37 #include <linux/etherdevice.h>
38 #include <linux/init.h>
39 #include <linux/pci.h>
40 #include <linux/delay.h>
41 #include <linux/ethtool.h>
42 #include <linux/compiler.h>
43 #include <linux/rtnetlink.h>
44 #include <linux/crc32.h>
45 #include <linux/slab.h>
49 #include <asm/uaccess.h>
50 #include <asm/unaligned.h>
52 /* These identify the driver base version and may not be removed. */
53 static char version[] =
54 KERN_INFO DRV_NAME " PCI Ethernet driver v" DRV_VERSION " (" DRV_RELDATE ")\n";
56 MODULE_AUTHOR("Jeff Garzik <jgarzik@pobox.com>");
57 MODULE_DESCRIPTION("Intel/Digital 21040/1 series PCI Ethernet driver");
58 MODULE_LICENSE("GPL");
59 MODULE_VERSION(DRV_VERSION);
61 static int debug = -1;
62 module_param (debug, int, 0);
63 MODULE_PARM_DESC (debug, "de2104x bitmapped message enable number");
65 /* Set the copy breakpoint for the copy-only-tiny-buffer Rx structure. */
66 #if defined(__alpha__) || defined(__arm__) || defined(__hppa__) || \
67 defined(CONFIG_SPARC) || defined(__ia64__) || \
68 defined(__sh__) || defined(__mips__)
69 static int rx_copybreak = 1518;
71 static int rx_copybreak = 100;
73 module_param (rx_copybreak, int, 0);
74 MODULE_PARM_DESC (rx_copybreak, "de2104x Breakpoint at which Rx packets are copied");
76 #define PFX DRV_NAME ": "
78 #define DE_DEF_MSG_ENABLE (NETIF_MSG_DRV | \
86 /* Descriptor skip length in 32 bit longwords. */
87 #ifndef CONFIG_DE2104X_DSL
90 #define DSL CONFIG_DE2104X_DSL
93 #define DE_RX_RING_SIZE 64
94 #define DE_TX_RING_SIZE 64
95 #define DE_RING_BYTES \
96 ((sizeof(struct de_desc) * DE_RX_RING_SIZE) + \
97 (sizeof(struct de_desc) * DE_TX_RING_SIZE))
98 #define NEXT_TX(N) (((N) + 1) & (DE_TX_RING_SIZE - 1))
99 #define NEXT_RX(N) (((N) + 1) & (DE_RX_RING_SIZE - 1))
100 #define TX_BUFFS_AVAIL(CP) \
101 (((CP)->tx_tail <= (CP)->tx_head) ? \
102 (CP)->tx_tail + (DE_TX_RING_SIZE - 1) - (CP)->tx_head : \
103 (CP)->tx_tail - (CP)->tx_head - 1)
105 #define PKT_BUF_SZ 1536 /* Size of each temporary Rx buffer.*/
108 #define DE_SETUP_SKB ((struct sk_buff *) 1)
109 #define DE_DUMMY_SKB ((struct sk_buff *) 2)
110 #define DE_SETUP_FRAME_WORDS 96
111 #define DE_EEPROM_WORDS 256
112 #define DE_EEPROM_SIZE (DE_EEPROM_WORDS * sizeof(u16))
113 #define DE_MAX_MEDIA 5
115 #define DE_MEDIA_TP_AUTO 0
116 #define DE_MEDIA_BNC 1
117 #define DE_MEDIA_AUI 2
118 #define DE_MEDIA_TP 3
119 #define DE_MEDIA_TP_FD 4
120 #define DE_MEDIA_INVALID DE_MAX_MEDIA
121 #define DE_MEDIA_FIRST 0
122 #define DE_MEDIA_LAST (DE_MAX_MEDIA - 1)
123 #define DE_AUI_BNC (SUPPORTED_AUI | SUPPORTED_BNC)
125 #define DE_TIMER_LINK (60 * HZ)
126 #define DE_TIMER_NO_LINK (5 * HZ)
128 #define DE_NUM_REGS 16
129 #define DE_REGS_SIZE (DE_NUM_REGS * sizeof(u32))
130 #define DE_REGS_VER 1
132 /* Time in jiffies before concluding the transmitter is hung. */
133 #define TX_TIMEOUT (6*HZ)
135 /* This is a mysterious value that can be written to CSR11 in the 21040 (only)
136 to support a pre-NWay full-duplex signaling mechanism using short frames.
137 No one knows what it should be, but if left at its default value some
138 10base2(!) packets trigger a full-duplex-request interrupt. */
139 #define FULL_DUPLEX_MAGIC 0x6969
162 CacheAlign16 = 0x00008000,
163 BurstLen4 = 0x00000400,
164 DescSkipLen = (DSL << 2),
167 NormalTxPoll = (1 << 0),
168 NormalRxPoll = (1 << 0),
170 /* Tx/Rx descriptor status bits */
173 RxErrLong = (1 << 7),
175 RxErrFIFO = (1 << 0),
176 RxErrRunt = (1 << 11),
177 RxErrFrame = (1 << 14),
179 FirstFrag = (1 << 29),
180 LastFrag = (1 << 30),
182 TxFIFOUnder = (1 << 1),
183 TxLinkFail = (1 << 2) | (1 << 10) | (1 << 11),
186 TxJabber = (1 << 14),
187 SetupFrame = (1 << 27),
198 TxState = (1 << 22) | (1 << 21) | (1 << 20),
199 RxState = (1 << 19) | (1 << 18) | (1 << 17),
200 LinkFail = (1 << 12),
202 RxStopped = (1 << 8),
203 TxStopped = (1 << 1),
206 TxEnable = (1 << 13),
208 RxTx = TxEnable | RxEnable,
209 FullDuplex = (1 << 9),
210 AcceptAllMulticast = (1 << 7),
211 AcceptAllPhys = (1 << 6),
213 MacModeClear = (1<<12) | (1<<11) | (1<<10) | (1<<8) | (1<<3) |
214 RxTx | BOCnt | AcceptAllPhys | AcceptAllMulticast,
217 EE_SHIFT_CLK = 0x02, /* EEPROM shift clock. */
218 EE_CS = 0x01, /* EEPROM chip select. */
219 EE_DATA_WRITE = 0x04, /* Data from the Tulip to EEPROM. */
222 EE_DATA_READ = 0x08, /* Data from the EEPROM chip. */
223 EE_ENB = (0x4800 | EE_CS),
225 /* The EEPROM commands include the alway-set leading bit. */
229 RxMissedOver = (1 << 16),
230 RxMissedMask = 0xffff,
232 /* SROM-related bits */
234 MediaBlockMask = 0x3f,
235 MediaCustomCSRs = (1 << 6),
238 PM_Sleep = (1 << 31),
239 PM_Snooze = (1 << 30),
240 PM_Mask = PM_Sleep | PM_Snooze,
243 NWayState = (1 << 14) | (1 << 13) | (1 << 12),
244 NWayRestart = (1 << 12),
245 NonselPortActive = (1 << 9),
246 LinkFailStatus = (1 << 2),
247 NetCxnErr = (1 << 1),
250 static const u32 de_intr_mask =
251 IntrOK | IntrErr | RxIntr | RxEmpty | TxIntr | TxEmpty |
252 LinkPass | LinkFail | PciErr;
255 * Set the programmable burst length to 4 longwords for all:
256 * DMA errors result without these values. Cache align 16 long.
258 static const u32 de_bus_mode = CacheAlign16 | BurstLen4 | DescSkipLen;
260 struct de_srom_media_block {
265 } __attribute__((packed));
267 struct de_srom_info_leaf {
271 } __attribute__((packed));
284 u16 type; /* DE_MEDIA_xxx */
301 struct net_device *dev;
304 struct de_desc *rx_ring;
305 struct de_desc *tx_ring;
306 struct ring_info tx_skb[DE_TX_RING_SIZE];
307 struct ring_info rx_skb[DE_RX_RING_SIZE];
313 struct net_device_stats net_stats;
315 struct pci_dev *pdev;
317 u16 setup_frame[DE_SETUP_FRAME_WORDS];
322 struct media_info media[DE_MAX_MEDIA];
323 struct timer_list media_timer;
327 unsigned de21040 : 1;
328 unsigned media_lock : 1;
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 (unsigned long data);
337 static void de21041_media_timer (unsigned long data);
338 static unsigned int de_ok_to_advertise (struct de_private *de, u32 new_media);
341 static DEFINE_PCI_DEVICE_TABLE(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 },
348 MODULE_DEVICE_TABLE(pci, de_pci_tbl);
350 static const char * const media_name[DE_MAX_MEDIA] = {
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, };
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, 0x6F3F, 0x6F3D, };
367 static u16 t21041_csr15[] = { 0x0008, 0x0006, 0x000E, 0x0008, 0x0008, };
370 #define dr32(reg) readl(de->regs + (reg))
371 #define dw32(reg,val) writel((val), de->regs + (reg))
374 static void de_rx_err_acct (struct de_private *de, unsigned rx_tail,
377 if (netif_msg_rx_err (de))
379 "%s: rx err, slot %d status 0x%x len %d\n",
380 de->dev->name, rx_tail, status, len);
382 if ((status & 0x38000300) != 0x0300) {
383 /* Ingore earlier buffers. */
384 if ((status & 0xffff) != 0x7fff) {
385 if (netif_msg_rx_err(de))
386 dev_warn(&de->dev->dev,
387 "Oversized Ethernet frame spanned multiple buffers, status %08x!\n",
389 de->net_stats.rx_length_errors++;
391 } else if (status & RxError) {
392 /* There was a fatal error. */
393 de->net_stats.rx_errors++; /* end of a packet.*/
394 if (status & 0x0890) de->net_stats.rx_length_errors++;
395 if (status & RxErrCRC) de->net_stats.rx_crc_errors++;
396 if (status & RxErrFIFO) de->net_stats.rx_fifo_errors++;
400 static void de_rx (struct de_private *de)
402 unsigned rx_tail = de->rx_tail;
403 unsigned rx_work = DE_RX_RING_SIZE;
410 struct sk_buff *skb, *copy_skb;
411 unsigned copying_skb, buflen;
413 skb = de->rx_skb[rx_tail].skb;
416 status = le32_to_cpu(de->rx_ring[rx_tail].opts1);
417 if (status & DescOwn)
420 len = ((status >> 16) & 0x7ff) - 4;
421 mapping = de->rx_skb[rx_tail].mapping;
423 if (unlikely(drop)) {
424 de->net_stats.rx_dropped++;
428 if (unlikely((status & 0x38008300) != 0x0300)) {
429 de_rx_err_acct(de, rx_tail, status, len);
433 copying_skb = (len <= rx_copybreak);
435 if (unlikely(netif_msg_rx_status(de)))
436 printk(KERN_DEBUG "%s: rx slot %d status 0x%x len %d copying? %d\n",
437 de->dev->name, rx_tail, status, len,
440 buflen = copying_skb ? (len + RX_OFFSET) : de->rx_buf_sz;
441 copy_skb = dev_alloc_skb (buflen);
442 if (unlikely(!copy_skb)) {
443 de->net_stats.rx_dropped++;
450 pci_unmap_single(de->pdev, mapping,
451 buflen, PCI_DMA_FROMDEVICE);
455 de->rx_skb[rx_tail].mapping =
456 pci_map_single(de->pdev, copy_skb->data,
457 buflen, PCI_DMA_FROMDEVICE);
458 de->rx_skb[rx_tail].skb = copy_skb;
460 pci_dma_sync_single_for_cpu(de->pdev, mapping, len, PCI_DMA_FROMDEVICE);
461 skb_reserve(copy_skb, RX_OFFSET);
462 skb_copy_from_linear_data(skb, skb_put(copy_skb, len),
464 pci_dma_sync_single_for_device(de->pdev, mapping, len, PCI_DMA_FROMDEVICE);
466 /* We'll reuse the original ring buffer. */
470 skb->protocol = eth_type_trans (skb, de->dev);
472 de->net_stats.rx_packets++;
473 de->net_stats.rx_bytes += skb->len;
475 if (rc == NET_RX_DROP)
479 if (rx_tail == (DE_RX_RING_SIZE - 1))
480 de->rx_ring[rx_tail].opts2 =
481 cpu_to_le32(RingEnd | de->rx_buf_sz);
483 de->rx_ring[rx_tail].opts2 = cpu_to_le32(de->rx_buf_sz);
484 de->rx_ring[rx_tail].addr1 = cpu_to_le32(mapping);
486 de->rx_ring[rx_tail].opts1 = cpu_to_le32(DescOwn);
487 rx_tail = NEXT_RX(rx_tail);
491 dev_warn(&de->dev->dev, "rx work limit reached\n");
493 de->rx_tail = rx_tail;
496 static irqreturn_t de_interrupt (int irq, void *dev_instance)
498 struct net_device *dev = dev_instance;
499 struct de_private *de = netdev_priv(dev);
502 status = dr32(MacStatus);
503 if ((!(status & (IntrOK|IntrErr))) || (status == 0xFFFF))
506 if (netif_msg_intr(de))
507 printk(KERN_DEBUG "%s: intr, status %08x mode %08x desc %u/%u/%u\n",
508 dev->name, status, dr32(MacMode),
509 de->rx_tail, de->tx_head, de->tx_tail);
511 dw32(MacStatus, status);
513 if (status & (RxIntr | RxEmpty)) {
515 if (status & RxEmpty)
516 dw32(RxPoll, NormalRxPoll);
519 spin_lock(&de->lock);
521 if (status & (TxIntr | TxEmpty))
524 if (status & (LinkPass | LinkFail))
525 de_media_interrupt(de, status);
527 spin_unlock(&de->lock);
529 if (status & PciErr) {
532 pci_read_config_word(de->pdev, PCI_STATUS, &pci_status);
533 pci_write_config_word(de->pdev, PCI_STATUS, pci_status);
534 dev_err(&de->dev->dev,
535 "PCI bus error, status=%08x, PCI status=%04x\n",
542 static void de_tx (struct de_private *de)
544 unsigned tx_head = de->tx_head;
545 unsigned tx_tail = de->tx_tail;
547 while (tx_tail != tx_head) {
552 status = le32_to_cpu(de->tx_ring[tx_tail].opts1);
553 if (status & DescOwn)
556 skb = de->tx_skb[tx_tail].skb;
558 if (unlikely(skb == DE_DUMMY_SKB))
561 if (unlikely(skb == DE_SETUP_SKB)) {
562 pci_unmap_single(de->pdev, de->tx_skb[tx_tail].mapping,
563 sizeof(de->setup_frame), PCI_DMA_TODEVICE);
567 pci_unmap_single(de->pdev, de->tx_skb[tx_tail].mapping,
568 skb->len, PCI_DMA_TODEVICE);
570 if (status & LastFrag) {
571 if (status & TxError) {
572 if (netif_msg_tx_err(de))
573 printk(KERN_DEBUG "%s: tx err, status 0x%x\n",
574 de->dev->name, status);
575 de->net_stats.tx_errors++;
577 de->net_stats.tx_window_errors++;
578 if (status & TxMaxCol)
579 de->net_stats.tx_aborted_errors++;
580 if (status & TxLinkFail)
581 de->net_stats.tx_carrier_errors++;
582 if (status & TxFIFOUnder)
583 de->net_stats.tx_fifo_errors++;
585 de->net_stats.tx_packets++;
586 de->net_stats.tx_bytes += skb->len;
587 if (netif_msg_tx_done(de))
588 printk(KERN_DEBUG "%s: tx done, slot %d\n",
589 de->dev->name, tx_tail);
591 dev_kfree_skb_irq(skb);
595 de->tx_skb[tx_tail].skb = NULL;
597 tx_tail = NEXT_TX(tx_tail);
600 de->tx_tail = tx_tail;
602 if (netif_queue_stopped(de->dev) && (TX_BUFFS_AVAIL(de) > (DE_TX_RING_SIZE / 4)))
603 netif_wake_queue(de->dev);
606 static netdev_tx_t de_start_xmit (struct sk_buff *skb,
607 struct net_device *dev)
609 struct de_private *de = netdev_priv(dev);
610 unsigned int entry, tx_free;
611 u32 mapping, len, flags = FirstFrag | LastFrag;
614 spin_lock_irq(&de->lock);
616 tx_free = TX_BUFFS_AVAIL(de);
618 netif_stop_queue(dev);
619 spin_unlock_irq(&de->lock);
620 return NETDEV_TX_BUSY;
626 txd = &de->tx_ring[entry];
629 mapping = pci_map_single(de->pdev, skb->data, len, PCI_DMA_TODEVICE);
630 if (entry == (DE_TX_RING_SIZE - 1))
632 if (!tx_free || (tx_free == (DE_TX_RING_SIZE / 2)))
635 txd->opts2 = cpu_to_le32(flags);
636 txd->addr1 = cpu_to_le32(mapping);
638 de->tx_skb[entry].skb = skb;
639 de->tx_skb[entry].mapping = mapping;
642 txd->opts1 = cpu_to_le32(DescOwn);
645 de->tx_head = NEXT_TX(entry);
646 if (netif_msg_tx_queued(de))
647 printk(KERN_DEBUG "%s: tx queued, slot %d, skblen %d\n",
648 dev->name, entry, skb->len);
651 netif_stop_queue(dev);
653 spin_unlock_irq(&de->lock);
655 /* Trigger an immediate transmit demand. */
656 dw32(TxPoll, NormalTxPoll);
657 dev->trans_start = jiffies;
662 /* Set or clear the multicast filter for this adaptor.
663 Note that we only use exclusion around actually queueing the
664 new frame, not around filling de->setup_frame. This is non-deterministic
665 when re-entered but still correct. */
668 #define set_bit_le(i,p) do { ((char *)(p))[(i)/8] |= (1<<((i)%8)); } while(0)
670 static void build_setup_frame_hash(u16 *setup_frm, struct net_device *dev)
672 struct de_private *de = netdev_priv(dev);
674 struct dev_mc_list *mclist;
678 memset(hash_table, 0, sizeof(hash_table));
679 set_bit_le(255, hash_table); /* Broadcast entry */
680 /* This should work on big-endian machines as well. */
681 netdev_for_each_mc_addr(mclist, dev) {
682 int index = ether_crc_le(ETH_ALEN, mclist->dmi_addr) & 0x1ff;
684 set_bit_le(index, hash_table);
687 for (i = 0; i < 32; i++) {
688 *setup_frm++ = hash_table[i];
689 *setup_frm++ = hash_table[i];
691 setup_frm = &de->setup_frame[13*6];
693 /* Fill the final entry with our physical address. */
694 eaddrs = (u16 *)dev->dev_addr;
695 *setup_frm++ = eaddrs[0]; *setup_frm++ = eaddrs[0];
696 *setup_frm++ = eaddrs[1]; *setup_frm++ = eaddrs[1];
697 *setup_frm++ = eaddrs[2]; *setup_frm++ = eaddrs[2];
700 static void build_setup_frame_perfect(u16 *setup_frm, struct net_device *dev)
702 struct de_private *de = netdev_priv(dev);
703 struct dev_mc_list *mclist;
706 /* We have <= 14 addresses so we can use the wonderful
707 16 address perfect filtering of the Tulip. */
708 netdev_for_each_mc_addr(mclist, dev) {
709 eaddrs = (u16 *)mclist->dmi_addr;
710 *setup_frm++ = *eaddrs; *setup_frm++ = *eaddrs++;
711 *setup_frm++ = *eaddrs; *setup_frm++ = *eaddrs++;
712 *setup_frm++ = *eaddrs; *setup_frm++ = *eaddrs++;
714 /* Fill the unused entries with the broadcast address. */
715 memset(setup_frm, 0xff, (15 - netdev_mc_count(dev)) * 12);
716 setup_frm = &de->setup_frame[15*6];
718 /* Fill the final entry with our physical address. */
719 eaddrs = (u16 *)dev->dev_addr;
720 *setup_frm++ = eaddrs[0]; *setup_frm++ = eaddrs[0];
721 *setup_frm++ = eaddrs[1]; *setup_frm++ = eaddrs[1];
722 *setup_frm++ = eaddrs[2]; *setup_frm++ = eaddrs[2];
726 static void __de_set_rx_mode (struct net_device *dev)
728 struct de_private *de = netdev_priv(dev);
733 struct de_desc *dummy_txd = NULL;
735 macmode = dr32(MacMode) & ~(AcceptAllMulticast | AcceptAllPhys);
737 if (dev->flags & IFF_PROMISC) { /* Set promiscuous. */
738 macmode |= AcceptAllMulticast | AcceptAllPhys;
742 if ((netdev_mc_count(dev) > 1000) || (dev->flags & IFF_ALLMULTI)) {
743 /* Too many to filter well -- accept all multicasts. */
744 macmode |= AcceptAllMulticast;
748 /* Note that only the low-address shortword of setup_frame is valid!
749 The values are doubled for big-endian architectures. */
750 if (netdev_mc_count(dev) > 14) /* Must use a multicast hash table. */
751 build_setup_frame_hash (de->setup_frame, dev);
753 build_setup_frame_perfect (de->setup_frame, dev);
756 * Now add this frame to the Tx list.
761 /* Avoid a chip errata by prefixing a dummy entry. */
763 de->tx_skb[entry].skb = DE_DUMMY_SKB;
765 dummy_txd = &de->tx_ring[entry];
766 dummy_txd->opts2 = (entry == (DE_TX_RING_SIZE - 1)) ?
767 cpu_to_le32(RingEnd) : 0;
768 dummy_txd->addr1 = 0;
770 /* Must set DescOwned later to avoid race with chip */
772 entry = NEXT_TX(entry);
775 de->tx_skb[entry].skb = DE_SETUP_SKB;
776 de->tx_skb[entry].mapping = mapping =
777 pci_map_single (de->pdev, de->setup_frame,
778 sizeof (de->setup_frame), PCI_DMA_TODEVICE);
780 /* Put the setup frame on the Tx list. */
781 txd = &de->tx_ring[entry];
782 if (entry == (DE_TX_RING_SIZE - 1))
783 txd->opts2 = cpu_to_le32(SetupFrame | RingEnd | sizeof (de->setup_frame));
785 txd->opts2 = cpu_to_le32(SetupFrame | sizeof (de->setup_frame));
786 txd->addr1 = cpu_to_le32(mapping);
789 txd->opts1 = cpu_to_le32(DescOwn);
793 dummy_txd->opts1 = cpu_to_le32(DescOwn);
797 de->tx_head = NEXT_TX(entry);
799 if (TX_BUFFS_AVAIL(de) == 0)
800 netif_stop_queue(dev);
802 /* Trigger an immediate transmit demand. */
803 dw32(TxPoll, NormalTxPoll);
806 if (macmode != dr32(MacMode))
807 dw32(MacMode, macmode);
810 static void de_set_rx_mode (struct net_device *dev)
813 struct de_private *de = netdev_priv(dev);
815 spin_lock_irqsave (&de->lock, flags);
816 __de_set_rx_mode(dev);
817 spin_unlock_irqrestore (&de->lock, flags);
820 static inline void de_rx_missed(struct de_private *de, u32 rx_missed)
822 if (unlikely(rx_missed & RxMissedOver))
823 de->net_stats.rx_missed_errors += RxMissedMask;
825 de->net_stats.rx_missed_errors += (rx_missed & RxMissedMask);
828 static void __de_get_stats(struct de_private *de)
830 u32 tmp = dr32(RxMissed); /* self-clearing */
832 de_rx_missed(de, tmp);
835 static struct net_device_stats *de_get_stats(struct net_device *dev)
837 struct de_private *de = netdev_priv(dev);
839 /* The chip only need report frame silently dropped. */
840 spin_lock_irq(&de->lock);
841 if (netif_running(dev) && netif_device_present(dev))
843 spin_unlock_irq(&de->lock);
845 return &de->net_stats;
848 static inline int de_is_running (struct de_private *de)
850 return (dr32(MacStatus) & (RxState | TxState)) ? 1 : 0;
853 static void de_stop_rxtx (struct de_private *de)
856 unsigned int i = 1300/100;
858 macmode = dr32(MacMode);
859 if (macmode & RxTx) {
860 dw32(MacMode, macmode & ~RxTx);
864 /* wait until in-flight frame completes.
865 * Max time @ 10BT: 1500*8b/10Mbps == 1200us (+ 100us margin)
866 * Typically expect this loop to end in < 50 us on 100BT.
869 if (!de_is_running(de))
874 dev_warn(&de->dev->dev, "timeout expired stopping DMA\n");
877 static inline void de_start_rxtx (struct de_private *de)
881 macmode = dr32(MacMode);
882 if ((macmode & RxTx) != RxTx) {
883 dw32(MacMode, macmode | RxTx);
888 static void de_stop_hw (struct de_private *de)
896 dw32(MacStatus, dr32(MacStatus));
901 de->tx_head = de->tx_tail = 0;
904 static void de_link_up(struct de_private *de)
906 if (!netif_carrier_ok(de->dev)) {
907 netif_carrier_on(de->dev);
908 if (netif_msg_link(de))
909 dev_info(&de->dev->dev, "link up, media %s\n",
910 media_name[de->media_type]);
914 static void de_link_down(struct de_private *de)
916 if (netif_carrier_ok(de->dev)) {
917 netif_carrier_off(de->dev);
918 if (netif_msg_link(de))
919 dev_info(&de->dev->dev, "link down\n");
923 static void de_set_media (struct de_private *de)
925 unsigned media = de->media_type;
926 u32 macmode = dr32(MacMode);
928 if (de_is_running(de))
929 dev_warn(&de->dev->dev,
930 "chip is running while changing media!\n");
933 dw32(CSR11, FULL_DUPLEX_MAGIC);
934 dw32(CSR13, 0); /* Reset phy */
935 dw32(CSR14, de->media[media].csr14);
936 dw32(CSR15, de->media[media].csr15);
937 dw32(CSR13, de->media[media].csr13);
939 /* must delay 10ms before writing to other registers,
944 if (media == DE_MEDIA_TP_FD)
945 macmode |= FullDuplex;
947 macmode &= ~FullDuplex;
949 if (netif_msg_link(de)) {
950 dev_info(&de->dev->dev, "set link %s\n", media_name[media]);
951 dev_info(&de->dev->dev, "mode 0x%x, sia 0x%x,0x%x,0x%x,0x%x\n",
952 dr32(MacMode), dr32(SIAStatus),
953 dr32(CSR13), dr32(CSR14), dr32(CSR15));
955 dev_info(&de->dev->dev,
956 "set mode 0x%x, set sia 0x%x,0x%x,0x%x\n",
957 macmode, de->media[media].csr13,
958 de->media[media].csr14, de->media[media].csr15);
960 if (macmode != dr32(MacMode))
961 dw32(MacMode, macmode);
964 static void de_next_media (struct de_private *de, u32 *media,
965 unsigned int n_media)
969 for (i = 0; i < n_media; i++) {
970 if (de_ok_to_advertise(de, media[i])) {
971 de->media_type = media[i];
977 static void de21040_media_timer (unsigned long data)
979 struct de_private *de = (struct de_private *) data;
980 struct net_device *dev = de->dev;
981 u32 status = dr32(SIAStatus);
982 unsigned int carrier;
985 carrier = (status & NetCxnErr) ? 0 : 1;
988 if (de->media_type != DE_MEDIA_AUI && (status & LinkFailStatus))
991 de->media_timer.expires = jiffies + DE_TIMER_LINK;
992 add_timer(&de->media_timer);
993 if (!netif_carrier_ok(dev))
996 if (netif_msg_timer(de))
997 dev_info(&dev->dev, "%s link ok, status %x\n",
998 media_name[de->media_type], status);
1007 if (de->media_type == DE_MEDIA_AUI) {
1008 u32 next_state = DE_MEDIA_TP;
1009 de_next_media(de, &next_state, 1);
1011 u32 next_state = DE_MEDIA_AUI;
1012 de_next_media(de, &next_state, 1);
1015 spin_lock_irqsave(&de->lock, flags);
1017 spin_unlock_irqrestore(&de->lock, flags);
1022 de->media_timer.expires = jiffies + DE_TIMER_NO_LINK;
1023 add_timer(&de->media_timer);
1025 if (netif_msg_timer(de))
1026 dev_info(&dev->dev, "no link, trying media %s, status %x\n",
1027 media_name[de->media_type], status);
1030 static unsigned int de_ok_to_advertise (struct de_private *de, u32 new_media)
1032 switch (new_media) {
1033 case DE_MEDIA_TP_AUTO:
1034 if (!(de->media_advertise & ADVERTISED_Autoneg))
1036 if (!(de->media_advertise & (ADVERTISED_10baseT_Half | ADVERTISED_10baseT_Full)))
1040 if (!(de->media_advertise & ADVERTISED_BNC))
1044 if (!(de->media_advertise & ADVERTISED_AUI))
1048 if (!(de->media_advertise & ADVERTISED_10baseT_Half))
1051 case DE_MEDIA_TP_FD:
1052 if (!(de->media_advertise & ADVERTISED_10baseT_Full))
1060 static void de21041_media_timer (unsigned long data)
1062 struct de_private *de = (struct de_private *) data;
1063 struct net_device *dev = de->dev;
1064 u32 status = dr32(SIAStatus);
1065 unsigned int carrier;
1066 unsigned long flags;
1068 carrier = (status & NetCxnErr) ? 0 : 1;
1071 if ((de->media_type == DE_MEDIA_TP_AUTO ||
1072 de->media_type == DE_MEDIA_TP ||
1073 de->media_type == DE_MEDIA_TP_FD) &&
1074 (status & LinkFailStatus))
1077 de->media_timer.expires = jiffies + DE_TIMER_LINK;
1078 add_timer(&de->media_timer);
1079 if (!netif_carrier_ok(dev))
1082 if (netif_msg_timer(de))
1084 "%s link ok, mode %x status %x\n",
1085 media_name[de->media_type],
1086 dr32(MacMode), status);
1092 /* if media type locked, don't switch media */
1096 /* if activity detected, use that as hint for new media type */
1097 if (status & NonselPortActive) {
1098 unsigned int have_media = 1;
1100 /* if AUI/BNC selected, then activity is on TP port */
1101 if (de->media_type == DE_MEDIA_AUI ||
1102 de->media_type == DE_MEDIA_BNC) {
1103 if (de_ok_to_advertise(de, DE_MEDIA_TP_AUTO))
1104 de->media_type = DE_MEDIA_TP_AUTO;
1109 /* TP selected. If there is only TP and BNC, then it's BNC */
1110 else if (((de->media_supported & DE_AUI_BNC) == SUPPORTED_BNC) &&
1111 de_ok_to_advertise(de, DE_MEDIA_BNC))
1112 de->media_type = DE_MEDIA_BNC;
1114 /* TP selected. If there is only TP and AUI, then it's AUI */
1115 else if (((de->media_supported & DE_AUI_BNC) == SUPPORTED_AUI) &&
1116 de_ok_to_advertise(de, DE_MEDIA_AUI))
1117 de->media_type = DE_MEDIA_AUI;
1119 /* otherwise, ignore the hint */
1128 * Absent or ambiguous activity hint, move to next advertised
1129 * media state. If de->media_type is left unchanged, this
1130 * simply resets the PHY and reloads the current media settings.
1132 if (de->media_type == DE_MEDIA_AUI) {
1133 u32 next_states[] = { DE_MEDIA_BNC, DE_MEDIA_TP_AUTO };
1134 de_next_media(de, next_states, ARRAY_SIZE(next_states));
1135 } else if (de->media_type == DE_MEDIA_BNC) {
1136 u32 next_states[] = { DE_MEDIA_TP_AUTO, DE_MEDIA_AUI };
1137 de_next_media(de, next_states, ARRAY_SIZE(next_states));
1139 u32 next_states[] = { DE_MEDIA_AUI, DE_MEDIA_BNC, DE_MEDIA_TP_AUTO };
1140 de_next_media(de, next_states, ARRAY_SIZE(next_states));
1144 spin_lock_irqsave(&de->lock, flags);
1146 spin_unlock_irqrestore(&de->lock, flags);
1151 de->media_timer.expires = jiffies + DE_TIMER_NO_LINK;
1152 add_timer(&de->media_timer);
1154 if (netif_msg_timer(de))
1155 dev_info(&dev->dev, "no link, trying media %s, status %x\n",
1156 media_name[de->media_type], status);
1159 static void de_media_interrupt (struct de_private *de, u32 status)
1161 if (status & LinkPass) {
1163 mod_timer(&de->media_timer, jiffies + DE_TIMER_LINK);
1167 BUG_ON(!(status & LinkFail));
1169 if (netif_carrier_ok(de->dev)) {
1171 mod_timer(&de->media_timer, jiffies + DE_TIMER_NO_LINK);
1175 static int de_reset_mac (struct de_private *de)
1180 * Reset MAC. de4x5.c and tulip.c examined for "advice"
1184 if (dr32(BusMode) == 0xffffffff)
1187 /* Reset the chip, holding bit 0 set at least 50 PCI cycles. */
1188 dw32 (BusMode, CmdReset);
1191 dw32 (BusMode, de_bus_mode);
1194 for (tmp = 0; tmp < 5; tmp++) {
1201 status = dr32(MacStatus);
1202 if (status & (RxState | TxState))
1204 if (status == 0xffffffff)
1209 static void de_adapter_wake (struct de_private *de)
1216 pci_read_config_dword(de->pdev, PCIPM, &pmctl);
1217 if (pmctl & PM_Mask) {
1219 pci_write_config_dword(de->pdev, PCIPM, pmctl);
1221 /* de4x5.c delays, so we do too */
1226 static void de_adapter_sleep (struct de_private *de)
1233 pci_read_config_dword(de->pdev, PCIPM, &pmctl);
1235 pci_write_config_dword(de->pdev, PCIPM, pmctl);
1238 static int de_init_hw (struct de_private *de)
1240 struct net_device *dev = de->dev;
1244 de_adapter_wake(de);
1246 macmode = dr32(MacMode) & ~MacModeClear;
1248 rc = de_reset_mac(de);
1252 de_set_media(de); /* reset phy */
1254 dw32(RxRingAddr, de->ring_dma);
1255 dw32(TxRingAddr, de->ring_dma + (sizeof(struct de_desc) * DE_RX_RING_SIZE));
1257 dw32(MacMode, RxTx | macmode);
1259 dr32(RxMissed); /* self-clearing */
1261 dw32(IntrMask, de_intr_mask);
1263 de_set_rx_mode(dev);
1268 static int de_refill_rx (struct de_private *de)
1272 for (i = 0; i < DE_RX_RING_SIZE; i++) {
1273 struct sk_buff *skb;
1275 skb = dev_alloc_skb(de->rx_buf_sz);
1281 de->rx_skb[i].mapping = pci_map_single(de->pdev,
1282 skb->data, de->rx_buf_sz, PCI_DMA_FROMDEVICE);
1283 de->rx_skb[i].skb = skb;
1285 de->rx_ring[i].opts1 = cpu_to_le32(DescOwn);
1286 if (i == (DE_RX_RING_SIZE - 1))
1287 de->rx_ring[i].opts2 =
1288 cpu_to_le32(RingEnd | de->rx_buf_sz);
1290 de->rx_ring[i].opts2 = cpu_to_le32(de->rx_buf_sz);
1291 de->rx_ring[i].addr1 = cpu_to_le32(de->rx_skb[i].mapping);
1292 de->rx_ring[i].addr2 = 0;
1302 static int de_init_rings (struct de_private *de)
1304 memset(de->tx_ring, 0, sizeof(struct de_desc) * DE_TX_RING_SIZE);
1305 de->tx_ring[DE_TX_RING_SIZE - 1].opts2 = cpu_to_le32(RingEnd);
1308 de->tx_head = de->tx_tail = 0;
1310 return de_refill_rx (de);
1313 static int de_alloc_rings (struct de_private *de)
1315 de->rx_ring = pci_alloc_consistent(de->pdev, DE_RING_BYTES, &de->ring_dma);
1318 de->tx_ring = &de->rx_ring[DE_RX_RING_SIZE];
1319 return de_init_rings(de);
1322 static void de_clean_rings (struct de_private *de)
1326 memset(de->rx_ring, 0, sizeof(struct de_desc) * DE_RX_RING_SIZE);
1327 de->rx_ring[DE_RX_RING_SIZE - 1].opts2 = cpu_to_le32(RingEnd);
1329 memset(de->tx_ring, 0, sizeof(struct de_desc) * DE_TX_RING_SIZE);
1330 de->tx_ring[DE_TX_RING_SIZE - 1].opts2 = cpu_to_le32(RingEnd);
1333 for (i = 0; i < DE_RX_RING_SIZE; i++) {
1334 if (de->rx_skb[i].skb) {
1335 pci_unmap_single(de->pdev, de->rx_skb[i].mapping,
1336 de->rx_buf_sz, PCI_DMA_FROMDEVICE);
1337 dev_kfree_skb(de->rx_skb[i].skb);
1341 for (i = 0; i < DE_TX_RING_SIZE; i++) {
1342 struct sk_buff *skb = de->tx_skb[i].skb;
1343 if ((skb) && (skb != DE_DUMMY_SKB)) {
1344 if (skb != DE_SETUP_SKB) {
1345 de->net_stats.tx_dropped++;
1346 pci_unmap_single(de->pdev,
1347 de->tx_skb[i].mapping,
1348 skb->len, PCI_DMA_TODEVICE);
1351 pci_unmap_single(de->pdev,
1352 de->tx_skb[i].mapping,
1353 sizeof(de->setup_frame),
1359 memset(&de->rx_skb, 0, sizeof(struct ring_info) * DE_RX_RING_SIZE);
1360 memset(&de->tx_skb, 0, sizeof(struct ring_info) * DE_TX_RING_SIZE);
1363 static void de_free_rings (struct de_private *de)
1366 pci_free_consistent(de->pdev, DE_RING_BYTES, de->rx_ring, de->ring_dma);
1371 static int de_open (struct net_device *dev)
1373 struct de_private *de = netdev_priv(dev);
1376 if (netif_msg_ifup(de))
1377 printk(KERN_DEBUG "%s: enabling interface\n", dev->name);
1379 de->rx_buf_sz = (dev->mtu <= 1500 ? PKT_BUF_SZ : dev->mtu + 32);
1381 rc = de_alloc_rings(de);
1383 dev_err(&dev->dev, "ring allocation failure, err=%d\n", rc);
1389 rc = request_irq(dev->irq, de_interrupt, IRQF_SHARED, dev->name, dev);
1391 dev_err(&dev->dev, "IRQ %d request failure, err=%d\n",
1396 rc = de_init_hw(de);
1398 dev_err(&dev->dev, "h/w init failure, err=%d\n", rc);
1399 goto err_out_free_irq;
1402 netif_start_queue(dev);
1403 mod_timer(&de->media_timer, jiffies + DE_TIMER_NO_LINK);
1408 free_irq(dev->irq, dev);
1414 static int de_close (struct net_device *dev)
1416 struct de_private *de = netdev_priv(dev);
1417 unsigned long flags;
1419 if (netif_msg_ifdown(de))
1420 printk(KERN_DEBUG "%s: disabling interface\n", dev->name);
1422 del_timer_sync(&de->media_timer);
1424 spin_lock_irqsave(&de->lock, flags);
1426 netif_stop_queue(dev);
1427 netif_carrier_off(dev);
1428 spin_unlock_irqrestore(&de->lock, flags);
1430 free_irq(dev->irq, dev);
1433 de_adapter_sleep(de);
1437 static void de_tx_timeout (struct net_device *dev)
1439 struct de_private *de = netdev_priv(dev);
1441 printk(KERN_DEBUG "%s: NIC status %08x mode %08x sia %08x desc %u/%u/%u\n",
1442 dev->name, dr32(MacStatus), dr32(MacMode), dr32(SIAStatus),
1443 de->rx_tail, de->tx_head, de->tx_tail);
1445 del_timer_sync(&de->media_timer);
1447 disable_irq(dev->irq);
1448 spin_lock_irq(&de->lock);
1451 netif_stop_queue(dev);
1452 netif_carrier_off(dev);
1454 spin_unlock_irq(&de->lock);
1455 enable_irq(dev->irq);
1457 /* Update the error counts. */
1460 synchronize_irq(dev->irq);
1467 netif_wake_queue(dev);
1470 static void __de_get_regs(struct de_private *de, u8 *buf)
1473 u32 *rbuf = (u32 *)buf;
1476 for (i = 0; i < DE_NUM_REGS; i++)
1477 rbuf[i] = dr32(i * 8);
1479 /* handle self-clearing RxMissed counter, CSR8 */
1480 de_rx_missed(de, rbuf[8]);
1483 static int __de_get_settings(struct de_private *de, struct ethtool_cmd *ecmd)
1485 ecmd->supported = de->media_supported;
1486 ecmd->transceiver = XCVR_INTERNAL;
1487 ecmd->phy_address = 0;
1488 ecmd->advertising = de->media_advertise;
1490 switch (de->media_type) {
1492 ecmd->port = PORT_AUI;
1496 ecmd->port = PORT_BNC;
1500 ecmd->port = PORT_TP;
1501 ecmd->speed = SPEED_10;
1505 if (dr32(MacMode) & FullDuplex)
1506 ecmd->duplex = DUPLEX_FULL;
1508 ecmd->duplex = DUPLEX_HALF;
1511 ecmd->autoneg = AUTONEG_DISABLE;
1513 ecmd->autoneg = AUTONEG_ENABLE;
1515 /* ignore maxtxpkt, maxrxpkt for now */
1520 static int __de_set_settings(struct de_private *de, struct ethtool_cmd *ecmd)
1523 unsigned int media_lock;
1525 if (ecmd->speed != SPEED_10 && ecmd->speed != 5 && ecmd->speed != 2)
1527 if (de->de21040 && ecmd->speed == 2)
1529 if (ecmd->duplex != DUPLEX_HALF && ecmd->duplex != DUPLEX_FULL)
1531 if (ecmd->port != PORT_TP && ecmd->port != PORT_AUI && ecmd->port != PORT_BNC)
1533 if (de->de21040 && ecmd->port == PORT_BNC)
1535 if (ecmd->transceiver != XCVR_INTERNAL)
1537 if (ecmd->autoneg != AUTONEG_DISABLE && ecmd->autoneg != AUTONEG_ENABLE)
1539 if (ecmd->advertising & ~de->media_supported)
1541 if (ecmd->autoneg == AUTONEG_ENABLE &&
1542 (!(ecmd->advertising & ADVERTISED_Autoneg)))
1545 switch (ecmd->port) {
1547 new_media = DE_MEDIA_AUI;
1548 if (!(ecmd->advertising & ADVERTISED_AUI))
1552 new_media = DE_MEDIA_BNC;
1553 if (!(ecmd->advertising & ADVERTISED_BNC))
1557 if (ecmd->autoneg == AUTONEG_ENABLE)
1558 new_media = DE_MEDIA_TP_AUTO;
1559 else if (ecmd->duplex == DUPLEX_FULL)
1560 new_media = DE_MEDIA_TP_FD;
1562 new_media = DE_MEDIA_TP;
1563 if (!(ecmd->advertising & ADVERTISED_TP))
1565 if (!(ecmd->advertising & (ADVERTISED_10baseT_Full | ADVERTISED_10baseT_Half)))
1570 media_lock = (ecmd->autoneg == AUTONEG_ENABLE) ? 0 : 1;
1572 if ((new_media == de->media_type) &&
1573 (media_lock == de->media_lock) &&
1574 (ecmd->advertising == de->media_advertise))
1575 return 0; /* nothing to change */
1580 de->media_type = new_media;
1581 de->media_lock = media_lock;
1582 de->media_advertise = ecmd->advertising;
1588 static void de_get_drvinfo (struct net_device *dev,struct ethtool_drvinfo *info)
1590 struct de_private *de = netdev_priv(dev);
1592 strcpy (info->driver, DRV_NAME);
1593 strcpy (info->version, DRV_VERSION);
1594 strcpy (info->bus_info, pci_name(de->pdev));
1595 info->eedump_len = DE_EEPROM_SIZE;
1598 static int de_get_regs_len(struct net_device *dev)
1600 return DE_REGS_SIZE;
1603 static int de_get_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
1605 struct de_private *de = netdev_priv(dev);
1608 spin_lock_irq(&de->lock);
1609 rc = __de_get_settings(de, ecmd);
1610 spin_unlock_irq(&de->lock);
1615 static int de_set_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
1617 struct de_private *de = netdev_priv(dev);
1620 spin_lock_irq(&de->lock);
1621 rc = __de_set_settings(de, ecmd);
1622 spin_unlock_irq(&de->lock);
1627 static u32 de_get_msglevel(struct net_device *dev)
1629 struct de_private *de = netdev_priv(dev);
1631 return de->msg_enable;
1634 static void de_set_msglevel(struct net_device *dev, u32 msglvl)
1636 struct de_private *de = netdev_priv(dev);
1638 de->msg_enable = msglvl;
1641 static int de_get_eeprom(struct net_device *dev,
1642 struct ethtool_eeprom *eeprom, u8 *data)
1644 struct de_private *de = netdev_priv(dev);
1648 if ((eeprom->offset != 0) || (eeprom->magic != 0) ||
1649 (eeprom->len != DE_EEPROM_SIZE))
1651 memcpy(data, de->ee_data, eeprom->len);
1656 static int de_nway_reset(struct net_device *dev)
1658 struct de_private *de = netdev_priv(dev);
1661 if (de->media_type != DE_MEDIA_TP_AUTO)
1663 if (netif_carrier_ok(de->dev))
1666 status = dr32(SIAStatus);
1667 dw32(SIAStatus, (status & ~NWayState) | NWayRestart);
1668 if (netif_msg_link(de))
1669 dev_info(&de->dev->dev, "link nway restart, status %x,%x\n",
1670 status, dr32(SIAStatus));
1674 static void de_get_regs(struct net_device *dev, struct ethtool_regs *regs,
1677 struct de_private *de = netdev_priv(dev);
1679 regs->version = (DE_REGS_VER << 2) | de->de21040;
1681 spin_lock_irq(&de->lock);
1682 __de_get_regs(de, data);
1683 spin_unlock_irq(&de->lock);
1686 static const struct ethtool_ops de_ethtool_ops = {
1687 .get_link = ethtool_op_get_link,
1688 .get_drvinfo = de_get_drvinfo,
1689 .get_regs_len = de_get_regs_len,
1690 .get_settings = de_get_settings,
1691 .set_settings = de_set_settings,
1692 .get_msglevel = de_get_msglevel,
1693 .set_msglevel = de_set_msglevel,
1694 .get_eeprom = de_get_eeprom,
1695 .nway_reset = de_nway_reset,
1696 .get_regs = de_get_regs,
1699 static void __devinit de21040_get_mac_address (struct de_private *de)
1703 dw32 (ROMCmd, 0); /* Reset the pointer with a dummy write. */
1706 for (i = 0; i < 6; i++) {
1707 int value, boguscnt = 100000;
1709 value = dr32(ROMCmd);
1710 } while (value < 0 && --boguscnt > 0);
1711 de->dev->dev_addr[i] = value;
1714 pr_warning(PFX "timeout reading 21040 MAC address byte %u\n", i);
1718 static void __devinit de21040_get_media_info(struct de_private *de)
1722 de->media_type = DE_MEDIA_TP;
1723 de->media_supported |= SUPPORTED_TP | SUPPORTED_10baseT_Full |
1724 SUPPORTED_10baseT_Half | SUPPORTED_AUI;
1725 de->media_advertise = de->media_supported;
1727 for (i = 0; i < DE_MAX_MEDIA; i++) {
1731 case DE_MEDIA_TP_FD:
1732 de->media[i].type = i;
1733 de->media[i].csr13 = t21040_csr13[i];
1734 de->media[i].csr14 = t21040_csr14[i];
1735 de->media[i].csr15 = t21040_csr15[i];
1738 de->media[i].type = DE_MEDIA_INVALID;
1744 /* Note: this routine returns extra data bits for size detection. */
1745 static unsigned __devinit tulip_read_eeprom(void __iomem *regs, int location, int addr_len)
1748 unsigned retval = 0;
1749 void __iomem *ee_addr = regs + ROMCmd;
1750 int read_cmd = location | (EE_READ_CMD << addr_len);
1752 writel(EE_ENB & ~EE_CS, ee_addr);
1753 writel(EE_ENB, ee_addr);
1755 /* Shift the read command bits out. */
1756 for (i = 4 + addr_len; i >= 0; i--) {
1757 short dataval = (read_cmd & (1 << i)) ? EE_DATA_WRITE : 0;
1758 writel(EE_ENB | dataval, ee_addr);
1760 writel(EE_ENB | dataval | EE_SHIFT_CLK, ee_addr);
1762 retval = (retval << 1) | ((readl(ee_addr) & EE_DATA_READ) ? 1 : 0);
1764 writel(EE_ENB, ee_addr);
1767 for (i = 16; i > 0; i--) {
1768 writel(EE_ENB | EE_SHIFT_CLK, ee_addr);
1770 retval = (retval << 1) | ((readl(ee_addr) & EE_DATA_READ) ? 1 : 0);
1771 writel(EE_ENB, ee_addr);
1775 /* Terminate the EEPROM access. */
1776 writel(EE_ENB & ~EE_CS, ee_addr);
1780 static void __devinit de21041_get_srom_info (struct de_private *de)
1782 unsigned i, sa_offset = 0, ofs;
1783 u8 ee_data[DE_EEPROM_SIZE + 6] = {};
1784 unsigned ee_addr_size = tulip_read_eeprom(de->regs, 0xff, 8) & 0x40000 ? 8 : 6;
1785 struct de_srom_info_leaf *il;
1788 /* download entire eeprom */
1789 for (i = 0; i < DE_EEPROM_WORDS; i++)
1790 ((__le16 *)ee_data)[i] =
1791 cpu_to_le16(tulip_read_eeprom(de->regs, i, ee_addr_size));
1793 /* DEC now has a specification but early board makers
1794 just put the address in the first EEPROM locations. */
1795 /* This does memcmp(eedata, eedata+16, 8) */
1797 #ifndef CONFIG_MIPS_COBALT
1799 for (i = 0; i < 8; i ++)
1800 if (ee_data[i] != ee_data[16+i])
1805 /* store MAC address */
1806 for (i = 0; i < 6; i ++)
1807 de->dev->dev_addr[i] = ee_data[i + sa_offset];
1809 /* get offset of controller 0 info leaf. ignore 2nd byte. */
1810 ofs = ee_data[SROMC0InfoLeaf];
1811 if (ofs >= (sizeof(ee_data) - sizeof(struct de_srom_info_leaf) - sizeof(struct de_srom_media_block)))
1814 /* get pointer to info leaf */
1815 il = (struct de_srom_info_leaf *) &ee_data[ofs];
1817 /* paranoia checks */
1818 if (il->n_blocks == 0)
1820 if ((sizeof(ee_data) - ofs) <
1821 (sizeof(struct de_srom_info_leaf) + (sizeof(struct de_srom_media_block) * il->n_blocks)))
1824 /* get default media type */
1825 switch (get_unaligned(&il->default_media)) {
1826 case 0x0001: de->media_type = DE_MEDIA_BNC; break;
1827 case 0x0002: de->media_type = DE_MEDIA_AUI; break;
1828 case 0x0204: de->media_type = DE_MEDIA_TP_FD; break;
1829 default: de->media_type = DE_MEDIA_TP_AUTO; break;
1832 if (netif_msg_probe(de))
1833 pr_info("de%d: SROM leaf offset %u, default media %s\n",
1834 de->board_idx, ofs, media_name[de->media_type]);
1836 /* init SIA register values to defaults */
1837 for (i = 0; i < DE_MAX_MEDIA; i++) {
1838 de->media[i].type = DE_MEDIA_INVALID;
1839 de->media[i].csr13 = 0xffff;
1840 de->media[i].csr14 = 0xffff;
1841 de->media[i].csr15 = 0xffff;
1844 /* parse media blocks to see what medias are supported,
1845 * and if any custom CSR values are provided
1847 bufp = ((void *)il) + sizeof(*il);
1848 for (i = 0; i < il->n_blocks; i++) {
1849 struct de_srom_media_block *ib = bufp;
1852 /* index based on media type in media block */
1853 switch(ib->opts & MediaBlockMask) {
1854 case 0: /* 10baseT */
1855 de->media_supported |= SUPPORTED_TP | SUPPORTED_10baseT_Half
1856 | SUPPORTED_Autoneg;
1858 de->media[DE_MEDIA_TP_AUTO].type = DE_MEDIA_TP_AUTO;
1861 de->media_supported |= SUPPORTED_BNC;
1865 de->media_supported |= SUPPORTED_AUI;
1868 case 4: /* 10baseT-FD */
1869 de->media_supported |= SUPPORTED_TP | SUPPORTED_10baseT_Full
1870 | SUPPORTED_Autoneg;
1871 idx = DE_MEDIA_TP_FD;
1872 de->media[DE_MEDIA_TP_AUTO].type = DE_MEDIA_TP_AUTO;
1878 de->media[idx].type = idx;
1880 if (netif_msg_probe(de))
1881 pr_info("de%d: media block #%u: %s",
1883 media_name[de->media[idx].type]);
1885 bufp += sizeof (ib->opts);
1887 if (ib->opts & MediaCustomCSRs) {
1888 de->media[idx].csr13 = get_unaligned(&ib->csr13);
1889 de->media[idx].csr14 = get_unaligned(&ib->csr14);
1890 de->media[idx].csr15 = get_unaligned(&ib->csr15);
1891 bufp += sizeof(ib->csr13) + sizeof(ib->csr14) +
1894 if (netif_msg_probe(de))
1895 pr_cont(" (%x,%x,%x)\n",
1896 de->media[idx].csr13,
1897 de->media[idx].csr14,
1898 de->media[idx].csr15);
1900 } else if (netif_msg_probe(de))
1903 if (bufp > ((void *)&ee_data[DE_EEPROM_SIZE - 3]))
1907 de->media_advertise = de->media_supported;
1910 /* fill in defaults, for cases where custom CSRs not used */
1911 for (i = 0; i < DE_MAX_MEDIA; i++) {
1912 if (de->media[i].csr13 == 0xffff)
1913 de->media[i].csr13 = t21041_csr13[i];
1914 if (de->media[i].csr14 == 0xffff)
1915 de->media[i].csr14 = t21041_csr14[i];
1916 if (de->media[i].csr15 == 0xffff)
1917 de->media[i].csr15 = t21041_csr15[i];
1920 de->ee_data = kmemdup(&ee_data[0], DE_EEPROM_SIZE, GFP_KERNEL);
1925 /* for error cases, it's ok to assume we support all these */
1926 for (i = 0; i < DE_MAX_MEDIA; i++)
1927 de->media[i].type = i;
1928 de->media_supported =
1929 SUPPORTED_10baseT_Half |
1930 SUPPORTED_10baseT_Full |
1938 static const struct net_device_ops de_netdev_ops = {
1939 .ndo_open = de_open,
1940 .ndo_stop = de_close,
1941 .ndo_set_multicast_list = de_set_rx_mode,
1942 .ndo_start_xmit = de_start_xmit,
1943 .ndo_get_stats = de_get_stats,
1944 .ndo_tx_timeout = de_tx_timeout,
1945 .ndo_change_mtu = eth_change_mtu,
1946 .ndo_set_mac_address = eth_mac_addr,
1947 .ndo_validate_addr = eth_validate_addr,
1950 static int __devinit de_init_one (struct pci_dev *pdev,
1951 const struct pci_device_id *ent)
1953 struct net_device *dev;
1954 struct de_private *de;
1957 unsigned long pciaddr;
1958 static int board_idx = -1;
1964 printk("%s", version);
1967 /* allocate a new ethernet device structure, and fill in defaults */
1968 dev = alloc_etherdev(sizeof(struct de_private));
1972 dev->netdev_ops = &de_netdev_ops;
1973 SET_NETDEV_DEV(dev, &pdev->dev);
1974 dev->ethtool_ops = &de_ethtool_ops;
1975 dev->watchdog_timeo = TX_TIMEOUT;
1977 de = netdev_priv(dev);
1978 de->de21040 = ent->driver_data == 0 ? 1 : 0;
1981 de->msg_enable = (debug < 0 ? DE_DEF_MSG_ENABLE : debug);
1982 de->board_idx = board_idx;
1983 spin_lock_init (&de->lock);
1984 init_timer(&de->media_timer);
1986 de->media_timer.function = de21040_media_timer;
1988 de->media_timer.function = de21041_media_timer;
1989 de->media_timer.data = (unsigned long) de;
1991 netif_carrier_off(dev);
1992 netif_stop_queue(dev);
1994 /* wake up device, assign resources */
1995 rc = pci_enable_device(pdev);
1999 /* reserve PCI resources to ensure driver atomicity */
2000 rc = pci_request_regions(pdev, DRV_NAME);
2002 goto err_out_disable;
2004 /* check for invalid IRQ value */
2005 if (pdev->irq < 2) {
2007 pr_err(PFX "invalid irq (%d) for pci dev %s\n",
2008 pdev->irq, pci_name(pdev));
2012 dev->irq = pdev->irq;
2014 /* obtain and check validity of PCI I/O address */
2015 pciaddr = pci_resource_start(pdev, 1);
2018 pr_err(PFX "no MMIO resource for pci dev %s\n", pci_name(pdev));
2021 if (pci_resource_len(pdev, 1) < DE_REGS_SIZE) {
2023 pr_err(PFX "MMIO resource (%llx) too small on pci dev %s\n",
2024 (unsigned long long)pci_resource_len(pdev, 1),
2029 /* remap CSR registers */
2030 regs = ioremap_nocache(pciaddr, DE_REGS_SIZE);
2033 pr_err(PFX "Cannot map PCI MMIO (%llx@%lx) on pci dev %s\n",
2034 (unsigned long long)pci_resource_len(pdev, 1),
2035 pciaddr, pci_name(pdev));
2038 dev->base_addr = (unsigned long) regs;
2041 de_adapter_wake(de);
2043 /* make sure hardware is not running */
2044 rc = de_reset_mac(de);
2046 pr_err(PFX "Cannot reset MAC, pci dev %s\n", pci_name(pdev));
2050 /* get MAC address, initialize default media type and
2051 * get list of supported media
2054 de21040_get_mac_address(de);
2055 de21040_get_media_info(de);
2057 de21041_get_srom_info(de);
2060 /* register new network interface with kernel */
2061 rc = register_netdev(dev);
2065 /* print info about board and interface just registered */
2066 dev_info(&dev->dev, "%s at 0x%lx, %pM, IRQ %d\n",
2067 de->de21040 ? "21040" : "21041",
2072 pci_set_drvdata(pdev, dev);
2074 /* enable busmastering */
2075 pci_set_master(pdev);
2077 /* put adapter to sleep */
2078 de_adapter_sleep(de);
2086 pci_release_regions(pdev);
2088 pci_disable_device(pdev);
2094 static void __devexit de_remove_one (struct pci_dev *pdev)
2096 struct net_device *dev = pci_get_drvdata(pdev);
2097 struct de_private *de = netdev_priv(dev);
2100 unregister_netdev(dev);
2103 pci_release_regions(pdev);
2104 pci_disable_device(pdev);
2105 pci_set_drvdata(pdev, NULL);
2111 static int de_suspend (struct pci_dev *pdev, pm_message_t state)
2113 struct net_device *dev = pci_get_drvdata (pdev);
2114 struct de_private *de = netdev_priv(dev);
2117 if (netif_running (dev)) {
2118 del_timer_sync(&de->media_timer);
2120 disable_irq(dev->irq);
2121 spin_lock_irq(&de->lock);
2124 netif_stop_queue(dev);
2125 netif_device_detach(dev);
2126 netif_carrier_off(dev);
2128 spin_unlock_irq(&de->lock);
2129 enable_irq(dev->irq);
2131 /* Update the error counts. */
2134 synchronize_irq(dev->irq);
2137 de_adapter_sleep(de);
2138 pci_disable_device(pdev);
2140 netif_device_detach(dev);
2146 static int de_resume (struct pci_dev *pdev)
2148 struct net_device *dev = pci_get_drvdata (pdev);
2149 struct de_private *de = netdev_priv(dev);
2153 if (netif_device_present(dev))
2155 if (!netif_running(dev))
2157 if ((retval = pci_enable_device(pdev))) {
2158 dev_err(&dev->dev, "pci_enable_device failed in resume\n");
2163 netif_device_attach(dev);
2169 #endif /* CONFIG_PM */
2171 static struct pci_driver de_driver = {
2173 .id_table = de_pci_tbl,
2174 .probe = de_init_one,
2175 .remove = __devexit_p(de_remove_one),
2177 .suspend = de_suspend,
2178 .resume = de_resume,
2182 static int __init de_init (void)
2185 printk("%s", version);
2187 return pci_register_driver(&de_driver);
2190 static void __exit de_exit (void)
2192 pci_unregister_driver (&de_driver);
2195 module_init(de_init);
2196 module_exit(de_exit);