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>
48 #include <asm/uaccess.h>
49 #include <asm/unaligned.h>
51 /* These identify the driver base version and may not be removed. */
52 static char version[] =
53 KERN_INFO DRV_NAME " PCI Ethernet driver v" DRV_VERSION " (" DRV_RELDATE ")\n";
55 MODULE_AUTHOR("Jeff Garzik <jgarzik@pobox.com>");
56 MODULE_DESCRIPTION("Intel/Digital 21040/1 series PCI Ethernet driver");
57 MODULE_LICENSE("GPL");
58 MODULE_VERSION(DRV_VERSION);
60 static int debug = -1;
61 module_param (debug, int, 0);
62 MODULE_PARM_DESC (debug, "de2104x bitmapped message enable number");
64 /* Set the copy breakpoint for the copy-only-tiny-buffer Rx structure. */
65 #if defined(__alpha__) || defined(__arm__) || defined(__hppa__) || \
66 defined(CONFIG_SPARC) || defined(__ia64__) || \
67 defined(__sh__) || defined(__mips__)
68 static int rx_copybreak = 1518;
70 static int rx_copybreak = 100;
72 module_param (rx_copybreak, int, 0);
73 MODULE_PARM_DESC (rx_copybreak, "de2104x Breakpoint at which Rx packets are copied");
75 #define PFX DRV_NAME ": "
77 #define DE_DEF_MSG_ENABLE (NETIF_MSG_DRV | \
85 /* Descriptor skip length in 32 bit longwords. */
86 #ifndef CONFIG_DE2104X_DSL
89 #define DSL CONFIG_DE2104X_DSL
92 #define DE_RX_RING_SIZE 64
93 #define DE_TX_RING_SIZE 64
94 #define DE_RING_BYTES \
95 ((sizeof(struct de_desc) * DE_RX_RING_SIZE) + \
96 (sizeof(struct de_desc) * DE_TX_RING_SIZE))
97 #define NEXT_TX(N) (((N) + 1) & (DE_TX_RING_SIZE - 1))
98 #define NEXT_RX(N) (((N) + 1) & (DE_RX_RING_SIZE - 1))
99 #define TX_BUFFS_AVAIL(CP) \
100 (((CP)->tx_tail <= (CP)->tx_head) ? \
101 (CP)->tx_tail + (DE_TX_RING_SIZE - 1) - (CP)->tx_head : \
102 (CP)->tx_tail - (CP)->tx_head - 1)
104 #define PKT_BUF_SZ 1536 /* Size of each temporary Rx buffer.*/
107 #define DE_SETUP_SKB ((struct sk_buff *) 1)
108 #define DE_DUMMY_SKB ((struct sk_buff *) 2)
109 #define DE_SETUP_FRAME_WORDS 96
110 #define DE_EEPROM_WORDS 256
111 #define DE_EEPROM_SIZE (DE_EEPROM_WORDS * sizeof(u16))
112 #define DE_MAX_MEDIA 5
114 #define DE_MEDIA_TP_AUTO 0
115 #define DE_MEDIA_BNC 1
116 #define DE_MEDIA_AUI 2
117 #define DE_MEDIA_TP 3
118 #define DE_MEDIA_TP_FD 4
119 #define DE_MEDIA_INVALID DE_MAX_MEDIA
120 #define DE_MEDIA_FIRST 0
121 #define DE_MEDIA_LAST (DE_MAX_MEDIA - 1)
122 #define DE_AUI_BNC (SUPPORTED_AUI | SUPPORTED_BNC)
124 #define DE_TIMER_LINK (60 * HZ)
125 #define DE_TIMER_NO_LINK (5 * HZ)
127 #define DE_NUM_REGS 16
128 #define DE_REGS_SIZE (DE_NUM_REGS * sizeof(u32))
129 #define DE_REGS_VER 1
131 /* Time in jiffies before concluding the transmitter is hung. */
132 #define TX_TIMEOUT (6*HZ)
134 /* This is a mysterious value that can be written to CSR11 in the 21040 (only)
135 to support a pre-NWay full-duplex signaling mechanism using short frames.
136 No one knows what it should be, but if left at its default value some
137 10base2(!) packets trigger a full-duplex-request interrupt. */
138 #define FULL_DUPLEX_MAGIC 0x6969
161 CacheAlign16 = 0x00008000,
162 BurstLen4 = 0x00000400,
163 DescSkipLen = (DSL << 2),
166 NormalTxPoll = (1 << 0),
167 NormalRxPoll = (1 << 0),
169 /* Tx/Rx descriptor status bits */
172 RxErrLong = (1 << 7),
174 RxErrFIFO = (1 << 0),
175 RxErrRunt = (1 << 11),
176 RxErrFrame = (1 << 14),
178 FirstFrag = (1 << 29),
179 LastFrag = (1 << 30),
181 TxFIFOUnder = (1 << 1),
182 TxLinkFail = (1 << 2) | (1 << 10) | (1 << 11),
185 TxJabber = (1 << 14),
186 SetupFrame = (1 << 27),
197 TxState = (1 << 22) | (1 << 21) | (1 << 20),
198 RxState = (1 << 19) | (1 << 18) | (1 << 17),
199 LinkFail = (1 << 12),
201 RxStopped = (1 << 8),
202 TxStopped = (1 << 1),
205 TxEnable = (1 << 13),
207 RxTx = TxEnable | RxEnable,
208 FullDuplex = (1 << 9),
209 AcceptAllMulticast = (1 << 7),
210 AcceptAllPhys = (1 << 6),
212 MacModeClear = (1<<12) | (1<<11) | (1<<10) | (1<<8) | (1<<3) |
213 RxTx | BOCnt | AcceptAllPhys | AcceptAllMulticast,
216 EE_SHIFT_CLK = 0x02, /* EEPROM shift clock. */
217 EE_CS = 0x01, /* EEPROM chip select. */
218 EE_DATA_WRITE = 0x04, /* Data from the Tulip to EEPROM. */
221 EE_DATA_READ = 0x08, /* Data from the EEPROM chip. */
222 EE_ENB = (0x4800 | EE_CS),
224 /* The EEPROM commands include the alway-set leading bit. */
228 RxMissedOver = (1 << 16),
229 RxMissedMask = 0xffff,
231 /* SROM-related bits */
233 MediaBlockMask = 0x3f,
234 MediaCustomCSRs = (1 << 6),
237 PM_Sleep = (1 << 31),
238 PM_Snooze = (1 << 30),
239 PM_Mask = PM_Sleep | PM_Snooze,
242 NWayState = (1 << 14) | (1 << 13) | (1 << 12),
243 NWayRestart = (1 << 12),
244 NonselPortActive = (1 << 9),
245 LinkFailStatus = (1 << 2),
246 NetCxnErr = (1 << 1),
249 static const u32 de_intr_mask =
250 IntrOK | IntrErr | RxIntr | RxEmpty | TxIntr | TxEmpty |
251 LinkPass | LinkFail | PciErr;
254 * Set the programmable burst length to 4 longwords for all:
255 * DMA errors result without these values. Cache align 16 long.
257 static const u32 de_bus_mode = CacheAlign16 | BurstLen4 | DescSkipLen;
259 struct de_srom_media_block {
264 } __attribute__((packed));
266 struct de_srom_info_leaf {
270 } __attribute__((packed));
283 u16 type; /* DE_MEDIA_xxx */
300 struct net_device *dev;
303 struct de_desc *rx_ring;
304 struct de_desc *tx_ring;
305 struct ring_info tx_skb[DE_TX_RING_SIZE];
306 struct ring_info rx_skb[DE_RX_RING_SIZE];
312 struct net_device_stats net_stats;
314 struct pci_dev *pdev;
316 u16 setup_frame[DE_SETUP_FRAME_WORDS];
321 struct media_info media[DE_MAX_MEDIA];
322 struct timer_list media_timer;
326 unsigned de21040 : 1;
327 unsigned media_lock : 1;
331 static void de_set_rx_mode (struct net_device *dev);
332 static void de_tx (struct de_private *de);
333 static void de_clean_rings (struct de_private *de);
334 static void de_media_interrupt (struct de_private *de, u32 status);
335 static void de21040_media_timer (unsigned long data);
336 static void de21041_media_timer (unsigned long data);
337 static unsigned int de_ok_to_advertise (struct de_private *de, u32 new_media);
340 static DEFINE_PCI_DEVICE_TABLE(de_pci_tbl) = {
341 { PCI_VENDOR_ID_DEC, PCI_DEVICE_ID_DEC_TULIP,
342 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
343 { PCI_VENDOR_ID_DEC, PCI_DEVICE_ID_DEC_TULIP_PLUS,
344 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 1 },
347 MODULE_DEVICE_TABLE(pci, de_pci_tbl);
349 static const char * const media_name[DE_MAX_MEDIA] = {
357 /* 21040 transceiver register settings:
358 * TP AUTO(unused), BNC(unused), AUI, TP, TP FD*/
359 static u16 t21040_csr13[] = { 0, 0, 0x8F09, 0x8F01, 0x8F01, };
360 static u16 t21040_csr14[] = { 0, 0, 0x0705, 0xFFFF, 0xFFFD, };
361 static u16 t21040_csr15[] = { 0, 0, 0x0006, 0x0000, 0x0000, };
363 /* 21041 transceiver register settings: TP AUTO, BNC, AUI, TP, TP FD*/
364 static u16 t21041_csr13[] = { 0xEF01, 0xEF09, 0xEF09, 0xEF01, 0xEF09, };
365 static u16 t21041_csr14[] = { 0xFFFF, 0xF7FD, 0xF7FD, 0x6F3F, 0x6F3D, };
366 static u16 t21041_csr15[] = { 0x0008, 0x0006, 0x000E, 0x0008, 0x0008, };
369 #define dr32(reg) readl(de->regs + (reg))
370 #define dw32(reg,val) writel((val), de->regs + (reg))
373 static void de_rx_err_acct (struct de_private *de, unsigned rx_tail,
376 if (netif_msg_rx_err (de))
378 "%s: rx err, slot %d status 0x%x len %d\n",
379 de->dev->name, rx_tail, status, len);
381 if ((status & 0x38000300) != 0x0300) {
382 /* Ingore earlier buffers. */
383 if ((status & 0xffff) != 0x7fff) {
384 if (netif_msg_rx_err(de))
385 dev_warn(&de->dev->dev,
386 "Oversized Ethernet frame spanned multiple buffers, status %08x!\n",
388 de->net_stats.rx_length_errors++;
390 } else if (status & RxError) {
391 /* There was a fatal error. */
392 de->net_stats.rx_errors++; /* end of a packet.*/
393 if (status & 0x0890) de->net_stats.rx_length_errors++;
394 if (status & RxErrCRC) de->net_stats.rx_crc_errors++;
395 if (status & RxErrFIFO) de->net_stats.rx_fifo_errors++;
399 static void de_rx (struct de_private *de)
401 unsigned rx_tail = de->rx_tail;
402 unsigned rx_work = DE_RX_RING_SIZE;
409 struct sk_buff *skb, *copy_skb;
410 unsigned copying_skb, buflen;
412 skb = de->rx_skb[rx_tail].skb;
415 status = le32_to_cpu(de->rx_ring[rx_tail].opts1);
416 if (status & DescOwn)
419 len = ((status >> 16) & 0x7ff) - 4;
420 mapping = de->rx_skb[rx_tail].mapping;
422 if (unlikely(drop)) {
423 de->net_stats.rx_dropped++;
427 if (unlikely((status & 0x38008300) != 0x0300)) {
428 de_rx_err_acct(de, rx_tail, status, len);
432 copying_skb = (len <= rx_copybreak);
434 if (unlikely(netif_msg_rx_status(de)))
435 printk(KERN_DEBUG "%s: rx slot %d status 0x%x len %d copying? %d\n",
436 de->dev->name, rx_tail, status, len,
439 buflen = copying_skb ? (len + RX_OFFSET) : de->rx_buf_sz;
440 copy_skb = dev_alloc_skb (buflen);
441 if (unlikely(!copy_skb)) {
442 de->net_stats.rx_dropped++;
449 pci_unmap_single(de->pdev, mapping,
450 buflen, PCI_DMA_FROMDEVICE);
454 de->rx_skb[rx_tail].mapping =
455 pci_map_single(de->pdev, copy_skb->data,
456 buflen, PCI_DMA_FROMDEVICE);
457 de->rx_skb[rx_tail].skb = copy_skb;
459 pci_dma_sync_single_for_cpu(de->pdev, mapping, len, PCI_DMA_FROMDEVICE);
460 skb_reserve(copy_skb, RX_OFFSET);
461 skb_copy_from_linear_data(skb, skb_put(copy_skb, len),
463 pci_dma_sync_single_for_device(de->pdev, mapping, len, PCI_DMA_FROMDEVICE);
465 /* We'll reuse the original ring buffer. */
469 skb->protocol = eth_type_trans (skb, de->dev);
471 de->net_stats.rx_packets++;
472 de->net_stats.rx_bytes += skb->len;
474 if (rc == NET_RX_DROP)
478 if (rx_tail == (DE_RX_RING_SIZE - 1))
479 de->rx_ring[rx_tail].opts2 =
480 cpu_to_le32(RingEnd | de->rx_buf_sz);
482 de->rx_ring[rx_tail].opts2 = cpu_to_le32(de->rx_buf_sz);
483 de->rx_ring[rx_tail].addr1 = cpu_to_le32(mapping);
485 de->rx_ring[rx_tail].opts1 = cpu_to_le32(DescOwn);
486 rx_tail = NEXT_RX(rx_tail);
490 dev_warn(&de->dev->dev, "rx work limit reached\n");
492 de->rx_tail = rx_tail;
495 static irqreturn_t de_interrupt (int irq, void *dev_instance)
497 struct net_device *dev = dev_instance;
498 struct de_private *de = netdev_priv(dev);
501 status = dr32(MacStatus);
502 if ((!(status & (IntrOK|IntrErr))) || (status == 0xFFFF))
505 if (netif_msg_intr(de))
506 printk(KERN_DEBUG "%s: intr, status %08x mode %08x desc %u/%u/%u\n",
507 dev->name, status, dr32(MacMode),
508 de->rx_tail, de->tx_head, de->tx_tail);
510 dw32(MacStatus, status);
512 if (status & (RxIntr | RxEmpty)) {
514 if (status & RxEmpty)
515 dw32(RxPoll, NormalRxPoll);
518 spin_lock(&de->lock);
520 if (status & (TxIntr | TxEmpty))
523 if (status & (LinkPass | LinkFail))
524 de_media_interrupt(de, status);
526 spin_unlock(&de->lock);
528 if (status & PciErr) {
531 pci_read_config_word(de->pdev, PCI_STATUS, &pci_status);
532 pci_write_config_word(de->pdev, PCI_STATUS, pci_status);
533 dev_err(&de->dev->dev,
534 "PCI bus error, status=%08x, PCI status=%04x\n",
541 static void de_tx (struct de_private *de)
543 unsigned tx_head = de->tx_head;
544 unsigned tx_tail = de->tx_tail;
546 while (tx_tail != tx_head) {
551 status = le32_to_cpu(de->tx_ring[tx_tail].opts1);
552 if (status & DescOwn)
555 skb = de->tx_skb[tx_tail].skb;
557 if (unlikely(skb == DE_DUMMY_SKB))
560 if (unlikely(skb == DE_SETUP_SKB)) {
561 pci_unmap_single(de->pdev, de->tx_skb[tx_tail].mapping,
562 sizeof(de->setup_frame), PCI_DMA_TODEVICE);
566 pci_unmap_single(de->pdev, de->tx_skb[tx_tail].mapping,
567 skb->len, PCI_DMA_TODEVICE);
569 if (status & LastFrag) {
570 if (status & TxError) {
571 if (netif_msg_tx_err(de))
572 printk(KERN_DEBUG "%s: tx err, status 0x%x\n",
573 de->dev->name, status);
574 de->net_stats.tx_errors++;
576 de->net_stats.tx_window_errors++;
577 if (status & TxMaxCol)
578 de->net_stats.tx_aborted_errors++;
579 if (status & TxLinkFail)
580 de->net_stats.tx_carrier_errors++;
581 if (status & TxFIFOUnder)
582 de->net_stats.tx_fifo_errors++;
584 de->net_stats.tx_packets++;
585 de->net_stats.tx_bytes += skb->len;
586 if (netif_msg_tx_done(de))
587 printk(KERN_DEBUG "%s: tx done, slot %d\n",
588 de->dev->name, tx_tail);
590 dev_kfree_skb_irq(skb);
594 de->tx_skb[tx_tail].skb = NULL;
596 tx_tail = NEXT_TX(tx_tail);
599 de->tx_tail = tx_tail;
601 if (netif_queue_stopped(de->dev) && (TX_BUFFS_AVAIL(de) > (DE_TX_RING_SIZE / 4)))
602 netif_wake_queue(de->dev);
605 static netdev_tx_t de_start_xmit (struct sk_buff *skb,
606 struct net_device *dev)
608 struct de_private *de = netdev_priv(dev);
609 unsigned int entry, tx_free;
610 u32 mapping, len, flags = FirstFrag | LastFrag;
613 spin_lock_irq(&de->lock);
615 tx_free = TX_BUFFS_AVAIL(de);
617 netif_stop_queue(dev);
618 spin_unlock_irq(&de->lock);
619 return NETDEV_TX_BUSY;
625 txd = &de->tx_ring[entry];
628 mapping = pci_map_single(de->pdev, skb->data, len, PCI_DMA_TODEVICE);
629 if (entry == (DE_TX_RING_SIZE - 1))
631 if (!tx_free || (tx_free == (DE_TX_RING_SIZE / 2)))
634 txd->opts2 = cpu_to_le32(flags);
635 txd->addr1 = cpu_to_le32(mapping);
637 de->tx_skb[entry].skb = skb;
638 de->tx_skb[entry].mapping = mapping;
641 txd->opts1 = cpu_to_le32(DescOwn);
644 de->tx_head = NEXT_TX(entry);
645 if (netif_msg_tx_queued(de))
646 printk(KERN_DEBUG "%s: tx queued, slot %d, skblen %d\n",
647 dev->name, entry, skb->len);
650 netif_stop_queue(dev);
652 spin_unlock_irq(&de->lock);
654 /* Trigger an immediate transmit demand. */
655 dw32(TxPoll, NormalTxPoll);
656 dev->trans_start = jiffies;
661 /* Set or clear the multicast filter for this adaptor.
662 Note that we only use exclusion around actually queueing the
663 new frame, not around filling de->setup_frame. This is non-deterministic
664 when re-entered but still correct. */
667 #define set_bit_le(i,p) do { ((char *)(p))[(i)/8] |= (1<<((i)%8)); } while(0)
669 static void build_setup_frame_hash(u16 *setup_frm, struct net_device *dev)
671 struct de_private *de = netdev_priv(dev);
673 struct dev_mc_list *mclist;
677 memset(hash_table, 0, sizeof(hash_table));
678 set_bit_le(255, hash_table); /* Broadcast entry */
679 /* This should work on big-endian machines as well. */
680 netdev_for_each_mc_addr(mclist, dev) {
681 int index = ether_crc_le(ETH_ALEN, mclist->dmi_addr) & 0x1ff;
683 set_bit_le(index, hash_table);
686 for (i = 0; i < 32; i++) {
687 *setup_frm++ = hash_table[i];
688 *setup_frm++ = hash_table[i];
690 setup_frm = &de->setup_frame[13*6];
692 /* Fill the final entry with our physical address. */
693 eaddrs = (u16 *)dev->dev_addr;
694 *setup_frm++ = eaddrs[0]; *setup_frm++ = eaddrs[0];
695 *setup_frm++ = eaddrs[1]; *setup_frm++ = eaddrs[1];
696 *setup_frm++ = eaddrs[2]; *setup_frm++ = eaddrs[2];
699 static void build_setup_frame_perfect(u16 *setup_frm, struct net_device *dev)
701 struct de_private *de = netdev_priv(dev);
702 struct dev_mc_list *mclist;
705 /* We have <= 14 addresses so we can use the wonderful
706 16 address perfect filtering of the Tulip. */
707 netdev_for_each_mc_addr(mclist, dev) {
708 eaddrs = (u16 *)mclist->dmi_addr;
709 *setup_frm++ = *eaddrs; *setup_frm++ = *eaddrs++;
710 *setup_frm++ = *eaddrs; *setup_frm++ = *eaddrs++;
711 *setup_frm++ = *eaddrs; *setup_frm++ = *eaddrs++;
713 /* Fill the unused entries with the broadcast address. */
714 memset(setup_frm, 0xff, (15 - netdev_mc_count(dev)) * 12);
715 setup_frm = &de->setup_frame[15*6];
717 /* Fill the final entry with our physical address. */
718 eaddrs = (u16 *)dev->dev_addr;
719 *setup_frm++ = eaddrs[0]; *setup_frm++ = eaddrs[0];
720 *setup_frm++ = eaddrs[1]; *setup_frm++ = eaddrs[1];
721 *setup_frm++ = eaddrs[2]; *setup_frm++ = eaddrs[2];
725 static void __de_set_rx_mode (struct net_device *dev)
727 struct de_private *de = netdev_priv(dev);
732 struct de_desc *dummy_txd = NULL;
734 macmode = dr32(MacMode) & ~(AcceptAllMulticast | AcceptAllPhys);
736 if (dev->flags & IFF_PROMISC) { /* Set promiscuous. */
737 macmode |= AcceptAllMulticast | AcceptAllPhys;
741 if ((netdev_mc_count(dev) > 1000) || (dev->flags & IFF_ALLMULTI)) {
742 /* Too many to filter well -- accept all multicasts. */
743 macmode |= AcceptAllMulticast;
747 /* Note that only the low-address shortword of setup_frame is valid!
748 The values are doubled for big-endian architectures. */
749 if (netdev_mc_count(dev) > 14) /* Must use a multicast hash table. */
750 build_setup_frame_hash (de->setup_frame, dev);
752 build_setup_frame_perfect (de->setup_frame, dev);
755 * Now add this frame to the Tx list.
760 /* Avoid a chip errata by prefixing a dummy entry. */
762 de->tx_skb[entry].skb = DE_DUMMY_SKB;
764 dummy_txd = &de->tx_ring[entry];
765 dummy_txd->opts2 = (entry == (DE_TX_RING_SIZE - 1)) ?
766 cpu_to_le32(RingEnd) : 0;
767 dummy_txd->addr1 = 0;
769 /* Must set DescOwned later to avoid race with chip */
771 entry = NEXT_TX(entry);
774 de->tx_skb[entry].skb = DE_SETUP_SKB;
775 de->tx_skb[entry].mapping = mapping =
776 pci_map_single (de->pdev, de->setup_frame,
777 sizeof (de->setup_frame), PCI_DMA_TODEVICE);
779 /* Put the setup frame on the Tx list. */
780 txd = &de->tx_ring[entry];
781 if (entry == (DE_TX_RING_SIZE - 1))
782 txd->opts2 = cpu_to_le32(SetupFrame | RingEnd | sizeof (de->setup_frame));
784 txd->opts2 = cpu_to_le32(SetupFrame | sizeof (de->setup_frame));
785 txd->addr1 = cpu_to_le32(mapping);
788 txd->opts1 = cpu_to_le32(DescOwn);
792 dummy_txd->opts1 = cpu_to_le32(DescOwn);
796 de->tx_head = NEXT_TX(entry);
798 if (TX_BUFFS_AVAIL(de) == 0)
799 netif_stop_queue(dev);
801 /* Trigger an immediate transmit demand. */
802 dw32(TxPoll, NormalTxPoll);
805 if (macmode != dr32(MacMode))
806 dw32(MacMode, macmode);
809 static void de_set_rx_mode (struct net_device *dev)
812 struct de_private *de = netdev_priv(dev);
814 spin_lock_irqsave (&de->lock, flags);
815 __de_set_rx_mode(dev);
816 spin_unlock_irqrestore (&de->lock, flags);
819 static inline void de_rx_missed(struct de_private *de, u32 rx_missed)
821 if (unlikely(rx_missed & RxMissedOver))
822 de->net_stats.rx_missed_errors += RxMissedMask;
824 de->net_stats.rx_missed_errors += (rx_missed & RxMissedMask);
827 static void __de_get_stats(struct de_private *de)
829 u32 tmp = dr32(RxMissed); /* self-clearing */
831 de_rx_missed(de, tmp);
834 static struct net_device_stats *de_get_stats(struct net_device *dev)
836 struct de_private *de = netdev_priv(dev);
838 /* The chip only need report frame silently dropped. */
839 spin_lock_irq(&de->lock);
840 if (netif_running(dev) && netif_device_present(dev))
842 spin_unlock_irq(&de->lock);
844 return &de->net_stats;
847 static inline int de_is_running (struct de_private *de)
849 return (dr32(MacStatus) & (RxState | TxState)) ? 1 : 0;
852 static void de_stop_rxtx (struct de_private *de)
855 unsigned int i = 1300/100;
857 macmode = dr32(MacMode);
858 if (macmode & RxTx) {
859 dw32(MacMode, macmode & ~RxTx);
863 /* wait until in-flight frame completes.
864 * Max time @ 10BT: 1500*8b/10Mbps == 1200us (+ 100us margin)
865 * Typically expect this loop to end in < 50 us on 100BT.
868 if (!de_is_running(de))
873 dev_warn(&de->dev->dev, "timeout expired stopping DMA\n");
876 static inline void de_start_rxtx (struct de_private *de)
880 macmode = dr32(MacMode);
881 if ((macmode & RxTx) != RxTx) {
882 dw32(MacMode, macmode | RxTx);
887 static void de_stop_hw (struct de_private *de)
895 dw32(MacStatus, dr32(MacStatus));
900 de->tx_head = de->tx_tail = 0;
903 static void de_link_up(struct de_private *de)
905 if (!netif_carrier_ok(de->dev)) {
906 netif_carrier_on(de->dev);
907 if (netif_msg_link(de))
908 dev_info(&de->dev->dev, "link up, media %s\n",
909 media_name[de->media_type]);
913 static void de_link_down(struct de_private *de)
915 if (netif_carrier_ok(de->dev)) {
916 netif_carrier_off(de->dev);
917 if (netif_msg_link(de))
918 dev_info(&de->dev->dev, "link down\n");
922 static void de_set_media (struct de_private *de)
924 unsigned media = de->media_type;
925 u32 macmode = dr32(MacMode);
927 if (de_is_running(de))
928 dev_warn(&de->dev->dev,
929 "chip is running while changing media!\n");
932 dw32(CSR11, FULL_DUPLEX_MAGIC);
933 dw32(CSR13, 0); /* Reset phy */
934 dw32(CSR14, de->media[media].csr14);
935 dw32(CSR15, de->media[media].csr15);
936 dw32(CSR13, de->media[media].csr13);
938 /* must delay 10ms before writing to other registers,
943 if (media == DE_MEDIA_TP_FD)
944 macmode |= FullDuplex;
946 macmode &= ~FullDuplex;
948 if (netif_msg_link(de)) {
949 dev_info(&de->dev->dev, "set link %s\n", media_name[media]);
950 dev_info(&de->dev->dev, "mode 0x%x, sia 0x%x,0x%x,0x%x,0x%x\n",
951 dr32(MacMode), dr32(SIAStatus),
952 dr32(CSR13), dr32(CSR14), dr32(CSR15));
954 dev_info(&de->dev->dev,
955 "set mode 0x%x, set sia 0x%x,0x%x,0x%x\n",
956 macmode, de->media[media].csr13,
957 de->media[media].csr14, de->media[media].csr15);
959 if (macmode != dr32(MacMode))
960 dw32(MacMode, macmode);
963 static void de_next_media (struct de_private *de, u32 *media,
964 unsigned int n_media)
968 for (i = 0; i < n_media; i++) {
969 if (de_ok_to_advertise(de, media[i])) {
970 de->media_type = media[i];
976 static void de21040_media_timer (unsigned long data)
978 struct de_private *de = (struct de_private *) data;
979 struct net_device *dev = de->dev;
980 u32 status = dr32(SIAStatus);
981 unsigned int carrier;
984 carrier = (status & NetCxnErr) ? 0 : 1;
987 if (de->media_type != DE_MEDIA_AUI && (status & LinkFailStatus))
990 de->media_timer.expires = jiffies + DE_TIMER_LINK;
991 add_timer(&de->media_timer);
992 if (!netif_carrier_ok(dev))
995 if (netif_msg_timer(de))
996 dev_info(&dev->dev, "%s link ok, status %x\n",
997 media_name[de->media_type], status);
1006 if (de->media_type == DE_MEDIA_AUI) {
1007 u32 next_state = DE_MEDIA_TP;
1008 de_next_media(de, &next_state, 1);
1010 u32 next_state = DE_MEDIA_AUI;
1011 de_next_media(de, &next_state, 1);
1014 spin_lock_irqsave(&de->lock, flags);
1016 spin_unlock_irqrestore(&de->lock, flags);
1021 de->media_timer.expires = jiffies + DE_TIMER_NO_LINK;
1022 add_timer(&de->media_timer);
1024 if (netif_msg_timer(de))
1025 dev_info(&dev->dev, "no link, trying media %s, status %x\n",
1026 media_name[de->media_type], status);
1029 static unsigned int de_ok_to_advertise (struct de_private *de, u32 new_media)
1031 switch (new_media) {
1032 case DE_MEDIA_TP_AUTO:
1033 if (!(de->media_advertise & ADVERTISED_Autoneg))
1035 if (!(de->media_advertise & (ADVERTISED_10baseT_Half | ADVERTISED_10baseT_Full)))
1039 if (!(de->media_advertise & ADVERTISED_BNC))
1043 if (!(de->media_advertise & ADVERTISED_AUI))
1047 if (!(de->media_advertise & ADVERTISED_10baseT_Half))
1050 case DE_MEDIA_TP_FD:
1051 if (!(de->media_advertise & ADVERTISED_10baseT_Full))
1059 static void de21041_media_timer (unsigned long data)
1061 struct de_private *de = (struct de_private *) data;
1062 struct net_device *dev = de->dev;
1063 u32 status = dr32(SIAStatus);
1064 unsigned int carrier;
1065 unsigned long flags;
1067 carrier = (status & NetCxnErr) ? 0 : 1;
1070 if ((de->media_type == DE_MEDIA_TP_AUTO ||
1071 de->media_type == DE_MEDIA_TP ||
1072 de->media_type == DE_MEDIA_TP_FD) &&
1073 (status & LinkFailStatus))
1076 de->media_timer.expires = jiffies + DE_TIMER_LINK;
1077 add_timer(&de->media_timer);
1078 if (!netif_carrier_ok(dev))
1081 if (netif_msg_timer(de))
1083 "%s link ok, mode %x status %x\n",
1084 media_name[de->media_type],
1085 dr32(MacMode), status);
1091 /* if media type locked, don't switch media */
1095 /* if activity detected, use that as hint for new media type */
1096 if (status & NonselPortActive) {
1097 unsigned int have_media = 1;
1099 /* if AUI/BNC selected, then activity is on TP port */
1100 if (de->media_type == DE_MEDIA_AUI ||
1101 de->media_type == DE_MEDIA_BNC) {
1102 if (de_ok_to_advertise(de, DE_MEDIA_TP_AUTO))
1103 de->media_type = DE_MEDIA_TP_AUTO;
1108 /* TP selected. If there is only TP and BNC, then it's BNC */
1109 else if (((de->media_supported & DE_AUI_BNC) == SUPPORTED_BNC) &&
1110 de_ok_to_advertise(de, DE_MEDIA_BNC))
1111 de->media_type = DE_MEDIA_BNC;
1113 /* TP selected. If there is only TP and AUI, then it's AUI */
1114 else if (((de->media_supported & DE_AUI_BNC) == SUPPORTED_AUI) &&
1115 de_ok_to_advertise(de, DE_MEDIA_AUI))
1116 de->media_type = DE_MEDIA_AUI;
1118 /* otherwise, ignore the hint */
1127 * Absent or ambiguous activity hint, move to next advertised
1128 * media state. If de->media_type is left unchanged, this
1129 * simply resets the PHY and reloads the current media settings.
1131 if (de->media_type == DE_MEDIA_AUI) {
1132 u32 next_states[] = { DE_MEDIA_BNC, DE_MEDIA_TP_AUTO };
1133 de_next_media(de, next_states, ARRAY_SIZE(next_states));
1134 } else if (de->media_type == DE_MEDIA_BNC) {
1135 u32 next_states[] = { DE_MEDIA_TP_AUTO, DE_MEDIA_AUI };
1136 de_next_media(de, next_states, ARRAY_SIZE(next_states));
1138 u32 next_states[] = { DE_MEDIA_AUI, DE_MEDIA_BNC, DE_MEDIA_TP_AUTO };
1139 de_next_media(de, next_states, ARRAY_SIZE(next_states));
1143 spin_lock_irqsave(&de->lock, flags);
1145 spin_unlock_irqrestore(&de->lock, flags);
1150 de->media_timer.expires = jiffies + DE_TIMER_NO_LINK;
1151 add_timer(&de->media_timer);
1153 if (netif_msg_timer(de))
1154 dev_info(&dev->dev, "no link, trying media %s, status %x\n",
1155 media_name[de->media_type], status);
1158 static void de_media_interrupt (struct de_private *de, u32 status)
1160 if (status & LinkPass) {
1162 mod_timer(&de->media_timer, jiffies + DE_TIMER_LINK);
1166 BUG_ON(!(status & LinkFail));
1168 if (netif_carrier_ok(de->dev)) {
1170 mod_timer(&de->media_timer, jiffies + DE_TIMER_NO_LINK);
1174 static int de_reset_mac (struct de_private *de)
1179 * Reset MAC. de4x5.c and tulip.c examined for "advice"
1183 if (dr32(BusMode) == 0xffffffff)
1186 /* Reset the chip, holding bit 0 set at least 50 PCI cycles. */
1187 dw32 (BusMode, CmdReset);
1190 dw32 (BusMode, de_bus_mode);
1193 for (tmp = 0; tmp < 5; tmp++) {
1200 status = dr32(MacStatus);
1201 if (status & (RxState | TxState))
1203 if (status == 0xffffffff)
1208 static void de_adapter_wake (struct de_private *de)
1215 pci_read_config_dword(de->pdev, PCIPM, &pmctl);
1216 if (pmctl & PM_Mask) {
1218 pci_write_config_dword(de->pdev, PCIPM, pmctl);
1220 /* de4x5.c delays, so we do too */
1225 static void de_adapter_sleep (struct de_private *de)
1232 pci_read_config_dword(de->pdev, PCIPM, &pmctl);
1234 pci_write_config_dword(de->pdev, PCIPM, pmctl);
1237 static int de_init_hw (struct de_private *de)
1239 struct net_device *dev = de->dev;
1243 de_adapter_wake(de);
1245 macmode = dr32(MacMode) & ~MacModeClear;
1247 rc = de_reset_mac(de);
1251 de_set_media(de); /* reset phy */
1253 dw32(RxRingAddr, de->ring_dma);
1254 dw32(TxRingAddr, de->ring_dma + (sizeof(struct de_desc) * DE_RX_RING_SIZE));
1256 dw32(MacMode, RxTx | macmode);
1258 dr32(RxMissed); /* self-clearing */
1260 dw32(IntrMask, de_intr_mask);
1262 de_set_rx_mode(dev);
1267 static int de_refill_rx (struct de_private *de)
1271 for (i = 0; i < DE_RX_RING_SIZE; i++) {
1272 struct sk_buff *skb;
1274 skb = dev_alloc_skb(de->rx_buf_sz);
1280 de->rx_skb[i].mapping = pci_map_single(de->pdev,
1281 skb->data, de->rx_buf_sz, PCI_DMA_FROMDEVICE);
1282 de->rx_skb[i].skb = skb;
1284 de->rx_ring[i].opts1 = cpu_to_le32(DescOwn);
1285 if (i == (DE_RX_RING_SIZE - 1))
1286 de->rx_ring[i].opts2 =
1287 cpu_to_le32(RingEnd | de->rx_buf_sz);
1289 de->rx_ring[i].opts2 = cpu_to_le32(de->rx_buf_sz);
1290 de->rx_ring[i].addr1 = cpu_to_le32(de->rx_skb[i].mapping);
1291 de->rx_ring[i].addr2 = 0;
1301 static int de_init_rings (struct de_private *de)
1303 memset(de->tx_ring, 0, sizeof(struct de_desc) * DE_TX_RING_SIZE);
1304 de->tx_ring[DE_TX_RING_SIZE - 1].opts2 = cpu_to_le32(RingEnd);
1307 de->tx_head = de->tx_tail = 0;
1309 return de_refill_rx (de);
1312 static int de_alloc_rings (struct de_private *de)
1314 de->rx_ring = pci_alloc_consistent(de->pdev, DE_RING_BYTES, &de->ring_dma);
1317 de->tx_ring = &de->rx_ring[DE_RX_RING_SIZE];
1318 return de_init_rings(de);
1321 static void de_clean_rings (struct de_private *de)
1325 memset(de->rx_ring, 0, sizeof(struct de_desc) * DE_RX_RING_SIZE);
1326 de->rx_ring[DE_RX_RING_SIZE - 1].opts2 = cpu_to_le32(RingEnd);
1328 memset(de->tx_ring, 0, sizeof(struct de_desc) * DE_TX_RING_SIZE);
1329 de->tx_ring[DE_TX_RING_SIZE - 1].opts2 = cpu_to_le32(RingEnd);
1332 for (i = 0; i < DE_RX_RING_SIZE; i++) {
1333 if (de->rx_skb[i].skb) {
1334 pci_unmap_single(de->pdev, de->rx_skb[i].mapping,
1335 de->rx_buf_sz, PCI_DMA_FROMDEVICE);
1336 dev_kfree_skb(de->rx_skb[i].skb);
1340 for (i = 0; i < DE_TX_RING_SIZE; i++) {
1341 struct sk_buff *skb = de->tx_skb[i].skb;
1342 if ((skb) && (skb != DE_DUMMY_SKB)) {
1343 if (skb != DE_SETUP_SKB) {
1344 de->net_stats.tx_dropped++;
1345 pci_unmap_single(de->pdev,
1346 de->tx_skb[i].mapping,
1347 skb->len, PCI_DMA_TODEVICE);
1350 pci_unmap_single(de->pdev,
1351 de->tx_skb[i].mapping,
1352 sizeof(de->setup_frame),
1358 memset(&de->rx_skb, 0, sizeof(struct ring_info) * DE_RX_RING_SIZE);
1359 memset(&de->tx_skb, 0, sizeof(struct ring_info) * DE_TX_RING_SIZE);
1362 static void de_free_rings (struct de_private *de)
1365 pci_free_consistent(de->pdev, DE_RING_BYTES, de->rx_ring, de->ring_dma);
1370 static int de_open (struct net_device *dev)
1372 struct de_private *de = netdev_priv(dev);
1375 if (netif_msg_ifup(de))
1376 printk(KERN_DEBUG "%s: enabling interface\n", dev->name);
1378 de->rx_buf_sz = (dev->mtu <= 1500 ? PKT_BUF_SZ : dev->mtu + 32);
1380 rc = de_alloc_rings(de);
1382 dev_err(&dev->dev, "ring allocation failure, err=%d\n", rc);
1388 rc = request_irq(dev->irq, de_interrupt, IRQF_SHARED, dev->name, dev);
1390 dev_err(&dev->dev, "IRQ %d request failure, err=%d\n",
1395 rc = de_init_hw(de);
1397 dev_err(&dev->dev, "h/w init failure, err=%d\n", rc);
1398 goto err_out_free_irq;
1401 netif_start_queue(dev);
1402 mod_timer(&de->media_timer, jiffies + DE_TIMER_NO_LINK);
1407 free_irq(dev->irq, dev);
1413 static int de_close (struct net_device *dev)
1415 struct de_private *de = netdev_priv(dev);
1416 unsigned long flags;
1418 if (netif_msg_ifdown(de))
1419 printk(KERN_DEBUG "%s: disabling interface\n", dev->name);
1421 del_timer_sync(&de->media_timer);
1423 spin_lock_irqsave(&de->lock, flags);
1425 netif_stop_queue(dev);
1426 netif_carrier_off(dev);
1427 spin_unlock_irqrestore(&de->lock, flags);
1429 free_irq(dev->irq, dev);
1432 de_adapter_sleep(de);
1436 static void de_tx_timeout (struct net_device *dev)
1438 struct de_private *de = netdev_priv(dev);
1440 printk(KERN_DEBUG "%s: NIC status %08x mode %08x sia %08x desc %u/%u/%u\n",
1441 dev->name, dr32(MacStatus), dr32(MacMode), dr32(SIAStatus),
1442 de->rx_tail, de->tx_head, de->tx_tail);
1444 del_timer_sync(&de->media_timer);
1446 disable_irq(dev->irq);
1447 spin_lock_irq(&de->lock);
1450 netif_stop_queue(dev);
1451 netif_carrier_off(dev);
1453 spin_unlock_irq(&de->lock);
1454 enable_irq(dev->irq);
1456 /* Update the error counts. */
1459 synchronize_irq(dev->irq);
1466 netif_wake_queue(dev);
1469 static void __de_get_regs(struct de_private *de, u8 *buf)
1472 u32 *rbuf = (u32 *)buf;
1475 for (i = 0; i < DE_NUM_REGS; i++)
1476 rbuf[i] = dr32(i * 8);
1478 /* handle self-clearing RxMissed counter, CSR8 */
1479 de_rx_missed(de, rbuf[8]);
1482 static int __de_get_settings(struct de_private *de, struct ethtool_cmd *ecmd)
1484 ecmd->supported = de->media_supported;
1485 ecmd->transceiver = XCVR_INTERNAL;
1486 ecmd->phy_address = 0;
1487 ecmd->advertising = de->media_advertise;
1489 switch (de->media_type) {
1491 ecmd->port = PORT_AUI;
1495 ecmd->port = PORT_BNC;
1499 ecmd->port = PORT_TP;
1500 ecmd->speed = SPEED_10;
1504 if (dr32(MacMode) & FullDuplex)
1505 ecmd->duplex = DUPLEX_FULL;
1507 ecmd->duplex = DUPLEX_HALF;
1510 ecmd->autoneg = AUTONEG_DISABLE;
1512 ecmd->autoneg = AUTONEG_ENABLE;
1514 /* ignore maxtxpkt, maxrxpkt for now */
1519 static int __de_set_settings(struct de_private *de, struct ethtool_cmd *ecmd)
1522 unsigned int media_lock;
1524 if (ecmd->speed != SPEED_10 && ecmd->speed != 5 && ecmd->speed != 2)
1526 if (de->de21040 && ecmd->speed == 2)
1528 if (ecmd->duplex != DUPLEX_HALF && ecmd->duplex != DUPLEX_FULL)
1530 if (ecmd->port != PORT_TP && ecmd->port != PORT_AUI && ecmd->port != PORT_BNC)
1532 if (de->de21040 && ecmd->port == PORT_BNC)
1534 if (ecmd->transceiver != XCVR_INTERNAL)
1536 if (ecmd->autoneg != AUTONEG_DISABLE && ecmd->autoneg != AUTONEG_ENABLE)
1538 if (ecmd->advertising & ~de->media_supported)
1540 if (ecmd->autoneg == AUTONEG_ENABLE &&
1541 (!(ecmd->advertising & ADVERTISED_Autoneg)))
1544 switch (ecmd->port) {
1546 new_media = DE_MEDIA_AUI;
1547 if (!(ecmd->advertising & ADVERTISED_AUI))
1551 new_media = DE_MEDIA_BNC;
1552 if (!(ecmd->advertising & ADVERTISED_BNC))
1556 if (ecmd->autoneg == AUTONEG_ENABLE)
1557 new_media = DE_MEDIA_TP_AUTO;
1558 else if (ecmd->duplex == DUPLEX_FULL)
1559 new_media = DE_MEDIA_TP_FD;
1561 new_media = DE_MEDIA_TP;
1562 if (!(ecmd->advertising & ADVERTISED_TP))
1564 if (!(ecmd->advertising & (ADVERTISED_10baseT_Full | ADVERTISED_10baseT_Half)))
1569 media_lock = (ecmd->autoneg == AUTONEG_ENABLE) ? 0 : 1;
1571 if ((new_media == de->media_type) &&
1572 (media_lock == de->media_lock) &&
1573 (ecmd->advertising == de->media_advertise))
1574 return 0; /* nothing to change */
1579 de->media_type = new_media;
1580 de->media_lock = media_lock;
1581 de->media_advertise = ecmd->advertising;
1587 static void de_get_drvinfo (struct net_device *dev,struct ethtool_drvinfo *info)
1589 struct de_private *de = netdev_priv(dev);
1591 strcpy (info->driver, DRV_NAME);
1592 strcpy (info->version, DRV_VERSION);
1593 strcpy (info->bus_info, pci_name(de->pdev));
1594 info->eedump_len = DE_EEPROM_SIZE;
1597 static int de_get_regs_len(struct net_device *dev)
1599 return DE_REGS_SIZE;
1602 static int de_get_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
1604 struct de_private *de = netdev_priv(dev);
1607 spin_lock_irq(&de->lock);
1608 rc = __de_get_settings(de, ecmd);
1609 spin_unlock_irq(&de->lock);
1614 static int de_set_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
1616 struct de_private *de = netdev_priv(dev);
1619 spin_lock_irq(&de->lock);
1620 rc = __de_set_settings(de, ecmd);
1621 spin_unlock_irq(&de->lock);
1626 static u32 de_get_msglevel(struct net_device *dev)
1628 struct de_private *de = netdev_priv(dev);
1630 return de->msg_enable;
1633 static void de_set_msglevel(struct net_device *dev, u32 msglvl)
1635 struct de_private *de = netdev_priv(dev);
1637 de->msg_enable = msglvl;
1640 static int de_get_eeprom(struct net_device *dev,
1641 struct ethtool_eeprom *eeprom, u8 *data)
1643 struct de_private *de = netdev_priv(dev);
1647 if ((eeprom->offset != 0) || (eeprom->magic != 0) ||
1648 (eeprom->len != DE_EEPROM_SIZE))
1650 memcpy(data, de->ee_data, eeprom->len);
1655 static int de_nway_reset(struct net_device *dev)
1657 struct de_private *de = netdev_priv(dev);
1660 if (de->media_type != DE_MEDIA_TP_AUTO)
1662 if (netif_carrier_ok(de->dev))
1665 status = dr32(SIAStatus);
1666 dw32(SIAStatus, (status & ~NWayState) | NWayRestart);
1667 if (netif_msg_link(de))
1668 dev_info(&de->dev->dev, "link nway restart, status %x,%x\n",
1669 status, dr32(SIAStatus));
1673 static void de_get_regs(struct net_device *dev, struct ethtool_regs *regs,
1676 struct de_private *de = netdev_priv(dev);
1678 regs->version = (DE_REGS_VER << 2) | de->de21040;
1680 spin_lock_irq(&de->lock);
1681 __de_get_regs(de, data);
1682 spin_unlock_irq(&de->lock);
1685 static const struct ethtool_ops de_ethtool_ops = {
1686 .get_link = ethtool_op_get_link,
1687 .get_drvinfo = de_get_drvinfo,
1688 .get_regs_len = de_get_regs_len,
1689 .get_settings = de_get_settings,
1690 .set_settings = de_set_settings,
1691 .get_msglevel = de_get_msglevel,
1692 .set_msglevel = de_set_msglevel,
1693 .get_eeprom = de_get_eeprom,
1694 .nway_reset = de_nway_reset,
1695 .get_regs = de_get_regs,
1698 static void __devinit de21040_get_mac_address (struct de_private *de)
1702 dw32 (ROMCmd, 0); /* Reset the pointer with a dummy write. */
1705 for (i = 0; i < 6; i++) {
1706 int value, boguscnt = 100000;
1708 value = dr32(ROMCmd);
1709 } while (value < 0 && --boguscnt > 0);
1710 de->dev->dev_addr[i] = value;
1713 pr_warning(PFX "timeout reading 21040 MAC address byte %u\n", i);
1717 static void __devinit de21040_get_media_info(struct de_private *de)
1721 de->media_type = DE_MEDIA_TP;
1722 de->media_supported |= SUPPORTED_TP | SUPPORTED_10baseT_Full |
1723 SUPPORTED_10baseT_Half | SUPPORTED_AUI;
1724 de->media_advertise = de->media_supported;
1726 for (i = 0; i < DE_MAX_MEDIA; i++) {
1730 case DE_MEDIA_TP_FD:
1731 de->media[i].type = i;
1732 de->media[i].csr13 = t21040_csr13[i];
1733 de->media[i].csr14 = t21040_csr14[i];
1734 de->media[i].csr15 = t21040_csr15[i];
1737 de->media[i].type = DE_MEDIA_INVALID;
1743 /* Note: this routine returns extra data bits for size detection. */
1744 static unsigned __devinit tulip_read_eeprom(void __iomem *regs, int location, int addr_len)
1747 unsigned retval = 0;
1748 void __iomem *ee_addr = regs + ROMCmd;
1749 int read_cmd = location | (EE_READ_CMD << addr_len);
1751 writel(EE_ENB & ~EE_CS, ee_addr);
1752 writel(EE_ENB, ee_addr);
1754 /* Shift the read command bits out. */
1755 for (i = 4 + addr_len; i >= 0; i--) {
1756 short dataval = (read_cmd & (1 << i)) ? EE_DATA_WRITE : 0;
1757 writel(EE_ENB | dataval, ee_addr);
1759 writel(EE_ENB | dataval | EE_SHIFT_CLK, ee_addr);
1761 retval = (retval << 1) | ((readl(ee_addr) & EE_DATA_READ) ? 1 : 0);
1763 writel(EE_ENB, ee_addr);
1766 for (i = 16; i > 0; i--) {
1767 writel(EE_ENB | EE_SHIFT_CLK, ee_addr);
1769 retval = (retval << 1) | ((readl(ee_addr) & EE_DATA_READ) ? 1 : 0);
1770 writel(EE_ENB, ee_addr);
1774 /* Terminate the EEPROM access. */
1775 writel(EE_ENB & ~EE_CS, ee_addr);
1779 static void __devinit de21041_get_srom_info (struct de_private *de)
1781 unsigned i, sa_offset = 0, ofs;
1782 u8 ee_data[DE_EEPROM_SIZE + 6] = {};
1783 unsigned ee_addr_size = tulip_read_eeprom(de->regs, 0xff, 8) & 0x40000 ? 8 : 6;
1784 struct de_srom_info_leaf *il;
1787 /* download entire eeprom */
1788 for (i = 0; i < DE_EEPROM_WORDS; i++)
1789 ((__le16 *)ee_data)[i] =
1790 cpu_to_le16(tulip_read_eeprom(de->regs, i, ee_addr_size));
1792 /* DEC now has a specification but early board makers
1793 just put the address in the first EEPROM locations. */
1794 /* This does memcmp(eedata, eedata+16, 8) */
1796 #ifndef CONFIG_MIPS_COBALT
1798 for (i = 0; i < 8; i ++)
1799 if (ee_data[i] != ee_data[16+i])
1804 /* store MAC address */
1805 for (i = 0; i < 6; i ++)
1806 de->dev->dev_addr[i] = ee_data[i + sa_offset];
1808 /* get offset of controller 0 info leaf. ignore 2nd byte. */
1809 ofs = ee_data[SROMC0InfoLeaf];
1810 if (ofs >= (sizeof(ee_data) - sizeof(struct de_srom_info_leaf) - sizeof(struct de_srom_media_block)))
1813 /* get pointer to info leaf */
1814 il = (struct de_srom_info_leaf *) &ee_data[ofs];
1816 /* paranoia checks */
1817 if (il->n_blocks == 0)
1819 if ((sizeof(ee_data) - ofs) <
1820 (sizeof(struct de_srom_info_leaf) + (sizeof(struct de_srom_media_block) * il->n_blocks)))
1823 /* get default media type */
1824 switch (get_unaligned(&il->default_media)) {
1825 case 0x0001: de->media_type = DE_MEDIA_BNC; break;
1826 case 0x0002: de->media_type = DE_MEDIA_AUI; break;
1827 case 0x0204: de->media_type = DE_MEDIA_TP_FD; break;
1828 default: de->media_type = DE_MEDIA_TP_AUTO; break;
1831 if (netif_msg_probe(de))
1832 pr_info("de%d: SROM leaf offset %u, default media %s\n",
1833 de->board_idx, ofs, media_name[de->media_type]);
1835 /* init SIA register values to defaults */
1836 for (i = 0; i < DE_MAX_MEDIA; i++) {
1837 de->media[i].type = DE_MEDIA_INVALID;
1838 de->media[i].csr13 = 0xffff;
1839 de->media[i].csr14 = 0xffff;
1840 de->media[i].csr15 = 0xffff;
1843 /* parse media blocks to see what medias are supported,
1844 * and if any custom CSR values are provided
1846 bufp = ((void *)il) + sizeof(*il);
1847 for (i = 0; i < il->n_blocks; i++) {
1848 struct de_srom_media_block *ib = bufp;
1851 /* index based on media type in media block */
1852 switch(ib->opts & MediaBlockMask) {
1853 case 0: /* 10baseT */
1854 de->media_supported |= SUPPORTED_TP | SUPPORTED_10baseT_Half
1855 | SUPPORTED_Autoneg;
1857 de->media[DE_MEDIA_TP_AUTO].type = DE_MEDIA_TP_AUTO;
1860 de->media_supported |= SUPPORTED_BNC;
1864 de->media_supported |= SUPPORTED_AUI;
1867 case 4: /* 10baseT-FD */
1868 de->media_supported |= SUPPORTED_TP | SUPPORTED_10baseT_Full
1869 | SUPPORTED_Autoneg;
1870 idx = DE_MEDIA_TP_FD;
1871 de->media[DE_MEDIA_TP_AUTO].type = DE_MEDIA_TP_AUTO;
1877 de->media[idx].type = idx;
1879 if (netif_msg_probe(de))
1880 pr_info("de%d: media block #%u: %s",
1882 media_name[de->media[idx].type]);
1884 bufp += sizeof (ib->opts);
1886 if (ib->opts & MediaCustomCSRs) {
1887 de->media[idx].csr13 = get_unaligned(&ib->csr13);
1888 de->media[idx].csr14 = get_unaligned(&ib->csr14);
1889 de->media[idx].csr15 = get_unaligned(&ib->csr15);
1890 bufp += sizeof(ib->csr13) + sizeof(ib->csr14) +
1893 if (netif_msg_probe(de))
1894 pr_cont(" (%x,%x,%x)\n",
1895 de->media[idx].csr13,
1896 de->media[idx].csr14,
1897 de->media[idx].csr15);
1899 } else if (netif_msg_probe(de))
1902 if (bufp > ((void *)&ee_data[DE_EEPROM_SIZE - 3]))
1906 de->media_advertise = de->media_supported;
1909 /* fill in defaults, for cases where custom CSRs not used */
1910 for (i = 0; i < DE_MAX_MEDIA; i++) {
1911 if (de->media[i].csr13 == 0xffff)
1912 de->media[i].csr13 = t21041_csr13[i];
1913 if (de->media[i].csr14 == 0xffff)
1914 de->media[i].csr14 = t21041_csr14[i];
1915 if (de->media[i].csr15 == 0xffff)
1916 de->media[i].csr15 = t21041_csr15[i];
1919 de->ee_data = kmemdup(&ee_data[0], DE_EEPROM_SIZE, GFP_KERNEL);
1924 /* for error cases, it's ok to assume we support all these */
1925 for (i = 0; i < DE_MAX_MEDIA; i++)
1926 de->media[i].type = i;
1927 de->media_supported =
1928 SUPPORTED_10baseT_Half |
1929 SUPPORTED_10baseT_Full |
1937 static const struct net_device_ops de_netdev_ops = {
1938 .ndo_open = de_open,
1939 .ndo_stop = de_close,
1940 .ndo_set_multicast_list = de_set_rx_mode,
1941 .ndo_start_xmit = de_start_xmit,
1942 .ndo_get_stats = de_get_stats,
1943 .ndo_tx_timeout = de_tx_timeout,
1944 .ndo_change_mtu = eth_change_mtu,
1945 .ndo_set_mac_address = eth_mac_addr,
1946 .ndo_validate_addr = eth_validate_addr,
1949 static int __devinit de_init_one (struct pci_dev *pdev,
1950 const struct pci_device_id *ent)
1952 struct net_device *dev;
1953 struct de_private *de;
1956 unsigned long pciaddr;
1957 static int board_idx = -1;
1963 printk("%s", version);
1966 /* allocate a new ethernet device structure, and fill in defaults */
1967 dev = alloc_etherdev(sizeof(struct de_private));
1971 dev->netdev_ops = &de_netdev_ops;
1972 SET_NETDEV_DEV(dev, &pdev->dev);
1973 dev->ethtool_ops = &de_ethtool_ops;
1974 dev->watchdog_timeo = TX_TIMEOUT;
1976 de = netdev_priv(dev);
1977 de->de21040 = ent->driver_data == 0 ? 1 : 0;
1980 de->msg_enable = (debug < 0 ? DE_DEF_MSG_ENABLE : debug);
1981 de->board_idx = board_idx;
1982 spin_lock_init (&de->lock);
1983 init_timer(&de->media_timer);
1985 de->media_timer.function = de21040_media_timer;
1987 de->media_timer.function = de21041_media_timer;
1988 de->media_timer.data = (unsigned long) de;
1990 netif_carrier_off(dev);
1991 netif_stop_queue(dev);
1993 /* wake up device, assign resources */
1994 rc = pci_enable_device(pdev);
1998 /* reserve PCI resources to ensure driver atomicity */
1999 rc = pci_request_regions(pdev, DRV_NAME);
2001 goto err_out_disable;
2003 /* check for invalid IRQ value */
2004 if (pdev->irq < 2) {
2006 pr_err(PFX "invalid irq (%d) for pci dev %s\n",
2007 pdev->irq, pci_name(pdev));
2011 dev->irq = pdev->irq;
2013 /* obtain and check validity of PCI I/O address */
2014 pciaddr = pci_resource_start(pdev, 1);
2017 pr_err(PFX "no MMIO resource for pci dev %s\n", pci_name(pdev));
2020 if (pci_resource_len(pdev, 1) < DE_REGS_SIZE) {
2022 pr_err(PFX "MMIO resource (%llx) too small on pci dev %s\n",
2023 (unsigned long long)pci_resource_len(pdev, 1),
2028 /* remap CSR registers */
2029 regs = ioremap_nocache(pciaddr, DE_REGS_SIZE);
2032 pr_err(PFX "Cannot map PCI MMIO (%llx@%lx) on pci dev %s\n",
2033 (unsigned long long)pci_resource_len(pdev, 1),
2034 pciaddr, pci_name(pdev));
2037 dev->base_addr = (unsigned long) regs;
2040 de_adapter_wake(de);
2042 /* make sure hardware is not running */
2043 rc = de_reset_mac(de);
2045 pr_err(PFX "Cannot reset MAC, pci dev %s\n", pci_name(pdev));
2049 /* get MAC address, initialize default media type and
2050 * get list of supported media
2053 de21040_get_mac_address(de);
2054 de21040_get_media_info(de);
2056 de21041_get_srom_info(de);
2059 /* register new network interface with kernel */
2060 rc = register_netdev(dev);
2064 /* print info about board and interface just registered */
2065 dev_info(&dev->dev, "%s at 0x%lx, %pM, IRQ %d\n",
2066 de->de21040 ? "21040" : "21041",
2071 pci_set_drvdata(pdev, dev);
2073 /* enable busmastering */
2074 pci_set_master(pdev);
2076 /* put adapter to sleep */
2077 de_adapter_sleep(de);
2085 pci_release_regions(pdev);
2087 pci_disable_device(pdev);
2093 static void __devexit de_remove_one (struct pci_dev *pdev)
2095 struct net_device *dev = pci_get_drvdata(pdev);
2096 struct de_private *de = netdev_priv(dev);
2099 unregister_netdev(dev);
2102 pci_release_regions(pdev);
2103 pci_disable_device(pdev);
2104 pci_set_drvdata(pdev, NULL);
2110 static int de_suspend (struct pci_dev *pdev, pm_message_t state)
2112 struct net_device *dev = pci_get_drvdata (pdev);
2113 struct de_private *de = netdev_priv(dev);
2116 if (netif_running (dev)) {
2117 del_timer_sync(&de->media_timer);
2119 disable_irq(dev->irq);
2120 spin_lock_irq(&de->lock);
2123 netif_stop_queue(dev);
2124 netif_device_detach(dev);
2125 netif_carrier_off(dev);
2127 spin_unlock_irq(&de->lock);
2128 enable_irq(dev->irq);
2130 /* Update the error counts. */
2133 synchronize_irq(dev->irq);
2136 de_adapter_sleep(de);
2137 pci_disable_device(pdev);
2139 netif_device_detach(dev);
2145 static int de_resume (struct pci_dev *pdev)
2147 struct net_device *dev = pci_get_drvdata (pdev);
2148 struct de_private *de = netdev_priv(dev);
2152 if (netif_device_present(dev))
2154 if (!netif_running(dev))
2156 if ((retval = pci_enable_device(pdev))) {
2157 dev_err(&dev->dev, "pci_enable_device failed in resume\n");
2162 netif_device_attach(dev);
2168 #endif /* CONFIG_PM */
2170 static struct pci_driver de_driver = {
2172 .id_table = de_pci_tbl,
2173 .probe = de_init_one,
2174 .remove = __devexit_p(de_remove_one),
2176 .suspend = de_suspend,
2177 .resume = de_resume,
2181 static int __init de_init (void)
2184 printk("%s", version);
2186 return pci_register_driver(&de_driver);
2189 static void __exit de_exit (void)
2191 pci_unregister_driver (&de_driver);
2194 module_init(de_init);
2195 module_exit(de_exit);