drivers/net/tulip/de2104x.c

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