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

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