git.oblomov.eu Git - linux-2.6/blob - drivers/net/tulip/de2104x.c

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