Fedora kernel-2.6.17-1.2142_FC4 patched with stable patch-2.6.17.4-vs2.0.2-rc26.diff
[linux-2.6.git] / drivers / net / 3c59x.c
index b5e0760..274b013 100644 (file)
 
 
 #define DRV_NAME       "3c59x"
-#define DRV_VERSION    "LK1.1.19"
-#define DRV_RELDATE    "10 Nov 2002"
 
 
 
@@ -258,6 +256,7 @@ static int vortex_debug = 1;
 #include <linux/highmem.h>
 #include <linux/eisa.h>
 #include <linux/bitops.h>
+#include <linux/jiffies.h>
 #include <asm/irq.h>                   /* For NR_IRQS only. */
 #include <asm/io.h>
 #include <asm/uaccess.h>
@@ -274,10 +273,8 @@ static char version[] __devinitdata =
 DRV_NAME ": Donald Becker and others. www.scyld.com/network/vortex.html\n";
 
 MODULE_AUTHOR("Donald Becker <becker@scyld.com>");
-MODULE_DESCRIPTION("3Com 3c59x/3c9xx ethernet driver "
-                                       DRV_VERSION " " DRV_RELDATE);
+MODULE_DESCRIPTION("3Com 3c59x/3c9xx ethernet driver ");
 MODULE_LICENSE("GPL");
-MODULE_VERSION(DRV_VERSION);
 
 
 /* Operational parameter that usually are not changed. */
@@ -602,7 +599,7 @@ MODULE_DEVICE_TABLE(pci, vortex_pci_tbl);
    First the windows.  There are eight register windows, with the command
    and status registers available in each.
    */
-#define EL3WINDOW(win_num) outw(SelectWindow + (win_num), ioaddr + EL3_CMD)
+#define EL3WINDOW(win_num) iowrite16(SelectWindow + (win_num), ioaddr + EL3_CMD)
 #define EL3_CMD 0x0e
 #define EL3_STATUS 0x0e
 
