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