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