drivers/net/tulip/de2104x.c

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