drivers/net/ethernet/dec/tulip/de2104x.c

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