drivers/net/natsemi.c

   1 /* natsemi.c: A Linux PCI Ethernet driver for the NatSemi DP8381x series. */
   2 /*
   3         Written/copyright 1999-2001 by Donald Becker.
   4         Portions copyright (c) 2001,2002 Sun Microsystems (thockin@sun.com)
   5         Portions copyright 2001,2002 Manfred Spraul (manfred@colorfullife.com)
   6         Portions copyright 2004 Harald Welte <laforge@gnumonks.org>
   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.  License for under other terms may be
  14         available.  Contact the original author for details.
  15
  16         The original author may be reached as becker@scyld.com, or at
  17         Scyld Computing Corporation
  18         410 Severn Ave., Suite 210
  19         Annapolis MD 21403
  20
  21         Support information and updates available at
  22         http://www.scyld.com/network/netsemi.html
  23         [link no longer provides useful info -jgarzik]
  24
  25
  26         TODO:
  27         * big endian support with CFG:BEM instead of cpu_to_le32
  28 */
  29
  30 #include <linux/module.h>
  31 #include <linux/kernel.h>
  32 #include <linux/string.h>
  33 #include <linux/timer.h>
  34 #include <linux/errno.h>
  35 #include <linux/ioport.h>
  36 #include <linux/slab.h>
  37 #include <linux/interrupt.h>
  38 #include <linux/pci.h>
  39 #include <linux/netdevice.h>
  40 #include <linux/etherdevice.h>
  41 #include <linux/skbuff.h>
  42 #include <linux/init.h>
  43 #include <linux/spinlock.h>
  44 #include <linux/ethtool.h>
  45 #include <linux/delay.h>
  46 #include <linux/rtnetlink.h>
  47 #include <linux/mii.h>
  48 #include <linux/crc32.h>
  49 #include <linux/bitops.h>
  50 #include <linux/prefetch.h>
  51 #include <asm/processor.h>      /* Processor type for cache alignment. */
  52 #include <asm/io.h>
  53 #include <asm/irq.h>
  54 #include <asm/uaccess.h>
  55
  56 #define DRV_NAME        "natsemi"
  57 #define DRV_VERSION     "2.1"
  58 #define DRV_RELDATE     "Sept 11, 2006"
  59
  60 #define RX_OFFSET       2
  61
  62 /* Updated to recommendations in pci-skeleton v2.03. */
  63
  64 /* The user-configurable values.
  65    These may be modified when a driver module is loaded.*/
  66
  67 #define NATSEMI_DEF_MSG         (NETIF_MSG_DRV          | \
  68                                  NETIF_MSG_LINK         | \
  69                                  NETIF_MSG_WOL          | \
  70                                  NETIF_MSG_RX_ERR       | \
  71                                  NETIF_MSG_TX_ERR)
  72 static int debug = -1;
  73
  74 static int mtu;
  75
  76 /* Maximum number of multicast addresses to filter (vs. rx-all-multicast).
  77    This chip uses a 512 element hash table based on the Ethernet CRC.  */
  78 static const int multicast_filter_limit = 100;
  79
  80 /* Set the copy breakpoint for the copy-only-tiny-frames scheme.
  81    Setting to > 1518 effectively disables this feature. */
  82 static int rx_copybreak;
  83
  84 /* Used to pass the media type, etc.
  85    Both 'options[]' and 'full_duplex[]' should exist for driver
  86    interoperability.
  87    The media type is usually passed in 'options[]'.
  88 */
  89 #define MAX_UNITS 8             /* More are supported, limit only on options */
  90 static int options[MAX_UNITS];
  91 static int full_duplex[MAX_UNITS];
  92
  93 /* Operational parameters that are set at compile time. */
  94
  95 /* Keep the ring sizes a power of two for compile efficiency.
  96    The compiler will convert <unsigned>'%'<2^N> into a bit mask.
  97    Making the Tx ring too large decreases the effectiveness of channel
  98    bonding and packet priority.
  99    There are no ill effects from too-large receive rings. */
 100 #define TX_RING_SIZE    16
 101 #define TX_QUEUE_LEN    10 /* Limit ring entries actually used, min 4. */
 102 #define RX_RING_SIZE    32
 103
 104 /* Operational parameters that usually are not changed. */
 105 /* Time in jiffies before concluding the transmitter is hung. */
 106 #define TX_TIMEOUT  (2*HZ)
 107
 108 #define NATSEMI_HW_TIMEOUT      400
 109 #define NATSEMI_TIMER_FREQ      3*HZ
 110 #define NATSEMI_PG0_NREGS       64
 111 #define NATSEMI_RFDR_NREGS      8
 112 #define NATSEMI_PG1_NREGS       4
 113 #define NATSEMI_NREGS           (NATSEMI_PG0_NREGS + NATSEMI_RFDR_NREGS + \
 114                                  NATSEMI_PG1_NREGS)
 115 #define NATSEMI_REGS_VER        1 /* v1 added RFDR registers */
 116 #define NATSEMI_REGS_SIZE       (NATSEMI_NREGS * sizeof(u32))
 117
 118 /* Buffer sizes:
 119  * The nic writes 32-bit values, even if the upper bytes of
 120  * a 32-bit value are beyond the end of the buffer.
 121  */
 122 #define NATSEMI_HEADERS         22      /* 2*mac,type,vlan,crc */
 123 #define NATSEMI_PADDING         16      /* 2 bytes should be sufficient */
 124 #define NATSEMI_LONGPKT         1518    /* limit for normal packets */
 125 #define NATSEMI_RX_LIMIT        2046    /* maximum supported by hardware */
 126
 127 /* These identify the driver base version and may not be removed. */
 128 static const char version[] __devinitdata =
 129   KERN_INFO DRV_NAME " dp8381x driver, version "
 130       DRV_VERSION ", " DRV_RELDATE "\n"
 131   KERN_INFO "  originally by Donald Becker <becker@scyld.com>\n"
 132   KERN_INFO "  http://www.scyld.com/network/natsemi.html\n"
 133   KERN_INFO "  2.4.x kernel port by Jeff Garzik, Tjeerd Mulder\n";
 134
 135 MODULE_AUTHOR("Donald Becker <becker@scyld.com>");
 136 MODULE_DESCRIPTION("National Semiconductor DP8381x series PCI Ethernet driver");
 137 MODULE_LICENSE("GPL");
 138
 139 module_param(mtu, int, 0);
 140 module_param(debug, int, 0);
 141 module_param(rx_copybreak, int, 0);
 142 module_param_array(options, int, NULL, 0);
 143 module_param_array(full_duplex, int, NULL, 0);
 144 MODULE_PARM_DESC(mtu, "DP8381x MTU (all boards)");
 145 MODULE_PARM_DESC(debug, "DP8381x default debug level");
 146 MODULE_PARM_DESC(rx_copybreak,
 147         "DP8381x copy breakpoint for copy-only-tiny-frames");
 148 MODULE_PARM_DESC(options,
 149         "DP8381x: Bits 0-3: media type, bit 17: full duplex");
 150 MODULE_PARM_DESC(full_duplex, "DP8381x full duplex setting(s) (1)");
 151
 152 /*
 153                                 Theory of Operation
 154
 155 I. Board Compatibility
 156
 157 This driver is designed for National Semiconductor DP83815 PCI Ethernet NIC.
 158 It also works with other chips in in the DP83810 series.
 159
 160 II. Board-specific settings
 161
 162 This driver requires the PCI interrupt line to be valid.
 163 It honors the EEPROM-set values.
 164
 165 III. Driver operation
 166
 167 IIIa. Ring buffers
 168
 169 This driver uses two statically allocated fixed-size descriptor lists
 170 formed into rings by a branch from the final descriptor to the beginning of
 171 the list.  The ring sizes are set at compile time by RX/TX_RING_SIZE.
 172 The NatSemi design uses a 'next descriptor' pointer that the driver forms
 173 into a list.
 174
 175 IIIb/c. Transmit/Receive Structure
 176
 177 This driver uses a zero-copy receive and transmit scheme.
 178 The driver allocates full frame size skbuffs for the Rx ring buffers at
 179 open() time and passes the skb->data field to the chip as receive data
 180 buffers.  When an incoming frame is less than RX_COPYBREAK bytes long,
 181 a fresh skbuff is allocated and the frame is copied to the new skbuff.
 182 When the incoming frame is larger, the skbuff is passed directly up the
 183 protocol stack.  Buffers consumed this way are replaced by newly allocated
 184 skbuffs in a later phase of receives.
 185
 186 The RX_COPYBREAK value is chosen to trade-off the memory wasted by
 187 using a full-sized skbuff for small frames vs. the copying costs of larger
 188 frames.  New boards are typically used in generously configured machines
 189 and the underfilled buffers have negligible impact compared to the benefit of
 190 a single allocation size, so the default value of zero results in never
 191 copying packets.  When copying is done, the cost is usually mitigated by using
 192 a combined copy/checksum routine.  Copying also preloads the cache, which is
 193 most useful with small frames.
 194
 195 A subtle aspect of the operation is that unaligned buffers are not permitted
 196 by the hardware.  Thus the IP header at offset 14 in an ethernet frame isn't
 197 longword aligned for further processing.  On copies frames are put into the
 198 skbuff at an offset of "+2", 16-byte aligning the IP header.
 199
 200 IIId. Synchronization
 201
 202 Most operations are synchronized on the np->lock irq spinlock, except the
 203 performance critical codepaths:
 204
 205 The rx process only runs in the interrupt handler. Access from outside
 206 the interrupt handler is only permitted after disable_irq().
 207
 208 The rx process usually runs under the netif_tx_lock. If np->intr_tx_reap
 209 is set, then access is permitted under spin_lock_irq(&np->lock).
 210
 211 Thus configuration functions that want to access everything must call
 212         disable_irq(dev->irq);
 213         netif_tx_lock_bh(dev);
 214         spin_lock_irq(&np->lock);
 215
 216 IV. Notes
 217
 218 NatSemi PCI network controllers are very uncommon.
 219
 220 IVb. References
 221
 222 http://www.scyld.com/expert/100mbps.html
 223 http://www.scyld.com/expert/NWay.html
 224 Datasheet is available from:
 225 http://www.national.com/pf/DP/DP83815.html
 226
 227 IVc. Errata
 228
 229 None characterised.
 230 */
 231
 232
 233
 234 /*
 235  * Support for fibre connections on Am79C874:
 236  * This phy needs a special setup when connected to a fibre cable.
 237  * http://www.amd.com/files/connectivitysolutions/networking/archivednetworking/22235.pdf
 238  */
 239 #define PHYID_AM79C874  0x0022561b
 240
 241 enum {
 242         MII_MCTRL       = 0x15,         /* mode control register */
 243         MII_FX_SEL      = 0x0001,       /* 100BASE-FX (fiber) */
 244         MII_EN_SCRM     = 0x0004,       /* enable scrambler (tp) */
 245 };
 246
 247 enum {
 248         NATSEMI_FLAG_IGNORE_PHY         = 0x1,
 249 };
 250
 251 /* array of board data directly indexed by pci_tbl[x].driver_data */
 252 static const struct {
 253         const char *name;
 254         unsigned long flags;
 255         unsigned int eeprom_size;
 256 } natsemi_pci_info[] __devinitdata = {
 257         { "Aculab E1/T1 PMXc cPCI carrier card", NATSEMI_FLAG_IGNORE_PHY, 128 },
 258         { "NatSemi DP8381[56]", 0, 24 },
 259 };
 260
 261 static const struct pci_device_id natsemi_pci_tbl[] __devinitdata = {
 262         { PCI_VENDOR_ID_NS, 0x0020, 0x12d9,     0x000c,     0, 0, 0 },
 263         { PCI_VENDOR_ID_NS, 0x0020, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
 264         { }     /* terminate list */
 265 };
 266 MODULE_DEVICE_TABLE(pci, natsemi_pci_tbl);
 267
 268 /* Offsets to the device registers.
 269    Unlike software-only systems, device drivers interact with complex hardware.
 270    It's not useful to define symbolic names for every register bit in the
 271    device.
 272 */
 273 enum register_offsets {
 274         ChipCmd                 = 0x00,
 275         ChipConfig              = 0x04,
 276         EECtrl                  = 0x08,
 277         PCIBusCfg               = 0x0C,
 278         IntrStatus              = 0x10,
 279         IntrMask                = 0x14,
 280         IntrEnable              = 0x18,
 281         IntrHoldoff             = 0x1C, /* DP83816 only */
 282         TxRingPtr               = 0x20,
 283         TxConfig                = 0x24,
 284         RxRingPtr               = 0x30,
 285         RxConfig                = 0x34,
 286         ClkRun                  = 0x3C,
 287         WOLCmd                  = 0x40,
 288         PauseCmd                = 0x44,
 289         RxFilterAddr            = 0x48,
 290         RxFilterData            = 0x4C,
 291         BootRomAddr             = 0x50,
 292         BootRomData             = 0x54,
 293         SiliconRev              = 0x58,
 294         StatsCtrl               = 0x5C,
 295         StatsData               = 0x60,
 296         RxPktErrs               = 0x60,
 297         RxMissed                = 0x68,
 298         RxCRCErrs               = 0x64,
 299         BasicControl            = 0x80,
 300         BasicStatus             = 0x84,
 301         AnegAdv                 = 0x90,
 302         AnegPeer                = 0x94,
 303         PhyStatus               = 0xC0,
 304         MIntrCtrl               = 0xC4,
 305         MIntrStatus             = 0xC8,
 306         PhyCtrl                 = 0xE4,
 307
 308         /* These are from the spec, around page 78... on a separate table.
 309          * The meaning of these registers depend on the value of PGSEL. */
 310         PGSEL                   = 0xCC,
 311         PMDCSR                  = 0xE4,
 312         TSTDAT                  = 0xFC,
 313         DSPCFG                  = 0xF4,
 314         SDCFG                   = 0xF8
 315 };
 316 /* the values for the 'magic' registers above (PGSEL=1) */
 317 #define PMDCSR_VAL      0x189c  /* enable preferred adaptation circuitry */
 318 #define TSTDAT_VAL      0x0
 319 #define DSPCFG_VAL      0x5040
 320 #define SDCFG_VAL       0x008c  /* set voltage thresholds for Signal Detect */
 321 #define DSPCFG_LOCK     0x20    /* coefficient lock bit in DSPCFG */
 322 #define DSPCFG_COEF     0x1000  /* see coefficient (in TSTDAT) bit in DSPCFG */
 323 #define TSTDAT_FIXED    0xe8    /* magic number for bad coefficients */
 324
 325 /* misc PCI space registers */
 326 enum pci_register_offsets {
 327         PCIPM                   = 0x44,
 328 };
 329
 330 enum ChipCmd_bits {
 331         ChipReset               = 0x100,
 332         RxReset                 = 0x20,
 333         TxReset                 = 0x10,
 334         RxOff                   = 0x08,
 335         RxOn                    = 0x04,
 336         TxOff                   = 0x02,
 337         TxOn                    = 0x01,
 338 };
 339
 340 enum ChipConfig_bits {
 341         CfgPhyDis               = 0x200,
 342         CfgPhyRst               = 0x400,
 343         CfgExtPhy               = 0x1000,
 344         CfgAnegEnable           = 0x2000,
 345         CfgAneg100              = 0x4000,
 346         CfgAnegFull             = 0x8000,
 347         CfgAnegDone             = 0x8000000,
 348         CfgFullDuplex           = 0x20000000,
 349         CfgSpeed100             = 0x40000000,
 350         CfgLink                 = 0x80000000,
 351 };
 352
 353 enum EECtrl_bits {
 354         EE_ShiftClk             = 0x04,
 355         EE_DataIn               = 0x01,
 356         EE_ChipSelect           = 0x08,
 357         EE_DataOut              = 0x02,
 358         MII_Data                = 0x10,
 359         MII_Write               = 0x20,
 360         MII_ShiftClk            = 0x40,
 361 };
 362
 363 enum PCIBusCfg_bits {
 364         EepromReload            = 0x4,
 365 };
 366
 367 /* Bits in the interrupt status/mask registers. */
 368 enum IntrStatus_bits {
 369         IntrRxDone              = 0x0001,
 370         IntrRxIntr              = 0x0002,
 371         IntrRxErr               = 0x0004,
 372         IntrRxEarly             = 0x0008,
 373         IntrRxIdle              = 0x0010,
 374         IntrRxOverrun           = 0x0020,
 375         IntrTxDone              = 0x0040,
 376         IntrTxIntr              = 0x0080,
 377         IntrTxErr               = 0x0100,
 378         IntrTxIdle              = 0x0200,
 379         IntrTxUnderrun          = 0x0400,
 380         StatsMax                = 0x0800,
 381         SWInt                   = 0x1000,
 382         WOLPkt                  = 0x2000,
 383         LinkChange              = 0x4000,
 384         IntrHighBits            = 0x8000,
 385         RxStatusFIFOOver        = 0x10000,
 386         IntrPCIErr              = 0xf00000,
 387         RxResetDone             = 0x1000000,
 388         TxResetDone             = 0x2000000,
 389         IntrAbnormalSummary     = 0xCD20,
 390 };
 391
 392 /*
 393  * Default Interrupts:
 394  * Rx OK, Rx Packet Error, Rx Overrun,
 395  * Tx OK, Tx Packet Error, Tx Underrun,
 396  * MIB Service, Phy Interrupt, High Bits,
 397  * Rx Status FIFO overrun,
 398  * Received Target Abort, Received Master Abort,
 399  * Signalled System Error, Received Parity Error
 400  */
 401 #define DEFAULT_INTR 0x00f1cd65
 402
 403 enum TxConfig_bits {
 404         TxDrthMask              = 0x3f,
 405         TxFlthMask              = 0x3f00,
 406         TxMxdmaMask             = 0x700000,
 407         TxMxdma_512             = 0x0,
 408         TxMxdma_4               = 0x100000,
 409         TxMxdma_8               = 0x200000,
 410         TxMxdma_16              = 0x300000,
 411         TxMxdma_32              = 0x400000,
 412         TxMxdma_64              = 0x500000,
 413         TxMxdma_128             = 0x600000,
 414         TxMxdma_256             = 0x700000,
 415         TxCollRetry             = 0x800000,
 416         TxAutoPad               = 0x10000000,
 417         TxMacLoop               = 0x20000000,
 418         TxHeartIgn              = 0x40000000,
 419         TxCarrierIgn            = 0x80000000
 420 };
 421
 422 /*
 423  * Tx Configuration:
 424  * - 256 byte DMA burst length
 425  * - fill threshold 512 bytes (i.e. restart DMA when 512 bytes are free)
 426  * - 64 bytes initial drain threshold (i.e. begin actual transmission
 427  *   when 64 byte are in the fifo)
 428  * - on tx underruns, increase drain threshold by 64.
 429  * - at most use a drain threshold of 1472 bytes: The sum of the fill
 430  *   threshold and the drain threshold must be less than 2016 bytes.
 431  *
 432  */
 433 #define TX_FLTH_VAL             ((512/32) << 8)
 434 #define TX_DRTH_VAL_START       (64/32)
 435 #define TX_DRTH_VAL_INC         2
 436 #define TX_DRTH_VAL_LIMIT       (1472/32)
 437
 438 enum RxConfig_bits {
 439         RxDrthMask              = 0x3e,
 440         RxMxdmaMask             = 0x700000,
 441         RxMxdma_512             = 0x0,
 442         RxMxdma_4               = 0x100000,
 443         RxMxdma_8               = 0x200000,
 444         RxMxdma_16              = 0x300000,
 445         RxMxdma_32              = 0x400000,
 446         RxMxdma_64              = 0x500000,
 447         RxMxdma_128             = 0x600000,
 448         RxMxdma_256             = 0x700000,
 449         RxAcceptLong            = 0x8000000,
 450         RxAcceptTx              = 0x10000000,
 451         RxAcceptRunt            = 0x40000000,
 452         RxAcceptErr             = 0x80000000
 453 };
 454 #define RX_DRTH_VAL             (128/8)
 455
 456 enum ClkRun_bits {
 457         PMEEnable               = 0x100,
 458         PMEStatus               = 0x8000,
 459 };
 460
 461 enum WolCmd_bits {
 462         WakePhy                 = 0x1,
 463         WakeUnicast             = 0x2,
 464         WakeMulticast           = 0x4,
 465         WakeBroadcast           = 0x8,
 466         WakeArp                 = 0x10,
 467         WakePMatch0             = 0x20,
 468         WakePMatch1             = 0x40,
 469         WakePMatch2             = 0x80,
 470         WakePMatch3             = 0x100,
 471         WakeMagic               = 0x200,
 472         WakeMagicSecure         = 0x400,
 473         SecureHack              = 0x100000,
 474         WokePhy                 = 0x400000,
 475         WokeUnicast             = 0x800000,
 476         WokeMulticast           = 0x1000000,
 477         WokeBroadcast           = 0x2000000,
 478         WokeArp                 = 0x4000000,
 479         WokePMatch0             = 0x8000000,
 480         WokePMatch1             = 0x10000000,
 481         WokePMatch2             = 0x20000000,
 482         WokePMatch3             = 0x40000000,
 483         WokeMagic               = 0x80000000,
 484         WakeOptsSummary         = 0x7ff
 485 };
 486
 487 enum RxFilterAddr_bits {
 488         RFCRAddressMask         = 0x3ff,
 489         AcceptMulticast         = 0x00200000,
 490         AcceptMyPhys            = 0x08000000,
 491         AcceptAllPhys           = 0x10000000,
 492         AcceptAllMulticast      = 0x20000000,
 493         AcceptBroadcast         = 0x40000000,
 494         RxFilterEnable          = 0x80000000
 495 };
 496
 497 enum StatsCtrl_bits {
 498         StatsWarn               = 0x1,
 499         StatsFreeze             = 0x2,
 500         StatsClear              = 0x4,
 501         StatsStrobe             = 0x8,
 502 };
 503
 504 enum MIntrCtrl_bits {
 505         MICRIntEn               = 0x2,
 506 };
 507
 508 enum PhyCtrl_bits {
 509         PhyAddrMask             = 0x1f,
 510 };
 511
 512 #define PHY_ADDR_NONE           32
 513 #define PHY_ADDR_INTERNAL       1
 514
 515 /* values we might find in the silicon revision register */
 516 #define SRR_DP83815_C   0x0302
 517 #define SRR_DP83815_D   0x0403
 518 #define SRR_DP83816_A4  0x0504
 519 #define SRR_DP83816_A5  0x0505
 520
 521 /* The Rx and Tx buffer descriptors. */
 522 /* Note that using only 32 bit fields simplifies conversion to big-endian
 523    architectures. */
 524 struct netdev_desc {
 525         u32 next_desc;
 526         s32 cmd_status;
 527         u32 addr;
 528         u32 software_use;
 529 };
 530
 531 /* Bits in network_desc.status */
 532 enum desc_status_bits {
 533         DescOwn=0x80000000, DescMore=0x40000000, DescIntr=0x20000000,
 534         DescNoCRC=0x10000000, DescPktOK=0x08000000,
 535         DescSizeMask=0xfff,
 536
 537         DescTxAbort=0x04000000, DescTxFIFO=0x02000000,
 538         DescTxCarrier=0x01000000, DescTxDefer=0x00800000,
 539         DescTxExcDefer=0x00400000, DescTxOOWCol=0x00200000,
 540         DescTxExcColl=0x00100000, DescTxCollCount=0x000f0000,
 541
 542         DescRxAbort=0x04000000, DescRxOver=0x02000000,
 543         DescRxDest=0x01800000, DescRxLong=0x00400000,
 544         DescRxRunt=0x00200000, DescRxInvalid=0x00100000,
 545         DescRxCRC=0x00080000, DescRxAlign=0x00040000,
 546         DescRxLoop=0x00020000, DesRxColl=0x00010000,
 547 };
 548
 549 struct netdev_private {
 550         /* Descriptor rings first for alignment */
 551         dma_addr_t ring_dma;
 552         struct netdev_desc *rx_ring;
 553         struct netdev_desc *tx_ring;
 554         /* The addresses of receive-in-place skbuffs */
 555         struct sk_buff *rx_skbuff[RX_RING_SIZE];
 556         dma_addr_t rx_dma[RX_RING_SIZE];
 557         /* address of a sent-in-place packet/buffer, for later free() */
 558         struct sk_buff *tx_skbuff[TX_RING_SIZE];
 559         dma_addr_t tx_dma[TX_RING_SIZE];
 560         struct net_device_stats stats;
 561         /* Media monitoring timer */
 562         struct timer_list timer;
 563         /* Frequently used values: keep some adjacent for cache effect */
 564         struct pci_dev *pci_dev;
 565         struct netdev_desc *rx_head_desc;
 566         /* Producer/consumer ring indices */
 567         unsigned int cur_rx, dirty_rx;
 568         unsigned int cur_tx, dirty_tx;
 569         /* Based on MTU+slack. */
 570         unsigned int rx_buf_sz;
 571         int oom;
 572         /* Interrupt status */
 573         u32 intr_status;
 574         /* Do not touch the nic registers */
 575         int hands_off;
 576         /* Don't pay attention to the reported link state. */
 577         int ignore_phy;
 578         /* external phy that is used: only valid if dev->if_port != PORT_TP */
 579         int mii;
 580         int phy_addr_external;
 581         unsigned int full_duplex;
 582         /* Rx filter */
 583         u32 cur_rx_mode;
 584         u32 rx_filter[16];
 585         /* FIFO and PCI burst thresholds */
 586         u32 tx_config, rx_config;
 587         /* original contents of ClkRun register */
 588         u32 SavedClkRun;
 589         /* silicon revision */
 590         u32 srr;
 591         /* expected DSPCFG value */
 592         u16 dspcfg;
 593         /* parms saved in ethtool format */
 594         u16     speed;          /* The forced speed, 10Mb, 100Mb, gigabit */
 595         u8      duplex;         /* Duplex, half or full */
 596         u8      autoneg;        /* Autonegotiation enabled */
 597         /* MII transceiver section */
 598         u16 advertising;
 599         unsigned int iosize;
 600         spinlock_t lock;
 601         u32 msg_enable;
 602         /* EEPROM data */
 603         int eeprom_size;
 604 };
 605
 606 static void move_int_phy(struct net_device *dev, int addr);
 607 static int eeprom_read(void __iomem *ioaddr, int location);
 608 static int mdio_read(struct net_device *dev, int reg);
 609 static void mdio_write(struct net_device *dev, int reg, u16 data);
 610 static void init_phy_fixup(struct net_device *dev);
 611 static int miiport_read(struct net_device *dev, int phy_id, int reg);
 612 static void miiport_write(struct net_device *dev, int phy_id, int reg, u16 data);
 613 static int find_mii(struct net_device *dev);
 614 static void natsemi_reset(struct net_device *dev);
 615 static void natsemi_reload_eeprom(struct net_device *dev);
 616 static void natsemi_stop_rxtx(struct net_device *dev);
 617 static int netdev_open(struct net_device *dev);
 618 static void do_cable_magic(struct net_device *dev);
 619 static void undo_cable_magic(struct net_device *dev);
 620 static void check_link(struct net_device *dev);
 621 static void netdev_timer(unsigned long data);
 622 static void dump_ring(struct net_device *dev);
 623 static void tx_timeout(struct net_device *dev);
 624 static int alloc_ring(struct net_device *dev);
 625 static void refill_rx(struct net_device *dev);
 626 static void init_ring(struct net_device *dev);
 627 static void drain_tx(struct net_device *dev);
 628 static void drain_ring(struct net_device *dev);
 629 static void free_ring(struct net_device *dev);
 630 static void reinit_ring(struct net_device *dev);
 631 static void init_registers(struct net_device *dev);
 632 static int start_tx(struct sk_buff *skb, struct net_device *dev);
 633 static irqreturn_t intr_handler(int irq, void *dev_instance);
 634 static void netdev_error(struct net_device *dev, int intr_status);
 635 static int natsemi_poll(struct net_device *dev, int *budget);
 636 static void netdev_rx(struct net_device *dev, int *work_done, int work_to_do);
 637 static void netdev_tx_done(struct net_device *dev);
 638 static int natsemi_change_mtu(struct net_device *dev, int new_mtu);
 639 #ifdef CONFIG_NET_POLL_CONTROLLER
 640 static void natsemi_poll_controller(struct net_device *dev);
 641 #endif
 642 static void __set_rx_mode(struct net_device *dev);
 643 static void set_rx_mode(struct net_device *dev);
 644 static void __get_stats(struct net_device *dev);
 645 static struct net_device_stats *get_stats(struct net_device *dev);
 646 static int netdev_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
 647 static int netdev_set_wol(struct net_device *dev, u32 newval);
 648 static int netdev_get_wol(struct net_device *dev, u32 *supported, u32 *cur);
 649 static int netdev_set_sopass(struct net_device *dev, u8 *newval);
 650 static int netdev_get_sopass(struct net_device *dev, u8 *data);
 651 static int netdev_get_ecmd(struct net_device *dev, struct ethtool_cmd *ecmd);
 652 static int netdev_set_ecmd(struct net_device *dev, struct ethtool_cmd *ecmd);
 653 static void enable_wol_mode(struct net_device *dev, int enable_intr);
 654 static int netdev_close(struct net_device *dev);
 655 static int netdev_get_regs(struct net_device *dev, u8 *buf);
 656 static int netdev_get_eeprom(struct net_device *dev, u8 *buf);
 657 static const struct ethtool_ops ethtool_ops;
 658
 659 static inline void __iomem *ns_ioaddr(struct net_device *dev)
 660 {
 661         return (void __iomem *) dev->base_addr;
 662 }
 663
 664 static inline void natsemi_irq_enable(struct net_device *dev)
 665 {
 666         writel(1, ns_ioaddr(dev) + IntrEnable);
 667         readl(ns_ioaddr(dev) + IntrEnable);
 668 }
 669
 670 static inline void natsemi_irq_disable(struct net_device *dev)
 671 {
 672         writel(0, ns_ioaddr(dev) + IntrEnable);
 673         readl(ns_ioaddr(dev) + IntrEnable);
 674 }
 675
 676 static void move_int_phy(struct net_device *dev, int addr)
 677 {
 678         struct netdev_private *np = netdev_priv(dev);
 679         void __iomem *ioaddr = ns_ioaddr(dev);
 680         int target = 31;
 681
 682         /*
 683          * The internal phy is visible on the external mii bus. Therefore we must
 684          * move it away before we can send commands to an external phy.
 685          * There are two addresses we must avoid:
 686          * - the address on the external phy that is used for transmission.
 687          * - the address that we want to access. User space can access phys
 688          *   on the mii bus with SIOCGMIIREG/SIOCSMIIREG, independant from the
 689          *   phy that is used for transmission.
 690          */
 691
 692         if (target == addr)
 693                 target--;
 694         if (target == np->phy_addr_external)
 695                 target--;
 696         writew(target, ioaddr + PhyCtrl);
 697         readw(ioaddr + PhyCtrl);
 698         udelay(1);
 699 }
 700
 701 static void __devinit natsemi_init_media (struct net_device *dev)
 702 {
 703         struct netdev_private *np = netdev_priv(dev);
 704         u32 tmp;
 705
 706         if (np->ignore_phy)
 707                 netif_carrier_on(dev);
 708         else
 709                 netif_carrier_off(dev);
 710
 711         /* get the initial settings from hardware */
 712         tmp            = mdio_read(dev, MII_BMCR);
 713         np->speed      = (tmp & BMCR_SPEED100)? SPEED_100     : SPEED_10;
 714         np->duplex     = (tmp & BMCR_FULLDPLX)? DUPLEX_FULL   : DUPLEX_HALF;
 715         np->autoneg    = (tmp & BMCR_ANENABLE)? AUTONEG_ENABLE: AUTONEG_DISABLE;
 716         np->advertising= mdio_read(dev, MII_ADVERTISE);
 717
 718         if ((np->advertising & ADVERTISE_ALL) != ADVERTISE_ALL
 719          && netif_msg_probe(np)) {
 720                 printk(KERN_INFO "natsemi %s: Transceiver default autonegotiation %s "
 721                         "10%s %s duplex.\n",
 722                         pci_name(np->pci_dev),
 723                         (mdio_read(dev, MII_BMCR) & BMCR_ANENABLE)?
 724                           "enabled, advertise" : "disabled, force",
 725                         (np->advertising &
 726                           (ADVERTISE_100FULL|ADVERTISE_100HALF))?
 727                             "0" : "",
 728                         (np->advertising &
 729                           (ADVERTISE_100FULL|ADVERTISE_10FULL))?
 730                             "full" : "half");
 731         }
 732         if (netif_msg_probe(np))
 733                 printk(KERN_INFO
 734                         "natsemi %s: Transceiver status %#04x advertising %#04x.\n",
 735                         pci_name(np->pci_dev), mdio_read(dev, MII_BMSR),
 736                         np->advertising);
 737
 738 }
 739
 740 static int __devinit natsemi_probe1 (struct pci_dev *pdev,
 741         const struct pci_device_id *ent)
 742 {
 743         struct net_device *dev;
 744         struct netdev_private *np;
 745         int i, option, irq, chip_idx = ent->driver_data;
 746         static int find_cnt = -1;
 747         unsigned long iostart, iosize;
 748         void __iomem *ioaddr;
 749         const int pcibar = 1; /* PCI base address register */
 750         int prev_eedata;
 751         u32 tmp;
 752
 753 /* when built into the kernel, we only print version if device is found */
 754 #ifndef MODULE
 755         static int printed_version;
 756         if (!printed_version++)
 757                 printk(version);
 758 #endif
 759
 760         i = pci_enable_device(pdev);
 761         if (i) return i;
 762
 763         /* natsemi has a non-standard PM control register
 764          * in PCI config space.  Some boards apparently need
 765          * to be brought to D0 in this manner.
 766          */
 767         pci_read_config_dword(pdev, PCIPM, &tmp);
 768         if (tmp & PCI_PM_CTRL_STATE_MASK) {
 769                 /* D0 state, disable PME assertion */
 770                 u32 newtmp = tmp & ~PCI_PM_CTRL_STATE_MASK;
 771                 pci_write_config_dword(pdev, PCIPM, newtmp);
 772         }
 773
 774         find_cnt++;
 775         iostart = pci_resource_start(pdev, pcibar);
 776         iosize = pci_resource_len(pdev, pcibar);
 777         irq = pdev->irq;
 778
 779         pci_set_master(pdev);
 780
 781         dev = alloc_etherdev(sizeof (struct netdev_private));
 782         if (!dev)
 783                 return -ENOMEM;
 784         SET_MODULE_OWNER(dev);
 785         SET_NETDEV_DEV(dev, &pdev->dev);
 786
 787         i = pci_request_regions(pdev, DRV_NAME);
 788         if (i)
 789                 goto err_pci_request_regions;
 790
 791         ioaddr = ioremap(iostart, iosize);
 792         if (!ioaddr) {
 793                 i = -ENOMEM;
 794                 goto err_ioremap;
 795         }
 796
 797         /* Work around the dropped serial bit. */
 798         prev_eedata = eeprom_read(ioaddr, 6);
 799         for (i = 0; i < 3; i++) {
 800                 int eedata = eeprom_read(ioaddr, i + 7);
 801                 dev->dev_addr[i*2] = (eedata << 1) + (prev_eedata >> 15);
 802                 dev->dev_addr[i*2+1] = eedata >> 7;
 803                 prev_eedata = eedata;
 804         }
 805
 806         dev->base_addr = (unsigned long __force) ioaddr;
 807         dev->irq = irq;
 808
 809         np = netdev_priv(dev);
 810
 811         np->pci_dev = pdev;
 812         pci_set_drvdata(pdev, dev);
 813         np->iosize = iosize;
 814         spin_lock_init(&np->lock);
 815         np->msg_enable = (debug >= 0) ? (1<<debug)-1 : NATSEMI_DEF_MSG;
 816         np->hands_off = 0;
 817         np->intr_status = 0;
 818         np->eeprom_size = natsemi_pci_info[chip_idx].eeprom_size;
 819         if (natsemi_pci_info[chip_idx].flags & NATSEMI_FLAG_IGNORE_PHY)
 820                 np->ignore_phy = 1;
 821         else
 822                 np->ignore_phy = 0;
 823
 824         /* Initial port:
 825          * - If configured to ignore the PHY set up for external.
 826          * - If the nic was configured to use an external phy and if find_mii
 827          *   finds a phy: use external port, first phy that replies.
 828          * - Otherwise: internal port.
 829          * Note that the phy address for the internal phy doesn't matter:
 830          * The address would be used to access a phy over the mii bus, but
 831          * the internal phy is accessed through mapped registers.
 832          */
 833         if (np->ignore_phy || readl(ioaddr + ChipConfig) & CfgExtPhy)
 834                 dev->if_port = PORT_MII;
 835         else
 836                 dev->if_port = PORT_TP;
 837         /* Reset the chip to erase previous misconfiguration. */
 838         natsemi_reload_eeprom(dev);
 839         natsemi_reset(dev);
 840
 841         if (dev->if_port != PORT_TP) {
 842                 np->phy_addr_external = find_mii(dev);
 843                 /* If we're ignoring the PHY it doesn't matter if we can't
 844                  * find one. */
 845                 if (!np->ignore_phy && np->phy_addr_external == PHY_ADDR_NONE) {
 846                         dev->if_port = PORT_TP;
 847                         np->phy_addr_external = PHY_ADDR_INTERNAL;
 848                 }
 849         } else {
 850                 np->phy_addr_external = PHY_ADDR_INTERNAL;
 851         }
 852
 853         option = find_cnt < MAX_UNITS ? options[find_cnt] : 0;
 854         if (dev->mem_start)
 855                 option = dev->mem_start;
 856
 857         /* The lower four bits are the media type. */
 858         if (option) {
 859                 if (option & 0x200)
 860                         np->full_duplex = 1;
 861                 if (option & 15)
 862                         printk(KERN_INFO
 863                                 "natsemi %s: ignoring user supplied media type %d",
 864                                 pci_name(np->pci_dev), option & 15);
 865         }
 866         if (find_cnt < MAX_UNITS  &&  full_duplex[find_cnt])
 867                 np->full_duplex = 1;
 868
 869         /* The chip-specific entries in the device structure. */
 870         dev->open = &netdev_open;
 871         dev->hard_start_xmit = &start_tx;
 872         dev->stop = &netdev_close;
 873         dev->get_stats = &get_stats;
 874         dev->set_multicast_list = &set_rx_mode;
 875         dev->change_mtu = &natsemi_change_mtu;
 876         dev->do_ioctl = &netdev_ioctl;
 877         dev->tx_timeout = &tx_timeout;
 878         dev->watchdog_timeo = TX_TIMEOUT;
 879         dev->poll = natsemi_poll;
 880         dev->weight = 64;
 881
 882 #ifdef CONFIG_NET_POLL_CONTROLLER
 883         dev->poll_controller = &natsemi_poll_controller;
 884 #endif
 885         SET_ETHTOOL_OPS(dev, &ethtool_ops);
 886
 887         if (mtu)
 888                 dev->mtu = mtu;
 889
 890         natsemi_init_media(dev);
 891
 892         /* save the silicon revision for later querying */
 893         np->srr = readl(ioaddr + SiliconRev);
 894         if (netif_msg_hw(np))
 895                 printk(KERN_INFO "natsemi %s: silicon revision %#04x.\n",
 896                                 pci_name(np->pci_dev), np->srr);
 897
 898         i = register_netdev(dev);
 899         if (i)
 900                 goto err_register_netdev;
 901
 902         if (netif_msg_drv(np)) {
 903                 printk(KERN_INFO "natsemi %s: %s at %#08lx (%s), ",
 904                         dev->name, natsemi_pci_info[chip_idx].name, iostart,
 905                         pci_name(np->pci_dev));
 906                 for (i = 0; i < ETH_ALEN-1; i++)
 907                                 printk("%02x:", dev->dev_addr[i]);
 908                 printk("%02x, IRQ %d", dev->dev_addr[i], irq);
 909                 if (dev->if_port == PORT_TP)
 910                         printk(", port TP.\n");
 911                 else if (np->ignore_phy)
 912                         printk(", port MII, ignoring PHY\n");
 913                 else
 914                         printk(", port MII, phy ad %d.\n", np->phy_addr_external);
 915         }
 916         return 0;
 917
 918  err_register_netdev:
 919         iounmap(ioaddr);
 920
 921  err_ioremap:
 922         pci_release_regions(pdev);
 923         pci_set_drvdata(pdev, NULL);
 924
 925  err_pci_request_regions:
 926         free_netdev(dev);
 927         return i;
 928 }
 929
 930
 931 /* Read the EEPROM and MII Management Data I/O (MDIO) interfaces.
 932    The EEPROM code is for the common 93c06/46 EEPROMs with 6 bit addresses. */
 933
 934 /* Delay between EEPROM clock transitions.
 935    No extra delay is needed with 33Mhz PCI, but future 66Mhz access may need
 936    a delay.  Note that pre-2.0.34 kernels had a cache-alignment bug that
 937    made udelay() unreliable.
 938    The old method of using an ISA access as a delay, __SLOW_DOWN_IO__, is
 939    depricated.
 940 */
 941 #define eeprom_delay(ee_addr)   readl(ee_addr)
 942
 943 #define EE_Write0 (EE_ChipSelect)
 944 #define EE_Write1 (EE_ChipSelect | EE_DataIn)
 945
 946 /* The EEPROM commands include the alway-set leading bit. */
 947 enum EEPROM_Cmds {
 948         EE_WriteCmd=(5 << 6), EE_ReadCmd=(6 << 6), EE_EraseCmd=(7 << 6),
 949 };
 950
 951 static int eeprom_read(void __iomem *addr, int location)
 952 {
 953         int i;
 954         int retval = 0;
 955         void __iomem *ee_addr = addr + EECtrl;
 956         int read_cmd = location | EE_ReadCmd;
 957
 958         writel(EE_Write0, ee_addr);
 959
 960         /* Shift the read command bits out. */
 961         for (i = 10; i >= 0; i--) {
 962                 short dataval = (read_cmd & (1 << i)) ? EE_Write1 : EE_Write0;
 963                 writel(dataval, ee_addr);
 964                 eeprom_delay(ee_addr);
 965                 writel(dataval | EE_ShiftClk, ee_addr);
 966                 eeprom_delay(ee_addr);
 967         }
 968         writel(EE_ChipSelect, ee_addr);
 969         eeprom_delay(ee_addr);
 970
 971         for (i = 0; i < 16; i++) {
 972                 writel(EE_ChipSelect | EE_ShiftClk, ee_addr);
 973                 eeprom_delay(ee_addr);
 974                 retval |= (readl(ee_addr) & EE_DataOut) ? 1 << i : 0;
 975                 writel(EE_ChipSelect, ee_addr);
 976                 eeprom_delay(ee_addr);
 977         }
 978
 979         /* Terminate the EEPROM access. */
 980         writel(EE_Write0, ee_addr);
 981         writel(0, ee_addr);
 982         return retval;
 983 }
 984
 985 /* MII transceiver control section.
 986  * The 83815 series has an internal transceiver, and we present the
 987  * internal management registers as if they were MII connected.
 988  * External Phy registers are referenced through the MII interface.
 989  */
 990
 991 /* clock transitions >= 20ns (25MHz)
 992  * One readl should be good to PCI @ 100MHz
 993  */
 994 #define mii_delay(ioaddr)  readl(ioaddr + EECtrl)
 995
 996 static int mii_getbit (struct net_device *dev)
 997 {
 998         int data;
 999         void __iomem *ioaddr = ns_ioaddr(dev);
1000
1001         writel(MII_ShiftClk, ioaddr + EECtrl);
1002         data = readl(ioaddr + EECtrl);
1003         writel(0, ioaddr + EECtrl);
1004         mii_delay(ioaddr);
1005         return (data & MII_Data)? 1 : 0;
1006 }
1007
1008 static void mii_send_bits (struct net_device *dev, u32 data, int len)
1009 {
1010         u32 i;
1011         void __iomem *ioaddr = ns_ioaddr(dev);
1012
1013         for (i = (1 << (len-1)); i; i >>= 1)
1014         {
1015                 u32 mdio_val = MII_Write | ((data & i)? MII_Data : 0);
1016                 writel(mdio_val, ioaddr + EECtrl);
1017                 mii_delay(ioaddr);
1018                 writel(mdio_val | MII_ShiftClk, ioaddr + EECtrl);
1019                 mii_delay(ioaddr);
1020         }
1021         writel(0, ioaddr + EECtrl);
1022         mii_delay(ioaddr);
1023 }
1024
1025 static int miiport_read(struct net_device *dev, int phy_id, int reg)
1026 {
1027         u32 cmd;
1028         int i;
1029         u32 retval = 0;
1030
1031         /* Ensure sync */
1032         mii_send_bits (dev, 0xffffffff, 32);
1033         /* ST(2), OP(2), ADDR(5), REG#(5), TA(2), Data(16) total 32 bits */
1034         /* ST,OP = 0110'b for read operation */
1035         cmd = (0x06 << 10) | (phy_id << 5) | reg;
1036         mii_send_bits (dev, cmd, 14);
1037         /* Turnaround */
1038         if (mii_getbit (dev))
1039                 return 0;
1040         /* Read data */
1041         for (i = 0; i < 16; i++) {
1042                 retval <<= 1;
1043                 retval |= mii_getbit (dev);
1044         }
1045         /* End cycle */
1046         mii_getbit (dev);
1047         return retval;
1048 }
1049
1050 static void miiport_write(struct net_device *dev, int phy_id, int reg, u16 data)
1051 {
1052         u32 cmd;
1053
1054         /* Ensure sync */
1055         mii_send_bits (dev, 0xffffffff, 32);
1056         /* ST(2), OP(2), ADDR(5), REG#(5), TA(2), Data(16) total 32 bits */
1057         /* ST,OP,AAAAA,RRRRR,TA = 0101xxxxxxxxxx10'b = 0x5002 for write */
1058         cmd = (0x5002 << 16) | (phy_id << 23) | (reg << 18) | data;
1059         mii_send_bits (dev, cmd, 32);
1060         /* End cycle */
1061         mii_getbit (dev);
1062 }
1063
1064 static int mdio_read(struct net_device *dev, int reg)
1065 {
1066         struct netdev_private *np = netdev_priv(dev);
1067         void __iomem *ioaddr = ns_ioaddr(dev);
1068
1069         /* The 83815 series has two ports:
1070          * - an internal transceiver
1071          * - an external mii bus
1072          */
1073         if (dev->if_port == PORT_TP)
1074                 return readw(ioaddr+BasicControl+(reg<<2));
1075         else
1076                 return miiport_read(dev, np->phy_addr_external, reg);
1077 }
1078
1079 static void mdio_write(struct net_device *dev, int reg, u16 data)
1080 {
1081         struct netdev_private *np = netdev_priv(dev);
1082         void __iomem *ioaddr = ns_ioaddr(dev);
1083
1084         /* The 83815 series has an internal transceiver; handle separately */
1085         if (dev->if_port == PORT_TP)
1086                 writew(data, ioaddr+BasicControl+(reg<<2));
1087         else
1088                 miiport_write(dev, np->phy_addr_external, reg, data);
1089 }
1090
1091 static void init_phy_fixup(struct net_device *dev)
1092 {
1093         struct netdev_private *np = netdev_priv(dev);
1094         void __iomem *ioaddr = ns_ioaddr(dev);
1095         int i;
1096         u32 cfg;
1097         u16 tmp;
1098
1099         /* restore stuff lost when power was out */
1100         tmp = mdio_read(dev, MII_BMCR);
1101         if (np->autoneg == AUTONEG_ENABLE) {
1102                 /* renegotiate if something changed */
1103                 if ((tmp & BMCR_ANENABLE) == 0
1104                  || np->advertising != mdio_read(dev, MII_ADVERTISE))
1105                 {
1106                         /* turn on autonegotiation and force negotiation */
1107                         tmp |= (BMCR_ANENABLE | BMCR_ANRESTART);
1108                         mdio_write(dev, MII_ADVERTISE, np->advertising);
1109                 }
1110         } else {
1111                 /* turn off auto negotiation, set speed and duplexity */
1112                 tmp &= ~(BMCR_ANENABLE | BMCR_SPEED100 | BMCR_FULLDPLX);
1113                 if (np->speed == SPEED_100)
1114                         tmp |= BMCR_SPEED100;
1115                 if (np->duplex == DUPLEX_FULL)
1116                         tmp |= BMCR_FULLDPLX;
1117                 /*
1118                  * Note: there is no good way to inform the link partner
1119                  * that our capabilities changed. The user has to unplug
1120                  * and replug the network cable after some changes, e.g.
1121                  * after switching from 10HD, autoneg off to 100 HD,
1122                  * autoneg off.
1123                  */
1124         }
1125         mdio_write(dev, MII_BMCR, tmp);
1126         readl(ioaddr + ChipConfig);
1127         udelay(1);
1128
1129         /* find out what phy this is */
1130         np->mii = (mdio_read(dev, MII_PHYSID1) << 16)
1131                                 + mdio_read(dev, MII_PHYSID2);
1132
1133         /* handle external phys here */
1134         switch (np->mii) {
1135         case PHYID_AM79C874:
1136                 /* phy specific configuration for fibre/tp operation */
1137                 tmp = mdio_read(dev, MII_MCTRL);
1138                 tmp &= ~(MII_FX_SEL | MII_EN_SCRM);
1139                 if (dev->if_port == PORT_FIBRE)
1140                         tmp |= MII_FX_SEL;
1141                 else
1142                         tmp |= MII_EN_SCRM;
1143                 mdio_write(dev, MII_MCTRL, tmp);
1144                 break;
1145         default:
1146                 break;
1147         }
1148         cfg = readl(ioaddr + ChipConfig);
1149         if (cfg & CfgExtPhy)
1150                 return;
1151
1152         /* On page 78 of the spec, they recommend some settings for "optimum
1153            performance" to be done in sequence.  These settings optimize some
1154            of the 100Mbit autodetection circuitry.  They say we only want to
1155            do this for rev C of the chip, but engineers at NSC (Bradley
1156            Kennedy) recommends always setting them.  If you don't, you get
1157            errors on some autonegotiations that make the device unusable.
1158
1159            It seems that the DSP needs a few usec to reinitialize after
1160            the start of the phy. Just retry writing these values until they
1161            stick.
1162         */
1163         for (i=0;i<NATSEMI_HW_TIMEOUT;i++) {
1164
1165                 int dspcfg;
1166                 writew(1, ioaddr + PGSEL);
1167                 writew(PMDCSR_VAL, ioaddr + PMDCSR);
1168                 writew(TSTDAT_VAL, ioaddr + TSTDAT);
1169                 np->dspcfg = (np->srr <= SRR_DP83815_C)?
1170                         DSPCFG_VAL : (DSPCFG_COEF | readw(ioaddr + DSPCFG));
1171                 writew(np->dspcfg, ioaddr + DSPCFG);
1172                 writew(SDCFG_VAL, ioaddr + SDCFG);
1173                 writew(0, ioaddr + PGSEL);
1174                 readl(ioaddr + ChipConfig);
1175                 udelay(10);
1176
1177                 writew(1, ioaddr + PGSEL);
1178                 dspcfg = readw(ioaddr + DSPCFG);
1179                 writew(0, ioaddr + PGSEL);
1180                 if (np->dspcfg == dspcfg)
1181                         break;
1182         }
1183
1184         if (netif_msg_link(np)) {
1185                 if (i==NATSEMI_HW_TIMEOUT) {
1186                         printk(KERN_INFO
1187                                 "%s: DSPCFG mismatch after retrying for %d usec.\n",
1188                                 dev->name, i*10);
1189                 } else {
1190                         printk(KERN_INFO
1191                                 "%s: DSPCFG accepted after %d usec.\n",
1192                                 dev->name, i*10);
1193                 }
1194         }
1195         /*
1196          * Enable PHY Specific event based interrupts.  Link state change
1197          * and Auto-Negotiation Completion are among the affected.
1198          * Read the intr status to clear it (needed for wake events).
1199          */
1200         readw(ioaddr + MIntrStatus);
1201         writew(MICRIntEn, ioaddr + MIntrCtrl);
1202 }
1203
1204 static int switch_port_external(struct net_device *dev)
1205 {
1206         struct netdev_private *np = netdev_priv(dev);
1207         void __iomem *ioaddr = ns_ioaddr(dev);
1208         u32 cfg;
1209
1210         cfg = readl(ioaddr + ChipConfig);
1211         if (cfg & CfgExtPhy)
1212                 return 0;
1213
1214         if (netif_msg_link(np)) {
1215                 printk(KERN_INFO "%s: switching to external transceiver.\n",
1216                                 dev->name);
1217         }
1218
1219         /* 1) switch back to external phy */
1220         writel(cfg | (CfgExtPhy | CfgPhyDis), ioaddr + ChipConfig);
1221         readl(ioaddr + ChipConfig);
1222         udelay(1);
1223
1224         /* 2) reset the external phy: */
1225         /* resetting the external PHY has been known to cause a hub supplying
1226          * power over Ethernet to kill the power.  We don't want to kill
1227          * power to this computer, so we avoid resetting the phy.
1228          */
1229
1230         /* 3) reinit the phy fixup, it got lost during power down. */
1231         move_int_phy(dev, np->phy_addr_external);
1232         init_phy_fixup(dev);
1233
1234         return 1;
1235 }
1236
1237 static int switch_port_internal(struct net_device *dev)
1238 {
1239         struct netdev_private *np = netdev_priv(dev);
1240         void __iomem *ioaddr = ns_ioaddr(dev);
1241         int i;
1242         u32 cfg;
1243         u16 bmcr;
1244
1245         cfg = readl(ioaddr + ChipConfig);
1246         if (!(cfg &CfgExtPhy))
1247                 return 0;
1248
1249         if (netif_msg_link(np)) {
1250                 printk(KERN_INFO "%s: switching to internal transceiver.\n",
1251                                 dev->name);
1252         }
1253         /* 1) switch back to internal phy: */
1254         cfg = cfg & ~(CfgExtPhy | CfgPhyDis);
1255         writel(cfg, ioaddr + ChipConfig);
1256         readl(ioaddr + ChipConfig);
1257         udelay(1);
1258
1259         /* 2) reset the internal phy: */
1260         bmcr = readw(ioaddr+BasicControl+(MII_BMCR<<2));
1261         writel(bmcr | BMCR_RESET, ioaddr+BasicControl+(MII_BMCR<<2));
1262         readl(ioaddr + ChipConfig);
1263         udelay(10);
1264         for (i=0;i<NATSEMI_HW_TIMEOUT;i++) {
1265                 bmcr = readw(ioaddr+BasicControl+(MII_BMCR<<2));
1266                 if (!(bmcr & BMCR_RESET))
1267                         break;
1268                 udelay(10);
1269         }
1270         if (i==NATSEMI_HW_TIMEOUT && netif_msg_link(np)) {
1271                 printk(KERN_INFO
1272                         "%s: phy reset did not complete in %d usec.\n",
1273                         dev->name, i*10);
1274         }
1275         /* 3) reinit the phy fixup, it got lost during power down. */
1276         init_phy_fixup(dev);
1277
1278         return 1;
1279 }
1280
1281 /* Scan for a PHY on the external mii bus.
1282  * There are two tricky points:
1283  * - Do not scan while the internal phy is enabled. The internal phy will
1284  *   crash: e.g. reads from the DSPCFG register will return odd values and
1285  *   the nasty random phy reset code will reset the nic every few seconds.
1286  * - The internal phy must be moved around, an external phy could
1287  *   have the same address as the internal phy.
1288  */
1289 static int find_mii(struct net_device *dev)
1290 {
1291         struct netdev_private *np = netdev_priv(dev);
1292         int tmp;
1293         int i;
1294         int did_switch;
1295
1296         /* Switch to external phy */
1297         did_switch = switch_port_external(dev);
1298
1299         /* Scan the possible phy addresses:
1300          *
1301          * PHY address 0 means that the phy is in isolate mode. Not yet
1302          * supported due to lack of test hardware. User space should
1303          * handle it through ethtool.
1304          */
1305         for (i = 1; i <= 31; i++) {
1306                 move_int_phy(dev, i);
1307                 tmp = miiport_read(dev, i, MII_BMSR);
1308                 if (tmp != 0xffff && tmp != 0x0000) {
1309                         /* found something! */
1310                         np->mii = (mdio_read(dev, MII_PHYSID1) << 16)
1311                                         + mdio_read(dev, MII_PHYSID2);
1312                         if (netif_msg_probe(np)) {
1313                                 printk(KERN_INFO "natsemi %s: found external phy %08x at address %d.\n",
1314                                                 pci_name(np->pci_dev), np->mii, i);
1315                         }
1316                         break;
1317                 }
1318         }
1319         /* And switch back to internal phy: */
1320         if (did_switch)
1321                 switch_port_internal(dev);
1322         return i;
1323 }
1324
1325 /* CFG bits [13:16] [18:23] */
1326 #define CFG_RESET_SAVE 0xfde000
1327 /* WCSR bits [0:4] [9:10] */
1328 #define WCSR_RESET_SAVE 0x61f
1329 /* RFCR bits [20] [22] [27:31] */
1330 #define RFCR_RESET_SAVE 0xf8500000;
1331
1332 static void natsemi_reset(struct net_device *dev)
1333 {
1334         int i;
1335         u32 cfg;
1336         u32 wcsr;
1337         u32 rfcr;
1338         u16 pmatch[3];
1339         u16 sopass[3];
1340         struct netdev_private *np = netdev_priv(dev);
1341         void __iomem *ioaddr = ns_ioaddr(dev);
1342
1343         /*
1344          * Resetting the chip causes some registers to be lost.
1345          * Natsemi suggests NOT reloading the EEPROM while live, so instead
1346          * we save the state that would have been loaded from EEPROM
1347          * on a normal power-up (see the spec EEPROM map).  This assumes
1348          * whoever calls this will follow up with init_registers() eventually.
1349          */
1350
1351         /* CFG */
1352         cfg = readl(ioaddr + ChipConfig) & CFG_RESET_SAVE;
1353         /* WCSR */
1354         wcsr = readl(ioaddr + WOLCmd) & WCSR_RESET_SAVE;
1355         /* RFCR */
1356         rfcr = readl(ioaddr + RxFilterAddr) & RFCR_RESET_SAVE;
1357         /* PMATCH */
1358         for (i = 0; i < 3; i++) {
1359                 writel(i*2, ioaddr + RxFilterAddr);
1360                 pmatch[i] = readw(ioaddr + RxFilterData);
1361         }
1362         /* SOPAS */
1363         for (i = 0; i < 3; i++) {
1364                 writel(0xa+(i*2), ioaddr + RxFilterAddr);
1365                 sopass[i] = readw(ioaddr + RxFilterData);
1366         }
1367
1368         /* now whack the chip */
1369         writel(ChipReset, ioaddr + ChipCmd);
1370         for (i=0;i<NATSEMI_HW_TIMEOUT;i++) {
1371                 if (!(readl(ioaddr + ChipCmd) & ChipReset))
1372                         break;
1373                 udelay(5);
1374         }
1375         if (i==NATSEMI_HW_TIMEOUT) {
1376                 printk(KERN_WARNING "%s: reset did not complete in %d usec.\n",
1377                         dev->name, i*5);
1378         } else if (netif_msg_hw(np)) {
1379                 printk(KERN_DEBUG "%s: reset completed in %d usec.\n",
1380                         dev->name, i*5);
1381         }
1382
1383         /* restore CFG */
1384         cfg |= readl(ioaddr + ChipConfig) & ~CFG_RESET_SAVE;
1385         /* turn on external phy if it was selected */
1386         if (dev->if_port == PORT_TP)
1387                 cfg &= ~(CfgExtPhy | CfgPhyDis);
1388         else
1389                 cfg |= (CfgExtPhy | CfgPhyDis);
1390         writel(cfg, ioaddr + ChipConfig);
1391         /* restore WCSR */
1392         wcsr |= readl(ioaddr + WOLCmd) & ~WCSR_RESET_SAVE;
1393         writel(wcsr, ioaddr + WOLCmd);
1394         /* read RFCR */
1395         rfcr |= readl(ioaddr + RxFilterAddr) & ~RFCR_RESET_SAVE;
1396         /* restore PMATCH */
1397         for (i = 0; i < 3; i++) {
1398                 writel(i*2, ioaddr + RxFilterAddr);
1399                 writew(pmatch[i], ioaddr + RxFilterData);
1400         }
1401         for (i = 0; i < 3; i++) {
1402                 writel(0xa+(i*2), ioaddr + RxFilterAddr);
1403                 writew(sopass[i], ioaddr + RxFilterData);
1404         }
1405         /* restore RFCR */
1406         writel(rfcr, ioaddr + RxFilterAddr);
1407 }
1408
1409 static void reset_rx(struct net_device *dev)
1410 {
1411         int i;
1412         struct netdev_private *np = netdev_priv(dev);
1413         void __iomem *ioaddr = ns_ioaddr(dev);
1414
1415         np->intr_status &= ~RxResetDone;
1416
1417         writel(RxReset, ioaddr + ChipCmd);
1418
1419         for (i=0;i<NATSEMI_HW_TIMEOUT;i++) {
1420                 np->intr_status |= readl(ioaddr + IntrStatus);
1421                 if (np->intr_status & RxResetDone)
1422                         break;
1423                 udelay(15);
1424         }
1425         if (i==NATSEMI_HW_TIMEOUT) {
1426                 printk(KERN_WARNING "%s: RX reset did not complete in %d usec.\n",
1427                        dev->name, i*15);
1428         } else if (netif_msg_hw(np)) {
1429                 printk(KERN_WARNING "%s: RX reset took %d usec.\n",
1430                        dev->name, i*15);
1431         }
1432 }
1433
1434 static void natsemi_reload_eeprom(struct net_device *dev)
1435 {
1436         struct netdev_private *np = netdev_priv(dev);
1437         void __iomem *ioaddr = ns_ioaddr(dev);
1438         int i;
1439
1440         writel(EepromReload, ioaddr + PCIBusCfg);
1441         for (i=0;i<NATSEMI_HW_TIMEOUT;i++) {
1442                 udelay(50);
1443                 if (!(readl(ioaddr + PCIBusCfg) & EepromReload))
1444                         break;
1445         }
1446         if (i==NATSEMI_HW_TIMEOUT) {
1447                 printk(KERN_WARNING "natsemi %s: EEPROM did not reload in %d usec.\n",
1448                         pci_name(np->pci_dev), i*50);
1449         } else if (netif_msg_hw(np)) {
1450                 printk(KERN_DEBUG "natsemi %s: EEPROM reloaded in %d usec.\n",
1451                         pci_name(np->pci_dev), i*50);
1452         }
1453 }
1454
1455 static void natsemi_stop_rxtx(struct net_device *dev)
1456 {
1457         void __iomem * ioaddr = ns_ioaddr(dev);
1458         struct netdev_private *np = netdev_priv(dev);
1459         int i;
1460
1461         writel(RxOff | TxOff, ioaddr + ChipCmd);
1462         for(i=0;i< NATSEMI_HW_TIMEOUT;i++) {
1463                 if ((readl(ioaddr + ChipCmd) & (TxOn|RxOn)) == 0)
1464                         break;
1465                 udelay(5);
1466         }
1467         if (i==NATSEMI_HW_TIMEOUT) {
1468                 printk(KERN_WARNING "%s: Tx/Rx process did not stop in %d usec.\n",
1469                         dev->name, i*5);
1470         } else if (netif_msg_hw(np)) {
1471                 printk(KERN_DEBUG "%s: Tx/Rx process stopped in %d usec.\n",
1472                         dev->name, i*5);
1473         }
1474 }
1475
1476 static int netdev_open(struct net_device *dev)
1477 {
1478         struct netdev_private *np = netdev_priv(dev);
1479         void __iomem * ioaddr = ns_ioaddr(dev);
1480         int i;
1481
1482         /* Reset the chip, just in case. */
1483         natsemi_reset(dev);
1484
1485         i = request_irq(dev->irq, &intr_handler, IRQF_SHARED, dev->name, dev);
1486         if (i) return i;
1487
1488         if (netif_msg_ifup(np))
1489                 printk(KERN_DEBUG "%s: netdev_open() irq %d.\n",
1490                         dev->name, dev->irq);
1491         i = alloc_ring(dev);
1492         if (i < 0) {
1493                 free_irq(dev->irq, dev);
1494                 return i;
1495         }
1496         init_ring(dev);
1497         spin_lock_irq(&np->lock);
1498         init_registers(dev);
1499         /* now set the MAC address according to dev->dev_addr */
1500         for (i = 0; i < 3; i++) {
1501                 u16 mac = (dev->dev_addr[2*i+1]<<8) + dev->dev_addr[2*i];
1502
1503                 writel(i*2, ioaddr + RxFilterAddr);
1504                 writew(mac, ioaddr + RxFilterData);
1505         }
1506         writel(np->cur_rx_mode, ioaddr + RxFilterAddr);
1507         spin_unlock_irq(&np->lock);
1508
1509         netif_start_queue(dev);
1510
1511         if (netif_msg_ifup(np))
1512                 printk(KERN_DEBUG "%s: Done netdev_open(), status: %#08x.\n",
1513                         dev->name, (int)readl(ioaddr + ChipCmd));
1514
1515         /* Set the timer to check for link beat. */
1516         init_timer(&np->timer);
1517         np->timer.expires = jiffies + NATSEMI_TIMER_FREQ;
1518         np->timer.data = (unsigned long)dev;
1519         np->timer.function = &netdev_timer; /* timer handler */
1520         add_timer(&np->timer);
1521
1522         return 0;
1523 }
1524
1525 static void do_cable_magic(struct net_device *dev)
1526 {
1527         struct netdev_private *np = netdev_priv(dev);
1528         void __iomem *ioaddr = ns_ioaddr(dev);
1529
1530         if (dev->if_port != PORT_TP)
1531                 return;
1532
1533         if (np->srr >= SRR_DP83816_A5)
1534                 return;
1535
1536         /*
1537          * 100 MBit links with short cables can trip an issue with the chip.
1538          * The problem manifests as lots of CRC errors and/or flickering
1539          * activity LED while idle.  This process is based on instructions
1540          * from engineers at National.
1541          */
1542         if (readl(ioaddr + ChipConfig) & CfgSpeed100) {
1543                 u16 data;
1544
1545                 writew(1, ioaddr + PGSEL);
1546                 /*
1547                  * coefficient visibility should already be enabled via
1548                  * DSPCFG | 0x1000
1549                  */
1550                 data = readw(ioaddr + TSTDAT) & 0xff;
1551                 /*
1552                  * the value must be negative, and within certain values
1553                  * (these values all come from National)
1554                  */
1555                 if (!(data & 0x80) || ((data >= 0xd8) && (data <= 0xff))) {
1556                         struct netdev_private *np = netdev_priv(dev);
1557
1558                         /* the bug has been triggered - fix the coefficient */
1559                         writew(TSTDAT_FIXED, ioaddr + TSTDAT);
1560                         /* lock the value */
1561                         data = readw(ioaddr + DSPCFG);
1562                         np->dspcfg = data | DSPCFG_LOCK;
1563                         writew(np->dspcfg, ioaddr + DSPCFG);
1564                 }
1565                 writew(0, ioaddr + PGSEL);
1566         }
1567 }
1568
1569 static void undo_cable_magic(struct net_device *dev)
1570 {
1571         u16 data;
1572         struct netdev_private *np = netdev_priv(dev);
1573         void __iomem * ioaddr = ns_ioaddr(dev);
1574
1575         if (dev->if_port != PORT_TP)
1576                 return;
1577
1578         if (np->srr >= SRR_DP83816_A5)
1579                 return;
1580
1581         writew(1, ioaddr + PGSEL);
1582         /* make sure the lock bit is clear */
1583         data = readw(ioaddr + DSPCFG);
1584         np->dspcfg = data & ~DSPCFG_LOCK;
1585         writew(np->dspcfg, ioaddr + DSPCFG);
1586         writew(0, ioaddr + PGSEL);
1587 }
1588
1589 static void check_link(struct net_device *dev)
1590 {
1591         struct netdev_private *np = netdev_priv(dev);
1592         void __iomem * ioaddr = ns_ioaddr(dev);
1593         int duplex = np->duplex;
1594         u16 bmsr;
1595
1596         /* If we are ignoring the PHY then don't try reading it. */
1597         if (np->ignore_phy)
1598                 goto propagate_state;
1599
1600         /* The link status field is latched: it remains low after a temporary
1601          * link failure until it's read. We need the current link status,
1602          * thus read twice.
1603          */
1604         mdio_read(dev, MII_BMSR);
1605         bmsr = mdio_read(dev, MII_BMSR);
1606
1607         if (!(bmsr & BMSR_LSTATUS)) {
1608                 if (netif_carrier_ok(dev)) {
1609                         if (netif_msg_link(np))
1610                                 printk(KERN_NOTICE "%s: link down.\n",
1611                                        dev->name);
1612                         netif_carrier_off(dev);
1613                         undo_cable_magic(dev);
1614                 }
1615                 return;
1616         }
1617         if (!netif_carrier_ok(dev)) {
1618                 if (netif_msg_link(np))
1619                         printk(KERN_NOTICE "%s: link up.\n", dev->name);
1620                 netif_carrier_on(dev);
1621                 do_cable_magic(dev);
1622         }
1623
1624         duplex = np->full_duplex;
1625         if (!duplex) {
1626                 if (bmsr & BMSR_ANEGCOMPLETE) {
1627                         int tmp = mii_nway_result(
1628                                 np->advertising & mdio_read(dev, MII_LPA));
1629                         if (tmp == LPA_100FULL || tmp == LPA_10FULL)
1630                                 duplex = 1;
1631                 } else if (mdio_read(dev, MII_BMCR) & BMCR_FULLDPLX)
1632                         duplex = 1;
1633         }
1634
1635 propagate_state:
1636         /* if duplex is set then bit 28 must be set, too */
1637         if (duplex ^ !!(np->rx_config & RxAcceptTx)) {
1638                 if (netif_msg_link(np))
1639                         printk(KERN_INFO
1640                                 "%s: Setting %s-duplex based on negotiated "
1641                                 "link capability.\n", dev->name,
1642                                 duplex ? "full" : "half");
1643                 if (duplex) {
1644                         np->rx_config |= RxAcceptTx;
1645                         np->tx_config |= TxCarrierIgn | TxHeartIgn;
1646                 } else {
1647                         np->rx_config &= ~RxAcceptTx;
1648                         np->tx_config &= ~(TxCarrierIgn | TxHeartIgn);
1649                 }
1650                 writel(np->tx_config, ioaddr + TxConfig);
1651                 writel(np->rx_config, ioaddr + RxConfig);
1652         }
1653 }
1654
1655 static void init_registers(struct net_device *dev)
1656 {
1657         struct netdev_private *np = netdev_priv(dev);
1658         void __iomem * ioaddr = ns_ioaddr(dev);
1659
1660         init_phy_fixup(dev);
1661
1662         /* clear any interrupts that are pending, such as wake events */
1663         readl(ioaddr + IntrStatus);
1664
1665         writel(np->ring_dma, ioaddr + RxRingPtr);
1666         writel(np->ring_dma + RX_RING_SIZE * sizeof(struct netdev_desc),
1667                 ioaddr + TxRingPtr);
1668
1669         /* Initialize other registers.
1670          * Configure the PCI bus bursts and FIFO thresholds.
1671          * Configure for standard, in-spec Ethernet.
1672          * Start with half-duplex. check_link will update
1673          * to the correct settings.
1674          */
1675
1676         /* DRTH: 2: start tx if 64 bytes are in the fifo
1677          * FLTH: 0x10: refill with next packet if 512 bytes are free
1678          * MXDMA: 0: up to 256 byte bursts.
1679          *      MXDMA must be <= FLTH
1680          * ECRETRY=1
1681          * ATP=1
1682          */
1683         np->tx_config = TxAutoPad | TxCollRetry | TxMxdma_256 |
1684                                 TX_FLTH_VAL | TX_DRTH_VAL_START;
1685         writel(np->tx_config, ioaddr + TxConfig);
1686
1687         /* DRTH 0x10: start copying to memory if 128 bytes are in the fifo
1688          * MXDMA 0: up to 256 byte bursts
1689          */
1690         np->rx_config = RxMxdma_256 | RX_DRTH_VAL;
1691         /* if receive ring now has bigger buffers than normal, enable jumbo */
1692         if (np->rx_buf_sz > NATSEMI_LONGPKT)
1693                 np->rx_config |= RxAcceptLong;
1694
1695         writel(np->rx_config, ioaddr + RxConfig);
1696
1697         /* Disable PME:
1698          * The PME bit is initialized from the EEPROM contents.
1699          * PCI cards probably have PME disabled, but motherboard
1700          * implementations may have PME set to enable WakeOnLan.
1701          * With PME set the chip will scan incoming packets but
1702          * nothing will be written to memory. */
1703         np->SavedClkRun = readl(ioaddr + ClkRun);
1704         writel(np->SavedClkRun & ~PMEEnable, ioaddr + ClkRun);
1705         if (np->SavedClkRun & PMEStatus && netif_msg_wol(np)) {
1706                 printk(KERN_NOTICE "%s: Wake-up event %#08x\n",
1707                         dev->name, readl(ioaddr + WOLCmd));
1708         }
1709
1710         check_link(dev);
1711         __set_rx_mode(dev);
1712
1713         /* Enable interrupts by setting the interrupt mask. */
1714         writel(DEFAULT_INTR, ioaddr + IntrMask);
1715         writel(1, ioaddr + IntrEnable);
1716
1717         writel(RxOn | TxOn, ioaddr + ChipCmd);
1718         writel(StatsClear, ioaddr + StatsCtrl); /* Clear Stats */
1719 }
1720
1721 /*
1722  * netdev_timer:
1723  * Purpose:
1724  * 1) check for link changes. Usually they are handled by the MII interrupt
1725  *    but it doesn't hurt to check twice.
1726  * 2) check for sudden death of the NIC:
1727  *    It seems that a reference set for this chip went out with incorrect info,
1728  *    and there exist boards that aren't quite right.  An unexpected voltage
1729  *    drop can cause the PHY to get itself in a weird state (basically reset).
1730  *    NOTE: this only seems to affect revC chips.
1731  * 3) check of death of the RX path due to OOM
1732  */
1733 static void netdev_timer(unsigned long data)
1734 {
1735         struct net_device *dev = (struct net_device *)data;
1736         struct netdev_private *np = netdev_priv(dev);
1737         void __iomem * ioaddr = ns_ioaddr(dev);
1738         int next_tick = 5*HZ;
1739
1740         if (netif_msg_timer(np)) {
1741                 /* DO NOT read the IntrStatus register,
1742                  * a read clears any pending interrupts.
1743                  */
1744                 printk(KERN_DEBUG "%s: Media selection timer tick.\n",
1745                         dev->name);
1746         }
1747
1748         if (dev->if_port == PORT_TP) {
1749                 u16 dspcfg;
1750
1751                 spin_lock_irq(&np->lock);
1752                 /* check for a nasty random phy-reset - use dspcfg as a flag */
1753                 writew(1, ioaddr+PGSEL);
1754                 dspcfg = readw(ioaddr+DSPCFG);
1755                 writew(0, ioaddr+PGSEL);
1756                 if (dspcfg != np->dspcfg) {
1757                         if (!netif_queue_stopped(dev)) {
1758                                 spin_unlock_irq(&np->lock);
1759                                 if (netif_msg_hw(np))
1760                                         printk(KERN_NOTICE "%s: possible phy reset: "
1761                                                 "re-initializing\n", dev->name);
1762                                 disable_irq(dev->irq);
1763                                 spin_lock_irq(&np->lock);
1764                                 natsemi_stop_rxtx(dev);
1765                                 dump_ring(dev);
1766                                 reinit_ring(dev);
1767                                 init_registers(dev);
1768                                 spin_unlock_irq(&np->lock);
1769                                 enable_irq(dev->irq);
1770                         } else {
1771                                 /* hurry back */
1772                                 next_tick = HZ;
1773                                 spin_unlock_irq(&np->lock);
1774                         }
1775                 } else {
1776                         /* init_registers() calls check_link() for the above case */
1777                         check_link(dev);
1778                         spin_unlock_irq(&np->lock);
1779                 }
1780         } else {
1781                 spin_lock_irq(&np->lock);
1782                 check_link(dev);
1783                 spin_unlock_irq(&np->lock);
1784         }
1785         if (np->oom) {
1786                 disable_irq(dev->irq);
1787                 np->oom = 0;
1788                 refill_rx(dev);
1789                 enable_irq(dev->irq);
1790                 if (!np->oom) {
1791                         writel(RxOn, ioaddr + ChipCmd);
1792                 } else {
1793                         next_tick = 1;
1794                 }
1795         }
1796         mod_timer(&np->timer, jiffies + next_tick);
1797 }
1798
1799 static void dump_ring(struct net_device *dev)
1800 {
1801         struct netdev_private *np = netdev_priv(dev);
1802
1803         if (netif_msg_pktdata(np)) {
1804                 int i;
1805                 printk(KERN_DEBUG "  Tx ring at %p:\n", np->tx_ring);
1806                 for (i = 0; i < TX_RING_SIZE; i++) {
1807                         printk(KERN_DEBUG " #%d desc. %#08x %#08x %#08x.\n",
1808                                 i, np->tx_ring[i].next_desc,
1809                                 np->tx_ring[i].cmd_status,
1810                                 np->tx_ring[i].addr);
1811                 }
1812                 printk(KERN_DEBUG "  Rx ring %p:\n", np->rx_ring);
1813                 for (i = 0; i < RX_RING_SIZE; i++) {
1814                         printk(KERN_DEBUG " #%d desc. %#08x %#08x %#08x.\n",
1815                                 i, np->rx_ring[i].next_desc,
1816                                 np->rx_ring[i].cmd_status,
1817                                 np->rx_ring[i].addr);
1818                 }
1819         }
1820 }
1821
1822 static void tx_timeout(struct net_device *dev)
1823 {
1824         struct netdev_private *np = netdev_priv(dev);
1825         void __iomem * ioaddr = ns_ioaddr(dev);
1826
1827         disable_irq(dev->irq);
1828         spin_lock_irq(&np->lock);
1829         if (!np->hands_off) {
1830                 if (netif_msg_tx_err(np))
1831                         printk(KERN_WARNING
1832                                 "%s: Transmit timed out, status %#08x,"
1833                                 " resetting...\n",
1834                                 dev->name, readl(ioaddr + IntrStatus));
1835                 dump_ring(dev);
1836
1837                 natsemi_reset(dev);
1838                 reinit_ring(dev);
1839                 init_registers(dev);
1840         } else {
1841                 printk(KERN_WARNING
1842                         "%s: tx_timeout while in hands_off state?\n",
1843                         dev->name);
1844         }
1845         spin_unlock_irq(&np->lock);
1846         enable_irq(dev->irq);
1847
1848         dev->trans_start = jiffies;
1849         np->stats.tx_errors++;
1850         netif_wake_queue(dev);
1851 }
1852
1853 static int alloc_ring(struct net_device *dev)
1854 {
1855         struct netdev_private *np = netdev_priv(dev);
1856         np->rx_ring = pci_alloc_consistent(np->pci_dev,
1857                 sizeof(struct netdev_desc) * (RX_RING_SIZE+TX_RING_SIZE),
1858                 &np->ring_dma);
1859         if (!np->rx_ring)
1860                 return -ENOMEM;
1861         np->tx_ring = &np->rx_ring[RX_RING_SIZE];
1862         return 0;
1863 }
1864
1865 static void refill_rx(struct net_device *dev)
1866 {
1867         struct netdev_private *np = netdev_priv(dev);
1868
1869         /* Refill the Rx ring buffers. */
1870         for (; np->cur_rx - np->dirty_rx > 0; np->dirty_rx++) {
1871                 struct sk_buff *skb;
1872                 int entry = np->dirty_rx % RX_RING_SIZE;
1873                 if (np->rx_skbuff[entry] == NULL) {
1874                         unsigned int buflen = np->rx_buf_sz+NATSEMI_PADDING;
1875                         skb = dev_alloc_skb(buflen);
1876                         np->rx_skbuff[entry] = skb;
1877                         if (skb == NULL)
1878                                 break; /* Better luck next round. */
1879                         skb->dev = dev; /* Mark as being used by this device. */
1880                         np->rx_dma[entry] = pci_map_single(np->pci_dev,
1881                                 skb->data, buflen, PCI_DMA_FROMDEVICE);
1882                         np->rx_ring[entry].addr = cpu_to_le32(np->rx_dma[entry]);
1883                 }
1884                 np->rx_ring[entry].cmd_status = cpu_to_le32(np->rx_buf_sz);
1885         }
1886         if (np->cur_rx - np->dirty_rx == RX_RING_SIZE) {
1887                 if (netif_msg_rx_err(np))
1888                         printk(KERN_WARNING "%s: going OOM.\n", dev->name);
1889                 np->oom = 1;
1890         }
1891 }
1892
1893 static void set_bufsize(struct net_device *dev)
1894 {
1895         struct netdev_private *np = netdev_priv(dev);
1896         if (dev->mtu <= ETH_DATA_LEN)
1897                 np->rx_buf_sz = ETH_DATA_LEN + NATSEMI_HEADERS;
1898         else
1899                 np->rx_buf_sz = dev->mtu + NATSEMI_HEADERS;
1900 }
1901
1902 /* Initialize the Rx and Tx rings, along with various 'dev' bits. */
1903 static void init_ring(struct net_device *dev)
1904 {
1905         struct netdev_private *np = netdev_priv(dev);
1906         int i;
1907
1908         /* 1) TX ring */
1909         np->dirty_tx = np->cur_tx = 0;
1910         for (i = 0; i < TX_RING_SIZE; i++) {
1911                 np->tx_skbuff[i] = NULL;
1912                 np->tx_ring[i].next_desc = cpu_to_le32(np->ring_dma
1913                         +sizeof(struct netdev_desc)
1914                         *((i+1)%TX_RING_SIZE+RX_RING_SIZE));
1915                 np->tx_ring[i].cmd_status = 0;
1916         }
1917
1918         /* 2) RX ring */
1919         np->dirty_rx = 0;
1920         np->cur_rx = RX_RING_SIZE;
1921         np->oom = 0;
1922         set_bufsize(dev);
1923
1924         np->rx_head_desc = &np->rx_ring[0];
1925
1926         /* Please be carefull before changing this loop - at least gcc-2.95.1
1927          * miscompiles it otherwise.
1928          */
1929         /* Initialize all Rx descriptors. */
1930         for (i = 0; i < RX_RING_SIZE; i++) {
1931                 np->rx_ring[i].next_desc = cpu_to_le32(np->ring_dma
1932                                 +sizeof(struct netdev_desc)
1933                                 *((i+1)%RX_RING_SIZE));
1934                 np->rx_ring[i].cmd_status = cpu_to_le32(DescOwn);
1935                 np->rx_skbuff[i] = NULL;
1936         }
1937         refill_rx(dev);
1938         dump_ring(dev);
1939 }
1940
1941 static void drain_tx(struct net_device *dev)
1942 {
1943         struct netdev_private *np = netdev_priv(dev);
1944         int i;
1945
1946         for (i = 0; i < TX_RING_SIZE; i++) {
1947                 if (np->tx_skbuff[i]) {
1948                         pci_unmap_single(np->pci_dev,
1949                                 np->tx_dma[i], np->tx_skbuff[i]->len,
1950                                 PCI_DMA_TODEVICE);
1951                         dev_kfree_skb(np->tx_skbuff[i]);
1952                         np->stats.tx_dropped++;
1953                 }
1954                 np->tx_skbuff[i] = NULL;
1955         }
1956 }
1957
1958 static void drain_rx(struct net_device *dev)
1959 {
1960         struct netdev_private *np = netdev_priv(dev);
1961         unsigned int buflen = np->rx_buf_sz;
1962         int i;
1963
1964         /* Free all the skbuffs in the Rx queue. */
1965         for (i = 0; i < RX_RING_SIZE; i++) {
1966                 np->rx_ring[i].cmd_status = 0;
1967                 np->rx_ring[i].addr = 0xBADF00D0; /* An invalid address. */
1968                 if (np->rx_skbuff[i]) {
1969                         pci_unmap_single(np->pci_dev,
1970                                 np->rx_dma[i], buflen,
1971                                 PCI_DMA_FROMDEVICE);
1972                         dev_kfree_skb(np->rx_skbuff[i]);
1973                 }
1974                 np->rx_skbuff[i] = NULL;
1975         }
1976 }
1977
1978 static void drain_ring(struct net_device *dev)
1979 {
1980         drain_rx(dev);
1981         drain_tx(dev);
1982 }
1983
1984 static void free_ring(struct net_device *dev)
1985 {
1986         struct netdev_private *np = netdev_priv(dev);
1987         pci_free_consistent(np->pci_dev,
1988                 sizeof(struct netdev_desc) * (RX_RING_SIZE+TX_RING_SIZE),
1989                 np->rx_ring, np->ring_dma);
1990 }
1991
1992 static void reinit_rx(struct net_device *dev)
1993 {
1994         struct netdev_private *np = netdev_priv(dev);
1995         int i;
1996
1997         /* RX Ring */
1998         np->dirty_rx = 0;
1999         np->cur_rx = RX_RING_SIZE;
2000         np->rx_head_desc = &np->rx_ring[0];
2001         /* Initialize all Rx descriptors. */
2002         for (i = 0; i < RX_RING_SIZE; i++)
2003                 np->rx_ring[i].cmd_status = cpu_to_le32(DescOwn);
2004
2005         refill_rx(dev);
2006 }
2007
2008 static void reinit_ring(struct net_device *dev)
2009 {
2010         struct netdev_private *np = netdev_priv(dev);
2011         int i;
2012
2013         /* drain TX ring */
2014         drain_tx(dev);
2015         np->dirty_tx = np->cur_tx = 0;
2016         for (i=0;i<TX_RING_SIZE;i++)
2017                 np->tx_ring[i].cmd_status = 0;
2018
2019         reinit_rx(dev);
2020 }
2021
2022 static int start_tx(struct sk_buff *skb, struct net_device *dev)
2023 {
2024         struct netdev_private *np = netdev_priv(dev);
2025         void __iomem * ioaddr = ns_ioaddr(dev);
2026         unsigned entry;
2027
2028         /* Note: Ordering is important here, set the field with the
2029            "ownership" bit last, and only then increment cur_tx. */
2030
2031         /* Calculate the next Tx descriptor entry. */
2032         entry = np->cur_tx % TX_RING_SIZE;
2033
2034         np->tx_skbuff[entry] = skb;
2035         np->tx_dma[entry] = pci_map_single(np->pci_dev,
2036                                 skb->data,skb->len, PCI_DMA_TODEVICE);
2037
2038         np->tx_ring[entry].addr = cpu_to_le32(np->tx_dma[entry]);
2039
2040         spin_lock_irq(&np->lock);
2041
2042         if (!np->hands_off) {
2043                 np->tx_ring[entry].cmd_status = cpu_to_le32(DescOwn | skb->len);
2044                 /* StrongARM: Explicitly cache flush np->tx_ring and
2045                  * skb->data,skb->len. */
2046                 wmb();
2047                 np->cur_tx++;
2048                 if (np->cur_tx - np->dirty_tx >= TX_QUEUE_LEN - 1) {
2049                         netdev_tx_done(dev);
2050                         if (np->cur_tx - np->dirty_tx >= TX_QUEUE_LEN - 1)
2051                                 netif_stop_queue(dev);
2052                 }
2053                 /* Wake the potentially-idle transmit channel. */
2054                 writel(TxOn, ioaddr + ChipCmd);
2055         } else {
2056                 dev_kfree_skb_irq(skb);
2057                 np->stats.tx_dropped++;
2058         }
2059         spin_unlock_irq(&np->lock);
2060
2061         dev->trans_start = jiffies;
2062
2063         if (netif_msg_tx_queued(np)) {
2064                 printk(KERN_DEBUG "%s: Transmit frame #%d queued in slot %d.\n",
2065                         dev->name, np->cur_tx, entry);
2066         }
2067         return 0;
2068 }
2069
2070 static void netdev_tx_done(struct net_device *dev)
2071 {
2072         struct netdev_private *np = netdev_priv(dev);
2073
2074         for (; np->cur_tx - np->dirty_tx > 0; np->dirty_tx++) {
2075                 int entry = np->dirty_tx % TX_RING_SIZE;
2076                 if (np->tx_ring[entry].cmd_status & cpu_to_le32(DescOwn))
2077                         break;
2078                 if (netif_msg_tx_done(np))
2079                         printk(KERN_DEBUG
2080                                 "%s: tx frame #%d finished, status %#08x.\n",
2081                                         dev->name, np->dirty_tx,
2082                                         le32_to_cpu(np->tx_ring[entry].cmd_status));
2083                 if (np->tx_ring[entry].cmd_status & cpu_to_le32(DescPktOK)) {
2084                         np->stats.tx_packets++;
2085                         np->stats.tx_bytes += np->tx_skbuff[entry]->len;
2086                 } else { /* Various Tx errors */
2087                         int tx_status =
2088                                 le32_to_cpu(np->tx_ring[entry].cmd_status);
2089                         if (tx_status & (DescTxAbort|DescTxExcColl))
2090                                 np->stats.tx_aborted_errors++;
2091                         if (tx_status & DescTxFIFO)
2092                                 np->stats.tx_fifo_errors++;
2093                         if (tx_status & DescTxCarrier)
2094                                 np->stats.tx_carrier_errors++;
2095                         if (tx_status & DescTxOOWCol)
2096                                 np->stats.tx_window_errors++;
2097                         np->stats.tx_errors++;
2098                 }
2099                 pci_unmap_single(np->pci_dev,np->tx_dma[entry],
2100                                         np->tx_skbuff[entry]->len,
2101                                         PCI_DMA_TODEVICE);
2102                 /* Free the original skb. */
2103                 dev_kfree_skb_irq(np->tx_skbuff[entry]);
2104                 np->tx_skbuff[entry] = NULL;
2105         }
2106         if (netif_queue_stopped(dev)
2107                 && np->cur_tx - np->dirty_tx < TX_QUEUE_LEN - 4) {
2108                 /* The ring is no longer full, wake queue. */
2109                 netif_wake_queue(dev);
2110         }
2111 }
2112
2113 /* The interrupt handler doesn't actually handle interrupts itself, it
2114  * schedules a NAPI poll if there is anything to do. */
2115 static irqreturn_t intr_handler(int irq, void *dev_instance)
2116 {
2117         struct net_device *dev = dev_instance;
2118         struct netdev_private *np = netdev_priv(dev);
2119         void __iomem * ioaddr = ns_ioaddr(dev);
2120
2121         if (np->hands_off)
2122                 return IRQ_NONE;
2123
2124         /* Reading automatically acknowledges. */
2125         np->intr_status = readl(ioaddr + IntrStatus);
2126
2127         if (netif_msg_intr(np))
2128                 printk(KERN_DEBUG
2129                        "%s: Interrupt, status %#08x, mask %#08x.\n",
2130                        dev->name, np->intr_status,
2131                        readl(ioaddr + IntrMask));
2132
2133         if (!np->intr_status)
2134                 return IRQ_NONE;
2135
2136         prefetch(&np->rx_skbuff[np->cur_rx % RX_RING_SIZE]);
2137
2138         if (netif_rx_schedule_prep(dev)) {
2139                 /* Disable interrupts and register for poll */
2140                 natsemi_irq_disable(dev);
2141                 __netif_rx_schedule(dev);
2142         }
2143         return IRQ_HANDLED;
2144 }
2145
2146 /* This is the NAPI poll routine.  As well as the standard RX handling
2147  * it also handles all other interrupts that the chip might raise.
2148  */
2149 static int natsemi_poll(struct net_device *dev, int *budget)
2150 {
2151         struct netdev_private *np = netdev_priv(dev);
2152         void __iomem * ioaddr = ns_ioaddr(dev);
2153
2154         int work_to_do = min(*budget, dev->quota);
2155         int work_done = 0;
2156
2157         do {
2158                 if (np->intr_status &
2159                     (IntrTxDone | IntrTxIntr | IntrTxIdle | IntrTxErr)) {
2160                         spin_lock(&np->lock);
2161                         netdev_tx_done(dev);
2162                         spin_unlock(&np->lock);
2163                 }
2164
2165                 /* Abnormal error summary/uncommon events handlers. */
2166                 if (np->intr_status & IntrAbnormalSummary)
2167                         netdev_error(dev, np->intr_status);
2168
2169                 if (np->intr_status &
2170                     (IntrRxDone | IntrRxIntr | RxStatusFIFOOver |
2171                      IntrRxErr | IntrRxOverrun)) {
2172                         netdev_rx(dev, &work_done, work_to_do);
2173                 }
2174
2175                 *budget -= work_done;
2176                 dev->quota -= work_done;
2177
2178                 if (work_done >= work_to_do)
2179                         return 1;
2180
2181                 np->intr_status = readl(ioaddr + IntrStatus);
2182         } while (np->intr_status);
2183
2184         netif_rx_complete(dev);
2185
2186         /* Reenable interrupts providing nothing is trying to shut
2187          * the chip down. */
2188         spin_lock(&np->lock);
2189         if (!np->hands_off && netif_running(dev))
2190                 natsemi_irq_enable(dev);
2191         spin_unlock(&np->lock);
2192
2193         return 0;
2194 }
2195
2196 /* This routine is logically part of the interrupt handler, but separated
2197    for clarity and better register allocation. */
2198 static void netdev_rx(struct net_device *dev, int *work_done, int work_to_do)
2199 {
2200         struct netdev_private *np = netdev_priv(dev);
2201         int entry = np->cur_rx % RX_RING_SIZE;
2202         int boguscnt = np->dirty_rx + RX_RING_SIZE - np->cur_rx;
2203         s32 desc_status = le32_to_cpu(np->rx_head_desc->cmd_status);
2204         unsigned int buflen = np->rx_buf_sz;
2205         void __iomem * ioaddr = ns_ioaddr(dev);
2206
2207         /* If the driver owns the next entry it's a new packet. Send it up. */
2208         while (desc_status < 0) { /* e.g. & DescOwn */
2209                 int pkt_len;
2210                 if (netif_msg_rx_status(np))
2211                         printk(KERN_DEBUG
2212                                 "  netdev_rx() entry %d status was %#08x.\n",
2213                                 entry, desc_status);
2214                 if (--boguscnt < 0)
2215                         break;
2216
2217                 if (*work_done >= work_to_do)
2218                         break;
2219
2220                 (*work_done)++;
2221
2222                 pkt_len = (desc_status & DescSizeMask) - 4;
2223                 if ((desc_status&(DescMore|DescPktOK|DescRxLong)) != DescPktOK){
2224                         if (desc_status & DescMore) {
2225                                 if (netif_msg_rx_err(np))
2226                                         printk(KERN_WARNING
2227                                                 "%s: Oversized(?) Ethernet "
2228                                                 "frame spanned multiple "
2229                                                 "buffers, entry %#08x "
2230                                                 "status %#08x.\n", dev->name,
2231                                                 np->cur_rx, desc_status);
2232                                 np->stats.rx_length_errors++;
2233
2234                                 /* The RX state machine has probably
2235                                  * locked up beneath us.  Follow the
2236                                  * reset procedure documented in
2237                                  * AN-1287. */
2238
2239                                 spin_lock_irq(&np->lock);
2240                                 reset_rx(dev);
2241                                 reinit_rx(dev);
2242                                 writel(np->ring_dma, ioaddr + RxRingPtr);
2243                                 check_link(dev);
2244                                 spin_unlock_irq(&np->lock);
2245
2246                                 /* We'll enable RX on exit from this
2247                                  * function. */
2248                                 break;
2249
2250                         } else {
2251                                 /* There was an error. */
2252                                 np->stats.rx_errors++;
2253                                 if (desc_status & (DescRxAbort|DescRxOver))
2254                                         np->stats.rx_over_errors++;
2255                                 if (desc_status & (DescRxLong|DescRxRunt))
2256                                         np->stats.rx_length_errors++;
2257                                 if (desc_status & (DescRxInvalid|DescRxAlign))
2258                                         np->stats.rx_frame_errors++;
2259                                 if (desc_status & DescRxCRC)
2260                                         np->stats.rx_crc_errors++;
2261                         }
2262                 } else if (pkt_len > np->rx_buf_sz) {
2263                         /* if this is the tail of a double buffer
2264                          * packet, we've already counted the error
2265                          * on the first part.  Ignore the second half.
2266                          */
2267                 } else {
2268                         struct sk_buff *skb;
2269                         /* Omit CRC size. */
2270                         /* Check if the packet is long enough to accept
2271                          * without copying to a minimally-sized skbuff. */
2272                         if (pkt_len < rx_copybreak
2273                             && (skb = dev_alloc_skb(pkt_len + RX_OFFSET)) != NULL) {
2274                                 skb->dev = dev;
2275                                 /* 16 byte align the IP header */
2276                                 skb_reserve(skb, RX_OFFSET);
2277                                 pci_dma_sync_single_for_cpu(np->pci_dev,
2278                                         np->rx_dma[entry],
2279                                         buflen,
2280                                         PCI_DMA_FROMDEVICE);
2281                                 eth_copy_and_sum(skb,
2282                                         np->rx_skbuff[entry]->data, pkt_len, 0);
2283                                 skb_put(skb, pkt_len);
2284                                 pci_dma_sync_single_for_device(np->pci_dev,
2285                                         np->rx_dma[entry],
2286                                         buflen,
2287                                         PCI_DMA_FROMDEVICE);
2288                         } else {
2289                                 pci_unmap_single(np->pci_dev, np->rx_dma[entry],
2290                                         buflen, PCI_DMA_FROMDEVICE);
2291                                 skb_put(skb = np->rx_skbuff[entry], pkt_len);
2292                                 np->rx_skbuff[entry] = NULL;
2293                         }
2294                         skb->protocol = eth_type_trans(skb, dev);
2295                         netif_receive_skb(skb);
2296                         dev->last_rx = jiffies;
2297                         np->stats.rx_packets++;
2298                         np->stats.rx_bytes += pkt_len;
2299                 }
2300                 entry = (++np->cur_rx) % RX_RING_SIZE;
2301                 np->rx_head_desc = &np->rx_ring[entry];
2302                 desc_status = le32_to_cpu(np->rx_head_desc->cmd_status);
2303         }
2304         refill_rx(dev);
2305
2306         /* Restart Rx engine if stopped. */
2307         if (np->oom)
2308                 mod_timer(&np->timer, jiffies + 1);
2309         else
2310                 writel(RxOn, ioaddr + ChipCmd);
2311 }
2312
2313 static void netdev_error(struct net_device *dev, int intr_status)
2314 {
2315         struct netdev_private *np = netdev_priv(dev);
2316         void __iomem * ioaddr = ns_ioaddr(dev);
2317
2318         spin_lock(&np->lock);
2319         if (intr_status & LinkChange) {
2320                 u16 lpa = mdio_read(dev, MII_LPA);
2321                 if (mdio_read(dev, MII_BMCR) & BMCR_ANENABLE
2322                  && netif_msg_link(np)) {
2323                         printk(KERN_INFO
2324                                 "%s: Autonegotiation advertising"
2325                                 " %#04x  partner %#04x.\n", dev->name,
2326                                 np->advertising, lpa);
2327                 }
2328
2329                 /* read MII int status to clear the flag */
2330                 readw(ioaddr + MIntrStatus);
2331                 check_link(dev);
2332         }
2333         if (intr_status & StatsMax) {
2334                 __get_stats(dev);
2335         }
2336         if (intr_status & IntrTxUnderrun) {
2337                 if ((np->tx_config & TxDrthMask) < TX_DRTH_VAL_LIMIT) {
2338                         np->tx_config += TX_DRTH_VAL_INC;
2339                         if (netif_msg_tx_err(np))
2340                                 printk(KERN_NOTICE
2341                                         "%s: increased tx threshold, txcfg %#08x.\n",
2342                                         dev->name, np->tx_config);
2343                 } else {
2344                         if (netif_msg_tx_err(np))
2345                                 printk(KERN_NOTICE
2346                                         "%s: tx underrun with maximum tx threshold, txcfg %#08x.\n",
2347                                         dev->name, np->tx_config);
2348                 }
2349                 writel(np->tx_config, ioaddr + TxConfig);
2350         }
2351         if (intr_status & WOLPkt && netif_msg_wol(np)) {
2352                 int wol_status = readl(ioaddr + WOLCmd);
2353                 printk(KERN_NOTICE "%s: Link wake-up event %#08x\n",
2354                         dev->name, wol_status);
2355         }
2356         if (intr_status & RxStatusFIFOOver) {
2357                 if (netif_msg_rx_err(np) && netif_msg_intr(np)) {
2358                         printk(KERN_NOTICE "%s: Rx status FIFO overrun\n",
2359                                 dev->name);
2360                 }
2361                 np->stats.rx_fifo_errors++;
2362         }
2363         /* Hmmmmm, it's not clear how to recover from PCI faults. */
2364         if (intr_status & IntrPCIErr) {
2365                 printk(KERN_NOTICE "%s: PCI error %#08x\n", dev->name,
2366                         intr_status & IntrPCIErr);
2367                 np->stats.tx_fifo_errors++;
2368                 np->stats.rx_fifo_errors++;
2369         }
2370         spin_unlock(&np->lock);
2371 }
2372
2373 static void __get_stats(struct net_device *dev)
2374 {
2375         void __iomem * ioaddr = ns_ioaddr(dev);
2376         struct netdev_private *np = netdev_priv(dev);
2377
2378         /* The chip only need report frame silently dropped. */
2379         np->stats.rx_crc_errors += readl(ioaddr + RxCRCErrs);
2380         np->stats.rx_missed_errors += readl(ioaddr + RxMissed);
2381 }
2382
2383 static struct net_device_stats *get_stats(struct net_device *dev)
2384 {
2385         struct netdev_private *np = netdev_priv(dev);
2386
2387         /* The chip only need report frame silently dropped. */
2388         spin_lock_irq(&np->lock);
2389         if (netif_running(dev) && !np->hands_off)
2390                 __get_stats(dev);
2391         spin_unlock_irq(&np->lock);
2392
2393         return &np->stats;
2394 }
2395
2396 #ifdef CONFIG_NET_POLL_CONTROLLER
2397 static void natsemi_poll_controller(struct net_device *dev)
2398 {
2399         disable_irq(dev->irq);
2400         intr_handler(dev->irq, dev);
2401         enable_irq(dev->irq);
2402 }
2403 #endif
2404
2405 #define HASH_TABLE      0x200
2406 static void __set_rx_mode(struct net_device *dev)
2407 {
2408         void __iomem * ioaddr = ns_ioaddr(dev);
2409         struct netdev_private *np = netdev_priv(dev);
2410         u8 mc_filter[64]; /* Multicast hash filter */
2411         u32 rx_mode;
2412
2413         if (dev->flags & IFF_PROMISC) { /* Set promiscuous. */
2414                 rx_mode = RxFilterEnable | AcceptBroadcast
2415                         | AcceptAllMulticast | AcceptAllPhys | AcceptMyPhys;
2416         } else if ((dev->mc_count > multicast_filter_limit)
2417           || (dev->flags & IFF_ALLMULTI)) {
2418                 rx_mode = RxFilterEnable | AcceptBroadcast
2419                         | AcceptAllMulticast | AcceptMyPhys;
2420         } else {
2421                 struct dev_mc_list *mclist;
2422                 int i;
2423                 memset(mc_filter, 0, sizeof(mc_filter));
2424                 for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count;
2425                          i++, mclist = mclist->next) {
2426                         int i = (ether_crc(ETH_ALEN, mclist->dmi_addr) >> 23) & 0x1ff;
2427                         mc_filter[i/8] |= (1 << (i & 0x07));
2428                 }
2429                 rx_mode = RxFilterEnable | AcceptBroadcast
2430                         | AcceptMulticast | AcceptMyPhys;
2431                 for (i = 0; i < 64; i += 2) {
2432                         writel(HASH_TABLE + i, ioaddr + RxFilterAddr);
2433                         writel((mc_filter[i + 1] << 8) + mc_filter[i],
2434                                ioaddr + RxFilterData);
2435                 }
2436         }
2437         writel(rx_mode, ioaddr + RxFilterAddr);
2438         np->cur_rx_mode = rx_mode;
2439 }
2440
2441 static int natsemi_change_mtu(struct net_device *dev, int new_mtu)
2442 {
2443         if (new_mtu < 64 || new_mtu > NATSEMI_RX_LIMIT-NATSEMI_HEADERS)
2444                 return -EINVAL;
2445
2446         dev->mtu = new_mtu;
2447
2448         /* synchronized against open : rtnl_lock() held by caller */
2449         if (netif_running(dev)) {
2450                 struct netdev_private *np = netdev_priv(dev);
2451                 void __iomem * ioaddr = ns_ioaddr(dev);
2452
2453                 disable_irq(dev->irq);
2454                 spin_lock(&np->lock);
2455                 /* stop engines */
2456                 natsemi_stop_rxtx(dev);
2457                 /* drain rx queue */
2458                 drain_rx(dev);
2459                 /* change buffers */
2460                 set_bufsize(dev);
2461                 reinit_rx(dev);
2462                 writel(np->ring_dma, ioaddr + RxRingPtr);
2463                 /* restart engines */
2464                 writel(RxOn | TxOn, ioaddr + ChipCmd);
2465                 spin_unlock(&np->lock);
2466                 enable_irq(dev->irq);
2467         }
2468         return 0;
2469 }
2470
2471 static void set_rx_mode(struct net_device *dev)
2472 {
2473         struct netdev_private *np = netdev_priv(dev);
2474         spin_lock_irq(&np->lock);
2475         if (!np->hands_off)
2476                 __set_rx_mode(dev);
2477         spin_unlock_irq(&np->lock);
2478 }
2479
2480 static void get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
2481 {
2482         struct netdev_private *np = netdev_priv(dev);
2483         strncpy(info->driver, DRV_NAME, ETHTOOL_BUSINFO_LEN);
2484         strncpy(info->version, DRV_VERSION, ETHTOOL_BUSINFO_LEN);
2485         strncpy(info->bus_info, pci_name(np->pci_dev), ETHTOOL_BUSINFO_LEN);
2486 }
2487
2488 static int get_regs_len(struct net_device *dev)
2489 {
2490         return NATSEMI_REGS_SIZE;
2491 }
2492
2493 static int get_eeprom_len(struct net_device *dev)
2494 {
2495         struct netdev_private *np = netdev_priv(dev);
2496         return np->eeprom_size;
2497 }
2498
2499 static int get_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
2500 {
2501         struct netdev_private *np = netdev_priv(dev);
2502         spin_lock_irq(&np->lock);
2503         netdev_get_ecmd(dev, ecmd);
2504         spin_unlock_irq(&np->lock);
2505         return 0;
2506 }
2507
2508 static int set_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
2509 {
2510         struct netdev_private *np = netdev_priv(dev);
2511         int res;
2512         spin_lock_irq(&np->lock);
2513         res = netdev_set_ecmd(dev, ecmd);
2514         spin_unlock_irq(&np->lock);
2515         return res;
2516 }
2517
2518 static void get_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
2519 {
2520         struct netdev_private *np = netdev_priv(dev);
2521         spin_lock_irq(&np->lock);
2522         netdev_get_wol(dev, &wol->supported, &wol->wolopts);
2523         netdev_get_sopass(dev, wol->sopass);
2524         spin_unlock_irq(&np->lock);
2525 }
2526
2527 static int set_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
2528 {
2529         struct netdev_private *np = netdev_priv(dev);
2530         int res;
2531         spin_lock_irq(&np->lock);
2532         netdev_set_wol(dev, wol->wolopts);
2533         res = netdev_set_sopass(dev, wol->sopass);
2534         spin_unlock_irq(&np->lock);
2535         return res;
2536 }
2537
2538 static void get_regs(struct net_device *dev, struct ethtool_regs *regs, void *buf)
2539 {
2540         struct netdev_private *np = netdev_priv(dev);
2541         regs->version = NATSEMI_REGS_VER;
2542         spin_lock_irq(&np->lock);
2543         netdev_get_regs(dev, buf);
2544         spin_unlock_irq(&np->lock);
2545 }
2546
2547 static u32 get_msglevel(struct net_device *dev)
2548 {
2549         struct netdev_private *np = netdev_priv(dev);
2550         return np->msg_enable;
2551 }
2552
2553 static void set_msglevel(struct net_device *dev, u32 val)
2554 {
2555         struct netdev_private *np = netdev_priv(dev);
2556         np->msg_enable = val;
2557 }
2558
2559 static int nway_reset(struct net_device *dev)
2560 {
2561         int tmp;
2562         int r = -EINVAL;
2563         /* if autoneg is off, it's an error */
2564         tmp = mdio_read(dev, MII_BMCR);
2565         if (tmp & BMCR_ANENABLE) {
2566                 tmp |= (BMCR_ANRESTART);
2567                 mdio_write(dev, MII_BMCR, tmp);
2568                 r = 0;
2569         }
2570         return r;
2571 }
2572
2573 static u32 get_link(struct net_device *dev)
2574 {
2575         /* LSTATUS is latched low until a read - so read twice */
2576         mdio_read(dev, MII_BMSR);
2577         return (mdio_read(dev, MII_BMSR)&BMSR_LSTATUS) ? 1:0;
2578 }
2579
2580 static int get_eeprom(struct net_device *dev, struct ethtool_eeprom *eeprom, u8 *data)
2581 {
2582         struct netdev_private *np = netdev_priv(dev);
2583         u8 *eebuf;
2584         int res;
2585
2586         eebuf = kmalloc(np->eeprom_size, GFP_KERNEL);
2587         if (!eebuf)
2588                 return -ENOMEM;
2589
2590         eeprom->magic = PCI_VENDOR_ID_NS | (PCI_DEVICE_ID_NS_83815<<16);
2591         spin_lock_irq(&np->lock);
2592         res = netdev_get_eeprom(dev, eebuf);
2593         spin_unlock_irq(&np->lock);
2594         if (!res)
2595                 memcpy(data, eebuf+eeprom->offset, eeprom->len);
2596         kfree(eebuf);
2597         return res;
2598 }
2599
2600 static const struct ethtool_ops ethtool_ops = {
2601         .get_drvinfo = get_drvinfo,
2602         .get_regs_len = get_regs_len,
2603         .get_eeprom_len = get_eeprom_len,
2604         .get_settings = get_settings,
2605         .set_settings = set_settings,
2606         .get_wol = get_wol,
2607         .set_wol = set_wol,
2608         .get_regs = get_regs,
2609         .get_msglevel = get_msglevel,
2610         .set_msglevel = set_msglevel,
2611         .nway_reset = nway_reset,
2612         .get_link = get_link,
2613         .get_eeprom = get_eeprom,
2614 };
2615
2616 static int netdev_set_wol(struct net_device *dev, u32 newval)
2617 {
2618         struct netdev_private *np = netdev_priv(dev);
2619         void __iomem * ioaddr = ns_ioaddr(dev);
2620         u32 data = readl(ioaddr + WOLCmd) & ~WakeOptsSummary;
2621
2622         /* translate to bitmasks this chip understands */
2623         if (newval & WAKE_PHY)
2624                 data |= WakePhy;
2625         if (newval & WAKE_UCAST)
2626                 data |= WakeUnicast;
2627         if (newval & WAKE_MCAST)
2628                 data |= WakeMulticast;
2629         if (newval & WAKE_BCAST)
2630                 data |= WakeBroadcast;
2631         if (newval & WAKE_ARP)
2632                 data |= WakeArp;
2633         if (newval & WAKE_MAGIC)
2634                 data |= WakeMagic;
2635         if (np->srr >= SRR_DP83815_D) {
2636                 if (newval & WAKE_MAGICSECURE) {
2637                         data |= WakeMagicSecure;
2638                 }
2639         }
2640
2641         writel(data, ioaddr + WOLCmd);
2642
2643         return 0;
2644 }
2645
2646 static int netdev_get_wol(struct net_device *dev, u32 *supported, u32 *cur)
2647 {
2648         struct netdev_private *np = netdev_priv(dev);
2649         void __iomem * ioaddr = ns_ioaddr(dev);
2650         u32 regval = readl(ioaddr + WOLCmd);
2651
2652         *supported = (WAKE_PHY | WAKE_UCAST | WAKE_MCAST | WAKE_BCAST
2653                         | WAKE_ARP | WAKE_MAGIC);
2654
2655         if (np->srr >= SRR_DP83815_D) {
2656                 /* SOPASS works on revD and higher */
2657                 *supported |= WAKE_MAGICSECURE;
2658         }
2659         *cur = 0;
2660
2661         /* translate from chip bitmasks */
2662         if (regval & WakePhy)
2663                 *cur |= WAKE_PHY;
2664         if (regval & WakeUnicast)
2665                 *cur |= WAKE_UCAST;
2666         if (regval & WakeMulticast)
2667                 *cur |= WAKE_MCAST;
2668         if (regval & WakeBroadcast)
2669                 *cur |= WAKE_BCAST;
2670         if (regval & WakeArp)
2671                 *cur |= WAKE_ARP;
2672         if (regval & WakeMagic)
2673                 *cur |= WAKE_MAGIC;
2674         if (regval & WakeMagicSecure) {
2675                 /* this can be on in revC, but it's broken */
2676                 *cur |= WAKE_MAGICSECURE;
2677         }
2678
2679         return 0;
2680 }
2681
2682 static int netdev_set_sopass(struct net_device *dev, u8 *newval)
2683 {
2684         struct netdev_private *np = netdev_priv(dev);
2685         void __iomem * ioaddr = ns_ioaddr(dev);
2686         u16 *sval = (u16 *)newval;
2687         u32 addr;
2688
2689         if (np->srr < SRR_DP83815_D) {
2690                 return 0;
2691         }
2692
2693         /* enable writing to these registers by disabling the RX filter */
2694         addr = readl(ioaddr + RxFilterAddr) & ~RFCRAddressMask;
2695         addr &= ~RxFilterEnable;
2696         writel(addr, ioaddr + RxFilterAddr);
2697
2698         /* write the three words to (undocumented) RFCR vals 0xa, 0xc, 0xe */
2699         writel(addr | 0xa, ioaddr + RxFilterAddr);
2700         writew(sval[0], ioaddr + RxFilterData);
2701
2702         writel(addr | 0xc, ioaddr + RxFilterAddr);
2703         writew(sval[1], ioaddr + RxFilterData);
2704
2705         writel(addr | 0xe, ioaddr + RxFilterAddr);
2706         writew(sval[2], ioaddr + RxFilterData);
2707
2708         /* re-enable the RX filter */
2709         writel(addr | RxFilterEnable, ioaddr + RxFilterAddr);
2710
2711         return 0;
2712 }
2713
2714 static int netdev_get_sopass(struct net_device *dev, u8 *data)
2715 {
2716         struct netdev_private *np = netdev_priv(dev);
2717         void __iomem * ioaddr = ns_ioaddr(dev);
2718         u16 *sval = (u16 *)data;
2719         u32 addr;
2720
2721         if (np->srr < SRR_DP83815_D) {
2722                 sval[0] = sval[1] = sval[2] = 0;
2723                 return 0;
2724         }
2725
2726         /* read the three words from (undocumented) RFCR vals 0xa, 0xc, 0xe */
2727         addr = readl(ioaddr + RxFilterAddr) & ~RFCRAddressMask;
2728
2729         writel(addr | 0xa, ioaddr + RxFilterAddr);
2730         sval[0] = readw(ioaddr + RxFilterData);
2731
2732         writel(addr | 0xc, ioaddr + RxFilterAddr);
2733         sval[1] = readw(ioaddr + RxFilterData);
2734
2735         writel(addr | 0xe, ioaddr + RxFilterAddr);
2736         sval[2] = readw(ioaddr + RxFilterData);
2737
2738         writel(addr, ioaddr + RxFilterAddr);
2739
2740         return 0;
2741 }
2742
2743 static int netdev_get_ecmd(struct net_device *dev, struct ethtool_cmd *ecmd)
2744 {
2745         struct netdev_private *np = netdev_priv(dev);
2746         u32 tmp;
2747
2748         ecmd->port        = dev->if_port;
2749         ecmd->speed       = np->speed;
2750         ecmd->duplex      = np->duplex;
2751         ecmd->autoneg     = np->autoneg;
2752         ecmd->advertising = 0;
2753         if (np->advertising & ADVERTISE_10HALF)
2754                 ecmd->advertising |= ADVERTISED_10baseT_Half;
2755         if (np->advertising & ADVERTISE_10FULL)
2756                 ecmd->advertising |= ADVERTISED_10baseT_Full;
2757         if (np->advertising & ADVERTISE_100HALF)
2758                 ecmd->advertising |= ADVERTISED_100baseT_Half;
2759         if (np->advertising & ADVERTISE_100FULL)
2760                 ecmd->advertising |= ADVERTISED_100baseT_Full;
2761         ecmd->supported   = (SUPPORTED_Autoneg |
2762                 SUPPORTED_10baseT_Half  | SUPPORTED_10baseT_Full  |
2763                 SUPPORTED_100baseT_Half | SUPPORTED_100baseT_Full |
2764                 SUPPORTED_TP | SUPPORTED_MII | SUPPORTED_FIBRE);
2765         ecmd->phy_address = np->phy_addr_external;
2766         /*
2767          * We intentionally report the phy address of the external
2768          * phy, even if the internal phy is used. This is necessary
2769          * to work around a deficiency of the ethtool interface:
2770          * It's only possible to query the settings of the active
2771          * port. Therefore
2772          * # ethtool -s ethX port mii
2773          * actually sends an ioctl to switch to port mii with the
2774          * settings that are used for the current active port.
2775          * If we would report a different phy address in this
2776          * command, then
2777          * # ethtool -s ethX port tp;ethtool -s ethX port mii
2778          * would unintentionally change the phy address.
2779          *
2780          * Fortunately the phy address doesn't matter with the
2781          * internal phy...
2782          */
2783
2784         /* set information based on active port type */
2785         switch (ecmd->port) {
2786         default:
2787         case PORT_TP:
2788                 ecmd->advertising |= ADVERTISED_TP;
2789                 ecmd->transceiver = XCVR_INTERNAL;
2790                 break;
2791         case PORT_MII:
2792                 ecmd->advertising |= ADVERTISED_MII;
2793                 ecmd->transceiver = XCVR_EXTERNAL;
2794                 break;
2795         case PORT_FIBRE:
2796                 ecmd->advertising |= ADVERTISED_FIBRE;
2797                 ecmd->transceiver = XCVR_EXTERNAL;
2798                 break;
2799         }
2800
2801         /* if autonegotiation is on, try to return the active speed/duplex */
2802         if (ecmd->autoneg == AUTONEG_ENABLE) {
2803                 ecmd->advertising |= ADVERTISED_Autoneg;
2804                 tmp = mii_nway_result(
2805                         np->advertising & mdio_read(dev, MII_LPA));
2806                 if (tmp == LPA_100FULL || tmp == LPA_100HALF)
2807                         ecmd->speed  = SPEED_100;
2808                 else
2809                         ecmd->speed  = SPEED_10;
2810                 if (tmp == LPA_100FULL || tmp == LPA_10FULL)
2811                         ecmd->duplex = DUPLEX_FULL;
2812                 else
2813                         ecmd->duplex = DUPLEX_HALF;
2814         }
2815
2816         /* ignore maxtxpkt, maxrxpkt for now */
2817
2818         return 0;
2819 }
2820
2821 static int netdev_set_ecmd(struct net_device *dev, struct ethtool_cmd *ecmd)
2822 {
2823         struct netdev_private *np = netdev_priv(dev);
2824
2825         if (ecmd->port != PORT_TP && ecmd->port != PORT_MII && ecmd->port != PORT_FIBRE)
2826                 return -EINVAL;
2827         if (ecmd->transceiver != XCVR_INTERNAL && ecmd->transceiver != XCVR_EXTERNAL)
2828                 return -EINVAL;
2829         if (ecmd->autoneg == AUTONEG_ENABLE) {
2830                 if ((ecmd->advertising & (ADVERTISED_10baseT_Half |
2831                                           ADVERTISED_10baseT_Full |
2832                                           ADVERTISED_100baseT_Half |
2833                                           ADVERTISED_100baseT_Full)) == 0) {
2834                         return -EINVAL;
2835                 }
2836         } else if (ecmd->autoneg == AUTONEG_DISABLE) {
2837                 if (ecmd->speed != SPEED_10 && ecmd->speed != SPEED_100)
2838                         return -EINVAL;
2839                 if (ecmd->duplex != DUPLEX_HALF && ecmd->duplex != DUPLEX_FULL)
2840                         return -EINVAL;
2841         } else {
2842                 return -EINVAL;
2843         }
2844
2845         /*
2846          * If we're ignoring the PHY then autoneg and the internal
2847          * transciever are really not going to work so don't let the
2848          * user select them.
2849          */
2850         if (np->ignore_phy && (ecmd->autoneg == AUTONEG_ENABLE ||
2851                                ecmd->port == PORT_TP))
2852                 return -EINVAL;
2853
2854         /*
2855          * maxtxpkt, maxrxpkt: ignored for now.
2856          *
2857          * transceiver:
2858          * PORT_TP is always XCVR_INTERNAL, PORT_MII and PORT_FIBRE are always
2859          * XCVR_EXTERNAL. The implementation thus ignores ecmd->transceiver and
2860          * selects based on ecmd->port.
2861          *
2862          * Actually PORT_FIBRE is nearly identical to PORT_MII: it's for fibre
2863          * phys that are connected to the mii bus. It's used to apply fibre
2864          * specific updates.
2865          */
2866
2867         /* WHEW! now lets bang some bits */
2868
2869         /* save the parms */
2870         dev->if_port          = ecmd->port;
2871         np->autoneg           = ecmd->autoneg;
2872         np->phy_addr_external = ecmd->phy_address & PhyAddrMask;
2873         if (np->autoneg == AUTONEG_ENABLE) {
2874                 /* advertise only what has been requested */
2875                 np->advertising &= ~(ADVERTISE_ALL | ADVERTISE_100BASE4);
2876                 if (ecmd->advertising & ADVERTISED_10baseT_Half)
2877                         np->advertising |= ADVERTISE_10HALF;
2878                 if (ecmd->advertising & ADVERTISED_10baseT_Full)
2879                         np->advertising |= ADVERTISE_10FULL;
2880                 if (ecmd->advertising & ADVERTISED_100baseT_Half)
2881                         np->advertising |= ADVERTISE_100HALF;
2882                 if (ecmd->advertising & ADVERTISED_100baseT_Full)
2883                         np->advertising |= ADVERTISE_100FULL;
2884         } else {
2885                 np->speed  = ecmd->speed;
2886                 np->duplex = ecmd->duplex;
2887                 /* user overriding the initial full duplex parm? */
2888                 if (np->duplex == DUPLEX_HALF)
2889                         np->full_duplex = 0;
2890         }
2891
2892         /* get the right phy enabled */
2893         if (ecmd->port == PORT_TP)
2894                 switch_port_internal(dev);
2895         else
2896                 switch_port_external(dev);
2897
2898         /* set parms and see how this affected our link status */
2899         init_phy_fixup(dev);
2900         check_link(dev);
2901         return 0;
2902 }
2903
2904 static int netdev_get_regs(struct net_device *dev, u8 *buf)
2905 {
2906         int i;
2907         int j;
2908         u32 rfcr;
2909         u32 *rbuf = (u32 *)buf;
2910         void __iomem * ioaddr = ns_ioaddr(dev);
2911
2912         /* read non-mii page 0 of registers */
2913         for (i = 0; i < NATSEMI_PG0_NREGS/2; i++) {
2914                 rbuf[i] = readl(ioaddr + i*4);
2915         }
2916
2917         /* read current mii registers */
2918         for (i = NATSEMI_PG0_NREGS/2; i < NATSEMI_PG0_NREGS; i++)
2919                 rbuf[i] = mdio_read(dev, i & 0x1f);
2920
2921         /* read only the 'magic' registers from page 1 */
2922         writew(1, ioaddr + PGSEL);
2923         rbuf[i++] = readw(ioaddr + PMDCSR);
2924         rbuf[i++] = readw(ioaddr + TSTDAT);
2925         rbuf[i++] = readw(ioaddr + DSPCFG);
2926         rbuf[i++] = readw(ioaddr + SDCFG);
2927         writew(0, ioaddr + PGSEL);
2928
2929         /* read RFCR indexed registers */
2930         rfcr = readl(ioaddr + RxFilterAddr);
2931         for (j = 0; j < NATSEMI_RFDR_NREGS; j++) {
2932                 writel(j*2, ioaddr + RxFilterAddr);
2933                 rbuf[i++] = readw(ioaddr + RxFilterData);
2934         }
2935         writel(rfcr, ioaddr + RxFilterAddr);
2936
2937         /* the interrupt status is clear-on-read - see if we missed any */
2938         if (rbuf[4] & rbuf[5]) {
2939                 printk(KERN_WARNING
2940                         "%s: shoot, we dropped an interrupt (%#08x)\n",
2941                         dev->name, rbuf[4] & rbuf[5]);
2942         }
2943
2944         return 0;
2945 }
2946
2947 #define SWAP_BITS(x)    ( (((x) & 0x0001) << 15) | (((x) & 0x0002) << 13) \
2948                         | (((x) & 0x0004) << 11) | (((x) & 0x0008) << 9)  \
2949                         | (((x) & 0x0010) << 7)  | (((x) & 0x0020) << 5)  \
2950                         | (((x) & 0x0040) << 3)  | (((x) & 0x0080) << 1)  \
2951                         | (((x) & 0x0100) >> 1)  | (((x) & 0x0200) >> 3)  \
2952                         | (((x) & 0x0400) >> 5)  | (((x) & 0x0800) >> 7)  \
2953                         | (((x) & 0x1000) >> 9)  | (((x) & 0x2000) >> 11) \
2954                         | (((x) & 0x4000) >> 13) | (((x) & 0x8000) >> 15) )
2955
2956 static int netdev_get_eeprom(struct net_device *dev, u8 *buf)
2957 {
2958         int i;
2959         u16 *ebuf = (u16 *)buf;
2960         void __iomem * ioaddr = ns_ioaddr(dev);
2961         struct netdev_private *np = netdev_priv(dev);
2962
2963         /* eeprom_read reads 16 bits, and indexes by 16 bits */
2964         for (i = 0; i < np->eeprom_size/2; i++) {
2965                 ebuf[i] = eeprom_read(ioaddr, i);
2966                 /* The EEPROM itself stores data bit-swapped, but eeprom_read
2967                  * reads it back "sanely". So we swap it back here in order to
2968                  * present it to userland as it is stored. */
2969                 ebuf[i] = SWAP_BITS(ebuf[i]);
2970         }
2971         return 0;
2972 }
2973
2974 static int netdev_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
2975 {
2976         struct mii_ioctl_data *data = if_mii(rq);
2977         struct netdev_private *np = netdev_priv(dev);
2978
2979         switch(cmd) {
2980         case SIOCGMIIPHY:               /* Get address of MII PHY in use. */
2981         case SIOCDEVPRIVATE:            /* for binary compat, remove in 2.5 */
2982                 data->phy_id = np->phy_addr_external;
2983                 /* Fall Through */
2984
2985         case SIOCGMIIREG:               /* Read MII PHY register. */
2986         case SIOCDEVPRIVATE+1:          /* for binary compat, remove in 2.5 */
2987                 /* The phy_id is not enough to uniquely identify
2988                  * the intended target. Therefore the command is sent to
2989                  * the given mii on the current port.
2990                  */
2991                 if (dev->if_port == PORT_TP) {
2992                         if ((data->phy_id & 0x1f) == np->phy_addr_external)
2993                                 data->val_out = mdio_read(dev,
2994                                                         data->reg_num & 0x1f);
2995                         else
2996                                 data->val_out = 0;
2997                 } else {
2998                         move_int_phy(dev, data->phy_id & 0x1f);
2999                         data->val_out = miiport_read(dev, data->phy_id & 0x1f,
3000                                                         data->reg_num & 0x1f);
3001                 }
3002                 return 0;
3003
3004         case SIOCSMIIREG:               /* Write MII PHY register. */
3005         case SIOCDEVPRIVATE+2:          /* for binary compat, remove in 2.5 */
3006                 if (!capable(CAP_NET_ADMIN))
3007                         return -EPERM;
3008                 if (dev->if_port == PORT_TP) {
3009                         if ((data->phy_id & 0x1f) == np->phy_addr_external) {
3010                                 if ((data->reg_num & 0x1f) == MII_ADVERTISE)
3011                                         np->advertising = data->val_in;
3012                                 mdio_write(dev, data->reg_num & 0x1f,
3013                                                         data->val_in);
3014                         }
3015                 } else {
3016                         if ((data->phy_id & 0x1f) == np->phy_addr_external) {
3017                                 if ((data->reg_num & 0x1f) == MII_ADVERTISE)
3018                                         np->advertising = data->val_in;
3019                         }
3020                         move_int_phy(dev, data->phy_id & 0x1f);
3021                         miiport_write(dev, data->phy_id & 0x1f,
3022                                                 data->reg_num & 0x1f,
3023                                                 data->val_in);
3024                 }
3025                 return 0;
3026         default:
3027                 return -EOPNOTSUPP;
3028         }
3029 }
3030
3031 static void enable_wol_mode(struct net_device *dev, int enable_intr)
3032 {
3033         void __iomem * ioaddr = ns_ioaddr(dev);
3034         struct netdev_private *np = netdev_priv(dev);
3035
3036         if (netif_msg_wol(np))
3037                 printk(KERN_INFO "%s: remaining active for wake-on-lan\n",
3038                         dev->name);
3039
3040         /* For WOL we must restart the rx process in silent mode.
3041          * Write NULL to the RxRingPtr. Only possible if
3042          * rx process is stopped
3043          */
3044         writel(0, ioaddr + RxRingPtr);
3045
3046         /* read WoL status to clear */
3047         readl(ioaddr + WOLCmd);
3048
3049         /* PME on, clear status */
3050         writel(np->SavedClkRun | PMEEnable | PMEStatus, ioaddr + ClkRun);
3051
3052         /* and restart the rx process */
3053         writel(RxOn, ioaddr + ChipCmd);
3054
3055         if (enable_intr) {
3056                 /* enable the WOL interrupt.
3057                  * Could be used to send a netlink message.
3058                  */
3059                 writel(WOLPkt | LinkChange, ioaddr + IntrMask);
3060                 writel(1, ioaddr + IntrEnable);
3061         }
3062 }
3063
3064 static int netdev_close(struct net_device *dev)
3065 {
3066         void __iomem * ioaddr = ns_ioaddr(dev);
3067         struct netdev_private *np = netdev_priv(dev);
3068
3069         if (netif_msg_ifdown(np))
3070                 printk(KERN_DEBUG
3071                         "%s: Shutting down ethercard, status was %#04x.\n",
3072                         dev->name, (int)readl(ioaddr + ChipCmd));
3073         if (netif_msg_pktdata(np))
3074                 printk(KERN_DEBUG
3075                         "%s: Queue pointers were Tx %d / %d,  Rx %d / %d.\n",
3076                         dev->name, np->cur_tx, np->dirty_tx,
3077                         np->cur_rx, np->dirty_rx);
3078
3079         /*
3080          * FIXME: what if someone tries to close a device
3081          * that is suspended?
3082          * Should we reenable the nic to switch to
3083          * the final WOL settings?
3084          */
3085
3086         del_timer_sync(&np->timer);
3087         disable_irq(dev->irq);
3088         spin_lock_irq(&np->lock);
3089         natsemi_irq_disable(dev);
3090         np->hands_off = 1;
3091         spin_unlock_irq(&np->lock);
3092         enable_irq(dev->irq);
3093
3094         free_irq(dev->irq, dev);
3095
3096         /* Interrupt disabled, interrupt handler released,
3097          * queue stopped, timer deleted, rtnl_lock held
3098          * All async codepaths that access the driver are disabled.
3099          */
3100         spin_lock_irq(&np->lock);
3101         np->hands_off = 0;
3102         readl(ioaddr + IntrMask);
3103         readw(ioaddr + MIntrStatus);
3104
3105         /* Freeze Stats */
3106         writel(StatsFreeze, ioaddr + StatsCtrl);
3107
3108         /* Stop the chip's Tx and Rx processes. */
3109         natsemi_stop_rxtx(dev);
3110
3111         __get_stats(dev);
3112         spin_unlock_irq(&np->lock);
3113
3114         /* clear the carrier last - an interrupt could reenable it otherwise */
3115         netif_carrier_off(dev);
3116         netif_stop_queue(dev);
3117
3118         dump_ring(dev);
3119         drain_ring(dev);
3120         free_ring(dev);
3121
3122         {
3123                 u32 wol = readl(ioaddr + WOLCmd) & WakeOptsSummary;
3124                 if (wol) {
3125                         /* restart the NIC in WOL mode.
3126                          * The nic must be stopped for this.
3127                          */
3128                         enable_wol_mode(dev, 0);
3129                 } else {
3130                         /* Restore PME enable bit unmolested */
3131                         writel(np->SavedClkRun, ioaddr + ClkRun);
3132                 }
3133         }
3134         return 0;
3135 }
3136
3137
3138 static void __devexit natsemi_remove1 (struct pci_dev *pdev)
3139 {
3140         struct net_device *dev = pci_get_drvdata(pdev);
3141         void __iomem * ioaddr = ns_ioaddr(dev);
3142
3143         unregister_netdev (dev);
3144         pci_release_regions (pdev);
3145         iounmap(ioaddr);
3146         free_netdev (dev);
3147         pci_set_drvdata(pdev, NULL);
3148 }
3149
3150 #ifdef CONFIG_PM
3151
3152 /*
3153  * The ns83815 chip doesn't have explicit RxStop bits.
3154  * Kicking the Rx or Tx process for a new packet reenables the Rx process
3155  * of the nic, thus this function must be very careful:
3156  *
3157  * suspend/resume synchronization:
3158  * entry points:
3159  *   netdev_open, netdev_close, netdev_ioctl, set_rx_mode, intr_handler,
3160  *   start_tx, tx_timeout
3161  *
3162  * No function accesses the hardware without checking np->hands_off.
3163  *      the check occurs under spin_lock_irq(&np->lock);
3164  * exceptions:
3165  *      * netdev_ioctl: noncritical access.
3166  *      * netdev_open: cannot happen due to the device_detach
3167  *      * netdev_close: doesn't hurt.
3168  *      * netdev_timer: timer stopped by natsemi_suspend.
3169  *      * intr_handler: doesn't acquire the spinlock. suspend calls
3170  *              disable_irq() to enforce synchronization.
3171  *      * natsemi_poll: checks before reenabling interrupts.  suspend
3172  *              sets hands_off, disables interrupts and then waits with
3173  *              netif_poll_disable().
3174  *
3175  * Interrupts must be disabled, otherwise hands_off can cause irq storms.
3176  */
3177
3178 static int natsemi_suspend (struct pci_dev *pdev, pm_message_t state)
3179 {
3180         struct net_device *dev = pci_get_drvdata (pdev);
3181         struct netdev_private *np = netdev_priv(dev);
3182         void __iomem * ioaddr = ns_ioaddr(dev);
3183
3184         rtnl_lock();
3185         if (netif_running (dev)) {
3186                 del_timer_sync(&np->timer);
3187
3188                 disable_irq(dev->irq);
3189                 spin_lock_irq(&np->lock);
3190
3191                 writel(0, ioaddr + IntrEnable);
3192                 np->hands_off = 1;
3193                 natsemi_stop_rxtx(dev);
3194                 netif_stop_queue(dev);
3195
3196                 spin_unlock_irq(&np->lock);
3197                 enable_irq(dev->irq);
3198
3199                 netif_poll_disable(dev);
3200
3201                 /* Update the error counts. */
3202                 __get_stats(dev);
3203
3204                 /* pci_power_off(pdev, -1); */
3205                 drain_ring(dev);
3206                 {
3207                         u32 wol = readl(ioaddr + WOLCmd) & WakeOptsSummary;
3208                         /* Restore PME enable bit */
3209                         if (wol) {
3210                                 /* restart the NIC in WOL mode.
3211                                  * The nic must be stopped for this.
3212                                  * FIXME: use the WOL interrupt
3213                                  */
3214                                 enable_wol_mode(dev, 0);
3215                         } else {
3216                                 /* Restore PME enable bit unmolested */
3217                                 writel(np->SavedClkRun, ioaddr + ClkRun);
3218                         }
3219                 }
3220         }
3221         netif_device_detach(dev);
3222         rtnl_unlock();
3223         return 0;
3224 }
3225
3226
3227 static int natsemi_resume (struct pci_dev *pdev)
3228 {
3229         struct net_device *dev = pci_get_drvdata (pdev);
3230         struct netdev_private *np = netdev_priv(dev);
3231
3232         rtnl_lock();
3233         if (netif_device_present(dev))
3234                 goto out;
3235         if (netif_running(dev)) {
3236                 BUG_ON(!np->hands_off);
3237                 pci_enable_device(pdev);
3238         /*      pci_power_on(pdev); */
3239
3240                 natsemi_reset(dev);
3241                 init_ring(dev);
3242                 disable_irq(dev->irq);
3243                 spin_lock_irq(&np->lock);
3244                 np->hands_off = 0;
3245                 init_registers(dev);
3246                 netif_device_attach(dev);
3247                 spin_unlock_irq(&np->lock);
3248                 enable_irq(dev->irq);
3249
3250                 mod_timer(&np->timer, jiffies + 1*HZ);
3251         }
3252         netif_device_attach(dev);
3253         netif_poll_enable(dev);
3254 out:
3255         rtnl_unlock();
3256         return 0;
3257 }
3258
3259 #endif /* CONFIG_PM */
3260
3261 static struct pci_driver natsemi_driver = {
3262         .name           = DRV_NAME,
3263         .id_table       = natsemi_pci_tbl,
3264         .probe          = natsemi_probe1,
3265         .remove         = __devexit_p(natsemi_remove1),
3266 #ifdef CONFIG_PM
3267         .suspend        = natsemi_suspend,
3268         .resume         = natsemi_resume,
3269 #endif
3270 };
3271
3272 static int __init natsemi_init_mod (void)
3273 {
3274 /* when a module, this is printed whether or not devices are found in probe */
3275 #ifdef MODULE
3276         printk(version);
3277 #endif
3278
3279         return pci_register_driver(&natsemi_driver);
3280 }
3281
3282 static void __exit natsemi_exit_mod (void)
3283 {
3284         pci_unregister_driver (&natsemi_driver);
3285 }
3286
3287 module_init(natsemi_init_mod);
3288 module_exit(natsemi_exit_mod);
3289