@@ -753,9 +750,11 @@ enum tx_desc_status {
 enum ChipCaps { CapBusMaster=0x20, CapPwrMgmt=0x2000 };
 
 struct vortex_extra_stats {
-        unsigned long tx_deferred;
-        unsigned long tx_multiple_collisions;
-        unsigned long rx_bad_ssd;
+       unsigned long tx_deferred;
+       unsigned long tx_max_collisions;
+       unsigned long tx_multiple_collisions;
+       unsigned long tx_single_collisions;
+       unsigned long rx_bad_ssd;
 };
 
 struct vortex_private {
@@ -776,7 +775,8 @@ struct vortex_private {
 
        /* PCI configuration space information. */
        struct device *gendev;
-       char __iomem *cb_fn_base;               /* CardBus function status addr space. */
+       void __iomem *ioaddr;                   /* IO address space */
+       void __iomem *cb_fn_base;               /* CardBus function status addr space. */
 
        /* Some values here only for performance evaluation and path-coverage */
        int rx_nocopy, rx_copy, queued_packet, rx_csumhits;
@@ -788,7 +788,7 @@ struct vortex_private {
        int options;                                            /* User-settable misc. driver options. */
        unsigned int media_override:4,          /* Passed-in media type. */
                default_media:4,                                /* Read from the EEPROM/Wn3_Config. */
-               full_duplex:1, force_fd:1, autoselect:1,
+               full_duplex:1, autoselect:1,
                bus_master:1,                                   /* Vortex can only do a fragment bus-m. */
                full_bus_master_tx:1, full_bus_master_rx:2, /* Boomerang  */
                flow_ctrl:1,                                    /* Use 802.3x flow control (PAUSE only) */
@@ -838,7 +838,7 @@ enum xcvr_types {
        XCVR_100baseFx, XCVR_MII=6, XCVR_NWAY=8, XCVR_ExtMII=9, XCVR_Default=10,
 };
 
-static struct media_table {
+static const struct media_table {
        char *name;
        unsigned int media_bits:16,             /* Bits to set in Wn4_Media register. */
                mask:8,                                         /* The transceiver-present bit in Wn3_Config.*/
@@ -862,19 +862,21 @@ static struct {
        const char str[ETH_GSTRING_LEN];
 } ethtool_stats_keys[] = {
        { "tx_deferred" },
+       { "tx_max_collisions" },
        { "tx_multiple_collisions" },
+       { "tx_single_collisions" },
        { "rx_bad_ssd" },
 };
 
 /* number of ETHTOOL_GSTATS u64's */
-#define VORTEX_NUM_STATS     3
+#define VORTEX_NUM_STATS    5
 
-static int vortex_probe1(struct device *gendev, long ioaddr, int irq,
+static int vortex_probe1(struct device *gendev, void __iomem *ioaddr, int irq,
                                   int chip_idx, int card_idx);
 static void vortex_up(struct net_device *dev);
 static void vortex_down(struct net_device *dev, int final);
 static int vortex_open(struct net_device *dev);
-static void mdio_sync(long ioaddr, int bits);
+static void mdio_sync(void __iomem *ioaddr, int bits);
 static int mdio_read(struct net_device *dev, int phy_id, int location);
 static void mdio_write(struct net_device *vp, int phy_id, int location, int value);
 static void vortex_timer(unsigned long arg);
@@ -887,7 +889,7 @@ static irqreturn_t vortex_interrupt(int irq, void *dev_id, struct pt_regs *regs)
 static irqreturn_t boomerang_interrupt(int irq, void *dev_id, struct pt_regs *regs);
 static int vortex_close(struct net_device *dev);
 static void dump_tx_ring(struct net_device *dev);
-static void update_stats(long ioaddr, struct net_device *dev);
+static void update_stats(void __iomem *ioaddr, struct net_device *dev);
 static struct net_device_stats *vortex_get_stats(struct net_device *dev);
 static void set_rx_mode(struct net_device *dev);
 #ifdef CONFIG_PCI
@@ -898,20 +900,19 @@ static void acpi_set_WOL(struct net_device *dev);
 static struct ethtool_ops vortex_ethtool_ops;
 static void set_8021q_mode(struct net_device *dev, int enable);
 
-\f
 /* This driver uses 'options' to pass the media type, full-duplex flag, etc. */
 /* Option count limit only -- unlimited interfaces are supported. */
 #define MAX_UNITS 8
-static int options[MAX_UNITS] = { -1, -1, -1, -1, -1, -1, -1, -1,};
-static int full_duplex[MAX_UNITS] = {-1, -1, -1, -1, -1, -1, -1, -1};
-static int hw_checksums[MAX_UNITS] = {-1, -1, -1, -1, -1, -1, -1, -1};
-static int flow_ctrl[MAX_UNITS] = {-1, -1, -1, -1, -1, -1, -1, -1};
-static int enable_wol[MAX_UNITS] = {-1, -1, -1, -1, -1, -1, -1, -1};
+static int options[MAX_UNITS] = { [0 ... MAX_UNITS-1] = -1 };
+static int full_duplex[MAX_UNITS] = {[0 ... MAX_UNITS-1] = -1 };
+static int hw_checksums[MAX_UNITS] = {[0 ... MAX_UNITS-1] = -1 };
+static int flow_ctrl[MAX_UNITS] = {[0 ... MAX_UNITS-1] = -1 };
+static int enable_wol[MAX_UNITS] = {[0 ... MAX_UNITS-1] = -1 };
+static int use_mmio[MAX_UNITS] = {[0 ... MAX_UNITS-1] = -1 };
 static int global_options = -1;
 static int global_full_duplex = -1;
 static int global_enable_wol = -1;
-
-/* #define dev_alloc_skb dev_alloc_skb_debug */
+static int global_use_mmio = -1;
 
 /* Variables to work-around the Compaq PCI BIOS32 problem. */
 static int compaq_ioaddr, compaq_irq, compaq_device_id = 0x5900;
@@ -934,21 +935,25 @@ module_param(compaq_ioaddr, int, 0);
 module_param(compaq_irq, int, 0);
 module_param(compaq_device_id, int, 0);
 module_param(watchdog, int, 0);
+module_param(global_use_mmio, int, 0);
+module_param_array(use_mmio, int, NULL, 0);
 MODULE_PARM_DESC(debug, "3c59x debug level (0-6)");
 MODULE_PARM_DESC(options, "3c59x: Bits 0-3: media type, bit 4: bus mastering, bit 9: full duplex");
 MODULE_PARM_DESC(global_options, "3c59x: same as options, but applies to all NICs if options is unset");
 MODULE_PARM_DESC(full_duplex, "3c59x full duplex setting(s) (1)");
-MODULE_PARM_DESC(global_full_duplex, "3c59x: same as full_duplex, but applies to all NICs if options is unset");
+MODULE_PARM_DESC(global_full_duplex, "3c59x: same as full_duplex, but applies to all NICs if full_duplex is unset");
 MODULE_PARM_DESC(hw_checksums, "3c59x Hardware checksum checking by adapter(s) (0-1)");
 MODULE_PARM_DESC(flow_ctrl, "3c59x 802.3x flow control usage (PAUSE only) (0-1)");
 MODULE_PARM_DESC(enable_wol, "3c59x: Turn on Wake-on-LAN for adapter(s) (0-1)");
-MODULE_PARM_DESC(global_enable_wol, "3c59x: same as enable_wol, but applies to all NICs if options is unset");
+MODULE_PARM_DESC(global_enable_wol, "3c59x: same as enable_wol, but applies to all NICs if enable_wol is unset");
 MODULE_PARM_DESC(rx_copybreak, "3c59x copy breakpoint for copy-only-tiny-frames");
 MODULE_PARM_DESC(max_interrupt_work, "3c59x maximum events handled per interrupt");
 MODULE_PARM_DESC(compaq_ioaddr, "3c59x PCI I/O base address (Compaq BIOS problem workaround)");
 MODULE_PARM_DESC(compaq_irq, "3c59x PCI IRQ number (Compaq BIOS problem workaround)");
 MODULE_PARM_DESC(compaq_device_id, "3c59x PCI device ID (Compaq BIOS problem workaround)");
 MODULE_PARM_DESC(watchdog, "3c59x transmit timeout in milliseconds");
+MODULE_PARM_DESC(global_use_mmio, "3c59x: same as use_mmio, but applies to all NICs if options is unset");
+MODULE_PARM_DESC(use_mmio, "3c59x: use memory-mapped PCI I/O resource (0-1)");
 
 #ifdef CONFIG_NET_POLL_CONTROLLER
 static void poll_vortex(struct net_device *dev)
@@ -964,7 +969,7 @@ static void poll_vortex(struct net_device *dev)
 
 #ifdef CONFIG_PM
 
-static int vortex_suspend (struct pci_dev *pdev, pm_message_t state)
+static int vortex_suspend(struct pci_dev *pdev, pm_message_t state)
 {
        struct net_device *dev = pci_get_drvdata(pdev);
 
@@ -973,15 +978,31 @@ static int vortex_suspend (struct pci_dev *pdev, pm_message_t state)
                        netif_device_detach(dev);
                        vortex_down(dev, 1);
                }
+               pci_save_state(pdev);
+               pci_enable_wake(pdev, pci_choose_state(pdev, state), 0);
+               free_irq(dev->irq, dev);
+               pci_disable_device(pdev);
+               pci_set_power_state(pdev, pci_choose_state(pdev, state));
        }
        return 0;
 }
 
-static int vortex_resume (struct pci_dev *pdev)
+static int vortex_resume(struct pci_dev *pdev)
 {
        struct net_device *dev = pci_get_drvdata(pdev);
+       struct vortex_private *vp = netdev_priv(dev);
 
-       if (dev && dev->priv) {
+       if (dev && vp) {
+               pci_set_power_state(pdev, PCI_D0);
+               pci_restore_state(pdev);
+               pci_enable_device(pdev);
+               pci_set_master(pdev);
+               if (request_irq(dev->irq, vp->full_bus_master_rx ?
+                               &boomerang_interrupt : &vortex_interrupt, SA_SHIRQ, dev->name, dev)) {
+                       printk(KERN_WARNING "%s: Could not reserve IRQ %d\n", dev->name, dev->irq);
+                       pci_disable_device(pdev);
+                       return -EBUSY;
+               }
                if (netif_running(dev)) {
                        vortex_up(dev);
                        netif_device_attach(dev);
@@ -999,8 +1020,8 @@ static struct eisa_device_id vortex_eisa_ids[] = {
        { "" }
 };
 
-static int vortex_eisa_probe (struct device *device);
-static int vortex_eisa_remove (struct device *device);
+static int vortex_eisa_probe(struct device *device);
+static int vortex_eisa_remove(struct device *device);
 
 static struct eisa_driver vortex_eisa_driver = {
        .id_table = vortex_eisa_ids,
@@ -1011,20 +1032,21 @@ static struct eisa_driver vortex_eisa_driver = {
        }
 };
 
-static int vortex_eisa_probe (struct device *device)
+static int vortex_eisa_probe(struct device *device)
 {
-       long ioaddr;
+       void __iomem *ioaddr;
        struct eisa_device *edev;
 
-       edev = to_eisa_device (device);
-       ioaddr = edev->base_addr;
+       edev = to_eisa_device(device);
 
-       if (!request_region(ioaddr, VORTEX_TOTAL_SIZE, DRV_NAME))
+       if (!request_region(edev->base_addr, VORTEX_TOTAL_SIZE, DRV_NAME))
                return -EBUSY;
 
-       if (vortex_probe1(device, ioaddr, inw(ioaddr + 0xC88) >> 12,
+       ioaddr = ioport_map(edev->base_addr, VORTEX_TOTAL_SIZE);
+
+       if (vortex_probe1(device, ioaddr, ioread16(ioaddr + 0xC88) >> 12,
                                          edev->id.driver_data, vortex_cards_found)) {
-               release_region (ioaddr, VORTEX_TOTAL_SIZE);
+               release_region(edev->base_addr, VORTEX_TOTAL_SIZE);
                return -ENODEV;
        }
 
@@ -1033,15 +1055,15 @@ static int vortex_eisa_probe (struct device *device)
        return 0;
 }
 
-static int vortex_eisa_remove (struct device *device)
+static int vortex_eisa_remove(struct device *device)
 {
        struct eisa_device *edev;
        struct net_device *dev;
        struct vortex_private *vp;
-       long ioaddr;
+       void __iomem *ioaddr;
 
-       edev = to_eisa_device (device);
-       dev = eisa_get_drvdata (edev);
+       edev = to_eisa_device(device);
+       dev = eisa_get_drvdata(edev);
 
        if (!dev) {
                printk("vortex_eisa_remove called for Compaq device!\n");
@@ -1049,59 +1071,80 @@ static int vortex_eisa_remove (struct device *device)
        }
 
        vp = netdev_priv(dev);
-       ioaddr = dev->base_addr;
+       ioaddr = vp->ioaddr;
        
-       unregister_netdev (dev);
-       outw (TotalReset|0x14, ioaddr + EL3_CMD);
-       release_region (ioaddr, VORTEX_TOTAL_SIZE);
+       unregister_netdev(dev);
+       iowrite16(TotalReset|0x14, ioaddr + EL3_CMD);
+       release_region(dev->base_addr, VORTEX_TOTAL_SIZE);
 
-       free_netdev (dev);
+       free_netdev(dev);
        return 0;
 }
 #endif
 
 /* returns count found (>= 0), or negative on error */
-static int __init vortex_eisa_init (void)
+static int __init vortex_eisa_init(void)
 {
        int eisa_found = 0;
        int orig_cards_found = vortex_cards_found;
 
 #ifdef CONFIG_EISA
-       if (eisa_driver_register (&vortex_eisa_driver) >= 0) {
-                       /* Because of the way EISA bus is probed, we cannot assume
-                        * any device have been found when we exit from
-                        * eisa_driver_register (the bus root driver may not be
-                        * initialized yet). So we blindly assume something was
-                        * found, and let the sysfs magic happend... */
-                       
-                       eisa_found = 1;
+       int err;
+
+       err = eisa_driver_register (&vortex_eisa_driver);
+       if (!err) {
+               /*
+                * Because of the way EISA bus is probed, we cannot assume
+                * any device have been found when we exit from
+                * eisa_driver_register (the bus root driver may not be
+                * initialized yet). So we blindly assume something was
+                * found, and let the sysfs magic happend...
+                */
+               eisa_found = 1;
        }
 #endif
        
        /* Special code to work-around the Compaq PCI BIOS32 problem. */
        if (compaq_ioaddr) {
-               vortex_probe1(NULL, compaq_ioaddr, compaq_irq,
-                                         compaq_device_id, vortex_cards_found++);
+               vortex_probe1(NULL, ioport_map(compaq_ioaddr, VORTEX_TOTAL_SIZE),
+                             compaq_irq, compaq_device_id, vortex_cards_found++);
        }
 
        return vortex_cards_found - orig_cards_found + eisa_found;
 }
 
 /* returns count (>= 0), or negative on error */
-static int __devinit vortex_init_one (struct pci_dev *pdev,
+static int __devinit vortex_init_one(struct pci_dev *pdev,
                                      const struct pci_device_id *ent)
 {
-       int rc;
+       int rc, unit, pci_bar;
+       struct vortex_chip_info *vci;
+       void __iomem *ioaddr;
 
        /* wake up and enable device */         
-       rc = pci_enable_device (pdev);
+       rc = pci_enable_device(pdev);
        if (rc < 0)
                goto out;
 
-       rc = vortex_probe1 (&pdev->dev, pci_resource_start (pdev, 0),
-                                               pdev->irq, ent->driver_data, vortex_cards_found);
+       unit = vortex_cards_found;
+
+       if (global_use_mmio < 0 && (unit >= MAX_UNITS || use_mmio[unit] < 0)) {
+               /* Determine the default if the user didn't override us */
+               vci = &vortex_info_tbl[ent->driver_data];
+               pci_bar = vci->drv_flags & (IS_CYCLONE | IS_TORNADO) ? 1 : 0;
+       } else if (unit < MAX_UNITS && use_mmio[unit] >= 0)
+               pci_bar = use_mmio[unit] ? 1 : 0;
+       else
+               pci_bar = global_use_mmio ? 1 : 0;
+
+       ioaddr = pci_iomap(pdev, pci_bar, 0);
+       if (!ioaddr) /* If mapping fails, fall-back to BAR 0... */
+               ioaddr = pci_iomap(pdev, 0, 0);
+
+       rc = vortex_probe1(&pdev->dev, ioaddr, pdev->irq,
+                          ent->driver_data, unit);
        if (rc < 0) {
-               pci_disable_device (pdev);
+               pci_disable_device(pdev);
                goto out;
        }
 
@@ -1118,7 +1161,7 @@ out:
  * NOTE: pdev can be NULL, for the case of a Compaq device
  */
 static int __devinit vortex_probe1(struct device *gendev,
-                                  long ioaddr, int irq,
+                                  void __iomem *ioaddr, int irq,
                                   int chip_idx, int card_idx)
 {
        struct vortex_private *vp;
@@ -1186,15 +1229,16 @@ static int __devinit vortex_probe1(struct device *gendev,
        if (print_info)
                printk (KERN_INFO "See Documentation/networking/vortex.txt\n");
 
-       printk(KERN_INFO "%s: 3Com %s %s at 0x%lx. Vers " DRV_VERSION "\n",
+       printk(KERN_INFO "%s: 3Com %s %s at %p.\n",
               print_name,
               pdev ? "PCI" : "EISA",
               vci->name,
               ioaddr);
 
-       dev->base_addr = ioaddr;
+       dev->base_addr = (unsigned long)ioaddr;
        dev->irq = irq;
        dev->mtu = mtu;
+       vp->ioaddr = ioaddr;
        vp->large_frames = mtu > 1500;
        vp->drv_flags = vci->drv_flags;
        vp->has_nway = (vci->drv_flags & HAS_NWAY) ? 1 : 0;
@@ -1210,12 +1254,12 @@ static int __devinit vortex_probe1(struct device *gendev,
        if (pdev) {
                /* EISA resources already marked, so only PCI needs to do this here */
                /* Ignore return value, because Cardbus drivers already allocate for us */
-               if (request_region(ioaddr, vci->io_size, print_name) != NULL)
+               if (request_region(dev->base_addr, vci->io_size, print_name) != NULL)
                        vp->must_free_region = 1;
 
                /* enable bus-mastering if necessary */         
                if (vci->flags & PCI_USES_MASTER)
-                       pci_set_master (pdev);
+                       pci_set_master(pdev);
 
                if (vci->drv_flags & IS_VORTEX) {
                        u8 pci_latency;
@@ -1259,7 +1303,7 @@ static int __devinit vortex_probe1(struct device *gendev,
        if (pdev)
                pci_set_drvdata(pdev, dev);
        if (edev)
-               eisa_set_drvdata (edev, dev);
+               eisa_set_drvdata(edev, dev);
 
        vp->media_override = 7;
        if (option >= 0) {
@@ -1284,7 +1328,7 @@ static int __devinit vortex_probe1(struct device *gendev,
                        vp->enable_wol = 1;
        }
 
-       vp->force_fd = vp->full_duplex;
+       vp->mii.force_media = vp->full_duplex;
        vp->options = option;
        /* Read the station address from the EEPROM. */
        EL3WINDOW(0);
@@ -1300,14 +1344,14 @@ static int __devinit vortex_probe1(struct device *gendev,
 
                for (i = 0; i < 0x40; i++) {
                        int timer;
-                       outw(base + i, ioaddr + Wn0EepromCmd);
+                       iowrite16(base + i, ioaddr + Wn0EepromCmd);
                        /* Pause for at least 162 us. for the read to take place. */
                        for (timer = 10; timer >= 0; timer--) {
                                udelay(162);
-                               if ((inw(ioaddr + Wn0EepromCmd) & 0x8000) == 0)
+                               if ((ioread16(ioaddr + Wn0EepromCmd) & 0x8000) == 0)
                                        break;
                        }
-                       eeprom[i] = inw(ioaddr + Wn0EepromData);
+                       eeprom[i] = ioread16(ioaddr + Wn0EepromData);
                }
        }
        for (i = 0; i < 0x18; i++)
@@ -1322,6 +1366,7 @@ static int __devinit vortex_probe1(struct device *gendev,
                printk(" ***INVALID CHECKSUM %4.4x*** ", checksum);
        for (i = 0; i < 3; i++)
                ((u16 *)dev->dev_addr)[i] = htons(eeprom[i + 10]);
+       memcpy(dev->perm_addr, dev->dev_addr, dev->addr_len);
        if (print_info) {
                for (i = 0; i < 6; i++)
                        printk("%c%2.2x", i ? ':' : ' ', dev->dev_addr[i]);
@@ -1335,7 +1380,7 @@ static int __devinit vortex_probe1(struct device *gendev,
        }
        EL3WINDOW(2);
        for (i = 0; i < 6; i++)
-               outb(dev->dev_addr[i], ioaddr + i);
+               iowrite8(dev->dev_addr[i], ioaddr + i);
 
 #ifdef __sparc__
        if (print_info)
@@ -1350,7 +1395,7 @@ static int __devinit vortex_probe1(struct device *gendev,
 #endif
 
        EL3WINDOW(4);
-       step = (inb(ioaddr + Wn4_NetDiag) & 0x1e) >> 1;
+       step = (ioread8(ioaddr + Wn4_NetDiag) & 0x1e) >> 1;
        if (print_info) {
                printk(KERN_INFO "  product code %02x%02x rev %02x.%d date %02d-"
                        "%02d-%02d\n", eeprom[6]&0xff, eeprom[6]>>8, eeprom[0x14],
@@ -1359,31 +1404,30 @@ static int __devinit vortex_probe1(struct device *gendev,
 
 
        if (pdev && vci->drv_flags & HAS_CB_FNS) {
-               unsigned long fn_st_addr;                       /* Cardbus function status space */
                unsigned short n;
 
-               fn_st_addr = pci_resource_start (pdev, 2);
-               if (fn_st_addr) {
-                       vp->cb_fn_base = ioremap(fn_st_addr, 128);
+               vp->cb_fn_base = pci_iomap(pdev, 2, 0);
+               if (!vp->cb_fn_base) {
                        retval = -ENOMEM;
-                       if (!vp->cb_fn_base)
-                               goto free_ring;
+                       goto free_ring;
                }
+
                if (print_info) {
                        printk(KERN_INFO "%s: CardBus functions mapped %8.8lx->%p\n",
-                               print_name, fn_st_addr, vp->cb_fn_base);
+                               print_name, pci_resource_start(pdev, 2),
+                               vp->cb_fn_base);
                }
                EL3WINDOW(2);
 
-               n = inw(ioaddr + Wn2_ResetOptions) & ~0x4010;
+               n = ioread16(ioaddr + Wn2_ResetOptions) & ~0x4010;
                if (vp->drv_flags & INVERT_LED_PWR)
                        n |= 0x10;
                if (vp->drv_flags & INVERT_MII_PWR)
                        n |= 0x4000;
-               outw(n, ioaddr + Wn2_ResetOptions);
+               iowrite16(n, ioaddr + Wn2_ResetOptions);
                if (vp->drv_flags & WNO_XCVR_PWR) {
                        EL3WINDOW(0);
-                       outw(0x0800, ioaddr);
+                       iowrite16(0x0800, ioaddr);
                }
        }
 
@@ -1399,16 +1443,16 @@ static int __devinit vortex_probe1(struct device *gendev,
        }
 
        {
-               static const char * ram_split[] = {"5:3", "3:1", "1:1", "3:5"};
+               static const char * const ram_split[] = {"5:3", "3:1", "1:1", "3:5"};
                unsigned int config;
                EL3WINDOW(3);
-               vp->available_media = inw(ioaddr + Wn3_Options);
+               vp->available_media = ioread16(ioaddr + Wn3_Options);
                if ((vp->available_media & 0xff) == 0)          /* Broken 3c916 */
                        vp->available_media = 0x40;
-               config = inl(ioaddr + Wn3_Config);
+               config = ioread32(ioaddr + Wn3_Config);
                if (print_info) {
                        printk(KERN_DEBUG "  Internal config register is %4.4x, "
-                                  "transceivers %#x.\n", config, inw(ioaddr + Wn3_Options));
+                                  "transceivers %#x.\n", config, ioread16(ioaddr + Wn3_Options));
                        printk(KERN_INFO "  %dK %s-wide RAM %s Rx:Tx split, %s%s interface.\n",
                                   8 << RAM_SIZE(config),
                                   RAM_WIDTH(config) ? "word" : "byte",
@@ -1439,7 +1483,7 @@ static int __devinit vortex_probe1(struct device *gendev,
                if (vp->drv_flags & EXTRA_PREAMBLE)
                        mii_preamble_required++;
                mdio_sync(ioaddr, 32);
-               mdio_read(dev, 24, 1);
+               mdio_read(dev, 24, MII_BMSR);
                for (phy = 0; phy < 32 && phy_idx < 1; phy++) {
                        int mii_status, phyx;
 
@@ -1453,7 +1497,7 @@ static int __devinit vortex_probe1(struct device *gendev,
                                phyx = phy - 1;
                        else
                                phyx = phy;
-                       mii_status = mdio_read(dev, phyx, 1);
+                       mii_status = mdio_read(dev, phyx, MII_BMSR);
                        if (mii_status  &&  mii_status != 0xffff) {
                                vp->phys[phy_idx++] = phyx;
                                if (print_info) {
@@ -1469,7 +1513,7 @@ static int __devinit vortex_probe1(struct device *gendev,
                        printk(KERN_WARNING"  ***WARNING*** No MII transceivers found!\n");
                        vp->phys[0] = 24;
                } else {
-                       vp->advertising = mdio_read(dev, vp->phys[0], 4);
+                       vp->advertising = mdio_read(dev, vp->phys[0], MII_ADVERTISE);
                        if (vp->full_duplex) {
                                /* Only advertise the FD media types. */
                                vp->advertising &= ~0x02A0;
@@ -1494,10 +1538,10 @@ static int __devinit vortex_probe1(struct device *gendev,
        if (vp->full_bus_master_tx) {
                dev->hard_start_xmit = boomerang_start_xmit;
                /* Actually, it still should work with iommu. */
-               dev->features |= NETIF_F_SG;
-               if (((hw_checksums[card_idx] == -1) && (vp->drv_flags & HAS_HWCKSM)) ||
-                                       (hw_checksums[card_idx] == 1)) {
-                               dev->features |= NETIF_F_IP_CSUM;
+               if (card_idx < MAX_UNITS &&
+                   ((hw_checksums[card_idx] == -1 && (vp->drv_flags & HAS_HWCKSM)) ||
+                               hw_checksums[card_idx] == 1)) {
+                       dev->features |= NETIF_F_IP_CSUM | NETIF_F_SG;
                }
        } else {
                dev->hard_start_xmit = vortex_start_xmit;
@@ -1539,7 +1583,7 @@ free_ring:
                                                vp->rx_ring_dma);
 free_region:
        if (vp->must_free_region)
-               release_region(ioaddr, vci->io_size);
+               release_region(dev->base_addr, vci->io_size);
        free_netdev(dev);
        printk(KERN_ERR PFX "vortex_probe1 fails.  Returns %d\n", retval);
 out:
@@ -1549,17 +1593,19 @@ out:
 static void
 issue_and_wait(struct net_device *dev, int cmd)
 {
+       struct vortex_private *vp = netdev_priv(dev);
+       void __iomem *ioaddr = vp->ioaddr;
        int i;
 
-       outw(cmd, dev->base_addr + EL3_CMD);
+       iowrite16(cmd, ioaddr + EL3_CMD);
        for (i = 0; i < 2000; i++) {
-               if (!(inw(dev->base_addr + EL3_STATUS) & CmdInProgress))
+               if (!(ioread16(ioaddr + EL3_STATUS) & CmdInProgress))
                        return;
        }
 
        /* OK, that didn't work.  Do it the slow way.  One second */
        for (i = 0; i < 100000; i++) {
-               if (!(inw(dev->base_addr + EL3_STATUS) & CmdInProgress)) {
+               if (!(ioread16(ioaddr + EL3_STATUS) & CmdInProgress)) {
                        if (vortex_debug > 1)
                                printk(KERN_INFO "%s: command 0x%04x took %d usecs\n",
                                           dev->name, cmd, i * 10);
@@ -1568,16 +1614,50 @@ issue_and_wait(struct net_device *dev, int cmd)
                udelay(10);
        }
        printk(KERN_ERR "%s: command 0x%04x did not complete! Status=0x%x\n",
-                          dev->name, cmd, inw(dev->base_addr + EL3_STATUS));
+                          dev->name, cmd, ioread16(ioaddr + EL3_STATUS));
+}
+
+static void
+vortex_set_duplex(struct net_device *dev)
+{
+       struct vortex_private *vp = netdev_priv(dev);
+       void __iomem *ioaddr = vp->ioaddr;
+
+       printk(KERN_INFO "%s:  setting %s-duplex.\n",
+               dev->name, (vp->full_duplex) ? "full" : "half");
+
+       EL3WINDOW(3);
+       /* Set the full-duplex bit. */
+       iowrite16(((vp->info1 & 0x8000) || vp->full_duplex ? 0x20 : 0) |
+                       (vp->large_frames ? 0x40 : 0) |
+                       ((vp->full_duplex && vp->flow_ctrl && vp->partner_flow_ctrl) ?
+                                       0x100 : 0),
+                       ioaddr + Wn3_MAC_Ctrl);
+}
+
+static void vortex_check_media(struct net_device *dev, unsigned int init)
+{
+       struct vortex_private *vp = netdev_priv(dev);
+       unsigned int ok_to_print = 0;
+
+       if (vortex_debug > 3)
+               ok_to_print = 1;
+
+       if (mii_check_media(&vp->mii, ok_to_print, init)) {
+               vp->full_duplex = vp->mii.full_duplex;
+               vortex_set_duplex(dev);
+       } else if (init) {
+               vortex_set_duplex(dev);
+       }
 }
 
 static void
 vortex_up(struct net_device *dev)
 {
-       long ioaddr = dev->base_addr;
        struct vortex_private *vp = netdev_priv(dev);
+       void __iomem *ioaddr = vp->ioaddr;
        unsigned int config;
-       int i;
+       int i, mii_reg1, mii_reg5;
 
        if (VORTEX_PCI(vp)) {
                pci_set_power_state(VORTEX_PCI(vp), PCI_D0);    /* Go active */
@@ -1588,7 +1668,7 @@ vortex_up(struct net_device *dev)
 
        /* Before initializing select the active media port. */
        EL3WINDOW(3);
-       config = inl(ioaddr + Wn3_Config);
+       config = ioread32(ioaddr + Wn3_Config);
 
        if (vp->media_override != 7) {
                printk(KERN_INFO "%s: Media override to transceiver %d (%s).\n",
@@ -1631,47 +1711,22 @@ vortex_up(struct net_device *dev)
                printk(KERN_DEBUG "%s: Initial media type %s.\n",
                           dev->name, media_tbl[dev->if_port].name);
 
-       vp->full_duplex = vp->force_fd;
+       vp->full_duplex = vp->mii.force_media;
        config = BFINS(config, dev->if_port, 20, 4);
        if (vortex_debug > 6)
                printk(KERN_DEBUG "vortex_up(): writing 0x%x to InternalConfig\n", config);
-       outl(config, ioaddr + Wn3_Config);
+       iowrite32(config, ioaddr + Wn3_Config);
 
        if (dev->if_port == XCVR_MII || dev->if_port == XCVR_NWAY) {
-               int mii_reg1, mii_reg5;
                EL3WINDOW(4);
-               /* Read BMSR (reg1) only to clear old status. */
-               mii_reg1 = mdio_read(dev, vp->phys[0], 1);
-               mii_reg5 = mdio_read(dev, vp->phys[0], 5);
-               if (mii_reg5 == 0xffff  ||  mii_reg5 == 0x0000) {
-                       netif_carrier_off(dev); /* No MII device or no link partner report */
-               } else {
-                       mii_reg5 &= vp->advertising;
-                       if ((mii_reg5 & 0x0100) != 0    /* 100baseTx-FD */
-                                || (mii_reg5 & 0x00C0) == 0x0040) /* 10T-FD, but not 100-HD */
-                       vp->full_duplex = 1;
-                       netif_carrier_on(dev);
-               }
+               mii_reg1 = mdio_read(dev, vp->phys[0], MII_BMSR);
+               mii_reg5 = mdio_read(dev, vp->phys[0], MII_LPA);
                vp->partner_flow_ctrl = ((mii_reg5 & 0x0400) != 0);
-               if (vortex_debug > 1)
-                       printk(KERN_INFO "%s: MII #%d status %4.4x, link partner capability %4.4x,"
-                                  " info1 %04x, setting %s-duplex.\n",
-                                       dev->name, vp->phys[0],
-                                       mii_reg1, mii_reg5,
-                                       vp->info1, ((vp->info1 & 0x8000) || vp->full_duplex) ? "full" : "half");
-               EL3WINDOW(3);
-       }
-
-       /* Set the full-duplex bit. */
-       outw(   ((vp->info1 & 0x8000) || vp->full_duplex ? 0x20 : 0) |
-                       (vp->large_frames ? 0x40 : 0) |
-                       ((vp->full_duplex && vp->flow_ctrl && vp->partner_flow_ctrl) ? 0x100 : 0),
-                       ioaddr + Wn3_MAC_Ctrl);
 
-       if (vortex_debug > 1) {
-               printk(KERN_DEBUG "%s: vortex_up() InternalConfig %8.8x.\n",
-                       dev->name, config);
+               vortex_check_media(dev, 1);
        }
+       else
+               vortex_set_duplex(dev);
 
        issue_and_wait(dev, TxReset);
        /*
@@ -1679,51 +1734,52 @@ vortex_up(struct net_device *dev)
         */
        issue_and_wait(dev, RxReset|0x04);
 
-       outw(SetStatusEnb | 0x00, ioaddr + EL3_CMD);
+
+       iowrite16(SetStatusEnb | 0x00, ioaddr + EL3_CMD);
 
        if (vortex_debug > 1) {
                EL3WINDOW(4);
                printk(KERN_DEBUG "%s: vortex_up() irq %d media status %4.4x.\n",
-                          dev->name, dev->irq, inw(ioaddr + Wn4_Media));
+                          dev->name, dev->irq, ioread16(ioaddr + Wn4_Media));
        }
 
        /* Set the station address and mask in window 2 each time opened. */
        EL3WINDOW(2);
        for (i = 0; i < 6; i++)
-               outb(dev->dev_addr[i], ioaddr + i);
+               iowrite8(dev->dev_addr[i], ioaddr + i);
        for (; i < 12; i+=2)
-               outw(0, ioaddr + i);
+               iowrite16(0, ioaddr + i);
 
        if (vp->cb_fn_base) {
-               unsigned short n = inw(ioaddr + Wn2_ResetOptions) & ~0x4010;
+               unsigned short n = ioread16(ioaddr + Wn2_ResetOptions) & ~0x4010;
                if (vp->drv_flags & INVERT_LED_PWR)
                        n |= 0x10;
                if (vp->drv_flags & INVERT_MII_PWR)
                        n |= 0x4000;
-               outw(n, ioaddr + Wn2_ResetOptions);
+               iowrite16(n, ioaddr + Wn2_ResetOptions);
        }
 
        if (dev->if_port == XCVR_10base2)
                /* Start the thinnet transceiver. We should really wait 50ms...*/
-               outw(StartCoax, ioaddr + EL3_CMD);
+               iowrite16(StartCoax, ioaddr + EL3_CMD);
        if (dev->if_port != XCVR_NWAY) {
                EL3WINDOW(4);
-               outw((inw(ioaddr + Wn4_Media) & ~(Media_10TP|Media_SQE)) |
+               iowrite16((ioread16(ioaddr + Wn4_Media) & ~(Media_10TP|Media_SQE)) |
                         media_tbl[dev->if_port].media_bits, ioaddr + Wn4_Media);
        }
 
        /* Switch to the stats window, and clear all stats by reading. */
-       outw(StatsDisable, ioaddr + EL3_CMD);
+       iowrite16(StatsDisable, ioaddr + EL3_CMD);
        EL3WINDOW(6);
        for (i = 0; i < 10; i++)
-               inb(ioaddr + i);
-       inw(ioaddr + 10);
-       inw(ioaddr + 12);
+               ioread8(ioaddr + i);
+       ioread16(ioaddr + 10);
+       ioread16(ioaddr + 12);
        /* New: On the Vortex we must also clear the BadSSD counter. */
        EL3WINDOW(4);
-       inb(ioaddr + 12);
+       ioread8(ioaddr + 12);
        /* ..and on the Boomerang we enable the extra statistics bits. */
-       outw(0x0040, ioaddr + Wn4_NetDiag);
+       iowrite16(0x0040, ioaddr + Wn4_NetDiag);
 
        /* Switch to register set 7 for normal use. */
        EL3WINDOW(7);
@@ -1731,30 +1787,29 @@ vortex_up(struct net_device *dev)
        if (vp->full_bus_master_rx) { /* Boomerang bus master. */
                vp->cur_rx = vp->dirty_rx = 0;
                /* Initialize the RxEarly register as recommended. */
-               outw(SetRxThreshold + (1536>>2), ioaddr + EL3_CMD);
-               outl(0x0020, ioaddr + PktStatus);
-               outl(vp->rx_ring_dma, ioaddr + UpListPtr);
+               iowrite16(SetRxThreshold + (1536>>2), ioaddr + EL3_CMD);
+               iowrite32(0x0020, ioaddr + PktStatus);
+               iowrite32(vp->rx_ring_dma, ioaddr + UpListPtr);
        }
        if (vp->full_bus_master_tx) {           /* Boomerang bus master Tx. */
                vp->cur_tx = vp->dirty_tx = 0;
                if (vp->drv_flags & IS_BOOMERANG)
-                       outb(PKT_BUF_SZ>>8, ioaddr + TxFreeThreshold); /* Room for a packet. */
+                       iowrite8(PKT_BUF_SZ>>8, ioaddr + TxFreeThreshold); /* Room for a packet. */
                /* Clear the Rx, Tx rings. */
                for (i = 0; i < RX_RING_SIZE; i++)      /* AKPM: this is done in vortex_open, too */
                        vp->rx_ring[i].status = 0;
                for (i = 0; i < TX_RING_SIZE; i++)
                        vp->tx_skbuff[i] = NULL;
-               outl(0, ioaddr + DownListPtr);
+               iowrite32(0, ioaddr + DownListPtr);
        }
        /* Set receiver mode: presumably accept b-case and phys addr only. */
        set_rx_mode(dev);
        /* enable 802.1q tagged frames */
        set_8021q_mode(dev, 1);
-       outw(StatsEnable, ioaddr + EL3_CMD); /* Turn on statistics. */
+       iowrite16(StatsEnable, ioaddr + EL3_CMD); /* Turn on statistics. */
 
-//     issue_and_wait(dev, SetTxStart|0x07ff);
-       outw(RxEnable, ioaddr + EL3_CMD); /* Enable the receiver. */
-       outw(TxEnable, ioaddr + EL3_CMD); /* Enable transmitter. */
+       iowrite16(RxEnable, ioaddr + EL3_CMD); /* Enable the receiver. */
+       iowrite16(TxEnable, ioaddr + EL3_CMD); /* Enable transmitter. */
        /* Allow status bits to be seen. */
        vp->status_enable = SetStatusEnb | HostError|IntReq|StatsFull|TxComplete|
                (vp->full_bus_master_tx ? DownComplete : TxAvailable) |
@@ -1764,13 +1819,13 @@ vortex_up(struct net_device *dev)
                (vp->full_bus_master_rx ? 0 : RxComplete) |
                StatsFull | HostError | TxComplete | IntReq
                | (vp->bus_master ? DMADone : 0) | UpComplete | DownComplete;
-       outw(vp->status_enable, ioaddr + EL3_CMD);
+       iowrite16(vp->status_enable, ioaddr + EL3_CMD);
        /* Ack all pending events, and set active indicator mask. */
-       outw(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq,
+       iowrite16(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq,
                 ioaddr + EL3_CMD);
-       outw(vp->intr_enable, ioaddr + EL3_CMD);
+       iowrite16(vp->intr_enable, ioaddr + EL3_CMD);
        if (vp->cb_fn_base)                     /* The PCMCIA people are idiots.  */
-               writel(0x8000, vp->cb_fn_base + 4);
+               iowrite32(0x8000, vp->cb_fn_base + 4);
        netif_start_queue (dev);
 }
 
@@ -1802,7 +1857,7 @@ vortex_open(struct net_device *dev)
                                break;                  /* Bad news!  */
                        skb->dev = dev;                 /* Mark as being used by this device. */
                        skb_reserve(skb, 2);    /* Align IP on 16 byte boundaries */
-                       vp->rx_ring[i].addr = cpu_to_le32(pci_map_single(VORTEX_PCI(vp), skb->tail, PKT_BUF_SZ, PCI_DMA_FROMDEVICE));
+                       vp->rx_ring[i].addr = cpu_to_le32(pci_map_single(VORTEX_PCI(vp), skb->data, PKT_BUF_SZ, PCI_DMA_FROMDEVICE));
                }
                if (i != RX_RING_SIZE) {
                        int j;
@@ -1836,10 +1891,10 @@ vortex_timer(unsigned long data)
 {
        struct net_device *dev = (struct net_device *)data;
        struct vortex_private *vp = netdev_priv(dev);
-       long ioaddr = dev->base_addr;
+       void __iomem *ioaddr = vp->ioaddr;
        int next_tick = 60*HZ;
        int ok = 0;
-       int media_status, mii_status, old_window;
+       int media_status, old_window;
 
        if (vortex_debug > 2) {
                printk(KERN_DEBUG "%s: Media selection timer tick happened, %s.\n",
@@ -1847,12 +1902,10 @@ vortex_timer(unsigned long data)
                printk(KERN_DEBUG "dev->watchdog_timeo=%d\n", dev->watchdog_timeo);
        }
 
-       if (vp->medialock)
-               goto leave_media_alone;
        disable_irq(dev->irq);
-       old_window = inw(ioaddr + EL3_CMD) >> 13;
+       old_window = ioread16(ioaddr + EL3_CMD) >> 13;
        EL3WINDOW(4);
-       media_status = inw(ioaddr + Wn4_Media);
+       media_status = ioread16(ioaddr + Wn4_Media);
        switch (dev->if_port) {
        case XCVR_10baseT:  case XCVR_100baseTx:  case XCVR_100baseFx:
                if (media_status & Media_LnkBeat) {
@@ -1871,40 +1924,9 @@ vortex_timer(unsigned long data)
                break;
        case XCVR_MII: case XCVR_NWAY:
                {
-                       spin_lock_bh(&vp->lock);
-                       mii_status = mdio_read(dev, vp->phys[0], 1);
                        ok = 1;
-                       if (vortex_debug > 2)
-                               printk(KERN_DEBUG "%s: MII transceiver has status %4.4x.\n",
-                                       dev->name, mii_status);
-                       if (mii_status & BMSR_LSTATUS) {
-                               int mii_reg5 = mdio_read(dev, vp->phys[0], 5);
-                               if (! vp->force_fd  &&  mii_reg5 != 0xffff) {
-                                       int duplex;
-
-                                       mii_reg5 &= vp->advertising;
-                                       duplex = (mii_reg5&0x0100) || (mii_reg5 & 0x01C0) == 0x0040;
-                                       if (vp->full_duplex != duplex) {
-                                               vp->full_duplex = duplex;
-                                               printk(KERN_INFO "%s: Setting %s-duplex based on MII "
-                                                       "#%d link partner capability of %4.4x.\n",
-                                                       dev->name, vp->full_duplex ? "full" : "half",
-                                                       vp->phys[0], mii_reg5);
-                                               /* Set the full-duplex bit. */
-                                               EL3WINDOW(3);
-                                               outw(   (vp->full_duplex ? 0x20 : 0) |
-                                                               (vp->large_frames ? 0x40 : 0) |
-                                                               ((vp->full_duplex && vp->flow_ctrl && vp->partner_flow_ctrl) ? 0x100 : 0),
-                                                               ioaddr + Wn3_MAC_Ctrl);
-                                               if (vortex_debug > 1)
-                                                       printk(KERN_DEBUG "Setting duplex in Wn3_MAC_Ctrl\n");
-                                               /* AKPM: bug: should reset Tx and Rx after setting Duplex.  Page 180 */
-                                       }
-                               }
-                               netif_carrier_on(dev);
-                       } else {
-                               netif_carrier_off(dev);
-                       }
+                       spin_lock_bh(&vp->lock);
+                       vortex_check_media(dev, 0);
                        spin_unlock_bh(&vp->lock);
                }
                break;
@@ -1914,7 +1936,14 @@ vortex_timer(unsigned long data)
                                 dev->name, media_tbl[dev->if_port].name, media_status);
                ok = 1;
        }
-       if ( ! ok) {
+
+       if (!netif_carrier_ok(dev))
+               next_tick = 5*HZ;
+
+       if (vp->medialock)
+               goto leave_media_alone;
+
+       if (!ok) {
                unsigned int config;
 
                do {
@@ -1933,53 +1962,53 @@ vortex_timer(unsigned long data)
                                           dev->name, media_tbl[dev->if_port].name);
                        next_tick = media_tbl[dev->if_port].wait;
                }
-               outw((media_status & ~(Media_10TP|Media_SQE)) |
+               iowrite16((media_status & ~(Media_10TP|Media_SQE)) |
                         media_tbl[dev->if_port].media_bits, ioaddr + Wn4_Media);
 
                EL3WINDOW(3);
-               config = inl(ioaddr + Wn3_Config);
+               config = ioread32(ioaddr + Wn3_Config);
                config = BFINS(config, dev->if_port, 20, 4);
-               outl(config, ioaddr + Wn3_Config);
+               iowrite32(config, ioaddr + Wn3_Config);
 
-               outw(dev->if_port == XCVR_10base2 ? StartCoax : StopCoax,
+               iowrite16(dev->if_port == XCVR_10base2 ? StartCoax : StopCoax,
                         ioaddr + EL3_CMD);
                if (vortex_debug > 1)
                        printk(KERN_DEBUG "wrote 0x%08x to Wn3_Config\n", config);
                /* AKPM: FIXME: Should reset Rx & Tx here.  P60 of 3c90xc.pdf */
        }
-       EL3WINDOW(old_window);
-       enable_irq(dev->irq);
 
 leave_media_alone:
        if (vortex_debug > 2)
          printk(KERN_DEBUG "%s: Media selection timer finished, %s.\n",
                         dev->name, media_tbl[dev->if_port].name);
 
+       EL3WINDOW(old_window);
+       enable_irq(dev->irq);
        mod_timer(&vp->timer, RUN_AT(next_tick));
        if (vp->deferred)
-               outw(FakeIntr, ioaddr + EL3_CMD);
+               iowrite16(FakeIntr, ioaddr + EL3_CMD);
        return;
 }
 
 static void vortex_tx_timeout(struct net_device *dev)
 {
        struct vortex_private *vp = netdev_priv(dev);
-       long ioaddr = dev->base_addr;
+       void __iomem *ioaddr = vp->ioaddr;
 
        printk(KERN_ERR "%s: transmit timed out, tx_status %2.2x status %4.4x.\n",
-                  dev->name, inb(ioaddr + TxStatus),
-                  inw(ioaddr + EL3_STATUS));
+                  dev->name, ioread8(ioaddr + TxStatus),
+                  ioread16(ioaddr + EL3_STATUS));
        EL3WINDOW(4);
        printk(KERN_ERR "  diagnostics: net %04x media %04x dma %08x fifo %04x\n",
-                       inw(ioaddr + Wn4_NetDiag),
-                       inw(ioaddr + Wn4_Media),
-                       inl(ioaddr + PktStatus),
-                       inw(ioaddr + Wn4_FIFODiag));
+                       ioread16(ioaddr + Wn4_NetDiag),
+                       ioread16(ioaddr + Wn4_Media),
+                       ioread32(ioaddr + PktStatus),
+                       ioread16(ioaddr + Wn4_FIFODiag));
        /* Slight code bloat to be user friendly. */
-       if ((inb(ioaddr + TxStatus) & 0x88) == 0x88)
+       if ((ioread8(ioaddr + TxStatus) & 0x88) == 0x88)
                printk(KERN_ERR "%s: Transmitter encountered 16 collisions --"
                           " network cable problem?\n", dev->name);
-       if (inw(ioaddr + EL3_STATUS) & IntLatch) {
+       if (ioread16(ioaddr + EL3_STATUS) & IntLatch) {
                printk(KERN_ERR "%s: Interrupt posted but not delivered --"
                           " IRQ blocked by another device?\n", dev->name);
                /* Bad idea here.. but we might as well handle a few events. */
@@ -2005,21 +2034,21 @@ static void vortex_tx_timeout(struct net_device *dev)
        vp->stats.tx_errors++;
        if (vp->full_bus_master_tx) {
                printk(KERN_DEBUG "%s: Resetting the Tx ring pointer.\n", dev->name);
-               if (vp->cur_tx - vp->dirty_tx > 0  &&  inl(ioaddr + DownListPtr) == 0)
-                       outl(vp->tx_ring_dma + (vp->dirty_tx % TX_RING_SIZE) * sizeof(struct boom_tx_desc),
+               if (vp->cur_tx - vp->dirty_tx > 0  &&  ioread32(ioaddr + DownListPtr) == 0)
+                       iowrite32(vp->tx_ring_dma + (vp->dirty_tx % TX_RING_SIZE) * sizeof(struct boom_tx_desc),
                                 ioaddr + DownListPtr);
                if (vp->cur_tx - vp->dirty_tx < TX_RING_SIZE)
                        netif_wake_queue (dev);
                if (vp->drv_flags & IS_BOOMERANG)
-                       outb(PKT_BUF_SZ>>8, ioaddr + TxFreeThreshold);
-               outw(DownUnstall, ioaddr + EL3_CMD);
+                       iowrite8(PKT_BUF_SZ>>8, ioaddr + TxFreeThreshold);
+               iowrite16(DownUnstall, ioaddr + EL3_CMD);
        } else {
                vp->stats.tx_dropped++;
                netif_wake_queue(dev);
        }
        
        /* Issue Tx Enable */
-       outw(TxEnable, ioaddr + EL3_CMD);
+       iowrite16(TxEnable, ioaddr + EL3_CMD);
        dev->trans_start = jiffies;
        
        /* Switch to register set 7 for normal use. */
@@ -2034,7 +2063,7 @@ static void
 vortex_error(struct net_device *dev, int status)
 {
        struct vortex_private *vp = netdev_priv(dev);
-       long ioaddr = dev->base_addr;
+       void __iomem *ioaddr = vp->ioaddr;
        int do_tx_reset = 0, reset_mask = 0;
        unsigned char tx_status = 0;
 
@@ -2043,7 +2072,7 @@ vortex_error(struct net_device *dev, int status)
        }
 
        if (status & TxComplete) {                      /* Really "TxError" for us. */
-               tx_status = inb(ioaddr + TxStatus);
+               tx_status = ioread8(ioaddr + TxStatus);
                /* Presumably a tx-timeout. We must merely re-enable. */
                if (vortex_debug > 2
                        || (tx_status != 0x88 && vortex_debug > 0)) {
@@ -2057,20 +2086,21 @@ vortex_error(struct net_device *dev, int status)
                }
                if (tx_status & 0x14)  vp->stats.tx_fifo_errors++;
                if (tx_status & 0x38)  vp->stats.tx_aborted_errors++;
-               outb(0, ioaddr + TxStatus);
+               if (tx_status & 0x08)  vp->xstats.tx_max_collisions++;
+               iowrite8(0, ioaddr + TxStatus);
                if (tx_status & 0x30) {                 /* txJabber or txUnderrun */
                        do_tx_reset = 1;
-               } else if ((tx_status & 0x08) && (vp->drv_flags & MAX_COLLISION_RESET))       /* maxCollisions */
+               } else if ((tx_status & 0x08) && (vp->drv_flags & MAX_COLLISION_RESET))  {      /* maxCollisions */
                        do_tx_reset = 1;
                        reset_mask = 0x0108;            /* Reset interface logic, but not download logic */
-               } else {                                                /* Merely re-enable the transmitter. */
-                       outw(TxEnable, ioaddr + EL3_CMD);
+               } else {                                /* Merely re-enable the transmitter. */
+                       iowrite16(TxEnable, ioaddr + EL3_CMD);
                }
        }
 
        if (status & RxEarly) {                         /* Rx early is unused. */
                vortex_rx(dev);
-               outw(AckIntr | RxEarly, ioaddr + EL3_CMD);
+               iowrite16(AckIntr | RxEarly, ioaddr + EL3_CMD);
        }
        if (status & StatsFull) {                       /* Empty statistics. */
                static int DoneDidThat;
@@ -2080,29 +2110,29 @@ vortex_error(struct net_device *dev, int status)
                /* HACK: Disable statistics as an interrupt source. */
                /* This occurs when we have the wrong media type! */
                if (DoneDidThat == 0  &&
-                       inw(ioaddr + EL3_STATUS) & StatsFull) {
+                       ioread16(ioaddr + EL3_STATUS) & StatsFull) {
                        printk(KERN_WARNING "%s: Updating statistics failed, disabling "
                                   "stats as an interrupt source.\n", dev->name);
                        EL3WINDOW(5);
-                       outw(SetIntrEnb | (inw(ioaddr + 10) & ~StatsFull), ioaddr + EL3_CMD);
+                       iowrite16(SetIntrEnb | (ioread16(ioaddr + 10) & ~StatsFull), ioaddr + EL3_CMD);
                        vp->intr_enable &= ~StatsFull;
                        EL3WINDOW(7);
                        DoneDidThat++;
                }
        }
        if (status & IntReq) {          /* Restore all interrupt sources.  */
-               outw(vp->status_enable, ioaddr + EL3_CMD);
-               outw(vp->intr_enable, ioaddr + EL3_CMD);
+               iowrite16(vp->status_enable, ioaddr + EL3_CMD);
+               iowrite16(vp->intr_enable, ioaddr + EL3_CMD);
        }
        if (status & HostError) {
                u16 fifo_diag;
                EL3WINDOW(4);
-               fifo_diag = inw(ioaddr + Wn4_FIFODiag);
+               fifo_diag = ioread16(ioaddr + Wn4_FIFODiag);
                printk(KERN_ERR "%s: Host error, FIFO diagnostic register %4.4x.\n",
                           dev->name, fifo_diag);
                /* Adapter failure requires Tx/Rx reset and reinit. */
                if (vp->full_bus_master_tx) {
-                       int bus_status = inl(ioaddr + PktStatus);
+                       int bus_status = ioread32(ioaddr + PktStatus);
                        /* 0x80000000 PCI master abort. */
                        /* 0x40000000 PCI target abort. */
                        if (vortex_debug)
@@ -2122,14 +2152,14 @@ vortex_error(struct net_device *dev, int status)
                        set_rx_mode(dev);
                        /* enable 802.1q VLAN tagged frames */
                        set_8021q_mode(dev, 1);
-                       outw(RxEnable, ioaddr + EL3_CMD); /* Re-enable the receiver. */
-                       outw(AckIntr | HostError, ioaddr + EL3_CMD);
+                       iowrite16(RxEnable, ioaddr + EL3_CMD); /* Re-enable the receiver. */
+                       iowrite16(AckIntr | HostError, ioaddr + EL3_CMD);
                }
        }
 
        if (do_tx_reset) {
                issue_and_wait(dev, TxReset|reset_mask);
-               outw(TxEnable, ioaddr + EL3_CMD);
+               iowrite16(TxEnable, ioaddr + EL3_CMD);
                if (!vp->full_bus_master_tx)
                        netif_wake_queue(dev);
        }
@@ -2139,29 +2169,29 @@ static int
 vortex_start_xmit(struct sk_buff *skb, struct net_device *dev)
 {
        struct vortex_private *vp = netdev_priv(dev);
-       long ioaddr = dev->base_addr;
+       void __iomem *ioaddr = vp->ioaddr;
 
        /* Put out the doubleword header... */
-       outl(skb->len, ioaddr + TX_FIFO);
+       iowrite32(skb->len, ioaddr + TX_FIFO);
        if (vp->bus_master) {
                /* Set the bus-master controller to transfer the packet. */
                int len = (skb->len + 3) & ~3;
-               outl(   vp->tx_skb_dma = pci_map_single(VORTEX_PCI(vp), skb->data, len, PCI_DMA_TODEVICE),
+               iowrite32(vp->tx_skb_dma = pci_map_single(VORTEX_PCI(vp), skb->data, len, PCI_DMA_TODEVICE),
                                ioaddr + Wn7_MasterAddr);
-               outw(len, ioaddr + Wn7_MasterLen);
+               iowrite16(len, ioaddr + Wn7_MasterLen);
                vp->tx_skb = skb;
-               outw(StartDMADown, ioaddr + EL3_CMD);
+               iowrite16(StartDMADown, ioaddr + EL3_CMD);
                /* netif_wake_queue() will be called at the DMADone interrupt. */
        } else {
                /* ... and the packet rounded to a doubleword. */
-               outsl(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2);
+               iowrite32_rep(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2);
                dev_kfree_skb (skb);
-               if (inw(ioaddr + TxFree) > 1536) {
+               if (ioread16(ioaddr + TxFree) > 1536) {
                        netif_start_queue (dev);        /* AKPM: redundant? */
                } else {
                        /* Interrupt us when the FIFO has room for max-sized packet. */
                        netif_stop_queue(dev);
-                       outw(SetTxThreshold + (1536>>2), ioaddr + EL3_CMD);
+                       iowrite16(SetTxThreshold + (1536>>2), ioaddr + EL3_CMD);
                }
        }
 
@@ -2172,7 +2202,7 @@ vortex_start_xmit(struct sk_buff *skb, struct net_device *dev)
                int tx_status;
                int i = 32;
 
-               while (--i > 0  &&      (tx_status = inb(ioaddr + TxStatus)) > 0) {
+               while (--i > 0  &&      (tx_status = ioread8(ioaddr + TxStatus)) > 0) {
                        if (tx_status & 0x3C) {         /* A Tx-disabling error occurred.  */
                                if (vortex_debug > 2)
                                  printk(KERN_DEBUG "%s: Tx error, status %2.2x.\n",
@@ -2182,9 +2212,9 @@ vortex_start_xmit(struct sk_buff *skb, struct net_device *dev)
                                if (tx_status & 0x30) {
                                        issue_and_wait(dev, TxReset);
                                }
-                               outw(TxEnable, ioaddr + EL3_CMD);
+                               iowrite16(TxEnable, ioaddr + EL3_CMD);
                        }
-                       outb(0x00, ioaddr + TxStatus); /* Pop the status stack. */
+                       iowrite8(0x00, ioaddr + TxStatus); /* Pop the status stack. */
                }
        }
        return 0;
@@ -2194,7 +2224,7 @@ static int
 boomerang_start_xmit(struct sk_buff *skb, struct net_device *dev)
 {
        struct vortex_private *vp = netdev_priv(dev);
-       long ioaddr = dev->base_addr;
+       void __iomem *ioaddr = vp->ioaddr;
        /* Calculate the next Tx descriptor entry. */
        int entry = vp->cur_tx % TX_RING_SIZE;
        struct boom_tx_desc *prev_entry = &vp->tx_ring[(vp->cur_tx-1) % TX_RING_SIZE];
@@ -2202,9 +2232,8 @@ boomerang_start_xmit(struct sk_buff *skb, struct net_device *dev)
 
        if (vortex_debug > 6) {
                printk(KERN_DEBUG "boomerang_start_xmit()\n");
-               if (vortex_debug > 3)
-                       printk(KERN_DEBUG "%s: Trying to send a packet, Tx index %d.\n",
-                                  dev->name, vp->cur_tx);
+               printk(KERN_DEBUG "%s: Trying to send a packet, Tx index %d.\n",
+                          dev->name, vp->cur_tx);
        }
 
        if (vp->cur_tx - vp->dirty_tx >= TX_RING_SIZE) {
@@ -2259,8 +2288,8 @@ boomerang_start_xmit(struct sk_buff *skb, struct net_device *dev)
        /* Wait for the stall to complete. */
        issue_and_wait(dev, DownStall);
        prev_entry->next = cpu_to_le32(vp->tx_ring_dma + entry * sizeof(struct boom_tx_desc));
-       if (inl(ioaddr + DownListPtr) == 0) {
-               outl(vp->tx_ring_dma + entry * sizeof(struct boom_tx_desc), ioaddr + DownListPtr);
+       if (ioread32(ioaddr + DownListPtr) == 0) {
+               iowrite32(vp->tx_ring_dma + entry * sizeof(struct boom_tx_desc), ioaddr + DownListPtr);
                vp->queued_packet++;
        }
 
@@ -2275,7 +2304,7 @@ boomerang_start_xmit(struct sk_buff *skb, struct net_device *dev)
                prev_entry->status &= cpu_to_le32(~TxIntrUploaded);
 #endif
        }
-       outw(DownUnstall, ioaddr + EL3_CMD);
+       iowrite16(DownUnstall, ioaddr + EL3_CMD);
        spin_unlock_irqrestore(&vp->lock, flags);
        dev->trans_start = jiffies;
        return 0;
@@ -2294,15 +2323,15 @@ vortex_interrupt(int irq, void *dev_id, struct pt_regs *regs)
 {
        struct net_device *dev = dev_id;
        struct vortex_private *vp = netdev_priv(dev);
-       long ioaddr;
+       void __iomem *ioaddr;
        int status;
        int work_done = max_interrupt_work;
        int handled = 0;
 
-       ioaddr = dev->base_addr;
+       ioaddr = vp->ioaddr;
        spin_lock(&vp->lock);
 
-       status = inw(ioaddr + EL3_STATUS);
+       status = ioread16(ioaddr + EL3_STATUS);
 
        if (vortex_debug > 6)
                printk("vortex_interrupt(). status=0x%4x\n", status);
@@ -2321,7 +2350,7 @@ vortex_interrupt(int irq, void *dev_id, struct pt_regs *regs)
 
        if (vortex_debug > 4)
                printk(KERN_DEBUG "%s: interrupt, status %4.4x, latency %d ticks.\n",
-                          dev->name, status, inb(ioaddr + Timer));
+                          dev->name, status, ioread8(ioaddr + Timer));
 
        do {
                if (vortex_debug > 5)
@@ -2334,16 +2363,16 @@ vortex_interrupt(int irq, void *dev_id, struct pt_regs *regs)
                        if (vortex_debug > 5)
                                printk(KERN_DEBUG "     TX room bit was handled.\n");
                        /* There's room in the FIFO for a full-sized packet. */
-                       outw(AckIntr | TxAvailable, ioaddr + EL3_CMD);
+                       iowrite16(AckIntr | TxAvailable, ioaddr + EL3_CMD);
                        netif_wake_queue (dev);
                }
 
                if (status & DMADone) {
-                       if (inw(ioaddr + Wn7_MasterStatus) & 0x1000) {
-                               outw(0x1000, ioaddr + Wn7_MasterStatus); /* Ack the event. */
+                       if (ioread16(ioaddr + Wn7_MasterStatus) & 0x1000) {
+                               iowrite16(0x1000, ioaddr + Wn7_MasterStatus); /* Ack the event. */
                                pci_unmap_single(VORTEX_PCI(vp), vp->tx_skb_dma, (vp->tx_skb->len + 3) & ~3, PCI_DMA_TODEVICE);
                                dev_kfree_skb_irq(vp->tx_skb); /* Release the transferred buffer */
-                               if (inw(ioaddr + TxFree) > 1536) {
+                               if (ioread16(ioaddr + TxFree) > 1536) {
                                        /*
                                         * AKPM: FIXME: I don't think we need this.  If the queue was stopped due to
                                         * insufficient FIFO room, the TxAvailable test will succeed and call
@@ -2351,7 +2380,7 @@ vortex_interrupt(int irq, void *dev_id, struct pt_regs *regs)
                                         */
                                        netif_wake_queue(dev);
                                } else { /* Interrupt when FIFO has room for max-sized packet. */
-                                       outw(SetTxThreshold + (1536>>2), ioaddr + EL3_CMD);
+                                       iowrite16(SetTxThreshold + (1536>>2), ioaddr + EL3_CMD);
                                        netif_stop_queue(dev);
                                }
                        }
@@ -2369,17 +2398,17 @@ vortex_interrupt(int irq, void *dev_id, struct pt_regs *regs)
                        /* Disable all pending interrupts. */
                        do {
                                vp->deferred |= status;
-                               outw(SetStatusEnb | (~vp->deferred & vp->status_enable),
+                               iowrite16(SetStatusEnb | (~vp->deferred & vp->status_enable),
                                         ioaddr + EL3_CMD);
-                               outw(AckIntr | (vp->deferred & 0x7ff), ioaddr + EL3_CMD);
-                       } while ((status = inw(ioaddr + EL3_CMD)) & IntLatch);
+                               iowrite16(AckIntr | (vp->deferred & 0x7ff), ioaddr + EL3_CMD);
+                       } while ((status = ioread16(ioaddr + EL3_CMD)) & IntLatch);
                        /* The timer will reenable interrupts. */
                        mod_timer(&vp->timer, jiffies + 1*HZ);
                        break;
                }
                /* Acknowledge the IRQ. */
-               outw(AckIntr | IntReq | IntLatch, ioaddr + EL3_CMD);
-       } while ((status = inw(ioaddr + EL3_STATUS)) & (IntLatch | RxComplete));
+               iowrite16(AckIntr | IntReq | IntLatch, ioaddr + EL3_CMD);
+       } while ((status = ioread16(ioaddr + EL3_STATUS)) & (IntLatch | RxComplete));
 
        if (vortex_debug > 4)
                printk(KERN_DEBUG "%s: exiting interrupt, status %4.4x.\n",
@@ -2399,11 +2428,11 @@ boomerang_interrupt(int irq, void *dev_id, struct pt_regs *regs)
 {
        struct net_device *dev = dev_id;
        struct vortex_private *vp = netdev_priv(dev);
-       long ioaddr;
+       void __iomem *ioaddr;
        int status;
        int work_done = max_interrupt_work;
 
-       ioaddr = dev->base_addr;
+       ioaddr = vp->ioaddr;
 
        /*
         * It seems dopey to put the spinlock this early, but we could race against vortex_tx_timeout
@@ -2411,7 +2440,7 @@ boomerang_interrupt(int irq, void *dev_id, struct pt_regs *regs)
         */
        spin_lock(&vp->lock);
 
-       status = inw(ioaddr + EL3_STATUS);
+       status = ioread16(ioaddr + EL3_STATUS);
 
        if (vortex_debug > 6)
                printk(KERN_DEBUG "boomerang_interrupt. status=0x%4x\n", status);
@@ -2432,13 +2461,13 @@ boomerang_interrupt(int irq, void *dev_id, struct pt_regs *regs)
 
        if (vortex_debug > 4)
                printk(KERN_DEBUG "%s: interrupt, status %4.4x, latency %d ticks.\n",
-                          dev->name, status, inb(ioaddr + Timer));
+                          dev->name, status, ioread8(ioaddr + Timer));
        do {
                if (vortex_debug > 5)
                                printk(KERN_DEBUG "%s: In interrupt loop, status %4.4x.\n",
                                           dev->name, status);
                if (status & UpComplete) {
-                       outw(AckIntr | UpComplete, ioaddr + EL3_CMD);
+                       iowrite16(AckIntr | UpComplete, ioaddr + EL3_CMD);
                        if (vortex_debug > 5)
                                printk(KERN_DEBUG "boomerang_interrupt->boomerang_rx\n");
                        boomerang_rx(dev);
@@ -2447,11 +2476,11 @@ boomerang_interrupt(int irq, void *dev_id, struct pt_regs *regs)
                if (status & DownComplete) {
                        unsigned int dirty_tx = vp->dirty_tx;
 
-                       outw(AckIntr | DownComplete, ioaddr + EL3_CMD);
+                       iowrite16(AckIntr | DownComplete, ioaddr + EL3_CMD);
                        while (vp->cur_tx - dirty_tx > 0) {
                                int entry = dirty_tx % TX_RING_SIZE;
 #if 1  /* AKPM: the latter is faster, but cyclone-only */
-                               if (inl(ioaddr + DownListPtr) ==
+                               if (ioread32(ioaddr + DownListPtr) ==
                                        vp->tx_ring_dma + entry * sizeof(struct boom_tx_desc))
                                        break;                  /* It still hasn't been processed. */
 #else
@@ -2498,20 +2527,20 @@ boomerang_interrupt(int irq, void *dev_id, struct pt_regs *regs)
                        /* Disable all pending interrupts. */
                        do {
                                vp->deferred |= status;
-                               outw(SetStatusEnb | (~vp->deferred & vp->status_enable),
+                               iowrite16(SetStatusEnb | (~vp->deferred & vp->status_enable),
                                         ioaddr + EL3_CMD);
-                               outw(AckIntr | (vp->deferred & 0x7ff), ioaddr + EL3_CMD);
-                       } while ((status = inw(ioaddr + EL3_CMD)) & IntLatch);
+                               iowrite16(AckIntr | (vp->deferred & 0x7ff), ioaddr + EL3_CMD);
+                       } while ((status = ioread16(ioaddr + EL3_CMD)) & IntLatch);
                        /* The timer will reenable interrupts. */
                        mod_timer(&vp->timer, jiffies + 1*HZ);
                        break;
                }
                /* Acknowledge the IRQ. */
-               outw(AckIntr | IntReq | IntLatch, ioaddr + EL3_CMD);
+               iowrite16(AckIntr | IntReq | IntLatch, ioaddr + EL3_CMD);
                if (vp->cb_fn_base)                     /* The PCMCIA people are idiots.  */
-                       writel(0x8000, vp->cb_fn_base + 4);
+                       iowrite32(0x8000, vp->cb_fn_base + 4);
 
-       } while ((status = inw(ioaddr + EL3_STATUS)) & IntLatch);
+       } while ((status = ioread16(ioaddr + EL3_STATUS)) & IntLatch);
 
        if (vortex_debug > 4)
                printk(KERN_DEBUG "%s: exiting interrupt, status %4.4x.\n",
@@ -2524,16 +2553,16 @@ handler_exit:
 static int vortex_rx(struct net_device *dev)
 {
        struct vortex_private *vp = netdev_priv(dev);
-       long ioaddr = dev->base_addr;
+       void __iomem *ioaddr = vp->ioaddr;
        int i;
        short rx_status;
 
        if (vortex_debug > 5)
                printk(KERN_DEBUG "vortex_rx(): status %4.4x, rx_status %4.4x.\n",
-                          inw(ioaddr+EL3_STATUS), inw(ioaddr+RxStatus));
-       while ((rx_status = inw(ioaddr + RxStatus)) > 0) {
+                          ioread16(ioaddr+EL3_STATUS), ioread16(ioaddr+RxStatus));
+       while ((rx_status = ioread16(ioaddr + RxStatus)) > 0) {
                if (rx_status & 0x4000) { /* Error, update stats. */
-                       unsigned char rx_error = inb(ioaddr + RxErrors);
+                       unsigned char rx_error = ioread8(ioaddr + RxErrors);
                        if (vortex_debug > 2)
                                printk(KERN_DEBUG " Rx error: status %2.2x.\n", rx_error);
                        vp->stats.rx_errors++;
@@ -2556,34 +2585,35 @@ static int vortex_rx(struct net_device *dev)
                                skb_reserve(skb, 2);    /* Align IP on 16 byte boundaries */
                                /* 'skb_put()' points to the start of sk_buff data area. */
                                if (vp->bus_master &&
-                                       ! (inw(ioaddr + Wn7_MasterStatus) & 0x8000)) {
+                                       ! (ioread16(ioaddr + Wn7_MasterStatus) & 0x8000)) {
                                        dma_addr_t dma = pci_map_single(VORTEX_PCI(vp), skb_put(skb, pkt_len),
                                                                           pkt_len, PCI_DMA_FROMDEVICE);
-                                       outl(dma, ioaddr + Wn7_MasterAddr);
-                                       outw((skb->len + 3) & ~3, ioaddr + Wn7_MasterLen);
-                                       outw(StartDMAUp, ioaddr + EL3_CMD);
-                                       while (inw(ioaddr + Wn7_MasterStatus) & 0x8000)
+                                       iowrite32(dma, ioaddr + Wn7_MasterAddr);
+                                       iowrite16((skb->len + 3) & ~3, ioaddr + Wn7_MasterLen);
+                                       iowrite16(StartDMAUp, ioaddr + EL3_CMD);
+                                       while (ioread16(ioaddr + Wn7_MasterStatus) & 0x8000)
                                                ;
                                        pci_unmap_single(VORTEX_PCI(vp), dma, pkt_len, PCI_DMA_FROMDEVICE);
                                } else {
-                                       insl(ioaddr + RX_FIFO, skb_put(skb, pkt_len),
-                                                (pkt_len + 3) >> 2);
+                                       ioread32_rep(ioaddr + RX_FIFO,
+                                                    skb_put(skb, pkt_len),
+                                                    (pkt_len + 3) >> 2);
                                }
-                               outw(RxDiscard, ioaddr + EL3_CMD); /* Pop top Rx packet. */
+                               iowrite16(RxDiscard, ioaddr + EL3_CMD); /* Pop top Rx packet. */
                                skb->protocol = eth_type_trans(skb, dev);
                                netif_rx(skb);
                                dev->last_rx = jiffies;
                                vp->stats.rx_packets++;
                                /* Wait a limited time to go to next packet. */
                                for (i = 200; i >= 0; i--)
-                                       if ( ! (inw(ioaddr + EL3_STATUS) & CmdInProgress))
+                                       if ( ! (ioread16(ioaddr + EL3_STATUS) & CmdInProgress))
                                                break;
                                continue;
                        } else if (vortex_debug > 0)
                                printk(KERN_NOTICE "%s: No memory to allocate a sk_buff of "
                                           "size %d.\n", dev->name, pkt_len);
+                       vp->stats.rx_dropped++;
                }
-               vp->stats.rx_dropped++;
                issue_and_wait(dev, RxDiscard);
        }
 
@@ -2595,12 +2625,12 @@ boomerang_rx(struct net_device *dev)
 {
        struct vortex_private *vp = netdev_priv(dev);
        int entry = vp->cur_rx % RX_RING_SIZE;
-       long ioaddr = dev->base_addr;
+       void __iomem *ioaddr = vp->ioaddr;
        int rx_status;
        int rx_work_limit = vp->dirty_rx + RX_RING_SIZE - vp->cur_rx;
 
        if (vortex_debug > 5)
-               printk(KERN_DEBUG "boomerang_rx(): status %4.4x\n", inw(ioaddr+EL3_STATUS));
+               printk(KERN_DEBUG "boomerang_rx(): status %4.4x\n", ioread16(ioaddr+EL3_STATUS));
 
        while ((rx_status = le32_to_cpu(vp->rx_ring[entry].status)) & RxDComplete){
                if (--rx_work_limit < 0)
@@ -2633,7 +2663,7 @@ boomerang_rx(struct net_device *dev)
                                pci_dma_sync_single_for_cpu(VORTEX_PCI(vp), dma, PKT_BUF_SZ, PCI_DMA_FROMDEVICE);
                                /* 'skb_put()' points to the start of sk_buff data area. */
                                memcpy(skb_put(skb, pkt_len),
-                                          vp->rx_skbuff[entry]->tail,
+                                          vp->rx_skbuff[entry]->data,
                                           pkt_len);
                                pci_dma_sync_single_for_device(VORTEX_PCI(vp), dma, PKT_BUF_SZ, PCI_DMA_FROMDEVICE);
                                vp->rx_copy++;
@@ -2669,7 +2699,7 @@ boomerang_rx(struct net_device *dev)
                        skb = dev_alloc_skb(PKT_BUF_SZ);
                        if (skb == NULL) {
                                static unsigned long last_jif;
-                               if ((jiffies - last_jif) > 10 * HZ) {
+                               if (time_after(jiffies, last_jif + 10 * HZ)) {
                                        printk(KERN_WARNING "%s: memory shortage\n", dev->name);
                                        last_jif = jiffies;
                                }
@@ -2679,11 +2709,11 @@ boomerang_rx(struct net_device *dev)
                        }
                        skb->dev = dev;                 /* Mark as being used by this device. */
                        skb_reserve(skb, 2);    /* Align IP on 16 byte boundaries */
-                       vp->rx_ring[entry].addr = cpu_to_le32(pci_map_single(VORTEX_PCI(vp), skb->tail, PKT_BUF_SZ, PCI_DMA_FROMDEVICE));
+                       vp->rx_ring[entry].addr = cpu_to_le32(pci_map_single(VORTEX_PCI(vp), skb->data, PKT_BUF_SZ, PCI_DMA_FROMDEVICE));
                        vp->rx_skbuff[entry] = skb;
                }
                vp->rx_ring[entry].status = 0;  /* Clear complete bit. */
-               outw(UpUnstall, ioaddr + EL3_CMD);
+               iowrite16(UpUnstall, ioaddr + EL3_CMD);
        }
        return 0;
 }
@@ -2712,7 +2742,7 @@ static void
 vortex_down(struct net_device *dev, int final_down)
 {
        struct vortex_private *vp = netdev_priv(dev);
-       long ioaddr = dev->base_addr;
+       void __iomem *ioaddr = vp->ioaddr;
 
        netif_stop_queue (dev);
 
@@ -2720,26 +2750,26 @@ vortex_down(struct net_device *dev, int final_down)
        del_timer_sync(&vp->timer);
 
        /* Turn off statistics ASAP.  We update vp->stats below. */
-       outw(StatsDisable, ioaddr + EL3_CMD);
+       iowrite16(StatsDisable, ioaddr + EL3_CMD);
 
        /* Disable the receiver and transmitter. */
-       outw(RxDisable, ioaddr + EL3_CMD);
-       outw(TxDisable, ioaddr + EL3_CMD);
+       iowrite16(RxDisable, ioaddr + EL3_CMD);
+       iowrite16(TxDisable, ioaddr + EL3_CMD);
 
        /* Disable receiving 802.1q tagged frames */
        set_8021q_mode(dev, 0);
 
        if (dev->if_port == XCVR_10base2)
                /* Turn off thinnet power.  Green! */
-               outw(StopCoax, ioaddr + EL3_CMD);
+               iowrite16(StopCoax, ioaddr + EL3_CMD);
 
-       outw(SetIntrEnb | 0x0000, ioaddr + EL3_CMD);
+       iowrite16(SetIntrEnb | 0x0000, ioaddr + EL3_CMD);
 
        update_stats(ioaddr, dev);
        if (vp->full_bus_master_rx)
-               outl(0, ioaddr + UpListPtr);
+               iowrite32(0, ioaddr + UpListPtr);
        if (vp->full_bus_master_tx)
-               outl(0, ioaddr + DownListPtr);
+               iowrite32(0, ioaddr + DownListPtr);
 
        if (final_down && VORTEX_PCI(vp)) {
                vp->pm_state_valid = 1;
@@ -2752,7 +2782,7 @@ static int
 vortex_close(struct net_device *dev)
 {
        struct vortex_private *vp = netdev_priv(dev);
-       long ioaddr = dev->base_addr;
+       void __iomem *ioaddr = vp->ioaddr;
        int i;
 
        if (netif_device_present(dev))
@@ -2760,17 +2790,18 @@ vortex_close(struct net_device *dev)
 
        if (vortex_debug > 1) {
                printk(KERN_DEBUG"%s: vortex_close() status %4.4x, Tx status %2.2x.\n",
-                          dev->name, inw(ioaddr + EL3_STATUS), inb(ioaddr + TxStatus));
+                          dev->name, ioread16(ioaddr + EL3_STATUS), ioread8(ioaddr + TxStatus));
                printk(KERN_DEBUG "%s: vortex close stats: rx_nocopy %d rx_copy %d"
                           " tx_queued %d Rx pre-checksummed %d.\n",
                           dev->name, vp->rx_nocopy, vp->rx_copy, vp->queued_packet, vp->rx_csumhits);
        }
 
 #if DO_ZEROCOPY
-       if (    vp->rx_csumhits &&
-                       ((vp->drv_flags & HAS_HWCKSM) == 0) &&
-                       (hw_checksums[vp->card_idx] == -1)) {
-               printk(KERN_WARNING "%s supports hardware checksums, and we're not using them!\n", dev->name);
+       if (vp->rx_csumhits &&
+           (vp->drv_flags & HAS_HWCKSM) == 0 &&
+           (vp->card_idx >= MAX_UNITS || hw_checksums[vp->card_idx] == -1)) {
+                       printk(KERN_WARNING "%s supports hardware checksums, and we're "
+                                               "not using them!\n", dev->name);
        }
 #endif
                
@@ -2814,18 +2845,18 @@ dump_tx_ring(struct net_device *dev)
 {
        if (vortex_debug > 0) {
        struct vortex_private *vp = netdev_priv(dev);
-               long ioaddr = dev->base_addr;
+               void __iomem *ioaddr = vp->ioaddr;
                
                if (vp->full_bus_master_tx) {
                        int i;
-                       int stalled = inl(ioaddr + PktStatus) & 0x04;   /* Possible racy. But it's only debug stuff */
+                       int stalled = ioread32(ioaddr + PktStatus) & 0x04;      /* Possible racy. But it's only debug stuff */
 
                        printk(KERN_ERR "  Flags; bus-master %d, dirty %d(%d) current %d(%d)\n",
                                        vp->full_bus_master_tx,
                                        vp->dirty_tx, vp->dirty_tx % TX_RING_SIZE,
                                        vp->cur_tx, vp->cur_tx % TX_RING_SIZE);
                        printk(KERN_ERR "  Transmit list %8.8x vs. %p.\n",
-                                  inl(ioaddr + DownListPtr),
+                                  ioread32(ioaddr + DownListPtr),
                                   &vp->tx_ring[vp->dirty_tx % TX_RING_SIZE]);
                        issue_and_wait(dev, DownStall);
                        for (i = 0; i < TX_RING_SIZE; i++) {
@@ -2839,7 +2870,7 @@ dump_tx_ring(struct net_device *dev)
                                           le32_to_cpu(vp->tx_ring[i].status));
                        }
                        if (!stalled)
-                               outw(DownUnstall, ioaddr + EL3_CMD);
+                               iowrite16(DownUnstall, ioaddr + EL3_CMD);
                }
        }
 }
@@ -2847,11 +2878,12 @@ dump_tx_ring(struct net_device *dev)
 static struct net_device_stats *vortex_get_stats(struct net_device *dev)
 {
        struct vortex_private *vp = netdev_priv(dev);
+       void __iomem *ioaddr = vp->ioaddr;
        unsigned long flags;
 
        if (netif_device_present(dev)) {        /* AKPM: Used to be netif_running */
                spin_lock_irqsave (&vp->lock, flags);
-               update_stats(dev->base_addr, dev);
+               update_stats(ioaddr, dev);
                spin_unlock_irqrestore (&vp->lock, flags);
        }
        return &vp->stats;
@@ -2864,37 +2896,41 @@ static struct net_device_stats *vortex_get_stats(struct net_device *dev)
        table.  This is done by checking that the ASM (!) code generated uses
        atomic updates with '+='.
        */
-static void update_stats(long ioaddr, struct net_device *dev)
+static void update_stats(void __iomem *ioaddr, struct net_device *dev)
 {
        struct vortex_private *vp = netdev_priv(dev);
-       int old_window = inw(ioaddr + EL3_CMD);
+       int old_window = ioread16(ioaddr + EL3_CMD);
 
        if (old_window == 0xffff)       /* Chip suspended or ejected. */
                return;
        /* Unlike the 3c5x9 we need not turn off stats updates while reading. */
        /* Switch to the stats window, and read everything. */
        EL3WINDOW(6);
-       vp->stats.tx_carrier_errors             += inb(ioaddr + 0);
-       vp->stats.tx_heartbeat_errors           += inb(ioaddr + 1);
-       vp->stats.collisions                    += inb(ioaddr + 3);
-       vp->stats.tx_window_errors              += inb(ioaddr + 4);
-       vp->stats.rx_fifo_errors                += inb(ioaddr + 5);
-       vp->stats.tx_packets                    += inb(ioaddr + 6);
-       vp->stats.tx_packets                    += (inb(ioaddr + 9)&0x30) << 4;
-       /* Rx packets   */                      inb(ioaddr + 7);   /* Must read to clear */
+       vp->stats.tx_carrier_errors             += ioread8(ioaddr + 0);
+       vp->stats.tx_heartbeat_errors           += ioread8(ioaddr + 1);
+       vp->stats.tx_window_errors              += ioread8(ioaddr + 4);
+       vp->stats.rx_fifo_errors                += ioread8(ioaddr + 5);
+       vp->stats.tx_packets                    += ioread8(ioaddr + 6);
+       vp->stats.tx_packets                    += (ioread8(ioaddr + 9)&0x30) << 4;
+       /* Rx packets   */                      ioread8(ioaddr + 7);   /* Must read to clear */
        /* Don't bother with register 9, an extension of registers 6&7.
           If we do use the 6&7 values the atomic update assumption above
           is invalid. */
-       vp->stats.rx_bytes                      += inw(ioaddr + 10);
-       vp->stats.tx_bytes                      += inw(ioaddr + 12);
+       vp->stats.rx_bytes                      += ioread16(ioaddr + 10);
+       vp->stats.tx_bytes                      += ioread16(ioaddr + 12);
        /* Extra stats for get_ethtool_stats() */
-       vp->xstats.tx_multiple_collisions       += inb(ioaddr + 2);
-       vp->xstats.tx_deferred                  += inb(ioaddr + 8);
+       vp->xstats.tx_multiple_collisions       += ioread8(ioaddr + 2);
+       vp->xstats.tx_single_collisions         += ioread8(ioaddr + 3);
+       vp->xstats.tx_deferred                  += ioread8(ioaddr + 8);
        EL3WINDOW(4);
-       vp->xstats.rx_bad_ssd                   += inb(ioaddr + 12);
+       vp->xstats.rx_bad_ssd                   += ioread8(ioaddr + 12);
+
+       vp->stats.collisions = vp->xstats.tx_multiple_collisions
+               + vp->xstats.tx_single_collisions
+               + vp->xstats.tx_max_collisions;
 
        {
-               u8 up = inb(ioaddr + 13);
+               u8 up = ioread8(ioaddr + 13);
                vp->stats.rx_bytes += (up & 0x0f) << 16;
                vp->stats.tx_bytes += (up & 0xf0) << 12;
        }
@@ -2906,7 +2942,7 @@ static void update_stats(long ioaddr, struct net_device *dev)
 static int vortex_nway_reset(struct net_device *dev)
 {
        struct vortex_private *vp = netdev_priv(dev);
-       long ioaddr = dev->base_addr;
+       void __iomem *ioaddr = vp->ioaddr;
        unsigned long flags;
        int rc;
 
@@ -2917,24 +2953,10 @@ static int vortex_nway_reset(struct net_device *dev)
        return rc;
 }
 
-static u32 vortex_get_link(struct net_device *dev)
-{
-       struct vortex_private *vp = netdev_priv(dev);
-       long ioaddr = dev->base_addr;
-       unsigned long flags;
-       int rc;
-
-       spin_lock_irqsave(&vp->lock, flags);
-       EL3WINDOW(4);
-       rc = mii_link_ok(&vp->mii);
-       spin_unlock_irqrestore(&vp->lock, flags);
-       return rc;
-}
-
 static int vortex_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
 {
        struct vortex_private *vp = netdev_priv(dev);
-       long ioaddr = dev->base_addr;
+       void __iomem *ioaddr = vp->ioaddr;
        unsigned long flags;
        int rc;
 
@@ -2948,7 +2970,7 @@ static int vortex_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
 static int vortex_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
 {
        struct vortex_private *vp = netdev_priv(dev);
-       long ioaddr = dev->base_addr;
+       void __iomem *ioaddr = vp->ioaddr;
        unsigned long flags;
        int rc;
 
@@ -2978,15 +3000,18 @@ static void vortex_get_ethtool_stats(struct net_device *dev,
        struct ethtool_stats *stats, u64 *data)
 {
        struct vortex_private *vp = netdev_priv(dev);
+       void __iomem *ioaddr = vp->ioaddr;
        unsigned long flags;
 
        spin_lock_irqsave(&vp->lock, flags);
-       update_stats(dev->base_addr, dev);
+       update_stats(ioaddr, dev);
        spin_unlock_irqrestore(&vp->lock, flags);
 
        data[0] = vp->xstats.tx_deferred;
-       data[1] = vp->xstats.tx_multiple_collisions;
-       data[2] = vp->xstats.rx_bad_ssd;
+       data[1] = vp->xstats.tx_max_collisions;
+       data[2] = vp->xstats.tx_multiple_collisions;
+       data[3] = vp->xstats.tx_single_collisions;
+       data[4] = vp->xstats.rx_bad_ssd;
 }
 
 
@@ -3008,7 +3033,6 @@ static void vortex_get_drvinfo(struct net_device *dev,
        struct vortex_private *vp = netdev_priv(dev);
 
        strcpy(info->driver, DRV_NAME);
-       strcpy(info->version, DRV_VERSION);
        if (VORTEX_PCI(vp)) {
                strcpy(info->bus_info, pci_name(VORTEX_PCI(vp)));
        } else {
@@ -3029,8 +3053,9 @@ static struct ethtool_ops vortex_ethtool_ops = {
        .get_stats_count        = vortex_get_stats_count,
        .get_settings           = vortex_get_settings,
        .set_settings           = vortex_set_settings,
-       .get_link               = vortex_get_link,
+       .get_link               = ethtool_op_get_link,
        .nway_reset             = vortex_nway_reset,
+       .get_perm_addr          = ethtool_op_get_perm_addr,
 };
 
 #ifdef CONFIG_PCI
@@ -3041,7 +3066,7 @@ static int vortex_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
 {
        int err;
        struct vortex_private *vp = netdev_priv(dev);
-       long ioaddr = dev->base_addr;
+       void __iomem *ioaddr = vp->ioaddr;
        unsigned long flags;
        int state = 0;
 
@@ -3069,7 +3094,8 @@ static int vortex_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
    the chip has a very clean way to set the mode, unlike many others. */
 static void set_rx_mode(struct net_device *dev)
 {
-       long ioaddr = dev->base_addr;
+       struct vortex_private *vp = netdev_priv(dev);
+       void __iomem *ioaddr = vp->ioaddr;
        int new_mode;
 
        if (dev->flags & IFF_PROMISC) {
@@ -3081,7 +3107,7 @@ static void set_rx_mode(struct net_device *dev)
        } else
                new_mode = SetRxFilter | RxStation | RxBroadcast;
 
-       outw(new_mode, ioaddr + EL3_CMD);
+       iowrite16(new_mode, ioaddr + EL3_CMD);
 }
 
 #if defined(CONFIG_VLAN_8021Q) || defined(CONFIG_VLAN_8021Q_MODULE)
@@ -3095,8 +3121,8 @@ static void set_rx_mode(struct net_device *dev)
 static void set_8021q_mode(struct net_device *dev, int enable)
 {
        struct vortex_private *vp = netdev_priv(dev);
-       long ioaddr = dev->base_addr;
-       int old_window = inw(ioaddr + EL3_CMD);
+       void __iomem *ioaddr = vp->ioaddr;
+       int old_window = ioread16(ioaddr + EL3_CMD);
        int mac_ctrl;
 
        if ((vp->drv_flags&IS_CYCLONE) || (vp->drv_flags&IS_TORNADO)) {
@@ -3108,24 +3134,24 @@ static void set_8021q_mode(struct net_device *dev, int enable)
                        max_pkt_size += 4;      /* 802.1Q VLAN tag */
 
                EL3WINDOW(3);
-               outw(max_pkt_size, ioaddr+Wn3_MaxPktSize);
+               iowrite16(max_pkt_size, ioaddr+Wn3_MaxPktSize);
 
                /* set VlanEtherType to let the hardware checksumming
                   treat tagged frames correctly */
                EL3WINDOW(7);
-               outw(VLAN_ETHER_TYPE, ioaddr+Wn7_VlanEtherType);
+               iowrite16(VLAN_ETHER_TYPE, ioaddr+Wn7_VlanEtherType);
        } else {
                /* on older cards we have to enable large frames */
 
                vp->large_frames = dev->mtu > 1500 || enable;
 
                EL3WINDOW(3);
-               mac_ctrl = inw(ioaddr+Wn3_MAC_Ctrl);
+               mac_ctrl = ioread16(ioaddr+Wn3_MAC_Ctrl);
                if (vp->large_frames)
                        mac_ctrl |= 0x40;
                else
                        mac_ctrl &= ~0x40;
-               outw(mac_ctrl, ioaddr+Wn3_MAC_Ctrl);
+               iowrite16(mac_ctrl, ioaddr+Wn3_MAC_Ctrl);
        }
 
        EL3WINDOW(old_window);
@@ -3147,7 +3173,7 @@ static void set_8021q_mode(struct net_device *dev, int enable)
 /* The maximum data clock rate is 2.5 Mhz.  The minimum timing is usually
    met by back-to-back PCI I/O cycles, but we insert a delay to avoid
    "overclocking" issues. */
-#define mdio_delay() inl(mdio_addr)
+#define mdio_delay() ioread32(mdio_addr)
 
 #define MDIO_SHIFT_CLK 0x01
 #define MDIO_DIR_WRITE 0x04
@@ -3158,15 +3184,15 @@ static void set_8021q_mode(struct net_device *dev, int enable)
 
 /* Generate the preamble required for initial synchronization and
    a few older transceivers. */
-static void mdio_sync(long ioaddr, int bits)
+static void mdio_sync(void __iomem *ioaddr, int bits)
 {
-       long mdio_addr = ioaddr + Wn4_PhysicalMgmt;
+       void __iomem *mdio_addr = ioaddr + Wn4_PhysicalMgmt;
 
        /* Establish sync by sending at least 32 logic ones. */
        while (-- bits >= 0) {
-               outw(MDIO_DATA_WRITE1, mdio_addr);
+               iowrite16(MDIO_DATA_WRITE1, mdio_addr);
                mdio_delay();
-               outw(MDIO_DATA_WRITE1 | MDIO_SHIFT_CLK, mdio_addr);
+               iowrite16(MDIO_DATA_WRITE1 | MDIO_SHIFT_CLK, mdio_addr);
                mdio_delay();
        }
 }
@@ -3174,10 +3200,11 @@ static void mdio_sync(long ioaddr, int bits)
 static int mdio_read(struct net_device *dev, int phy_id, int location)
 {
        int i;
-       long ioaddr = dev->base_addr;
+       struct vortex_private *vp = netdev_priv(dev);
+       void __iomem *ioaddr = vp->ioaddr;
        int read_cmd = (0xf6 << 10) | (phy_id << 5) | location;
        unsigned int retval = 0;
-       long mdio_addr = ioaddr + Wn4_PhysicalMgmt;
+       void __iomem *mdio_addr = ioaddr + Wn4_PhysicalMgmt;
 
        if (mii_preamble_required)
                mdio_sync(ioaddr, 32);
@@ -3185,17 +3212,17 @@ static int mdio_read(struct net_device *dev, int phy_id, int location)
        /* Shift the read command bits out. */
        for (i = 14; i >= 0; i--) {
                int dataval = (read_cmd&(1<<i)) ? MDIO_DATA_WRITE1 : MDIO_DATA_WRITE0;
-               outw(dataval, mdio_addr);
+               iowrite16(dataval, mdio_addr);
                mdio_delay();
-               outw(dataval | MDIO_SHIFT_CLK, mdio_addr);
+               iowrite16(dataval | MDIO_SHIFT_CLK, mdio_addr);
                mdio_delay();
        }
        /* Read the two transition, 16 data, and wire-idle bits. */
        for (i = 19; i > 0; i--) {
-               outw(MDIO_ENB_IN, mdio_addr);
+               iowrite16(MDIO_ENB_IN, mdio_addr);
                mdio_delay();
-               retval = (retval << 1) | ((inw(mdio_addr) & MDIO_DATA_READ) ? 1 : 0);
-               outw(MDIO_ENB_IN | MDIO_SHIFT_CLK, mdio_addr);
+               retval = (retval << 1) | ((ioread16(mdio_addr) & MDIO_DATA_READ) ? 1 : 0);
+               iowrite16(MDIO_ENB_IN | MDIO_SHIFT_CLK, mdio_addr);
                mdio_delay();
        }
        return retval & 0x20000 ? 0xffff : retval>>1 & 0xffff;
@@ -3203,9 +3230,10 @@ static int mdio_read(struct net_device *dev, int phy_id, int location)
 
 static void mdio_write(struct net_device *dev, int phy_id, int location, int value)
 {
-       long ioaddr = dev->base_addr;
+       struct vortex_private *vp = netdev_priv(dev);
+       void __iomem *ioaddr = vp->ioaddr;
        int write_cmd = 0x50020000 | (phy_id << 23) | (location << 18) | value;
-       long mdio_addr = ioaddr + Wn4_PhysicalMgmt;
+       void __iomem *mdio_addr = ioaddr + Wn4_PhysicalMgmt;
        int i;
 
        if (mii_preamble_required)
@@ -3214,35 +3242,35 @@ static void mdio_write(struct net_device *dev, int phy_id, int location, int val
        /* Shift the command bits out. */
        for (i = 31; i >= 0; i--) {
                int dataval = (write_cmd&(1<<i)) ? MDIO_DATA_WRITE1 : MDIO_DATA_WRITE0;
-               outw(dataval, mdio_addr);
+               iowrite16(dataval, mdio_addr);
                mdio_delay();
-               outw(dataval | MDIO_SHIFT_CLK, mdio_addr);
+               iowrite16(dataval | MDIO_SHIFT_CLK, mdio_addr);
                mdio_delay();
        }
        /* Leave the interface idle. */
        for (i = 1; i >= 0; i--) {
-               outw(MDIO_ENB_IN, mdio_addr);
+               iowrite16(MDIO_ENB_IN, mdio_addr);
                mdio_delay();
-               outw(MDIO_ENB_IN | MDIO_SHIFT_CLK, mdio_addr);
+               iowrite16(MDIO_ENB_IN | MDIO_SHIFT_CLK, mdio_addr);
                mdio_delay();
        }
        return;
 }
-\f
+
 /* ACPI: Advanced Configuration and Power Interface. */
 /* Set Wake-On-LAN mode and put the board into D3 (power-down) state. */
 static void acpi_set_WOL(struct net_device *dev)
 {
        struct vortex_private *vp = netdev_priv(dev);
-       long ioaddr = dev->base_addr;
+       void __iomem *ioaddr = vp->ioaddr;
 
        if (vp->enable_wol) {
                /* Power up on: 1==Downloaded Filter, 2==Magic Packets, 4==Link Status. */
                EL3WINDOW(7);
-               outw(2, ioaddr + 0x0c);
+               iowrite16(2, ioaddr + 0x0c);
                /* The RxFilter must accept the WOL frames. */
-               outw(SetRxFilter|RxStation|RxMulticast|RxBroadcast, ioaddr + EL3_CMD);
-               outw(RxEnable, ioaddr + EL3_CMD);
+               iowrite16(SetRxFilter|RxStation|RxMulticast|RxBroadcast, ioaddr + EL3_CMD);
+               iowrite16(RxEnable, ioaddr + EL3_CMD);
 
                pci_enable_wake(VORTEX_PCI(vp), 0, 1);
 
@@ -3252,7 +3280,7 @@ static void acpi_set_WOL(struct net_device *dev)
 }
 
 
-static void __devexit vortex_remove_one (struct pci_dev *pdev)
+static void __devexit vortex_remove_one(struct pci_dev *pdev)
 {
        struct net_device *dev = pci_get_drvdata(pdev);
        struct vortex_private *vp;
@@ -3264,10 +3292,9 @@ static void __devexit vortex_remove_one (struct pci_dev *pdev)
 
        vp = netdev_priv(dev);
 
-       /* AKPM: FIXME: we should have
-        *      if (vp->cb_fn_base) iounmap(vp->cb_fn_base);
-        * here
-        */
+       if (vp->cb_fn_base)
+               pci_iounmap(VORTEX_PCI(vp), vp->cb_fn_base);
+
        unregister_netdev(dev);
 
        if (VORTEX_PCI(vp)) {
@@ -3277,8 +3304,10 @@ static void __devexit vortex_remove_one (struct pci_dev *pdev)
                pci_disable_device(VORTEX_PCI(vp));
        }
        /* Should really use issue_and_wait() here */
-       outw(TotalReset | ((vp->drv_flags & EEPROM_RESET) ? 0x04 : 0x14),
-            dev->base_addr + EL3_CMD);
+       iowrite16(TotalReset | ((vp->drv_flags & EEPROM_RESET) ? 0x04 : 0x14),
+            vp->ioaddr + EL3_CMD);
+
+       pci_iounmap(VORTEX_PCI(vp), vp->ioaddr);
 
        pci_free_consistent(pdev,
                                                sizeof(struct boom_rx_desc) * RX_RING_SIZE
@@ -3307,7 +3336,7 @@ static int vortex_have_pci;
 static int vortex_have_eisa;
 
 
-static int __init vortex_init (void)
+static int __init vortex_init(void)
 {
        int pci_rc, eisa_rc;
 
@@ -3323,46 +3352,39 @@ static int __init vortex_init (void)
 }
 
 
-static void __exit vortex_eisa_cleanup (void)
+static void __exit vortex_eisa_cleanup(void)
 {
        struct vortex_private *vp;
-       long ioaddr;
+       void __iomem *ioaddr;
 
 #ifdef CONFIG_EISA
        /* Take care of the EISA devices */
-       eisa_driver_unregister (&vortex_eisa_driver);
+       eisa_driver_unregister(&vortex_eisa_driver);
 #endif
        
        if (compaq_net_device) {
                vp = compaq_net_device->priv;
-               ioaddr = compaq_net_device->base_addr;
+               ioaddr = ioport_map(compaq_net_device->base_addr,
+                                   VORTEX_TOTAL_SIZE);
 
-               unregister_netdev (compaq_net_device);
-               outw (TotalReset, ioaddr + EL3_CMD);
-               release_region (ioaddr, VORTEX_TOTAL_SIZE);
+               unregister_netdev(compaq_net_device);
+               iowrite16(TotalReset, ioaddr + EL3_CMD);
+               release_region(compaq_net_device->base_addr,
+                              VORTEX_TOTAL_SIZE);
 
-               free_netdev (compaq_net_device);
+               free_netdev(compaq_net_device);
        }
 }
 
 
-static void __exit vortex_cleanup (void)
+static void __exit vortex_cleanup(void)
 {
        if (vortex_have_pci)
-               pci_unregister_driver (&vortex_driver);
+               pci_unregister_driver(&vortex_driver);
        if (vortex_have_eisa)
-               vortex_eisa_cleanup ();
+               vortex_eisa_cleanup();
 }
 
 
 module_init(vortex_init);
 module_exit(vortex_cleanup);
-
-\f
-/*
- * Local variables:
- *  c-indent-level: 4
- *  c-basic-offset: 4
- *  tab-width: 4
- * End:
- */