SAFE public projects git trees. - safe/jmp/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 #define DE_UNALIGNED_16(a)      (u16)(get_unaligned((u16 *)(a)))
 128
 129 /* This is a mysterious value that can be written to CSR11 in the 21040 (only)
 130    to support a pre-NWay full-duplex signaling mechanism using short frames.
 131    No one knows what it should be, but if left at its default value some
 132    10base2(!) packets trigger a full-duplex-request interrupt. */
 133 #define FULL_DUPLEX_MAGIC       0x6969
 134
 135 enum {
 136         /* NIC registers */
 137         BusMode                 = 0x00,
 138         TxPoll                  = 0x08,
 139         RxPoll                  = 0x10,
 140         RxRingAddr              = 0x18,
 141         TxRingAddr              = 0x20,
 142         MacStatus               = 0x28,
 143         MacMode                 = 0x30,
 144         IntrMask                = 0x38,
 145         RxMissed                = 0x40,
 146         ROMCmd                  = 0x48,
 147         CSR11                   = 0x58,
 148         SIAStatus               = 0x60,
 149         CSR13                   = 0x68,
 150         CSR14                   = 0x70,
 151         CSR15                   = 0x78,
 152         PCIPM                   = 0x40,
 153
 154         /* BusMode bits */
 155         CmdReset                = (1 << 0),
 156         CacheAlign16            = 0x00008000,
 157         BurstLen4               = 0x00000400,
 158
 159         /* Rx/TxPoll bits */
 160         NormalTxPoll            = (1 << 0),
 161         NormalRxPoll            = (1 << 0),
 162
 163         /* Tx/Rx descriptor status bits */
 164         DescOwn                 = (1 << 31),
 165         RxError                 = (1 << 15),
 166         RxErrLong               = (1 << 7),
 167         RxErrCRC                = (1 << 1),
 168         RxErrFIFO               = (1 << 0),
 169         RxErrRunt               = (1 << 11),
 170         RxErrFrame              = (1 << 14),
 171         RingEnd                 = (1 << 25),
 172         FirstFrag               = (1 << 29),
 173         LastFrag                = (1 << 30),
 174         TxError                 = (1 << 15),
 175         TxFIFOUnder             = (1 << 1),
 176         TxLinkFail              = (1 << 2) | (1 << 10) | (1 << 11),
 177         TxMaxCol                = (1 << 8),
 178         TxOWC                   = (1 << 9),
 179         TxJabber                = (1 << 14),
 180         SetupFrame              = (1 << 27),
 181         TxSwInt                 = (1 << 31),
 182
 183         /* MacStatus bits */
 184         IntrOK                  = (1 << 16),
 185         IntrErr                 = (1 << 15),
 186         RxIntr                  = (1 << 6),
 187         RxEmpty                 = (1 << 7),
 188         TxIntr                  = (1 << 0),
 189         TxEmpty                 = (1 << 2),
 190         PciErr                  = (1 << 13),
 191         TxState                 = (1 << 22) | (1 << 21) | (1 << 20),
 192         RxState                 = (1 << 19) | (1 << 18) | (1 << 17),
 193         LinkFail                = (1 << 12),
 194         LinkPass                = (1 << 4),
 195         RxStopped               = (1 << 8),
 196         TxStopped               = (1 << 1),
 197
 198         /* MacMode bits */
 199         TxEnable                = (1 << 13),
 200         RxEnable                = (1 << 1),
 201         RxTx                    = TxEnable | RxEnable,
 202         FullDuplex              = (1 << 9),
 203         AcceptAllMulticast      = (1 << 7),
 204         AcceptAllPhys           = (1 << 6),
 205         BOCnt                   = (1 << 5),
 206         MacModeClear            = (1<<12) | (1<<11) | (1<<10) | (1<<8) | (1<<3) |
 207                                   RxTx | BOCnt | AcceptAllPhys | AcceptAllMulticast,
 208
 209         /* ROMCmd bits */
 210         EE_SHIFT_CLK            = 0x02, /* EEPROM shift clock. */
 211         EE_CS                   = 0x01, /* EEPROM chip select. */
 212         EE_DATA_WRITE           = 0x04, /* Data from the Tulip to EEPROM. */
 213         EE_WRITE_0              = 0x01,
 214         EE_WRITE_1              = 0x05,
 215         EE_DATA_READ            = 0x08, /* Data from the EEPROM chip. */
 216         EE_ENB                  = (0x4800 | EE_CS),
 217
 218         /* The EEPROM commands include the alway-set leading bit. */
 219         EE_READ_CMD             = 6,
 220
 221         /* RxMissed bits */
 222         RxMissedOver            = (1 << 16),
 223         RxMissedMask            = 0xffff,
 224
 225         /* SROM-related bits */
 226         SROMC0InfoLeaf          = 27,
 227         MediaBlockMask          = 0x3f,
 228         MediaCustomCSRs         = (1 << 6),
 229
 230         /* PCIPM bits */
 231         PM_Sleep                = (1 << 31),
 232         PM_Snooze               = (1 << 30),
 233         PM_Mask                 = PM_Sleep | PM_Snooze,
 234
 235         /* SIAStatus bits */
 236         NWayState               = (1 << 14) | (1 << 13) | (1 << 12),
 237         NWayRestart             = (1 << 12),
 238         NonselPortActive        = (1 << 9),
 239         LinkFailStatus          = (1 << 2),
 240         NetCxnErr               = (1 << 1),
 241 };
 242
 243 static const u32 de_intr_mask =
 244         IntrOK | IntrErr | RxIntr | RxEmpty | TxIntr | TxEmpty |
 245         LinkPass | LinkFail | PciErr;
 246
 247 /*
 248  * Set the programmable burst length to 4 longwords for all:
 249  * DMA errors result without these values. Cache align 16 long.
 250  */
 251 static const u32 de_bus_mode = CacheAlign16 | BurstLen4;
 252
 253 struct de_srom_media_block {
 254         u8                      opts;
 255         u16                     csr13;
 256         u16                     csr14;
 257         u16                     csr15;
 258 } __attribute__((packed));
 259
 260 struct de_srom_info_leaf {
 261         u16                     default_media;
 262         u8                      n_blocks;
 263         u8                      unused;
 264 } __attribute__((packed));
 265
 266 struct de_desc {
 267         u32                     opts1;
 268         u32                     opts2;
 269         u32                     addr1;
 270         u32                     addr2;
 271 };
 272
 273 struct media_info {
 274         u16                     type;   /* DE_MEDIA_xxx */
 275         u16                     csr13;
 276         u16                     csr14;
 277         u16                     csr15;
 278 };
 279
 280 struct ring_info {
 281         struct sk_buff          *skb;
 282         dma_addr_t              mapping;
 283 };
 284
 285 struct de_private {
 286         unsigned                tx_head;
 287         unsigned                tx_tail;
 288         unsigned                rx_tail;
 289
 290         void                    __iomem *regs;
 291         struct net_device       *dev;
 292         spinlock_t              lock;
 293
 294         struct de_desc          *rx_ring;
 295         struct de_desc          *tx_ring;
 296         struct ring_info        tx_skb[DE_TX_RING_SIZE];
 297         struct ring_info        rx_skb[DE_RX_RING_SIZE];
 298         unsigned                rx_buf_sz;
 299         dma_addr_t              ring_dma;
 300
 301         u32                     msg_enable;
 302
 303         struct net_device_stats net_stats;
 304
 305         struct pci_dev          *pdev;
 306
 307         u16                     setup_frame[DE_SETUP_FRAME_WORDS];
 308
 309         u32                     media_type;
 310         u32                     media_supported;
 311         u32                     media_advertise;
 312         struct media_info       media[DE_MAX_MEDIA];
 313         struct timer_list       media_timer;
 314
 315         u8                      *ee_data;
 316         unsigned                board_idx;
 317         unsigned                de21040 : 1;
 318         unsigned                media_lock : 1;
 319 };
 320
 321
 322 static void de_set_rx_mode (struct net_device *dev);
 323 static void de_tx (struct de_private *de);
 324 static void de_clean_rings (struct de_private *de);
 325 static void de_media_interrupt (struct de_private *de, u32 status);
 326 static void de21040_media_timer (unsigned long data);
 327 static void de21041_media_timer (unsigned long data);
 328 static unsigned int de_ok_to_advertise (struct de_private *de, u32 new_media);
 329
 330
 331 static struct pci_device_id de_pci_tbl[] = {
 332         { PCI_VENDOR_ID_DEC, PCI_DEVICE_ID_DEC_TULIP,
 333           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
 334         { PCI_VENDOR_ID_DEC, PCI_DEVICE_ID_DEC_TULIP_PLUS,
 335           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 1 },
 336         { },
 337 };
 338 MODULE_DEVICE_TABLE(pci, de_pci_tbl);
 339
 340 static const char * const media_name[DE_MAX_MEDIA] = {
 341         "10baseT auto",
 342         "BNC",
 343         "AUI",
 344         "10baseT-HD",
 345         "10baseT-FD"
 346 };
 347
 348 /* 21040 transceiver register settings:
 349  * TP AUTO(unused), BNC(unused), AUI, TP, TP FD*/
 350 static u16 t21040_csr13[] = { 0, 0, 0x8F09, 0x8F01, 0x8F01, };
 351 static u16 t21040_csr14[] = { 0, 0, 0x0705, 0xFFFF, 0xFFFD, };
 352 static u16 t21040_csr15[] = { 0, 0, 0x0006, 0x0000, 0x0000, };
 353
 354 /* 21041 transceiver register settings: TP AUTO, BNC, AUI, TP, TP FD*/
 355 static u16 t21041_csr13[] = { 0xEF01, 0xEF09, 0xEF09, 0xEF01, 0xEF09, };
 356 static u16 t21041_csr14[] = { 0xFFFF, 0xF7FD, 0xF7FD, 0x6F3F, 0x6F3D, };
 357 static u16 t21041_csr15[] = { 0x0008, 0x0006, 0x000E, 0x0008, 0x0008, };
 358
 359
 360 #define dr32(reg)               readl(de->regs + (reg))
 361 #define dw32(reg,val)           writel((val), de->regs + (reg))
 362
 363
 364 static void de_rx_err_acct (struct de_private *de, unsigned rx_tail,
 365                             u32 status, u32 len)
 366 {
 367         if (netif_msg_rx_err (de))
 368                 printk (KERN_DEBUG
 369                         "%s: rx err, slot %d status 0x%x len %d\n",
 370                         de->dev->name, rx_tail, status, len);
 371
 372         if ((status & 0x38000300) != 0x0300) {
 373                 /* Ingore earlier buffers. */
 374                 if ((status & 0xffff) != 0x7fff) {
 375                         if (netif_msg_rx_err(de))
 376                                 printk(KERN_WARNING "%s: Oversized Ethernet frame "
 377                                            "spanned multiple buffers, status %8.8x!\n",
 378                                            de->dev->name, status);
 379                         de->net_stats.rx_length_errors++;
 380                 }
 381         } else if (status & RxError) {
 382                 /* There was a fatal error. */
 383                 de->net_stats.rx_errors++; /* end of a packet.*/
 384                 if (status & 0x0890) de->net_stats.rx_length_errors++;
 385                 if (status & RxErrCRC) de->net_stats.rx_crc_errors++;
 386                 if (status & RxErrFIFO) de->net_stats.rx_fifo_errors++;
 387         }
 388 }
 389
 390 static void de_rx (struct de_private *de)
 391 {
 392         unsigned rx_tail = de->rx_tail;
 393         unsigned rx_work = DE_RX_RING_SIZE;
 394         unsigned drop = 0;
 395         int rc;
 396
 397         while (rx_work--) {
 398                 u32 status, len;
 399                 dma_addr_t mapping;
 400                 struct sk_buff *skb, *copy_skb;
 401                 unsigned copying_skb, buflen;
 402
 403                 skb = de->rx_skb[rx_tail].skb;
 404                 BUG_ON(!skb);
 405                 rmb();
 406                 status = le32_to_cpu(de->rx_ring[rx_tail].opts1);
 407                 if (status & DescOwn)
 408                         break;
 409
 410                 len = ((status >> 16) & 0x7ff) - 4;
 411                 mapping = de->rx_skb[rx_tail].mapping;
 412
 413                 if (unlikely(drop)) {
 414                         de->net_stats.rx_dropped++;
 415                         goto rx_next;
 416                 }
 417
 418                 if (unlikely((status & 0x38008300) != 0x0300)) {
 419                         de_rx_err_acct(de, rx_tail, status, len);
 420                         goto rx_next;
 421                 }
 422
 423                 copying_skb = (len <= rx_copybreak);
 424
 425                 if (unlikely(netif_msg_rx_status(de)))
 426                         printk(KERN_DEBUG "%s: rx slot %d status 0x%x len %d copying? %d\n",
 427                                de->dev->name, rx_tail, status, len,
 428                                copying_skb);
 429
 430                 buflen = copying_skb ? (len + RX_OFFSET) : de->rx_buf_sz;
 431                 copy_skb = dev_alloc_skb (buflen);
 432                 if (unlikely(!copy_skb)) {
 433                         de->net_stats.rx_dropped++;
 434                         drop = 1;
 435                         rx_work = 100;
 436                         goto rx_next;
 437                 }
 438
 439                 if (!copying_skb) {
 440                         pci_unmap_single(de->pdev, mapping,
 441                                          buflen, PCI_DMA_FROMDEVICE);
 442                         skb_put(skb, len);
 443
 444                         mapping =
 445                         de->rx_skb[rx_tail].mapping =
 446                                 pci_map_single(de->pdev, copy_skb->data,
 447                                                buflen, PCI_DMA_FROMDEVICE);
 448                         de->rx_skb[rx_tail].skb = copy_skb;
 449                 } else {
 450                         pci_dma_sync_single_for_cpu(de->pdev, mapping, len, PCI_DMA_FROMDEVICE);
 451                         skb_reserve(copy_skb, RX_OFFSET);
 452                         skb_copy_from_linear_data(skb, skb_put(copy_skb, len),
 453                                                   len);
 454                         pci_dma_sync_single_for_device(de->pdev, mapping, len, PCI_DMA_FROMDEVICE);
 455
 456                         /* We'll reuse the original ring buffer. */
 457                         skb = copy_skb;
 458                 }
 459
 460                 skb->protocol = eth_type_trans (skb, de->dev);
 461
 462                 de->net_stats.rx_packets++;
 463                 de->net_stats.rx_bytes += skb->len;
 464                 de->dev->last_rx = jiffies;
 465                 rc = netif_rx (skb);
 466                 if (rc == NET_RX_DROP)
 467                         drop = 1;
 468
 469 rx_next:
 470                 de->rx_ring[rx_tail].opts1 = cpu_to_le32(DescOwn);
 471                 if (rx_tail == (DE_RX_RING_SIZE - 1))
 472                         de->rx_ring[rx_tail].opts2 =
 473                                 cpu_to_le32(RingEnd | de->rx_buf_sz);
 474                 else
 475                         de->rx_ring[rx_tail].opts2 = cpu_to_le32(de->rx_buf_sz);
 476                 de->rx_ring[rx_tail].addr1 = cpu_to_le32(mapping);
 477                 rx_tail = NEXT_RX(rx_tail);
 478         }
 479
 480         if (!rx_work)
 481                 printk(KERN_WARNING "%s: rx work limit reached\n", de->dev->name);
 482
 483         de->rx_tail = rx_tail;
 484 }
 485
 486 static irqreturn_t de_interrupt (int irq, void *dev_instance)
 487 {
 488         struct net_device *dev = dev_instance;
 489         struct de_private *de = dev->priv;
 490         u32 status;
 491
 492         status = dr32(MacStatus);
 493         if ((!(status & (IntrOK|IntrErr))) || (status == 0xFFFF))
 494                 return IRQ_NONE;
 495
 496         if (netif_msg_intr(de))
 497                 printk(KERN_DEBUG "%s: intr, status %08x mode %08x desc %u/%u/%u\n",
 498                         dev->name, status, dr32(MacMode), de->rx_tail, de->tx_head, de->tx_tail);
 499
 500         dw32(MacStatus, status);
 501
 502         if (status & (RxIntr | RxEmpty)) {
 503                 de_rx(de);
 504                 if (status & RxEmpty)
 505                         dw32(RxPoll, NormalRxPoll);
 506         }
 507
 508         spin_lock(&de->lock);
 509
 510         if (status & (TxIntr | TxEmpty))
 511                 de_tx(de);
 512
 513         if (status & (LinkPass | LinkFail))
 514                 de_media_interrupt(de, status);
 515
 516         spin_unlock(&de->lock);
 517
 518         if (status & PciErr) {
 519                 u16 pci_status;
 520
 521                 pci_read_config_word(de->pdev, PCI_STATUS, &pci_status);
 522                 pci_write_config_word(de->pdev, PCI_STATUS, pci_status);
 523                 printk(KERN_ERR "%s: PCI bus error, status=%08x, PCI status=%04x\n",
 524                        dev->name, status, pci_status);
 525         }
 526
 527         return IRQ_HANDLED;
 528 }
 529
 530 static void de_tx (struct de_private *de)
 531 {
 532         unsigned tx_head = de->tx_head;
 533         unsigned tx_tail = de->tx_tail;
 534
 535         while (tx_tail != tx_head) {
 536                 struct sk_buff *skb;
 537                 u32 status;
 538
 539                 rmb();
 540                 status = le32_to_cpu(de->tx_ring[tx_tail].opts1);
 541                 if (status & DescOwn)
 542                         break;
 543
 544                 skb = de->tx_skb[tx_tail].skb;
 545                 BUG_ON(!skb);
 546                 if (unlikely(skb == DE_DUMMY_SKB))
 547                         goto next;
 548
 549                 if (unlikely(skb == DE_SETUP_SKB)) {
 550                         pci_unmap_single(de->pdev, de->tx_skb[tx_tail].mapping,
 551                                          sizeof(de->setup_frame), PCI_DMA_TODEVICE);
 552                         goto next;
 553                 }
 554
 555                 pci_unmap_single(de->pdev, de->tx_skb[tx_tail].mapping,
 556                                  skb->len, PCI_DMA_TODEVICE);
 557
 558                 if (status & LastFrag) {
 559                         if (status & TxError) {
 560                                 if (netif_msg_tx_err(de))
 561                                         printk(KERN_DEBUG "%s: tx err, status 0x%x\n",
 562                                                de->dev->name, status);
 563                                 de->net_stats.tx_errors++;
 564                                 if (status & TxOWC)
 565                                         de->net_stats.tx_window_errors++;
 566                                 if (status & TxMaxCol)
 567                                         de->net_stats.tx_aborted_errors++;
 568                                 if (status & TxLinkFail)
 569                                         de->net_stats.tx_carrier_errors++;
 570                                 if (status & TxFIFOUnder)
 571                                         de->net_stats.tx_fifo_errors++;
 572                         } else {
 573                                 de->net_stats.tx_packets++;
 574                                 de->net_stats.tx_bytes += skb->len;
 575                                 if (netif_msg_tx_done(de))
 576                                         printk(KERN_DEBUG "%s: tx done, slot %d\n", de->dev->name, tx_tail);
 577                         }
 578                         dev_kfree_skb_irq(skb);
 579                 }
 580
 581 next:
 582                 de->tx_skb[tx_tail].skb = NULL;
 583
 584                 tx_tail = NEXT_TX(tx_tail);
 585         }
 586
 587         de->tx_tail = tx_tail;
 588
 589         if (netif_queue_stopped(de->dev) && (TX_BUFFS_AVAIL(de) > (DE_TX_RING_SIZE / 4)))
 590                 netif_wake_queue(de->dev);
 591 }
 592
 593 static int de_start_xmit (struct sk_buff *skb, struct net_device *dev)
 594 {
 595         struct de_private *de = dev->priv;
 596         unsigned int entry, tx_free;
 597         u32 mapping, len, flags = FirstFrag | LastFrag;
 598         struct de_desc *txd;
 599
 600         spin_lock_irq(&de->lock);
 601
 602         tx_free = TX_BUFFS_AVAIL(de);
 603         if (tx_free == 0) {
 604                 netif_stop_queue(dev);
 605                 spin_unlock_irq(&de->lock);
 606                 return 1;
 607         }
 608         tx_free--;
 609
 610         entry = de->tx_head;
 611
 612         txd = &de->tx_ring[entry];
 613
 614         len = skb->len;
 615         mapping = pci_map_single(de->pdev, skb->data, len, PCI_DMA_TODEVICE);
 616         if (entry == (DE_TX_RING_SIZE - 1))
 617                 flags |= RingEnd;
 618         if (!tx_free || (tx_free == (DE_TX_RING_SIZE / 2)))
 619                 flags |= TxSwInt;
 620         flags |= len;
 621         txd->opts2 = cpu_to_le32(flags);
 622         txd->addr1 = cpu_to_le32(mapping);
 623
 624         de->tx_skb[entry].skb = skb;
 625         de->tx_skb[entry].mapping = mapping;
 626         wmb();
 627
 628         txd->opts1 = cpu_to_le32(DescOwn);
 629         wmb();
 630
 631         de->tx_head = NEXT_TX(entry);
 632         if (netif_msg_tx_queued(de))
 633                 printk(KERN_DEBUG "%s: tx queued, slot %d, skblen %d\n",
 634                        dev->name, entry, skb->len);
 635
 636         if (tx_free == 0)
 637                 netif_stop_queue(dev);
 638
 639         spin_unlock_irq(&de->lock);
 640
 641         /* Trigger an immediate transmit demand. */
 642         dw32(TxPoll, NormalTxPoll);
 643         dev->trans_start = jiffies;
 644
 645         return 0;
 646 }
 647
 648 /* Set or clear the multicast filter for this adaptor.
 649    Note that we only use exclusion around actually queueing the
 650    new frame, not around filling de->setup_frame.  This is non-deterministic
 651    when re-entered but still correct. */
 652
 653 #undef set_bit_le
 654 #define set_bit_le(i,p) do { ((char *)(p))[(i)/8] |= (1<<((i)%8)); } while(0)
 655
 656 static void build_setup_frame_hash(u16 *setup_frm, struct net_device *dev)
 657 {
 658         struct de_private *de = dev->priv;
 659         u16 hash_table[32];
 660         struct dev_mc_list *mclist;
 661         int i;
 662         u16 *eaddrs;
 663
 664         memset(hash_table, 0, sizeof(hash_table));
 665         set_bit_le(255, hash_table);                    /* Broadcast entry */
 666         /* This should work on big-endian machines as well. */
 667         for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count;
 668              i++, mclist = mclist->next) {
 669                 int index = ether_crc_le(ETH_ALEN, mclist->dmi_addr) & 0x1ff;
 670
 671                 set_bit_le(index, hash_table);
 672
 673                 for (i = 0; i < 32; i++) {
 674                         *setup_frm++ = hash_table[i];
 675                         *setup_frm++ = hash_table[i];
 676                 }
 677                 setup_frm = &de->setup_frame[13*6];
 678         }
 679
 680         /* Fill the final entry with our physical address. */
 681         eaddrs = (u16 *)dev->dev_addr;
 682         *setup_frm++ = eaddrs[0]; *setup_frm++ = eaddrs[0];
 683         *setup_frm++ = eaddrs[1]; *setup_frm++ = eaddrs[1];
 684         *setup_frm++ = eaddrs[2]; *setup_frm++ = eaddrs[2];
 685 }
 686
 687 static void build_setup_frame_perfect(u16 *setup_frm, struct net_device *dev)
 688 {
 689         struct de_private *de = dev->priv;
 690         struct dev_mc_list *mclist;
 691         int i;
 692         u16 *eaddrs;
 693
 694         /* We have <= 14 addresses so we can use the wonderful
 695            16 address perfect filtering of the Tulip. */
 696         for (i = 0, mclist = dev->mc_list; i < dev->mc_count;
 697              i++, mclist = mclist->next) {
 698                 eaddrs = (u16 *)mclist->dmi_addr;
 699                 *setup_frm++ = *eaddrs; *setup_frm++ = *eaddrs++;
 700                 *setup_frm++ = *eaddrs; *setup_frm++ = *eaddrs++;
 701                 *setup_frm++ = *eaddrs; *setup_frm++ = *eaddrs++;
 702         }
 703         /* Fill the unused entries with the broadcast address. */
 704         memset(setup_frm, 0xff, (15-i)*12);
 705         setup_frm = &de->setup_frame[15*6];
 706
 707         /* Fill the final entry with our physical address. */
 708         eaddrs = (u16 *)dev->dev_addr;
 709         *setup_frm++ = eaddrs[0]; *setup_frm++ = eaddrs[0];
 710         *setup_frm++ = eaddrs[1]; *setup_frm++ = eaddrs[1];
 711         *setup_frm++ = eaddrs[2]; *setup_frm++ = eaddrs[2];
 712 }
 713
 714
 715 static void __de_set_rx_mode (struct net_device *dev)
 716 {
 717         struct de_private *de = dev->priv;
 718         u32 macmode;
 719         unsigned int entry;
 720         u32 mapping;
 721         struct de_desc *txd;
 722         struct de_desc *dummy_txd = NULL;
 723
 724         macmode = dr32(MacMode) & ~(AcceptAllMulticast | AcceptAllPhys);
 725
 726         if (dev->flags & IFF_PROMISC) { /* Set promiscuous. */
 727                 macmode |= AcceptAllMulticast | AcceptAllPhys;
 728                 goto out;
 729         }
 730
 731         if ((dev->mc_count > 1000) || (dev->flags & IFF_ALLMULTI)) {
 732                 /* Too many to filter well -- accept all multicasts. */
 733                 macmode |= AcceptAllMulticast;
 734                 goto out;
 735         }
 736
 737         /* Note that only the low-address shortword of setup_frame is valid!
 738            The values are doubled for big-endian architectures. */
 739         if (dev->mc_count > 14) /* Must use a multicast hash table. */
 740                 build_setup_frame_hash (de->setup_frame, dev);
 741         else
 742                 build_setup_frame_perfect (de->setup_frame, dev);
 743
 744         /*
 745          * Now add this frame to the Tx list.
 746          */
 747
 748         entry = de->tx_head;
 749
 750         /* Avoid a chip errata by prefixing a dummy entry. */
 751         if (entry != 0) {
 752                 de->tx_skb[entry].skb = DE_DUMMY_SKB;
 753
 754                 dummy_txd = &de->tx_ring[entry];
 755                 dummy_txd->opts2 = (entry == (DE_TX_RING_SIZE - 1)) ?
 756                                    cpu_to_le32(RingEnd) : 0;
 757                 dummy_txd->addr1 = 0;
 758
 759                 /* Must set DescOwned later to avoid race with chip */
 760
 761                 entry = NEXT_TX(entry);
 762         }
 763
 764         de->tx_skb[entry].skb = DE_SETUP_SKB;
 765         de->tx_skb[entry].mapping = mapping =
 766             pci_map_single (de->pdev, de->setup_frame,
 767                             sizeof (de->setup_frame), PCI_DMA_TODEVICE);
 768
 769         /* Put the setup frame on the Tx list. */
 770         txd = &de->tx_ring[entry];
 771         if (entry == (DE_TX_RING_SIZE - 1))
 772                 txd->opts2 = cpu_to_le32(SetupFrame | RingEnd | sizeof (de->setup_frame));
 773         else
 774                 txd->opts2 = cpu_to_le32(SetupFrame | sizeof (de->setup_frame));
 775         txd->addr1 = cpu_to_le32(mapping);
 776         wmb();
 777
 778         txd->opts1 = cpu_to_le32(DescOwn);
 779         wmb();
 780
 781         if (dummy_txd) {
 782                 dummy_txd->opts1 = cpu_to_le32(DescOwn);
 783                 wmb();
 784         }
 785
 786         de->tx_head = NEXT_TX(entry);
 787
 788         if (TX_BUFFS_AVAIL(de) == 0)
 789                 netif_stop_queue(dev);
 790
 791         /* Trigger an immediate transmit demand. */
 792         dw32(TxPoll, NormalTxPoll);
 793
 794 out:
 795         if (macmode != dr32(MacMode))
 796                 dw32(MacMode, macmode);
 797 }
 798
 799 static void de_set_rx_mode (struct net_device *dev)
 800 {
 801         unsigned long flags;
 802         struct de_private *de = dev->priv;
 803
 804         spin_lock_irqsave (&de->lock, flags);
 805         __de_set_rx_mode(dev);
 806         spin_unlock_irqrestore (&de->lock, flags);
 807 }
 808
 809 static inline void de_rx_missed(struct de_private *de, u32 rx_missed)
 810 {
 811         if (unlikely(rx_missed & RxMissedOver))
 812                 de->net_stats.rx_missed_errors += RxMissedMask;
 813         else
 814                 de->net_stats.rx_missed_errors += (rx_missed & RxMissedMask);
 815 }
 816
 817 static void __de_get_stats(struct de_private *de)
 818 {
 819         u32 tmp = dr32(RxMissed); /* self-clearing */
 820
 821         de_rx_missed(de, tmp);
 822 }
 823
 824 static struct net_device_stats *de_get_stats(struct net_device *dev)
 825 {
 826         struct de_private *de = dev->priv;
 827
 828         /* The chip only need report frame silently dropped. */
 829         spin_lock_irq(&de->lock);
 830         if (netif_running(dev) && netif_device_present(dev))
 831                 __de_get_stats(de);
 832         spin_unlock_irq(&de->lock);
 833
 834         return &de->net_stats;
 835 }
 836
 837 static inline int de_is_running (struct de_private *de)
 838 {
 839         return (dr32(MacStatus) & (RxState | TxState)) ? 1 : 0;
 840 }
 841
 842 static void de_stop_rxtx (struct de_private *de)
 843 {
 844         u32 macmode;
 845         unsigned int work = 1000;
 846
 847         macmode = dr32(MacMode);
 848         if (macmode & RxTx) {
 849                 dw32(MacMode, macmode & ~RxTx);
 850                 dr32(MacMode);
 851         }
 852
 853         while (--work > 0) {
 854                 if (!de_is_running(de))
 855                         return;
 856                 cpu_relax();
 857         }
 858
 859         printk(KERN_WARNING "%s: timeout expired stopping DMA\n", de->dev->name);
 860 }
 861
 862 static inline void de_start_rxtx (struct de_private *de)
 863 {
 864         u32 macmode;
 865
 866         macmode = dr32(MacMode);
 867         if ((macmode & RxTx) != RxTx) {
 868                 dw32(MacMode, macmode | RxTx);
 869                 dr32(MacMode);
 870         }
 871 }
 872
 873 static void de_stop_hw (struct de_private *de)
 874 {
 875
 876         udelay(5);
 877         dw32(IntrMask, 0);
 878
 879         de_stop_rxtx(de);
 880
 881         dw32(MacStatus, dr32(MacStatus));
 882
 883         udelay(10);
 884
 885         de->rx_tail = 0;
 886         de->tx_head = de->tx_tail = 0;
 887 }
 888
 889 static void de_link_up(struct de_private *de)
 890 {
 891         if (!netif_carrier_ok(de->dev)) {
 892                 netif_carrier_on(de->dev);
 893                 if (netif_msg_link(de))
 894                         printk(KERN_INFO "%s: link up, media %s\n",
 895                                de->dev->name, media_name[de->media_type]);
 896         }
 897 }
 898
 899 static void de_link_down(struct de_private *de)
 900 {
 901         if (netif_carrier_ok(de->dev)) {
 902                 netif_carrier_off(de->dev);
 903                 if (netif_msg_link(de))
 904                         printk(KERN_INFO "%s: link down\n", de->dev->name);
 905         }
 906 }
 907
 908 static void de_set_media (struct de_private *de)
 909 {
 910         unsigned media = de->media_type;
 911         u32 macmode = dr32(MacMode);
 912
 913         BUG_ON(de_is_running(de));
 914
 915         if (de->de21040)
 916                 dw32(CSR11, FULL_DUPLEX_MAGIC);
 917         dw32(CSR13, 0); /* Reset phy */
 918         dw32(CSR14, de->media[media].csr14);
 919         dw32(CSR15, de->media[media].csr15);
 920         dw32(CSR13, de->media[media].csr13);
 921
 922         /* must delay 10ms before writing to other registers,
 923          * especially CSR6
 924          */
 925         mdelay(10);
 926
 927         if (media == DE_MEDIA_TP_FD)
 928                 macmode |= FullDuplex;
 929         else
 930                 macmode &= ~FullDuplex;
 931
 932         if (netif_msg_link(de)) {
 933                 printk(KERN_INFO "%s: set link %s\n"
 934                        KERN_INFO "%s:    mode 0x%x, sia 0x%x,0x%x,0x%x,0x%x\n"
 935                        KERN_INFO "%s:    set mode 0x%x, set sia 0x%x,0x%x,0x%x\n",
 936                        de->dev->name, media_name[media],
 937                        de->dev->name, dr32(MacMode), dr32(SIAStatus),
 938                        dr32(CSR13), dr32(CSR14), dr32(CSR15),
 939                        de->dev->name, macmode, de->media[media].csr13,
 940                        de->media[media].csr14, de->media[media].csr15);
 941         }
 942         if (macmode != dr32(MacMode))
 943                 dw32(MacMode, macmode);
 944 }
 945
 946 static void de_next_media (struct de_private *de, u32 *media,
 947                            unsigned int n_media)
 948 {
 949         unsigned int i;
 950
 951         for (i = 0; i < n_media; i++) {
 952                 if (de_ok_to_advertise(de, media[i])) {
 953                         de->media_type = media[i];
 954                         return;
 955                 }
 956         }
 957 }
 958
 959 static void de21040_media_timer (unsigned long data)
 960 {
 961         struct de_private *de = (struct de_private *) data;
 962         struct net_device *dev = de->dev;
 963         u32 status = dr32(SIAStatus);
 964         unsigned int carrier;
 965         unsigned long flags;
 966
 967         carrier = (status & NetCxnErr) ? 0 : 1;
 968
 969         if (carrier) {
 970                 if (de->media_type != DE_MEDIA_AUI && (status & LinkFailStatus))
 971                         goto no_link_yet;
 972
 973                 de->media_timer.expires = jiffies + DE_TIMER_LINK;
 974                 add_timer(&de->media_timer);
 975                 if (!netif_carrier_ok(dev))
 976                         de_link_up(de);
 977                 else
 978                         if (netif_msg_timer(de))
 979                                 printk(KERN_INFO "%s: %s link ok, status %x\n",
 980                                        dev->name, media_name[de->media_type],
 981                                        status);
 982                 return;
 983         }
 984
 985         de_link_down(de);
 986
 987         if (de->media_lock)
 988                 return;
 989
 990         if (de->media_type == DE_MEDIA_AUI) {
 991                 u32 next_state = DE_MEDIA_TP;
 992                 de_next_media(de, &next_state, 1);
 993         } else {
 994                 u32 next_state = DE_MEDIA_AUI;
 995                 de_next_media(de, &next_state, 1);
 996         }
 997
 998         spin_lock_irqsave(&de->lock, flags);
 999         de_stop_rxtx(de);
1000         spin_unlock_irqrestore(&de->lock, flags);
1001         de_set_media(de);
1002         de_start_rxtx(de);
1003
1004 no_link_yet:
1005         de->media_timer.expires = jiffies + DE_TIMER_NO_LINK;
1006         add_timer(&de->media_timer);
1007
1008         if (netif_msg_timer(de))
1009                 printk(KERN_INFO "%s: no link, trying media %s, status %x\n",
1010                        dev->name, media_name[de->media_type], status);
1011 }
1012
1013 static unsigned int de_ok_to_advertise (struct de_private *de, u32 new_media)
1014 {
1015         switch (new_media) {
1016         case DE_MEDIA_TP_AUTO:
1017                 if (!(de->media_advertise & ADVERTISED_Autoneg))
1018                         return 0;
1019                 if (!(de->media_advertise & (ADVERTISED_10baseT_Half | ADVERTISED_10baseT_Full)))
1020                         return 0;
1021                 break;
1022         case DE_MEDIA_BNC:
1023                 if (!(de->media_advertise & ADVERTISED_BNC))
1024                         return 0;
1025                 break;
1026         case DE_MEDIA_AUI:
1027                 if (!(de->media_advertise & ADVERTISED_AUI))
1028                         return 0;
1029                 break;
1030         case DE_MEDIA_TP:
1031                 if (!(de->media_advertise & ADVERTISED_10baseT_Half))
1032                         return 0;
1033                 break;
1034         case DE_MEDIA_TP_FD:
1035                 if (!(de->media_advertise & ADVERTISED_10baseT_Full))
1036                         return 0;
1037                 break;
1038         }
1039
1040         return 1;
1041 }
1042
1043 static void de21041_media_timer (unsigned long data)
1044 {
1045         struct de_private *de = (struct de_private *) data;
1046         struct net_device *dev = de->dev;
1047         u32 status = dr32(SIAStatus);
1048         unsigned int carrier;
1049         unsigned long flags;
1050
1051         carrier = (status & NetCxnErr) ? 0 : 1;
1052
1053         if (carrier) {
1054                 if ((de->media_type == DE_MEDIA_TP_AUTO ||
1055                      de->media_type == DE_MEDIA_TP ||
1056                      de->media_type == DE_MEDIA_TP_FD) &&
1057                     (status & LinkFailStatus))
1058                         goto no_link_yet;
1059
1060                 de->media_timer.expires = jiffies + DE_TIMER_LINK;
1061                 add_timer(&de->media_timer);
1062                 if (!netif_carrier_ok(dev))
1063                         de_link_up(de);
1064                 else
1065                         if (netif_msg_timer(de))
1066                                 printk(KERN_INFO "%s: %s link ok, mode %x status %x\n",
1067                                        dev->name, media_name[de->media_type],
1068                                        dr32(MacMode), status);
1069                 return;
1070         }
1071
1072         de_link_down(de);
1073
1074         /* if media type locked, don't switch media */
1075         if (de->media_lock)
1076                 goto set_media;
1077
1078         /* if activity detected, use that as hint for new media type */
1079         if (status & NonselPortActive) {
1080                 unsigned int have_media = 1;
1081
1082                 /* if AUI/BNC selected, then activity is on TP port */
1083                 if (de->media_type == DE_MEDIA_AUI ||
1084                     de->media_type == DE_MEDIA_BNC) {
1085                         if (de_ok_to_advertise(de, DE_MEDIA_TP_AUTO))
1086                                 de->media_type = DE_MEDIA_TP_AUTO;
1087                         else
1088                                 have_media = 0;
1089                 }
1090
1091                 /* TP selected.  If there is only TP and BNC, then it's BNC */
1092                 else if (((de->media_supported & DE_AUI_BNC) == SUPPORTED_BNC) &&
1093                          de_ok_to_advertise(de, DE_MEDIA_BNC))
1094                         de->media_type = DE_MEDIA_BNC;
1095
1096                 /* TP selected.  If there is only TP and AUI, then it's AUI */
1097                 else if (((de->media_supported & DE_AUI_BNC) == SUPPORTED_AUI) &&
1098                          de_ok_to_advertise(de, DE_MEDIA_AUI))
1099                         de->media_type = DE_MEDIA_AUI;
1100
1101                 /* otherwise, ignore the hint */
1102                 else
1103                         have_media = 0;
1104
1105                 if (have_media)
1106                         goto set_media;
1107         }
1108
1109         /*
1110          * Absent or ambiguous activity hint, move to next advertised
1111          * media state.  If de->media_type is left unchanged, this
1112          * simply resets the PHY and reloads the current media settings.
1113          */
1114         if (de->media_type == DE_MEDIA_AUI) {
1115                 u32 next_states[] = { DE_MEDIA_BNC, DE_MEDIA_TP_AUTO };
1116                 de_next_media(de, next_states, ARRAY_SIZE(next_states));
1117         } else if (de->media_type == DE_MEDIA_BNC) {
1118                 u32 next_states[] = { DE_MEDIA_TP_AUTO, DE_MEDIA_AUI };
1119                 de_next_media(de, next_states, ARRAY_SIZE(next_states));
1120         } else {
1121                 u32 next_states[] = { DE_MEDIA_AUI, DE_MEDIA_BNC, DE_MEDIA_TP_AUTO };
1122                 de_next_media(de, next_states, ARRAY_SIZE(next_states));
1123         }
1124
1125 set_media:
1126         spin_lock_irqsave(&de->lock, flags);
1127         de_stop_rxtx(de);
1128         spin_unlock_irqrestore(&de->lock, flags);
1129         de_set_media(de);
1130         de_start_rxtx(de);
1131
1132 no_link_yet:
1133         de->media_timer.expires = jiffies + DE_TIMER_NO_LINK;
1134         add_timer(&de->media_timer);
1135
1136         if (netif_msg_timer(de))
1137                 printk(KERN_INFO "%s: no link, trying media %s, status %x\n",
1138                        dev->name, media_name[de->media_type], status);
1139 }
1140
1141 static void de_media_interrupt (struct de_private *de, u32 status)
1142 {
1143         if (status & LinkPass) {
1144                 de_link_up(de);
1145                 mod_timer(&de->media_timer, jiffies + DE_TIMER_LINK);
1146                 return;
1147         }
1148
1149         BUG_ON(!(status & LinkFail));
1150
1151         if (netif_carrier_ok(de->dev)) {
1152                 de_link_down(de);
1153                 mod_timer(&de->media_timer, jiffies + DE_TIMER_NO_LINK);
1154         }
1155 }
1156
1157 static int de_reset_mac (struct de_private *de)
1158 {
1159         u32 status, tmp;
1160
1161         /*
1162          * Reset MAC.  de4x5.c and tulip.c examined for "advice"
1163          * in this area.
1164          */
1165
1166         if (dr32(BusMode) == 0xffffffff)
1167                 return -EBUSY;
1168
1169         /* Reset the chip, holding bit 0 set at least 50 PCI cycles. */
1170         dw32 (BusMode, CmdReset);
1171         mdelay (1);
1172
1173         dw32 (BusMode, de_bus_mode);
1174         mdelay (1);
1175
1176         for (tmp = 0; tmp < 5; tmp++) {
1177                 dr32 (BusMode);
1178                 mdelay (1);
1179         }
1180
1181         mdelay (1);
1182
1183         status = dr32(MacStatus);
1184         if (status & (RxState | TxState))
1185                 return -EBUSY;
1186         if (status == 0xffffffff)
1187                 return -ENODEV;
1188         return 0;
1189 }
1190
1191 static void de_adapter_wake (struct de_private *de)
1192 {
1193         u32 pmctl;
1194
1195         if (de->de21040)
1196                 return;
1197
1198         pci_read_config_dword(de->pdev, PCIPM, &pmctl);
1199         if (pmctl & PM_Mask) {
1200                 pmctl &= ~PM_Mask;
1201                 pci_write_config_dword(de->pdev, PCIPM, pmctl);
1202
1203                 /* de4x5.c delays, so we do too */
1204                 msleep(10);
1205         }
1206 }
1207
1208 static void de_adapter_sleep (struct de_private *de)
1209 {
1210         u32 pmctl;
1211
1212         if (de->de21040)
1213                 return;
1214
1215         pci_read_config_dword(de->pdev, PCIPM, &pmctl);
1216         pmctl |= PM_Sleep;
1217         pci_write_config_dword(de->pdev, PCIPM, pmctl);
1218 }
1219
1220 static int de_init_hw (struct de_private *de)
1221 {
1222         struct net_device *dev = de->dev;
1223         u32 macmode;
1224         int rc;
1225
1226         de_adapter_wake(de);
1227
1228         macmode = dr32(MacMode) & ~MacModeClear;
1229
1230         rc = de_reset_mac(de);
1231         if (rc)
1232                 return rc;
1233
1234         de_set_media(de); /* reset phy */
1235
1236         dw32(RxRingAddr, de->ring_dma);
1237         dw32(TxRingAddr, de->ring_dma + (sizeof(struct de_desc) * DE_RX_RING_SIZE));
1238
1239         dw32(MacMode, RxTx | macmode);
1240
1241         dr32(RxMissed); /* self-clearing */
1242
1243         dw32(IntrMask, de_intr_mask);
1244
1245         de_set_rx_mode(dev);
1246
1247         return 0;
1248 }
1249
1250 static int de_refill_rx (struct de_private *de)
1251 {
1252         unsigned i;
1253
1254         for (i = 0; i < DE_RX_RING_SIZE; i++) {
1255                 struct sk_buff *skb;
1256
1257                 skb = dev_alloc_skb(de->rx_buf_sz);
1258                 if (!skb)
1259                         goto err_out;
1260
1261                 skb->dev = de->dev;
1262
1263                 de->rx_skb[i].mapping = pci_map_single(de->pdev,
1264                         skb->data, de->rx_buf_sz, PCI_DMA_FROMDEVICE);
1265                 de->rx_skb[i].skb = skb;
1266
1267                 de->rx_ring[i].opts1 = cpu_to_le32(DescOwn);
1268                 if (i == (DE_RX_RING_SIZE - 1))
1269                         de->rx_ring[i].opts2 =
1270                                 cpu_to_le32(RingEnd | de->rx_buf_sz);
1271                 else
1272                         de->rx_ring[i].opts2 = cpu_to_le32(de->rx_buf_sz);
1273                 de->rx_ring[i].addr1 = cpu_to_le32(de->rx_skb[i].mapping);
1274                 de->rx_ring[i].addr2 = 0;
1275         }
1276
1277         return 0;
1278
1279 err_out:
1280         de_clean_rings(de);
1281         return -ENOMEM;
1282 }
1283
1284 static int de_init_rings (struct de_private *de)
1285 {
1286         memset(de->tx_ring, 0, sizeof(struct de_desc) * DE_TX_RING_SIZE);
1287         de->tx_ring[DE_TX_RING_SIZE - 1].opts2 = cpu_to_le32(RingEnd);
1288
1289         de->rx_tail = 0;
1290         de->tx_head = de->tx_tail = 0;
1291
1292         return de_refill_rx (de);
1293 }
1294
1295 static int de_alloc_rings (struct de_private *de)
1296 {
1297         de->rx_ring = pci_alloc_consistent(de->pdev, DE_RING_BYTES, &de->ring_dma);
1298         if (!de->rx_ring)
1299                 return -ENOMEM;
1300         de->tx_ring = &de->rx_ring[DE_RX_RING_SIZE];
1301         return de_init_rings(de);
1302 }
1303
1304 static void de_clean_rings (struct de_private *de)
1305 {
1306         unsigned i;
1307
1308         memset(de->rx_ring, 0, sizeof(struct de_desc) * DE_RX_RING_SIZE);
1309         de->rx_ring[DE_RX_RING_SIZE - 1].opts2 = cpu_to_le32(RingEnd);
1310         wmb();
1311         memset(de->tx_ring, 0, sizeof(struct de_desc) * DE_TX_RING_SIZE);
1312         de->tx_ring[DE_TX_RING_SIZE - 1].opts2 = cpu_to_le32(RingEnd);
1313         wmb();
1314
1315         for (i = 0; i < DE_RX_RING_SIZE; i++) {
1316                 if (de->rx_skb[i].skb) {
1317                         pci_unmap_single(de->pdev, de->rx_skb[i].mapping,
1318                                          de->rx_buf_sz, PCI_DMA_FROMDEVICE);
1319                         dev_kfree_skb(de->rx_skb[i].skb);
1320                 }
1321         }
1322
1323         for (i = 0; i < DE_TX_RING_SIZE; i++) {
1324                 struct sk_buff *skb = de->tx_skb[i].skb;
1325                 if ((skb) && (skb != DE_DUMMY_SKB)) {
1326                         if (skb != DE_SETUP_SKB) {
1327                                 de->net_stats.tx_dropped++;
1328                                 pci_unmap_single(de->pdev,
1329                                         de->tx_skb[i].mapping,
1330                                         skb->len, PCI_DMA_TODEVICE);
1331                                 dev_kfree_skb(skb);
1332                         } else {
1333                                 pci_unmap_single(de->pdev,
1334                                         de->tx_skb[i].mapping,
1335                                         sizeof(de->setup_frame),
1336                                         PCI_DMA_TODEVICE);
1337                         }
1338                 }
1339         }
1340
1341         memset(&de->rx_skb, 0, sizeof(struct ring_info) * DE_RX_RING_SIZE);
1342         memset(&de->tx_skb, 0, sizeof(struct ring_info) * DE_TX_RING_SIZE);
1343 }
1344
1345 static void de_free_rings (struct de_private *de)
1346 {
1347         de_clean_rings(de);
1348         pci_free_consistent(de->pdev, DE_RING_BYTES, de->rx_ring, de->ring_dma);
1349         de->rx_ring = NULL;
1350         de->tx_ring = NULL;
1351 }
1352
1353 static int de_open (struct net_device *dev)
1354 {
1355         struct de_private *de = dev->priv;
1356         int rc;
1357
1358         if (netif_msg_ifup(de))
1359                 printk(KERN_DEBUG "%s: enabling interface\n", dev->name);
1360
1361         de->rx_buf_sz = (dev->mtu <= 1500 ? PKT_BUF_SZ : dev->mtu + 32);
1362
1363         rc = de_alloc_rings(de);
1364         if (rc) {
1365                 printk(KERN_ERR "%s: ring allocation failure, err=%d\n",
1366                        dev->name, rc);
1367                 return rc;
1368         }
1369
1370         dw32(IntrMask, 0);
1371
1372         rc = request_irq(dev->irq, de_interrupt, IRQF_SHARED, dev->name, dev);
1373         if (rc) {
1374                 printk(KERN_ERR "%s: IRQ %d request failure, err=%d\n",
1375                        dev->name, dev->irq, rc);
1376                 goto err_out_free;
1377         }
1378
1379         rc = de_init_hw(de);
1380         if (rc) {
1381                 printk(KERN_ERR "%s: h/w init failure, err=%d\n",
1382                        dev->name, rc);
1383                 goto err_out_free_irq;
1384         }
1385
1386         netif_start_queue(dev);
1387         mod_timer(&de->media_timer, jiffies + DE_TIMER_NO_LINK);
1388
1389         return 0;
1390
1391 err_out_free_irq:
1392         free_irq(dev->irq, dev);
1393 err_out_free:
1394         de_free_rings(de);
1395         return rc;
1396 }
1397
1398 static int de_close (struct net_device *dev)
1399 {
1400         struct de_private *de = dev->priv;
1401         unsigned long flags;
1402
1403         if (netif_msg_ifdown(de))
1404                 printk(KERN_DEBUG "%s: disabling interface\n", dev->name);
1405
1406         del_timer_sync(&de->media_timer);
1407
1408         spin_lock_irqsave(&de->lock, flags);
1409         de_stop_hw(de);
1410         netif_stop_queue(dev);
1411         netif_carrier_off(dev);
1412         spin_unlock_irqrestore(&de->lock, flags);
1413
1414         free_irq(dev->irq, dev);
1415
1416         de_free_rings(de);
1417         de_adapter_sleep(de);
1418         pci_disable_device(de->pdev);
1419         return 0;
1420 }
1421
1422 static void de_tx_timeout (struct net_device *dev)
1423 {
1424         struct de_private *de = dev->priv;
1425
1426         printk(KERN_DEBUG "%s: NIC status %08x mode %08x sia %08x desc %u/%u/%u\n",
1427                dev->name, dr32(MacStatus), dr32(MacMode), dr32(SIAStatus),
1428                de->rx_tail, de->tx_head, de->tx_tail);
1429
1430         del_timer_sync(&de->media_timer);
1431
1432         disable_irq(dev->irq);
1433         spin_lock_irq(&de->lock);
1434
1435         de_stop_hw(de);
1436         netif_stop_queue(dev);
1437         netif_carrier_off(dev);
1438
1439         spin_unlock_irq(&de->lock);
1440         enable_irq(dev->irq);
1441
1442         /* Update the error counts. */
1443         __de_get_stats(de);
1444
1445         synchronize_irq(dev->irq);
1446         de_clean_rings(de);
1447
1448         de_init_rings(de);
1449
1450         de_init_hw(de);
1451
1452         netif_wake_queue(dev);
1453 }
1454
1455 static void __de_get_regs(struct de_private *de, u8 *buf)
1456 {
1457         int i;
1458         u32 *rbuf = (u32 *)buf;
1459
1460         /* read all CSRs */
1461         for (i = 0; i < DE_NUM_REGS; i++)
1462                 rbuf[i] = dr32(i * 8);
1463
1464         /* handle self-clearing RxMissed counter, CSR8 */
1465         de_rx_missed(de, rbuf[8]);
1466 }
1467
1468 static int __de_get_settings(struct de_private *de, struct ethtool_cmd *ecmd)
1469 {
1470         ecmd->supported = de->media_supported;
1471         ecmd->transceiver = XCVR_INTERNAL;
1472         ecmd->phy_address = 0;
1473         ecmd->advertising = de->media_advertise;
1474
1475         switch (de->media_type) {
1476         case DE_MEDIA_AUI:
1477                 ecmd->port = PORT_AUI;
1478                 ecmd->speed = 5;
1479                 break;
1480         case DE_MEDIA_BNC:
1481                 ecmd->port = PORT_BNC;
1482                 ecmd->speed = 2;
1483                 break;
1484         default:
1485                 ecmd->port = PORT_TP;
1486                 ecmd->speed = SPEED_10;
1487                 break;
1488         }
1489
1490         if (dr32(MacMode) & FullDuplex)
1491                 ecmd->duplex = DUPLEX_FULL;
1492         else
1493                 ecmd->duplex = DUPLEX_HALF;
1494
1495         if (de->media_lock)
1496                 ecmd->autoneg = AUTONEG_DISABLE;
1497         else
1498                 ecmd->autoneg = AUTONEG_ENABLE;
1499
1500         /* ignore maxtxpkt, maxrxpkt for now */
1501
1502         return 0;
1503 }
1504
1505 static int __de_set_settings(struct de_private *de, struct ethtool_cmd *ecmd)
1506 {
1507         u32 new_media;
1508         unsigned int media_lock;
1509
1510         if (ecmd->speed != SPEED_10 && ecmd->speed != 5 && ecmd->speed != 2)
1511                 return -EINVAL;
1512         if (de->de21040 && ecmd->speed == 2)
1513                 return -EINVAL;
1514         if (ecmd->duplex != DUPLEX_HALF && ecmd->duplex != DUPLEX_FULL)
1515                 return -EINVAL;
1516         if (ecmd->port != PORT_TP && ecmd->port != PORT_AUI && ecmd->port != PORT_BNC)
1517                 return -EINVAL;
1518         if (de->de21040 && ecmd->port == PORT_BNC)
1519                 return -EINVAL;
1520         if (ecmd->transceiver != XCVR_INTERNAL)
1521                 return -EINVAL;
1522         if (ecmd->autoneg != AUTONEG_DISABLE && ecmd->autoneg != AUTONEG_ENABLE)
1523                 return -EINVAL;
1524         if (ecmd->advertising & ~de->media_supported)
1525                 return -EINVAL;
1526         if (ecmd->autoneg == AUTONEG_ENABLE &&
1527             (!(ecmd->advertising & ADVERTISED_Autoneg)))
1528                 return -EINVAL;
1529
1530         switch (ecmd->port) {
1531         case PORT_AUI:
1532                 new_media = DE_MEDIA_AUI;
1533                 if (!(ecmd->advertising & ADVERTISED_AUI))
1534                         return -EINVAL;
1535                 break;
1536         case PORT_BNC:
1537                 new_media = DE_MEDIA_BNC;
1538                 if (!(ecmd->advertising & ADVERTISED_BNC))
1539                         return -EINVAL;
1540                 break;
1541         default:
1542                 if (ecmd->autoneg == AUTONEG_ENABLE)
1543                         new_media = DE_MEDIA_TP_AUTO;
1544                 else if (ecmd->duplex == DUPLEX_FULL)
1545                         new_media = DE_MEDIA_TP_FD;
1546                 else
1547                         new_media = DE_MEDIA_TP;
1548                 if (!(ecmd->advertising & ADVERTISED_TP))
1549                         return -EINVAL;
1550                 if (!(ecmd->advertising & (ADVERTISED_10baseT_Full | ADVERTISED_10baseT_Half)))
1551                         return -EINVAL;
1552                 break;
1553         }
1554
1555         media_lock = (ecmd->autoneg == AUTONEG_ENABLE) ? 0 : 1;
1556
1557         if ((new_media == de->media_type) &&
1558             (media_lock == de->media_lock) &&
1559             (ecmd->advertising == de->media_advertise))
1560                 return 0; /* nothing to change */
1561
1562         de_link_down(de);
1563         de_stop_rxtx(de);
1564
1565         de->media_type = new_media;
1566         de->media_lock = media_lock;
1567         de->media_advertise = ecmd->advertising;
1568         de_set_media(de);
1569
1570         return 0;
1571 }
1572
1573 static void de_get_drvinfo (struct net_device *dev,struct ethtool_drvinfo *info)
1574 {
1575         struct de_private *de = dev->priv;
1576
1577         strcpy (info->driver, DRV_NAME);
1578         strcpy (info->version, DRV_VERSION);
1579         strcpy (info->bus_info, pci_name(de->pdev));
1580         info->eedump_len = DE_EEPROM_SIZE;
1581 }
1582
1583 static int de_get_regs_len(struct net_device *dev)
1584 {
1585         return DE_REGS_SIZE;
1586 }
1587
1588 static int de_get_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
1589 {
1590         struct de_private *de = dev->priv;
1591         int rc;
1592
1593         spin_lock_irq(&de->lock);
1594         rc = __de_get_settings(de, ecmd);
1595         spin_unlock_irq(&de->lock);
1596
1597         return rc;
1598 }
1599
1600 static int de_set_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
1601 {
1602         struct de_private *de = dev->priv;
1603         int rc;
1604
1605         spin_lock_irq(&de->lock);
1606         rc = __de_set_settings(de, ecmd);
1607         spin_unlock_irq(&de->lock);
1608
1609         return rc;
1610 }
1611
1612 static u32 de_get_msglevel(struct net_device *dev)
1613 {
1614         struct de_private *de = dev->priv;
1615
1616         return de->msg_enable;
1617 }
1618
1619 static void de_set_msglevel(struct net_device *dev, u32 msglvl)
1620 {
1621         struct de_private *de = dev->priv;
1622
1623         de->msg_enable = msglvl;
1624 }
1625
1626 static int de_get_eeprom(struct net_device *dev,
1627                          struct ethtool_eeprom *eeprom, u8 *data)
1628 {
1629         struct de_private *de = dev->priv;
1630
1631         if (!de->ee_data)
1632                 return -EOPNOTSUPP;
1633         if ((eeprom->offset != 0) || (eeprom->magic != 0) ||
1634             (eeprom->len != DE_EEPROM_SIZE))
1635                 return -EINVAL;
1636         memcpy(data, de->ee_data, eeprom->len);
1637
1638         return 0;
1639 }
1640
1641 static int de_nway_reset(struct net_device *dev)
1642 {
1643         struct de_private *de = dev->priv;
1644         u32 status;
1645
1646         if (de->media_type != DE_MEDIA_TP_AUTO)
1647                 return -EINVAL;
1648         if (netif_carrier_ok(de->dev))
1649                 de_link_down(de);
1650
1651         status = dr32(SIAStatus);
1652         dw32(SIAStatus, (status & ~NWayState) | NWayRestart);
1653         if (netif_msg_link(de))
1654                 printk(KERN_INFO "%s: link nway restart, status %x,%x\n",
1655                        de->dev->name, status, dr32(SIAStatus));
1656         return 0;
1657 }
1658
1659 static void de_get_regs(struct net_device *dev, struct ethtool_regs *regs,
1660                         void *data)
1661 {
1662         struct de_private *de = dev->priv;
1663
1664         regs->version = (DE_REGS_VER << 2) | de->de21040;
1665
1666         spin_lock_irq(&de->lock);
1667         __de_get_regs(de, data);
1668         spin_unlock_irq(&de->lock);
1669 }
1670
1671 static const struct ethtool_ops de_ethtool_ops = {
1672         .get_link               = ethtool_op_get_link,
1673         .get_tx_csum            = ethtool_op_get_tx_csum,
1674         .get_sg                 = ethtool_op_get_sg,
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                 ((u16 *)ee_data)[i] =
1777                         le16_to_cpu(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 (DE_UNALIGNED_16(&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 = DE_UNALIGNED_16(&ib->csr13);
1876                         de->media[idx].csr14 = DE_UNALIGNED_16(&ib->csr14);
1877                         de->media[idx].csr15 = DE_UNALIGNED_16(&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
1935         board_idx++;
1936
1937 #ifndef MODULE
1938         if (board_idx == 0)
1939                 printk("%s", version);
1940 #endif
1941
1942         /* allocate a new ethernet device structure, and fill in defaults */
1943         dev = alloc_etherdev(sizeof(struct de_private));
1944         if (!dev)
1945                 return -ENOMEM;
1946
1947         SET_MODULE_OWNER(dev);
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, "
2049                 "%02x:%02x:%02x:%02x:%02x:%02x, "
2050                 "IRQ %d\n",
2051                 dev->name,
2052                 de->de21040 ? "21040" : "21041",
2053                 dev->base_addr,
2054                 dev->dev_addr[0], dev->dev_addr[1],
2055                 dev->dev_addr[2], dev->dev_addr[3],
2056                 dev->dev_addr[4], dev->dev_addr[5],
2057                 dev->irq);
2058
2059         pci_set_drvdata(pdev, dev);
2060
2061         /* enable busmastering */
2062         pci_set_master(pdev);
2063
2064         /* put adapter to sleep */
2065         de_adapter_sleep(de);
2066
2067         return 0;
2068
2069 err_out_iomap:
2070         kfree(de->ee_data);
2071         iounmap(regs);
2072 err_out_res:
2073         pci_release_regions(pdev);
2074 err_out_disable:
2075         pci_disable_device(pdev);
2076 err_out_free:
2077         free_netdev(dev);
2078         return rc;
2079 }
2080
2081 static void __devexit de_remove_one (struct pci_dev *pdev)
2082 {
2083         struct net_device *dev = pci_get_drvdata(pdev);
2084         struct de_private *de = dev->priv;
2085
2086         BUG_ON(!dev);
2087         unregister_netdev(dev);
2088         kfree(de->ee_data);
2089         iounmap(de->regs);
2090         pci_release_regions(pdev);
2091         pci_disable_device(pdev);
2092         pci_set_drvdata(pdev, NULL);
2093         free_netdev(dev);
2094 }
2095
2096 #ifdef CONFIG_PM
2097
2098 static int de_suspend (struct pci_dev *pdev, pm_message_t state)
2099 {
2100         struct net_device *dev = pci_get_drvdata (pdev);
2101         struct de_private *de = dev->priv;
2102
2103         rtnl_lock();
2104         if (netif_running (dev)) {
2105                 del_timer_sync(&de->media_timer);
2106
2107                 disable_irq(dev->irq);
2108                 spin_lock_irq(&de->lock);
2109
2110                 de_stop_hw(de);
2111                 netif_stop_queue(dev);
2112                 netif_device_detach(dev);
2113                 netif_carrier_off(dev);
2114
2115                 spin_unlock_irq(&de->lock);
2116                 enable_irq(dev->irq);
2117
2118                 /* Update the error counts. */
2119                 __de_get_stats(de);
2120
2121                 synchronize_irq(dev->irq);
2122                 de_clean_rings(de);
2123
2124                 de_adapter_sleep(de);
2125                 pci_disable_device(pdev);
2126         } else {
2127                 netif_device_detach(dev);
2128         }
2129         rtnl_unlock();
2130         return 0;
2131 }
2132
2133 static int de_resume (struct pci_dev *pdev)
2134 {
2135         struct net_device *dev = pci_get_drvdata (pdev);
2136         struct de_private *de = dev->priv;
2137         int retval = 0;
2138
2139         rtnl_lock();
2140         if (netif_device_present(dev))
2141                 goto out;
2142         if (!netif_running(dev))
2143                 goto out_attach;
2144         if ((retval = pci_enable_device(pdev))) {
2145                 printk (KERN_ERR "%s: pci_enable_device failed in resume\n",
2146                         dev->name);
2147                 goto out;
2148         }
2149         de_init_hw(de);
2150 out_attach:
2151         netif_device_attach(dev);
2152 out:
2153         rtnl_unlock();
2154         return 0;
2155 }
2156
2157 #endif /* CONFIG_PM */
2158
2159 static struct pci_driver de_driver = {
2160         .name           = DRV_NAME,
2161         .id_table       = de_pci_tbl,
2162         .probe          = de_init_one,
2163         .remove         = __devexit_p(de_remove_one),
2164 #ifdef CONFIG_PM
2165         .suspend        = de_suspend,
2166         .resume         = de_resume,
2167 #endif
2168 };
2169
2170 static int __init de_init (void)
2171 {
2172 #ifdef MODULE
2173         printk("%s", version);
2174 #endif
2175         return pci_register_driver(&de_driver);
2176 }
2177
2178 static void __exit de_exit (void)
2179 {
2180         pci_unregister_driver (&de_driver);
2181 }
2182
2183 module_init(de_init);
2184 module_exit(de_exit);