fedora core 6 1.2949 + vserver 2.2.0

[linux-2.6.git] / drivers / net / natsemi.c

diff --git a/drivers/net/natsemi.c b/drivers/net/natsemi.c
index 88c626a..ffa0afd 100644 (file)
--- a/drivers/net/natsemi.c
+++ b/drivers/net/natsemi.c
@@ -3,6 +3,7 @@
        Written/copyright 1999-2001 by Donald Becker.
        Portions copyright (c) 2001,2002 Sun Microsystems (thockin@sun.com)
        Portions copyright 2001,2002 Manfred Spraul (manfred@colorfullife.com)
        Written/copyright 1999-2001 by Donald Becker.
        Portions copyright (c) 2001,2002 Sun Microsystems (thockin@sun.com)
        Portions copyright 2001,2002 Manfred Spraul (manfred@colorfullife.com)

+       Portions copyright 2004 Harald Welte <laforge@gnumonks.org>

 
        This software may be used and distributed according to the terms of
        the GNU General Public License (GPL), incorporated herein by reference.
 
        This software may be used and distributed according to the terms of
        the GNU General Public License (GPL), incorporated herein by reference.


@@ -19,127 +20,13 @@
 
        Support information and updates available at
        http://www.scyld.com/network/netsemi.html
 
        Support information and updates available at
        http://www.scyld.com/network/netsemi.html

+       [link no longer provides useful info -jgarzik]

 
 
 
 

-       Linux kernel modifications:
-
-       Version 1.0.1:
-               - Spinlock fixes
-               - Bug fixes and better intr performance (Tjeerd)
-       Version 1.0.2:
-               - Now reads correct MAC address from eeprom
-       Version 1.0.3:
-               - Eliminate redundant priv->tx_full flag
-               - Call netif_start_queue from dev->tx_timeout
-               - wmb() in start_tx() to flush data
-               - Update Tx locking
-               - Clean up PCI enable (davej)
-       Version 1.0.4:
-               - Merge Donald Becker's natsemi.c version 1.07
-       Version 1.0.5:
-               - { fill me in }
-       Version 1.0.6:
-               * ethtool support (jgarzik)
-               * Proper initialization of the card (which sometimes
-               fails to occur and leaves the card in a non-functional
-               state). (uzi)
-
-               * Some documented register settings to optimize some
-               of the 100Mbit autodetection circuitry in rev C cards. (uzi)
-
-               * Polling of the PHY intr for stuff like link state
-               change and auto- negotiation to finally work properly. (uzi)
-
-               * One-liner removal of a duplicate declaration of
-               netdev_error(). (uzi)
-
-       Version 1.0.7: (Manfred Spraul)
-               * pci dma
-               * SMP locking update
-               * full reset added into tx_timeout
-               * correct multicast hash generation (both big and little endian)
-                       [copied from a natsemi driver version
-                        from Myrio Corporation, Greg Smith]
-               * suspend/resume
-
-       version 1.0.8 (Tim Hockin <thockin@sun.com>)
-               * ETHTOOL_* support
-               * Wake on lan support (Erik Gilling)
-               * MXDMA fixes for serverworks
-               * EEPROM reload
-
-       version 1.0.9 (Manfred Spraul)
-               * Main change: fix lack of synchronize
-               netif_close/netif_suspend against a last interrupt
-               or packet.
-               * do not enable superflous interrupts (e.g. the
-               drivers relies on TxDone - TxIntr not needed)
-               * wait that the hardware has really stopped in close
-               and suspend.
-               * workaround for the (at least) gcc-2.95.1 compiler
-               problem. Also simplifies the code a bit.
-               * disable_irq() in tx_timeout - needed to protect
-               against rx interrupts.
-               * stop the nic before switching into silent rx mode
-               for wol (required according to docu).
-
-       version 1.0.10:
-               * use long for ee_addr (various)
-               * print pointers properly (DaveM)
-               * include asm/irq.h (?)
-
-       version 1.0.11:
-               * check and reset if PHY errors appear (Adrian Sun)
-               * WoL cleanup (Tim Hockin)
-               * Magic number cleanup (Tim Hockin)
-               * Don't reload EEPROM on every reset (Tim Hockin)
-               * Save and restore EEPROM state across reset (Tim Hockin)
-               * MDIO Cleanup (Tim Hockin)
-               * Reformat register offsets/bits (jgarzik)
-
-       version 1.0.12:
-               * ETHTOOL_* further support (Tim Hockin)
-
-       version 1.0.13:
-               * ETHTOOL_[G]EEPROM support (Tim Hockin)
-
-       version 1.0.13:
-               * crc cleanup (Matt Domsch <Matt_Domsch@dell.com>)
-
-       version 1.0.14:
-               * Cleanup some messages and autoneg in ethtool (Tim Hockin)
-
-       version 1.0.15:
-               * Get rid of cable_magic flag
-               * use new (National provided) solution for cable magic issue
-
-       version 1.0.16:
-               * call netdev_rx() for RxErrors (Manfred Spraul)
-               * formatting and cleanups
-               * change options and full_duplex arrays to be zero
-                 initialized
-               * enable only the WoL and PHY interrupts in wol mode
-
-       version 1.0.17:
-               * only do cable_magic on 83815 and early 83816 (Tim Hockin)
-               * create a function for rx refill (Manfred Spraul)
-               * combine drain_ring and init_ring (Manfred Spraul)
-               * oom handling (Manfred Spraul)
-               * hands_off instead of playing with netif_device_{de,a}ttach
-                 (Manfred Spraul)
-               * be sure to write the MAC back to the chip (Manfred Spraul)
-               * lengthen EEPROM timeout, and always warn about timeouts
-                 (Manfred Spraul)
-               * comments update (Manfred)
-               * do the right thing on a phy-reset (Manfred and Tim)
-

        TODO:
        * big endian support with CFG:BEM instead of cpu_to_le32
        TODO:
        * big endian support with CFG:BEM instead of cpu_to_le32

-       * support for an external PHY
-       * NAPI

 */
 
 */
 

-#include <linux/config.h>

 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/string.h>
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/string.h>


@@ -159,15 +46,16 @@
 #include <linux/rtnetlink.h>
 #include <linux/mii.h>
 #include <linux/crc32.h>
 #include <linux/rtnetlink.h>
 #include <linux/mii.h>
 #include <linux/crc32.h>

+#include <linux/bitops.h>
+#include <linux/prefetch.h>

 #include <asm/processor.h>     /* Processor type for cache alignment. */
 #include <asm/processor.h>     /* Processor type for cache alignment. */

-#include <asm/bitops.h>

 #include <asm/io.h>
 #include <asm/irq.h>
 #include <asm/uaccess.h>
 
 #define DRV_NAME       "natsemi"
 #include <asm/io.h>
 #include <asm/irq.h>
 #include <asm/uaccess.h>
 
 #define DRV_NAME       "natsemi"

-#define DRV_VERSION    "1.07+LK1.0.17"
-#define DRV_RELDATE    "Sep 27, 2002"
+#define DRV_VERSION    "2.1"
+#define DRV_RELDATE    "Sept 11, 2006"

 
 #define RX_OFFSET      2
 
 
 #define RX_OFFSET      2
 


@@ -183,13 +71,11 @@
                                 NETIF_MSG_TX_ERR)
 static int debug = -1;
 
                                 NETIF_MSG_TX_ERR)
 static int debug = -1;
 

-/* Maximum events (Rx packets, etc.) to handle at each interrupt. */
-static int max_interrupt_work = 20;

 static int mtu;
 
 /* Maximum number of multicast addresses to filter (vs. rx-all-multicast).
    This chip uses a 512 element hash table based on the Ethernet CRC.  */
 static int mtu;
 
 /* Maximum number of multicast addresses to filter (vs. rx-all-multicast).
    This chip uses a 512 element hash table based on the Ethernet CRC.  */

-static int multicast_filter_limit = 100;
+static const int multicast_filter_limit = 100;

 
 /* Set the copy breakpoint for the copy-only-tiny-frames scheme.
    Setting to > 1518 effectively disables this feature. */
 
 /* Set the copy breakpoint for the copy-only-tiny-frames scheme.
    Setting to > 1518 effectively disables this feature. */


@@ -228,7 +114,6 @@ static int full_duplex[MAX_UNITS];
                                 NATSEMI_PG1_NREGS)
 #define NATSEMI_REGS_VER       1 /* v1 added RFDR registers */
 #define NATSEMI_REGS_SIZE      (NATSEMI_NREGS * sizeof(u32))
                                 NATSEMI_PG1_NREGS)
 #define NATSEMI_REGS_VER       1 /* v1 added RFDR registers */
 #define NATSEMI_REGS_SIZE      (NATSEMI_NREGS * sizeof(u32))

-#define NATSEMI_EEPROM_SIZE    24 /* 12 16-bit values */

 
 /* Buffer sizes:
  * The nic writes 32-bit values, even if the upper bytes of
 
 /* Buffer sizes:
  * The nic writes 32-bit values, even if the upper bytes of


@@ -240,7 +125,7 @@ static int full_duplex[MAX_UNITS];
 #define NATSEMI_RX_LIMIT       2046    /* maximum supported by hardware */
 
 /* These identify the driver base version and may not be removed. */
 #define NATSEMI_RX_LIMIT       2046    /* maximum supported by hardware */
 
 /* These identify the driver base version and may not be removed. */

-static char version[] __devinitdata =
+static const char version[] __devinitdata =

   KERN_INFO DRV_NAME " dp8381x driver, version "
       DRV_VERSION ", " DRV_RELDATE "\n"
   KERN_INFO "  originally by Donald Becker <becker@scyld.com>\n"
   KERN_INFO DRV_NAME " dp8381x driver, version "
       DRV_VERSION ", " DRV_RELDATE "\n"
   KERN_INFO "  originally by Donald Becker <becker@scyld.com>\n"


@@ -251,19 +136,16 @@ MODULE_AUTHOR("Donald Becker <becker@scyld.com>");
 MODULE_DESCRIPTION("National Semiconductor DP8381x series PCI Ethernet driver");
 MODULE_LICENSE("GPL");
 
 MODULE_DESCRIPTION("National Semiconductor DP8381x series PCI Ethernet driver");
 MODULE_LICENSE("GPL");
 

-MODULE_PARM(max_interrupt_work, "i");
-MODULE_PARM(mtu, "i");
-MODULE_PARM(debug, "i");
-MODULE_PARM(rx_copybreak, "i");
-MODULE_PARM(options, "1-" __MODULE_STRING(MAX_UNITS) "i");
-MODULE_PARM(full_duplex, "1-" __MODULE_STRING(MAX_UNITS) "i");
-MODULE_PARM_DESC(max_interrupt_work, 
-       "DP8381x maximum events handled per interrupt");
+module_param(mtu, int, 0);
+module_param(debug, int, 0);
+module_param(rx_copybreak, int, 0);
+module_param_array(options, int, NULL, 0);
+module_param_array(full_duplex, int, NULL, 0);

 MODULE_PARM_DESC(mtu, "DP8381x MTU (all boards)");
 MODULE_PARM_DESC(debug, "DP8381x default debug level");
 MODULE_PARM_DESC(mtu, "DP8381x MTU (all boards)");
 MODULE_PARM_DESC(debug, "DP8381x default debug level");

-MODULE_PARM_DESC(rx_copybreak, 
+MODULE_PARM_DESC(rx_copybreak,

        "DP8381x copy breakpoint for copy-only-tiny-frames");
        "DP8381x copy breakpoint for copy-only-tiny-frames");

-MODULE_PARM_DESC(options, 
+MODULE_PARM_DESC(options,

        "DP8381x: Bits 0-3: media type, bit 17: full duplex");
 MODULE_PARM_DESC(full_duplex, "DP8381x full duplex setting(s) (1)");
 
        "DP8381x: Bits 0-3: media type, bit 17: full duplex");
 MODULE_PARM_DESC(full_duplex, "DP8381x full duplex setting(s) (1)");
 


@@ -323,12 +205,12 @@ performance critical codepaths:
 The rx process only runs in the interrupt handler. Access from outside
 the interrupt handler is only permitted after disable_irq().
 
 The rx process only runs in the interrupt handler. Access from outside
 the interrupt handler is only permitted after disable_irq().
 

-The rx process usually runs under the dev->xmit_lock. If np->intr_tx_reap
+The rx process usually runs under the netif_tx_lock. If np->intr_tx_reap

 is set, then access is permitted under spin_lock_irq(&np->lock).
 
 Thus configuration functions that want to access everything must call
        disable_irq(dev->irq);
 is set, then access is permitted under spin_lock_irq(&np->lock).
 
 Thus configuration functions that want to access everything must call
        disable_irq(dev->irq);

-       spin_lock_bh(dev->xmit_lock);
+       netif_tx_lock_bh(dev);

        spin_lock_irq(&np->lock);
 
 IV. Notes
        spin_lock_irq(&np->lock);
 
 IV. Notes


@@ -349,18 +231,6 @@ None characterised.
 
 
 
 
 
 

