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