drivers/net/tulip/de2104x.c

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