-enum pcistuff {
-       PCI_USES_IO = 0x01,
-       PCI_USES_MEM = 0x02,
-       PCI_USES_MASTER = 0x04,
-       PCI_ADDR0 = 0x08,
-       PCI_ADDR1 = 0x10,
-};
-
-/* MMIO operations required */
-#define PCI_IOTYPE (PCI_USES_MASTER | PCI_USES_MEM | PCI_ADDR1)
-
-

 /*
  * Support for fibre connections on Am79C874:
  * This phy needs a special setup when connected to a fibre cable.
 /*
  * Support for fibre connections on Am79C874:
  * This phy needs a special setup when connected to a fibre cable.


@@ -368,22 +238,25 @@ enum pcistuff {
  */
 #define PHYID_AM79C874 0x0022561b
 
  */
 #define PHYID_AM79C874 0x0022561b
 

-#define MII_MCTRL      0x15    /* mode control register */
-#define MII_FX_SEL     0x0001  /* 100BASE-FX (fiber) */
-#define MII_EN_SCRM    0x0004  /* enable scrambler (tp) */
+enum {
+       MII_MCTRL       = 0x15,         /* mode control register */
+       MII_FX_SEL      = 0x0001,       /* 100BASE-FX (fiber) */
+       MII_EN_SCRM     = 0x0004,       /* enable scrambler (tp) */
+};
+

 
 

- 

 /* array of board data directly indexed by pci_tbl[x].driver_data */
 /* array of board data directly indexed by pci_tbl[x].driver_data */

-static struct {
+static const struct {

        const char *name;
        unsigned long flags;
        const char *name;
        unsigned long flags;

+       unsigned int eeprom_size;

 } natsemi_pci_info[] __devinitdata = {
 } natsemi_pci_info[] __devinitdata = {

-       { "NatSemi DP8381[56]", PCI_IOTYPE },
+       { "NatSemi DP8381[56]", 0, 24 },

 };
 
 };
 

-static struct pci_device_id natsemi_pci_tbl[] = {
-       { PCI_VENDOR_ID_NS, PCI_DEVICE_ID_NS_83815, PCI_ANY_ID, PCI_ANY_ID, },
-       { 0, },
+static const struct pci_device_id natsemi_pci_tbl[] __devinitdata = {
+       { PCI_VENDOR_ID_NS, 0x0020, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
+       { }     /* terminate list */

 };
 MODULE_DEVICE_TABLE(pci, natsemi_pci_tbl);
 
 };
 MODULE_DEVICE_TABLE(pci, natsemi_pci_tbl);
 


@@ -441,6 +314,7 @@ enum register_offsets {
 #define DSPCFG_VAL     0x5040
 #define SDCFG_VAL      0x008c  /* set voltage thresholds for Signal Detect */
 #define DSPCFG_LOCK    0x20    /* coefficient lock bit in DSPCFG */
 #define DSPCFG_VAL     0x5040
 #define SDCFG_VAL      0x008c  /* set voltage thresholds for Signal Detect */
 #define DSPCFG_LOCK    0x20    /* coefficient lock bit in DSPCFG */

+#define DSPCFG_COEF    0x1000  /* see coefficient (in TSTDAT) bit in DSPCFG */

 #define TSTDAT_FIXED   0xe8    /* magic number for bad coefficients */
 
 /* misc PCI space registers */
 #define TSTDAT_FIXED   0xe8    /* magic number for bad coefficients */
 
 /* misc PCI space registers */


@@ -540,7 +414,7 @@ enum TxConfig_bits {
        TxCarrierIgn            = 0x80000000
 };
 
        TxCarrierIgn            = 0x80000000
 };
 

-/* 
+/*

  * Tx Configuration:
  * - 256 byte DMA burst length
  * - fill threshold 512 bytes (i.e. restart DMA when 512 bytes are free)
  * Tx Configuration:
  * - 256 byte DMA burst length
  * - fill threshold 512 bytes (i.e. restart DMA when 512 bytes are free)


@@ -690,6 +564,8 @@ struct netdev_private {
        /* Based on MTU+slack. */
        unsigned int rx_buf_sz;
        int oom;
        /* Based on MTU+slack. */
        unsigned int rx_buf_sz;
        int oom;

+       /* Interrupt status */
+       u32 intr_status;

        /* Do not touch the nic registers */
        int hands_off;
        /* external phy that is used: only valid if dev->if_port != PORT_TP */
        /* Do not touch the nic registers */
        int hands_off;
        /* external phy that is used: only valid if dev->if_port != PORT_TP */


@@ -716,10 +592,12 @@ struct netdev_private {
        unsigned int iosize;
        spinlock_t lock;
        u32 msg_enable;
        unsigned int iosize;
        spinlock_t lock;
        u32 msg_enable;

+       /* EEPROM data */
+       int eeprom_size;

 };
 
 static void move_int_phy(struct net_device *dev, int addr);
 };
 
 static void move_int_phy(struct net_device *dev, int addr);

-static int eeprom_read(long ioaddr, int location);
+static int eeprom_read(void __iomem *ioaddr, int location);

 static int mdio_read(struct net_device *dev, int reg);
 static void mdio_write(struct net_device *dev, int reg, u16 data);
 static void init_phy_fixup(struct net_device *dev);
 static int mdio_read(struct net_device *dev, int reg);
 static void mdio_write(struct net_device *dev, int reg, u16 data);
 static void init_phy_fixup(struct net_device *dev);


@@ -745,11 +623,15 @@ static void free_ring(struct net_device *dev);
 static void reinit_ring(struct net_device *dev);
 static void init_registers(struct net_device *dev);
 static int start_tx(struct sk_buff *skb, struct net_device *dev);
 static void reinit_ring(struct net_device *dev);
 static void init_registers(struct net_device *dev);
 static int start_tx(struct sk_buff *skb, struct net_device *dev);

-static irqreturn_t intr_handler(int irq, void *dev_instance, struct pt_regs *regs);
+static irqreturn_t intr_handler(int irq, void *dev_instance);

 static void netdev_error(struct net_device *dev, int intr_status);
 static void netdev_error(struct net_device *dev, int intr_status);

-static void netdev_rx(struct net_device *dev);
+static int natsemi_poll(struct net_device *dev, int *budget);
+static void netdev_rx(struct net_device *dev, int *work_done, int work_to_do);

 static void netdev_tx_done(struct net_device *dev);
 static int natsemi_change_mtu(struct net_device *dev, int new_mtu);
 static void netdev_tx_done(struct net_device *dev);
 static int natsemi_change_mtu(struct net_device *dev, int new_mtu);

+#ifdef CONFIG_NET_POLL_CONTROLLER
+static void natsemi_poll_controller(struct net_device *dev);
+#endif

 static void __set_rx_mode(struct net_device *dev);
 static void set_rx_mode(struct net_device *dev);
 static void __get_stats(struct net_device *dev);
 static void __set_rx_mode(struct net_device *dev);
 static void set_rx_mode(struct net_device *dev);
 static void __get_stats(struct net_device *dev);


@@ -765,13 +647,32 @@ static void enable_wol_mode(struct net_device *dev, int enable_intr);
 static int netdev_close(struct net_device *dev);
 static int netdev_get_regs(struct net_device *dev, u8 *buf);
 static int netdev_get_eeprom(struct net_device *dev, u8 *buf);
 static int netdev_close(struct net_device *dev);
 static int netdev_get_regs(struct net_device *dev, u8 *buf);
 static int netdev_get_eeprom(struct net_device *dev, u8 *buf);

