drivers/net/tulip/de2104x.c

   1 /* de2104x.c: A Linux PCI Ethernet driver for Intel/Digital 21040/1 chips. */
   2 /*
   3         Copyright 2001,2003 Jeff Garzik <jgarzik@pobox.com>
   4
   5         Copyright 1994, 1995 Digital Equipment Corporation.         [de4x5.c]
   6         Written/copyright 1994-2001 by Donald Becker.               [tulip.c]
   7
   8         This software may be used and distributed according to the terms of
   9         the GNU General Public License (GPL), incorporated herein by reference.
  10         Drivers based on or derived from this code fall under the GPL and must
  11         retain the authorship, copyright and license notice.  This file is not
  12         a complete program and may only be used when the entire operating
  13         system is licensed under the GPL.
  14
  15         See the file COPYING in this distribution for more information.
  16
  17         TODO, in rough priority order:
  18         * Support forcing media type with a module parameter,
  19           like dl2k.c/sundance.c
  20         * Constants (module parms?) for Rx work limit
  21         * Complete reset on PciErr
  22         * Jumbo frames / dev->change_mtu
  23         * Adjust Rx FIFO threshold and Max Rx DMA burst on Rx FIFO error
  24         * Adjust Tx FIFO threshold and Max Tx DMA burst on Tx FIFO error
  25         * Implement Tx software interrupt mitigation via
  26           Tx descriptor bit
  27
  28  */
  29
  30 #define DRV_NAME                "de2104x"
  31 #define DRV_VERSION             "0.7"
  32 #define DRV_RELDATE             "Mar 17, 2004"
  33
  34 #include <linux/module.h>
  35 #include <linux/kernel.h>
  36 #include <linux/netdevice.h>
  37 #include <linux/etherdevice.h>
  38 #include <linux/init.h>
  39 #include <linux/pci.h>
  40 #include <linux/delay.h>
  41 #include <linux/ethtool.h>
  42 #include <linux/compiler.h>
  43 #include <linux/rtnetlink.h>
  44 #include <linux/crc32.h>
  45
  46 #include <asm/io.h>
  47 #include <asm/irq.h>
  48 #include <asm/uaccess.h>
  49 #include <asm/unaligned.h>
  50
  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";
  54
  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);
  59
  60 static int debug = -1;
  61 module_param (debug, int, 0);
  62 MODULE_PARM_DESC (debug, "de2104x bitmapped message enable number");
  63
  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;
  69 #else
  70 static int rx_copybreak = 100;
  71 #endif
  72 module_param (rx_copybreak, int, 0);
  73 MODULE_PARM_DESC (rx_copybreak, "de2104x Breakpoint at which Rx packets are copied");
  74
  75 #define PFX                     DRV_NAME ": "
  76
  77 #define DE_DEF_MSG_ENABLE       (NETIF_MSG_DRV          | \
  78                                  NETIF_MSG_PROBE        | \
  79                                  NETIF_MSG_LINK         | \
  80                                  NETIF_MSG_IFDOWN       | \
  81                                  NETIF_MSG_IFUP         | \
  82                                  NETIF_MSG_RX_ERR       | \
  83                                  NETIF_MSG_TX_ERR)
  84
  85 #define DE_RX_RING_SIZE         64
  86 #define DE_TX_RING_SIZE         64
  87 #define DE_RING_BYTES           \
  88                 ((sizeof(struct de_desc) * DE_RX_RING_SIZE) +   \
  89                 (sizeof(struct de_desc) * DE_TX_RING_SIZE))
  90 #define NEXT_TX(N)              (((N) + 1) & (DE_TX_RING_SIZE - 1))
  91 #define NEXT_RX(N)              (((N) + 1) & (DE_RX_RING_SIZE - 1))
  92 #define TX_BUFFS_AVAIL(CP)                                      \
  93         (((CP)->tx_tail <= (CP)->tx_head) ?                     \
  94           (CP)->tx_tail + (DE_TX_RING_SIZE - 1) - (CP)->tx_head :       \
  95           (CP)->tx_tail - (CP)->tx_head - 1)
  96
  97 #define PKT_BUF_SZ              1536    /* Size of each temporary Rx buffer.*/
  98 #define RX_OFFSET               2
  99
 100 #define DE_SETUP_SKB            ((struct sk_buff *) 1)
 101 #define DE_DUMMY_SKB            ((struct sk_buff *) 2)
 102 #define DE_SETUP_FRAME_WORDS    96
 103 #define DE_EEPROM_WORDS         256
 104 #define DE_EEPROM_SIZE          (DE_EEPROM_WORDS * sizeof(u16))
 105 #define DE_MAX_MEDIA            5
 106
 107 #define DE_MEDIA_TP_AUTO        0
 108 #define DE_MEDIA_BNC            1
 109 #define DE_MEDIA_AUI            2
 110 #define DE_MEDIA_TP             3
 111 #define DE_MEDIA_TP_FD          4
 112 #define DE_MEDIA_INVALID        DE_MAX_MEDIA
 113 #define DE_MEDIA_FIRST          0
 114 #define DE_MEDIA_LAST           (DE_MAX_MEDIA - 1)
 115 #define DE_AUI_BNC              (SUPPORTED_AUI | SUPPORTED_BNC)
 116
 117 #define DE_TIMER_LINK           (60 * HZ)
 118 #define DE_TIMER_NO_LINK        (5 * HZ)
 119
 120 #define DE_NUM_REGS             16
 121 #define DE_REGS_SIZE            (DE_NUM_REGS * sizeof(u32))
 122 #define DE_REGS_VER             1
 123
 124 /* Time in jiffies before concluding the transmitter is hung. */
 125 #define TX_TIMEOUT              (6*HZ)
 126
 127 #define DE_UNALIGNED_16(a)      (u16)(get_unaligned((u16 *)(a)))
 128
 129 /* This is a mysterious value that can be written to CSR11 in the 21040 (only)
 130    to support a pre-NWay full-duplex signaling mechanism using short frames.
 131    No one knows what it should be, but if left at its default value some
 132    10base2(!) packets trigger a full-duplex-request interrupt. */
 133 #define FULL_DUPLEX_MAGIC       0x6969
 134
 135 enum {
 136         /* NIC registers */
 137         BusMode                 = 0x00,
 138         TxPoll                  = 0x08,
 139         RxPoll                  = 0x10,
 140         RxRingAddr              = 0x18,
 141         TxRingAddr              = 0x20,
 142         MacStatus               = 0x28,
 143         MacMode                 = 0x30,
 144         IntrMask                = 0x38,
 145         RxMissed                = 0x40,
 146         ROMCmd                  = 0x48,
 147         CSR11                   = 0x58,
 148         SIAStatus               = 0x60,
 149         CSR13                   = 0x68,
 150         CSR14                   = 0x70,
 151         CSR15                   = 0x78,
 152         PCIPM                   = 0x40,
 153
 154         /* BusMode bits */
 155         CmdReset                = (1 << 0),
 156         CacheAlign16            = 0x00008000,
 157         BurstLen4               = 0x00000400,
 158
 159         /* Rx/TxPoll bits */
 160         NormalTxPoll            = (1 << 0),
 161         NormalRxPoll            = (1 << 0),
 162
 163         /* Tx/Rx descriptor status bits */
 164         DescOwn                 = (1 << 31),
 165         RxError                 = (1 << 15),
 166         RxErrLong               = (1 << 7),
 167         RxErrCRC                = (1 << 1),
 168         RxErrFIFO               = (1 << 0),
 169         RxErrRunt               = (1 << 11),
 170         RxErrFrame              = (1 << 14),
 171         RingEnd                 = (1 << 25),
 172         FirstFrag               = (1 << 29),
 173         LastFrag                = (1 << 30),
 174         TxError                 = (1 << 15),
 175         TxFIFOUnder             = (1 << 1),
 176         TxLinkFail              = (1 << 2) | (1 << 10) | (1 << 11),
 177         TxMaxCol                = (1 << 8),
 178         TxOWC                   = (1 << 9),
 179         TxJabber                = (1 << 14),
 180         SetupFrame              = (1 << 27),
 181         TxSwInt                 = (1 << 31),
 182
 183         /* MacStatus bits */
 184         IntrOK                  = (1 << 16),
 185         IntrErr                 = (1 << 15),
 186         RxIntr                  = (1 << 6),
 187         RxEmpty                 = (1 << 7),
 188         TxIntr                  = (1 << 0),
 189         TxEmpty                 = (1 << 2),
 190         PciErr                  = (1 << 13),
 191         TxState                 = (1 << 22) | (1 << 21) | (1 << 20),
 192         RxState                 = (1 << 19) | (1 << 18) | (1 << 17),
 193         LinkFail                = (1 << 12),
 194         LinkPass                = (1 << 4),
 195         RxStopped               = (1 << 8),
 196         TxStopped               = (1 << 1),
 197
 198         /* MacMode bits */
 199         TxEnable                = (1 << 13),
 200         RxEnable                = (1 << 1),
 201         RxTx                    = TxEnable | RxEnable,
 202         FullDuplex              = (1 << 9),
 203         AcceptAllMulticast      = (1 << 7),
 204         AcceptAllPhys           = (1 << 6),
 205         BOCnt                   = (1 << 5),
 206         MacModeClear            = (1<<12) | (1<<11) | (1<<10) | (1<<8) | (1<<3) |
 207                                   RxTx | BOCnt | AcceptAllPhys | AcceptAllMulticast,
 208
 209         /* ROMCmd bits */
 210         EE_SHIFT_CLK            = 0x02, /* EEPROM shift clock. */
 211         EE_CS                   = 0x01, /* EEPROM chip select. */
 212         EE_DATA_WRITE           = 0x04, /* Data from the Tulip to EEPROM. */
 213         EE_WRITE_0              = 0x01,
 214         EE_WRITE_1              = 0x05,
 215         EE_DATA_READ            = 0x08, /* Data from the EEPROM chip. */
 216         EE_ENB                  = (0x4800 | EE_CS),
 217
 218         /* The EEPROM commands include the alway-set leading bit. */
 219         EE_READ_CMD             = 6,
 220
 221         /* RxMissed bits */
 222         RxMissedOver            = (1 << 16),
 223         RxMissedMask            = 0xffff,
 224
 225         /* SROM-related bits */
 226         SROMC0InfoLeaf          = 27,
 227         MediaBlockMask          = 0x3f,
 228         MediaCustomCSRs         = (1 << 6),
 229
 230         /* PCIPM bits */
 231         PM_Sleep                = (1 << 31),
 232         PM_Snooze               = (1 << 30),
 233         PM_Mask                 = PM_Sleep | PM_Snooze,
 234
 235         /* SIAStatus bits */
 236         NWayState               = (1 << 14) | (1 << 13) | (1 << 12),
 237         NWayRestart             = (1 << 12),
 238         NonselPortActive        = (1 << 9),
 239         LinkFailStatus          = (1 << 2),
 240         NetCxnErr               = (1 << 1),
 241 };
 242
 243 static const u32 de_intr_mask =
 244         IntrOK | IntrErr | RxIntr | RxEmpty | TxIntr | TxEmpty |
 245         LinkPass | LinkFail | PciErr;
 246
 247 /*
 248  * Set the programmable burst length to 4 longwords for all:
 249  * DMA errors result without these values. Cache align 16 long.
 250  */
 251 static const u32 de_bus_mode = CacheAlign16 | BurstLen4;
 252
 253 struct de_srom_media_block {
 254         u8                      opts;
 255         u16                     csr13;
 256         u16                     csr14;
 257         u16                     csr15;
 258 } __attribute__((packed));
 259
 260 struct de_srom_info_leaf {
 261         u16                     default_media;
 262         u8                      n_blocks;
 263         u8                      unused;
 264 } __attribute__((packed));
 265
 266 struct de_desc {
 267         __le32                  opts1;
 268         __le32                  opts2;
 269         __le32                  addr1;
 270         __le32                  addr2;
 271 };
 272
 273 struct media_info {
 274         u16                     type;   /* DE_MEDIA_xxx */
 275         u16                     csr13;
 276         u16                     csr14;
 277         u16                     csr15;
 278 };
 279
 280 struct ring_info {
 281         struct sk_buff          *skb;
 282         dma_addr_t              mapping;
 283 };
 284
 285 struct de_private {
 286         unsigned                tx_head;
 287         unsigned                tx_tail;
 288         unsigned                rx_tail;
 289
 290         void                    __iomem *regs;
 291         struct net_device       *dev;
 292         spinlock_t              lock;
 293
 294         struct de_desc          *rx_ring;
 295         struct de_desc          *tx_ring;
 296         struct ring_info        tx_skb[DE_TX_RING_SIZE];
 297         struct ring_info        rx_skb[DE_RX_RING_SIZE];
 298         unsigned                rx_buf_sz;
 299         dma_addr_t              ring_dma;
 300
 301         u32                     msg_enable;
 302
 303         struct net_device_stats net_stats;
 304
 305         struct pci_dev          *pdev;
 306
 307         u16                     setup_frame[DE_SETUP_FRAME_WORDS];
 308
 309         u32                     media_type;
 310         u32                     media_supported;
 311         u32                     media_advertise;
 312         struct media_info       media[DE_MAX_MEDIA];
 313         struct timer_list       media_timer;
 314
 315         u8                      *ee_data;
 316         unsigned                board_idx;
 317         unsigned                de21040 : 1;
 318         unsigned                media_lock : 1;
 319 };
 320
 321
 322 static void de_set_rx_mode (struct net_device *dev);
 323 static void de_tx (struct de_private *de);
 324 static void de_clean_rings (struct de_private *de);
 325 static void de_media_interrupt (struct de_private *de, u32 status);
 326 static void de21040_media_timer (unsigned long data);
 327 static void de21041_media_timer (unsigned long data);
 328 static unsigned int de_ok_to_advertise (struct de_private *de, u32 new_media);
 329
 330
 331 static struct pci_device_id de_pci_tbl[] = {
 332         { PCI_VENDOR_ID_DEC, PCI_DEVICE_ID_DEC_TULIP,
 333           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
 334         { PCI_VENDOR_ID_DEC, PCI_DEVICE_ID_DEC_TULIP_PLUS,
 335           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 1 },
 336         { },
 337 };
 338 MODULE_DEVICE_TABLE(pci, de_pci_tbl);
 339
 340 static const char * const media_name[DE_MAX_MEDIA] = {
 341         "10baseT auto",
 342         "BNC",
 343         "AUI",
 344         "10baseT-HD",
 345         "10baseT-FD"
 346 };
 347
 348 /* 21040 transceiver register settings:
 349  * TP AUTO(unused), BNC(unused), AUI, TP, TP FD*/
 350 static u16 t21040_csr13[] = { 0, 0, 0x8F09, 0x8F01, 0x8F01, };
 351 static u16 t21040_csr14[] = { 0, 0, 0x0705, 0xFFFF, 0xFFFD, };
 352 static u16 t21040_csr15[] = { 0, 0, 0x0006, 0x0000, 0x0000, };
 353
 354 /* 21041 transceiver register settings: TP AUTO, BNC, AUI, TP, TP FD*/
 355 static u16 t21041_csr13[] = { 0xEF01, 0xEF09, 0xEF09, 0xEF01, 0xEF09, };
 356 static u16 t21041_csr14[] = { 0xFFFF, 0xF7FD, 0xF7FD, 0x6F3F, 0x6F3D, };
 357 static u16 t21041_csr15[] = { 0x0008, 0x0006, 0x000E, 0x0008, 0x0008, };
 358
 359
 360 #define dr32(reg)               readl(de->regs + (reg))
 361 #define dw32(reg,val)           writel((val), de->regs + (reg))
 362
 363
 364 static void de_rx_err_acct (struct de_private *de, unsigned rx_tail,
 365                             u32 status, u32 len)
 366 {
 367         if (netif_msg_rx_err (de))
 368                 printk (KERN_DEBUG
 369                         "%s: rx err, slot %d status 0x%x len %d\n",
 370                         de->dev->name, rx_tail, status, len);
 371
 372         if ((status & 0x38000300) != 0x0300) {
 373                 /* Ingore earlier buffers. */
 374                 if ((status & 0xffff) != 0x7fff) {
 375                         if (netif_msg_rx_err(de))
 376                                 printk(KERN_WARNING "%s: Oversized Ethernet frame "
 377                                            "spanned multiple buffers, status %8.8x!\n",
 378                                            de->dev->name, status);
 379                         de->net_stats.rx_length_errors++;
 380                 }
 381         } else if (status & RxError) {
 382                 /* There was a fatal error. */
 383                 de->net_stats.rx_errors++; /* end of a packet.*/
 384                 if (status & 0x0890) de->net_stats.rx_length_errors++;
 385                 if (status & RxErrCRC) de->net_stats.rx_crc_errors++;
 386                 if (status & RxErrFIFO) de->net_stats.rx_fifo_errors++;
 387         }
 388 }
 389
 390 static void de_rx (struct de_private *de)
 391 {
 392         unsigned rx_tail = de->rx_tail;
 393         unsigned rx_work = DE_RX_RING_SIZE;
 394         unsigned drop = 0;
 395         int rc;
 396
 397         while (rx_work--) {
 398                 u32 status, len;
 399                 dma_addr_t mapping;
 400                 struct sk_buff *skb, *copy_skb;
 401                 unsigned copying_skb, buflen;
 402
 403                 skb = de->rx_skb[rx_tail].skb;
 404                 BUG_ON(!skb);
 405                 rmb();
 406                 status = le32_to_cpu(de->rx_ring[rx_tail].opts1);
 407                 if (status & DescOwn)
 408                         break;
 409
 410                 len = ((status >> 16) & 0x7ff) - 4;
 411                 mapping = de->rx_skb[rx_tail].mapping;
 412
 413                 if (unlikely(drop)) {
 414                         de->net_stats.rx_dropped++;
 415                         goto rx_next;
 416                 }
 417
 418                 if (unlikely((status & 0x38008300) != 0x0300)) {
 419                         de_rx_err_acct(de, rx_tail, status, len);
 420                         goto rx_next;
 421                 }
 422
 423                 copying_skb = (len <= rx_copybreak);
 424
 425                 if (unlikely(netif_msg_rx_status(de)))
 426                         printk(KERN_DEBUG "%s: rx slot %d status 0x%x len %d copying? %d\n",
 427                                de->dev->name, rx_tail, status, len,
 428                                copying_skb);
 429
 430                 buflen = copying_skb ? (len + RX_OFFSET) : de->rx_buf_sz;
 431                 copy_skb = dev_alloc_skb (buflen);
 432                 if (unlikely(!copy_skb)) {
 433                         de->net_stats.rx_dropped++;
 434                         drop = 1;
 435                         rx_work = 100;
 436                         goto rx_next;
 437                 }
 438
 439                 if (!copying_skb) {
 440                         pci_unmap_single(de->pdev, mapping,
 441                                          buflen, PCI_DMA_FROMDEVICE);
 442                         skb_put(skb, len);
 443
 444                         mapping =
 445                         de->rx_skb[rx_tail].mapping =
 446                                 pci_map_single(de->pdev, copy_skb->data,
 447                                                buflen, PCI_DMA_FROMDEVICE);
 448                         de->rx_skb[rx_tail].skb = copy_skb;
 449                 } else {
 450                         pci_dma_sync_single_for_cpu(de->pdev, mapping, len, PCI_DMA_FROMDEVICE);
 451                         skb_reserve(copy_skb, RX_OFFSET);
 452                         skb_copy_from_linear_data(skb, skb_put(copy_skb, len),
 453                                                   len);
 454                         pci_dma_sync_single_for_device(de->pdev, mapping, len, PCI_DMA_FROMDEVICE);
 455
 456                         /* We'll reuse the original ring buffer. */
 457                         skb = copy_skb;
 458                 }
 459
 460                 skb->protocol = eth_type_trans (skb, de->dev);
 461
 462                 de->net_stats.rx_packets++;
 463                 de->net_stats.rx_bytes += skb->len;
 464                 de->dev->last_rx = jiffies;
 465                 rc = netif_rx (skb);
 466                 if (rc == NET_RX_DROP)
 467                         drop = 1;
 468
 469 rx_next:
 470                 de->rx_ring[rx_tail].opts1 = cpu_to_le32(DescOwn);
 471                 if (rx_tail == (DE_RX_RING_SIZE - 1))
 472                         de->rx_ring[rx_tail].opts2 =
 473                                 cpu_to_le32(RingEnd | de->rx_buf_sz);
 474                 else
 475                         de->rx_ring[rx_tail].opts2 = cpu_to_le32(de->rx_buf_sz);
 476                 de->rx_ring[rx_tail].addr1 = cpu_to_le32(mapping);
 477                 rx_tail = NEXT_RX(rx_tail);
 478         }
 479
 480         if (!rx_work)
 481                 printk(KERN_WARNING "%s: rx work limit reached\n", de->dev->name);
 482
 483         de->rx_tail = rx_tail;
 484 }
 485
 486 static irqreturn_t de_interrupt (int irq, void *dev_instance)
 487 {
 488         struct net_device *dev = dev_instance;
 489         struct de_private *de = dev->priv;
 490         u32 status;
 491
 492         status = dr32(MacStatus);
 493         if ((!(status & (IntrOK|IntrErr))) || (status == 0xFFFF))
 494                 return IRQ_NONE;
 495
 496         if (netif_msg_intr(de))
 497                 printk(KERN_DEBUG "%s: intr, status %08x mode %08x desc %u/%u/%u\n",
 498                         dev->name, status, dr32(MacMode), de->rx_tail, de->tx_head, de->tx_tail);
 499
 500         dw32(MacStatus, status);
 501
 502         if (status & (RxIntr | RxEmpty)) {
 503                 de_rx(de);
 504                 if (status & RxEmpty)
 505                         dw32(RxPoll, NormalRxPoll);
 506         }
 507
 508         spin_lock(&de->lock);
 509
 510         if (status & (TxIntr | TxEmpty))
 511                 de_tx(de);
 512
 513         if (status & (LinkPass | LinkFail))
 514                 de_media_interrupt(de, status);
 515
 516         spin_unlock(&de->lock);
 517
 518         if (status & PciErr) {
 519                 u16 pci_status;
 520
 521                 pci_read_config_word(de->pdev, PCI_STATUS, &pci_status);
 522                 pci_write_config_word(de->pdev, PCI_STATUS, pci_status);
 523                 printk(KERN_ERR "%s: PCI bus error, status=%08x, PCI status=%04x\n",
 524                        dev->name, status, pci_status);
 525         }
 526
 527         return IRQ_HANDLED;
 528 }
 529
 530 static void de_tx (struct de_private *de)
 531 {
 532         unsigned tx_head = de->tx_head;
 533         unsigned tx_tail = de->tx_tail;
 534
 535         while (tx_tail != tx_head) {
 536                 struct sk_buff *skb;
 537                 u32 status;
 538
 539                 rmb();
 540                 status = le32_to_cpu(de->tx_ring[tx_tail].opts1);
 541                 if (status & DescOwn)
 542                         break;
 543
 544                 skb = de->tx_skb[tx_tail].skb;
 545                 BUG_ON(!skb);
 546                 if (unlikely(skb == DE_DUMMY_SKB))
 547                         goto next;
 548
 549                 if (unlikely(skb == DE_SETUP_SKB)) {
 550                         pci_unmap_single(de->pdev, de->tx_skb[tx_tail].mapping,
 551                                          sizeof(de->setup_frame), PCI_DMA_TODEVICE);
 552                         goto next;
 553                 }
 554
 555                 pci_unmap_single(de->pdev, de->tx_skb[tx_tail].mapping,
 556                                  skb->len, PCI_DMA_TODEVICE);
 557
 558                 if (status & LastFrag) {
 559                         if (status & TxError) {
 560                                 if (netif_msg_tx_err(de))
 561                                         printk(KERN_DEBUG "%s: tx err, status 0x%x\n",
 562                                                de->dev->name, status);
 563                                 de->net_stats.tx_errors++;
 564                                 if (status & TxOWC)
 565                                         de->net_stats.tx_window_errors++;
 566                                 if (status & TxMaxCol)
 567                                         de->net_stats.tx_aborted_errors++;
 568                                 if (status & TxLinkFail)
 569                                         de->net_stats.tx_carrier_errors++;
 570                                 if (status & TxFIFOUnder)
 571                                         de->net_stats.tx_fifo_errors++;
 572                         } else {
 573                                 de->net_stats.tx_packets++;
 574                                 de->net_stats.tx_bytes += skb->len;
 575                                 if (netif_msg_tx_done(de))
 576                                         printk(KERN_DEBUG "%s: tx done, slot %d\n", de->dev->name, tx_tail);
 577                         }
 578                         dev_kfree_skb_irq(skb);
 579                 }
 580
 581 next:
 582                 de->tx_skb[tx_tail].skb = NULL;
 583
 584                 tx_tail = NEXT_TX(tx_tail);
 585         }
 586
 587         de->tx_tail = tx_tail;
 588
 589         if (netif_queue_stopped(de->dev) && (TX_BUFFS_AVAIL(de) > (DE_TX_RING_SIZE / 4)))
 590                 netif_wake_queue(de->dev);
 591 }
 592
 593 static int de_start_xmit (struct sk_buff *skb, struct net_device *dev)
 594 {
 595         struct de_private *de = dev->priv;
 596         unsigned int entry, tx_free;
 597         u32 mapping, len, flags = FirstFrag | LastFrag;
 598         struct de_desc *txd;
 599
 600         spin_lock_irq(&de->lock);
 601
 602         tx_free = TX_BUFFS_AVAIL(de);
 603         if (tx_free == 0) {
 604                 netif_stop_queue(dev);
 605                 spin_unlock_irq(&de->lock);
 606                 return 1;
 607         }
 608         tx_free--;
 609
 610         entry = de->tx_head;
 611
 612         txd = &de->tx_ring[entry];
 613
 614         len = skb->len;
 615         mapping = pci_map_single(de->pdev, skb->data, len, PCI_DMA_TODEVICE);
 616         if (entry == (DE_TX_RING_SIZE - 1))
 617                 flags |= RingEnd;
 618         if (!tx_free || (tx_free == (DE_TX_RING_SIZE / 2)))
 619                 flags |= TxSwInt;
 620         flags |= len;
 621         txd->opts2 = cpu_to_le32(flags);
 622         txd->addr1 = cpu_to_le32(mapping);
 623
 624         de->tx_skb[entry].skb = skb;
 625         de->tx_skb[entry].mapping = mapping;
 626         wmb();
 627
 628         txd->opts1 = cpu_to_le32(DescOwn);
 629         wmb();
 630
 631         de->tx_head = NEXT_TX(entry);
 632         if (netif_msg_tx_queued(de))
 633                 printk(KERN_DEBUG "%s: tx queued, slot %d, skblen %d\n",
 634                        dev->name, entry, skb->len);
 635
 636         if (tx_free == 0)
 637                 netif_stop_queue(dev);
 638
 639         spin_unlock_irq(&de->lock);
 640
 641         /* Trigger an immediate transmit demand. */
 642         dw32(TxPoll, NormalTxPoll);
 643         dev->trans_start = jiffies;
 644
 645         return 0;
 646 }
 647
 648 /* Set or clear the multicast filter for this adaptor.
 649    Note that we only use exclusion around actually queueing the
 650    new frame, not around filling de->setup_frame.  This is non-deterministic
 651    when re-entered but still correct. */
 652
 653 #undef set_bit_le
 654 #define set_bit_le(i,p) do { ((char *)(p))[(i)/8] |= (1<<((i)%8)); } while(0)
 655
 656 static void build_setup_frame_hash(u16 *setup_frm, struct net_device *dev)
 657 {
 658         struct de_private *de = dev->priv;
 659         u16 hash_table[32];
 660         struct dev_mc_list *mclist;
 661         int i;
 662         u16 *eaddrs;
 663
 664         memset(hash_table, 0, sizeof(hash_table));
 665         set_bit_le(255, hash_table);                    /* Broadcast entry */
 666         /* This should work on big-endian machines as well. */
 667         for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count;
 668              i++, mclist = mclist->next) {
 669                 int index = ether_crc_le(ETH_ALEN, mclist->dmi_addr) & 0x1ff;
 670
 671                 set_bit_le(index, hash_table);
 672
 673                 for (i = 0; i < 32; i++) {
 674                         *setup_frm++ = hash_table[i];
 675                         *setup_frm++ = hash_table[i];
 676                 }
 677                 setup_frm = &de->setup_frame[13*6];
 678         }
 679
 680         /* Fill the final entry with our physical address. */
 681         eaddrs = (u16 *)dev->dev_addr;
 682         *setup_frm++ = eaddrs[0]; *setup_frm++ = eaddrs[0];
 683         *setup_frm++ = eaddrs[1]; *setup_frm++ = eaddrs[1];
 684         *setup_frm++ = eaddrs[2]; *setup_frm++ = eaddrs[2];
 685 }
 686
 687 static void build_setup_frame_perfect(u16 *setup_frm, struct net_device *dev)
 688 {
 689         struct de_private *de = dev->priv;
 690         struct dev_mc_list *mclist;
 691         int i;
 692         u16 *eaddrs;
 693
 694         /* We have <= 14 addresses so we can use the wonderful
 695            16 address perfect filtering of the Tulip. */
 696         for (i = 0, mclist = dev->mc_list; i < dev->mc_count;
 697              i++, mclist = mclist->next) {
 698                 eaddrs = (u16 *)mclist->dmi_addr;
 699                 *setup_frm++ = *eaddrs; *setup_frm++ = *eaddrs++;
 700                 *setup_frm++ = *eaddrs; *setup_frm++ = *eaddrs++;
 701                 *setup_frm++ = *eaddrs; *setup_frm++ = *eaddrs++;
 702         }
 703         /* Fill the unused entries with the broadcast address. */
 704         memset(setup_frm, 0xff, (15-i)*12);
 705         setup_frm = &de->setup_frame[15*6];
 706
 707         /* Fill the final entry with our physical address. */
 708         eaddrs = (u16 *)dev->dev_addr;
 709         *setup_frm++ = eaddrs[0]; *setup_frm++ = eaddrs[0];
 710         *setup_frm++ = eaddrs[1]; *setup_frm++ = eaddrs[1];
 711         *setup_frm++ = eaddrs[2]; *setup_frm++ = eaddrs[2];
 712 }
 713
 714
 715 static void __de_set_rx_mode (struct net_device *dev)
 716 {
 717         struct de_private *de = dev->priv;
 718         u32 macmode;
 719         unsigned int entry;
 720         u32 mapping;
 721         struct de_desc *txd;
 722         struct de_desc *dummy_txd = NULL;
 723
 724         macmode = dr32(MacMode) & ~(AcceptAllMulticast | AcceptAllPhys);
 725
 726         if (dev->flags & IFF_PROMISC) { /* Set promiscuous. */
 727                 macmode |= AcceptAllMulticast | AcceptAllPhys;
 728                 goto out;
 729         }
 730
 731         if ((dev->mc_count > 1000) || (dev->flags & IFF_ALLMULTI)) {
 732                 /* Too many to filter well -- accept all multicasts. */
 733                 macmode |= AcceptAllMulticast;
 734                 goto out;
 735         }
 736
 737         /* Note that only the low-address shortword of setup_frame is valid!
 738            The values are doubled for big-endian architectures. */
 739         if (dev->mc_count > 14) /* Must use a multicast hash table. */
 740                 build_setup_frame_hash (de->setup_frame, dev);
 741         else
 742                 build_setup_frame_perfect (de->setup_frame, dev);
 743
 744         /*
 745          * Now add this frame to the Tx list.
 746          */
 747
 748         entry = de->tx_head;
 749
 750         /* Avoid a chip errata by prefixing a dummy entry. */
 751         if (entry != 0) {
 752                 de->tx_skb[entry].skb = DE_DUMMY_SKB;
 753
 754                 dummy_txd = &de->tx_ring[entry];
 755                 dummy_txd->opts2 = (entry == (DE_TX_RING_SIZE - 1)) ?
 756                                    cpu_to_le32(RingEnd) : 0;
 757                 dummy_txd->addr1 = 0;
 758
 759                 /* Must set DescOwned later to avoid race with chip */
 760
 761                 entry = NEXT_TX(entry);
 762         }
 763
 764         de->tx_skb[entry].skb = DE_SETUP_SKB;
 765         de->tx_skb[entry].mapping = mapping =
 766             pci_map_single (de->pdev, de->setup_frame,
 767                             sizeof (de->setup_frame), PCI_DMA_TODEVICE);
 768
 769         /* Put the setup frame on the Tx list. */
 770         txd = &de->tx_ring[entry];
 771         if (entry == (DE_TX_RING_SIZE - 1))
 772                 txd->opts2 = cpu_to_le32(SetupFrame | RingEnd | sizeof (de->setup_frame));
 773         else
 774                 txd->opts2 = cpu_to_le32(SetupFrame | sizeof (de->setup_frame));
 775         txd->addr1 = cpu_to_le32(mapping);
 776         wmb();
 777
 778         txd->opts1 = cpu_to_le32(DescOwn);
 779         wmb();
 780
 781         if (dummy_txd) {
 782                 dummy_txd->opts1 = cpu_to_le32(DescOwn);
 783                 wmb();
 784         }
 785
 786         de->tx_head = NEXT_TX(entry);
 787
 788         if (TX_BUFFS_AVAIL(de) == 0)
 789                 netif_stop_queue(dev);
 790
 791         /* Trigger an immediate transmit demand. */
 792         dw32(TxPoll, NormalTxPoll);
 793
 794 out:
 795         if (macmode != dr32(MacMode))
 796                 dw32(MacMode, macmode);
 797 }
 798
 799 static void de_set_rx_mode (struct net_device *dev)
 800 {
 801         unsigned long flags;
 802         struct de_private *de = dev->priv;
 803
 804         spin_lock_irqsave (&de->lock, flags);
 805         __de_set_rx_mode(dev);
 806         spin_unlock_irqrestore (&de->lock, flags);
 807 }
 808
 809 static inline void de_rx_missed(struct de_private *de, u32 rx_missed)
 810 {
 811         if (unlikely(rx_missed & RxMissedOver))
 812                 de->net_stats.rx_missed_errors += RxMissedMask;
 813         else
 814                 de->net_stats.rx_missed_errors += (rx_missed & RxMissedMask);
 815 }
 816
 817 static void __de_get_stats(struct de_private *de)
 818 {
 819         u32 tmp = dr32(RxMissed); /* self-clearing */
 820
 821         de_rx_missed(de, tmp);
 822 }
 823
 824 static struct net_device_stats *de_get_stats(struct net_device *dev)
 825 {
 826         struct de_private *de = dev->priv;
 827
 828         /* The chip only need report frame silently dropped. */
 829         spin_lock_irq(&de->lock);
 830         if (netif_running(dev) && netif_device_present(dev))
 831                 __de_get_stats(de);
 832         spin_unlock_irq(&de->lock);
 833
 834         return &de->net_stats;
 835 }
 836
 837 static inline int de_is_running (struct de_private *de)
 838 {
 839         return (dr32(MacStatus) & (RxState | TxState)) ? 1 : 0;
 840 }
 841
 842 static void de_stop_rxtx (struct de_private *de)
 843 {
 844         u32 macmode;
 845         unsigned int work = 1000;
 846
 847         macmode = dr32(MacMode);
 848         if (macmode & RxTx) {
 849                 dw32(MacMode, macmode & ~RxTx);
 850                 dr32(MacMode);
 851         }
 852
 853         while (--work > 0) {
 854                 if (!de_is_running(de))
 855                         return;
 856                 cpu_relax();
 857         }
 858
 859         printk(KERN_WARNING "%s: timeout expired stopping DMA\n", de->dev->name);
 860 }
 861
 862 static inline void de_start_rxtx (struct de_private *de)
 863 {
 864         u32 macmode;
 865
 866         macmode = dr32(MacMode);
 867         if ((macmode & RxTx) != RxTx) {
 868                 dw32(MacMode, macmode | RxTx);
 869                 dr32(MacMode);
 870         }
 871 }
 872
 873 static void de_stop_hw (struct de_private *de)
 874 {
 875
 876         udelay(5);
 877         dw32(IntrMask, 0);
 878
 879         de_stop_rxtx(de);
 880
 881         dw32(MacStatus, dr32(MacStatus));
 882
 883         udelay(10);
 884
 885         de->rx_tail = 0;
 886         de->tx_head = de->tx_tail = 0;
 887 }
 888
 889 static void de_link_up(struct de_private *de)
 890 {
 891         if (!netif_carrier_ok(de->dev)) {
 892                 netif_carrier_on(de->dev);
 893                 if (netif_msg_link(de))
 894                         printk(KERN_INFO "%s: link up, media %s\n",
 895                                de->dev->name, media_name[de->media_type]);
 896         }
 897 }
 898
 899 static void de_link_down(struct de_private *de)
 900 {
 901         if (netif_carrier_ok(de->dev)) {
 902                 netif_carrier_off(de->dev);
 903                 if (netif_msg_link(de))
 904                         printk(KERN_INFO "%s: link down\n", de->dev->name);
 905         }
 906 }
 907
 908 static void de_set_media (struct de_private *de)
 909 {
 910         unsigned media = de->media_type;
 911         u32 macmode = dr32(MacMode);
 912
 913         if (de_is_running(de))
 914                 printk(KERN_WARNING "%s: chip is running while changing media!\n", de->dev->name);
 915
 916         if (de->de21040)
 917                 dw32(CSR11, FULL_DUPLEX_MAGIC);
 918         dw32(CSR13, 0); /* Reset phy */
 919         dw32(CSR14, de->media[media].csr14);
 920         dw32(CSR15, de->media[media].csr15);
 921         dw32(CSR13, de->media[media].csr13);
 922
 923         /* must delay 10ms before writing to other registers,
 924          * especially CSR6
 925          */
 926         mdelay(10);
 927
 928         if (media == DE_MEDIA_TP_FD)
 929                 macmode |= FullDuplex;
 930         else
 931                 macmode &= ~FullDuplex;
 932
 933         if (netif_msg_link(de)) {
 934                 printk(KERN_INFO "%s: set link %s\n"
 935                        KERN_INFO "%s:    mode 0x%x, sia 0x%x,0x%x,0x%x,0x%x\n"
 936                        KERN_INFO "%s:    set mode 0x%x, set sia 0x%x,0x%x,0x%x\n",
 937                        de->dev->name, media_name[media],
 938                        de->dev->name, dr32(MacMode), dr32(SIAStatus),
 939                        dr32(CSR13), dr32(CSR14), dr32(CSR15),
 940                        de->dev->name, macmode, de->media[media].csr13,
 941                        de->media[media].csr14, de->media[media].csr15);
 942         }
 943         if (macmode != dr32(MacMode))
 944                 dw32(MacMode, macmode);
 945 }
 946
 947 static void de_next_media (struct de_private *de, u32 *media,
 948                            unsigned int n_media)
 949 {
 950         unsigned int i;
 951
 952         for (i = 0; i < n_media; i++) {
 953                 if (de_ok_to_advertise(de, media[i])) {
 954                         de->media_type = media[i];
 955                         return;
 956                 }
 957         }
 958 }
 959
 960 static void de21040_media_timer (unsigned long data)
 961 {
 962         struct de_private *de = (struct de_private *) data;
 963         struct net_device *dev = de->dev;
 964         u32 status = dr32(SIAStatus);
 965         unsigned int carrier;
 966         unsigned long flags;
 967
 968         carrier = (status & NetCxnErr) ? 0 : 1;
 969
 970         if (carrier) {
 971                 if (de->media_type != DE_MEDIA_AUI && (status & LinkFailStatus))
 972                         goto no_link_yet;
 973
 974                 de->media_timer.expires = jiffies + DE_TIMER_LINK;
 975                 add_timer(&de->media_timer);
 976                 if (!netif_carrier_ok(dev))
 977                         de_link_up(de);
 978                 else
 979                         if (netif_msg_timer(de))
 980                                 printk(KERN_INFO "%s: %s link ok, status %x\n",
 981                                        dev->name, media_name[de->media_type],
 982                                        status);
 983                 return;
 984         }
 985
 986         de_link_down(de);
 987
 988         if (de->media_lock)
 989                 return;
 990
 991         if (de->media_type == DE_MEDIA_AUI) {
 992                 u32 next_state = DE_MEDIA_TP;
 993                 de_next_media(de, &next_state, 1);
 994         } else {
 995                 u32 next_state = DE_MEDIA_AUI;
 996                 de_next_media(de, &next_state, 1);
 997         }
 998
 999         spin_lock_irqsave(&de->lock, flags);
1000         de_stop_rxtx(de);
1001         spin_unlock_irqrestore(&de->lock, flags);
1002         de_set_media(de);
1003         de_start_rxtx(de);
1004
1005 no_link_yet:
1006         de->media_timer.expires = jiffies + DE_TIMER_NO_LINK;
1007         add_timer(&de->media_timer);
1008
1009         if (netif_msg_timer(de))
1010                 printk(KERN_INFO "%s: no link, trying media %s, status %x\n",
1011                        dev->name, media_name[de->media_type], status);
1012 }
1013
1014 static unsigned int de_ok_to_advertise (struct de_private *de, u32 new_media)
1015 {
1016         switch (new_media) {
1017         case DE_MEDIA_TP_AUTO:
1018                 if (!(de->media_advertise & ADVERTISED_Autoneg))
1019                         return 0;
1020                 if (!(de->media_advertise & (ADVERTISED_10baseT_Half | ADVERTISED_10baseT_Full)))
1021                         return 0;
1022                 break;
1023         case DE_MEDIA_BNC:
1024                 if (!(de->media_advertise & ADVERTISED_BNC))
1025                         return 0;
1026                 break;
1027         case DE_MEDIA_AUI:
1028                 if (!(de->media_advertise & ADVERTISED_AUI))
1029                         return 0;
1030                 break;
1031         case DE_MEDIA_TP:
1032                 if (!(de->media_advertise & ADVERTISED_10baseT_Half))
1033                         return 0;
1034                 break;
1035         case DE_MEDIA_TP_FD:
1036                 if (!(de->media_advertise & ADVERTISED_10baseT_Full))
1037                         return 0;
1038                 break;
1039         }
1040
1041         return 1;
1042 }
1043
1044 static void de21041_media_timer (unsigned long data)
1045 {
1046         struct de_private *de = (struct de_private *) data;
1047         struct net_device *dev = de->dev;
1048         u32 status = dr32(SIAStatus);
1049         unsigned int carrier;
1050         unsigned long flags;
1051
1052         carrier = (status & NetCxnErr) ? 0 : 1;
1053
1054         if (carrier) {
1055                 if ((de->media_type == DE_MEDIA_TP_AUTO ||
1056                      de->media_type == DE_MEDIA_TP ||
1057                      de->media_type == DE_MEDIA_TP_FD) &&
1058                     (status & LinkFailStatus))
1059                         goto no_link_yet;
1060
1061                 de->media_timer.expires = jiffies + DE_TIMER_LINK;
1062                 add_timer(&de->media_timer);
1063                 if (!netif_carrier_ok(dev))
1064                         de_link_up(de);
1065                 else
1066                         if (netif_msg_timer(de))
1067                                 printk(KERN_INFO "%s: %s link ok, mode %x status %x\n",
1068                                        dev->name, media_name[de->media_type],
1069                                        dr32(MacMode), status);
1070                 return;
1071         }
1072
1073         de_link_down(de);
1074
1075         /* if media type locked, don't switch media */
1076         if (de->media_lock)
1077                 goto set_media;
1078
1079         /* if activity detected, use that as hint for new media type */
1080         if (status & NonselPortActive) {
1081                 unsigned int have_media = 1;
1082
1083                 /* if AUI/BNC selected, then activity is on TP port */
1084                 if (de->media_type == DE_MEDIA_AUI ||
1085                     de->media_type == DE_MEDIA_BNC) {
1086                         if (de_ok_to_advertise(de, DE_MEDIA_TP_AUTO))
1087                                 de->media_type = DE_MEDIA_TP_AUTO;
1088                         else
1089                                 have_media = 0;
1090                 }
1091
1092                 /* TP selected.  If there is only TP and BNC, then it's BNC */
1093                 else if (((de->media_supported & DE_AUI_BNC) == SUPPORTED_BNC) &&
1094                          de_ok_to_advertise(de, DE_MEDIA_BNC))
1095                         de->media_type = DE_MEDIA_BNC;
1096
1097                 /* TP selected.  If there is only TP and AUI, then it's AUI */
1098                 else if (((de->media_supported & DE_AUI_BNC) == SUPPORTED_AUI) &&
1099                          de_ok_to_advertise(de, DE_MEDIA_AUI))
1100                         de->media_type = DE_MEDIA_AUI;
1101
1102                 /* otherwise, ignore the hint */
1103                 else
1104                         have_media = 0;
1105
1106                 if (have_media)
1107                         goto set_media;
1108         }
1109
1110         /*
1111          * Absent or ambiguous activity hint, move to next advertised
1112          * media state.  If de->media_type is left unchanged, this
1113          * simply resets the PHY and reloads the current media settings.
1114          */
1115         if (de->media_type == DE_MEDIA_AUI) {
1116                 u32 next_states[] = { DE_MEDIA_BNC, DE_MEDIA_TP_AUTO };
1117                 de_next_media(de, next_states, ARRAY_SIZE(next_states));
1118         } else if (de->media_type == DE_MEDIA_BNC) {
1119                 u32 next_states[] = { DE_MEDIA_TP_AUTO, DE_MEDIA_AUI };
1120                 de_next_media(de, next_states, ARRAY_SIZE(next_states));
1121         } else {
1122                 u32 next_states[] = { DE_MEDIA_AUI, DE_MEDIA_BNC, DE_MEDIA_TP_AUTO };
1123                 de_next_media(de, next_states, ARRAY_SIZE(next_states));
1124         }
1125
1126 set_media:
1127         spin_lock_irqsave(&de->lock, flags);
1128         de_stop_rxtx(de);
1129         spin_unlock_irqrestore(&de->lock, flags);
1130         de_set_media(de);
1131         de_start_rxtx(de);
1132
1133 no_link_yet:
1134         de->media_timer.expires = jiffies + DE_TIMER_NO_LINK;
1135         add_timer(&de->media_timer);
1136
1137         if (netif_msg_timer(de))
1138                 printk(KERN_INFO "%s: no link, trying media %s, status %x\n",
1139                        dev->name, media_name[de->media_type], status);
1140 }
1141
1142 static void de_media_interrupt (struct de_private *de, u32 status)
1143 {
1144         if (status & LinkPass) {
1145                 de_link_up(de);
1146                 mod_timer(&de->media_timer, jiffies + DE_TIMER_LINK);
1147                 return;
1148         }
1149
1150         BUG_ON(!(status & LinkFail));
1151
1152         if (netif_carrier_ok(de->dev)) {
1153                 de_link_down(de);
1154                 mod_timer(&de->media_timer, jiffies + DE_TIMER_NO_LINK);
1155         }
1156 }
1157
1158 static int de_reset_mac (struct de_private *de)
1159 {
1160         u32 status, tmp;
1161
1162         /*
1163          * Reset MAC.  de4x5.c and tulip.c examined for "advice"
1164          * in this area.
1165          */
1166
1167         if (dr32(BusMode) == 0xffffffff)
1168                 return -EBUSY;
1169
1170         /* Reset the chip, holding bit 0 set at least 50 PCI cycles. */
1171         dw32 (BusMode, CmdReset);
1172         mdelay (1);
1173
1174         dw32 (BusMode, de_bus_mode);
1175         mdelay (1);
1176
1177         for (tmp = 0; tmp < 5; tmp++) {
1178                 dr32 (BusMode);
1179                 mdelay (1);
1180         }
1181
1182         mdelay (1);
1183
1184         status = dr32(MacStatus);
1185         if (status & (RxState | TxState))
1186                 return -EBUSY;
1187         if (status == 0xffffffff)
1188                 return -ENODEV;
1189         return 0;
1190 }
1191
1192 static void de_adapter_wake (struct de_private *de)
1193 {
1194         u32 pmctl;
1195
1196         if (de->de21040)
1197                 return;
1198
1199         pci_read_config_dword(de->pdev, PCIPM, &pmctl);
1200         if (pmctl & PM_Mask) {
1201                 pmctl &= ~PM_Mask;
1202                 pci_write_config_dword(de->pdev, PCIPM, pmctl);
1203
1204                 /* de4x5.c delays, so we do too */
1205                 msleep(10);
1206         }
1207 }
1208
1209 static void de_adapter_sleep (struct de_private *de)
1210 {
1211         u32 pmctl;
1212
1213         if (de->de21040)
1214                 return;
1215
1216         pci_read_config_dword(de->pdev, PCIPM, &pmctl);
1217         pmctl |= PM_Sleep;
1218         pci_write_config_dword(de->pdev, PCIPM, pmctl);
1219 }
1220
1221 static int de_init_hw (struct de_private *de)
1222 {
1223         struct net_device *dev = de->dev;
1224         u32 macmode;
1225         int rc;
1226
1227         de_adapter_wake(de);
1228
1229         macmode = dr32(MacMode) & ~MacModeClear;
1230
1231         rc = de_reset_mac(de);
1232         if (rc)
1233                 return rc;
1234
1235         de_set_media(de); /* reset phy */
1236
1237         dw32(RxRingAddr, de->ring_dma);
1238         dw32(TxRingAddr, de->ring_dma + (sizeof(struct de_desc) * DE_RX_RING_SIZE));
1239
1240         dw32(MacMode, RxTx | macmode);
1241
1242         dr32(RxMissed); /* self-clearing */
1243
1244         dw32(IntrMask, de_intr_mask);
1245
1246         de_set_rx_mode(dev);
1247
1248         return 0;
1249 }
1250
1251 static int de_refill_rx (struct de_private *de)
1252 {
1253         unsigned i;
1254
1255         for (i = 0; i < DE_RX_RING_SIZE; i++) {
1256                 struct sk_buff *skb;
1257
1258                 skb = dev_alloc_skb(de->rx_buf_sz);
1259                 if (!skb)
1260                         goto err_out;
1261
1262                 skb->dev = de->dev;
1263
1264                 de->rx_skb[i].mapping = pci_map_single(de->pdev,
1265                         skb->data, de->rx_buf_sz, PCI_DMA_FROMDEVICE);
1266                 de->rx_skb[i].skb = skb;
1267
1268                 de->rx_ring[i].opts1 = cpu_to_le32(DescOwn);
1269                 if (i == (DE_RX_RING_SIZE - 1))
1270                         de->rx_ring[i].opts2 =
1271                                 cpu_to_le32(RingEnd | de->rx_buf_sz);
1272                 else
1273                         de->rx_ring[i].opts2 = cpu_to_le32(de->rx_buf_sz);
1274                 de->rx_ring[i].addr1 = cpu_to_le32(de->rx_skb[i].mapping);
1275                 de->rx_ring[i].addr2 = 0;
1276         }
1277
1278         return 0;
1279
1280 err_out:
1281         de_clean_rings(de);
1282         return -ENOMEM;
1283 }
1284
1285 static int de_init_rings (struct de_private *de)
1286 {
1287         memset(de->tx_ring, 0, sizeof(struct de_desc) * DE_TX_RING_SIZE);
1288         de->tx_ring[DE_TX_RING_SIZE - 1].opts2 = cpu_to_le32(RingEnd);
1289
1290         de->rx_tail = 0;
1291         de->tx_head = de->tx_tail = 0;
1292
1293         return de_refill_rx (de);
1294 }
1295
1296 static int de_alloc_rings (struct de_private *de)
1297 {
1298         de->rx_ring = pci_alloc_consistent(de->pdev, DE_RING_BYTES, &de->ring_dma);
1299         if (!de->rx_ring)
1300                 return -ENOMEM;
1301         de->tx_ring = &de->rx_ring[DE_RX_RING_SIZE];
1302         return de_init_rings(de);
1303 }
1304
1305 static void de_clean_rings (struct de_private *de)
1306 {
1307         unsigned i;
1308
1309         memset(de->rx_ring, 0, sizeof(struct de_desc) * DE_RX_RING_SIZE);
1310         de->rx_ring[DE_RX_RING_SIZE - 1].opts2 = cpu_to_le32(RingEnd);
1311         wmb();
1312         memset(de->tx_ring, 0, sizeof(struct de_desc) * DE_TX_RING_SIZE);
1313         de->tx_ring[DE_TX_RING_SIZE - 1].opts2 = cpu_to_le32(RingEnd);
1314         wmb();
1315
1316         for (i = 0; i < DE_RX_RING_SIZE; i++) {
1317                 if (de->rx_skb[i].skb) {
1318                         pci_unmap_single(de->pdev, de->rx_skb[i].mapping,
1319                                          de->rx_buf_sz, PCI_DMA_FROMDEVICE);
1320                         dev_kfree_skb(de->rx_skb[i].skb);
1321                 }
1322         }
1323
1324         for (i = 0; i < DE_TX_RING_SIZE; i++) {
1325                 struct sk_buff *skb = de->tx_skb[i].skb;
1326                 if ((skb) && (skb != DE_DUMMY_SKB)) {
1327                         if (skb != DE_SETUP_SKB) {
1328                                 de->net_stats.tx_dropped++;
1329                                 pci_unmap_single(de->pdev,
1330                                         de->tx_skb[i].mapping,
1331                                         skb->len, PCI_DMA_TODEVICE);
1332                                 dev_kfree_skb(skb);
1333                         } else {
1334                                 pci_unmap_single(de->pdev,
1335                                         de->tx_skb[i].mapping,
1336                                         sizeof(de->setup_frame),
1337                                         PCI_DMA_TODEVICE);
1338                         }
1339                 }
1340         }
1341
1342         memset(&de->rx_skb, 0, sizeof(struct ring_info) * DE_RX_RING_SIZE);
1343         memset(&de->tx_skb, 0, sizeof(struct ring_info) * DE_TX_RING_SIZE);
1344 }
1345
1346 static void de_free_rings (struct de_private *de)
1347 {
1348         de_clean_rings(de);
1349         pci_free_consistent(de->pdev, DE_RING_BYTES, de->rx_ring, de->ring_dma);
1350         de->rx_ring = NULL;
1351         de->tx_ring = NULL;
1352 }
1353
1354 static int de_open (struct net_device *dev)
1355 {
1356         struct de_private *de = dev->priv;
1357         int rc;
1358
1359         if (netif_msg_ifup(de))
1360                 printk(KERN_DEBUG "%s: enabling interface\n", dev->name);
1361
1362         de->rx_buf_sz = (dev->mtu <= 1500 ? PKT_BUF_SZ : dev->mtu + 32);
1363
1364         rc = de_alloc_rings(de);
1365         if (rc) {
1366                 printk(KERN_ERR "%s: ring allocation failure, err=%d\n",
1367                        dev->name, rc);
1368                 return rc;
1369         }
1370
1371         dw32(IntrMask, 0);
1372
1373         rc = request_irq(dev->irq, de_interrupt, IRQF_SHARED, dev->name, dev);
1374         if (rc) {
1375                 printk(KERN_ERR "%s: IRQ %d request failure, err=%d\n",
1376                        dev->name, dev->irq, rc);
1377                 goto err_out_free;
1378         }
1379
1380         rc = de_init_hw(de);
1381         if (rc) {
1382                 printk(KERN_ERR "%s: h/w init failure, err=%d\n",
1383                        dev->name, rc);
1384                 goto err_out_free_irq;
1385         }
1386
1387         netif_start_queue(dev);
1388         mod_timer(&de->media_timer, jiffies + DE_TIMER_NO_LINK);
1389
1390         return 0;
1391
1392 err_out_free_irq:
1393         free_irq(dev->irq, dev);
1394 err_out_free:
1395         de_free_rings(de);
1396         return rc;
1397 }
1398
1399 static int de_close (struct net_device *dev)
1400 {
1401         struct de_private *de = dev->priv;
1402         unsigned long flags;
1403
1404         if (netif_msg_ifdown(de))
1405                 printk(KERN_DEBUG "%s: disabling interface\n", dev->name);
1406
1407         del_timer_sync(&de->media_timer);
1408
1409         spin_lock_irqsave(&de->lock, flags);
1410         de_stop_hw(de);
1411         netif_stop_queue(dev);
1412         netif_carrier_off(dev);
1413         spin_unlock_irqrestore(&de->lock, flags);
1414
1415         free_irq(dev->irq, dev);
1416
1417         de_free_rings(de);
1418         de_adapter_sleep(de);
1419         pci_disable_device(de->pdev);
1420         return 0;
1421 }
1422
1423 static void de_tx_timeout (struct net_device *dev)
1424 {
1425         struct de_private *de = dev->priv;
1426
1427         printk(KERN_DEBUG "%s: NIC status %08x mode %08x sia %08x desc %u/%u/%u\n",
1428                dev->name, dr32(MacStatus), dr32(MacMode), dr32(SIAStatus),
1429                de->rx_tail, de->tx_head, de->tx_tail);
1430
1431         del_timer_sync(&de->media_timer);
1432
1433         disable_irq(dev->irq);
1434         spin_lock_irq(&de->lock);
1435
1436         de_stop_hw(de);
1437         netif_stop_queue(dev);
1438         netif_carrier_off(dev);
1439
1440         spin_unlock_irq(&de->lock);
1441         enable_irq(dev->irq);
1442
1443         /* Update the error counts. */
1444         __de_get_stats(de);
1445
1446         synchronize_irq(dev->irq);
1447         de_clean_rings(de);
1448
1449         de_init_rings(de);
1450
1451         de_init_hw(de);
1452
1453         netif_wake_queue(dev);
1454 }
1455
1456 static void __de_get_regs(struct de_private *de, u8 *buf)
1457 {
1458         int i;
1459         u32 *rbuf = (u32 *)buf;
1460
1461         /* read all CSRs */
1462         for (i = 0; i < DE_NUM_REGS; i++)
1463                 rbuf[i] = dr32(i * 8);
1464
1465         /* handle self-clearing RxMissed counter, CSR8 */
1466         de_rx_missed(de, rbuf[8]);
1467 }
1468
1469 static int __de_get_settings(struct de_private *de, struct ethtool_cmd *ecmd)
1470 {
1471         ecmd->supported = de->media_supported;
1472         ecmd->transceiver = XCVR_INTERNAL;
1473         ecmd->phy_address = 0;
1474         ecmd->advertising = de->media_advertise;
1475
1476         switch (de->media_type) {
1477         case DE_MEDIA_AUI:
1478                 ecmd->port = PORT_AUI;
1479                 ecmd->speed = 5;
1480                 break;
1481         case DE_MEDIA_BNC:
1482                 ecmd->port = PORT_BNC;
1483                 ecmd->speed = 2;
1484                 break;
1485         default:
1486                 ecmd->port = PORT_TP;
1487                 ecmd->speed = SPEED_10;
1488                 break;
1489         }
1490
1491         if (dr32(MacMode) & FullDuplex)
1492                 ecmd->duplex = DUPLEX_FULL;
1493         else
1494                 ecmd->duplex = DUPLEX_HALF;
1495
1496         if (de->media_lock)
1497                 ecmd->autoneg = AUTONEG_DISABLE;
1498         else
1499                 ecmd->autoneg = AUTONEG_ENABLE;
1500
1501         /* ignore maxtxpkt, maxrxpkt for now */
1502
1503         return 0;
1504 }
1505
1506 static int __de_set_settings(struct de_private *de, struct ethtool_cmd *ecmd)
1507 {
1508         u32 new_media;
1509         unsigned int media_lock;
1510
1511         if (ecmd->speed != SPEED_10 && ecmd->speed != 5 && ecmd->speed != 2)
1512                 return -EINVAL;
1513         if (de->de21040 && ecmd->speed == 2)
1514                 return -EINVAL;
1515         if (ecmd->duplex != DUPLEX_HALF && ecmd->duplex != DUPLEX_FULL)
1516                 return -EINVAL;
1517         if (ecmd->port != PORT_TP && ecmd->port != PORT_AUI && ecmd->port != PORT_BNC)
1518                 return -EINVAL;
1519         if (de->de21040 && ecmd->port == PORT_BNC)
1520                 return -EINVAL;
1521         if (ecmd->transceiver != XCVR_INTERNAL)
1522                 return -EINVAL;
1523         if (ecmd->autoneg != AUTONEG_DISABLE && ecmd->autoneg != AUTONEG_ENABLE)
1524                 return -EINVAL;
1525         if (ecmd->advertising & ~de->media_supported)
1526                 return -EINVAL;
1527         if (ecmd->autoneg == AUTONEG_ENABLE &&
1528             (!(ecmd->advertising & ADVERTISED_Autoneg)))
1529                 return -EINVAL;
1530
1531         switch (ecmd->port) {
1532         case PORT_AUI:
1533                 new_media = DE_MEDIA_AUI;
1534                 if (!(ecmd->advertising & ADVERTISED_AUI))
1535                         return -EINVAL;
1536                 break;
1537         case PORT_BNC:
1538                 new_media = DE_MEDIA_BNC;
1539                 if (!(ecmd->advertising & ADVERTISED_BNC))
1540                         return -EINVAL;
1541                 break;
1542         default:
1543                 if (ecmd->autoneg == AUTONEG_ENABLE)
1544                         new_media = DE_MEDIA_TP_AUTO;
1545                 else if (ecmd->duplex == DUPLEX_FULL)
1546                         new_media = DE_MEDIA_TP_FD;
1547                 else
1548                         new_media = DE_MEDIA_TP;
1549                 if (!(ecmd->advertising & ADVERTISED_TP))
1550                         return -EINVAL;
1551                 if (!(ecmd->advertising & (ADVERTISED_10baseT_Full | ADVERTISED_10baseT_Half)))
1552                         return -EINVAL;
1553                 break;
1554         }
1555
1556         media_lock = (ecmd->autoneg == AUTONEG_ENABLE) ? 0 : 1;
1557
1558         if ((new_media == de->media_type) &&
1559             (media_lock == de->media_lock) &&
1560             (ecmd->advertising == de->media_advertise))
1561                 return 0; /* nothing to change */
1562
1563         de_link_down(de);
1564         de_stop_rxtx(de);
1565
1566         de->media_type = new_media;
1567         de->media_lock = media_lock;
1568         de->media_advertise = ecmd->advertising;
1569         de_set_media(de);
1570
1571         return 0;
1572 }
1573
1574 static void de_get_drvinfo (struct net_device *dev,struct ethtool_drvinfo *info)
1575 {
1576         struct de_private *de = dev->priv;
1577
1578         strcpy (info->driver, DRV_NAME);
1579         strcpy (info->version, DRV_VERSION);
1580         strcpy (info->bus_info, pci_name(de->pdev));
1581         info->eedump_len = DE_EEPROM_SIZE;
1582 }
1583
1584 static int de_get_regs_len(struct net_device *dev)
1585 {
1586         return DE_REGS_SIZE;
1587 }
1588
1589 static int de_get_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
1590 {
1591         struct de_private *de = dev->priv;
1592         int rc;
1593
1594         spin_lock_irq(&de->lock);
1595         rc = __de_get_settings(de, ecmd);
1596         spin_unlock_irq(&de->lock);
1597
1598         return rc;
1599 }
1600
1601 static int de_set_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
1602 {
1603         struct de_private *de = dev->priv;
1604         int rc;
1605
1606         spin_lock_irq(&de->lock);
1607         rc = __de_set_settings(de, ecmd);
1608         spin_unlock_irq(&de->lock);
1609
1610         return rc;
1611 }
1612
1613 static u32 de_get_msglevel(struct net_device *dev)
1614 {
1615         struct de_private *de = dev->priv;
1616
1617         return de->msg_enable;
1618 }
1619
1620 static void de_set_msglevel(struct net_device *dev, u32 msglvl)
1621 {
1622         struct de_private *de = dev->priv;
1623
1624         de->msg_enable = msglvl;
1625 }
1626
1627 static int de_get_eeprom(struct net_device *dev,
1628                          struct ethtool_eeprom *eeprom, u8 *data)
1629 {
1630         struct de_private *de = dev->priv;
1631
1632         if (!de->ee_data)
1633                 return -EOPNOTSUPP;
1634         if ((eeprom->offset != 0) || (eeprom->magic != 0) ||
1635             (eeprom->len != DE_EEPROM_SIZE))
1636                 return -EINVAL;
1637         memcpy(data, de->ee_data, eeprom->len);
1638
1639         return 0;
1640 }
1641
1642 static int de_nway_reset(struct net_device *dev)
1643 {
1644         struct de_private *de = dev->priv;
1645         u32 status;
1646
1647         if (de->media_type != DE_MEDIA_TP_AUTO)
1648                 return -EINVAL;
1649         if (netif_carrier_ok(de->dev))
1650                 de_link_down(de);
1651
1652         status = dr32(SIAStatus);
1653         dw32(SIAStatus, (status & ~NWayState) | NWayRestart);
1654         if (netif_msg_link(de))
1655                 printk(KERN_INFO "%s: link nway restart, status %x,%x\n",
1656                        de->dev->name, status, dr32(SIAStatus));
1657         return 0;
1658 }
1659
1660 static void de_get_regs(struct net_device *dev, struct ethtool_regs *regs,
1661                         void *data)
1662 {
1663         struct de_private *de = dev->priv;
1664
1665         regs->version = (DE_REGS_VER << 2) | de->de21040;
1666
1667         spin_lock_irq(&de->lock);
1668         __de_get_regs(de, data);
1669         spin_unlock_irq(&de->lock);
1670 }
1671
1672 static const struct ethtool_ops de_ethtool_ops = {
1673         .get_link               = ethtool_op_get_link,
1674         .get_drvinfo            = de_get_drvinfo,
1675         .get_regs_len           = de_get_regs_len,
1676         .get_settings           = de_get_settings,
1677         .set_settings           = de_set_settings,
1678         .get_msglevel           = de_get_msglevel,
1679         .set_msglevel           = de_set_msglevel,
1680         .get_eeprom             = de_get_eeprom,
1681         .nway_reset             = de_nway_reset,
1682         .get_regs               = de_get_regs,
1683 };
1684
1685 static void __devinit de21040_get_mac_address (struct de_private *de)
1686 {
1687         unsigned i;
1688
1689         dw32 (ROMCmd, 0);       /* Reset the pointer with a dummy write. */
1690
1691         for (i = 0; i < 6; i++) {
1692                 int value, boguscnt = 100000;
1693                 do
1694                         value = dr32(ROMCmd);
1695                 while (value < 0 && --boguscnt > 0);
1696                 de->dev->dev_addr[i] = value;
1697                 udelay(1);
1698                 if (boguscnt <= 0)
1699                         printk(KERN_WARNING PFX "timeout reading 21040 MAC address byte %u\n", i);
1700         }
1701 }
1702
1703 static void __devinit de21040_get_media_info(struct de_private *de)
1704 {
1705         unsigned int i;
1706
1707         de->media_type = DE_MEDIA_TP;
1708         de->media_supported |= SUPPORTED_TP | SUPPORTED_10baseT_Full |
1709                                SUPPORTED_10baseT_Half | SUPPORTED_AUI;
1710         de->media_advertise = de->media_supported;
1711
1712         for (i = 0; i < DE_MAX_MEDIA; i++) {
1713                 switch (i) {
1714                 case DE_MEDIA_AUI:
1715                 case DE_MEDIA_TP:
1716                 case DE_MEDIA_TP_FD:
1717                         de->media[i].type = i;
1718                         de->media[i].csr13 = t21040_csr13[i];
1719                         de->media[i].csr14 = t21040_csr14[i];
1720                         de->media[i].csr15 = t21040_csr15[i];
1721                         break;
1722                 default:
1723                         de->media[i].type = DE_MEDIA_INVALID;
1724                         break;
1725                 }
1726         }
1727 }
1728
1729 /* Note: this routine returns extra data bits for size detection. */
1730 static unsigned __devinit tulip_read_eeprom(void __iomem *regs, int location, int addr_len)
1731 {
1732         int i;
1733         unsigned retval = 0;
1734         void __iomem *ee_addr = regs + ROMCmd;
1735         int read_cmd = location | (EE_READ_CMD << addr_len);
1736
1737         writel(EE_ENB & ~EE_CS, ee_addr);
1738         writel(EE_ENB, ee_addr);
1739
1740         /* Shift the read command bits out. */
1741         for (i = 4 + addr_len; i >= 0; i--) {
1742                 short dataval = (read_cmd & (1 << i)) ? EE_DATA_WRITE : 0;
1743                 writel(EE_ENB | dataval, ee_addr);
1744                 readl(ee_addr);
1745                 writel(EE_ENB | dataval | EE_SHIFT_CLK, ee_addr);
1746                 readl(ee_addr);
1747                 retval = (retval << 1) | ((readl(ee_addr) & EE_DATA_READ) ? 1 : 0);
1748         }
1749         writel(EE_ENB, ee_addr);
1750         readl(ee_addr);
1751
1752         for (i = 16; i > 0; i--) {
1753                 writel(EE_ENB | EE_SHIFT_CLK, ee_addr);
1754                 readl(ee_addr);
1755                 retval = (retval << 1) | ((readl(ee_addr) & EE_DATA_READ) ? 1 : 0);
1756                 writel(EE_ENB, ee_addr);
1757                 readl(ee_addr);
1758         }
1759
1760         /* Terminate the EEPROM access. */
1761         writel(EE_ENB & ~EE_CS, ee_addr);
1762         return retval;
1763 }
1764
1765 static void __devinit de21041_get_srom_info (struct de_private *de)
1766 {
1767         unsigned i, sa_offset = 0, ofs;
1768         u8 ee_data[DE_EEPROM_SIZE + 6] = {};
1769         unsigned ee_addr_size = tulip_read_eeprom(de->regs, 0xff, 8) & 0x40000 ? 8 : 6;
1770         struct de_srom_info_leaf *il;
1771         void *bufp;
1772
1773         /* download entire eeprom */
1774         for (i = 0; i < DE_EEPROM_WORDS; i++)
1775                 ((__le16 *)ee_data)[i] =
1776                         cpu_to_le16(tulip_read_eeprom(de->regs, i, ee_addr_size));
1777
1778         /* DEC now has a specification but early board makers
1779            just put the address in the first EEPROM locations. */
1780         /* This does  memcmp(eedata, eedata+16, 8) */
1781
1782 #ifndef CONFIG_MIPS_COBALT
1783
1784         for (i = 0; i < 8; i ++)
1785                 if (ee_data[i] != ee_data[16+i])
1786                         sa_offset = 20;
1787
1788 #endif
1789
1790         /* store MAC address */
1791         for (i = 0; i < 6; i ++)
1792                 de->dev->dev_addr[i] = ee_data[i + sa_offset];
1793
1794         /* get offset of controller 0 info leaf.  ignore 2nd byte. */
1795         ofs = ee_data[SROMC0InfoLeaf];
1796         if (ofs >= (sizeof(ee_data) - sizeof(struct de_srom_info_leaf) - sizeof(struct de_srom_media_block)))
1797                 goto bad_srom;
1798
1799         /* get pointer to info leaf */
1800         il = (struct de_srom_info_leaf *) &ee_data[ofs];
1801
1802         /* paranoia checks */
1803         if (il->n_blocks == 0)
1804                 goto bad_srom;
1805         if ((sizeof(ee_data) - ofs) <
1806             (sizeof(struct de_srom_info_leaf) + (sizeof(struct de_srom_media_block) * il->n_blocks)))
1807                 goto bad_srom;
1808
1809         /* get default media type */
1810         switch (DE_UNALIGNED_16(&il->default_media)) {
1811         case 0x0001:  de->media_type = DE_MEDIA_BNC; break;
1812         case 0x0002:  de->media_type = DE_MEDIA_AUI; break;
1813         case 0x0204:  de->media_type = DE_MEDIA_TP_FD; break;
1814         default: de->media_type = DE_MEDIA_TP_AUTO; break;
1815         }
1816
1817         if (netif_msg_probe(de))
1818                 printk(KERN_INFO "de%d: SROM leaf offset %u, default media %s\n",
1819                        de->board_idx, ofs,
1820                        media_name[de->media_type]);
1821
1822         /* init SIA register values to defaults */
1823         for (i = 0; i < DE_MAX_MEDIA; i++) {
1824                 de->media[i].type = DE_MEDIA_INVALID;
1825                 de->media[i].csr13 = 0xffff;
1826                 de->media[i].csr14 = 0xffff;
1827                 de->media[i].csr15 = 0xffff;
1828         }
1829
1830         /* parse media blocks to see what medias are supported,
1831          * and if any custom CSR values are provided
1832          */
1833         bufp = ((void *)il) + sizeof(*il);
1834         for (i = 0; i < il->n_blocks; i++) {
1835                 struct de_srom_media_block *ib = bufp;
1836                 unsigned idx;
1837
1838                 /* index based on media type in media block */
1839                 switch(ib->opts & MediaBlockMask) {
1840                 case 0: /* 10baseT */
1841                         de->media_supported |= SUPPORTED_TP | SUPPORTED_10baseT_Half
1842                                           | SUPPORTED_Autoneg;
1843                         idx = DE_MEDIA_TP;
1844                         de->media[DE_MEDIA_TP_AUTO].type = DE_MEDIA_TP_AUTO;
1845                         break;
1846                 case 1: /* BNC */
1847                         de->media_supported |= SUPPORTED_BNC;
1848                         idx = DE_MEDIA_BNC;
1849                         break;
1850                 case 2: /* AUI */
1851                         de->media_supported |= SUPPORTED_AUI;
1852                         idx = DE_MEDIA_AUI;
1853                         break;
1854                 case 4: /* 10baseT-FD */
1855                         de->media_supported |= SUPPORTED_TP | SUPPORTED_10baseT_Full
1856                                           | SUPPORTED_Autoneg;
1857                         idx = DE_MEDIA_TP_FD;
1858                         de->media[DE_MEDIA_TP_AUTO].type = DE_MEDIA_TP_AUTO;
1859                         break;
1860                 default:
1861                         goto bad_srom;
1862                 }
1863
1864                 de->media[idx].type = idx;
1865
1866                 if (netif_msg_probe(de))
1867                         printk(KERN_INFO "de%d:   media block #%u: %s",
1868                                de->board_idx, i,
1869                                media_name[de->media[idx].type]);
1870
1871                 bufp += sizeof (ib->opts);
1872
1873                 if (ib->opts & MediaCustomCSRs) {
1874                         de->media[idx].csr13 = DE_UNALIGNED_16(&ib->csr13);
1875                         de->media[idx].csr14 = DE_UNALIGNED_16(&ib->csr14);
1876                         de->media[idx].csr15 = DE_UNALIGNED_16(&ib->csr15);
1877                         bufp += sizeof(ib->csr13) + sizeof(ib->csr14) +
1878                                 sizeof(ib->csr15);
1879
1880                         if (netif_msg_probe(de))
1881                                 printk(" (%x,%x,%x)\n",
1882                                        de->media[idx].csr13,
1883                                        de->media[idx].csr14,
1884                                        de->media[idx].csr15);
1885
1886                 } else if (netif_msg_probe(de))
1887                         printk("\n");
1888
1889                 if (bufp > ((void *)&ee_data[DE_EEPROM_SIZE - 3]))
1890                         break;
1891         }
1892
1893         de->media_advertise = de->media_supported;
1894
1895 fill_defaults:
1896         /* fill in defaults, for cases where custom CSRs not used */
1897         for (i = 0; i < DE_MAX_MEDIA; i++) {
1898                 if (de->media[i].csr13 == 0xffff)
1899                         de->media[i].csr13 = t21041_csr13[i];
1900                 if (de->media[i].csr14 == 0xffff)
1901                         de->media[i].csr14 = t21041_csr14[i];
1902                 if (de->media[i].csr15 == 0xffff)
1903                         de->media[i].csr15 = t21041_csr15[i];
1904         }
1905
1906         de->ee_data = kmemdup(&ee_data[0], DE_EEPROM_SIZE, GFP_KERNEL);
1907
1908         return;
1909
1910 bad_srom:
1911         /* for error cases, it's ok to assume we support all these */
1912         for (i = 0; i < DE_MAX_MEDIA; i++)
1913                 de->media[i].type = i;
1914         de->media_supported =
1915                 SUPPORTED_10baseT_Half |
1916                 SUPPORTED_10baseT_Full |
1917                 SUPPORTED_Autoneg |
1918                 SUPPORTED_TP |
1919                 SUPPORTED_AUI |
1920                 SUPPORTED_BNC;
1921         goto fill_defaults;
1922 }
1923
1924 static int __devinit de_init_one (struct pci_dev *pdev,
1925                                   const struct pci_device_id *ent)
1926 {
1927         struct net_device *dev;
1928         struct de_private *de;
1929         int rc;
1930         void __iomem *regs;
1931         unsigned long pciaddr;
1932         static int board_idx = -1;
1933         DECLARE_MAC_BUF(mac);
1934
1935         board_idx++;
1936
1937 #ifndef MODULE
1938         if (board_idx == 0)
1939                 printk("%s", version);
1940 #endif
1941
1942         /* allocate a new ethernet device structure, and fill in defaults */
1943         dev = alloc_etherdev(sizeof(struct de_private));
1944         if (!dev)
1945                 return -ENOMEM;
1946
1947         SET_NETDEV_DEV(dev, &pdev->dev);
1948         dev->open = de_open;
1949         dev->stop = de_close;
1950         dev->set_multicast_list = de_set_rx_mode;
1951         dev->hard_start_xmit = de_start_xmit;
1952         dev->get_stats = de_get_stats;
1953         dev->ethtool_ops = &de_ethtool_ops;
1954         dev->tx_timeout = de_tx_timeout;
1955         dev->watchdog_timeo = TX_TIMEOUT;
1956
1957         de = dev->priv;
1958         de->de21040 = ent->driver_data == 0 ? 1 : 0;
1959         de->pdev = pdev;
1960         de->dev = dev;
1961         de->msg_enable = (debug < 0 ? DE_DEF_MSG_ENABLE : debug);
1962         de->board_idx = board_idx;
1963         spin_lock_init (&de->lock);
1964         init_timer(&de->media_timer);
1965         if (de->de21040)
1966                 de->media_timer.function = de21040_media_timer;
1967         else
1968                 de->media_timer.function = de21041_media_timer;
1969         de->media_timer.data = (unsigned long) de;
1970
1971         netif_carrier_off(dev);
1972         netif_stop_queue(dev);
1973
1974         /* wake up device, assign resources */
1975         rc = pci_enable_device(pdev);
1976         if (rc)
1977                 goto err_out_free;
1978
1979         /* reserve PCI resources to ensure driver atomicity */
1980         rc = pci_request_regions(pdev, DRV_NAME);
1981         if (rc)
1982                 goto err_out_disable;
1983
1984         /* check for invalid IRQ value */
1985         if (pdev->irq < 2) {
1986                 rc = -EIO;
1987                 printk(KERN_ERR PFX "invalid irq (%d) for pci dev %s\n",
1988                        pdev->irq, pci_name(pdev));
1989                 goto err_out_res;
1990         }
1991
1992         dev->irq = pdev->irq;
1993
1994         /* obtain and check validity of PCI I/O address */
1995         pciaddr = pci_resource_start(pdev, 1);
1996         if (!pciaddr) {
1997                 rc = -EIO;
1998                 printk(KERN_ERR PFX "no MMIO resource for pci dev %s\n",
1999                        pci_name(pdev));
2000                 goto err_out_res;
2001         }
2002         if (pci_resource_len(pdev, 1) < DE_REGS_SIZE) {
2003                 rc = -EIO;
2004                 printk(KERN_ERR PFX "MMIO resource (%llx) too small on pci dev %s\n",
2005                        (unsigned long long)pci_resource_len(pdev, 1), pci_name(pdev));
2006                 goto err_out_res;
2007         }
2008
2009         /* remap CSR registers */
2010         regs = ioremap_nocache(pciaddr, DE_REGS_SIZE);
2011         if (!regs) {
2012                 rc = -EIO;
2013                 printk(KERN_ERR PFX "Cannot map PCI MMIO (%llx@%lx) on pci dev %s\n",
2014                         (unsigned long long)pci_resource_len(pdev, 1),
2015                         pciaddr, pci_name(pdev));
2016                 goto err_out_res;
2017         }
2018         dev->base_addr = (unsigned long) regs;
2019         de->regs = regs;
2020
2021         de_adapter_wake(de);
2022
2023         /* make sure hardware is not running */
2024         rc = de_reset_mac(de);
2025         if (rc) {
2026                 printk(KERN_ERR PFX "Cannot reset MAC, pci dev %s\n",
2027                        pci_name(pdev));
2028                 goto err_out_iomap;
2029         }
2030
2031         /* get MAC address, initialize default media type and
2032          * get list of supported media
2033          */
2034         if (de->de21040) {
2035                 de21040_get_mac_address(de);
2036                 de21040_get_media_info(de);
2037         } else {
2038                 de21041_get_srom_info(de);
2039         }
2040
2041         /* register new network interface with kernel */
2042         rc = register_netdev(dev);
2043         if (rc)
2044                 goto err_out_iomap;
2045
2046         /* print info about board and interface just registered */
2047         printk (KERN_INFO "%s: %s at 0x%lx, %s, IRQ %d\n",
2048                 dev->name,
2049                 de->de21040 ? "21040" : "21041",
2050                 dev->base_addr,
2051                 print_mac(mac, dev->dev_addr),
2052                 dev->irq);
2053
2054         pci_set_drvdata(pdev, dev);
2055
2056         /* enable busmastering */
2057         pci_set_master(pdev);
2058
2059         /* put adapter to sleep */
2060         de_adapter_sleep(de);
2061
2062         return 0;
2063
2064 err_out_iomap:
2065         kfree(de->ee_data);
2066         iounmap(regs);
2067 err_out_res:
2068         pci_release_regions(pdev);
2069 err_out_disable:
2070         pci_disable_device(pdev);
2071 err_out_free:
2072         free_netdev(dev);
2073         return rc;
2074 }
2075
2076 static void __devexit de_remove_one (struct pci_dev *pdev)
2077 {
2078         struct net_device *dev = pci_get_drvdata(pdev);
2079         struct de_private *de = dev->priv;
2080
2081         BUG_ON(!dev);
2082         unregister_netdev(dev);
2083         kfree(de->ee_data);
2084         iounmap(de->regs);
2085         pci_release_regions(pdev);
2086         pci_disable_device(pdev);
2087         pci_set_drvdata(pdev, NULL);
2088         free_netdev(dev);
2089 }
2090
2091 #ifdef CONFIG_PM
2092
2093 static int de_suspend (struct pci_dev *pdev, pm_message_t state)
2094 {
2095         struct net_device *dev = pci_get_drvdata (pdev);
2096         struct de_private *de = dev->priv;
2097
2098         rtnl_lock();
2099         if (netif_running (dev)) {
2100                 del_timer_sync(&de->media_timer);
2101
2102                 disable_irq(dev->irq);
2103                 spin_lock_irq(&de->lock);
2104
2105                 de_stop_hw(de);
2106                 netif_stop_queue(dev);
2107                 netif_device_detach(dev);
2108                 netif_carrier_off(dev);
2109
2110                 spin_unlock_irq(&de->lock);
2111                 enable_irq(dev->irq);
2112
2113                 /* Update the error counts. */
2114                 __de_get_stats(de);
2115
2116                 synchronize_irq(dev->irq);
2117                 de_clean_rings(de);
2118
2119                 de_adapter_sleep(de);
2120                 pci_disable_device(pdev);
2121         } else {
2122                 netif_device_detach(dev);
2123         }
2124         rtnl_unlock();
2125         return 0;
2126 }
2127
2128 static int de_resume (struct pci_dev *pdev)
2129 {
2130         struct net_device *dev = pci_get_drvdata (pdev);
2131         struct de_private *de = dev->priv;
2132         int retval = 0;
2133
2134         rtnl_lock();
2135         if (netif_device_present(dev))
2136                 goto out;
2137         if (!netif_running(dev))
2138                 goto out_attach;
2139         if ((retval = pci_enable_device(pdev))) {
2140                 printk (KERN_ERR "%s: pci_enable_device failed in resume\n",
2141                         dev->name);
2142                 goto out;
2143         }
2144         de_init_hw(de);
2145 out_attach:
2146         netif_device_attach(dev);
2147 out:
2148         rtnl_unlock();
2149         return 0;
2150 }
2151
2152 #endif /* CONFIG_PM */
2153
2154 static struct pci_driver de_driver = {
2155         .name           = DRV_NAME,
2156         .id_table       = de_pci_tbl,
2157         .probe          = de_init_one,
2158         .remove         = __devexit_p(de_remove_one),
2159 #ifdef CONFIG_PM
2160         .suspend        = de_suspend,
2161         .resume         = de_resume,
2162 #endif
2163 };
2164
2165 static int __init de_init (void)
2166 {
2167 #ifdef MODULE
2168         printk("%s", version);
2169 #endif
2170         return pci_register_driver(&de_driver);
2171 }
2172
2173 static void __exit de_exit (void)
2174 {
2175         pci_unregister_driver (&de_driver);
2176 }
2177
2178 module_init(de_init);
2179 module_exit(de_exit);