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 for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count;
681 i++, mclist = mclist->next) {
682 int index = ether_crc_le(ETH_ALEN, mclist->dmi_addr) & 0x1ff;
684 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];
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;
707 /* We have <= 14 addresses so we can use the wonderful
708 16 address perfect filtering of the Tulip. */
709 for (i = 0, mclist = dev->mc_list; i < dev->mc_count;
710 i++, mclist = mclist->next) {
711 eaddrs = (u16 *)mclist->dmi_addr;
712 *setup_frm++ = *eaddrs; *setup_frm++ = *eaddrs++;
713 *setup_frm++ = *eaddrs; *setup_frm++ = *eaddrs++;
714 *setup_frm++ = *eaddrs; *setup_frm++ = *eaddrs++;
716 /* Fill the unused entries with the broadcast address. */
717 memset(setup_frm, 0xff, (15-i)*12);
718 setup_frm = &de->setup_frame[15*6];
720 /* Fill the final entry with our physical address. */
721 eaddrs = (u16 *)dev->dev_addr;
722 *setup_frm++ = eaddrs[0]; *setup_frm++ = eaddrs[0];
723 *setup_frm++ = eaddrs[1]; *setup_frm++ = eaddrs[1];
724 *setup_frm++ = eaddrs[2]; *setup_frm++ = eaddrs[2];
728 static void __de_set_rx_mode (struct net_device *dev)
730 struct de_private *de = netdev_priv(dev);
735 struct de_desc *dummy_txd = NULL;
737 macmode = dr32(MacMode) & ~(AcceptAllMulticast | AcceptAllPhys);
739 if (dev->flags & IFF_PROMISC) { /* Set promiscuous. */
740 macmode |= AcceptAllMulticast | AcceptAllPhys;
744 if ((dev->mc_count > 1000) || (dev->flags & IFF_ALLMULTI)) {
745 /* Too many to filter well -- accept all multicasts. */
746 macmode |= AcceptAllMulticast;
750 /* Note that only the low-address shortword of setup_frame is valid!
751 The values are doubled for big-endian architectures. */
752 if (dev->mc_count > 14) /* Must use a multicast hash table. */
753 build_setup_frame_hash (de->setup_frame, dev);
755 build_setup_frame_perfect (de->setup_frame, dev);
758 * Now add this frame to the Tx list.
763 /* Avoid a chip errata by prefixing a dummy entry. */
765 de->tx_skb[entry].skb = DE_DUMMY_SKB;
767 dummy_txd = &de->tx_ring[entry];
768 dummy_txd->opts2 = (entry == (DE_TX_RING_SIZE - 1)) ?
769 cpu_to_le32(RingEnd) : 0;
770 dummy_txd->addr1 = 0;
772 /* Must set DescOwned later to avoid race with chip */
774 entry = NEXT_TX(entry);
777 de->tx_skb[entry].skb = DE_SETUP_SKB;
778 de->tx_skb[entry].mapping = mapping =
779 pci_map_single (de->pdev, de->setup_frame,
780 sizeof (de->setup_frame), PCI_DMA_TODEVICE);
782 /* Put the setup frame on the Tx list. */
783 txd = &de->tx_ring[entry];
784 if (entry == (DE_TX_RING_SIZE - 1))
785 txd->opts2 = cpu_to_le32(SetupFrame | RingEnd | sizeof (de->setup_frame));
787 txd->opts2 = cpu_to_le32(SetupFrame | sizeof (de->setup_frame));
788 txd->addr1 = cpu_to_le32(mapping);
791 txd->opts1 = cpu_to_le32(DescOwn);
795 dummy_txd->opts1 = cpu_to_le32(DescOwn);
799 de->tx_head = NEXT_TX(entry);
801 if (TX_BUFFS_AVAIL(de) == 0)
802 netif_stop_queue(dev);
804 /* Trigger an immediate transmit demand. */
805 dw32(TxPoll, NormalTxPoll);
808 if (macmode != dr32(MacMode))
809 dw32(MacMode, macmode);
812 static void de_set_rx_mode (struct net_device *dev)
815 struct de_private *de = netdev_priv(dev);
817 spin_lock_irqsave (&de->lock, flags);
818 __de_set_rx_mode(dev);
819 spin_unlock_irqrestore (&de->lock, flags);
822 static inline void de_rx_missed(struct de_private *de, u32 rx_missed)
824 if (unlikely(rx_missed & RxMissedOver))
825 de->net_stats.rx_missed_errors += RxMissedMask;
827 de->net_stats.rx_missed_errors += (rx_missed & RxMissedMask);
830 static void __de_get_stats(struct de_private *de)
832 u32 tmp = dr32(RxMissed); /* self-clearing */
834 de_rx_missed(de, tmp);
837 static struct net_device_stats *de_get_stats(struct net_device *dev)
839 struct de_private *de = netdev_priv(dev);
841 /* The chip only need report frame silently dropped. */
842 spin_lock_irq(&de->lock);
843 if (netif_running(dev) && netif_device_present(dev))
845 spin_unlock_irq(&de->lock);
847 return &de->net_stats;
850 static inline int de_is_running (struct de_private *de)
852 return (dr32(MacStatus) & (RxState | TxState)) ? 1 : 0;
855 static void de_stop_rxtx (struct de_private *de)
858 unsigned int i = 1300/100;
860 macmode = dr32(MacMode);
861 if (macmode & RxTx) {
862 dw32(MacMode, macmode & ~RxTx);
866 /* wait until in-flight frame completes.
867 * Max time @ 10BT: 1500*8b/10Mbps == 1200us (+ 100us margin)
868 * Typically expect this loop to end in < 50 us on 100BT.
871 if (!de_is_running(de))
876 dev_warn(&de->dev->dev, "timeout expired stopping DMA\n");
879 static inline void de_start_rxtx (struct de_private *de)
883 macmode = dr32(MacMode);
884 if ((macmode & RxTx) != RxTx) {
885 dw32(MacMode, macmode | RxTx);
890 static void de_stop_hw (struct de_private *de)
898 dw32(MacStatus, dr32(MacStatus));
903 de->tx_head = de->tx_tail = 0;
906 static void de_link_up(struct de_private *de)
908 if (!netif_carrier_ok(de->dev)) {
909 netif_carrier_on(de->dev);
910 if (netif_msg_link(de))
911 dev_info(&de->dev->dev, "link up, media %s\n",
912 media_name[de->media_type]);
916 static void de_link_down(struct de_private *de)
918 if (netif_carrier_ok(de->dev)) {
919 netif_carrier_off(de->dev);
920 if (netif_msg_link(de))
921 dev_info(&de->dev->dev, "link down\n");
925 static void de_set_media (struct de_private *de)
927 unsigned media = de->media_type;
928 u32 macmode = dr32(MacMode);
930 if (de_is_running(de))
931 dev_warn(&de->dev->dev,
932 "chip is running while changing media!\n");
935 dw32(CSR11, FULL_DUPLEX_MAGIC);
936 dw32(CSR13, 0); /* Reset phy */
937 dw32(CSR14, de->media[media].csr14);
938 dw32(CSR15, de->media[media].csr15);
939 dw32(CSR13, de->media[media].csr13);
941 /* must delay 10ms before writing to other registers,
946 if (media == DE_MEDIA_TP_FD)
947 macmode |= FullDuplex;
949 macmode &= ~FullDuplex;
951 if (netif_msg_link(de)) {
952 dev_info(&de->dev->dev, "set link %s\n", media_name[media]);
953 dev_info(&de->dev->dev, "mode 0x%x, sia 0x%x,0x%x,0x%x,0x%x\n",
954 dr32(MacMode), dr32(SIAStatus),
955 dr32(CSR13), dr32(CSR14), dr32(CSR15));
957 dev_info(&de->dev->dev,
958 "set mode 0x%x, set sia 0x%x,0x%x,0x%x\n",
959 macmode, de->media[media].csr13,
960 de->media[media].csr14, de->media[media].csr15);
962 if (macmode != dr32(MacMode))
963 dw32(MacMode, macmode);
966 static void de_next_media (struct de_private *de, u32 *media,
967 unsigned int n_media)
971 for (i = 0; i < n_media; i++) {
972 if (de_ok_to_advertise(de, media[i])) {
973 de->media_type = media[i];
979 static void de21040_media_timer (unsigned long data)
981 struct de_private *de = (struct de_private *) data;
982 struct net_device *dev = de->dev;
983 u32 status = dr32(SIAStatus);
984 unsigned int carrier;
987 carrier = (status & NetCxnErr) ? 0 : 1;
990 if (de->media_type != DE_MEDIA_AUI && (status & LinkFailStatus))
993 de->media_timer.expires = jiffies + DE_TIMER_LINK;
994 add_timer(&de->media_timer);
995 if (!netif_carrier_ok(dev))
998 if (netif_msg_timer(de))
999 dev_info(&dev->dev, "%s link ok, status %x\n",
1000 media_name[de->media_type], status);
1009 if (de->media_type == DE_MEDIA_AUI) {
1010 u32 next_state = DE_MEDIA_TP;
1011 de_next_media(de, &next_state, 1);
1013 u32 next_state = DE_MEDIA_AUI;
1014 de_next_media(de, &next_state, 1);
1017 spin_lock_irqsave(&de->lock, flags);
1019 spin_unlock_irqrestore(&de->lock, flags);
1024 de->media_timer.expires = jiffies + DE_TIMER_NO_LINK;
1025 add_timer(&de->media_timer);
1027 if (netif_msg_timer(de))
1028 dev_info(&dev->dev, "no link, trying media %s, status %x\n",
1029 media_name[de->media_type], status);
1032 static unsigned int de_ok_to_advertise (struct de_private *de, u32 new_media)
1034 switch (new_media) {
1035 case DE_MEDIA_TP_AUTO:
1036 if (!(de->media_advertise & ADVERTISED_Autoneg))
1038 if (!(de->media_advertise & (ADVERTISED_10baseT_Half | ADVERTISED_10baseT_Full)))
1042 if (!(de->media_advertise & ADVERTISED_BNC))
1046 if (!(de->media_advertise & ADVERTISED_AUI))
1050 if (!(de->media_advertise & ADVERTISED_10baseT_Half))
1053 case DE_MEDIA_TP_FD:
1054 if (!(de->media_advertise & ADVERTISED_10baseT_Full))
1062 static void de21041_media_timer (unsigned long data)
1064 struct de_private *de = (struct de_private *) data;
1065 struct net_device *dev = de->dev;
1066 u32 status = dr32(SIAStatus);
1067 unsigned int carrier;
1068 unsigned long flags;
1070 carrier = (status & NetCxnErr) ? 0 : 1;
1073 if ((de->media_type == DE_MEDIA_TP_AUTO ||
1074 de->media_type == DE_MEDIA_TP ||
1075 de->media_type == DE_MEDIA_TP_FD) &&
1076 (status & LinkFailStatus))
1079 de->media_timer.expires = jiffies + DE_TIMER_LINK;
1080 add_timer(&de->media_timer);
1081 if (!netif_carrier_ok(dev))
1084 if (netif_msg_timer(de))
1086 "%s link ok, mode %x status %x\n",
1087 media_name[de->media_type],
1088 dr32(MacMode), status);
1094 /* if media type locked, don't switch media */
1098 /* if activity detected, use that as hint for new media type */
1099 if (status & NonselPortActive) {
1100 unsigned int have_media = 1;
1102 /* if AUI/BNC selected, then activity is on TP port */
1103 if (de->media_type == DE_MEDIA_AUI ||
1104 de->media_type == DE_MEDIA_BNC) {
1105 if (de_ok_to_advertise(de, DE_MEDIA_TP_AUTO))
1106 de->media_type = DE_MEDIA_TP_AUTO;
1111 /* TP selected. If there is only TP and BNC, then it's BNC */
1112 else if (((de->media_supported & DE_AUI_BNC) == SUPPORTED_BNC) &&
1113 de_ok_to_advertise(de, DE_MEDIA_BNC))
1114 de->media_type = DE_MEDIA_BNC;
1116 /* TP selected. If there is only TP and AUI, then it's AUI */
1117 else if (((de->media_supported & DE_AUI_BNC) == SUPPORTED_AUI) &&
1118 de_ok_to_advertise(de, DE_MEDIA_AUI))
1119 de->media_type = DE_MEDIA_AUI;
1121 /* otherwise, ignore the hint */
1130 * Absent or ambiguous activity hint, move to next advertised
1131 * media state. If de->media_type is left unchanged, this
1132 * simply resets the PHY and reloads the current media settings.
1134 if (de->media_type == DE_MEDIA_AUI) {
1135 u32 next_states[] = { DE_MEDIA_BNC, DE_MEDIA_TP_AUTO };
1136 de_next_media(de, next_states, ARRAY_SIZE(next_states));
1137 } else if (de->media_type == DE_MEDIA_BNC) {
1138 u32 next_states[] = { DE_MEDIA_TP_AUTO, DE_MEDIA_AUI };
1139 de_next_media(de, next_states, ARRAY_SIZE(next_states));
1141 u32 next_states[] = { DE_MEDIA_AUI, DE_MEDIA_BNC, DE_MEDIA_TP_AUTO };
1142 de_next_media(de, next_states, ARRAY_SIZE(next_states));
1146 spin_lock_irqsave(&de->lock, flags);
1148 spin_unlock_irqrestore(&de->lock, flags);
1153 de->media_timer.expires = jiffies + DE_TIMER_NO_LINK;
1154 add_timer(&de->media_timer);
1156 if (netif_msg_timer(de))
1157 dev_info(&dev->dev, "no link, trying media %s, status %x\n",
1158 media_name[de->media_type], status);
1161 static void de_media_interrupt (struct de_private *de, u32 status)
1163 if (status & LinkPass) {
1165 mod_timer(&de->media_timer, jiffies + DE_TIMER_LINK);
1169 BUG_ON(!(status & LinkFail));
1171 if (netif_carrier_ok(de->dev)) {
1173 mod_timer(&de->media_timer, jiffies + DE_TIMER_NO_LINK);
1177 static int de_reset_mac (struct de_private *de)
1182 * Reset MAC. de4x5.c and tulip.c examined for "advice"
1186 if (dr32(BusMode) == 0xffffffff)
1189 /* Reset the chip, holding bit 0 set at least 50 PCI cycles. */
1190 dw32 (BusMode, CmdReset);
1193 dw32 (BusMode, de_bus_mode);
1196 for (tmp = 0; tmp < 5; tmp++) {
1203 status = dr32(MacStatus);
1204 if (status & (RxState | TxState))
1206 if (status == 0xffffffff)
1211 static void de_adapter_wake (struct de_private *de)
1218 pci_read_config_dword(de->pdev, PCIPM, &pmctl);
1219 if (pmctl & PM_Mask) {
1221 pci_write_config_dword(de->pdev, PCIPM, pmctl);
1223 /* de4x5.c delays, so we do too */
1228 static void de_adapter_sleep (struct de_private *de)
1235 pci_read_config_dword(de->pdev, PCIPM, &pmctl);
1237 pci_write_config_dword(de->pdev, PCIPM, pmctl);
1240 static int de_init_hw (struct de_private *de)
1242 struct net_device *dev = de->dev;
1246 de_adapter_wake(de);
1248 macmode = dr32(MacMode) & ~MacModeClear;
1250 rc = de_reset_mac(de);
1254 de_set_media(de); /* reset phy */
1256 dw32(RxRingAddr, de->ring_dma);
1257 dw32(TxRingAddr, de->ring_dma + (sizeof(struct de_desc) * DE_RX_RING_SIZE));
1259 dw32(MacMode, RxTx | macmode);
1261 dr32(RxMissed); /* self-clearing */
1263 dw32(IntrMask, de_intr_mask);
1265 de_set_rx_mode(dev);
1270 static int de_refill_rx (struct de_private *de)
1274 for (i = 0; i < DE_RX_RING_SIZE; i++) {
1275 struct sk_buff *skb;
1277 skb = dev_alloc_skb(de->rx_buf_sz);
1283 de->rx_skb[i].mapping = pci_map_single(de->pdev,
1284 skb->data, de->rx_buf_sz, PCI_DMA_FROMDEVICE);
1285 de->rx_skb[i].skb = skb;
1287 de->rx_ring[i].opts1 = cpu_to_le32(DescOwn);
1288 if (i == (DE_RX_RING_SIZE - 1))
1289 de->rx_ring[i].opts2 =
1290 cpu_to_le32(RingEnd | de->rx_buf_sz);
1292 de->rx_ring[i].opts2 = cpu_to_le32(de->rx_buf_sz);
1293 de->rx_ring[i].addr1 = cpu_to_le32(de->rx_skb[i].mapping);
1294 de->rx_ring[i].addr2 = 0;
1304 static int de_init_rings (struct de_private *de)
1306 memset(de->tx_ring, 0, sizeof(struct de_desc) * DE_TX_RING_SIZE);
1307 de->tx_ring[DE_TX_RING_SIZE - 1].opts2 = cpu_to_le32(RingEnd);
1310 de->tx_head = de->tx_tail = 0;
1312 return de_refill_rx (de);
1315 static int de_alloc_rings (struct de_private *de)
1317 de->rx_ring = pci_alloc_consistent(de->pdev, DE_RING_BYTES, &de->ring_dma);
1320 de->tx_ring = &de->rx_ring[DE_RX_RING_SIZE];
1321 return de_init_rings(de);
1324 static void de_clean_rings (struct de_private *de)
1328 memset(de->rx_ring, 0, sizeof(struct de_desc) * DE_RX_RING_SIZE);
1329 de->rx_ring[DE_RX_RING_SIZE - 1].opts2 = cpu_to_le32(RingEnd);
1331 memset(de->tx_ring, 0, sizeof(struct de_desc) * DE_TX_RING_SIZE);
1332 de->tx_ring[DE_TX_RING_SIZE - 1].opts2 = cpu_to_le32(RingEnd);
1335 for (i = 0; i < DE_RX_RING_SIZE; i++) {
1336 if (de->rx_skb[i].skb) {
1337 pci_unmap_single(de->pdev, de->rx_skb[i].mapping,
1338 de->rx_buf_sz, PCI_DMA_FROMDEVICE);
1339 dev_kfree_skb(de->rx_skb[i].skb);
1343 for (i = 0; i < DE_TX_RING_SIZE; i++) {
1344 struct sk_buff *skb = de->tx_skb[i].skb;
1345 if ((skb) && (skb != DE_DUMMY_SKB)) {
1346 if (skb != DE_SETUP_SKB) {
1347 de->net_stats.tx_dropped++;
1348 pci_unmap_single(de->pdev,
1349 de->tx_skb[i].mapping,
1350 skb->len, PCI_DMA_TODEVICE);
1353 pci_unmap_single(de->pdev,
1354 de->tx_skb[i].mapping,
1355 sizeof(de->setup_frame),
1361 memset(&de->rx_skb, 0, sizeof(struct ring_info) * DE_RX_RING_SIZE);
1362 memset(&de->tx_skb, 0, sizeof(struct ring_info) * DE_TX_RING_SIZE);
1365 static void de_free_rings (struct de_private *de)
1368 pci_free_consistent(de->pdev, DE_RING_BYTES, de->rx_ring, de->ring_dma);
1373 static int de_open (struct net_device *dev)
1375 struct de_private *de = netdev_priv(dev);
1378 if (netif_msg_ifup(de))
1379 printk(KERN_DEBUG "%s: enabling interface\n", dev->name);
1381 de->rx_buf_sz = (dev->mtu <= 1500 ? PKT_BUF_SZ : dev->mtu + 32);
1383 rc = de_alloc_rings(de);
1385 dev_err(&dev->dev, "ring allocation failure, err=%d\n", rc);
1391 rc = request_irq(dev->irq, de_interrupt, IRQF_SHARED, dev->name, dev);
1393 dev_err(&dev->dev, "IRQ %d request failure, err=%d\n",
1398 rc = de_init_hw(de);
1400 dev_err(&dev->dev, "h/w init failure, err=%d\n", rc);
1401 goto err_out_free_irq;
1404 netif_start_queue(dev);
1405 mod_timer(&de->media_timer, jiffies + DE_TIMER_NO_LINK);
1410 free_irq(dev->irq, dev);
1416 static int de_close (struct net_device *dev)
1418 struct de_private *de = netdev_priv(dev);
1419 unsigned long flags;
1421 if (netif_msg_ifdown(de))
1422 printk(KERN_DEBUG "%s: disabling interface\n", dev->name);
1424 del_timer_sync(&de->media_timer);
1426 spin_lock_irqsave(&de->lock, flags);
1428 netif_stop_queue(dev);
1429 netif_carrier_off(dev);
1430 spin_unlock_irqrestore(&de->lock, flags);
1432 free_irq(dev->irq, dev);
1435 de_adapter_sleep(de);
1439 static void de_tx_timeout (struct net_device *dev)
1441 struct de_private *de = netdev_priv(dev);
1443 printk(KERN_DEBUG "%s: NIC status %08x mode %08x sia %08x desc %u/%u/%u\n",
1444 dev->name, dr32(MacStatus), dr32(MacMode), dr32(SIAStatus),
1445 de->rx_tail, de->tx_head, de->tx_tail);
1447 del_timer_sync(&de->media_timer);
1449 disable_irq(dev->irq);
1450 spin_lock_irq(&de->lock);
1453 netif_stop_queue(dev);
1454 netif_carrier_off(dev);
1456 spin_unlock_irq(&de->lock);
1457 enable_irq(dev->irq);
1459 /* Update the error counts. */
1462 synchronize_irq(dev->irq);
1469 netif_wake_queue(dev);
1472 static void __de_get_regs(struct de_private *de, u8 *buf)
1475 u32 *rbuf = (u32 *)buf;
1478 for (i = 0; i < DE_NUM_REGS; i++)
1479 rbuf[i] = dr32(i * 8);
1481 /* handle self-clearing RxMissed counter, CSR8 */
1482 de_rx_missed(de, rbuf[8]);
1485 static int __de_get_settings(struct de_private *de, struct ethtool_cmd *ecmd)
1487 ecmd->supported = de->media_supported;
1488 ecmd->transceiver = XCVR_INTERNAL;
1489 ecmd->phy_address = 0;
1490 ecmd->advertising = de->media_advertise;
1492 switch (de->media_type) {
1494 ecmd->port = PORT_AUI;
1498 ecmd->port = PORT_BNC;
1502 ecmd->port = PORT_TP;
1503 ecmd->speed = SPEED_10;
1507 if (dr32(MacMode) & FullDuplex)
1508 ecmd->duplex = DUPLEX_FULL;
1510 ecmd->duplex = DUPLEX_HALF;
1513 ecmd->autoneg = AUTONEG_DISABLE;
1515 ecmd->autoneg = AUTONEG_ENABLE;
1517 /* ignore maxtxpkt, maxrxpkt for now */
1522 static int __de_set_settings(struct de_private *de, struct ethtool_cmd *ecmd)
1525 unsigned int media_lock;
1527 if (ecmd->speed != SPEED_10 && ecmd->speed != 5 && ecmd->speed != 2)
1529 if (de->de21040 && ecmd->speed == 2)
1531 if (ecmd->duplex != DUPLEX_HALF && ecmd->duplex != DUPLEX_FULL)
1533 if (ecmd->port != PORT_TP && ecmd->port != PORT_AUI && ecmd->port != PORT_BNC)
1535 if (de->de21040 && ecmd->port == PORT_BNC)
1537 if (ecmd->transceiver != XCVR_INTERNAL)
1539 if (ecmd->autoneg != AUTONEG_DISABLE && ecmd->autoneg != AUTONEG_ENABLE)
1541 if (ecmd->advertising & ~de->media_supported)
1543 if (ecmd->autoneg == AUTONEG_ENABLE &&
1544 (!(ecmd->advertising & ADVERTISED_Autoneg)))
1547 switch (ecmd->port) {
1549 new_media = DE_MEDIA_AUI;
1550 if (!(ecmd->advertising & ADVERTISED_AUI))
1554 new_media = DE_MEDIA_BNC;
1555 if (!(ecmd->advertising & ADVERTISED_BNC))
1559 if (ecmd->autoneg == AUTONEG_ENABLE)
1560 new_media = DE_MEDIA_TP_AUTO;
1561 else if (ecmd->duplex == DUPLEX_FULL)
1562 new_media = DE_MEDIA_TP_FD;
1564 new_media = DE_MEDIA_TP;
1565 if (!(ecmd->advertising & ADVERTISED_TP))
1567 if (!(ecmd->advertising & (ADVERTISED_10baseT_Full | ADVERTISED_10baseT_Half)))
1572 media_lock = (ecmd->autoneg == AUTONEG_ENABLE) ? 0 : 1;
1574 if ((new_media == de->media_type) &&
1575 (media_lock == de->media_lock) &&
1576 (ecmd->advertising == de->media_advertise))
1577 return 0; /* nothing to change */
1582 de->media_type = new_media;
1583 de->media_lock = media_lock;
1584 de->media_advertise = ecmd->advertising;
1590 static void de_get_drvinfo (struct net_device *dev,struct ethtool_drvinfo *info)
1592 struct de_private *de = netdev_priv(dev);
1594 strcpy (info->driver, DRV_NAME);
1595 strcpy (info->version, DRV_VERSION);
1596 strcpy (info->bus_info, pci_name(de->pdev));
1597 info->eedump_len = DE_EEPROM_SIZE;
1600 static int de_get_regs_len(struct net_device *dev)
1602 return DE_REGS_SIZE;
1605 static int de_get_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
1607 struct de_private *de = netdev_priv(dev);
1610 spin_lock_irq(&de->lock);
1611 rc = __de_get_settings(de, ecmd);
1612 spin_unlock_irq(&de->lock);
1617 static int de_set_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
1619 struct de_private *de = netdev_priv(dev);
1622 spin_lock_irq(&de->lock);
1623 rc = __de_set_settings(de, ecmd);
1624 spin_unlock_irq(&de->lock);
1629 static u32 de_get_msglevel(struct net_device *dev)
1631 struct de_private *de = netdev_priv(dev);
1633 return de->msg_enable;
1636 static void de_set_msglevel(struct net_device *dev, u32 msglvl)
1638 struct de_private *de = netdev_priv(dev);
1640 de->msg_enable = msglvl;
1643 static int de_get_eeprom(struct net_device *dev,
1644 struct ethtool_eeprom *eeprom, u8 *data)
1646 struct de_private *de = netdev_priv(dev);
1650 if ((eeprom->offset != 0) || (eeprom->magic != 0) ||
1651 (eeprom->len != DE_EEPROM_SIZE))
1653 memcpy(data, de->ee_data, eeprom->len);
1658 static int de_nway_reset(struct net_device *dev)
1660 struct de_private *de = netdev_priv(dev);
1663 if (de->media_type != DE_MEDIA_TP_AUTO)
1665 if (netif_carrier_ok(de->dev))
1668 status = dr32(SIAStatus);
1669 dw32(SIAStatus, (status & ~NWayState) | NWayRestart);
1670 if (netif_msg_link(de))
1671 dev_info(&de->dev->dev, "link nway restart, status %x,%x\n",
1672 status, dr32(SIAStatus));
1676 static void de_get_regs(struct net_device *dev, struct ethtool_regs *regs,
1679 struct de_private *de = netdev_priv(dev);
1681 regs->version = (DE_REGS_VER << 2) | de->de21040;
1683 spin_lock_irq(&de->lock);
1684 __de_get_regs(de, data);
1685 spin_unlock_irq(&de->lock);
1688 static const struct ethtool_ops de_ethtool_ops = {
1689 .get_link = ethtool_op_get_link,
1690 .get_drvinfo = de_get_drvinfo,
1691 .get_regs_len = de_get_regs_len,
1692 .get_settings = de_get_settings,
1693 .set_settings = de_set_settings,
1694 .get_msglevel = de_get_msglevel,
1695 .set_msglevel = de_set_msglevel,
1696 .get_eeprom = de_get_eeprom,
1697 .nway_reset = de_nway_reset,
1698 .get_regs = de_get_regs,
1701 static void __devinit de21040_get_mac_address (struct de_private *de)
1705 dw32 (ROMCmd, 0); /* Reset the pointer with a dummy write. */
1708 for (i = 0; i < 6; i++) {
1709 int value, boguscnt = 100000;
1711 value = dr32(ROMCmd);
1712 } while (value < 0 && --boguscnt > 0);
1713 de->dev->dev_addr[i] = value;
1716 pr_warning(PFX "timeout reading 21040 MAC address byte %u\n", i);
1720 static void __devinit de21040_get_media_info(struct de_private *de)
1724 de->media_type = DE_MEDIA_TP;
1725 de->media_supported |= SUPPORTED_TP | SUPPORTED_10baseT_Full |
1726 SUPPORTED_10baseT_Half | SUPPORTED_AUI;
1727 de->media_advertise = de->media_supported;
1729 for (i = 0; i < DE_MAX_MEDIA; i++) {
1733 case DE_MEDIA_TP_FD:
1734 de->media[i].type = i;
1735 de->media[i].csr13 = t21040_csr13[i];
1736 de->media[i].csr14 = t21040_csr14[i];
1737 de->media[i].csr15 = t21040_csr15[i];
1740 de->media[i].type = DE_MEDIA_INVALID;
1746 /* Note: this routine returns extra data bits for size detection. */
1747 static unsigned __devinit tulip_read_eeprom(void __iomem *regs, int location, int addr_len)
1750 unsigned retval = 0;
1751 void __iomem *ee_addr = regs + ROMCmd;
1752 int read_cmd = location | (EE_READ_CMD << addr_len);
1754 writel(EE_ENB & ~EE_CS, ee_addr);
1755 writel(EE_ENB, ee_addr);
1757 /* Shift the read command bits out. */
1758 for (i = 4 + addr_len; i >= 0; i--) {
1759 short dataval = (read_cmd & (1 << i)) ? EE_DATA_WRITE : 0;
1760 writel(EE_ENB | dataval, ee_addr);
1762 writel(EE_ENB | dataval | EE_SHIFT_CLK, ee_addr);
1764 retval = (retval << 1) | ((readl(ee_addr) & EE_DATA_READ) ? 1 : 0);
1766 writel(EE_ENB, ee_addr);
1769 for (i = 16; i > 0; i--) {
1770 writel(EE_ENB | EE_SHIFT_CLK, ee_addr);
1772 retval = (retval << 1) | ((readl(ee_addr) & EE_DATA_READ) ? 1 : 0);
1773 writel(EE_ENB, ee_addr);
1777 /* Terminate the EEPROM access. */
1778 writel(EE_ENB & ~EE_CS, ee_addr);
1782 static void __devinit de21041_get_srom_info (struct de_private *de)
1784 unsigned i, sa_offset = 0, ofs;
1785 u8 ee_data[DE_EEPROM_SIZE + 6] = {};
1786 unsigned ee_addr_size = tulip_read_eeprom(de->regs, 0xff, 8) & 0x40000 ? 8 : 6;
1787 struct de_srom_info_leaf *il;
1790 /* download entire eeprom */
1791 for (i = 0; i < DE_EEPROM_WORDS; i++)
1792 ((__le16 *)ee_data)[i] =
1793 cpu_to_le16(tulip_read_eeprom(de->regs, i, ee_addr_size));
1795 /* DEC now has a specification but early board makers
1796 just put the address in the first EEPROM locations. */
1797 /* This does memcmp(eedata, eedata+16, 8) */
1799 #ifndef CONFIG_MIPS_COBALT
1801 for (i = 0; i < 8; i ++)
1802 if (ee_data[i] != ee_data[16+i])
1807 /* store MAC address */
1808 for (i = 0; i < 6; i ++)
1809 de->dev->dev_addr[i] = ee_data[i + sa_offset];
1811 /* get offset of controller 0 info leaf. ignore 2nd byte. */
1812 ofs = ee_data[SROMC0InfoLeaf];
1813 if (ofs >= (sizeof(ee_data) - sizeof(struct de_srom_info_leaf) - sizeof(struct de_srom_media_block)))
1816 /* get pointer to info leaf */
1817 il = (struct de_srom_info_leaf *) &ee_data[ofs];
1819 /* paranoia checks */
1820 if (il->n_blocks == 0)
1822 if ((sizeof(ee_data) - ofs) <
1823 (sizeof(struct de_srom_info_leaf) + (sizeof(struct de_srom_media_block) * il->n_blocks)))
1826 /* get default media type */
1827 switch (get_unaligned(&il->default_media)) {
1828 case 0x0001: de->media_type = DE_MEDIA_BNC; break;
1829 case 0x0002: de->media_type = DE_MEDIA_AUI; break;
1830 case 0x0204: de->media_type = DE_MEDIA_TP_FD; break;
1831 default: de->media_type = DE_MEDIA_TP_AUTO; break;
1834 if (netif_msg_probe(de))
1835 pr_info("de%d: SROM leaf offset %u, default media %s\n",
1836 de->board_idx, ofs, media_name[de->media_type]);
1838 /* init SIA register values to defaults */
1839 for (i = 0; i < DE_MAX_MEDIA; i++) {
1840 de->media[i].type = DE_MEDIA_INVALID;
1841 de->media[i].csr13 = 0xffff;
1842 de->media[i].csr14 = 0xffff;
1843 de->media[i].csr15 = 0xffff;
1846 /* parse media blocks to see what medias are supported,
1847 * and if any custom CSR values are provided
1849 bufp = ((void *)il) + sizeof(*il);
1850 for (i = 0; i < il->n_blocks; i++) {
1851 struct de_srom_media_block *ib = bufp;
1854 /* index based on media type in media block */
1855 switch(ib->opts & MediaBlockMask) {
1856 case 0: /* 10baseT */
1857 de->media_supported |= SUPPORTED_TP | SUPPORTED_10baseT_Half
1858 | SUPPORTED_Autoneg;
1860 de->media[DE_MEDIA_TP_AUTO].type = DE_MEDIA_TP_AUTO;
1863 de->media_supported |= SUPPORTED_BNC;
1867 de->media_supported |= SUPPORTED_AUI;
1870 case 4: /* 10baseT-FD */
1871 de->media_supported |= SUPPORTED_TP | SUPPORTED_10baseT_Full
1872 | SUPPORTED_Autoneg;
1873 idx = DE_MEDIA_TP_FD;
1874 de->media[DE_MEDIA_TP_AUTO].type = DE_MEDIA_TP_AUTO;
1880 de->media[idx].type = idx;
1882 if (netif_msg_probe(de))
1883 pr_info("de%d: media block #%u: %s",
1885 media_name[de->media[idx].type]);
1887 bufp += sizeof (ib->opts);
1889 if (ib->opts & MediaCustomCSRs) {
1890 de->media[idx].csr13 = get_unaligned(&ib->csr13);
1891 de->media[idx].csr14 = get_unaligned(&ib->csr14);
1892 de->media[idx].csr15 = get_unaligned(&ib->csr15);
1893 bufp += sizeof(ib->csr13) + sizeof(ib->csr14) +
1896 if (netif_msg_probe(de))
1897 pr_cont(" (%x,%x,%x)\n",
1898 de->media[idx].csr13,
1899 de->media[idx].csr14,
1900 de->media[idx].csr15);
1902 } else if (netif_msg_probe(de))
1905 if (bufp > ((void *)&ee_data[DE_EEPROM_SIZE - 3]))
1909 de->media_advertise = de->media_supported;
1912 /* fill in defaults, for cases where custom CSRs not used */
1913 for (i = 0; i < DE_MAX_MEDIA; i++) {
1914 if (de->media[i].csr13 == 0xffff)
1915 de->media[i].csr13 = t21041_csr13[i];
1916 if (de->media[i].csr14 == 0xffff)
1917 de->media[i].csr14 = t21041_csr14[i];
1918 if (de->media[i].csr15 == 0xffff)
1919 de->media[i].csr15 = t21041_csr15[i];
1922 de->ee_data = kmemdup(&ee_data[0], DE_EEPROM_SIZE, GFP_KERNEL);
1927 /* for error cases, it's ok to assume we support all these */
1928 for (i = 0; i < DE_MAX_MEDIA; i++)
1929 de->media[i].type = i;
1930 de->media_supported =
1931 SUPPORTED_10baseT_Half |
1932 SUPPORTED_10baseT_Full |
1940 static const struct net_device_ops de_netdev_ops = {
1941 .ndo_open = de_open,
1942 .ndo_stop = de_close,
1943 .ndo_set_multicast_list = de_set_rx_mode,
1944 .ndo_start_xmit = de_start_xmit,
1945 .ndo_get_stats = de_get_stats,
1946 .ndo_tx_timeout = de_tx_timeout,
1947 .ndo_change_mtu = eth_change_mtu,
1948 .ndo_set_mac_address = eth_mac_addr,
1949 .ndo_validate_addr = eth_validate_addr,
1952 static int __devinit de_init_one (struct pci_dev *pdev,
1953 const struct pci_device_id *ent)
1955 struct net_device *dev;
1956 struct de_private *de;
1959 unsigned long pciaddr;
1960 static int board_idx = -1;
1966 printk("%s", version);
1969 /* allocate a new ethernet device structure, and fill in defaults */
1970 dev = alloc_etherdev(sizeof(struct de_private));
1974 dev->netdev_ops = &de_netdev_ops;
1975 SET_NETDEV_DEV(dev, &pdev->dev);
1976 dev->ethtool_ops = &de_ethtool_ops;
1977 dev->watchdog_timeo = TX_TIMEOUT;
1979 de = netdev_priv(dev);
1980 de->de21040 = ent->driver_data == 0 ? 1 : 0;
1983 de->msg_enable = (debug < 0 ? DE_DEF_MSG_ENABLE : debug);
1984 de->board_idx = board_idx;
1985 spin_lock_init (&de->lock);
1986 init_timer(&de->media_timer);
1988 de->media_timer.function = de21040_media_timer;
1990 de->media_timer.function = de21041_media_timer;
1991 de->media_timer.data = (unsigned long) de;
1993 netif_carrier_off(dev);
1994 netif_stop_queue(dev);
1996 /* wake up device, assign resources */
1997 rc = pci_enable_device(pdev);
2001 /* reserve PCI resources to ensure driver atomicity */
2002 rc = pci_request_regions(pdev, DRV_NAME);
2004 goto err_out_disable;
2006 /* check for invalid IRQ value */
2007 if (pdev->irq < 2) {
2009 pr_err(PFX "invalid irq (%d) for pci dev %s\n",
2010 pdev->irq, pci_name(pdev));
2014 dev->irq = pdev->irq;
2016 /* obtain and check validity of PCI I/O address */
2017 pciaddr = pci_resource_start(pdev, 1);
2020 pr_err(PFX "no MMIO resource for pci dev %s\n", pci_name(pdev));
2023 if (pci_resource_len(pdev, 1) < DE_REGS_SIZE) {
2025 pr_err(PFX "MMIO resource (%llx) too small on pci dev %s\n",
2026 (unsigned long long)pci_resource_len(pdev, 1),
2031 /* remap CSR registers */
2032 regs = ioremap_nocache(pciaddr, DE_REGS_SIZE);
2035 pr_err(PFX "Cannot map PCI MMIO (%llx@%lx) on pci dev %s\n",
2036 (unsigned long long)pci_resource_len(pdev, 1),
2037 pciaddr, pci_name(pdev));
2040 dev->base_addr = (unsigned long) regs;
2043 de_adapter_wake(de);
2045 /* make sure hardware is not running */
2046 rc = de_reset_mac(de);
2048 pr_err(PFX "Cannot reset MAC, pci dev %s\n", pci_name(pdev));
2052 /* get MAC address, initialize default media type and
2053 * get list of supported media
2056 de21040_get_mac_address(de);
2057 de21040_get_media_info(de);
2059 de21041_get_srom_info(de);
2062 /* register new network interface with kernel */
2063 rc = register_netdev(dev);
2067 /* print info about board and interface just registered */
2068 dev_info(&dev->dev, "%s at 0x%lx, %pM, IRQ %d\n",
2069 de->de21040 ? "21040" : "21041",
2074 pci_set_drvdata(pdev, dev);
2076 /* enable busmastering */
2077 pci_set_master(pdev);
2079 /* put adapter to sleep */
2080 de_adapter_sleep(de);
2088 pci_release_regions(pdev);
2090 pci_disable_device(pdev);
2096 static void __devexit de_remove_one (struct pci_dev *pdev)
2098 struct net_device *dev = pci_get_drvdata(pdev);
2099 struct de_private *de = netdev_priv(dev);
2102 unregister_netdev(dev);
2105 pci_release_regions(pdev);
2106 pci_disable_device(pdev);
2107 pci_set_drvdata(pdev, NULL);
2113 static int de_suspend (struct pci_dev *pdev, pm_message_t state)
2115 struct net_device *dev = pci_get_drvdata (pdev);
2116 struct de_private *de = netdev_priv(dev);
2119 if (netif_running (dev)) {
2120 del_timer_sync(&de->media_timer);
2122 disable_irq(dev->irq);
2123 spin_lock_irq(&de->lock);
2126 netif_stop_queue(dev);
2127 netif_device_detach(dev);
2128 netif_carrier_off(dev);
2130 spin_unlock_irq(&de->lock);
2131 enable_irq(dev->irq);
2133 /* Update the error counts. */
2136 synchronize_irq(dev->irq);
2139 de_adapter_sleep(de);
2140 pci_disable_device(pdev);
2142 netif_device_detach(dev);
2148 static int de_resume (struct pci_dev *pdev)
2150 struct net_device *dev = pci_get_drvdata (pdev);
2151 struct de_private *de = netdev_priv(dev);
2155 if (netif_device_present(dev))
2157 if (!netif_running(dev))
2159 if ((retval = pci_enable_device(pdev))) {
2160 dev_err(&dev->dev, "pci_enable_device failed in resume\n");
2165 netif_device_attach(dev);
2171 #endif /* CONFIG_PM */
2173 static struct pci_driver de_driver = {
2175 .id_table = de_pci_tbl,
2176 .probe = de_init_one,
2177 .remove = __devexit_p(de_remove_one),
2179 .suspend = de_suspend,
2180 .resume = de_resume,
2184 static int __init de_init (void)
2187 printk("%s", version);
2189 return pci_register_driver(&de_driver);
2192 static void __exit de_exit (void)
2194 pci_unregister_driver (&de_driver);
2197 module_init(de_init);
2198 module_exit(de_exit);