+static const struct ethtool_ops ethtool_ops;
+
+static inline void __iomem *ns_ioaddr(struct net_device *dev)
+{
+       return (void __iomem *) dev->base_addr;
+}
+
+static inline void natsemi_irq_enable(struct net_device *dev)
+{
+       writel(1, ns_ioaddr(dev) + IntrEnable);
+       readl(ns_ioaddr(dev) + IntrEnable);
+}
+
+static inline void natsemi_irq_disable(struct net_device *dev)
+{
+       writel(0, ns_ioaddr(dev) + IntrEnable);
+       readl(ns_ioaddr(dev) + IntrEnable);
+}

 
 static void move_int_phy(struct net_device *dev, int addr)
 {
        struct netdev_private *np = netdev_priv(dev);
 
 static void move_int_phy(struct net_device *dev, int addr)
 {
        struct netdev_private *np = netdev_priv(dev);

+       void __iomem *ioaddr = ns_ioaddr(dev);

        int target = 31;
 
        int target = 31;
 

-       /* 
+       /*

         * The internal phy is visible on the external mii bus. Therefore we must
         * move it away before we can send commands to an external phy.
         * There are two addresses we must avoid:
         * The internal phy is visible on the external mii bus. Therefore we must
         * move it away before we can send commands to an external phy.
         * There are two addresses we must avoid:


@@ -785,11 +686,47 @@ static void move_int_phy(struct net_device *dev, int addr)
                target--;
        if (target == np->phy_addr_external)
                target--;
                target--;
        if (target == np->phy_addr_external)
                target--;

-       writew(target, dev->base_addr + PhyCtrl);
-       readw(dev->base_addr + PhyCtrl);
+       writew(target, ioaddr + PhyCtrl);
+       readw(ioaddr + PhyCtrl);

        udelay(1);
 }
 
        udelay(1);
 }
 

+static void __devinit natsemi_init_media (struct net_device *dev)
+{
+       struct netdev_private *np = netdev_priv(dev);
+       u32 tmp;
+
+       netif_carrier_off(dev);
+
+       /* get the initial settings from hardware */
+       tmp            = mdio_read(dev, MII_BMCR);
+       np->speed      = (tmp & BMCR_SPEED100)? SPEED_100     : SPEED_10;
+       np->duplex     = (tmp & BMCR_FULLDPLX)? DUPLEX_FULL   : DUPLEX_HALF;
+       np->autoneg    = (tmp & BMCR_ANENABLE)? AUTONEG_ENABLE: AUTONEG_DISABLE;
+       np->advertising= mdio_read(dev, MII_ADVERTISE);
+
+       if ((np->advertising & ADVERTISE_ALL) != ADVERTISE_ALL
+        && netif_msg_probe(np)) {
+               printk(KERN_INFO "natsemi %s: Transceiver default autonegotiation %s "
+                       "10%s %s duplex.\n",
+                       pci_name(np->pci_dev),
+                       (mdio_read(dev, MII_BMCR) & BMCR_ANENABLE)?
+                         "enabled, advertise" : "disabled, force",
+                       (np->advertising &
+                         (ADVERTISE_100FULL|ADVERTISE_100HALF))?
+                           "0" : "",
+                       (np->advertising &
+                         (ADVERTISE_100FULL|ADVERTISE_10FULL))?
+                           "full" : "half");
+       }
+       if (netif_msg_probe(np))
+               printk(KERN_INFO
+                       "natsemi %s: Transceiver status %#04x advertising %#04x.\n",
+                       pci_name(np->pci_dev), mdio_read(dev, MII_BMSR),
+                       np->advertising);
+
+}
+

 static int __devinit natsemi_probe1 (struct pci_dev *pdev,
        const struct pci_device_id *ent)
 {
 static int __devinit natsemi_probe1 (struct pci_dev *pdev,
        const struct pci_device_id *ent)
 {


@@ -797,7 +734,8 @@ static int __devinit natsemi_probe1 (struct pci_dev *pdev,
        struct netdev_private *np;
        int i, option, irq, chip_idx = ent->driver_data;
        static int find_cnt = -1;
        struct netdev_private *np;
        int i, option, irq, chip_idx = ent->driver_data;
        static int find_cnt = -1;

-       unsigned long ioaddr, iosize;
+       unsigned long iostart, iosize;
+       void __iomem *ioaddr;

        const int pcibar = 1; /* PCI base address register */
        int prev_eedata;
        u32 tmp;
        const int pcibar = 1; /* PCI base address register */
        int prev_eedata;
        u32 tmp;


@@ -824,12 +762,11 @@ static int __devinit natsemi_probe1 (struct pci_dev *pdev,
        }
 
        find_cnt++;
        }
 
        find_cnt++;

-       ioaddr = pci_resource_start(pdev, pcibar);
+       iostart = pci_resource_start(pdev, pcibar);

        iosize = pci_resource_len(pdev, pcibar);
        irq = pdev->irq;
 
        iosize = pci_resource_len(pdev, pcibar);
        irq = pdev->irq;
 

-       if (natsemi_pci_info[chip_idx].flags & PCI_USES_MASTER)
-               pci_set_master(pdev);
+       pci_set_master(pdev);

 
        dev = alloc_etherdev(sizeof (struct netdev_private));
        if (!dev)
 
        dev = alloc_etherdev(sizeof (struct netdev_private));
        if (!dev)


@@ -841,7 +778,7 @@ static int __devinit natsemi_probe1 (struct pci_dev *pdev,
        if (i)
                goto err_pci_request_regions;
 
        if (i)
                goto err_pci_request_regions;
 

-       ioaddr = (unsigned long) ioremap (ioaddr, iosize);
+       ioaddr = ioremap(iostart, iosize);

        if (!ioaddr) {
                i = -ENOMEM;
                goto err_ioremap;
        if (!ioaddr) {
                i = -ENOMEM;
                goto err_ioremap;


@@ -856,7 +793,7 @@ static int __devinit natsemi_probe1 (struct pci_dev *pdev,
                prev_eedata = eedata;
        }
 
                prev_eedata = eedata;
        }
 

-       dev->base_addr = ioaddr;
+       dev->base_addr = (unsigned long __force) ioaddr;

        dev->irq = irq;
 
        np = netdev_priv(dev);
        dev->irq = irq;
 
        np = netdev_priv(dev);


@@ -867,6 +804,8 @@ static int __devinit natsemi_probe1 (struct pci_dev *pdev,
        spin_lock_init(&np->lock);
        np->msg_enable = (debug >= 0) ? (1<<debug)-1 : NATSEMI_DEF_MSG;
        np->hands_off = 0;
        spin_lock_init(&np->lock);
        np->msg_enable = (debug >= 0) ? (1<<debug)-1 : NATSEMI_DEF_MSG;
        np->hands_off = 0;

+       np->intr_status = 0;
+       np->eeprom_size = natsemi_pci_info[chip_idx].eeprom_size;

 
        /* Initial port:
         * - If the nic was configured to use an external phy and if find_mii
 
        /* Initial port:
         * - If the nic was configured to use an external phy and if find_mii


@@ -876,7 +815,7 @@ static int __devinit natsemi_probe1 (struct pci_dev *pdev,
         * The address would be used to access a phy over the mii bus, but
         * the internal phy is accessed through mapped registers.
         */
         * The address would be used to access a phy over the mii bus, but
         * the internal phy is accessed through mapped registers.
         */

-       if (readl(dev->base_addr + ChipConfig) & CfgExtPhy)
+       if (readl(ioaddr + ChipConfig) & CfgExtPhy)

                dev->if_port = PORT_MII;
        else
                dev->if_port = PORT_TP;
                dev->if_port = PORT_MII;
        else
                dev->if_port = PORT_TP;


@@ -920,38 +859,18 @@ static int __devinit natsemi_probe1 (struct pci_dev *pdev,
        dev->do_ioctl = &netdev_ioctl;
        dev->tx_timeout = &tx_timeout;
        dev->watchdog_timeo = TX_TIMEOUT;
        dev->do_ioctl = &netdev_ioctl;
        dev->tx_timeout = &tx_timeout;
        dev->watchdog_timeo = TX_TIMEOUT;

+       dev->poll = natsemi_poll;
+       dev->weight = 64;
+
+#ifdef CONFIG_NET_POLL_CONTROLLER
+       dev->poll_controller = &natsemi_poll_controller;
+#endif
+       SET_ETHTOOL_OPS(dev, &ethtool_ops);

 
        if (mtu)
                dev->mtu = mtu;
 
 
        if (mtu)
                dev->mtu = mtu;
 

-       netif_carrier_off(dev);
-
-       /* get the initial settings from hardware */
-       tmp            = mdio_read(dev, MII_BMCR);
-       np->speed      = (tmp & BMCR_SPEED100)? SPEED_100     : SPEED_10;
-       np->duplex     = (tmp & BMCR_FULLDPLX)? DUPLEX_FULL   : DUPLEX_HALF;
-       np->autoneg    = (tmp & BMCR_ANENABLE)? AUTONEG_ENABLE: AUTONEG_DISABLE;
-       np->advertising= mdio_read(dev, MII_ADVERTISE);
-
-       if ((np->advertising & ADVERTISE_ALL) != ADVERTISE_ALL
-        && netif_msg_probe(np)) {
-               printk(KERN_INFO "natsemi %s: Transceiver default autonegotiation %s "
-                       "10%s %s duplex.\n",
-                       pci_name(np->pci_dev),
-                       (mdio_read(dev, MII_BMCR) & BMCR_ANENABLE)?
-                         "enabled, advertise" : "disabled, force",
-                       (np->advertising &
-                         (ADVERTISE_100FULL|ADVERTISE_100HALF))?
-                           "0" : "",
-                       (np->advertising &
-                         (ADVERTISE_100FULL|ADVERTISE_10FULL))?
-                           "full" : "half");
-       }
-       if (netif_msg_probe(np))
-               printk(KERN_INFO
-                       "natsemi %s: Transceiver status %#04x advertising %#04x.\n",
-                       pci_name(np->pci_dev), mdio_read(dev, MII_BMSR),
-                       np->advertising);
+       natsemi_init_media(dev);

 
        /* save the silicon revision for later querying */
        np->srr = readl(ioaddr + SiliconRev);
 
        /* save the silicon revision for later querying */
        np->srr = readl(ioaddr + SiliconRev);


@@ -965,7 +884,7 @@ static int __devinit natsemi_probe1 (struct pci_dev *pdev,
 
        if (netif_msg_drv(np)) {
                printk(KERN_INFO "natsemi %s: %s at %#08lx (%s), ",
 
        if (netif_msg_drv(np)) {
                printk(KERN_INFO "natsemi %s: %s at %#08lx (%s), ",

-                       dev->name, natsemi_pci_info[chip_idx].name, ioaddr,
+                       dev->name, natsemi_pci_info[chip_idx].name, iostart,

                        pci_name(np->pci_dev));
                for (i = 0; i < ETH_ALEN-1; i++)
                                printk("%02x:", dev->dev_addr[i]);
                        pci_name(np->pci_dev));
                for (i = 0; i < ETH_ALEN-1; i++)
                                printk("%02x:", dev->dev_addr[i]);


@@ -978,7 +897,7 @@ static int __devinit natsemi_probe1 (struct pci_dev *pdev,
        return 0;
 
  err_register_netdev:
        return 0;
 
  err_register_netdev:

-       iounmap ((void *) dev->base_addr);
+       iounmap(ioaddr);

 
  err_ioremap:
        pci_release_regions(pdev);
 
  err_ioremap:
        pci_release_regions(pdev);


@@ -1010,12 +929,13 @@ enum EEPROM_Cmds {
        EE_WriteCmd=(5 << 6), EE_ReadCmd=(6 << 6), EE_EraseCmd=(7 << 6),
 };
 
        EE_WriteCmd=(5 << 6), EE_ReadCmd=(6 << 6), EE_EraseCmd=(7 << 6),
 };
 

-static int eeprom_read(long addr, int location)
+static int eeprom_read(void __iomem *addr, int location)

 {
        int i;
        int retval = 0;
 {
        int i;
        int retval = 0;

-       long ee_addr = addr + EECtrl;
+       void __iomem *ee_addr = addr + EECtrl;

        int read_cmd = location | EE_ReadCmd;
        int read_cmd = location | EE_ReadCmd;

+

        writel(EE_Write0, ee_addr);
 
        /* Shift the read command bits out. */
        writel(EE_Write0, ee_addr);
 
        /* Shift the read command bits out. */


@@ -1052,33 +972,35 @@ static int eeprom_read(long addr, int location)
 /* clock transitions >= 20ns (25MHz)
  * One readl should be good to PCI @ 100MHz
  */
 /* clock transitions >= 20ns (25MHz)
  * One readl should be good to PCI @ 100MHz
  */

-#define mii_delay(dev)  readl(dev->base_addr + EECtrl)
+#define mii_delay(ioaddr)  readl(ioaddr + EECtrl)

 
 static int mii_getbit (struct net_device *dev)
 {
        int data;
 
 static int mii_getbit (struct net_device *dev)
 {
        int data;

+       void __iomem *ioaddr = ns_ioaddr(dev);

 
 

-       writel(MII_ShiftClk, dev->base_addr + EECtrl);
-       data = readl(dev->base_addr + EECtrl);
-       writel(0, dev->base_addr + EECtrl);
-       mii_delay(dev);
+       writel(MII_ShiftClk, ioaddr + EECtrl);
+       data = readl(ioaddr + EECtrl);
+       writel(0, ioaddr + EECtrl);
+       mii_delay(ioaddr);

        return (data & MII_Data)? 1 : 0;
 }
 
 static void mii_send_bits (struct net_device *dev, u32 data, int len)
 {
        u32 i;
        return (data & MII_Data)? 1 : 0;
 }
 
 static void mii_send_bits (struct net_device *dev, u32 data, int len)
 {
        u32 i;

+       void __iomem *ioaddr = ns_ioaddr(dev);

 
        for (i = (1 << (len-1)); i; i >>= 1)
        {
                u32 mdio_val = MII_Write | ((data & i)? MII_Data : 0);
 
        for (i = (1 << (len-1)); i; i >>= 1)
        {
                u32 mdio_val = MII_Write | ((data & i)? MII_Data : 0);

-               writel(mdio_val, dev->base_addr + EECtrl);
-               mii_delay(dev);
-               writel(mdio_val | MII_ShiftClk, dev->base_addr + EECtrl);
-               mii_delay(dev);
+               writel(mdio_val, ioaddr + EECtrl);
+               mii_delay(ioaddr);
+               writel(mdio_val | MII_ShiftClk, ioaddr + EECtrl);
+               mii_delay(ioaddr);

        }
        }

-       writel(0, dev->base_addr + EECtrl);
-       mii_delay(dev);
+       writel(0, ioaddr + EECtrl);
+       mii_delay(ioaddr);

 }
 
 static int miiport_read(struct net_device *dev, int phy_id, int reg)
 }
 
 static int miiport_read(struct net_device *dev, int phy_id, int reg)


@@ -1123,13 +1045,14 @@ static void miiport_write(struct net_device *dev, int phy_id, int reg, u16 data)
 static int mdio_read(struct net_device *dev, int reg)
 {
        struct netdev_private *np = netdev_priv(dev);
 static int mdio_read(struct net_device *dev, int reg)
 {
        struct netdev_private *np = netdev_priv(dev);

+       void __iomem *ioaddr = ns_ioaddr(dev);

 
        /* The 83815 series has two ports:
         * - an internal transceiver
         * - an external mii bus
         */
        if (dev->if_port == PORT_TP)
 
        /* The 83815 series has two ports:
         * - an internal transceiver
         * - an external mii bus
         */
        if (dev->if_port == PORT_TP)

-               return readw(dev->base_addr+BasicControl+(reg<<2));
+               return readw(ioaddr+BasicControl+(reg<<2));

        else
                return miiport_read(dev, np->phy_addr_external, reg);
 }
        else
                return miiport_read(dev, np->phy_addr_external, reg);
 }


@@ -1137,10 +1060,11 @@ static int mdio_read(struct net_device *dev, int reg)
 static void mdio_write(struct net_device *dev, int reg, u16 data)
 {
        struct netdev_private *np = netdev_priv(dev);
 static void mdio_write(struct net_device *dev, int reg, u16 data)
 {
        struct netdev_private *np = netdev_priv(dev);

+       void __iomem *ioaddr = ns_ioaddr(dev);

 
        /* The 83815 series has an internal transceiver; handle separately */
        if (dev->if_port == PORT_TP)
 
        /* The 83815 series has an internal transceiver; handle separately */
        if (dev->if_port == PORT_TP)

-               writew(data, dev->base_addr+BasicControl+(reg<<2));
+               writew(data, ioaddr+BasicControl+(reg<<2));

        else
                miiport_write(dev, np->phy_addr_external, reg, data);
 }
        else
                miiport_write(dev, np->phy_addr_external, reg, data);
 }


@@ -1148,7 +1072,7 @@ static void mdio_write(struct net_device *dev, int reg, u16 data)
 static void init_phy_fixup(struct net_device *dev)
 {
        struct netdev_private *np = netdev_priv(dev);
 static void init_phy_fixup(struct net_device *dev)
 {
        struct netdev_private *np = netdev_priv(dev);

-       long ioaddr = dev->base_addr;
+       void __iomem *ioaddr = ns_ioaddr(dev);

        int i;
        u32 cfg;
        u16 tmp;
        int i;
        u32 cfg;
        u16 tmp;


@@ -1171,7 +1095,7 @@ static void init_phy_fixup(struct net_device *dev)
                        tmp |= BMCR_SPEED100;
                if (np->duplex == DUPLEX_FULL)
                        tmp |= BMCR_FULLDPLX;
                        tmp |= BMCR_SPEED100;
                if (np->duplex == DUPLEX_FULL)
                        tmp |= BMCR_FULLDPLX;

-               /* 
+               /*

                 * Note: there is no good way to inform the link partner
                 * that our capabilities changed. The user has to unplug
                 * and replug the network cable after some changes, e.g.
                 * Note: there is no good way to inform the link partner
                 * that our capabilities changed. The user has to unplug
                 * and replug the network cable after some changes, e.g.


@@ -1180,7 +1104,7 @@ static void init_phy_fixup(struct net_device *dev)
                 */
        }
        mdio_write(dev, MII_BMCR, tmp);
                 */
        }
        mdio_write(dev, MII_BMCR, tmp);

-       readl(dev->base_addr + ChipConfig);
+       readl(ioaddr + ChipConfig);

        udelay(1);
 
        /* find out what phy this is */
        udelay(1);
 
        /* find out what phy this is */


@@ -1202,7 +1126,7 @@ static void init_phy_fixup(struct net_device *dev)
        default:
                break;
        }
        default:
                break;
        }

-       cfg = readl(dev->base_addr + ChipConfig);
+       cfg = readl(ioaddr + ChipConfig);

        if (cfg & CfgExtPhy)
                return;
 
        if (cfg & CfgExtPhy)
                return;
 


@@ -1223,7 +1147,8 @@ static void init_phy_fixup(struct net_device *dev)
                writew(1, ioaddr + PGSEL);
                writew(PMDCSR_VAL, ioaddr + PMDCSR);
                writew(TSTDAT_VAL, ioaddr + TSTDAT);
                writew(1, ioaddr + PGSEL);
                writew(PMDCSR_VAL, ioaddr + PMDCSR);
                writew(TSTDAT_VAL, ioaddr + TSTDAT);

-               np->dspcfg = DSPCFG_VAL;
+               np->dspcfg = (np->srr <= SRR_DP83815_C)?
+                       DSPCFG_VAL : (DSPCFG_COEF | readw(ioaddr + DSPCFG));

                writew(np->dspcfg, ioaddr + DSPCFG);
                writew(SDCFG_VAL, ioaddr + SDCFG);
                writew(0, ioaddr + PGSEL);
                writew(np->dspcfg, ioaddr + DSPCFG);
                writew(SDCFG_VAL, ioaddr + SDCFG);
                writew(0, ioaddr + PGSEL);


@@ -1260,9 +1185,10 @@ static void init_phy_fixup(struct net_device *dev)
 static int switch_port_external(struct net_device *dev)
 {
        struct netdev_private *np = netdev_priv(dev);
 static int switch_port_external(struct net_device *dev)
 {
        struct netdev_private *np = netdev_priv(dev);

+       void __iomem *ioaddr = ns_ioaddr(dev);

        u32 cfg;
 
        u32 cfg;
 

-       cfg = readl(dev->base_addr + ChipConfig);
+       cfg = readl(ioaddr + ChipConfig);

        if (cfg & CfgExtPhy)
                return 0;
 
        if (cfg & CfgExtPhy)
                return 0;
 


@@ -1272,8 +1198,8 @@ static int switch_port_external(struct net_device *dev)
        }
 
        /* 1) switch back to external phy */
        }
 
        /* 1) switch back to external phy */

-       writel(cfg | (CfgExtPhy | CfgPhyDis), dev->base_addr + ChipConfig);
-       readl(dev->base_addr + ChipConfig);
+       writel(cfg | (CfgExtPhy | CfgPhyDis), ioaddr + ChipConfig);
+       readl(ioaddr + ChipConfig);

        udelay(1);
 
        /* 2) reset the external phy: */
        udelay(1);
 
        /* 2) reset the external phy: */


@@ -1292,11 +1218,12 @@ static int switch_port_external(struct net_device *dev)
 static int switch_port_internal(struct net_device *dev)
 {
        struct netdev_private *np = netdev_priv(dev);
 static int switch_port_internal(struct net_device *dev)
 {
        struct netdev_private *np = netdev_priv(dev);

+       void __iomem *ioaddr = ns_ioaddr(dev);

        int i;
        u32 cfg;
        u16 bmcr;
 
        int i;
        u32 cfg;
        u16 bmcr;
 

-       cfg = readl(dev->base_addr + ChipConfig);
+       cfg = readl(ioaddr + ChipConfig);

        if (!(cfg &CfgExtPhy))
                return 0;
 
        if (!(cfg &CfgExtPhy))
                return 0;
 


@@ -1306,17 +1233,17 @@ static int switch_port_internal(struct net_device *dev)
        }
        /* 1) switch back to internal phy: */
        cfg = cfg & ~(CfgExtPhy | CfgPhyDis);
        }
        /* 1) switch back to internal phy: */
        cfg = cfg & ~(CfgExtPhy | CfgPhyDis);

-       writel(cfg, dev->base_addr + ChipConfig);
-       readl(dev->base_addr + ChipConfig);
+       writel(cfg, ioaddr + ChipConfig);
+       readl(ioaddr + ChipConfig);

        udelay(1);
        udelay(1);

-       
+

        /* 2) reset the internal phy: */
        /* 2) reset the internal phy: */

-       bmcr = readw(dev->base_addr+BasicControl+(MII_BMCR<<2));
-       writel(bmcr | BMCR_RESET, dev->base_addr+BasicControl+(MII_BMCR<<2));
-       readl(dev->base_addr + ChipConfig);
+       bmcr = readw(ioaddr+BasicControl+(MII_BMCR<<2));
+       writel(bmcr | BMCR_RESET, ioaddr+BasicControl+(MII_BMCR<<2));
+       readl(ioaddr + ChipConfig);

        udelay(10);
        for (i=0;i<NATSEMI_HW_TIMEOUT;i++) {
        udelay(10);
        for (i=0;i<NATSEMI_HW_TIMEOUT;i++) {

-               bmcr = readw(dev->base_addr+BasicControl+(MII_BMCR<<2));
+               bmcr = readw(ioaddr+BasicControl+(MII_BMCR<<2));

                if (!(bmcr & BMCR_RESET))
                        break;
                udelay(10);
                if (!(bmcr & BMCR_RESET))
                        break;
                udelay(10);


@@ -1349,7 +1276,7 @@ static int find_mii(struct net_device *dev)
 
        /* Switch to external phy */
        did_switch = switch_port_external(dev);
 
        /* Switch to external phy */
        did_switch = switch_port_external(dev);

-               
+

        /* Scan the possible phy addresses:
         *
         * PHY address 0 means that the phy is in isolate mode. Not yet
        /* Scan the possible phy addresses:
         *
         * PHY address 0 means that the phy is in isolate mode. Not yet


@@ -1392,6 +1319,7 @@ static void natsemi_reset(struct net_device *dev)
        u16 pmatch[3];
        u16 sopass[3];
        struct netdev_private *np = netdev_priv(dev);
        u16 pmatch[3];
        u16 sopass[3];
        struct netdev_private *np = netdev_priv(dev);

+       void __iomem *ioaddr = ns_ioaddr(dev);

 
        /*
         * Resetting the chip causes some registers to be lost.
 
        /*
         * Resetting the chip causes some registers to be lost.


@@ -1402,26 +1330,26 @@ static void natsemi_reset(struct net_device *dev)
         */
 
        /* CFG */
         */
 
        /* CFG */

-       cfg = readl(dev->base_addr + ChipConfig) & CFG_RESET_SAVE;
+       cfg = readl(ioaddr + ChipConfig) & CFG_RESET_SAVE;

        /* WCSR */
        /* WCSR */

-       wcsr = readl(dev->base_addr + WOLCmd) & WCSR_RESET_SAVE;
+       wcsr = readl(ioaddr + WOLCmd) & WCSR_RESET_SAVE;

        /* RFCR */
        /* RFCR */

-       rfcr = readl(dev->base_addr + RxFilterAddr) & RFCR_RESET_SAVE;
+       rfcr = readl(ioaddr + RxFilterAddr) & RFCR_RESET_SAVE;

        /* PMATCH */
        for (i = 0; i < 3; i++) {
        /* PMATCH */
        for (i = 0; i < 3; i++) {

-               writel(i*2, dev->base_addr + RxFilterAddr);
-               pmatch[i] = readw(dev->base_addr + RxFilterData);
+               writel(i*2, ioaddr + RxFilterAddr);
+               pmatch[i] = readw(ioaddr + RxFilterData);

        }
        /* SOPAS */
        for (i = 0; i < 3; i++) {
        }
        /* SOPAS */
        for (i = 0; i < 3; i++) {

-               writel(0xa+(i*2), dev->base_addr + RxFilterAddr);
-               sopass[i] = readw(dev->base_addr + RxFilterData);
+               writel(0xa+(i*2), ioaddr + RxFilterAddr);
+               sopass[i] = readw(ioaddr + RxFilterData);

        }
 
        /* now whack the chip */
        }
 
        /* now whack the chip */

-       writel(ChipReset, dev->base_addr + ChipCmd);
+       writel(ChipReset, ioaddr + ChipCmd);

        for (i=0;i<NATSEMI_HW_TIMEOUT;i++) {
        for (i=0;i<NATSEMI_HW_TIMEOUT;i++) {

-               if (!(readl(dev->base_addr + ChipCmd) & ChipReset))
+               if (!(readl(ioaddr + ChipCmd) & ChipReset))

                        break;
                udelay(5);
        }
                        break;
                udelay(5);
        }


@@ -1434,40 +1362,66 @@ static void natsemi_reset(struct net_device *dev)
        }
 
        /* restore CFG */
        }
 
        /* restore CFG */

-       cfg |= readl(dev->base_addr + ChipConfig) & ~CFG_RESET_SAVE;
+       cfg |= readl(ioaddr + ChipConfig) & ~CFG_RESET_SAVE;

        /* turn on external phy if it was selected */
        if (dev->if_port == PORT_TP)
                cfg &= ~(CfgExtPhy | CfgPhyDis);
        else
                cfg |= (CfgExtPhy | CfgPhyDis);
        /* turn on external phy if it was selected */
        if (dev->if_port == PORT_TP)
                cfg &= ~(CfgExtPhy | CfgPhyDis);
        else
                cfg |= (CfgExtPhy | CfgPhyDis);

-       writel(cfg, dev->base_addr + ChipConfig);
+       writel(cfg, ioaddr + ChipConfig);

        /* restore WCSR */
        /* restore WCSR */

-       wcsr |= readl(dev->base_addr + WOLCmd) & ~WCSR_RESET_SAVE;
-       writel(wcsr, dev->base_addr + WOLCmd);
+       wcsr |= readl(ioaddr + WOLCmd) & ~WCSR_RESET_SAVE;
+       writel(wcsr, ioaddr + WOLCmd);

        /* read RFCR */
        /* read RFCR */

-       rfcr |= readl(dev->base_addr + RxFilterAddr) & ~RFCR_RESET_SAVE;
+       rfcr |= readl(ioaddr + RxFilterAddr) & ~RFCR_RESET_SAVE;

        /* restore PMATCH */
        for (i = 0; i < 3; i++) {
        /* restore PMATCH */
        for (i = 0; i < 3; i++) {

-               writel(i*2, dev->base_addr + RxFilterAddr);
-               writew(pmatch[i], dev->base_addr + RxFilterData);
+               writel(i*2, ioaddr + RxFilterAddr);
+               writew(pmatch[i], ioaddr + RxFilterData);

        }
        for (i = 0; i < 3; i++) {
        }
        for (i = 0; i < 3; i++) {

-               writel(0xa+(i*2), dev->base_addr + RxFilterAddr);
-               writew(sopass[i], dev->base_addr + RxFilterData);
+               writel(0xa+(i*2), ioaddr + RxFilterAddr);
+               writew(sopass[i], ioaddr + RxFilterData);

        }
        /* restore RFCR */
        }
        /* restore RFCR */

-       writel(rfcr, dev->base_addr + RxFilterAddr);
+       writel(rfcr, ioaddr + RxFilterAddr);
+}
+
+static void reset_rx(struct net_device *dev)
+{
+       int i;
+       struct netdev_private *np = netdev_priv(dev);
+       void __iomem *ioaddr = ns_ioaddr(dev);
+
+       np->intr_status &= ~RxResetDone;
+
+       writel(RxReset, ioaddr + ChipCmd);
+
+       for (i=0;i<NATSEMI_HW_TIMEOUT;i++) {
+               np->intr_status |= readl(ioaddr + IntrStatus);
+               if (np->intr_status & RxResetDone)
+                       break;
+               udelay(15);
+       }
+       if (i==NATSEMI_HW_TIMEOUT) {
+               printk(KERN_WARNING "%s: RX reset did not complete in %d usec.\n",
+                      dev->name, i*15);
+       } else if (netif_msg_hw(np)) {
+               printk(KERN_WARNING "%s: RX reset took %d usec.\n",
+                      dev->name, i*15);
+       }

 }
 
 static void natsemi_reload_eeprom(struct net_device *dev)
 {
        struct netdev_private *np = netdev_priv(dev);
 }
 
 static void natsemi_reload_eeprom(struct net_device *dev)
 {
        struct netdev_private *np = netdev_priv(dev);

+       void __iomem *ioaddr = ns_ioaddr(dev);

        int i;
 
        int i;
 

-       writel(EepromReload, dev->base_addr + PCIBusCfg);
+       writel(EepromReload, ioaddr + PCIBusCfg);

        for (i=0;i<NATSEMI_HW_TIMEOUT;i++) {
                udelay(50);
        for (i=0;i<NATSEMI_HW_TIMEOUT;i++) {
                udelay(50);

-               if (!(readl(dev->base_addr + PCIBusCfg) & EepromReload))
+               if (!(readl(ioaddr + PCIBusCfg) & EepromReload))

                        break;
        }
        if (i==NATSEMI_HW_TIMEOUT) {
                        break;
        }
        if (i==NATSEMI_HW_TIMEOUT) {


@@ -1481,7 +1435,7 @@ static void natsemi_reload_eeprom(struct net_device *dev)
 
 static void natsemi_stop_rxtx(struct net_device *dev)
 {
 
 static void natsemi_stop_rxtx(struct net_device *dev)
 {

-       long ioaddr = dev->base_addr;
+       void __iomem * ioaddr = ns_ioaddr(dev);

        struct netdev_private *np = netdev_priv(dev);
        int i;
 
        struct netdev_private *np = netdev_priv(dev);
        int i;
 


@@ -1503,13 +1457,13 @@ static void natsemi_stop_rxtx(struct net_device *dev)
 static int netdev_open(struct net_device *dev)
 {
        struct netdev_private *np = netdev_priv(dev);
 static int netdev_open(struct net_device *dev)
 {
        struct netdev_private *np = netdev_priv(dev);

-       long ioaddr = dev->base_addr;
+       void __iomem * ioaddr = ns_ioaddr(dev);

        int i;
 
        /* Reset the chip, just in case. */
        natsemi_reset(dev);
 
        int i;
 
        /* Reset the chip, just in case. */
        natsemi_reset(dev);
 

-       i = request_irq(dev->irq, &intr_handler, SA_SHIRQ, dev->name, dev);
+       i = request_irq(dev->irq, &intr_handler, IRQF_SHARED, dev->name, dev);

        if (i) return i;
 
        if (netif_msg_ifup(np))
        if (i) return i;
 
        if (netif_msg_ifup(np))


@@ -1552,6 +1506,7 @@ static int netdev_open(struct net_device *dev)
 static void do_cable_magic(struct net_device *dev)
 {
        struct netdev_private *np = netdev_priv(dev);
 static void do_cable_magic(struct net_device *dev)
 {
        struct netdev_private *np = netdev_priv(dev);

+       void __iomem *ioaddr = ns_ioaddr(dev);

 
        if (dev->if_port != PORT_TP)
                return;
 
        if (dev->if_port != PORT_TP)
                return;


@@ -1565,15 +1520,15 @@ static void do_cable_magic(struct net_device *dev)
         * activity LED while idle.  This process is based on instructions
         * from engineers at National.
         */
         * activity LED while idle.  This process is based on instructions
         * from engineers at National.
         */

-       if (readl(dev->base_addr + ChipConfig) & CfgSpeed100) {
+       if (readl(ioaddr + ChipConfig) & CfgSpeed100) {

                u16 data;
 
                u16 data;
 

-               writew(1, dev->base_addr + PGSEL);
+               writew(1, ioaddr + PGSEL);

                /*
                 * coefficient visibility should already be enabled via
                 * DSPCFG | 0x1000
                 */
                /*
                 * coefficient visibility should already be enabled via
                 * DSPCFG | 0x1000
                 */

-               data = readw(dev->base_addr + TSTDAT) & 0xff;
+               data = readw(ioaddr + TSTDAT) & 0xff;

                /*
                 * the value must be negative, and within certain values
                 * (these values all come from National)
                /*
                 * the value must be negative, and within certain values
                 * (these values all come from National)


@@ -1582,13 +1537,13 @@ static void do_cable_magic(struct net_device *dev)
                        struct netdev_private *np = netdev_priv(dev);
 
                        /* the bug has been triggered - fix the coefficient */
                        struct netdev_private *np = netdev_priv(dev);
 
                        /* the bug has been triggered - fix the coefficient */

-                       writew(TSTDAT_FIXED, dev->base_addr + TSTDAT);
+                       writew(TSTDAT_FIXED, ioaddr + TSTDAT);

                        /* lock the value */
                        /* lock the value */

-                       data = readw(dev->base_addr + DSPCFG);
+                       data = readw(ioaddr + DSPCFG);

                        np->dspcfg = data | DSPCFG_LOCK;
                        np->dspcfg = data | DSPCFG_LOCK;

-                       writew(np->dspcfg, dev->base_addr + DSPCFG);
+                       writew(np->dspcfg, ioaddr + DSPCFG);

                }
                }

-               writew(0, dev->base_addr + PGSEL);
+               writew(0, ioaddr + PGSEL);

        }
 }
 
        }
 }
 


@@ -1596,6 +1551,7 @@ static void undo_cable_magic(struct net_device *dev)
 {
        u16 data;
        struct netdev_private *np = netdev_priv(dev);
 {
        u16 data;
        struct netdev_private *np = netdev_priv(dev);

+       void __iomem * ioaddr = ns_ioaddr(dev);

 
        if (dev->if_port != PORT_TP)
                return;
 
        if (dev->if_port != PORT_TP)
                return;


@@ -1603,21 +1559,21 @@ static void undo_cable_magic(struct net_device *dev)
        if (np->srr >= SRR_DP83816_A5)
                return;
 
        if (np->srr >= SRR_DP83816_A5)
                return;
 

-       writew(1, dev->base_addr + PGSEL);
+       writew(1, ioaddr + PGSEL);

        /* make sure the lock bit is clear */
        /* make sure the lock bit is clear */

-       data = readw(dev->base_addr + DSPCFG);
+       data = readw(ioaddr + DSPCFG);

        np->dspcfg = data & ~DSPCFG_LOCK;
        np->dspcfg = data & ~DSPCFG_LOCK;

-       writew(np->dspcfg, dev->base_addr + DSPCFG);
-       writew(0, dev->base_addr + PGSEL);
+       writew(np->dspcfg, ioaddr + DSPCFG);
+       writew(0, ioaddr + PGSEL);

 }
 
 static void check_link(struct net_device *dev)
 {
        struct netdev_private *np = netdev_priv(dev);
 }
 
 static void check_link(struct net_device *dev)
 {
        struct netdev_private *np = netdev_priv(dev);

-       long ioaddr = dev->base_addr;
+       void __iomem * ioaddr = ns_ioaddr(dev);

        int duplex;
        u16 bmsr;
        int duplex;
        u16 bmsr;

-       
+

        /* The link status field is latched: it remains low after a temporary
         * link failure until it's read. We need the current link status,
         * thus read twice.
        /* The link status field is latched: it remains low after a temporary
         * link failure until it's read. We need the current link status,
         * thus read twice.


@@ -1675,7 +1631,7 @@ static void check_link(struct net_device *dev)
 static void init_registers(struct net_device *dev)
 {
        struct netdev_private *np = netdev_priv(dev);
 static void init_registers(struct net_device *dev)
 {
        struct netdev_private *np = netdev_priv(dev);

-       long ioaddr = dev->base_addr;
+       void __iomem * ioaddr = ns_ioaddr(dev);

 
        init_phy_fixup(dev);
 
 
        init_phy_fixup(dev);
 


@@ -1754,6 +1710,7 @@ static void netdev_timer(unsigned long data)
 {
        struct net_device *dev = (struct net_device *)data;
        struct netdev_private *np = netdev_priv(dev);
 {
        struct net_device *dev = (struct net_device *)data;
        struct netdev_private *np = netdev_priv(dev);

+       void __iomem * ioaddr = ns_ioaddr(dev);

        int next_tick = 5*HZ;
 
        if (netif_msg_timer(np)) {
        int next_tick = 5*HZ;
 
        if (netif_msg_timer(np)) {


@@ -1765,7 +1722,6 @@ static void netdev_timer(unsigned long data)
        }
 
        if (dev->if_port == PORT_TP) {
        }
 
        if (dev->if_port == PORT_TP) {

-               long ioaddr = dev->base_addr;

                u16 dspcfg;
 
                spin_lock_irq(&np->lock);
                u16 dspcfg;
 
                spin_lock_irq(&np->lock);


@@ -1808,7 +1764,7 @@ static void netdev_timer(unsigned long data)
                refill_rx(dev);
                enable_irq(dev->irq);
                if (!np->oom) {
                refill_rx(dev);
                enable_irq(dev->irq);
                if (!np->oom) {

-                       writel(RxOn, dev->base_addr + ChipCmd);
+                       writel(RxOn, ioaddr + ChipCmd);

                } else {
                        next_tick = 1;
                }
                } else {
                        next_tick = 1;
                }


@@ -1842,7 +1798,7 @@ static void dump_ring(struct net_device *dev)
 static void tx_timeout(struct net_device *dev)
 {
        struct netdev_private *np = netdev_priv(dev);
 static void tx_timeout(struct net_device *dev)
 {
        struct netdev_private *np = netdev_priv(dev);

-       long ioaddr = dev->base_addr;
+       void __iomem * ioaddr = ns_ioaddr(dev);

 
        disable_irq(dev->irq);
        spin_lock_irq(&np->lock);
 
        disable_irq(dev->irq);
        spin_lock_irq(&np->lock);


@@ -1898,7 +1854,7 @@ static void refill_rx(struct net_device *dev)
                                break; /* Better luck next round. */
                        skb->dev = dev; /* Mark as being used by this device. */
                        np->rx_dma[entry] = pci_map_single(np->pci_dev,
                                break; /* Better luck next round. */
                        skb->dev = dev; /* Mark as being used by this device. */
                        np->rx_dma[entry] = pci_map_single(np->pci_dev,

-                               skb->tail, buflen, PCI_DMA_FROMDEVICE);
+                               skb->data, buflen, PCI_DMA_FROMDEVICE);

                        np->rx_ring[entry].addr = cpu_to_le32(np->rx_dma[entry]);
                }
                np->rx_ring[entry].cmd_status = cpu_to_le32(np->rx_buf_sz);
                        np->rx_ring[entry].addr = cpu_to_le32(np->rx_dma[entry]);
                }
                np->rx_ring[entry].cmd_status = cpu_to_le32(np->rx_buf_sz);


@@ -2042,6 +1998,7 @@ static void reinit_ring(struct net_device *dev)
 static int start_tx(struct sk_buff *skb, struct net_device *dev)
 {
        struct netdev_private *np = netdev_priv(dev);
 static int start_tx(struct sk_buff *skb, struct net_device *dev)
 {
        struct netdev_private *np = netdev_priv(dev);

+       void __iomem * ioaddr = ns_ioaddr(dev);

        unsigned entry;
 
        /* Note: Ordering is important here, set the field with the
        unsigned entry;
 
        /* Note: Ordering is important here, set the field with the


@@ -2070,7 +2027,7 @@ static int start_tx(struct sk_buff *skb, struct net_device *dev)
                                netif_stop_queue(dev);
                }
                /* Wake the potentially-idle transmit channel. */
                                netif_stop_queue(dev);
                }
                /* Wake the potentially-idle transmit channel. */

-               writel(TxOn, dev->base_addr + ChipCmd);
+               writel(TxOn, ioaddr + ChipCmd);

        } else {
                dev_kfree_skb_irq(skb);
                np->stats.tx_dropped++;
        } else {
                dev_kfree_skb_irq(skb);
                np->stats.tx_dropped++;


@@ -2129,74 +2086,99 @@ static void netdev_tx_done(struct net_device *dev)
        }
 }
 
        }
 }
 

-/* The interrupt handler does all of the Rx thread work and cleans up
-   after the Tx thread. */
-static irqreturn_t intr_handler(int irq, void *dev_instance, struct pt_regs *rgs)
+/* The interrupt handler doesn't actually handle interrupts itself, it
+ * schedules a NAPI poll if there is anything to do. */
+static irqreturn_t intr_handler(int irq, void *dev_instance)

 {
        struct net_device *dev = dev_instance;
        struct netdev_private *np = netdev_priv(dev);
 {
        struct net_device *dev = dev_instance;
        struct netdev_private *np = netdev_priv(dev);

-       long ioaddr = dev->base_addr;
-       int boguscnt = max_interrupt_work;
-       unsigned int handled = 0;
+       void __iomem * ioaddr = ns_ioaddr(dev);

 
        if (np->hands_off)
                return IRQ_NONE;
 
        if (np->hands_off)
                return IRQ_NONE;

-       do {
-               /* Reading automatically acknowledges all int sources. */
-               u32 intr_status = readl(ioaddr + IntrStatus);

 
 

-               if (netif_msg_intr(np))
-                       printk(KERN_DEBUG
-                               "%s: Interrupt, status %#08x, mask %#08x.\n",
-                               dev->name, intr_status,
-                               readl(ioaddr + IntrMask));
+       /* Reading automatically acknowledges. */
+       np->intr_status = readl(ioaddr + IntrStatus);

 
 

-               if (intr_status == 0)
-                       break;
-               handled = 1;
+       if (netif_msg_intr(np))
+               printk(KERN_DEBUG
+                      "%s: Interrupt, status %#08x, mask %#08x.\n",
+                      dev->name, np->intr_status,
+                      readl(ioaddr + IntrMask));

 
 

-               if (intr_status &
-                  (IntrRxDone | IntrRxIntr | RxStatusFIFOOver |
-                   IntrRxErr | IntrRxOverrun)) {
-                       netdev_rx(dev);
-               }
+       if (!np->intr_status)
+               return IRQ_NONE;
+
+       prefetch(&np->rx_skbuff[np->cur_rx % RX_RING_SIZE]);
+
+       if (netif_rx_schedule_prep(dev)) {
+               /* Disable interrupts and register for poll */
+               natsemi_irq_disable(dev);
+               __netif_rx_schedule(dev);
+       }
+       return IRQ_HANDLED;
+}
+
+/* This is the NAPI poll routine.  As well as the standard RX handling
+ * it also handles all other interrupts that the chip might raise.
+ */
+static int natsemi_poll(struct net_device *dev, int *budget)
+{
+       struct netdev_private *np = netdev_priv(dev);
+       void __iomem * ioaddr = ns_ioaddr(dev);
+
+       int work_to_do = min(*budget, dev->quota);
+       int work_done = 0;

 
 

-               if (intr_status &
-                  (IntrTxDone | IntrTxIntr | IntrTxIdle | IntrTxErr)) {
+       do {
+               if (np->intr_status &
+                   (IntrTxDone | IntrTxIntr | IntrTxIdle | IntrTxErr)) {

                        spin_lock(&np->lock);
                        netdev_tx_done(dev);
                        spin_unlock(&np->lock);
                }
 
                /* Abnormal error summary/uncommon events handlers. */
                        spin_lock(&np->lock);
                        netdev_tx_done(dev);
                        spin_unlock(&np->lock);
                }
 
                /* Abnormal error summary/uncommon events handlers. */

-               if (intr_status & IntrAbnormalSummary)
-                       netdev_error(dev, intr_status);
-
-               if (--boguscnt < 0) {
-                       if (netif_msg_intr(np))
-                               printk(KERN_WARNING
-                                       "%s: Too much work at interrupt, "
-                                       "status=%#08x.\n",
-                                       dev->name, intr_status);
-                       break;
+               if (np->intr_status & IntrAbnormalSummary)
+                       netdev_error(dev, np->intr_status);
+
+               if (np->intr_status &
+                   (IntrRxDone | IntrRxIntr | RxStatusFIFOOver |
+                    IntrRxErr | IntrRxOverrun)) {
+                       netdev_rx(dev, &work_done, work_to_do);

                }
                }

-       } while (1);

 
 

-       if (netif_msg_intr(np))
-               printk(KERN_DEBUG "%s: exiting interrupt.\n", dev->name);
+               *budget -= work_done;
+               dev->quota -= work_done;
+
+               if (work_done >= work_to_do)
+                       return 1;
+
+               np->intr_status = readl(ioaddr + IntrStatus);
+       } while (np->intr_status);

 
 

-       return IRQ_RETVAL(handled);
+       netif_rx_complete(dev);
+
+       /* Reenable interrupts providing nothing is trying to shut
+        * the chip down. */
+       spin_lock(&np->lock);
+       if (!np->hands_off && netif_running(dev))
+               natsemi_irq_enable(dev);
+       spin_unlock(&np->lock);
+
+       return 0;

 }
 
 /* This routine is logically part of the interrupt handler, but separated
    for clarity and better register allocation. */
 }
 
 /* This routine is logically part of the interrupt handler, but separated
    for clarity and better register allocation. */

-static void netdev_rx(struct net_device *dev)
+static void netdev_rx(struct net_device *dev, int *work_done, int work_to_do)

 {
        struct netdev_private *np = netdev_priv(dev);
        int entry = np->cur_rx % RX_RING_SIZE;
        int boguscnt = np->dirty_rx + RX_RING_SIZE - np->cur_rx;
        s32 desc_status = le32_to_cpu(np->rx_head_desc->cmd_status);
        unsigned int buflen = np->rx_buf_sz;
 {
        struct netdev_private *np = netdev_priv(dev);
        int entry = np->cur_rx % RX_RING_SIZE;
        int boguscnt = np->dirty_rx + RX_RING_SIZE - np->cur_rx;
        s32 desc_status = le32_to_cpu(np->rx_head_desc->cmd_status);
        unsigned int buflen = np->rx_buf_sz;

+       void __iomem * ioaddr = ns_ioaddr(dev);

 
        /* If the driver owns the next entry it's a new packet. Send it up. */
        while (desc_status < 0) { /* e.g. & DescOwn */
 
        /* If the driver owns the next entry it's a new packet. Send it up. */
        while (desc_status < 0) { /* e.g. & DescOwn */


@@ -2207,6 +2189,12 @@ static void netdev_rx(struct net_device *dev)
                                entry, desc_status);
                if (--boguscnt < 0)
                        break;
                                entry, desc_status);
                if (--boguscnt < 0)
                        break;

+
+               if (*work_done >= work_to_do)
+                       break;
+
+               (*work_done)++;
+

                pkt_len = (desc_status & DescSizeMask) - 4;
                if ((desc_status&(DescMore|DescPktOK|DescRxLong)) != DescPktOK){
                        if (desc_status & DescMore) {
                pkt_len = (desc_status & DescSizeMask) - 4;
                if ((desc_status&(DescMore|DescPktOK|DescRxLong)) != DescPktOK){
                        if (desc_status & DescMore) {


@@ -2218,6 +2206,23 @@ static void netdev_rx(struct net_device *dev)
                                                "status %#08x.\n", dev->name,
                                                np->cur_rx, desc_status);
                                np->stats.rx_length_errors++;
                                                "status %#08x.\n", dev->name,
                                                np->cur_rx, desc_status);
                                np->stats.rx_length_errors++;

+
+                               /* The RX state machine has probably
+                                * locked up beneath us.  Follow the
+                                * reset procedure documented in
+                                * AN-1287. */
+
+                               spin_lock_irq(&np->lock);
+                               reset_rx(dev);
+                               reinit_rx(dev);
+                               writel(np->ring_dma, ioaddr + RxRingPtr);
+                               check_link(dev);
+                               spin_unlock_irq(&np->lock);
+
+                               /* We'll enable RX on exit from this
+                                * function. */
+                               break;
+

                        } else {
                                /* There was an error. */
                                np->stats.rx_errors++;
                        } else {
                                /* There was an error. */
                                np->stats.rx_errors++;


@@ -2250,7 +2255,7 @@ static void netdev_rx(struct net_device *dev)
                                        buflen,
                                        PCI_DMA_FROMDEVICE);
                                eth_copy_and_sum(skb,
                                        buflen,
                                        PCI_DMA_FROMDEVICE);
                                eth_copy_and_sum(skb,

-                                       np->rx_skbuff[entry]->tail, pkt_len, 0);
+                                       np->rx_skbuff[entry]->data, pkt_len, 0);

                                skb_put(skb, pkt_len);
                                pci_dma_sync_single_for_device(np->pci_dev,
                                        np->rx_dma[entry],
                                skb_put(skb, pkt_len);
                                pci_dma_sync_single_for_device(np->pci_dev,
                                        np->rx_dma[entry],


@@ -2263,7 +2268,7 @@ static void netdev_rx(struct net_device *dev)
                                np->rx_skbuff[entry] = NULL;
                        }
                        skb->protocol = eth_type_trans(skb, dev);
                                np->rx_skbuff[entry] = NULL;
                        }
                        skb->protocol = eth_type_trans(skb, dev);

-                       netif_rx(skb);
+                       netif_receive_skb(skb);

                        dev->last_rx = jiffies;
                        np->stats.rx_packets++;
                        np->stats.rx_bytes += pkt_len;
                        dev->last_rx = jiffies;
                        np->stats.rx_packets++;
                        np->stats.rx_bytes += pkt_len;


@@ -2278,13 +2283,13 @@ static void netdev_rx(struct net_device *dev)
        if (np->oom)
                mod_timer(&np->timer, jiffies + 1);
        else
        if (np->oom)
                mod_timer(&np->timer, jiffies + 1);
        else

-               writel(RxOn, dev->base_addr + ChipCmd);
+               writel(RxOn, ioaddr + ChipCmd);

 }
 
 static void netdev_error(struct net_device *dev, int intr_status)
 {
        struct netdev_private *np = netdev_priv(dev);
 }
 
 static void netdev_error(struct net_device *dev, int intr_status)
 {
        struct netdev_private *np = netdev_priv(dev);

-       long ioaddr = dev->base_addr;
+       void __iomem * ioaddr = ns_ioaddr(dev);

 
        spin_lock(&np->lock);
        if (intr_status & LinkChange) {
 
        spin_lock(&np->lock);
        if (intr_status & LinkChange) {


@@ -2343,7 +2348,7 @@ static void netdev_error(struct net_device *dev, int intr_status)
 
 static void __get_stats(struct net_device *dev)
 {
 
 static void __get_stats(struct net_device *dev)
 {

-       long ioaddr = dev->base_addr;
+       void __iomem * ioaddr = ns_ioaddr(dev);

        struct netdev_private *np = netdev_priv(dev);
 
        /* The chip only need report frame silently dropped. */
        struct netdev_private *np = netdev_priv(dev);
 
        /* The chip only need report frame silently dropped. */


@@ -2364,18 +2369,24 @@ static struct net_device_stats *get_stats(struct net_device *dev)
        return &np->stats;
 }
 
        return &np->stats;
 }
 

+#ifdef CONFIG_NET_POLL_CONTROLLER
+static void natsemi_poll_controller(struct net_device *dev)
+{
+       disable_irq(dev->irq);
+       intr_handler(dev->irq, dev);
+       enable_irq(dev->irq);
+}
+#endif
+

 #define HASH_TABLE     0x200
 static void __set_rx_mode(struct net_device *dev)
 {
 #define HASH_TABLE     0x200
 static void __set_rx_mode(struct net_device *dev)
 {

-       long ioaddr = dev->base_addr;
+       void __iomem * ioaddr = ns_ioaddr(dev);

        struct netdev_private *np = netdev_priv(dev);
        u8 mc_filter[64]; /* Multicast hash filter */
        u32 rx_mode;
 
        if (dev->flags & IFF_PROMISC) { /* Set promiscuous. */
        struct netdev_private *np = netdev_priv(dev);
        u8 mc_filter[64]; /* Multicast hash filter */
        u32 rx_mode;
 
        if (dev->flags & IFF_PROMISC) { /* Set promiscuous. */

-               /* Unconditionally log net taps. */
-               printk(KERN_NOTICE "%s: Promiscuous mode enabled.\n",
-                       dev->name);

                rx_mode = RxFilterEnable | AcceptBroadcast
                        | AcceptAllMulticast | AcceptAllPhys | AcceptMyPhys;
        } else if ((dev->mc_count > multicast_filter_limit)
                rx_mode = RxFilterEnable | AcceptBroadcast
                        | AcceptAllMulticast | AcceptAllPhys | AcceptMyPhys;
        } else if ((dev->mc_count > multicast_filter_limit)


@@ -2394,9 +2405,9 @@ static void __set_rx_mode(struct net_device *dev)
                rx_mode = RxFilterEnable | AcceptBroadcast
                        | AcceptMulticast | AcceptMyPhys;
                for (i = 0; i < 64; i += 2) {
                rx_mode = RxFilterEnable | AcceptBroadcast
                        | AcceptMulticast | AcceptMyPhys;
                for (i = 0; i < 64; i += 2) {

-                       writew(HASH_TABLE + i, ioaddr + RxFilterAddr);
-                       writew((mc_filter[i+1]<<8) + mc_filter[i],
-                               ioaddr + RxFilterData);
+                       writel(HASH_TABLE + i, ioaddr + RxFilterAddr);
+                       writel((mc_filter[i + 1] << 8) + mc_filter[i],
+                              ioaddr + RxFilterData);

                }
        }
        writel(rx_mode, ioaddr + RxFilterAddr);
                }
        }
        writel(rx_mode, ioaddr + RxFilterAddr);


@@ -2413,7 +2424,7 @@ static int natsemi_change_mtu(struct net_device *dev, int new_mtu)
        /* synchronized against open : rtnl_lock() held by caller */
        if (netif_running(dev)) {
                struct netdev_private *np = netdev_priv(dev);
        /* synchronized against open : rtnl_lock() held by caller */
        if (netif_running(dev)) {
                struct netdev_private *np = netdev_priv(dev);

-               long ioaddr = dev->base_addr;
+               void __iomem * ioaddr = ns_ioaddr(dev);

 
                disable_irq(dev->irq);
                spin_lock(&np->lock);
 
                disable_irq(dev->irq);
                spin_lock(&np->lock);


@@ -2442,181 +2453,147 @@ static void set_rx_mode(struct net_device *dev)
        spin_unlock_irq(&np->lock);
 }
 
        spin_unlock_irq(&np->lock);
 }
 

-static int netdev_ethtool_ioctl(struct net_device *dev, void __user *useraddr)
+static void get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)

 {
        struct netdev_private *np = netdev_priv(dev);
 {
        struct netdev_private *np = netdev_priv(dev);

-       u32 cmd;
+       strncpy(info->driver, DRV_NAME, ETHTOOL_BUSINFO_LEN);
+       strncpy(info->version, DRV_VERSION, ETHTOOL_BUSINFO_LEN);
+       strncpy(info->bus_info, pci_name(np->pci_dev), ETHTOOL_BUSINFO_LEN);
+}

 
 

-       if (get_user(cmd, (u32 __user *)useraddr))
-               return -EFAULT;
-
-       switch (cmd) {
-       /* get driver info */
-       case ETHTOOL_GDRVINFO: {
-               struct ethtool_drvinfo info = {ETHTOOL_GDRVINFO};
-               strncpy(info.driver, DRV_NAME, ETHTOOL_BUSINFO_LEN);
-               strncpy(info.version, DRV_VERSION, ETHTOOL_BUSINFO_LEN);
-               info.fw_version[0] = '\0';
-               strncpy(info.bus_info, pci_name(np->pci_dev),
-                       ETHTOOL_BUSINFO_LEN);
-               info.eedump_len = NATSEMI_EEPROM_SIZE;
-               info.regdump_len = NATSEMI_REGS_SIZE;
-               if (copy_to_user(useraddr, &info, sizeof(info)))
-                       return -EFAULT;
-               return 0;
-       }
-       /* get settings */
-       case ETHTOOL_GSET: {
-               struct ethtool_cmd ecmd = { ETHTOOL_GSET };
-               spin_lock_irq(&np->lock);
-               netdev_get_ecmd(dev, &ecmd);
-               spin_unlock_irq(&np->lock);
-               if (copy_to_user(useraddr, &ecmd, sizeof(ecmd)))
-                       return -EFAULT;
-               return 0;
-       }
-       /* set settings */
-       case ETHTOOL_SSET: {
-               struct ethtool_cmd ecmd;
-               int r;
-               if (copy_from_user(&ecmd, useraddr, sizeof(ecmd)))
-                       return -EFAULT;
-               spin_lock_irq(&np->lock);
-               r = netdev_set_ecmd(dev, &ecmd);
-               spin_unlock_irq(&np->lock);
-               return r;
-       }
-       /* get wake-on-lan */
-       case ETHTOOL_GWOL: {
-               struct ethtool_wolinfo wol = {ETHTOOL_GWOL};
-               spin_lock_irq(&np->lock);
-               netdev_get_wol(dev, &wol.supported, &wol.wolopts);
-               netdev_get_sopass(dev, wol.sopass);
-               spin_unlock_irq(&np->lock);
-               if (copy_to_user(useraddr, &wol, sizeof(wol)))
-                       return -EFAULT;
-               return 0;
-       }
-       /* set wake-on-lan */
-       case ETHTOOL_SWOL: {
-               struct ethtool_wolinfo wol;
-               int r;
-               if (copy_from_user(&wol, useraddr, sizeof(wol)))
-                       return -EFAULT;
-               spin_lock_irq(&np->lock);
-               netdev_set_wol(dev, wol.wolopts);
-               r = netdev_set_sopass(dev, wol.sopass);
-               spin_unlock_irq(&np->lock);
-               return r;
-       }
-       /* get registers */
-       case ETHTOOL_GREGS: {
-               struct ethtool_regs regs;
-               u8 regbuf[NATSEMI_REGS_SIZE];
-               int r;
+static int get_regs_len(struct net_device *dev)
+{
+       return NATSEMI_REGS_SIZE;
+}

 
 

-               if (copy_from_user(&regs, useraddr, sizeof(regs)))
-                       return -EFAULT;
+static int get_eeprom_len(struct net_device *dev)
+{
+       struct netdev_private *np = netdev_priv(dev);
+       return np->eeprom_size;
+}

 
 

-               if (regs.len > NATSEMI_REGS_SIZE) {
-                       regs.len = NATSEMI_REGS_SIZE;
-               }
-               regs.version = NATSEMI_REGS_VER;
-               if (copy_to_user(useraddr, &regs, sizeof(regs)))
-                       return -EFAULT;
+static int get_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
+{
+       struct netdev_private *np = netdev_priv(dev);
+       spin_lock_irq(&np->lock);
+       netdev_get_ecmd(dev, ecmd);
+       spin_unlock_irq(&np->lock);
+       return 0;
+}

 
 

-               useraddr += offsetof(struct ethtool_regs, data);
+static int set_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
+{
+       struct netdev_private *np = netdev_priv(dev);
+       int res;
+       spin_lock_irq(&np->lock);
+       res = netdev_set_ecmd(dev, ecmd);
+       spin_unlock_irq(&np->lock);
+       return res;
+}

 
 

-               spin_lock_irq(&np->lock);
-               r = netdev_get_regs(dev, regbuf);
-               spin_unlock_irq(&np->lock);
+static void get_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
+{
+       struct netdev_private *np = netdev_priv(dev);
+       spin_lock_irq(&np->lock);
+       netdev_get_wol(dev, &wol->supported, &wol->wolopts);
+       netdev_get_sopass(dev, wol->sopass);
+       spin_unlock_irq(&np->lock);
+}

 
 

-               if (r)
-                       return r;
-               if (copy_to_user(useraddr, regbuf, regs.len))
-                       return -EFAULT;
-               return 0;
-       }
-       /* get message-level */
-       case ETHTOOL_GMSGLVL: {
-               struct ethtool_value edata = {ETHTOOL_GMSGLVL};
-               edata.data = np->msg_enable;
-               if (copy_to_user(useraddr, &edata, sizeof(edata)))
-                       return -EFAULT;
-               return 0;
-       }
-       /* set message-level */
-       case ETHTOOL_SMSGLVL: {
-               struct ethtool_value edata;
-               if (copy_from_user(&edata, useraddr, sizeof(edata)))
-                       return -EFAULT;
-               np->msg_enable = edata.data;
-               return 0;
-       }
-       /* restart autonegotiation */
-       case ETHTOOL_NWAY_RST: {
-               int tmp;
-               int r = -EINVAL;
-               /* if autoneg is off, it's an error */
-               tmp = mdio_read(dev, MII_BMCR);
-               if (tmp & BMCR_ANENABLE) {
-                       tmp |= (BMCR_ANRESTART);
-                       mdio_write(dev, MII_BMCR, tmp);
-                       r = 0;
-               }
-               return r;
-       }
-       /* get link status */
-       case ETHTOOL_GLINK: {
-               struct ethtool_value edata = {ETHTOOL_GLINK};
-               /* LSTATUS is latched low until a read - so read twice */
-               mdio_read(dev, MII_BMSR);
-               edata.data = (mdio_read(dev, MII_BMSR)&BMSR_LSTATUS) ? 1:0;
-               if (copy_to_user(useraddr, &edata, sizeof(edata)))
-                       return -EFAULT;
-               return 0;
-       }
-       /* get EEPROM */
-       case ETHTOOL_GEEPROM: {
-               struct ethtool_eeprom eeprom;
-               u8 eebuf[NATSEMI_EEPROM_SIZE];
-               int r;
+static int set_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
+{
+       struct netdev_private *np = netdev_priv(dev);
+       int res;
+       spin_lock_irq(&np->lock);
+       netdev_set_wol(dev, wol->wolopts);
+       res = netdev_set_sopass(dev, wol->sopass);
+       spin_unlock_irq(&np->lock);
+       return res;
+}

 
 

-               if (copy_from_user(&eeprom, useraddr, sizeof(eeprom)))
-                       return -EFAULT;
+static void get_regs(struct net_device *dev, struct ethtool_regs *regs, void *buf)
+{
+       struct netdev_private *np = netdev_priv(dev);
+       regs->version = NATSEMI_REGS_VER;
+       spin_lock_irq(&np->lock);
+       netdev_get_regs(dev, buf);
+       spin_unlock_irq(&np->lock);
+}

 
 

-               if (eeprom.offset > eeprom.offset+eeprom.len)
-                       return -EINVAL;
+static u32 get_msglevel(struct net_device *dev)
+{
+       struct netdev_private *np = netdev_priv(dev);
+       return np->msg_enable;
+}

 
 

-               if ((eeprom.offset+eeprom.len) > NATSEMI_EEPROM_SIZE) {
-                       eeprom.len = NATSEMI_EEPROM_SIZE-eeprom.offset;
-               }
-               eeprom.magic = PCI_VENDOR_ID_NS | (PCI_DEVICE_ID_NS_83815<<16);
-               if (copy_to_user(useraddr, &eeprom, sizeof(eeprom)))
-                       return -EFAULT;
+static void set_msglevel(struct net_device *dev, u32 val)
+{
+       struct netdev_private *np = netdev_priv(dev);
+       np->msg_enable = val;
+}

 
 

-               useraddr += offsetof(struct ethtool_eeprom, data);
+static int nway_reset(struct net_device *dev)
+{
+       int tmp;
+       int r = -EINVAL;
+       /* if autoneg is off, it's an error */
+       tmp = mdio_read(dev, MII_BMCR);
+       if (tmp & BMCR_ANENABLE) {
+               tmp |= (BMCR_ANRESTART);
+               mdio_write(dev, MII_BMCR, tmp);
+               r = 0;
+       }
+       return r;
+}

 
 

-               spin_lock_irq(&np->lock);
-               r = netdev_get_eeprom(dev, eebuf);
-               spin_unlock_irq(&np->lock);
+static u32 get_link(struct net_device *dev)
+{
+       /* LSTATUS is latched low until a read - so read twice */
+       mdio_read(dev, MII_BMSR);
+       return (mdio_read(dev, MII_BMSR)&BMSR_LSTATUS) ? 1:0;
+}

 
 

-               if (r)
-                       return r;
-               if (copy_to_user(useraddr, eebuf+eeprom.offset, eeprom.len))
-                       return -EFAULT;
-               return 0;
-       }
+static int get_eeprom(struct net_device *dev, struct ethtool_eeprom *eeprom, u8 *data)
+{
+       struct netdev_private *np = netdev_priv(dev);
+       u8 *eebuf;
+       int res;

 
 

-       }
+       eebuf = kmalloc(np->eeprom_size, GFP_KERNEL);
+       if (!eebuf)
+               return -ENOMEM;

 
 

-       return -EOPNOTSUPP;
+       eeprom->magic = PCI_VENDOR_ID_NS | (PCI_DEVICE_ID_NS_83815<<16);
+       spin_lock_irq(&np->lock);
+       res = netdev_get_eeprom(dev, eebuf);
+       spin_unlock_irq(&np->lock);
+       if (!res)
+               memcpy(data, eebuf+eeprom->offset, eeprom->len);
+       kfree(eebuf);
+       return res;

 }
 
 }
 

+static const struct ethtool_ops ethtool_ops = {
+       .get_drvinfo = get_drvinfo,
+       .get_regs_len = get_regs_len,
+       .get_eeprom_len = get_eeprom_len,
+       .get_settings = get_settings,
+       .set_settings = set_settings,
+       .get_wol = get_wol,
+       .set_wol = set_wol,
+       .get_regs = get_regs,
+       .get_msglevel = get_msglevel,
+       .set_msglevel = set_msglevel,
+       .nway_reset = nway_reset,
+       .get_link = get_link,
+       .get_eeprom = get_eeprom,
+};
+

 static int netdev_set_wol(struct net_device *dev, u32 newval)
 {
        struct netdev_private *np = netdev_priv(dev);
 static int netdev_set_wol(struct net_device *dev, u32 newval)
 {
        struct netdev_private *np = netdev_priv(dev);

-       u32 data = readl(dev->base_addr + WOLCmd) & ~WakeOptsSummary;
+       void __iomem * ioaddr = ns_ioaddr(dev);
+       u32 data = readl(ioaddr + WOLCmd) & ~WakeOptsSummary;

 
        /* translate to bitmasks this chip understands */
        if (newval & WAKE_PHY)
 
        /* translate to bitmasks this chip understands */
        if (newval & WAKE_PHY)


@@ -2637,7 +2614,7 @@ static int netdev_set_wol(struct net_device *dev, u32 newval)
                }
        }
 
                }
        }
 

-       writel(data, dev->base_addr + WOLCmd);
+       writel(data, ioaddr + WOLCmd);

 
        return 0;
 }
 
        return 0;
 }


@@ -2645,7 +2622,8 @@ static int netdev_set_wol(struct net_device *dev, u32 newval)
 static int netdev_get_wol(struct net_device *dev, u32 *supported, u32 *cur)
 {
        struct netdev_private *np = netdev_priv(dev);
 static int netdev_get_wol(struct net_device *dev, u32 *supported, u32 *cur)
 {
        struct netdev_private *np = netdev_priv(dev);

-       u32 regval = readl(dev->base_addr + WOLCmd);
+       void __iomem * ioaddr = ns_ioaddr(dev);
+       u32 regval = readl(ioaddr + WOLCmd);

 
        *supported = (WAKE_PHY | WAKE_UCAST | WAKE_MCAST | WAKE_BCAST
                        | WAKE_ARP | WAKE_MAGIC);
 
        *supported = (WAKE_PHY | WAKE_UCAST | WAKE_MCAST | WAKE_BCAST
                        | WAKE_ARP | WAKE_MAGIC);


@@ -2680,6 +2658,7 @@ static int netdev_get_wol(struct net_device *dev, u32 *supported, u32 *cur)
 static int netdev_set_sopass(struct net_device *dev, u8 *newval)
 {
        struct netdev_private *np = netdev_priv(dev);
 static int netdev_set_sopass(struct net_device *dev, u8 *newval)
 {
        struct netdev_private *np = netdev_priv(dev);

+       void __iomem * ioaddr = ns_ioaddr(dev);

        u16 *sval = (u16 *)newval;
        u32 addr;
 
        u16 *sval = (u16 *)newval;
        u32 addr;
 


@@ -2688,22 +2667,22 @@ static int netdev_set_sopass(struct net_device *dev, u8 *newval)
        }
 
        /* enable writing to these registers by disabling the RX filter */
        }
 
        /* enable writing to these registers by disabling the RX filter */

-       addr = readl(dev->base_addr + RxFilterAddr) & ~RFCRAddressMask;
+       addr = readl(ioaddr + RxFilterAddr) & ~RFCRAddressMask;

        addr &= ~RxFilterEnable;
        addr &= ~RxFilterEnable;

-       writel(addr, dev->base_addr + RxFilterAddr);
+       writel(addr, ioaddr + RxFilterAddr);

 
        /* write the three words to (undocumented) RFCR vals 0xa, 0xc, 0xe */
 
        /* write the three words to (undocumented) RFCR vals 0xa, 0xc, 0xe */

-       writel(addr | 0xa, dev->base_addr + RxFilterAddr);
-       writew(sval[0], dev->base_addr + RxFilterData);
+       writel(addr | 0xa, ioaddr + RxFilterAddr);
+       writew(sval[0], ioaddr + RxFilterData);

 
 

-       writel(addr | 0xc, dev->base_addr + RxFilterAddr);
-       writew(sval[1], dev->base_addr + RxFilterData);
+       writel(addr | 0xc, ioaddr + RxFilterAddr);
+       writew(sval[1], ioaddr + RxFilterData);

 
 

-       writel(addr | 0xe, dev->base_addr + RxFilterAddr);
-       writew(sval[2], dev->base_addr + RxFilterData);
+       writel(addr | 0xe, ioaddr + RxFilterAddr);
+       writew(sval[2], ioaddr + RxFilterData);

 
        /* re-enable the RX filter */
 
        /* re-enable the RX filter */

-       writel(addr | RxFilterEnable, dev->base_addr + RxFilterAddr);
+       writel(addr | RxFilterEnable, ioaddr + RxFilterAddr);

 
        return 0;
 }
 
        return 0;
 }


@@ -2711,6 +2690,7 @@ static int netdev_set_sopass(struct net_device *dev, u8 *newval)
 static int netdev_get_sopass(struct net_device *dev, u8 *data)
 {
        struct netdev_private *np = netdev_priv(dev);
 static int netdev_get_sopass(struct net_device *dev, u8 *data)
 {
        struct netdev_private *np = netdev_priv(dev);

+       void __iomem * ioaddr = ns_ioaddr(dev);

        u16 *sval = (u16 *)data;
        u32 addr;
 
        u16 *sval = (u16 *)data;
        u32 addr;
 


@@ -2720,18 +2700,18 @@ static int netdev_get_sopass(struct net_device *dev, u8 *data)
        }
 
        /* read the three words from (undocumented) RFCR vals 0xa, 0xc, 0xe */
        }
 
        /* read the three words from (undocumented) RFCR vals 0xa, 0xc, 0xe */

-       addr = readl(dev->base_addr + RxFilterAddr) & ~RFCRAddressMask;
+       addr = readl(ioaddr + RxFilterAddr) & ~RFCRAddressMask;

 
 

-       writel(addr | 0xa, dev->base_addr + RxFilterAddr);
-       sval[0] = readw(dev->base_addr + RxFilterData);
+       writel(addr | 0xa, ioaddr + RxFilterAddr);
+       sval[0] = readw(ioaddr + RxFilterData);

 
 

-       writel(addr | 0xc, dev->base_addr + RxFilterAddr);
-       sval[1] = readw(dev->base_addr + RxFilterData);
+       writel(addr | 0xc, ioaddr + RxFilterAddr);
+       sval[1] = readw(ioaddr + RxFilterData);

 
 

-       writel(addr | 0xe, dev->base_addr + RxFilterAddr);
-       sval[2] = readw(dev->base_addr + RxFilterData);
+       writel(addr | 0xe, ioaddr + RxFilterAddr);
+       sval[2] = readw(ioaddr + RxFilterData);

 
 

-       writel(addr, dev->base_addr + RxFilterAddr);
+       writel(addr, ioaddr + RxFilterAddr);

 
        return 0;
 }
 
        return 0;
 }


@@ -2764,7 +2744,7 @@ static int netdev_get_ecmd(struct net_device *dev, struct ethtool_cmd *ecmd)
         * phy, even if the internal phy is used. This is necessary
         * to work around a deficiency of the ethtool interface:
         * It's only possible to query the settings of the active
         * phy, even if the internal phy is used. This is necessary
         * to work around a deficiency of the ethtool interface:
         * It's only possible to query the settings of the active

-        * port. Therefore 
+        * port. Therefore

         * # ethtool -s ethX port mii
         * actually sends an ioctl to switch to port mii with the
         * settings that are used for the current active port.
         * # ethtool -s ethX port mii
         * actually sends an ioctl to switch to port mii with the
         * settings that are used for the current active port.


@@ -2894,10 +2874,11 @@ static int netdev_get_regs(struct net_device *dev, u8 *buf)
        int j;
        u32 rfcr;
        u32 *rbuf = (u32 *)buf;
        int j;
        u32 rfcr;
        u32 *rbuf = (u32 *)buf;

+       void __iomem * ioaddr = ns_ioaddr(dev);

 
        /* read non-mii page 0 of registers */
        for (i = 0; i < NATSEMI_PG0_NREGS/2; i++) {
 
        /* read non-mii page 0 of registers */
        for (i = 0; i < NATSEMI_PG0_NREGS/2; i++) {

-               rbuf[i] = readl(dev->base_addr + i*4);
+               rbuf[i] = readl(ioaddr + i*4);

        }
 
        /* read current mii registers */
        }
 
        /* read current mii registers */


@@ -2905,20 +2886,20 @@ static int netdev_get_regs(struct net_device *dev, u8 *buf)
                rbuf[i] = mdio_read(dev, i & 0x1f);
 
        /* read only the 'magic' registers from page 1 */
                rbuf[i] = mdio_read(dev, i & 0x1f);
 
        /* read only the 'magic' registers from page 1 */

-       writew(1, dev->base_addr + PGSEL);
-       rbuf[i++] = readw(dev->base_addr + PMDCSR);
-       rbuf[i++] = readw(dev->base_addr + TSTDAT);
-       rbuf[i++] = readw(dev->base_addr + DSPCFG);
-       rbuf[i++] = readw(dev->base_addr + SDCFG);
-       writew(0, dev->base_addr + PGSEL);
+       writew(1, ioaddr + PGSEL);
+       rbuf[i++] = readw(ioaddr + PMDCSR);
+       rbuf[i++] = readw(ioaddr + TSTDAT);
+       rbuf[i++] = readw(ioaddr + DSPCFG);
+       rbuf[i++] = readw(ioaddr + SDCFG);
+       writew(0, ioaddr + PGSEL);

 
        /* read RFCR indexed registers */
 
        /* read RFCR indexed registers */

-       rfcr = readl(dev->base_addr + RxFilterAddr);
+       rfcr = readl(ioaddr + RxFilterAddr);

        for (j = 0; j < NATSEMI_RFDR_NREGS; j++) {
        for (j = 0; j < NATSEMI_RFDR_NREGS; j++) {

-               writel(j*2, dev->base_addr + RxFilterAddr);
-               rbuf[i++] = readw(dev->base_addr + RxFilterData);
+               writel(j*2, ioaddr + RxFilterAddr);
+               rbuf[i++] = readw(ioaddr + RxFilterData);

        }
        }

-       writel(rfcr, dev->base_addr + RxFilterAddr);
+       writel(rfcr, ioaddr + RxFilterAddr);

 
        /* the interrupt status is clear-on-read - see if we missed any */
        if (rbuf[4] & rbuf[5]) {
 
        /* the interrupt status is clear-on-read - see if we missed any */
        if (rbuf[4] & rbuf[5]) {


@@ -2943,10 +2924,12 @@ static int netdev_get_eeprom(struct net_device *dev, u8 *buf)
 {
        int i;
        u16 *ebuf = (u16 *)buf;
 {
        int i;
        u16 *ebuf = (u16 *)buf;

+       void __iomem * ioaddr = ns_ioaddr(dev);
+       struct netdev_private *np = netdev_priv(dev);

 
        /* eeprom_read reads 16 bits, and indexes by 16 bits */
 
        /* eeprom_read reads 16 bits, and indexes by 16 bits */

-       for (i = 0; i < NATSEMI_EEPROM_SIZE/2; i++) {
-               ebuf[i] = eeprom_read(dev->base_addr, i);
+       for (i = 0; i < np->eeprom_size/2; i++) {
+               ebuf[i] = eeprom_read(ioaddr, i);

                /* The EEPROM itself stores data bit-swapped, but eeprom_read
                 * reads it back "sanely". So we swap it back here in order to
                 * present it to userland as it is stored. */
                /* The EEPROM itself stores data bit-swapped, but eeprom_read
                 * reads it back "sanely". So we swap it back here in order to
                 * present it to userland as it is stored. */


@@ -2961,8 +2944,6 @@ static int netdev_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
        struct netdev_private *np = netdev_priv(dev);
 
        switch(cmd) {
        struct netdev_private *np = netdev_priv(dev);
 
        switch(cmd) {

-       case SIOCETHTOOL:
-               return netdev_ethtool_ioctl(dev, rq->ifr_data);

        case SIOCGMIIPHY:               /* Get address of MII PHY in use. */
        case SIOCDEVPRIVATE:            /* for binary compat, remove in 2.5 */
                data->phy_id = np->phy_addr_external;
        case SIOCGMIIPHY:               /* Get address of MII PHY in use. */
        case SIOCDEVPRIVATE:            /* for binary compat, remove in 2.5 */
                data->phy_id = np->phy_addr_external;


@@ -3016,7 +2997,7 @@ static int netdev_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
 
 static void enable_wol_mode(struct net_device *dev, int enable_intr)
 {
 
 static void enable_wol_mode(struct net_device *dev, int enable_intr)
 {

-       long ioaddr = dev->base_addr;
+       void __iomem * ioaddr = ns_ioaddr(dev);

        struct netdev_private *np = netdev_priv(dev);
 
        if (netif_msg_wol(np))
        struct netdev_private *np = netdev_priv(dev);
 
        if (netif_msg_wol(np))


@@ -3049,7 +3030,7 @@ static void enable_wol_mode(struct net_device *dev, int enable_intr)
 
 static int netdev_close(struct net_device *dev)
 {
 
 static int netdev_close(struct net_device *dev)
 {

-       long ioaddr = dev->base_addr;
+       void __iomem * ioaddr = ns_ioaddr(dev);

        struct netdev_private *np = netdev_priv(dev);
 
        if (netif_msg_ifdown(np))
        struct netdev_private *np = netdev_priv(dev);
 
        if (netif_msg_ifdown(np))


@@ -3072,9 +3053,7 @@ static int netdev_close(struct net_device *dev)
        del_timer_sync(&np->timer);
        disable_irq(dev->irq);
        spin_lock_irq(&np->lock);
        del_timer_sync(&np->timer);
        disable_irq(dev->irq);
        spin_lock_irq(&np->lock);

-       /* Disable interrupts, and flush posted writes */
-       writel(0, ioaddr + IntrEnable);
-       readl(ioaddr + IntrEnable);
+       natsemi_irq_disable(dev);

        np->hands_off = 1;
        spin_unlock_irq(&np->lock);
        enable_irq(dev->irq);
        np->hands_off = 1;
        spin_unlock_irq(&np->lock);
        enable_irq(dev->irq);


@@ -3126,10 +3105,11 @@ static int netdev_close(struct net_device *dev)
 static void __devexit natsemi_remove1 (struct pci_dev *pdev)
 {
        struct net_device *dev = pci_get_drvdata(pdev);
 static void __devexit natsemi_remove1 (struct pci_dev *pdev)
 {
        struct net_device *dev = pci_get_drvdata(pdev);

+       void __iomem * ioaddr = ns_ioaddr(dev);

 
        unregister_netdev (dev);
        pci_release_regions (pdev);
 
        unregister_netdev (dev);
        pci_release_regions (pdev);

-       iounmap ((char *) dev->base_addr);
+       iounmap(ioaddr);

        free_netdev (dev);
        pci_set_drvdata(pdev, NULL);
 }
        free_netdev (dev);
        pci_set_drvdata(pdev, NULL);
 }


@@ -3155,15 +3135,18 @@ static void __devexit natsemi_remove1 (struct pci_dev *pdev)
  *     * netdev_timer: timer stopped by natsemi_suspend.
  *     * intr_handler: doesn't acquire the spinlock. suspend calls
  *             disable_irq() to enforce synchronization.
  *     * netdev_timer: timer stopped by natsemi_suspend.
  *     * intr_handler: doesn't acquire the spinlock. suspend calls
  *             disable_irq() to enforce synchronization.

+ *      * natsemi_poll: checks before reenabling interrupts.  suspend
+ *              sets hands_off, disables interrupts and then waits with
+ *              netif_poll_disable().

  *
  * Interrupts must be disabled, otherwise hands_off can cause irq storms.
  */
 
  *
  * Interrupts must be disabled, otherwise hands_off can cause irq storms.
  */
 

-static int natsemi_suspend (struct pci_dev *pdev, u32 state)
+static int natsemi_suspend (struct pci_dev *pdev, pm_message_t state)

 {
        struct net_device *dev = pci_get_drvdata (pdev);
        struct netdev_private *np = netdev_priv(dev);
 {
        struct net_device *dev = pci_get_drvdata (pdev);
        struct netdev_private *np = netdev_priv(dev);

-       long ioaddr = dev->base_addr;
+       void __iomem * ioaddr = ns_ioaddr(dev);

 
        rtnl_lock();
        if (netif_running (dev)) {
 
        rtnl_lock();
        if (netif_running (dev)) {


@@ -3180,6 +3163,8 @@ static int natsemi_suspend (struct pci_dev *pdev, u32 state)
                spin_unlock_irq(&np->lock);
                enable_irq(dev->irq);
 
                spin_unlock_irq(&np->lock);
                enable_irq(dev->irq);
 

+               netif_poll_disable(dev);
+

                /* Update the error counts. */
                __get_stats(dev);
 
                /* Update the error counts. */
                __get_stats(dev);
 


@@ -3232,6 +3217,7 @@ static int natsemi_resume (struct pci_dev *pdev)
                mod_timer(&np->timer, jiffies + 1*HZ);
        }
        netif_device_attach(dev);
                mod_timer(&np->timer, jiffies + 1*HZ);
        }
        netif_device_attach(dev);

+       netif_poll_enable(dev);

 out:
        rtnl_unlock();
        return 0;
 out:
        rtnl_unlock();
        return 0;


@@ -3257,7 +3243,7 @@ static int __init natsemi_init_mod (void)
        printk(version);
 #endif
 
        printk(version);
 #endif
 

-       return pci_module_init (&natsemi_driver);
+       return pci_register_driver(&natsemi_driver);

 }
 
 static void __exit natsemi_exit_mod (void)
 }
 
 static void __exit natsemi_exit_mod (void)