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