121 files changed, 3368 insertions, 1580 deletions

diff --git a/drivers/accessibility/Kconfig b/drivers/accessibility/Kconfig
index 1264c4b98094..ef3b65bfdd0a 100644
--- a/drivers/accessibility/Kconfig
+++ b/drivers/accessibility/Kconfig
@@ -1,7 +1,17 @@
 menuconfig ACCESSIBILITY
         bool "Accessibility support"
         ---help---
-          Enable a submenu where accessibility items may be enabled.
+          Accessibility handles all special kinds of hardware devices or
+          software adapters which help people with disabilities (e.g.
+          blindness) to use computers.
+
+          That includes braille devices, speech synthesis, keyboard
+          remapping, etc.
+
+          Say Y here to get to see options for accessibility.
+          This option alone does not add any kernel code.
+
+          If you say N, all options in this submenu will be skipped and disabled.
 
           If unsure, say N.
 
diff --git a/drivers/ata/Kconfig b/drivers/ata/Kconfig
index 1c11df9a5f32..9bf2986a2788 100644
--- a/drivers/ata/Kconfig
+++ b/drivers/ata/Kconfig
@@ -205,8 +205,8 @@ config SATA_VITESSE
           If unsure, say N.
 
 config SATA_INIC162X
-        tristate "Initio 162x SATA support (HIGHLY EXPERIMENTAL)"
-        depends on PCI && EXPERIMENTAL
+        tristate "Initio 162x SATA support"
+        depends on PCI
         help
           This option enables support for Initio 162x Serial ATA.
 
@@ -697,6 +697,15 @@ config PATA_SCC
 
           If unsure, say N.
 
+config PATA_SCH
+        tristate "Intel SCH PATA support"
+        depends on PCI
+        help
+          This option enables support for Intel SCH PATA on the Intel
+          SCH (US15W, US15L, UL11L) series host controllers.
+
+          If unsure, say N.
+
 config PATA_BF54X
         tristate "Blackfin 54x ATAPI support"
         depends on BF542 || BF548 || BF549
diff --git a/drivers/ata/Makefile b/drivers/ata/Makefile
index b693d829383a..674965fa326d 100644
--- a/drivers/ata/Makefile
+++ b/drivers/ata/Makefile
@@ -67,6 +67,7 @@ obj-$(CONFIG_PATA_SIS)		+= pata_sis.o
 obj-$(CONFIG_PATA_TRIFLEX)      += pata_triflex.o
 obj-$(CONFIG_PATA_IXP4XX_CF)    += pata_ixp4xx_cf.o
 obj-$(CONFIG_PATA_SCC)          += pata_scc.o
+obj-$(CONFIG_PATA_SCH)          += pata_sch.o
 obj-$(CONFIG_PATA_BF54X)        += pata_bf54x.o
 obj-$(CONFIG_PATA_PLATFORM)     += pata_platform.o
 obj-$(CONFIG_PATA_OF_PLATFORM)  += pata_of_platform.o
diff --git a/drivers/ata/ahci.c b/drivers/ata/ahci.c
index 8cace9aa9c03..97f83fb2ee2e 100644
--- a/drivers/ata/ahci.c
+++ b/drivers/ata/ahci.c
@@ -1267,9 +1267,7 @@ static int ahci_check_ready(struct ata_link *link)
         void __iomem *port_mmio = ahci_port_base(link->ap);
         u8 status = readl(port_mmio + PORT_TFDATA) & 0xFF;
 
-        if (!(status & ATA_BUSY))
-                return 1;
-        return 0;
+        return ata_check_ready(status);
 }
 
 static int ahci_softreset(struct ata_link *link, unsigned int *class,
diff --git a/drivers/ata/ata_generic.c b/drivers/ata/ata_generic.c
index 47aeccd52fa9..75a406f5e694 100644
--- a/drivers/ata/ata_generic.c
+++ b/drivers/ata/ata_generic.c
@@ -152,6 +152,12 @@ static int ata_generic_init_one(struct pci_dev *dev, const struct pci_device_id
         if (dev->vendor == PCI_VENDOR_ID_AL)
                 ata_pci_bmdma_clear_simplex(dev);
 
+        if (dev->vendor == PCI_VENDOR_ID_ATI) {
+                int rc = pcim_enable_device(dev);
+                if (rc < 0)
+                        return rc;
+                pcim_pin_device(dev);
+        }
         return ata_pci_sff_init_one(dev, ppi, &generic_sht, NULL);
 }
 
diff --git a/drivers/ata/ata_piix.c b/drivers/ata/ata_piix.c
index ea2c7649d399..a9027b8fbdd5 100644
--- a/drivers/ata/ata_piix.c
+++ b/drivers/ata/ata_piix.c
@@ -1348,6 +1348,8 @@ static void __devinit piix_init_sidpr(struct ata_host *host)
 {
         struct pci_dev *pdev = to_pci_dev(host->dev);
         struct piix_host_priv *hpriv = host->private_data;
+        struct ata_device *dev0 = &host->ports[0]->link.device[0];
+        u32 scontrol;
         int i;
 
         /* check for availability */
@@ -1366,6 +1368,29 @@ static void __devinit piix_init_sidpr(struct ata_host *host)
                 return;
 
         hpriv->sidpr = pcim_iomap_table(pdev)[PIIX_SIDPR_BAR];
+
+        /* SCR access via SIDPR doesn't work on some configurations.
+         * Give it a test drive by inhibiting power save modes which
+         * we'll do anyway.
+         */
+        scontrol = piix_sidpr_read(dev0, SCR_CONTROL);
+
+        /* if IPM is already 3, SCR access is probably working.  Don't
+         * un-inhibit power save modes as BIOS might have inhibited
+         * them for a reason.
+         */
+        if ((scontrol & 0xf00) != 0x300) {
+                scontrol |= 0x300;
+                piix_sidpr_write(dev0, SCR_CONTROL, scontrol);
+                scontrol = piix_sidpr_read(dev0, SCR_CONTROL);
+
+                if ((scontrol & 0xf00) != 0x300) {
+                        dev_printk(KERN_INFO, host->dev, "SCR access via "
+                                   "SIDPR is available but doesn't work\n");
+                        return;
+                }
+        }
+
         host->ports[0]->ops = &piix_sidpr_sata_ops;
         host->ports[1]->ops = &piix_sidpr_sata_ops;
 }
diff --git a/drivers/ata/libata-core.c b/drivers/ata/libata-core.c
index 3bc488538204..927b692d723c 100644
--- a/drivers/ata/libata-core.c
+++ b/drivers/ata/libata-core.c
@@ -6292,6 +6292,7 @@ EXPORT_SYMBOL_GPL(ata_eh_freeze_port);
 EXPORT_SYMBOL_GPL(ata_eh_thaw_port);
 EXPORT_SYMBOL_GPL(ata_eh_qc_complete);
 EXPORT_SYMBOL_GPL(ata_eh_qc_retry);
+EXPORT_SYMBOL_GPL(ata_eh_analyze_ncq_error);
 EXPORT_SYMBOL_GPL(ata_do_eh);
 EXPORT_SYMBOL_GPL(ata_std_error_handler);
 
diff --git a/drivers/ata/libata-eh.c b/drivers/ata/libata-eh.c
index 61dcd0026c64..62e033146bed 100644
--- a/drivers/ata/libata-eh.c
+++ b/drivers/ata/libata-eh.c
@@ -1357,7 +1357,7 @@ static void ata_eh_analyze_serror(struct ata_link *link)
  *      LOCKING:
  *      Kernel thread context (may sleep).
  */
-static void ata_eh_analyze_ncq_error(struct ata_link *link)
+void ata_eh_analyze_ncq_error(struct ata_link *link)
 {
         struct ata_port *ap = link->ap;
         struct ata_eh_context *ehc = &link->eh_context;
diff --git a/drivers/ata/libata-sff.c b/drivers/ata/libata-sff.c
index 2ec65a8fda79..3c2d2289f85e 100644
--- a/drivers/ata/libata-sff.c
+++ b/drivers/ata/libata-sff.c
@@ -314,11 +314,7 @@ static int ata_sff_check_ready(struct ata_link *link)
 {
         u8 status = link->ap->ops->sff_check_status(link->ap);
 
-        if (!(status & ATA_BUSY))
-                return 1;
-        if (status == 0xff)
-                return -ENODEV;
-        return 0;
+        return ata_check_ready(status);
 }
 
 /**
diff --git a/drivers/ata/pata_acpi.c b/drivers/ata/pata_acpi.c
index c5f91e629945..fbe605711554 100644
--- a/drivers/ata/pata_acpi.c
+++ b/drivers/ata/pata_acpi.c
@@ -259,6 +259,12 @@ static int pacpi_init_one (struct pci_dev *pdev, const struct pci_device_id *id)
                 .port_ops       = &pacpi_ops,
         };
         const struct ata_port_info *ppi[] = { &info, NULL };
+        if (pdev->vendor == PCI_VENDOR_ID_ATI) {
+                int rc = pcim_enable_device(pdev);
+                if (rc < 0)
+                        return rc;
+                pcim_pin_device(pdev);
+        }
         return ata_pci_sff_init_one(pdev, ppi, &pacpi_sht, NULL);
 }
 
diff --git a/drivers/ata/pata_sch.c b/drivers/ata/pata_sch.c
new file mode 100644
index 000000000000..c8cc027789fe
--- /dev/null
+++ b/drivers/ata/pata_sch.c
@@ -0,0 +1,206 @@
+/*
+ *  pata_sch.c - Intel SCH PATA controllers
+ *
+ *  Copyright (c) 2008 Alek Du <alek.du@intel.com>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License 2 as published
+ *  by the Free Software Foundation.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; see the file COPYING.  If not, write to
+ *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+
+/*
+ *  Supports:
+ *    Intel SCH (AF82US15W, AF82US15L, AF82UL11L) chipsets -- see spec at:
+ *    http://download.intel.com/design/chipsets/embedded/datashts/319537.pdf
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/pci.h>
+#include <linux/init.h>
+#include <linux/blkdev.h>
+#include <linux/delay.h>
+#include <linux/device.h>
+#include <scsi/scsi_host.h>
+#include <linux/libata.h>
+#include <linux/dmi.h>
+
+#define DRV_NAME        "pata_sch"
+#define DRV_VERSION     "0.2"
+
+/* see SCH datasheet page 351 */
+enum {
+        D0TIM   = 0x80,         /* Device 0 Timing Register */
+        D1TIM   = 0x84,         /* Device 1 Timing Register */
+        PM      = 0x07,         /* PIO Mode Bit Mask */
+        MDM     = (0x03 << 8),  /* Multi-word DMA Mode Bit Mask */
+        UDM     = (0x07 << 16), /* Ultra DMA Mode Bit Mask */
+        PPE     = (1 << 30),    /* Prefetch/Post Enable */
+        USD     = (1 << 31),    /* Use Synchronous DMA */
+};
+
+static int sch_init_one(struct pci_dev *pdev,
+                         const struct pci_device_id *ent);
+static void sch_set_piomode(struct ata_port *ap, struct ata_device *adev);
+static void sch_set_dmamode(struct ata_port *ap, struct ata_device *adev);
+
+static const struct pci_device_id sch_pci_tbl[] = {
+        /* Intel SCH PATA Controller */
+        { PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_SCH_IDE), 0 },
+        { }     /* terminate list */
+};
+
+static struct pci_driver sch_pci_driver = {
+        .name                   = DRV_NAME,
+        .id_table               = sch_pci_tbl,
+        .probe                  = sch_init_one,
+        .remove                 = ata_pci_remove_one,
+#ifdef CONFIG_PM
+        .suspend                = ata_pci_device_suspend,
+        .resume                 = ata_pci_device_resume,
+#endif
+};
+
+static struct scsi_host_template sch_sht = {
+        ATA_BMDMA_SHT(DRV_NAME),
+};
+
+static struct ata_port_operations sch_pata_ops = {
+        .inherits               = &ata_bmdma_port_ops,
+        .cable_detect           = ata_cable_unknown,
+        .set_piomode            = sch_set_piomode,
+        .set_dmamode            = sch_set_dmamode,
+};
+
+static struct ata_port_info sch_port_info = {
+        .flags          = 0,
+        .pio_mask       = ATA_PIO4,   /* pio0-4 */
+        .mwdma_mask     = ATA_MWDMA2, /* mwdma0-2 */
+        .udma_mask      = ATA_UDMA5,  /* udma0-5 */
+        .port_ops       = &sch_pata_ops,
+};
+
+MODULE_AUTHOR("Alek Du <alek.du@intel.com>");
+MODULE_DESCRIPTION("SCSI low-level driver for Intel SCH PATA controllers");
+MODULE_LICENSE("GPL");
+MODULE_DEVICE_TABLE(pci, sch_pci_tbl);
+MODULE_VERSION(DRV_VERSION);
+
+/**
+ *      sch_set_piomode - Initialize host controller PATA PIO timings
+ *      @ap: Port whose timings we are configuring
+ *      @adev: ATA device
+ *
+ *      Set PIO mode for device, in host controller PCI config space.
+ *
+ *      LOCKING:
+ *      None (inherited from caller).
+ */
+
+static void sch_set_piomode(struct ata_port *ap, struct ata_device *adev)
+{
+        unsigned int pio        = adev->pio_mode - XFER_PIO_0;
+        struct pci_dev *dev     = to_pci_dev(ap->host->dev);
+        unsigned int port       = adev->devno ? D1TIM : D0TIM;
+        unsigned int data;
+
+        pci_read_config_dword(dev, port, &data);
+        /* see SCH datasheet page 351 */
+        /* set PIO mode */
+        data &= ~(PM | PPE);
+        data |= pio;
+        /* enable PPE for block device */
+        if (adev->class == ATA_DEV_ATA)
+                data |= PPE;
+        pci_write_config_dword(dev, port, data);
+}
+
+/**
+ *      sch_set_dmamode - Initialize host controller PATA DMA timings
+ *      @ap: Port whose timings we are configuring
+ *      @adev: ATA device
+ *
+ *      Set MW/UDMA mode for device, in host controller PCI config space.
+ *
+ *      LOCKING:
+ *      None (inherited from caller).
+ */
+
+static void sch_set_dmamode(struct ata_port *ap, struct ata_device *adev)
+{
+        unsigned int dma_mode   = adev->dma_mode;
+        struct pci_dev *dev     = to_pci_dev(ap->host->dev);
+        unsigned int port       = adev->devno ? D1TIM : D0TIM;
+        unsigned int data;
+
+        pci_read_config_dword(dev, port, &data);
+        /* see SCH datasheet page 351 */
+        if (dma_mode >= XFER_UDMA_0) {
+                /* enable Synchronous DMA mode */
+                data |= USD;
+                data &= ~UDM;
+                data |= (dma_mode - XFER_UDMA_0) << 16;
+        } else { /* must be MWDMA mode, since we masked SWDMA already */
+                data &= ~(USD | MDM);
+                data |= (dma_mode - XFER_MW_DMA_0) << 8;
+        }
+        pci_write_config_dword(dev, port, data);
+}
+
+/**
+ *      sch_init_one - Register SCH ATA PCI device with kernel services
+ *      @pdev: PCI device to register
+ *      @ent: Entry in sch_pci_tbl matching with @pdev
+ *
+ *      LOCKING:
+ *      Inherited from PCI layer (may sleep).
+ *
+ *      RETURNS:
+ *      Zero on success, or -ERRNO value.
+ */
+
+static int __devinit sch_init_one(struct pci_dev *pdev,
+                                   const struct pci_device_id *ent)
+{
+        static int printed_version;
+        const struct ata_port_info *ppi[] = { &sch_port_info, NULL };
+        struct ata_host *host;
+        int rc;
+
+        if (!printed_version++)
+                dev_printk(KERN_DEBUG, &pdev->dev,
+                           "version " DRV_VERSION "\n");
+
+        /* enable device and prepare host */
+        rc = pcim_enable_device(pdev);
+        if (rc)
+                return rc;
+        rc = ata_pci_sff_prepare_host(pdev, ppi, &host);
+        if (rc)
+                return rc;
+        pci_set_master(pdev);
+        return ata_pci_sff_activate_host(host, ata_sff_interrupt, &sch_sht);
+}
+
+static int __init sch_init(void)
+{
+        return pci_register_driver(&sch_pci_driver);
+}
+
+static void __exit sch_exit(void)
+{
+        pci_unregister_driver(&sch_pci_driver);
+}
+
+module_init(sch_init);
+module_exit(sch_exit);
diff --git a/drivers/ata/sata_inic162x.c b/drivers/ata/sata_inic162x.c
index d27bb9a2568f..3ead02fe379e 100644
--- a/drivers/ata/sata_inic162x.c
+++ b/drivers/ata/sata_inic162x.c
@@ -10,13 +10,33 @@
  * right.  Documentation is available at initio's website but it only
  * documents registers (not programming model).
  *
- * - ATA disks work.
- * - Hotplug works.
- * - ATAPI read works but burning doesn't.  This thing is really
- *   peculiar about ATAPI and I couldn't figure out how ATAPI PIO and
- *   ATAPI DMA WRITE should be programmed.  If you've got a clue, be
- *   my guest.
- * - Both STR and STD work.
+ * This driver has interesting history.  The first version was written
+ * from the documentation and a 2.4 IDE driver posted on a Taiwan
+ * company, which didn't use any IDMA features and couldn't handle
+ * LBA48.  The resulting driver couldn't handle LBA48 devices either
+ * making it pretty useless.
+ *
+ * After a while, initio picked the driver up, renamed it to
+ * sata_initio162x, updated it to use IDMA for ATA DMA commands and
+ * posted it on their website.  It only used ATA_PROT_DMA for IDMA and
+ * attaching both devices and issuing IDMA and !IDMA commands
+ * simultaneously broke it due to PIRQ masking interaction but it did
+ * show how to use the IDMA (ADMA + some initio specific twists)
+ * engine.
+ *
+ * Then, I picked up their changes again and here's the usable driver
+ * which uses IDMA for everything.  Everything works now including
+ * LBA48, CD/DVD burning, suspend/resume and hotplug.  There are some
+ * issues tho.  Result Tf is not resported properly, NCQ isn't
+ * supported yet and CD/DVD writing works with DMA assisted PIO
+ * protocol (which, for native SATA devices, shouldn't cause any
+ * noticeable difference).
+ *
+ * Anyways, so, here's finally a working driver for inic162x.  Enjoy!
+ *
+ * initio: If you guys wanna improve the driver regarding result TF
+ * access and other stuff, please feel free to contact me.  I'll be
+ * happy to assist.
  */
 
 #include <linux/kernel.h>
@@ -28,13 +48,19 @@
 #include <scsi/scsi_device.h>
 
 #define DRV_NAME        "sata_inic162x"
-#define DRV_VERSION     "0.3"
+#define DRV_VERSION     "0.4"
 
 enum {
-        MMIO_BAR                = 5,
+        MMIO_BAR_PCI            = 5,
+        MMIO_BAR_CARDBUS        = 1,
 
         NR_PORTS                = 2,
 
+        IDMA_CPB_TBL_SIZE       = 4 * 32,
+
+        INIC_DMA_BOUNDARY       = 0xffffff,
+
+        HOST_ACTRL              = 0x08,
         HOST_CTL                = 0x7c,
         HOST_STAT               = 0x7e,
         HOST_IRQ_STAT           = 0xbc,
@@ -43,22 +69,37 @@ enum {
         PORT_SIZE               = 0x40,
 
         /* registers for ATA TF operation */
-        PORT_TF                 = 0x00,
-        PORT_ALT_STAT           = 0x08,
+        PORT_TF_DATA            = 0x00,
+        PORT_TF_FEATURE         = 0x01,
+        PORT_TF_NSECT           = 0x02,
+        PORT_TF_LBAL            = 0x03,
+        PORT_TF_LBAM            = 0x04,
+        PORT_TF_LBAH            = 0x05,
+        PORT_TF_DEVICE          = 0x06,
+        PORT_TF_COMMAND         = 0x07,
+        PORT_TF_ALT_STAT        = 0x08,
         PORT_IRQ_STAT           = 0x09,
         PORT_IRQ_MASK           = 0x0a,
         PORT_PRD_CTL            = 0x0b,
         PORT_PRD_ADDR           = 0x0c,
         PORT_PRD_XFERLEN        = 0x10,
+        PORT_CPB_CPBLAR         = 0x18,
+        PORT_CPB_PTQFIFO        = 0x1c,
 
         /* IDMA register */
         PORT_IDMA_CTL           = 0x14,
+        PORT_IDMA_STAT          = 0x16,
+
+        PORT_RPQ_FIFO           = 0x1e,
+        PORT_RPQ_CNT            = 0x1f,
 
         PORT_SCR                = 0x20,
 
         /* HOST_CTL bits */
         HCTL_IRQOFF             = (1 << 8),  /* global IRQ off */
-        HCTL_PWRDWN             = (1 << 13), /* power down PHYs */
+        HCTL_FTHD0              = (1 << 10), /* fifo threshold 0 */
+        HCTL_FTHD1              = (1 << 11), /* fifo threshold 1*/
+        HCTL_PWRDWN             = (1 << 12), /* power down PHYs */
         HCTL_SOFTRST            = (1 << 13), /* global reset (no phy reset) */
         HCTL_RPGSEL             = (1 << 15), /* register page select */
 
@@ -81,9 +122,7 @@ enum {
         PIRQ_PENDING            = (1 << 7),  /* port IRQ pending (STAT only) */
 
         PIRQ_ERR                = PIRQ_OFFLINE | PIRQ_ONLINE | PIRQ_FATAL,
-
-        PIRQ_MASK_DMA_READ      = PIRQ_REPLY | PIRQ_ATA,
-        PIRQ_MASK_OTHER         = PIRQ_REPLY | PIRQ_COMPLETE,
+        PIRQ_MASK_DEFAULT       = PIRQ_REPLY | PIRQ_ATA,
         PIRQ_MASK_FREEZE        = 0xff,
 
         /* PORT_PRD_CTL bits */
@@ -96,20 +135,104 @@ enum {
         IDMA_CTL_RST_IDMA       = (1 << 5),  /* reset IDMA machinary */
         IDMA_CTL_GO             = (1 << 7),  /* IDMA mode go */
         IDMA_CTL_ATA_NIEN       = (1 << 8),  /* ATA IRQ disable */
+
+        /* PORT_IDMA_STAT bits */
+        IDMA_STAT_PERR          = (1 << 0),  /* PCI ERROR MODE */
+        IDMA_STAT_CPBERR        = (1 << 1),  /* ADMA CPB error */
+        IDMA_STAT_LGCY          = (1 << 3),  /* ADMA legacy */
+        IDMA_STAT_UIRQ          = (1 << 4),  /* ADMA unsolicited irq */
+        IDMA_STAT_STPD          = (1 << 5),  /* ADMA stopped */
+        IDMA_STAT_PSD           = (1 << 6),  /* ADMA pause */
+        IDMA_STAT_DONE          = (1 << 7),  /* ADMA done */
+
+        IDMA_STAT_ERR           = IDMA_STAT_PERR | IDMA_STAT_CPBERR,
+
+        /* CPB Control Flags*/
+        CPB_CTL_VALID           = (1 << 0),  /* CPB valid */
+        CPB_CTL_QUEUED          = (1 << 1),  /* queued command */
+        CPB_CTL_DATA            = (1 << 2),  /* data, rsvd in datasheet */
+        CPB_CTL_IEN             = (1 << 3),  /* PCI interrupt enable */
+        CPB_CTL_DEVDIR          = (1 << 4),  /* device direction control */
+
+        /* CPB Response Flags */
+        CPB_RESP_DONE           = (1 << 0),  /* ATA command complete */
+        CPB_RESP_REL            = (1 << 1),  /* ATA release */
+        CPB_RESP_IGNORED        = (1 << 2),  /* CPB ignored */
+        CPB_RESP_ATA_ERR        = (1 << 3),  /* ATA command error */
+        CPB_RESP_SPURIOUS       = (1 << 4),  /* ATA spurious interrupt error */
+        CPB_RESP_UNDERFLOW      = (1 << 5),  /* APRD deficiency length error */
+        CPB_RESP_OVERFLOW       = (1 << 6),  /* APRD exccess length error */
+        CPB_RESP_CPB_ERR        = (1 << 7),  /* CPB error flag */
+
+        /* PRD Control Flags */
+        PRD_DRAIN               = (1 << 1),  /* ignore data excess */
+        PRD_CDB                 = (1 << 2),  /* atapi packet command pointer */
+        PRD_DIRECT_INTR         = (1 << 3),  /* direct interrupt */
+        PRD_DMA                 = (1 << 4),  /* data transfer method */
+        PRD_WRITE               = (1 << 5),  /* data dir, rsvd in datasheet */
+        PRD_IOM                 = (1 << 6),  /* io/memory transfer */
+        PRD_END                 = (1 << 7),  /* APRD chain end */
 };
 
+/* Comman Parameter Block */
+struct inic_cpb {
+        u8              resp_flags;     /* Response Flags */
+        u8              error;          /* ATA Error */
+        u8              status;         /* ATA Status */
+        u8              ctl_flags;      /* Control Flags */
+        __le32          len;            /* Total Transfer Length */
+        __le32          prd;            /* First PRD pointer */
+        u8              rsvd[4];
+        /* 16 bytes */
+        u8              feature;        /* ATA Feature */
+        u8              hob_feature;    /* ATA Ex. Feature */
+        u8              device;         /* ATA Device/Head */
+        u8              mirctl;         /* Mirror Control */
+        u8              nsect;          /* ATA Sector Count */
+        u8              hob_nsect;      /* ATA Ex. Sector Count */
+        u8              lbal;           /* ATA Sector Number */
+        u8              hob_lbal;       /* ATA Ex. Sector Number */
+        u8              lbam;           /* ATA Cylinder Low */
+        u8              hob_lbam;       /* ATA Ex. Cylinder Low */
+        u8              lbah;           /* ATA Cylinder High */
+        u8              hob_lbah;       /* ATA Ex. Cylinder High */
+        u8              command;        /* ATA Command */
+        u8              ctl;            /* ATA Control */
+        u8              slave_error;    /* Slave ATA Error */
+        u8              slave_status;   /* Slave ATA Status */
+        /* 32 bytes */
+} __packed;
+
+/* Physical Region Descriptor */
+struct inic_prd {
+        __le32          mad;            /* Physical Memory Address */
+        __le16          len;            /* Transfer Length */
+        u8              rsvd;
+        u8              flags;          /* Control Flags */
+} __packed;
+
+struct inic_pkt {
+        struct inic_cpb cpb;
+        struct inic_prd prd[LIBATA_MAX_PRD + 1];        /* + 1 for cdb */
+        u8              cdb[ATAPI_CDB_LEN];
+} __packed;
+
 struct inic_host_priv {
-        u16     cached_hctl;
+        void __iomem    *mmio_base;
+        u16             cached_hctl;
 };
 
 struct inic_port_priv {
-        u8      dfl_prdctl;
-        u8      cached_prdctl;
-        u8      cached_pirq_mask;
+        struct inic_pkt *pkt;
+        dma_addr_t      pkt_dma;
+        u32             *cpb_tbl;
+        dma_addr_t      cpb_tbl_dma;
 };
 
 static struct scsi_host_template inic_sht = {
-        ATA_BMDMA_SHT(DRV_NAME),
+        ATA_BASE_SHT(DRV_NAME),
+        .sg_tablesize   = LIBATA_MAX_PRD,       /* maybe it can be larger? */
+        .dma_boundary   = INIC_DMA_BOUNDARY,
 };
 
 static const int scr_map[] = {
@@ -120,54 +243,34 @@ static const int scr_map[] = {
 
 static void __iomem *inic_port_base(struct ata_port *ap)
 {
-        return ap->host->iomap[MMIO_BAR] + ap->port_no * PORT_SIZE;
-}
-
-static void __inic_set_pirq_mask(struct ata_port *ap, u8 mask)
-{
-        void __iomem *port_base = inic_port_base(ap);
-        struct inic_port_priv *pp = ap->private_data;
+        struct inic_host_priv *hpriv = ap->host->private_data;
 
-        writeb(mask, port_base + PORT_IRQ_MASK);
-        pp->cached_pirq_mask = mask;
-}
-
-static void inic_set_pirq_mask(struct ata_port *ap, u8 mask)
-{
-        struct inic_port_priv *pp = ap->private_data;
-
-        if (pp->cached_pirq_mask != mask)
-                __inic_set_pirq_mask(ap, mask);
+        return hpriv->mmio_base + ap->port_no * PORT_SIZE;
 }
 
 static void inic_reset_port(void __iomem *port_base)
 {
         void __iomem *idma_ctl = port_base + PORT_IDMA_CTL;
-        u16 ctl;
 
-        ctl = readw(idma_ctl);
-        ctl &= ~(IDMA_CTL_RST_IDMA | IDMA_CTL_ATA_NIEN | IDMA_CTL_GO);
+        /* stop IDMA engine */
+        readw(idma_ctl); /* flush */
+        msleep(1);
 
         /* mask IRQ and assert reset */
-        writew(ctl | IDMA_CTL_RST_IDMA | IDMA_CTL_ATA_NIEN, idma_ctl);
+        writew(IDMA_CTL_RST_IDMA, idma_ctl);
         readw(idma_ctl); /* flush */
-
-        /* give it some time */
         msleep(1);
 
         /* release reset */
-        writew(ctl | IDMA_CTL_ATA_NIEN, idma_ctl);
+        writew(0, idma_ctl);
 
         /* clear irq */
         writeb(0xff, port_base + PORT_IRQ_STAT);
-
-        /* reenable ATA IRQ, turn off IDMA mode */
-        writew(ctl, idma_ctl);
 }
 
 static int inic_scr_read(struct ata_port *ap, unsigned sc_reg, u32 *val)
 {
-        void __iomem *scr_addr = ap->ioaddr.scr_addr;
+        void __iomem *scr_addr = inic_port_base(ap) + PORT_SCR;
         void __iomem *addr;
 
         if (unlikely(sc_reg >= ARRAY_SIZE(scr_map)))
@@ -184,120 +287,126 @@ static int inic_scr_read(struct ata_port *ap, unsigned sc_reg, u32 *val)
 
 static int inic_scr_write(struct ata_port *ap, unsigned sc_reg, u32 val)
 {
-        void __iomem *scr_addr = ap->ioaddr.scr_addr;
-        void __iomem *addr;
+        void __iomem *scr_addr = inic_port_base(ap) + PORT_SCR;
 
         if (unlikely(sc_reg >= ARRAY_SIZE(scr_map)))
                 return -EINVAL;
 
-        addr = scr_addr + scr_map[sc_reg] * 4;
         writel(val, scr_addr + scr_map[sc_reg] * 4);
         return 0;
 }
 
-/*
- * In TF mode, inic162x is very similar to SFF device.  TF registers
- * function the same.  DMA engine behaves similary using the same PRD
- * format as BMDMA but different command register, interrupt and event
- * notification methods are used.  The following inic_bmdma_*()
- * functions do the impedance matching.
- */
-static void inic_bmdma_setup(struct ata_queued_cmd *qc)
+static void inic_stop_idma(struct ata_port *ap)
 {
-        struct ata_port *ap = qc->ap;
-        struct inic_port_priv *pp = ap->private_data;
         void __iomem *port_base = inic_port_base(ap);
-        int rw = qc->tf.flags & ATA_TFLAG_WRITE;
-
-        /* make sure device sees PRD table writes */
-        wmb();
-
-        /* load transfer length */
-        writel(qc->nbytes, port_base + PORT_PRD_XFERLEN);
-
-        /* turn on DMA and specify data direction */
-        pp->cached_prdctl = pp->dfl_prdctl | PRD_CTL_DMAEN;
-        if (!rw)
-                pp->cached_prdctl |= PRD_CTL_WR;
-        writeb(pp->cached_prdctl, port_base + PORT_PRD_CTL);
 
-        /* issue r/w command */
-        ap->ops->sff_exec_command(ap, &qc->tf);
+        readb(port_base + PORT_RPQ_FIFO);
+        readb(port_base + PORT_RPQ_CNT);
+        writew(0, port_base + PORT_IDMA_CTL);
 }
 
-static void inic_bmdma_start(struct ata_queued_cmd *qc)
+static void inic_host_err_intr(struct ata_port *ap, u8 irq_stat, u16 idma_stat)
 {
-        struct ata_port *ap = qc->ap;
+        struct ata_eh_info *ehi = &ap->link.eh_info;
         struct inic_port_priv *pp = ap->private_data;
-        void __iomem *port_base = inic_port_base(ap);
+        struct inic_cpb *cpb = &pp->pkt->cpb;
+        bool freeze = false;
 
-        /* start host DMA transaction */
-        pp->cached_prdctl |= PRD_CTL_START;
-        writeb(pp->cached_prdctl, port_base + PORT_PRD_CTL);
-}
+        ata_ehi_clear_desc(ehi);
+        ata_ehi_push_desc(ehi, "irq_stat=0x%x idma_stat=0x%x",
+                          irq_stat, idma_stat);
 
-static void inic_bmdma_stop(struct ata_queued_cmd *qc)
-{
-        struct ata_port *ap = qc->ap;
-        struct inic_port_priv *pp = ap->private_data;
-        void __iomem *port_base = inic_port_base(ap);
+        inic_stop_idma(ap);
 
-        /* stop DMA engine */
-        writeb(pp->dfl_prdctl, port_base + PORT_PRD_CTL);
-}
+        if (irq_stat & (PIRQ_OFFLINE | PIRQ_ONLINE)) {
+                ata_ehi_push_desc(ehi, "hotplug");
+                ata_ehi_hotplugged(ehi);
+                freeze = true;
+        }
 
-static u8 inic_bmdma_status(struct ata_port *ap)
-{
-        /* event is already verified by the interrupt handler */
-        return ATA_DMA_INTR;
+        if (idma_stat & IDMA_STAT_PERR) {
+                ata_ehi_push_desc(ehi, "PCI error");
+                freeze = true;
+        }
+
+        if (idma_stat & IDMA_STAT_CPBERR) {
+                ata_ehi_push_desc(ehi, "CPB error");
+
+                if (cpb->resp_flags & CPB_RESP_IGNORED) {
+                        __ata_ehi_push_desc(ehi, " ignored");
+                        ehi->err_mask |= AC_ERR_INVALID;
+                        freeze = true;
+                }
+
+                if (cpb->resp_flags & CPB_RESP_ATA_ERR)
+                        ehi->err_mask |= AC_ERR_DEV;
+
+                if (cpb->resp_flags & CPB_RESP_SPURIOUS) {
+                        __ata_ehi_push_desc(ehi, " spurious-intr");
+                        ehi->err_mask |= AC_ERR_HSM;
+                        freeze = true;
+                }
+
+                if (cpb->resp_flags &
+                    (CPB_RESP_UNDERFLOW | CPB_RESP_OVERFLOW)) {
+                        __ata_ehi_push_desc(ehi, " data-over/underflow");
+                        ehi->err_mask |= AC_ERR_HSM;
+                        freeze = true;
+                }
+        }
+
+        if (freeze)
+                ata_port_freeze(ap);
+        else
+                ata_port_abort(ap);
 }
 
 static void inic_host_intr(struct ata_port *ap)
 {
         void __iomem *port_base = inic_port_base(ap);
-        struct ata_eh_info *ehi = &ap->link.eh_info;
+        struct ata_queued_cmd *qc = ata_qc_from_tag(ap, ap->link.active_tag);
         u8 irq_stat;
+        u16 idma_stat;
 
-        /* fetch and clear irq */
+        /* read and clear IRQ status */
         irq_stat = readb(port_base + PORT_IRQ_STAT);
         writeb(irq_stat, port_base + PORT_IRQ_STAT);
+        idma_stat = readw(port_base + PORT_IDMA_STAT);
 
-        if (likely(!(irq_stat & PIRQ_ERR))) {
-                struct ata_queued_cmd *qc =
-                        ata_qc_from_tag(ap, ap->link.active_tag);
+        if (unlikely((irq_stat & PIRQ_ERR) || (idma_stat & IDMA_STAT_ERR)))
+                inic_host_err_intr(ap, irq_stat, idma_stat);
 
-                if (unlikely(!qc || (qc->tf.flags & ATA_TFLAG_POLLING))) {
-                        ap->ops->sff_check_status(ap); /* clear ATA interrupt */
-                        return;
-                }
+        if (unlikely(!qc))
+                goto spurious;
 
-                if (likely(ata_sff_host_intr(ap, qc)))
-                        return;
+        if (likely(idma_stat & IDMA_STAT_DONE)) {
+                inic_stop_idma(ap);
 
-                ap->ops->sff_check_status(ap); /* clear ATA interrupt */
-                ata_port_printk(ap, KERN_WARNING, "unhandled "
-                                "interrupt, irq_stat=%x\n", irq_stat);
+                /* Depending on circumstances, device error
+                 * isn't reported by IDMA, check it explicitly.
+                 */
+                if (unlikely(readb(port_base + PORT_TF_COMMAND) &
+                             (ATA_DF | ATA_ERR)))
+                        qc->err_mask |= AC_ERR_DEV;
+
+                ata_qc_complete(qc);
                 return;
         }
 
-        /* error */
-        ata_ehi_push_desc(ehi, "irq_stat=0x%x", irq_stat);
-
-        if (irq_stat & (PIRQ_OFFLINE | PIRQ_ONLINE)) {
-                ata_ehi_hotplugged(ehi);
-                ata_port_freeze(ap);
-        } else
-                ata_port_abort(ap);
+ spurious:
+        ata_port_printk(ap, KERN_WARNING, "unhandled interrupt: "
+                        "cmd=0x%x irq_stat=0x%x idma_stat=0x%x\n",
+                        qc ? qc->tf.command : 0xff, irq_stat, idma_stat);
 }
 
 static irqreturn_t inic_interrupt(int irq, void *dev_instance)
 {
         struct ata_host *host = dev_instance;
-        void __iomem *mmio_base = host->iomap[MMIO_BAR];
+        struct inic_host_priv *hpriv = host->private_data;
         u16 host_irq_stat;
         int i, handled = 0;;
 
-        host_irq_stat = readw(mmio_base + HOST_IRQ_STAT);
+        host_irq_stat = readw(hpriv->mmio_base + HOST_IRQ_STAT);
 
         if (unlikely(!(host_irq_stat & HIRQ_GLOBAL)))
                 goto out;
@@ -327,60 +436,173 @@ static irqreturn_t inic_interrupt(int irq, void *dev_instance)
         return IRQ_RETVAL(handled);
 }
 
+static int inic_check_atapi_dma(struct ata_queued_cmd *qc)
+{
+        /* For some reason ATAPI_PROT_DMA doesn't work for some
+         * commands including writes and other misc ops.  Use PIO
+         * protocol instead, which BTW is driven by the DMA engine
+         * anyway, so it shouldn't make much difference for native
+         * SATA devices.
+         */
+        if (atapi_cmd_type(qc->cdb[0]) == READ)
+                return 0;
+        return 1;
+}
+
+static void inic_fill_sg(struct inic_prd *prd, struct ata_queued_cmd *qc)
+{
+        struct scatterlist *sg;
+        unsigned int si;
+        u8 flags = 0;
+
+        if (qc->tf.flags & ATA_TFLAG_WRITE)
+                flags |= PRD_WRITE;
+
+        if (ata_is_dma(qc->tf.protocol))
+                flags |= PRD_DMA;
+
+        for_each_sg(qc->sg, sg, qc->n_elem, si) {
+                prd->mad = cpu_to_le32(sg_dma_address(sg));
+                prd->len = cpu_to_le16(sg_dma_len(sg));
+                prd->flags = flags;
+                prd++;
+        }
+
+        WARN_ON(!si);
+        prd[-1].flags |= PRD_END;
+}
+
+static void inic_qc_prep(struct ata_queued_cmd *qc)
+{
+        struct inic_port_priv *pp = qc->ap->private_data;
+        struct inic_pkt *pkt = pp->pkt;
+        struct inic_cpb *cpb = &pkt->cpb;
+        struct inic_prd *prd = pkt->prd;
+        bool is_atapi = ata_is_atapi(qc->tf.protocol);
+        bool is_data = ata_is_data(qc->tf.protocol);
+        unsigned int cdb_len = 0;
+
+        VPRINTK("ENTER\n");
+
+        if (is_atapi)
+                cdb_len = qc->dev->cdb_len;
+
+        /* prepare packet, based on initio driver */
+        memset(pkt, 0, sizeof(struct inic_pkt));
+
+        cpb->ctl_flags = CPB_CTL_VALID | CPB_CTL_IEN;
+        if (is_atapi || is_data)
+                cpb->ctl_flags |= CPB_CTL_DATA;
+
+        cpb->len = cpu_to_le32(qc->nbytes + cdb_len);
+        cpb->prd = cpu_to_le32(pp->pkt_dma + offsetof(struct inic_pkt, prd));
+
+        cpb->device = qc->tf.device;
+        cpb->feature = qc->tf.feature;
+        cpb->nsect = qc->tf.nsect;
+        cpb->lbal = qc->tf.lbal;
+        cpb->lbam = qc->tf.lbam;
+        cpb->lbah = qc->tf.lbah;
+
+        if (qc->tf.flags & ATA_TFLAG_LBA48) {
+                cpb->hob_feature = qc->tf.hob_feature;
+                cpb->hob_nsect = qc->tf.hob_nsect;
+                cpb->hob_lbal = qc->tf.hob_lbal;
+                cpb->hob_lbam = qc->tf.hob_lbam;
+                cpb->hob_lbah = qc->tf.hob_lbah;
+        }
+
+        cpb->command = qc->tf.command;
+        /* don't load ctl - dunno why.  it's like that in the initio driver */
+
+        /* setup PRD for CDB */
+        if (is_atapi) {
+                memcpy(pkt->cdb, qc->cdb, ATAPI_CDB_LEN);
+                prd->mad = cpu_to_le32(pp->pkt_dma +
+                                       offsetof(struct inic_pkt, cdb));
+                prd->len = cpu_to_le16(cdb_len);
+                prd->flags = PRD_CDB | PRD_WRITE;
+                if (!is_data)
+                        prd->flags |= PRD_END;
+                prd++;
+        }
+
+        /* setup sg table */
+        if (is_data)
+                inic_fill_sg(prd, qc);
+
+        pp->cpb_tbl[0] = pp->pkt_dma;
+}
+
 static unsigned int inic_qc_issue(struct ata_queued_cmd *qc)
 {
         struct ata_port *ap = qc->ap;
+        void __iomem *port_base = inic_port_base(ap);
 
-        /* ATA IRQ doesn't wait for DMA transfer completion and vice
-         * versa.  Mask IRQ selectively to detect command completion.
-         * Without it, ATA DMA read command can cause data corruption.
-         *
-         * Something similar might be needed for ATAPI writes.  I
-         * tried a lot of combinations but couldn't find the solution.
-         */
-        if (qc->tf.protocol == ATA_PROT_DMA &&
-            !(qc->tf.flags & ATA_TFLAG_WRITE))
-                inic_set_pirq_mask(ap, PIRQ_MASK_DMA_READ);
-        else
-                inic_set_pirq_mask(ap, PIRQ_MASK_OTHER);
+        /* fire up the ADMA engine */
+        writew(HCTL_FTHD0, port_base + HOST_CTL);
+        writew(IDMA_CTL_GO, port_base + PORT_IDMA_CTL);
+        writeb(0, port_base + PORT_CPB_PTQFIFO);
+
+        return 0;
+}
+
+static void inic_tf_read(struct ata_port *ap, struct ata_taskfile *tf)
+{
+        void __iomem *port_base = inic_port_base(ap);
+
+        tf->feature     = readb(port_base + PORT_TF_FEATURE);
+        tf->nsect       = readb(port_base + PORT_TF_NSECT);
+        tf->lbal        = readb(port_base + PORT_TF_LBAL);
+        tf->lbam        = readb(port_base + PORT_TF_LBAM);
+        tf->lbah        = readb(port_base + PORT_TF_LBAH);
+        tf->device      = readb(port_base + PORT_TF_DEVICE);
+        tf->command     = readb(port_base + PORT_TF_COMMAND);
+}
 
-        /* Issuing a command to yet uninitialized port locks up the
-         * controller.  Most of the time, this happens for the first
-         * command after reset which are ATA and ATAPI IDENTIFYs.
-         * Fast fail if stat is 0x7f or 0xff for those commands.
+static bool inic_qc_fill_rtf(struct ata_queued_cmd *qc)
+{
+        struct ata_taskfile *rtf = &qc->result_tf;
+        struct ata_taskfile tf;
+
+        /* FIXME: Except for status and error, result TF access
+         * doesn't work.  I tried reading from BAR0/2, CPB and BAR5.
+         * None works regardless of which command interface is used.
+         * For now return true iff status indicates device error.
+         * This means that we're reporting bogus sector for RW
+         * failures.  Eeekk....
          */
-        if (unlikely(qc->tf.command == ATA_CMD_ID_ATA ||
-                     qc->tf.command == ATA_CMD_ID_ATAPI)) {
-                u8 stat = ap->ops->sff_check_status(ap);
-                if (stat == 0x7f || stat == 0xff)
-                        return AC_ERR_HSM;
-        }
+        inic_tf_read(qc->ap, &tf);
 
-        return ata_sff_qc_issue(qc);
+        if (!(tf.command & ATA_ERR))
+                return false;
+
+        rtf->command = tf.command;
+        rtf->feature = tf.feature;
+        return true;
 }
 
 static void inic_freeze(struct ata_port *ap)
 {
         void __iomem *port_base = inic_port_base(ap);
 
-        __inic_set_pirq_mask(ap, PIRQ_MASK_FREEZE);
-
-        ap->ops->sff_check_status(ap);
+        writeb(PIRQ_MASK_FREEZE, port_base + PORT_IRQ_MASK);
         writeb(0xff, port_base + PORT_IRQ_STAT);
-
-        readb(port_base + PORT_IRQ_STAT); /* flush */
 }
 
 static void inic_thaw(struct ata_port *ap)
 {
         void __iomem *port_base = inic_port_base(ap);
 
-        ap->ops->sff_check_status(ap);
         writeb(0xff, port_base + PORT_IRQ_STAT);
+        writeb(PIRQ_MASK_DEFAULT, port_base + PORT_IRQ_MASK);
+}
 
-        __inic_set_pirq_mask(ap, PIRQ_MASK_OTHER);
+static int inic_check_ready(struct ata_link *link)
+{
+        void __iomem *port_base = inic_port_base(link->ap);
 
-        readb(port_base + PORT_IRQ_STAT); /* flush */
+        return ata_check_ready(readb(port_base + PORT_TF_COMMAND));
 }
 
 /*
@@ -394,17 +616,15 @@ static int inic_hardreset(struct ata_link *link, unsigned int *class,
         void __iomem *port_base = inic_port_base(ap);
         void __iomem *idma_ctl = port_base + PORT_IDMA_CTL;
         const unsigned long *timing = sata_ehc_deb_timing(&link->eh_context);
-        u16 val;
         int rc;
 
         /* hammer it into sane state */
         inic_reset_port(port_base);
 
-        val = readw(idma_ctl);
-        writew(val | IDMA_CTL_RST_ATA, idma_ctl);
+        writew(IDMA_CTL_RST_ATA, idma_ctl);
         readw(idma_ctl);        /* flush */
         msleep(1);
-        writew(val & ~IDMA_CTL_RST_ATA, idma_ctl);
+        writew(0, idma_ctl);
 
         rc = sata_link_resume(link, timing, deadline);
         if (rc) {
@@ -418,7 +638,7 @@ static int inic_hardreset(struct ata_link *link, unsigned int *class,
                 struct ata_taskfile tf;
 
                 /* wait for link to become ready */
-                rc = ata_sff_wait_after_reset(link, 1, deadline);
+                rc = ata_wait_after_reset(link, deadline, inic_check_ready);
                 /* link occupied, -ENODEV too is an error */
                 if (rc) {
                         ata_link_printk(link, KERN_WARNING, "device not ready "
@@ -426,7 +646,7 @@ static int inic_hardreset(struct ata_link *link, unsigned int *class,
                         return rc;
                 }
 
-                ata_sff_tf_read(ap, &tf);
+                inic_tf_read(ap, &tf);
                 *class = ata_dev_classify(&tf);
         }
 
@@ -436,18 +656,8 @@ static int inic_hardreset(struct ata_link *link, unsigned int *class,
 static void inic_error_handler(struct ata_port *ap)
 {
         void __iomem *port_base = inic_port_base(ap);
-        struct inic_port_priv *pp = ap->private_data;
-        unsigned long flags;
 
-        /* reset PIO HSM and stop DMA engine */
         inic_reset_port(port_base);
-
-        spin_lock_irqsave(ap->lock, flags);
-        ap->hsm_task_state = HSM_ST_IDLE;
-        writeb(pp->dfl_prdctl, port_base + PORT_PRD_CTL);
-        spin_unlock_irqrestore(ap->lock, flags);
-
-        /* PIO and DMA engines have been stopped, perform recovery */
         ata_std_error_handler(ap);
 }
 
@@ -458,26 +668,18 @@ static void inic_post_internal_cmd(struct ata_queued_cmd *qc)
                 inic_reset_port(inic_port_base(qc->ap));
 }
 
-static void inic_dev_config(struct ata_device *dev)
-{
-        /* inic can only handle upto LBA28 max sectors */
-        if (dev->max_sectors > ATA_MAX_SECTORS)
-                dev->max_sectors = ATA_MAX_SECTORS;
-
-        if (dev->n_sectors >= 1 << 28) {
-                ata_dev_printk(dev, KERN_ERR,
-        "ERROR: This driver doesn't support LBA48 yet and may cause\n"
-        "                data corruption on such devices.  Disabling.\n");
-                ata_dev_disable(dev);
-        }
-}
-
 static void init_port(struct ata_port *ap)
 {
         void __iomem *port_base = inic_port_base(ap);
+        struct inic_port_priv *pp = ap->private_data;
 
-        /* Setup PRD address */
+        /* clear packet and CPB table */
+        memset(pp->pkt, 0, sizeof(struct inic_pkt));
+        memset(pp->cpb_tbl, 0, IDMA_CPB_TBL_SIZE);
+
+        /* setup PRD and CPB lookup table addresses */
         writel(ap->prd_dma, port_base + PORT_PRD_ADDR);
+        writel(pp->cpb_tbl_dma, port_base + PORT_CPB_CPBLAR);
 }
 
 static int inic_port_resume(struct ata_port *ap)
@@ -488,28 +690,30 @@ static int inic_port_resume(struct ata_port *ap)
 
 static int inic_port_start(struct ata_port *ap)
 {
-        void __iomem *port_base = inic_port_base(ap);
+        struct device *dev = ap->host->dev;
         struct inic_port_priv *pp;
-        u8 tmp;
         int rc;
 
         /* alloc and initialize private data */
-        pp = devm_kzalloc(ap->host->dev, sizeof(*pp), GFP_KERNEL);
+        pp = devm_kzalloc(dev, sizeof(*pp), GFP_KERNEL);
         if (!pp)
                 return -ENOMEM;
         ap->private_data = pp;
 
-        /* default PRD_CTL value, DMAEN, WR and START off */
-        tmp = readb(port_base + PORT_PRD_CTL);
-        tmp &= ~(PRD_CTL_DMAEN | PRD_CTL_WR | PRD_CTL_START);
-        pp->dfl_prdctl = tmp;
-
         /* Alloc resources */
         rc = ata_port_start(ap);
-        if (rc) {
-                kfree(pp);
+        if (rc)
                 return rc;
-        }
+
+        pp->pkt = dmam_alloc_coherent(dev, sizeof(struct inic_pkt),
+                                      &pp->pkt_dma, GFP_KERNEL);
+        if (!pp->pkt)
+                return -ENOMEM;
+
+        pp->cpb_tbl = dmam_alloc_coherent(dev, IDMA_CPB_TBL_SIZE,
+                                          &pp->cpb_tbl_dma, GFP_KERNEL);
+        if (!pp->cpb_tbl)
+                return -ENOMEM;
 
         init_port(ap);
 
@@ -517,21 +721,18 @@ static int inic_port_start(struct ata_port *ap)
 }
 
 static struct ata_port_operations inic_port_ops = {
-        .inherits               = &ata_sff_port_ops,
+        .inherits               = &sata_port_ops,
 
-        .bmdma_setup            = inic_bmdma_setup,
-        .bmdma_start            = inic_bmdma_start,
-        .bmdma_stop             = inic_bmdma_stop,
-        .bmdma_status           = inic_bmdma_status,
+        .check_atapi_dma        = inic_check_atapi_dma,
+        .qc_prep                = inic_qc_prep,
         .qc_issue               = inic_qc_issue,
+        .qc_fill_rtf            = inic_qc_fill_rtf,
 
         .freeze                 = inic_freeze,
         .thaw                   = inic_thaw,
-        .softreset              = ATA_OP_NULL,  /* softreset is broken */
         .hardreset              = inic_hardreset,
         .error_handler          = inic_error_handler,
         .post_internal_cmd      = inic_post_internal_cmd,
-        .dev_config             = inic_dev_config,
 
         .scr_read               = inic_scr_read,
         .scr_write              = inic_scr_write,
@@ -541,12 +742,6 @@ static struct ata_port_operations inic_port_ops = {
 };
 
 static struct ata_port_info inic_port_info = {
-        /* For some reason, ATAPI_PROT_PIO is broken on this
-         * controller, and no, PIO_POLLING does't fix it.  It somehow
-         * manages to report the wrong ireason and ignoring ireason
-         * results in machine lock up.  Tell libata to always prefer
-         * DMA.
-         */
         .flags                  = ATA_FLAG_SATA | ATA_FLAG_PIO_DMA,
         .pio_mask               = 0x1f, /* pio0-4 */
         .mwdma_mask             = 0x07, /* mwdma0-2 */
@@ -599,7 +794,6 @@ static int inic_pci_device_resume(struct pci_dev *pdev)
 {
         struct ata_host *host = dev_get_drvdata(&pdev->dev);
         struct inic_host_priv *hpriv = host->private_data;
-        void __iomem *mmio_base = host->iomap[MMIO_BAR];
         int rc;
 
         rc = ata_pci_device_do_resume(pdev);
@@ -607,7 +801,7 @@ static int inic_pci_device_resume(struct pci_dev *pdev)
                 return rc;
 
         if (pdev->dev.power.power_state.event == PM_EVENT_SUSPEND) {
-                rc = init_controller(mmio_base, hpriv->cached_hctl);
+                rc = init_controller(hpriv->mmio_base, hpriv->cached_hctl);
                 if (rc)
                         return rc;
         }
@@ -625,6 +819,7 @@ static int inic_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
         struct ata_host *host;
         struct inic_host_priv *hpriv;
         void __iomem * const *iomap;
+        int mmio_bar;
         int i, rc;
 
         if (!printed_version++)
@@ -638,38 +833,31 @@ static int inic_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
 
         host->private_data = hpriv;
 
-        /* acquire resources and fill host */
+        /* Acquire resources and fill host.  Note that PCI and cardbus
+         * use different BARs.
+         */
         rc = pcim_enable_device(pdev);
         if (rc)
                 return rc;
 
-        rc = pcim_iomap_regions(pdev, 0x3f, DRV_NAME);
+        if (pci_resource_flags(pdev, MMIO_BAR_PCI) & IORESOURCE_MEM)
+                mmio_bar = MMIO_BAR_PCI;
+        else
+                mmio_bar = MMIO_BAR_CARDBUS;
+
+        rc = pcim_iomap_regions(pdev, 1 << mmio_bar, DRV_NAME);
         if (rc)
                 return rc;
         host->iomap = iomap = pcim_iomap_table(pdev);
+        hpriv->mmio_base = iomap[mmio_bar];
+        hpriv->cached_hctl = readw(hpriv->mmio_base + HOST_CTL);
 
         for (i = 0; i < NR_PORTS; i++) {
                 struct ata_port *ap = host->ports[i];
-                struct ata_ioports *port = &ap->ioaddr;
-                unsigned int offset = i * PORT_SIZE;
-
-                port->cmd_addr = iomap[2 * i];
-                port->altstatus_addr =
-                port->ctl_addr = (void __iomem *)
-                        ((unsigned long)iomap[2 * i + 1] | ATA_PCI_CTL_OFS);
-                port->scr_addr = iomap[MMIO_BAR] + offset + PORT_SCR;
-
-                ata_sff_std_ports(port);
-
-                ata_port_pbar_desc(ap, MMIO_BAR, -1, "mmio");
-                ata_port_pbar_desc(ap, MMIO_BAR, offset, "port");
-                ata_port_desc(ap, "cmd 0x%llx ctl 0x%llx",
-                  (unsigned long long)pci_resource_start(pdev, 2 * i),
-                  (unsigned long long)pci_resource_start(pdev, (2 * i + 1)) |
-                                      ATA_PCI_CTL_OFS);
-        }
 
-        hpriv->cached_hctl = readw(iomap[MMIO_BAR] + HOST_CTL);
+                ata_port_pbar_desc(ap, mmio_bar, -1, "mmio");
+                ata_port_pbar_desc(ap, mmio_bar, i * PORT_SIZE, "port");
+        }
 
         /* Set dma_mask.  This devices doesn't support 64bit addressing. */
         rc = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
@@ -698,7 +886,7 @@ static int inic_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
                 return rc;
         }
 
-        rc = init_controller(iomap[MMIO_BAR], hpriv->cached_hctl);
+        rc = init_controller(hpriv->mmio_base, hpriv->cached_hctl);
         if (rc) {
                 dev_printk(KERN_ERR, &pdev->dev,
                            "failed to initialize controller\n");
diff --git a/drivers/ata/sata_mv.c b/drivers/ata/sata_mv.c
index 842b1a15b78c..bb73b2222627 100644
--- a/drivers/ata/sata_mv.c
+++ b/drivers/ata/sata_mv.c
@@ -65,6 +65,7 @@
 #include <linux/platform_device.h>
 #include <linux/ata_platform.h>
 #include <linux/mbus.h>
+#include <linux/bitops.h>
 #include <scsi/scsi_host.h>
 #include <scsi/scsi_cmnd.h>
 #include <scsi/scsi_device.h>
@@ -91,9 +92,9 @@ enum {
         MV_IRQ_COAL_TIME_THRESHOLD      = (MV_IRQ_COAL_REG_BASE + 0xd0),
 
         MV_SATAHC0_REG_BASE     = 0x20000,
-        MV_FLASH_CTL            = 0x1046c,
-        MV_GPIO_PORT_CTL        = 0x104f0,
-        MV_RESET_CFG            = 0x180d8,
+        MV_FLASH_CTL_OFS        = 0x1046c,
+        MV_GPIO_PORT_CTL_OFS    = 0x104f0,
+        MV_RESET_CFG_OFS        = 0x180d8,
 
         MV_PCI_REG_SZ           = MV_MAJOR_REG_AREA_SZ,
         MV_SATAHC_REG_SZ        = MV_MAJOR_REG_AREA_SZ,
@@ -147,18 +148,21 @@ enum {
         /* PCI interface registers */
 
         PCI_COMMAND_OFS         = 0xc00,
+        PCI_COMMAND_MRDTRIG     = (1 << 7),     /* PCI Master Read Trigger */
 
         PCI_MAIN_CMD_STS_OFS    = 0xd30,
         STOP_PCI_MASTER         = (1 << 2),
         PCI_MASTER_EMPTY        = (1 << 3),
         GLOB_SFT_RST            = (1 << 4),
 
-        MV_PCI_MODE             = 0xd00,
+        MV_PCI_MODE_OFS         = 0xd00,
+        MV_PCI_MODE_MASK        = 0x30,
+
         MV_PCI_EXP_ROM_BAR_CTL  = 0xd2c,
         MV_PCI_DISC_TIMER       = 0xd04,
         MV_PCI_MSI_TRIGGER      = 0xc38,
         MV_PCI_SERR_MASK        = 0xc28,
-        MV_PCI_XBAR_TMOUT       = 0x1d04,
+        MV_PCI_XBAR_TMOUT_OFS   = 0x1d04,
         MV_PCI_ERR_LOW_ADDRESS  = 0x1d40,
         MV_PCI_ERR_HIGH_ADDRESS = 0x1d44,
         MV_PCI_ERR_ATTRIBUTE    = 0x1d48,
@@ -225,16 +229,18 @@ enum {
         PHY_MODE4               = 0x314,
         PHY_MODE2               = 0x330,
         SATA_IFCTL_OFS          = 0x344,
+        SATA_TESTCTL_OFS        = 0x348,
         SATA_IFSTAT_OFS         = 0x34c,
         VENDOR_UNIQUE_FIS_OFS   = 0x35c,
 
-        FIS_CFG_OFS             = 0x360,
-        FIS_CFG_SINGLE_SYNC     = (1 << 16),    /* SYNC on DMA activation */
+        FISCFG_OFS              = 0x360,
+        FISCFG_WAIT_DEV_ERR     = (1 << 8),     /* wait for host on DevErr */
+        FISCFG_SINGLE_SYNC      = (1 << 16),    /* SYNC on DMA activation */
 
         MV5_PHY_MODE            = 0x74,
-        MV5_LT_MODE             = 0x30,
-        MV5_PHY_CTL             = 0x0C,
-        SATA_INTERFACE_CFG      = 0x050,
+        MV5_LTMODE_OFS          = 0x30,
+        MV5_PHY_CTL_OFS         = 0x0C,
+        SATA_INTERFACE_CFG_OFS  = 0x050,
 
         MV_M2_PREAMP_MASK       = 0x7e0,
 
@@ -332,10 +338,16 @@ enum {
         EDMA_CMD_OFS            = 0x28,         /* EDMA command register */
         EDMA_EN                 = (1 << 0),     /* enable EDMA */
         EDMA_DS                 = (1 << 1),     /* disable EDMA; self-negated */
-        ATA_RST                 = (1 << 2),     /* reset trans/link/phy */
+        EDMA_RESET              = (1 << 2),     /* reset eng/trans/link/phy */
+
+        EDMA_STATUS_OFS         = 0x30,         /* EDMA engine status */
+        EDMA_STATUS_CACHE_EMPTY = (1 << 6),     /* GenIIe command cache empty */
+        EDMA_STATUS_IDLE        = (1 << 7),     /* GenIIe EDMA enabled/idle */
 
-        EDMA_IORDY_TMOUT        = 0x34,
-        EDMA_ARB_CFG            = 0x38,
+        EDMA_IORDY_TMOUT_OFS    = 0x34,
+        EDMA_ARB_CFG_OFS        = 0x38,
+
+        EDMA_HALTCOND_OFS       = 0x60,         /* GenIIe halt conditions */
 
         GEN_II_NCQ_MAX_SECTORS  = 256,          /* max sects/io on Gen2 w/NCQ */
 
@@ -350,15 +362,19 @@ enum {
         MV_HP_GEN_II            = (1 << 7),     /* Generation II: 60xx */
         MV_HP_GEN_IIE           = (1 << 8),     /* Generation IIE: 6042/7042 */
         MV_HP_PCIE              = (1 << 9),     /* PCIe bus/regs: 7042 */
+        MV_HP_CUT_THROUGH       = (1 << 10),    /* can use EDMA cut-through */
 
         /* Port private flags (pp_flags) */
         MV_PP_FLAG_EDMA_EN      = (1 << 0),     /* is EDMA engine enabled? */
         MV_PP_FLAG_NCQ_EN       = (1 << 1),     /* is EDMA set up for NCQ? */
+        MV_PP_FLAG_FBS_EN       = (1 << 2),     /* is EDMA set up for FBS? */
+        MV_PP_FLAG_DELAYED_EH   = (1 << 3),     /* delayed dev err handling */
 };
 
 #define IS_GEN_I(hpriv) ((hpriv)->hp_flags & MV_HP_GEN_I)
 #define IS_GEN_II(hpriv) ((hpriv)->hp_flags & MV_HP_GEN_II)
 #define IS_GEN_IIE(hpriv) ((hpriv)->hp_flags & MV_HP_GEN_IIE)
+#define IS_PCIE(hpriv) ((hpriv)->hp_flags & MV_HP_PCIE)
 #define HAS_PCI(host) (!((host)->ports[0]->flags & MV_FLAG_SOC))
 
 #define WINDOW_CTRL(i)          (0x20030 + ((i) << 4))
@@ -433,6 +449,7 @@ struct mv_port_priv {
         unsigned int            resp_idx;
 
         u32                     pp_flags;
+        unsigned int            delayed_eh_pmp_map;
 };
 
 struct mv_port_signal {
@@ -479,6 +496,7 @@ static int mv5_scr_read(struct ata_port *ap, unsigned int sc_reg_in, u32 *val);
 static int mv5_scr_write(struct ata_port *ap, unsigned int sc_reg_in, u32 val);
 static int mv_port_start(struct ata_port *ap);
 static void mv_port_stop(struct ata_port *ap);
+static int mv_qc_defer(struct ata_queued_cmd *qc);
 static void mv_qc_prep(struct ata_queued_cmd *qc);
 static void mv_qc_prep_iie(struct ata_queued_cmd *qc);
 static unsigned int mv_qc_issue(struct ata_queued_cmd *qc);
@@ -527,6 +545,9 @@ static int mv_pmp_hardreset(struct ata_link *link, unsigned int *class,
                                 unsigned long deadline);
 static int  mv_softreset(struct ata_link *link, unsigned int *class,
                                 unsigned long deadline);
+static void mv_pmp_error_handler(struct ata_port *ap);
+static void mv_process_crpb_entries(struct ata_port *ap,
+                                        struct mv_port_priv *pp);
 
 /* .sg_tablesize is (MV_MAX_SG_CT / 2) in the structures below
  * because we have to allow room for worst case splitting of
@@ -548,6 +569,7 @@ static struct scsi_host_template mv6_sht = {
 static struct ata_port_operations mv5_ops = {
         .inherits               = &ata_sff_port_ops,
 
+        .qc_defer               = mv_qc_defer,
         .qc_prep                = mv_qc_prep,
         .qc_issue               = mv_qc_issue,
 
@@ -566,7 +588,6 @@ static struct ata_port_operations mv5_ops = {
 
 static struct ata_port_operations mv6_ops = {
         .inherits               = &mv5_ops,
-        .qc_defer               = sata_pmp_qc_defer_cmd_switch,
         .dev_config             = mv6_dev_config,
         .scr_read               = mv_scr_read,
         .scr_write              = mv_scr_write,
@@ -574,12 +595,11 @@ static struct ata_port_operations mv6_ops = {
         .pmp_hardreset          = mv_pmp_hardreset,
         .pmp_softreset          = mv_softreset,
         .softreset              = mv_softreset,
-        .error_handler          = sata_pmp_error_handler,
+        .error_handler          = mv_pmp_error_handler,
 };
 
 static struct ata_port_operations mv_iie_ops = {
         .inherits               = &mv6_ops,
-        .qc_defer               = ata_std_qc_defer, /* FIS-based switching */
         .dev_config             = ATA_OP_NULL,
         .qc_prep                = mv_qc_prep_iie,
 };
@@ -875,6 +895,29 @@ static void mv_start_dma(struct ata_port *ap, void __iomem *port_mmio,
         }
 }
 
+static void mv_wait_for_edma_empty_idle(struct ata_port *ap)
+{
+        void __iomem *port_mmio = mv_ap_base(ap);
+        const u32 empty_idle = (EDMA_STATUS_CACHE_EMPTY | EDMA_STATUS_IDLE);
+        const int per_loop = 5, timeout = (15 * 1000 / per_loop);
+        int i;
+
+        /*
+         * Wait for the EDMA engine to finish transactions in progress.
+         * No idea what a good "timeout" value might be, but measurements
+         * indicate that it often requires hundreds of microseconds
+         * with two drives in-use.  So we use the 15msec value above
+         * as a rough guess at what even more drives might require.
+         */
+        for (i = 0; i < timeout; ++i) {
+                u32 edma_stat = readl(port_mmio + EDMA_STATUS_OFS);
+                if ((edma_stat & empty_idle) == empty_idle)
+                        break;
+                udelay(per_loop);
+        }
+        /* ata_port_printk(ap, KERN_INFO, "%s: %u+ usecs\n", __func__, i); */
+}
+
 /**
  *      mv_stop_edma_engine - Disable eDMA engine
  *      @port_mmio: io base address
@@ -907,6 +950,7 @@ static int mv_stop_edma(struct ata_port *ap)
         if (!(pp->pp_flags & MV_PP_FLAG_EDMA_EN))
                 return 0;
         pp->pp_flags &= ~MV_PP_FLAG_EDMA_EN;
+        mv_wait_for_edma_empty_idle(ap);
         if (mv_stop_edma_engine(port_mmio)) {
                 ata_port_printk(ap, KERN_ERR, "Unable to stop eDMA\n");
                 return -EIO;
@@ -1057,26 +1101,95 @@ static void mv6_dev_config(struct ata_device *adev)
         }
 }
 
-static void mv_config_fbs(void __iomem *port_mmio, int enable_fbs)
+static int mv_qc_defer(struct ata_queued_cmd *qc)
 {
-        u32 old_fcfg, new_fcfg, old_ltmode, new_ltmode;
+        struct ata_link *link = qc->dev->link;
+        struct ata_port *ap = link->ap;
+        struct mv_port_priv *pp = ap->private_data;
+
+        /*
+         * Don't allow new commands if we're in a delayed EH state
+         * for NCQ and/or FIS-based switching.
+         */
+        if (pp->pp_flags & MV_PP_FLAG_DELAYED_EH)
+                return ATA_DEFER_PORT;
         /*
-         * Various bit settings required for operation
-         * in FIS-based switching (fbs) mode on GenIIe:
+         * If the port is completely idle, then allow the new qc.
          */
-        old_fcfg   = readl(port_mmio + FIS_CFG_OFS);
-        old_ltmode = readl(port_mmio + LTMODE_OFS);
-        if (enable_fbs) {
-                new_fcfg   = old_fcfg   |  FIS_CFG_SINGLE_SYNC;
-                new_ltmode = old_ltmode |  LTMODE_BIT8;
-        } else { /* disable fbs */
-                new_fcfg   = old_fcfg   & ~FIS_CFG_SINGLE_SYNC;
-                new_ltmode = old_ltmode & ~LTMODE_BIT8;
-        }
-        if (new_fcfg != old_fcfg)
-                writelfl(new_fcfg, port_mmio + FIS_CFG_OFS);
+        if (ap->nr_active_links == 0)
+                return 0;
+
+        if (pp->pp_flags & MV_PP_FLAG_EDMA_EN) {
+                /*
+                 * The port is operating in host queuing mode (EDMA).
+                 * It can accomodate a new qc if the qc protocol
+                 * is compatible with the current host queue mode.
+                 */
+                if (pp->pp_flags & MV_PP_FLAG_NCQ_EN) {
+                        /*
+                         * The host queue (EDMA) is in NCQ mode.
+                         * If the new qc is also an NCQ command,
+                         * then allow the new qc.
+                         */
+                        if (qc->tf.protocol == ATA_PROT_NCQ)
+                                return 0;
+                } else {
+                        /*
+                         * The host queue (EDMA) is in non-NCQ, DMA mode.
+                         * If the new qc is also a non-NCQ, DMA command,
+                         * then allow the new qc.
+                         */
+                        if (qc->tf.protocol == ATA_PROT_DMA)
+                                return 0;
+                }
+        }
+        return ATA_DEFER_PORT;
+}
+
+static void mv_config_fbs(void __iomem *port_mmio, int want_ncq, int want_fbs)
+{
+        u32 new_fiscfg, old_fiscfg;
+        u32 new_ltmode, old_ltmode;
+        u32 new_haltcond, old_haltcond;
+
+        old_fiscfg   = readl(port_mmio + FISCFG_OFS);
+        old_ltmode   = readl(port_mmio + LTMODE_OFS);
+        old_haltcond = readl(port_mmio + EDMA_HALTCOND_OFS);
+
+        new_fiscfg   = old_fiscfg & ~(FISCFG_SINGLE_SYNC | FISCFG_WAIT_DEV_ERR);
+        new_ltmode   = old_ltmode & ~LTMODE_BIT8;
+        new_haltcond = old_haltcond | EDMA_ERR_DEV;
+
+        if (want_fbs) {
+                new_fiscfg = old_fiscfg | FISCFG_SINGLE_SYNC;
+                new_ltmode = old_ltmode | LTMODE_BIT8;
+                if (want_ncq)
+                        new_haltcond &= ~EDMA_ERR_DEV;
+                else
+                        new_fiscfg |=  FISCFG_WAIT_DEV_ERR;
+        }
+
+        if (new_fiscfg != old_fiscfg)
+                writelfl(new_fiscfg, port_mmio + FISCFG_OFS);
         if (new_ltmode != old_ltmode)
                 writelfl(new_ltmode, port_mmio + LTMODE_OFS);
+        if (new_haltcond != old_haltcond)
+                writelfl(new_haltcond, port_mmio + EDMA_HALTCOND_OFS);
+}
+
+static void mv_60x1_errata_sata25(struct ata_port *ap, int want_ncq)
+{
+        struct mv_host_priv *hpriv = ap->host->private_data;
+        u32 old, new;
+
+        /* workaround for 88SX60x1 FEr SATA#25 (part 1) */
+        old = readl(hpriv->base + MV_GPIO_PORT_CTL_OFS);
+        if (want_ncq)
+                new = old | (1 << 22);
+        else
+                new = old & ~(1 << 22);
+        if (new != old)
+                writel(new, hpriv->base + MV_GPIO_PORT_CTL_OFS);
 }
 
 static void mv_edma_cfg(struct ata_port *ap, int want_ncq)
@@ -1088,25 +1201,40 @@ static void mv_edma_cfg(struct ata_port *ap, int want_ncq)
 
         /* set up non-NCQ EDMA configuration */
         cfg = EDMA_CFG_Q_DEPTH;         /* always 0x1f for *all* chips */
+        pp->pp_flags &= ~MV_PP_FLAG_FBS_EN;
 
         if (IS_GEN_I(hpriv))
                 cfg |= (1 << 8);        /* enab config burst size mask */
 
-        else if (IS_GEN_II(hpriv))
+        else if (IS_GEN_II(hpriv)) {
                 cfg |= EDMA_CFG_RD_BRST_EXT | EDMA_CFG_WR_BUFF_LEN;
+                mv_60x1_errata_sata25(ap, want_ncq);
 
-        else if (IS_GEN_IIE(hpriv)) {
-                cfg |= (1 << 23);       /* do not mask PM field in rx'd FIS */
-                cfg |= (1 << 22);       /* enab 4-entry host queue cache */
-                cfg |= (1 << 18);       /* enab early completion */
-                cfg |= (1 << 17);       /* enab cut-through (dis stor&forwrd) */
+        } else if (IS_GEN_IIE(hpriv)) {
+                int want_fbs = sata_pmp_attached(ap);
+                /*
+                 * Possible future enhancement:
+                 *
+                 * The chip can use FBS with non-NCQ, if we allow it,
+                 * But first we need to have the error handling in place
+                 * for this mode (datasheet section 7.3.15.4.2.3).
+                 * So disallow non-NCQ FBS for now.
+                 */
+                want_fbs &= want_ncq;
+
+                mv_config_fbs(port_mmio, want_ncq, want_fbs);
 
-                if (want_ncq && sata_pmp_attached(ap)) {
+                if (want_fbs) {
+                        pp->pp_flags |= MV_PP_FLAG_FBS_EN;
                         cfg |= EDMA_CFG_EDMA_FBS; /* FIS-based switching */
-                        mv_config_fbs(port_mmio, 1);
-                } else {
-                        mv_config_fbs(port_mmio, 0);
                 }
+
+                cfg |= (1 << 23);       /* do not mask PM field in rx'd FIS */
+                cfg |= (1 << 22);       /* enab 4-entry host queue cache */
+                if (HAS_PCI(ap->host))
+                        cfg |= (1 << 18);       /* enab early completion */
+                if (hpriv->hp_flags & MV_HP_CUT_THROUGH)
+                        cfg |= (1 << 17); /* enab cut-thru (dis stor&forwrd) */
         }
 
         if (want_ncq) {
@@ -1483,25 +1611,186 @@ static struct ata_queued_cmd *mv_get_active_qc(struct ata_port *ap)
         return qc;
 }
 
-static void mv_unexpected_intr(struct ata_port *ap)
+static void mv_pmp_error_handler(struct ata_port *ap)
 {
+        unsigned int pmp, pmp_map;
         struct mv_port_priv *pp = ap->private_data;
-        struct ata_eh_info *ehi = &ap->link.eh_info;
-        char *when = "";
 
+        if (pp->pp_flags & MV_PP_FLAG_DELAYED_EH) {
+                /*
+                 * Perform NCQ error analysis on failed PMPs
+                 * before we freeze the port entirely.
+                 *
+                 * The failed PMPs are marked earlier by mv_pmp_eh_prep().
+                 */
+                pmp_map = pp->delayed_eh_pmp_map;
+                pp->pp_flags &= ~MV_PP_FLAG_DELAYED_EH;
+                for (pmp = 0; pmp_map != 0; pmp++) {
+                        unsigned int this_pmp = (1 << pmp);
+                        if (pmp_map & this_pmp) {
+                                struct ata_link *link = &ap->pmp_link[pmp];
+                                pmp_map &= ~this_pmp;
+                                ata_eh_analyze_ncq_error(link);
+                        }
+                }
+                ata_port_freeze(ap);
+        }
+        sata_pmp_error_handler(ap);
+}
+
+static unsigned int mv_get_err_pmp_map(struct ata_port *ap)
+{
+        void __iomem *port_mmio = mv_ap_base(ap);
+
+        return readl(port_mmio + SATA_TESTCTL_OFS) >> 16;
+}
+
+static void mv_pmp_eh_prep(struct ata_port *ap, unsigned int pmp_map)
+{
+        struct ata_eh_info *ehi;
+        unsigned int pmp;
+
+        /*
+         * Initialize EH info for PMPs which saw device errors
+         */
+        ehi = &ap->link.eh_info;
+        for (pmp = 0; pmp_map != 0; pmp++) {
+                unsigned int this_pmp = (1 << pmp);
+                if (pmp_map & this_pmp) {
+                        struct ata_link *link = &ap->pmp_link[pmp];
+
+                        pmp_map &= ~this_pmp;
+                        ehi = &link->eh_info;
+                        ata_ehi_clear_desc(ehi);
+                        ata_ehi_push_desc(ehi, "dev err");
+                        ehi->err_mask |= AC_ERR_DEV;
+                        ehi->action |= ATA_EH_RESET;
+                        ata_link_abort(link);
+                }
+        }
+}
+
+static int mv_handle_fbs_ncq_dev_err(struct ata_port *ap)
+{
+        struct mv_port_priv *pp = ap->private_data;
+        int failed_links;
+        unsigned int old_map, new_map;
+
+        /*
+         * Device error during FBS+NCQ operation:
+         *
+         * Set a port flag to prevent further I/O being enqueued.
+         * Leave the EDMA running to drain outstanding commands from this port.
+         * Perform the post-mortem/EH only when all responses are complete.
+         * Follow recovery sequence from 6042/7042 datasheet (7.3.15.4.2.2).
+         */
+        if (!(pp->pp_flags & MV_PP_FLAG_DELAYED_EH)) {
+                pp->pp_flags |= MV_PP_FLAG_DELAYED_EH;
+                pp->delayed_eh_pmp_map = 0;
+        }
+        old_map = pp->delayed_eh_pmp_map;
+        new_map = old_map | mv_get_err_pmp_map(ap);
+
+        if (old_map != new_map) {
+                pp->delayed_eh_pmp_map = new_map;
+                mv_pmp_eh_prep(ap, new_map & ~old_map);
+        }
+        failed_links = hweight16(new_map);
+
+        ata_port_printk(ap, KERN_INFO, "%s: pmp_map=%04x qc_map=%04x "
+                        "failed_links=%d nr_active_links=%d\n",
+                        __func__, pp->delayed_eh_pmp_map,
+                        ap->qc_active, failed_links,
+                        ap->nr_active_links);
+
+        if (ap->nr_active_links <= failed_links) {
+                mv_process_crpb_entries(ap, pp);
+                mv_stop_edma(ap);
+                mv_eh_freeze(ap);
+                ata_port_printk(ap, KERN_INFO, "%s: done\n", __func__);
+                return 1;       /* handled */
+        }
+        ata_port_printk(ap, KERN_INFO, "%s: waiting\n", __func__);
+        return 1;       /* handled */
+}
+
+static int mv_handle_fbs_non_ncq_dev_err(struct ata_port *ap)
+{
         /*
-         * We got a device interrupt from something that
-         * was supposed to be using EDMA or polling.
+         * Possible future enhancement:
+         *
+         * FBS+non-NCQ operation is not yet implemented.
+         * See related notes in mv_edma_cfg().
+         *
+         * Device error during FBS+non-NCQ operation:
+         *
+         * We need to snapshot the shadow registers for each failed command.
+         * Follow recovery sequence from 6042/7042 datasheet (7.3.15.4.2.3).
          */
+        return 0;       /* not handled */
+}
+
+static int mv_handle_dev_err(struct ata_port *ap, u32 edma_err_cause)
+{
+        struct mv_port_priv *pp = ap->private_data;
+
+        if (!(pp->pp_flags & MV_PP_FLAG_EDMA_EN))
+                return 0;       /* EDMA was not active: not handled */
+        if (!(pp->pp_flags & MV_PP_FLAG_FBS_EN))
+                return 0;       /* FBS was not active: not handled */
+
+        if (!(edma_err_cause & EDMA_ERR_DEV))
+                return 0;       /* non DEV error: not handled */
+        edma_err_cause &= ~EDMA_ERR_IRQ_TRANSIENT;
+        if (edma_err_cause & ~(EDMA_ERR_DEV | EDMA_ERR_SELF_DIS))
+                return 0;       /* other problems: not handled */
+
+        if (pp->pp_flags & MV_PP_FLAG_NCQ_EN) {
+                /*
+                 * EDMA should NOT have self-disabled for this case.
+                 * If it did, then something is wrong elsewhere,
+                 * and we cannot handle it here.
+                 */
+                if (edma_err_cause & EDMA_ERR_SELF_DIS) {
+                        ata_port_printk(ap, KERN_WARNING,
+                                "%s: err_cause=0x%x pp_flags=0x%x\n",
+                                __func__, edma_err_cause, pp->pp_flags);
+                        return 0; /* not handled */
+                }
+                return mv_handle_fbs_ncq_dev_err(ap);
+        } else {
+                /*
+                 * EDMA should have self-disabled for this case.
+                 * If it did not, then something is wrong elsewhere,
+                 * and we cannot handle it here.
+                 */
+                if (!(edma_err_cause & EDMA_ERR_SELF_DIS)) {
+                        ata_port_printk(ap, KERN_WARNING,
+                                "%s: err_cause=0x%x pp_flags=0x%x\n",
+                                __func__, edma_err_cause, pp->pp_flags);
+                        return 0; /* not handled */
+                }
+                return mv_handle_fbs_non_ncq_dev_err(ap);
+        }
+        return 0;       /* not handled */
+}
+
+static void mv_unexpected_intr(struct ata_port *ap, int edma_was_enabled)
+{
+        struct ata_eh_info *ehi = &ap->link.eh_info;
+        char *when = "idle";
+
         ata_ehi_clear_desc(ehi);
-        if (pp->pp_flags & MV_PP_FLAG_EDMA_EN) {
-                when = " while EDMA enabled";
+        if (!ap || (ap->flags & ATA_FLAG_DISABLED)) {
+                when = "disabled";
+        } else if (edma_was_enabled) {
+                when = "EDMA enabled";
         } else {
                 struct ata_queued_cmd *qc = ata_qc_from_tag(ap, ap->link.active_tag);
                 if (qc && (qc->tf.flags & ATA_TFLAG_POLLING))
-                        when = " while polling";
+                        when = "polling";
         }
-        ata_ehi_push_desc(ehi, "unexpected device interrupt%s", when);
+        ata_ehi_push_desc(ehi, "unexpected device interrupt while %s", when);
         ehi->err_mask |= AC_ERR_OTHER;
         ehi->action   |= ATA_EH_RESET;
         ata_port_freeze(ap);
@@ -1519,7 +1808,7 @@ static void mv_unexpected_intr(struct ata_port *ap)
  *      LOCKING:
  *      Inherited from caller.
  */
-static void mv_err_intr(struct ata_port *ap, struct ata_queued_cmd *qc)
+static void mv_err_intr(struct ata_port *ap)
 {
         void __iomem *port_mmio = mv_ap_base(ap);
         u32 edma_err_cause, eh_freeze_mask, serr = 0;
@@ -1527,24 +1816,42 @@ static void mv_err_intr(struct ata_port *ap, struct ata_queued_cmd *qc)
         struct mv_host_priv *hpriv = ap->host->private_data;
         unsigned int action = 0, err_mask = 0;
         struct ata_eh_info *ehi = &ap->link.eh_info;
-
-        ata_ehi_clear_desc(ehi);
+        struct ata_queued_cmd *qc;
+        int abort = 0;
 
         /*
-         * Read and clear the err_cause bits.  This won't actually
-         * clear for some errors (eg. SError), but we will be doing
-         * a hard reset in those cases regardless, which *will* clear it.
+         * Read and clear the SError and err_cause bits.
          */
+        sata_scr_read(&ap->link, SCR_ERROR, &serr);
+        sata_scr_write_flush(&ap->link, SCR_ERROR, serr);
+
         edma_err_cause = readl(port_mmio + EDMA_ERR_IRQ_CAUSE_OFS);
         writelfl(~edma_err_cause, port_mmio + EDMA_ERR_IRQ_CAUSE_OFS);
 
-        ata_ehi_push_desc(ehi, "edma_err_cause=%08x", edma_err_cause);
+        ata_port_printk(ap, KERN_INFO, "%s: err_cause=%08x pp_flags=0x%x\n",
+                        __func__, edma_err_cause, pp->pp_flags);
+
+        if (edma_err_cause & EDMA_ERR_DEV) {
+                /*
+                 * Device errors during FIS-based switching operation
+                 * require special handling.
+                 */
+                if (mv_handle_dev_err(ap, edma_err_cause))
+                        return;
+        }
 
+        qc = mv_get_active_qc(ap);
+        ata_ehi_clear_desc(ehi);
+        ata_ehi_push_desc(ehi, "edma_err_cause=%08x pp_flags=%08x",
+                          edma_err_cause, pp->pp_flags);
         /*
          * All generations share these EDMA error cause bits:
          */
-        if (edma_err_cause & EDMA_ERR_DEV)
+        if (edma_err_cause & EDMA_ERR_DEV) {
                 err_mask |= AC_ERR_DEV;
+                action |= ATA_EH_RESET;
+                ata_ehi_push_desc(ehi, "dev error");
+        }
         if (edma_err_cause & (EDMA_ERR_D_PAR | EDMA_ERR_PRD_PAR |
                         EDMA_ERR_CRQB_PAR | EDMA_ERR_CRPB_PAR |
                         EDMA_ERR_INTRL_PAR)) {
@@ -1576,13 +1883,6 @@ static void mv_err_intr(struct ata_port *ap, struct ata_queued_cmd *qc)
                         ata_ehi_push_desc(ehi, "EDMA self-disable");
                 }
                 if (edma_err_cause & EDMA_ERR_SERR) {
-                        /*
-                         * Ensure that we read our own SCR, not a pmp link SCR:
-                         */
-                        ap->ops->scr_read(ap, SCR_ERROR, &serr);
-                        /*
-                         * Don't clear SError here; leave it for libata-eh:
-                         */
                         ata_ehi_push_desc(ehi, "SError=%08x", serr);
                         err_mask |= AC_ERR_ATA_BUS;
                         action |= ATA_EH_RESET;
@@ -1602,10 +1902,29 @@ static void mv_err_intr(struct ata_port *ap, struct ata_queued_cmd *qc)
         else
                 ehi->err_mask |= err_mask;
 
-        if (edma_err_cause & eh_freeze_mask)
+        if (err_mask == AC_ERR_DEV) {
+                /*
+                 * Cannot do ata_port_freeze() here,
+                 * because it would kill PIO access,
+                 * which is needed for further diagnosis.
+                 */
+                mv_eh_freeze(ap);
+                abort = 1;
+        } else if (edma_err_cause & eh_freeze_mask) {
+                /*
+                 * Note to self: ata_port_freeze() calls ata_port_abort()
+                 */
                 ata_port_freeze(ap);
-        else
-                ata_port_abort(ap);
+        } else {
+                abort = 1;
+        }
+
+        if (abort) {
+                if (qc)
+                        ata_link_abort(qc->dev->link);
+                else
+                        ata_port_abort(ap);
+        }
 }
 
 static void mv_process_crpb_response(struct ata_port *ap,
@@ -1632,8 +1951,9 @@ static void mv_process_crpb_response(struct ata_port *ap,
                         }
                 }
                 ata_status = edma_status >> CRPB_FLAG_STATUS_SHIFT;
-                qc->err_mask |= ac_err_mask(ata_status);
-                ata_qc_complete(qc);
+                if (!ac_err_mask(ata_status))
+                        ata_qc_complete(qc);
+                /* else: leave it for mv_err_intr() */
         } else {
                 ata_port_printk(ap, KERN_ERR, "%s: no qc for tag=%d\n",
                                 __func__, tag);
@@ -1677,6 +1997,44 @@ static void mv_process_crpb_entries(struct ata_port *ap, struct mv_port_priv *pp
                          port_mmio + EDMA_RSP_Q_OUT_PTR_OFS);
 }
 
+static void mv_port_intr(struct ata_port *ap, u32 port_cause)
+{
+        struct mv_port_priv *pp;
+        int edma_was_enabled;
+
+        if (!ap || (ap->flags & ATA_FLAG_DISABLED)) {
+                mv_unexpected_intr(ap, 0);
+                return;
+        }
+        /*
+         * Grab a snapshot of the EDMA_EN flag setting,
+         * so that we have a consistent view for this port,
+         * even if something we call of our routines changes it.
+         */
+        pp = ap->private_data;
+        edma_was_enabled = (pp->pp_flags & MV_PP_FLAG_EDMA_EN);
+        /*
+         * Process completed CRPB response(s) before other events.
+         */
+        if (edma_was_enabled && (port_cause & DONE_IRQ)) {
+                mv_process_crpb_entries(ap, pp);
+                if (pp->pp_flags & MV_PP_FLAG_DELAYED_EH)
+                        mv_handle_fbs_ncq_dev_err(ap);
+        }
+        /*
+         * Handle chip-reported errors, or continue on to handle PIO.
+         */
+        if (unlikely(port_cause & ERR_IRQ)) {
+                mv_err_intr(ap);
+        } else if (!edma_was_enabled) {
+                struct ata_queued_cmd *qc = mv_get_active_qc(ap);
+                if (qc)
+                        ata_sff_host_intr(ap, qc);
+                else
+                        mv_unexpected_intr(ap, edma_was_enabled);
+        }
+}
+
 /**
  *      mv_host_intr - Handle all interrupts on the given host controller
  *      @host: host specific structure
@@ -1688,66 +2046,58 @@ static void mv_process_crpb_entries(struct ata_port *ap, struct mv_port_priv *pp
 static int mv_host_intr(struct ata_host *host, u32 main_irq_cause)
 {
         struct mv_host_priv *hpriv = host->private_data;
-        void __iomem *mmio = hpriv->base, *hc_mmio = NULL;
-        u32 hc_irq_cause = 0;
+        void __iomem *mmio = hpriv->base, *hc_mmio;
         unsigned int handled = 0, port;
 
         for (port = 0; port < hpriv->n_ports; port++) {
                 struct ata_port *ap = host->ports[port];
-                struct mv_port_priv *pp;
-                unsigned int shift, hardport, port_cause;
-                /*
-                 * When we move to the second hc, flag our cached
-                 * copies of hc_mmio (and hc_irq_cause) as invalid again.
-                 */
-                if (port == MV_PORTS_PER_HC)
-                        hc_mmio = NULL;
-                /*
-                 * Do nothing if port is not interrupting or is disabled:
-                 */
+                unsigned int p, shift, hardport, port_cause;
+
                 MV_PORT_TO_SHIFT_AND_HARDPORT(port, shift, hardport);
-                port_cause = (main_irq_cause >> shift) & (DONE_IRQ | ERR_IRQ);
-                if (!port_cause || !ap || (ap->flags & ATA_FLAG_DISABLED))
-                        continue;
                 /*
-                 * Each hc within the host has its own hc_irq_cause register.
-                 * We defer reading it until we know we need it, right now:
-                 *
-                 * FIXME later: we don't really need to read this register
-                 * (some logic changes required below if we go that way),
-                 * because it doesn't tell us anything new.  But we do need
-                 * to write to it, outside the top of this loop,
-                 * to reset the interrupt triggers for next time.
+                 * Each hc within the host has its own hc_irq_cause register,
+                 * where the interrupting ports bits get ack'd.
                  */
-                if (!hc_mmio) {
+                if (hardport == 0) {    /* first port on this hc ? */
+                        u32 hc_cause = (main_irq_cause >> shift) & HC0_IRQ_PEND;
+                        u32 port_mask, ack_irqs;
+                        /*
+                         * Skip this entire hc if nothing pending for any ports
+                         */
+                        if (!hc_cause) {
+                                port += MV_PORTS_PER_HC - 1;
+                                continue;
+                        }
+                        /*
+                         * We don't need/want to read the hc_irq_cause register,
+                         * because doing so hurts performance, and
+                         * main_irq_cause already gives us everything we need.
+                         *
+                         * But we do have to *write* to the hc_irq_cause to ack
+                         * the ports that we are handling this time through.
+                         *
+                         * This requires that we create a bitmap for those
+                         * ports which interrupted us, and use that bitmap
+                         * to ack (only) those ports via hc_irq_cause.
+                         */
+                        ack_irqs = 0;
+                        for (p = 0; p < MV_PORTS_PER_HC; ++p) {
+                                if ((port + p) >= hpriv->n_ports)
+                                        break;
+                                port_mask = (DONE_IRQ | ERR_IRQ) << (p * 2);
+                                if (hc_cause & port_mask)
+                                        ack_irqs |= (DMA_IRQ | DEV_IRQ) << p;
+                        }
                         hc_mmio = mv_hc_base_from_port(mmio, port);
-                        hc_irq_cause = readl(hc_mmio + HC_IRQ_CAUSE_OFS);
-                        writelfl(~hc_irq_cause, hc_mmio + HC_IRQ_CAUSE_OFS);
+                        writelfl(~ack_irqs, hc_mmio + HC_IRQ_CAUSE_OFS);
                         handled = 1;
                 }
                 /*
-                 * Process completed CRPB response(s) before other events.
-                 */
-                pp = ap->private_data;
-                if (hc_irq_cause & (DMA_IRQ << hardport)) {
-                        if (pp->pp_flags & MV_PP_FLAG_EDMA_EN)
-                                mv_process_crpb_entries(ap, pp);
-                }
-                /*
-                 * Handle chip-reported errors, or continue on to handle PIO.
+                 * Handle interrupts signalled for this port:
                  */
-                if (unlikely(port_cause & ERR_IRQ)) {
-                        mv_err_intr(ap, mv_get_active_qc(ap));
-                } else if (hc_irq_cause & (DEV_IRQ << hardport)) {
-                        if (!(pp->pp_flags & MV_PP_FLAG_EDMA_EN)) {
-                                struct ata_queued_cmd *qc = mv_get_active_qc(ap);
-                                if (qc) {
-                                        ata_sff_host_intr(ap, qc);
-                                        continue;
-                                }
-                        }
-                        mv_unexpected_intr(ap);
-                }
+                port_cause = (main_irq_cause >> shift) & (DONE_IRQ | ERR_IRQ);
+                if (port_cause)
+                        mv_port_intr(ap, port_cause);
         }
         return handled;
 }
@@ -1894,7 +2244,7 @@ static void mv5_reset_bus(struct ata_host *host, void __iomem *mmio)
 
 static void mv5_reset_flash(struct mv_host_priv *hpriv, void __iomem *mmio)
 {
-        writel(0x0fcfffff, mmio + MV_FLASH_CTL);
+        writel(0x0fcfffff, mmio + MV_FLASH_CTL_OFS);
 }
 
 static void mv5_read_preamp(struct mv_host_priv *hpriv, int idx,
@@ -1913,7 +2263,7 @@ static void mv5_enable_leds(struct mv_host_priv *hpriv, void __iomem *mmio)
 {
         u32 tmp;
 
-        writel(0, mmio + MV_GPIO_PORT_CTL);
+        writel(0, mmio + MV_GPIO_PORT_CTL_OFS);
 
         /* FIXME: handle MV_HP_ERRATA_50XXB2 errata */
 
@@ -1931,14 +2281,14 @@ static void mv5_phy_errata(struct mv_host_priv *hpriv, void __iomem *mmio,
         int fix_apm_sq = (hpriv->hp_flags & MV_HP_ERRATA_50XXB0);
 
         if (fix_apm_sq) {
-                tmp = readl(phy_mmio + MV5_LT_MODE);
+                tmp = readl(phy_mmio + MV5_LTMODE_OFS);
                 tmp |= (1 << 19);
-                writel(tmp, phy_mmio + MV5_LT_MODE);
+                writel(tmp, phy_mmio + MV5_LTMODE_OFS);
 
-                tmp = readl(phy_mmio + MV5_PHY_CTL);
+                tmp = readl(phy_mmio + MV5_PHY_CTL_OFS);
                 tmp &= ~0x3;
                 tmp |= 0x1;
-                writel(tmp, phy_mmio + MV5_PHY_CTL);
+                writel(tmp, phy_mmio + MV5_PHY_CTL_OFS);
         }
 
         tmp = readl(phy_mmio + MV5_PHY_MODE);
@@ -1956,11 +2306,6 @@ static void mv5_reset_hc_port(struct mv_host_priv *hpriv, void __iomem *mmio,
 {
         void __iomem *port_mmio = mv_port_base(mmio, port);
 
-        /*
-         * The datasheet warns against setting ATA_RST when EDMA is active
-         * (but doesn't say what the problem might be).  So we first try
-         * to disable the EDMA engine before doing the ATA_RST operation.
-         */
         mv_reset_channel(hpriv, mmio, port);
 
         ZERO(0x028);    /* command */
@@ -1975,7 +2320,7 @@ static void mv5_reset_hc_port(struct mv_host_priv *hpriv, void __iomem *mmio,
         ZERO(0x024);    /* respq outp */
         ZERO(0x020);    /* respq inp */
         ZERO(0x02c);    /* test control */
-        writel(0xbc, port_mmio + EDMA_IORDY_TMOUT);
+        writel(0xbc, port_mmio + EDMA_IORDY_TMOUT_OFS);
 }
 #undef ZERO
 
@@ -2021,13 +2366,13 @@ static void mv_reset_pci_bus(struct ata_host *host, void __iomem *mmio)
         struct mv_host_priv *hpriv = host->private_data;
         u32 tmp;
 
-        tmp = readl(mmio + MV_PCI_MODE);
+        tmp = readl(mmio + MV_PCI_MODE_OFS);
         tmp &= 0xff00ffff;
-        writel(tmp, mmio + MV_PCI_MODE);
+        writel(tmp, mmio + MV_PCI_MODE_OFS);
 
         ZERO(MV_PCI_DISC_TIMER);
         ZERO(MV_PCI_MSI_TRIGGER);
-        writel(0x000100ff, mmio + MV_PCI_XBAR_TMOUT);
+        writel(0x000100ff, mmio + MV_PCI_XBAR_TMOUT_OFS);
         ZERO(PCI_HC_MAIN_IRQ_MASK_OFS);
         ZERO(MV_PCI_SERR_MASK);
         ZERO(hpriv->irq_cause_ofs);
@@ -2045,10 +2390,10 @@ static void mv6_reset_flash(struct mv_host_priv *hpriv, void __iomem *mmio)
 
         mv5_reset_flash(hpriv, mmio);
 
-        tmp = readl(mmio + MV_GPIO_PORT_CTL);
+        tmp = readl(mmio + MV_GPIO_PORT_CTL_OFS);
         tmp &= 0x3;
         tmp |= (1 << 5) | (1 << 6);
-        writel(tmp, mmio + MV_GPIO_PORT_CTL);
+        writel(tmp, mmio + MV_GPIO_PORT_CTL_OFS);
 }
 
 /**
@@ -2121,7 +2466,7 @@ static void mv6_read_preamp(struct mv_host_priv *hpriv, int idx,
         void __iomem *port_mmio;
         u32 tmp;
 
-        tmp = readl(mmio + MV_RESET_CFG);
+        tmp = readl(mmio + MV_RESET_CFG_OFS);
         if ((tmp & (1 << 0)) == 0) {
                 hpriv->signal[idx].amps = 0x7 << 8;
                 hpriv->signal[idx].pre = 0x1 << 5;
@@ -2137,7 +2482,7 @@ static void mv6_read_preamp(struct mv_host_priv *hpriv, int idx,
 
 static void mv6_enable_leds(struct mv_host_priv *hpriv, void __iomem *mmio)
 {
-        writel(0x00000060, mmio + MV_GPIO_PORT_CTL);
+        writel(0x00000060, mmio + MV_GPIO_PORT_CTL_OFS);
 }
 
 static void mv6_phy_errata(struct mv_host_priv *hpriv, void __iomem *mmio,
@@ -2235,11 +2580,6 @@ static void mv_soc_reset_hc_port(struct mv_host_priv *hpriv,
 {
         void __iomem *port_mmio = mv_port_base(mmio, port);
 
-        /*
-         * The datasheet warns against setting ATA_RST when EDMA is active
-         * (but doesn't say what the problem might be).  So we first try
-         * to disable the EDMA engine before doing the ATA_RST operation.
-         */
         mv_reset_channel(hpriv, mmio, port);
 
         ZERO(0x028);            /* command */
@@ -2254,7 +2594,7 @@ static void mv_soc_reset_hc_port(struct mv_host_priv *hpriv,
         ZERO(0x024);            /* respq outp */
         ZERO(0x020);            /* respq inp */
         ZERO(0x02c);            /* test control */
-        writel(0xbc, port_mmio + EDMA_IORDY_TMOUT);
+        writel(0xbc, port_mmio + EDMA_IORDY_TMOUT_OFS);
 }
 
 #undef ZERO
@@ -2297,38 +2637,39 @@ static void mv_soc_reset_bus(struct ata_host *host, void __iomem *mmio)
         return;
 }
 
-static void mv_setup_ifctl(void __iomem *port_mmio, int want_gen2i)
+static void mv_setup_ifcfg(void __iomem *port_mmio, int want_gen2i)
 {
-        u32 ifctl = readl(port_mmio + SATA_INTERFACE_CFG);
+        u32 ifcfg = readl(port_mmio + SATA_INTERFACE_CFG_OFS);
 
-        ifctl = (ifctl & 0xf7f) | 0x9b1000;     /* from chip spec */
+        ifcfg = (ifcfg & 0xf7f) | 0x9b1000;     /* from chip spec */
         if (want_gen2i)
-                ifctl |= (1 << 7);              /* enable gen2i speed */
-        writelfl(ifctl, port_mmio + SATA_INTERFACE_CFG);
+                ifcfg |= (1 << 7);              /* enable gen2i speed */
+        writelfl(ifcfg, port_mmio + SATA_INTERFACE_CFG_OFS);
 }
 
-/*
- * Caller must ensure that EDMA is not active,
- * by first doing mv_stop_edma() where needed.
- */
 static void mv_reset_channel(struct mv_host_priv *hpriv, void __iomem *mmio,
                              unsigned int port_no)
 {
         void __iomem *port_mmio = mv_port_base(mmio, port_no);
 
+        /*
+         * The datasheet warns against setting EDMA_RESET when EDMA is active
+         * (but doesn't say what the problem might be).  So we first try
+         * to disable the EDMA engine before doing the EDMA_RESET operation.
+         */
         mv_stop_edma_engine(port_mmio);
-        writelfl(ATA_RST, port_mmio + EDMA_CMD_OFS);
+        writelfl(EDMA_RESET, port_mmio + EDMA_CMD_OFS);
 
         if (!IS_GEN_I(hpriv)) {
-                /* Enable 3.0gb/s link speed */
-                mv_setup_ifctl(port_mmio, 1);
+                /* Enable 3.0gb/s link speed: this survives EDMA_RESET */
+                mv_setup_ifcfg(port_mmio, 1);
         }
         /*
-         * Strobing ATA_RST here causes a hard reset of the SATA transport,
+         * Strobing EDMA_RESET here causes a hard reset of the SATA transport,
          * link, and physical layers.  It resets all SATA interface registers
          * (except for SATA_INTERFACE_CFG), and issues a COMRESET to the dev.
          */
-        writelfl(ATA_RST, port_mmio + EDMA_CMD_OFS);
+        writelfl(EDMA_RESET, port_mmio + EDMA_CMD_OFS);
         udelay(25);     /* allow reset propagation */
         writelfl(0, port_mmio + EDMA_CMD_OFS);
 
@@ -2392,7 +2733,7 @@ static int mv_hardreset(struct ata_link *link, unsigned int *class,
                 sata_scr_read(link, SCR_STATUS, &sstatus);
                 if (!IS_GEN_I(hpriv) && ++attempts >= 5 && sstatus == 0x121) {
                         /* Force 1.5gb/s link speed and try again */
-                        mv_setup_ifctl(mv_ap_base(ap), 0);
+                        mv_setup_ifcfg(mv_ap_base(ap), 0);
                         if (time_after(jiffies + HZ, deadline))
                                 extra = HZ; /* only extend it once, max */
                 }
@@ -2493,6 +2834,34 @@ static void mv_port_init(struct ata_ioports *port,  void __iomem *port_mmio)
                 readl(port_mmio + EDMA_ERR_IRQ_MASK_OFS));
 }
 
+static unsigned int mv_in_pcix_mode(struct ata_host *host)
+{
+        struct mv_host_priv *hpriv = host->private_data;
+        void __iomem *mmio = hpriv->base;
+        u32 reg;
+
+        if (!HAS_PCI(host) || !IS_PCIE(hpriv))
+                return 0;       /* not PCI-X capable */
+        reg = readl(mmio + MV_PCI_MODE_OFS);
+        if ((reg & MV_PCI_MODE_MASK) == 0)
+                return 0;       /* conventional PCI mode */
+        return 1;       /* chip is in PCI-X mode */
+}
+
+static int mv_pci_cut_through_okay(struct ata_host *host)
+{
+        struct mv_host_priv *hpriv = host->private_data;
+        void __iomem *mmio = hpriv->base;
+        u32 reg;
+
+        if (!mv_in_pcix_mode(host)) {
+                reg = readl(mmio + PCI_COMMAND_OFS);
+                if (reg & PCI_COMMAND_MRDTRIG)
+                        return 0; /* not okay */
+        }
+        return 1; /* okay */
+}
+
 static int mv_chip_id(struct ata_host *host, unsigned int board_idx)
 {
         struct pci_dev *pdev = to_pci_dev(host->dev);
@@ -2560,7 +2929,7 @@ static int mv_chip_id(struct ata_host *host, unsigned int board_idx)
                 break;
 
         case chip_7042:
-                hp_flags |= MV_HP_PCIE;
+                hp_flags |= MV_HP_PCIE | MV_HP_CUT_THROUGH;
                 if (pdev->vendor == PCI_VENDOR_ID_TTI &&
                     (pdev->device == 0x2300 || pdev->device == 0x2310))
                 {
@@ -2590,9 +2959,12 @@ static int mv_chip_id(struct ata_host *host, unsigned int board_idx)
                                 " and avoid the final two gigabytes on"
                                 " all RocketRAID BIOS initialized drives.\n");
                 }
+                /* drop through */
         case chip_6042:
                 hpriv->ops = &mv6xxx_ops;
                 hp_flags |= MV_HP_GEN_IIE;
+                if (board_idx == chip_6042 && mv_pci_cut_through_okay(host))
+                        hp_flags |= MV_HP_CUT_THROUGH;
 
                 switch (pdev->revision) {
                 case 0x0:
diff --git a/drivers/base/sys.c b/drivers/base/sys.c
index 4fbb56bcb1ee..358bb0be3c08 100644
--- a/drivers/base/sys.c
+++ b/drivers/base/sys.c
@@ -175,8 +175,7 @@ int sysdev_driver_register(struct sysdev_class *cls, struct sysdev_driver *drv)
         }
 
         /* Check whether this driver has already been added to a class. */
-        if ((drv->entry.next != drv->entry.prev) ||
-            (drv->entry.next != NULL)) {
+        if (drv->entry.next && !list_empty(&drv->entry)) {
                 printk(KERN_WARNING "sysdev: class %s: driver (%p) has already"
                         " been registered to a class, something is wrong, but "
                         "will forge on!\n", cls->name, drv);
diff --git a/drivers/block/aoe/aoecmd.c b/drivers/block/aoe/aoecmd.c
index 8fc429cf82b6..41f818be2f7e 100644
--- a/drivers/block/aoe/aoecmd.c
+++ b/drivers/block/aoe/aoecmd.c
@@ -755,11 +755,13 @@ diskstats(struct gendisk *disk, struct bio *bio, ulong duration, sector_t sector
 {
         unsigned long n_sect = bio->bi_size >> 9;
         const int rw = bio_data_dir(bio);
+        struct hd_struct *part;
 
-        all_stat_inc(disk, ios[rw], sector);
-        all_stat_add(disk, ticks[rw], duration, sector);
-        all_stat_add(disk, sectors[rw], n_sect, sector);
-        all_stat_add(disk, io_ticks, duration, sector);
+        part = get_part(disk, sector);
+        all_stat_inc(disk, part, ios[rw], sector);
+        all_stat_add(disk, part, ticks[rw], duration, sector);
+        all_stat_add(disk, part, sectors[rw], n_sect, sector);
+        all_stat_add(disk, part, io_ticks, duration, sector);
 }
 
 void
diff --git a/drivers/char/serial167.c b/drivers/char/serial167.c
index fd2db07a50fc..3b23270eaa65 100644
--- a/drivers/char/serial167.c
+++ b/drivers/char/serial167.c
@@ -1073,7 +1073,7 @@ static int cy_put_char(struct tty_struct *tty, unsigned char ch)
                 return 0;
 
         if (!info->xmit_buf)
-                return;
+                return 0;
 
         local_irq_save(flags);
         if (info->xmit_cnt >= PAGE_SIZE - 1) {
diff --git a/drivers/char/sx.c b/drivers/char/sx.c
index f39f6fd89350..b1a7a8cb65ea 100644
--- a/drivers/char/sx.c
+++ b/drivers/char/sx.c
@@ -970,7 +970,8 @@ static int sx_set_real_termios(void *ptr)
                 sx_write_channel_byte(port, hi_mask, 0x1f);
                 break;
         default:
-                printk(KERN_INFO "sx: Invalid wordsize: %u\n", CFLAG & CSIZE);
+                printk(KERN_INFO "sx: Invalid wordsize: %u\n",
+                        (unsigned int)CFLAG & CSIZE);
                 break;
         }
 
@@ -997,7 +998,8 @@ static int sx_set_real_termios(void *ptr)
                 set_bit(TTY_HW_COOK_IN, &port->gs.tty->flags);
         }
         sx_dprintk(SX_DEBUG_TERMIOS, "iflags: %x(%d) ",
-                        port->gs.tty->termios->c_iflag, I_OTHER(port->gs.tty));
+                        (unsigned int)port->gs.tty->termios->c_iflag,
+                        I_OTHER(port->gs.tty));
 
 /* Tell line discipline whether we will do output cooking.
  * If OPOST is set and no other output flags are set then we can do output
@@ -1010,7 +1012,8 @@ static int sx_set_real_termios(void *ptr)
                 clear_bit(TTY_HW_COOK_OUT, &port->gs.tty->flags);
         }
         sx_dprintk(SX_DEBUG_TERMIOS, "oflags: %x(%d)\n",
-                        port->gs.tty->termios->c_oflag, O_OTHER(port->gs.tty));
+                        (unsigned int)port->gs.tty->termios->c_oflag,
+                        O_OTHER(port->gs.tty));
         /* port->c_dcd = sx_get_CD (port); */
         func_exit();
         return 0;
diff --git a/drivers/char/vt.c b/drivers/char/vt.c
index e458b08139af..fa1ffbf2c621 100644
--- a/drivers/char/vt.c
+++ b/drivers/char/vt.c
@@ -2742,6 +2742,10 @@ static int con_open(struct tty_struct *tty, struct file *filp)
                                 tty->winsize.ws_row = vc_cons[currcons].d->vc_rows;
                                 tty->winsize.ws_col = vc_cons[currcons].d->vc_cols;
                         }
+                        if (vc->vc_utf)
+                                tty->termios->c_iflag |= IUTF8;
+                        else
+                                tty->termios->c_iflag &= ~IUTF8;
                         release_console_sem();
                         vcs_make_sysfs(tty);
                         return ret;
@@ -2918,6 +2922,8 @@ int __init vty_init(void)
         console_driver->minor_start = 1;
         console_driver->type = TTY_DRIVER_TYPE_CONSOLE;
         console_driver->init_termios = tty_std_termios;
+        if (default_utf8)
+                console_driver->init_termios.c_iflag |= IUTF8;
         console_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_RESET_TERMIOS;
         tty_set_operations(console_driver, &con_ops);
         if (tty_register_driver(console_driver))
diff --git a/drivers/edac/edac_core.h b/drivers/edac/edac_core.h
index a9aa845dbe74..b27b13c5eb5a 100644
--- a/drivers/edac/edac_core.h
+++ b/drivers/edac/edac_core.h
@@ -97,7 +97,7 @@ extern int edac_debug_level;
 #define PCI_VEND_DEV(vend, dev) PCI_VENDOR_ID_ ## vend, \
         PCI_DEVICE_ID_ ## vend ## _ ## dev
 
-#define dev_name(dev) (dev)->dev_name
+#define edac_dev_name(dev) (dev)->dev_name
 
 /* memory devices */
 enum dev_type {
diff --git a/drivers/edac/edac_device.c b/drivers/edac/edac_device.c
index 63372fa7ecfe..5fcd3d89c75d 100644
--- a/drivers/edac/edac_device.c
+++ b/drivers/edac/edac_device.c
@@ -333,7 +333,7 @@ static int add_edac_dev_to_global_list(struct edac_device_ctl_info *edac_dev)
 fail0:
         edac_printk(KERN_WARNING, EDAC_MC,
                         "%s (%s) %s %s already assigned %d\n",
-                        rover->dev->bus_id, dev_name(rover),
+                        rover->dev->bus_id, edac_dev_name(rover),
                         rover->mod_name, rover->ctl_name, rover->dev_idx);
         return 1;
 
@@ -538,7 +538,7 @@ int edac_device_add_device(struct edac_device_ctl_info *edac_dev)
                                 "'%s': DEV '%s' (%s)\n",
                                 edac_dev->mod_name,
                                 edac_dev->ctl_name,
-                                dev_name(edac_dev),
+                                edac_dev_name(edac_dev),
                                 edac_op_state_to_string(edac_dev->op_state));
 
         mutex_unlock(&device_ctls_mutex);
@@ -599,7 +599,7 @@ struct edac_device_ctl_info *edac_device_del_device(struct device *dev)
         edac_printk(KERN_INFO, EDAC_MC,
                 "Removed device %d for %s %s: DEV %s\n",
                 edac_dev->dev_idx,
-                edac_dev->mod_name, edac_dev->ctl_name, dev_name(edac_dev));
+                edac_dev->mod_name, edac_dev->ctl_name, edac_dev_name(edac_dev));
 
         return edac_dev;
 }
diff --git a/drivers/edac/edac_mc.c b/drivers/edac/edac_mc.c
index a4cf1645f588..d110392d48f4 100644
--- a/drivers/edac/edac_mc.c
+++ b/drivers/edac/edac_mc.c
@@ -402,7 +402,7 @@ static int add_mc_to_global_list(struct mem_ctl_info *mci)
 fail0:
         edac_printk(KERN_WARNING, EDAC_MC,
                 "%s (%s) %s %s already assigned %d\n", p->dev->bus_id,
-                dev_name(mci), p->mod_name, p->ctl_name, p->mc_idx);
+                edac_dev_name(mci), p->mod_name, p->ctl_name, p->mc_idx);
         return 1;
 
 fail1:
@@ -517,7 +517,7 @@ int edac_mc_add_mc(struct mem_ctl_info *mci)
 
         /* Report action taken */
         edac_mc_printk(mci, KERN_INFO, "Giving out device to '%s' '%s':"
-                " DEV %s\n", mci->mod_name, mci->ctl_name, dev_name(mci));
+                " DEV %s\n", mci->mod_name, mci->ctl_name, edac_dev_name(mci));
 
         mutex_unlock(&mem_ctls_mutex);
         return 0;
@@ -565,7 +565,7 @@ struct mem_ctl_info *edac_mc_del_mc(struct device *dev)
 
         edac_printk(KERN_INFO, EDAC_MC,
                 "Removed device %d for %s %s: DEV %s\n", mci->mc_idx,
-                mci->mod_name, mci->ctl_name, dev_name(mci));
+                mci->mod_name, mci->ctl_name, edac_dev_name(mci));
 
         return mci;
 }
diff --git a/drivers/edac/edac_pci.c b/drivers/edac/edac_pci.c
index 9b24340b52e1..22ec9d5d4312 100644
--- a/drivers/edac/edac_pci.c
+++ b/drivers/edac/edac_pci.c
@@ -150,7 +150,7 @@ static int add_edac_pci_to_global_list(struct edac_pci_ctl_info *pci)
 fail0:
         edac_printk(KERN_WARNING, EDAC_PCI,
                 "%s (%s) %s %s already assigned %d\n",
-                rover->dev->bus_id, dev_name(rover),
+                rover->dev->bus_id, edac_dev_name(rover),
                 rover->mod_name, rover->ctl_name, rover->pci_idx);
         return 1;
 
@@ -360,7 +360,7 @@ int edac_pci_add_device(struct edac_pci_ctl_info *pci, int edac_idx)
                         " DEV '%s' (%s)\n",
                         pci->mod_name,
                         pci->ctl_name,
-                        dev_name(pci), edac_op_state_to_string(pci->op_state));
+                        edac_dev_name(pci), edac_op_state_to_string(pci->op_state));
 
         mutex_unlock(&edac_pci_ctls_mutex);
         return 0;
@@ -415,7 +415,7 @@ struct edac_pci_ctl_info *edac_pci_del_device(struct device *dev)
 
         edac_printk(KERN_INFO, EDAC_PCI,
                 "Removed device %d for %s %s: DEV %s\n",
-                pci->pci_idx, pci->mod_name, pci->ctl_name, dev_name(pci));
+                pci->pci_idx, pci->mod_name, pci->ctl_name, edac_dev_name(pci));
 
         return pci;
 }
diff --git a/drivers/ide/ide-probe.c b/drivers/ide/ide-probe.c
index 591deda3f86a..34b0d4f26b58 100644
--- a/drivers/ide/ide-probe.c
+++ b/drivers/ide/ide-probe.c
@@ -1355,12 +1355,6 @@ static void ide_init_port(ide_hwif_t *hwif, unsigned int port,
         if (hwif->chipset != ide_dtc2278 || hwif->channel == 0)
                 hwif->port_ops = d->port_ops;
 
-        if ((d->host_flags & IDE_HFLAG_SERIALIZE) ||
-            ((d->host_flags & IDE_HFLAG_SERIALIZE_DMA) && hwif->dma_base)) {
-                if (hwif->mate)
-                        hwif->mate->serialized = hwif->serialized = 1;
-        }
-
         hwif->swdma_mask = d->swdma_mask;
         hwif->mwdma_mask = d->mwdma_mask;
         hwif->ultra_mask = d->udma_mask;
@@ -1382,6 +1376,12 @@ static void ide_init_port(ide_hwif_t *hwif, unsigned int port,
                         hwif->dma_ops = d->dma_ops;
         }
 
+        if ((d->host_flags & IDE_HFLAG_SERIALIZE) ||
+            ((d->host_flags & IDE_HFLAG_SERIALIZE_DMA) && hwif->dma_base)) {
+                if (hwif->mate)
+                        hwif->mate->serialized = hwif->serialized = 1;
+        }
+
         if (d->host_flags & IDE_HFLAG_RQSIZE_256)
                 hwif->rqsize = 256;
 
diff --git a/drivers/ide/legacy/falconide.c b/drivers/ide/legacy/falconide.c
index 83555ca513b5..9e449a0c623f 100644
--- a/drivers/ide/legacy/falconide.c
+++ b/drivers/ide/legacy/falconide.c
@@ -61,7 +61,7 @@ static void falconide_output_data(ide_drive_t *drive, struct request *rq,
         unsigned long data_addr = drive->hwif->io_ports.data_addr;
 
         if (drive->media == ide_disk && rq && rq->cmd_type == REQ_TYPE_FS)
-                return outsw(data_adr, buf, (len + 1) / 2);
+                return outsw(data_addr, buf, (len + 1) / 2);
 
         outsw_swapw(data_addr, buf, (len + 1) / 2);
 }
diff --git a/drivers/infiniband/hw/cxgb3/cxio_hal.c b/drivers/infiniband/hw/cxgb3/cxio_hal.c
index ed2ee4ba4b7c..ebf9d3043f80 100644
--- a/drivers/infiniband/hw/cxgb3/cxio_hal.c
+++ b/drivers/infiniband/hw/cxgb3/cxio_hal.c
@@ -359,9 +359,10 @@ static void insert_recv_cqe(struct t3_wq *wq, struct t3_cq *cq)
         cq->sw_wptr++;
 }
 
-void cxio_flush_rq(struct t3_wq *wq, struct t3_cq *cq, int count)
+int cxio_flush_rq(struct t3_wq *wq, struct t3_cq *cq, int count)
 {
         u32 ptr;
+        int flushed = 0;
 
         PDBG("%s wq %p cq %p\n", __func__, wq, cq);
 
@@ -369,8 +370,11 @@ void cxio_flush_rq(struct t3_wq *wq, struct t3_cq *cq, int count)
         PDBG("%s rq_rptr %u rq_wptr %u skip count %u\n", __func__,
             wq->rq_rptr, wq->rq_wptr, count);
         ptr = wq->rq_rptr + count;
-        while (ptr++ != wq->rq_wptr)
+        while (ptr++ != wq->rq_wptr) {
                 insert_recv_cqe(wq, cq);
+                flushed++;
+        }
+        return flushed;
 }
 
 static void insert_sq_cqe(struct t3_wq *wq, struct t3_cq *cq,
@@ -394,9 +398,10 @@ static void insert_sq_cqe(struct t3_wq *wq, struct t3_cq *cq,
         cq->sw_wptr++;
 }
 
-void cxio_flush_sq(struct t3_wq *wq, struct t3_cq *cq, int count)
+int cxio_flush_sq(struct t3_wq *wq, struct t3_cq *cq, int count)
 {
         __u32 ptr;
+        int flushed = 0;
         struct t3_swsq *sqp = wq->sq + Q_PTR2IDX(wq->sq_rptr, wq->sq_size_log2);
 
         ptr = wq->sq_rptr + count;
@@ -405,7 +410,9 @@ void cxio_flush_sq(struct t3_wq *wq, struct t3_cq *cq, int count)
                 insert_sq_cqe(wq, cq, sqp);
                 sqp++;
                 ptr++;
+                flushed++;
         }
+        return flushed;
 }
 
 /*
@@ -581,7 +588,7 @@ static int cxio_hal_destroy_ctrl_qp(struct cxio_rdev *rdev_p)
  * caller aquires the ctrl_qp lock before the call
  */
 static int cxio_hal_ctrl_qp_write_mem(struct cxio_rdev *rdev_p, u32 addr,
-                                      u32 len, void *data, int completion)
+                                      u32 len, void *data)
 {
         u32 i, nr_wqe, copy_len;
         u8 *copy_data;
@@ -617,7 +624,7 @@ static int cxio_hal_ctrl_qp_write_mem(struct cxio_rdev *rdev_p, u32 addr,
                 flag = 0;
                 if (i == (nr_wqe - 1)) {
                         /* last WQE */
-                        flag = completion ? T3_COMPLETION_FLAG : 0;
+                        flag = T3_COMPLETION_FLAG;
                         if (len % 32)
                                 utx_len = len / 32 + 1;
                         else
@@ -676,21 +683,20 @@ static int cxio_hal_ctrl_qp_write_mem(struct cxio_rdev *rdev_p, u32 addr,
         return 0;
 }
 
-/* IN: stag key, pdid, perm, zbva, to, len, page_size, pbl, and pbl_size
- * OUT: stag index, actual pbl_size, pbl_addr allocated.
+/* IN: stag key, pdid, perm, zbva, to, len, page_size, pbl_size and pbl_addr
+ * OUT: stag index
  * TBD: shared memory region support
  */
 static int __cxio_tpt_op(struct cxio_rdev *rdev_p, u32 reset_tpt_entry,
                          u32 *stag, u8 stag_state, u32 pdid,
                          enum tpt_mem_type type, enum tpt_mem_perm perm,
-                         u32 zbva, u64 to, u32 len, u8 page_size, __be64 *pbl,
-                         u32 *pbl_size, u32 *pbl_addr)
+                         u32 zbva, u64 to, u32 len, u8 page_size,
+                         u32 pbl_size, u32 pbl_addr)
 {
         int err;
         struct tpt_entry tpt;
         u32 stag_idx;
         u32 wptr;
-        int rereg = (*stag != T3_STAG_UNSET);
 
         stag_state = stag_state > 0;
         stag_idx = (*stag) >> 8;
@@ -704,30 +710,8 @@ static int __cxio_tpt_op(struct cxio_rdev *rdev_p, u32 reset_tpt_entry,
         PDBG("%s stag_state 0x%0x type 0x%0x pdid 0x%0x, stag_idx 0x%x\n",
              __func__, stag_state, type, pdid, stag_idx);
 
-        if (reset_tpt_entry)
-                cxio_hal_pblpool_free(rdev_p, *pbl_addr, *pbl_size << 3);
-        else if (!rereg) {
-                *pbl_addr = cxio_hal_pblpool_alloc(rdev_p, *pbl_size << 3);
-                if (!*pbl_addr) {
-                        return -ENOMEM;
-                }
-        }
-
         mutex_lock(&rdev_p->ctrl_qp.lock);
 
-        /* write PBL first if any - update pbl only if pbl list exist */
-        if (pbl) {
-
-                PDBG("%s *pdb_addr 0x%x, pbl_base 0x%x, pbl_size %d\n",
-                     __func__, *pbl_addr, rdev_p->rnic_info.pbl_base,
-                     *pbl_size);
-                err = cxio_hal_ctrl_qp_write_mem(rdev_p,
-                                (*pbl_addr >> 5),
-                                (*pbl_size << 3), pbl, 0);
-                if (err)
-                        goto ret;
-        }
-
         /* write TPT entry */
         if (reset_tpt_entry)
                 memset(&tpt, 0, sizeof(tpt));
@@ -742,23 +726,23 @@ static int __cxio_tpt_op(struct cxio_rdev *rdev_p, u32 reset_tpt_entry,
                                 V_TPT_ADDR_TYPE((zbva ? TPT_ZBTO : TPT_VATO)) |
                                 V_TPT_PAGE_SIZE(page_size));
                 tpt.rsvd_pbl_addr = reset_tpt_entry ? 0 :
-                                    cpu_to_be32(V_TPT_PBL_ADDR(PBL_OFF(rdev_p, *pbl_addr)>>3));
+                                    cpu_to_be32(V_TPT_PBL_ADDR(PBL_OFF(rdev_p, pbl_addr)>>3));
                 tpt.len = cpu_to_be32(len);
                 tpt.va_hi = cpu_to_be32((u32) (to >> 32));
                 tpt.va_low_or_fbo = cpu_to_be32((u32) (to & 0xFFFFFFFFULL));
                 tpt.rsvd_bind_cnt_or_pstag = 0;
                 tpt.rsvd_pbl_size = reset_tpt_entry ? 0 :
-                                  cpu_to_be32(V_TPT_PBL_SIZE((*pbl_size) >> 2));
+                                  cpu_to_be32(V_TPT_PBL_SIZE(pbl_size >> 2));
         }
         err = cxio_hal_ctrl_qp_write_mem(rdev_p,
                                        stag_idx +
                                        (rdev_p->rnic_info.tpt_base >> 5),
-                                       sizeof(tpt), &tpt, 1);
+                                       sizeof(tpt), &tpt);
 
         /* release the stag index to free pool */
         if (reset_tpt_entry)
                 cxio_hal_put_stag(rdev_p->rscp, stag_idx);
-ret:
+
         wptr = rdev_p->ctrl_qp.wptr;
         mutex_unlock(&rdev_p->ctrl_qp.lock);
         if (!err)
@@ -769,44 +753,67 @@ ret:
         return err;
 }
 
+int cxio_write_pbl(struct cxio_rdev *rdev_p, __be64 *pbl,
+                   u32 pbl_addr, u32 pbl_size)
+{
+        u32 wptr;
+        int err;
+
+        PDBG("%s *pdb_addr 0x%x, pbl_base 0x%x, pbl_size %d\n",
+             __func__, pbl_addr, rdev_p->rnic_info.pbl_base,
+             pbl_size);
+
+        mutex_lock(&rdev_p->ctrl_qp.lock);
+        err = cxio_hal_ctrl_qp_write_mem(rdev_p, pbl_addr >> 5, pbl_size << 3,
+                                         pbl);
+        wptr = rdev_p->ctrl_qp.wptr;
+        mutex_unlock(&rdev_p->ctrl_qp.lock);
+        if (err)
+                return err;
+
+        if (wait_event_interruptible(rdev_p->ctrl_qp.waitq,
+                                     SEQ32_GE(rdev_p->ctrl_qp.rptr,
+                                              wptr)))
+                return -ERESTARTSYS;
+
+        return 0;
+}
+
 int cxio_register_phys_mem(struct cxio_rdev *rdev_p, u32 *stag, u32 pdid,
                            enum tpt_mem_perm perm, u32 zbva, u64 to, u32 len,
-                           u8 page_size, __be64 *pbl, u32 *pbl_size,
-                           u32 *pbl_addr)
+                           u8 page_size, u32 pbl_size, u32 pbl_addr)
 {
         *stag = T3_STAG_UNSET;
         return __cxio_tpt_op(rdev_p, 0, stag, 1, pdid, TPT_NON_SHARED_MR, perm,
-                             zbva, to, len, page_size, pbl, pbl_size, pbl_addr);
+                             zbva, to, len, page_size, pbl_size, pbl_addr);
 }
 
 int cxio_reregister_phys_mem(struct cxio_rdev *rdev_p, u32 *stag, u32 pdid,
                            enum tpt_mem_perm perm, u32 zbva, u64 to, u32 len,
-                           u8 page_size, __be64 *pbl, u32 *pbl_size,
-                           u32 *pbl_addr)
+                           u8 page_size, u32 pbl_size, u32 pbl_addr)
 {
         return __cxio_tpt_op(rdev_p, 0, stag, 1, pdid, TPT_NON_SHARED_MR, perm,
-                             zbva, to, len, page_size, pbl, pbl_size, pbl_addr);
+                             zbva, to, len, page_size, pbl_size, pbl_addr);
 }
 
 int cxio_dereg_mem(struct cxio_rdev *rdev_p, u32 stag, u32 pbl_size,
                    u32 pbl_addr)
 {
-        return __cxio_tpt_op(rdev_p, 1, &stag, 0, 0, 0, 0, 0, 0ULL, 0, 0, NULL,
-                             &pbl_size, &pbl_addr);
+        return __cxio_tpt_op(rdev_p, 1, &stag, 0, 0, 0, 0, 0, 0ULL, 0, 0,
+                             pbl_size, pbl_addr);
 }
 
 int cxio_allocate_window(struct cxio_rdev *rdev_p, u32 * stag, u32 pdid)
 {
-        u32 pbl_size = 0;
         *stag = T3_STAG_UNSET;
         return __cxio_tpt_op(rdev_p, 0, stag, 0, pdid, TPT_MW, 0, 0, 0ULL, 0, 0,
-                             NULL, &pbl_size, NULL);
+                             0, 0);
 }
 
 int cxio_deallocate_window(struct cxio_rdev *rdev_p, u32 stag)
 {
-        return __cxio_tpt_op(rdev_p, 1, &stag, 0, 0, 0, 0, 0, 0ULL, 0, 0, NULL,
-                             NULL, NULL);
+        return __cxio_tpt_op(rdev_p, 1, &stag, 0, 0, 0, 0, 0, 0ULL, 0, 0,
+                             0, 0);
 }
 
 int cxio_rdma_init(struct cxio_rdev *rdev_p, struct t3_rdma_init_attr *attr)
diff --git a/drivers/infiniband/hw/cxgb3/cxio_hal.h b/drivers/infiniband/hw/cxgb3/cxio_hal.h
index 2bcff7f5046e..6e128f6bab05 100644
--- a/drivers/infiniband/hw/cxgb3/cxio_hal.h
+++ b/drivers/infiniband/hw/cxgb3/cxio_hal.h
@@ -154,14 +154,14 @@ int cxio_create_qp(struct cxio_rdev *rdev, u32 kernel_domain, struct t3_wq *wq,
 int cxio_destroy_qp(struct cxio_rdev *rdev, struct t3_wq *wq,
                     struct cxio_ucontext *uctx);
 int cxio_peek_cq(struct t3_wq *wr, struct t3_cq *cq, int opcode);
+int cxio_write_pbl(struct cxio_rdev *rdev_p, __be64 *pbl,
+                   u32 pbl_addr, u32 pbl_size);
 int cxio_register_phys_mem(struct cxio_rdev *rdev, u32 * stag, u32 pdid,
                            enum tpt_mem_perm perm, u32 zbva, u64 to, u32 len,
-                           u8 page_size, __be64 *pbl, u32 *pbl_size,
-                           u32 *pbl_addr);
+                           u8 page_size, u32 pbl_size, u32 pbl_addr);
 int cxio_reregister_phys_mem(struct cxio_rdev *rdev, u32 * stag, u32 pdid,
                            enum tpt_mem_perm perm, u32 zbva, u64 to, u32 len,
-                           u8 page_size, __be64 *pbl, u32 *pbl_size,
-                           u32 *pbl_addr);
+                           u8 page_size, u32 pbl_size, u32 pbl_addr);
 int cxio_dereg_mem(struct cxio_rdev *rdev, u32 stag, u32 pbl_size,
                    u32 pbl_addr);
 int cxio_allocate_window(struct cxio_rdev *rdev, u32 * stag, u32 pdid);
@@ -173,8 +173,8 @@ u32 cxio_hal_get_pdid(struct cxio_hal_resource *rscp);
 void cxio_hal_put_pdid(struct cxio_hal_resource *rscp, u32 pdid);
 int __init cxio_hal_init(void);
 void __exit cxio_hal_exit(void);
-void cxio_flush_rq(struct t3_wq *wq, struct t3_cq *cq, int count);
-void cxio_flush_sq(struct t3_wq *wq, struct t3_cq *cq, int count);
+int cxio_flush_rq(struct t3_wq *wq, struct t3_cq *cq, int count);
+int cxio_flush_sq(struct t3_wq *wq, struct t3_cq *cq, int count);
 void cxio_count_rcqes(struct t3_cq *cq, struct t3_wq *wq, int *count);
 void cxio_count_scqes(struct t3_cq *cq, struct t3_wq *wq, int *count);
 void cxio_flush_hw_cq(struct t3_cq *cq);
diff --git a/drivers/infiniband/hw/cxgb3/cxio_resource.c b/drivers/infiniband/hw/cxgb3/cxio_resource.c
index 45ed4f25ef78..bd233c087653 100644
--- a/drivers/infiniband/hw/cxgb3/cxio_resource.c
+++ b/drivers/infiniband/hw/cxgb3/cxio_resource.c
@@ -250,7 +250,6 @@ void cxio_hal_destroy_resource(struct cxio_hal_resource *rscp)
  */
 
 #define MIN_PBL_SHIFT 8                 /* 256B == min PBL size (32 entries) */
-#define PBL_CHUNK 2*1024*1024
 
 u32 cxio_hal_pblpool_alloc(struct cxio_rdev *rdev_p, int size)
 {
@@ -267,14 +266,35 @@ void cxio_hal_pblpool_free(struct cxio_rdev *rdev_p, u32 addr, int size)
 
 int cxio_hal_pblpool_create(struct cxio_rdev *rdev_p)
 {
-        unsigned long i;
+        unsigned pbl_start, pbl_chunk;
+
         rdev_p->pbl_pool = gen_pool_create(MIN_PBL_SHIFT, -1);
-        if (rdev_p->pbl_pool)
-                for (i = rdev_p->rnic_info.pbl_base;
-                     i <= rdev_p->rnic_info.pbl_top - PBL_CHUNK + 1;
-                     i += PBL_CHUNK)
-                        gen_pool_add(rdev_p->pbl_pool, i, PBL_CHUNK, -1);
-        return rdev_p->pbl_pool ? 0 : -ENOMEM;
+        if (!rdev_p->pbl_pool)
+                return -ENOMEM;
+
+        pbl_start = rdev_p->rnic_info.pbl_base;
+        pbl_chunk = rdev_p->rnic_info.pbl_top - pbl_start + 1;
+
+        while (pbl_start < rdev_p->rnic_info.pbl_top) {
+                pbl_chunk = min(rdev_p->rnic_info.pbl_top - pbl_start + 1,
+                                pbl_chunk);
+                if (gen_pool_add(rdev_p->pbl_pool, pbl_start, pbl_chunk, -1)) {
+                        PDBG("%s failed to add PBL chunk (%x/%x)\n",
+                             __func__, pbl_start, pbl_chunk);
+                        if (pbl_chunk <= 1024 << MIN_PBL_SHIFT) {
+                                printk(KERN_WARNING MOD "%s: Failed to add all PBL chunks (%x/%x)\n",
+                                       __func__, pbl_start, rdev_p->rnic_info.pbl_top - pbl_start);
+                                return 0;
+                        }
+                        pbl_chunk >>= 1;
+                } else {
+                        PDBG("%s added PBL chunk (%x/%x)\n",
+                             __func__, pbl_start, pbl_chunk);
+                        pbl_start += pbl_chunk;
+                }
+        }
+
+        return 0;
 }
 
 void cxio_hal_pblpool_destroy(struct cxio_rdev *rdev_p)
diff --git a/drivers/infiniband/hw/cxgb3/iwch_cm.c b/drivers/infiniband/hw/cxgb3/iwch_cm.c
index d44a6df9ad8c..c325c44807e8 100644
--- a/drivers/infiniband/hw/cxgb3/iwch_cm.c
+++ b/drivers/infiniband/hw/cxgb3/iwch_cm.c
@@ -67,10 +67,10 @@ int peer2peer = 0;
 module_param(peer2peer, int, 0644);
 MODULE_PARM_DESC(peer2peer, "Support peer2peer ULPs (default=0)");
 
-static int ep_timeout_secs = 10;
+static int ep_timeout_secs = 60;
 module_param(ep_timeout_secs, int, 0644);
 MODULE_PARM_DESC(ep_timeout_secs, "CM Endpoint operation timeout "
-                                   "in seconds (default=10)");
+                                   "in seconds (default=60)");
 
 static int mpa_rev = 1;
 module_param(mpa_rev, int, 0644);
@@ -1650,8 +1650,8 @@ static int close_con_rpl(struct t3cdev *tdev, struct sk_buff *skb, void *ctx)
                 release = 1;
                 break;
         case ABORTING:
-                break;
         case DEAD:
+                break;
         default:
                 BUG_ON(1);
                 break;
diff --git a/drivers/infiniband/hw/cxgb3/iwch_mem.c b/drivers/infiniband/hw/cxgb3/iwch_mem.c
index 58c3d61bcd14..ec49a5cbdebb 100644
--- a/drivers/infiniband/hw/cxgb3/iwch_mem.c
+++ b/drivers/infiniband/hw/cxgb3/iwch_mem.c
@@ -35,17 +35,26 @@
 #include <rdma/ib_verbs.h>
 
 #include "cxio_hal.h"
+#include "cxio_resource.h"
 #include "iwch.h"
 #include "iwch_provider.h"
 
-int iwch_register_mem(struct iwch_dev *rhp, struct iwch_pd *php,
-                                        struct iwch_mr *mhp,
-                                        int shift,
-                                        __be64 *page_list)
+static void iwch_finish_mem_reg(struct iwch_mr *mhp, u32 stag)
 {
-        u32 stag;
         u32 mmid;
 
+        mhp->attr.state = 1;
+        mhp->attr.stag = stag;
+        mmid = stag >> 8;
+        mhp->ibmr.rkey = mhp->ibmr.lkey = stag;
+        insert_handle(mhp->rhp, &mhp->rhp->mmidr, mhp, mmid);
+        PDBG("%s mmid 0x%x mhp %p\n", __func__, mmid, mhp);
+}
+
+int iwch_register_mem(struct iwch_dev *rhp, struct iwch_pd *php,
+                      struct iwch_mr *mhp, int shift)
+{
+        u32 stag;
 
         if (cxio_register_phys_mem(&rhp->rdev,
                                    &stag, mhp->attr.pdid,
@@ -53,28 +62,21 @@ int iwch_register_mem(struct iwch_dev *rhp, struct iwch_pd *php,
                                    mhp->attr.zbva,
                                    mhp->attr.va_fbo,
                                    mhp->attr.len,
-                                   shift-12,
-                                   page_list,
-                                   &mhp->attr.pbl_size, &mhp->attr.pbl_addr))
+                                   shift - 12,
+                                   mhp->attr.pbl_size, mhp->attr.pbl_addr))
                 return -ENOMEM;
-        mhp->attr.state = 1;
-        mhp->attr.stag = stag;
-        mmid = stag >> 8;
-        mhp->ibmr.rkey = mhp->ibmr.lkey = stag;
-        insert_handle(rhp, &rhp->mmidr, mhp, mmid);
-        PDBG("%s mmid 0x%x mhp %p\n", __func__, mmid, mhp);
+
+        iwch_finish_mem_reg(mhp, stag);
+
         return 0;
 }
 
 int iwch_reregister_mem(struct iwch_dev *rhp, struct iwch_pd *php,
                                         struct iwch_mr *mhp,
                                         int shift,
-                                        __be64 *page_list,
                                         int npages)
 {
         u32 stag;
-        u32 mmid;
-
 
         /* We could support this... */
         if (npages > mhp->attr.pbl_size)
@@ -87,19 +89,40 @@ int iwch_reregister_mem(struct iwch_dev *rhp, struct iwch_pd *php,
                                    mhp->attr.zbva,
                                    mhp->attr.va_fbo,
                                    mhp->attr.len,
-                                   shift-12,
-                                   page_list,
-                                   &mhp->attr.pbl_size, &mhp->attr.pbl_addr))
+                                   shift - 12,
+                                   mhp->attr.pbl_size, mhp->attr.pbl_addr))
                 return -ENOMEM;
-        mhp->attr.state = 1;
-        mhp->attr.stag = stag;
-        mmid = stag >> 8;
-        mhp->ibmr.rkey = mhp->ibmr.lkey = stag;
-        insert_handle(rhp, &rhp->mmidr, mhp, mmid);
-        PDBG("%s mmid 0x%x mhp %p\n", __func__, mmid, mhp);
+
+        iwch_finish_mem_reg(mhp, stag);
+
+        return 0;
+}
+
+int iwch_alloc_pbl(struct iwch_mr *mhp, int npages)
+{
+        mhp->attr.pbl_addr = cxio_hal_pblpool_alloc(&mhp->rhp->rdev,
+                                                    npages << 3);
+
+        if (!mhp->attr.pbl_addr)
+                return -ENOMEM;
+
+        mhp->attr.pbl_size = npages;
+
         return 0;
 }
 
+void iwch_free_pbl(struct iwch_mr *mhp)
+{
+        cxio_hal_pblpool_free(&mhp->rhp->rdev, mhp->attr.pbl_addr,
+                              mhp->attr.pbl_size << 3);
+}
+
+int iwch_write_pbl(struct iwch_mr *mhp, __be64 *pages, int npages, int offset)
+{
+        return cxio_write_pbl(&mhp->rhp->rdev, pages,
+                              mhp->attr.pbl_addr + (offset << 3), npages);
+}
+
 int build_phys_page_list(struct ib_phys_buf *buffer_list,
                                         int num_phys_buf,
                                         u64 *iova_start,
diff --git a/drivers/infiniband/hw/cxgb3/iwch_provider.c b/drivers/infiniband/hw/cxgb3/iwch_provider.c
index d07d3a377b5f..8934178a23ee 100644
--- a/drivers/infiniband/hw/cxgb3/iwch_provider.c
+++ b/drivers/infiniband/hw/cxgb3/iwch_provider.c
@@ -442,6 +442,7 @@ static int iwch_dereg_mr(struct ib_mr *ib_mr)
         mmid = mhp->attr.stag >> 8;
         cxio_dereg_mem(&rhp->rdev, mhp->attr.stag, mhp->attr.pbl_size,
                        mhp->attr.pbl_addr);
+        iwch_free_pbl(mhp);
         remove_handle(rhp, &rhp->mmidr, mmid);
         if (mhp->kva)
                 kfree((void *) (unsigned long) mhp->kva);
@@ -475,6 +476,8 @@ static struct ib_mr *iwch_register_phys_mem(struct ib_pd *pd,
         if (!mhp)
                 return ERR_PTR(-ENOMEM);
 
+        mhp->rhp = rhp;
+
         /* First check that we have enough alignment */
         if ((*iova_start & ~PAGE_MASK) != (buffer_list[0].addr & ~PAGE_MASK)) {
                 ret = -EINVAL;
@@ -492,7 +495,17 @@ static struct ib_mr *iwch_register_phys_mem(struct ib_pd *pd,
         if (ret)
                 goto err;
 
-        mhp->rhp = rhp;
+        ret = iwch_alloc_pbl(mhp, npages);
+        if (ret) {
+                kfree(page_list);
+                goto err_pbl;
+        }
+
+        ret = iwch_write_pbl(mhp, page_list, npages, 0);
+        kfree(page_list);
+        if (ret)
+                goto err_pbl;
+
         mhp->attr.pdid = php->pdid;
         mhp->attr.zbva = 0;
 
@@ -502,12 +515,15 @@ static struct ib_mr *iwch_register_phys_mem(struct ib_pd *pd,
 
         mhp->attr.len = (u32) total_size;
         mhp->attr.pbl_size = npages;
-        ret = iwch_register_mem(rhp, php, mhp, shift, page_list);
-        kfree(page_list);
-        if (ret) {
-                goto err;
-        }
+        ret = iwch_register_mem(rhp, php, mhp, shift);
+        if (ret)
+                goto err_pbl;
+
         return &mhp->ibmr;
+
+err_pbl:
+        iwch_free_pbl(mhp);
+
 err:
         kfree(mhp);
         return ERR_PTR(ret);
@@ -560,7 +576,7 @@ static int iwch_reregister_phys_mem(struct ib_mr *mr,
                         return ret;
         }
 
-        ret = iwch_reregister_mem(rhp, php, &mh, shift, page_list, npages);
+        ret = iwch_reregister_mem(rhp, php, &mh, shift, npages);
         kfree(page_list);
         if (ret) {
                 return ret;
@@ -602,6 +618,8 @@ static struct ib_mr *iwch_reg_user_mr(struct ib_pd *pd, u64 start, u64 length,
         if (!mhp)
                 return ERR_PTR(-ENOMEM);
 
+        mhp->rhp = rhp;
+
         mhp->umem = ib_umem_get(pd->uobject->context, start, length, acc, 0);
         if (IS_ERR(mhp->umem)) {
                 err = PTR_ERR(mhp->umem);
@@ -615,10 +633,14 @@ static struct ib_mr *iwch_reg_user_mr(struct ib_pd *pd, u64 start, u64 length,
         list_for_each_entry(chunk, &mhp->umem->chunk_list, list)
                 n += chunk->nents;
 
-        pages = kmalloc(n * sizeof(u64), GFP_KERNEL);
+        err = iwch_alloc_pbl(mhp, n);
+        if (err)
+                goto err;
+
+        pages = (__be64 *) __get_free_page(GFP_KERNEL);
         if (!pages) {
                 err = -ENOMEM;
-                goto err;
+                goto err_pbl;
         }
 
         i = n = 0;
@@ -630,25 +652,38 @@ static struct ib_mr *iwch_reg_user_mr(struct ib_pd *pd, u64 start, u64 length,
                                 pages[i++] = cpu_to_be64(sg_dma_address(
                                         &chunk->page_list[j]) +
                                         mhp->umem->page_size * k);
+                                if (i == PAGE_SIZE / sizeof *pages) {
+                                        err = iwch_write_pbl(mhp, pages, i, n);
+                                        if (err)
+                                                goto pbl_done;
+                                        n += i;
+                                        i = 0;
+                                }
                         }
                 }
 
-        mhp->rhp = rhp;
+        if (i)
+                err = iwch_write_pbl(mhp, pages, i, n);
+
+pbl_done:
+        free_page((unsigned long) pages);
+        if (err)
+                goto err_pbl;
+
         mhp->attr.pdid = php->pdid;
         mhp->attr.zbva = 0;
         mhp->attr.perms = iwch_ib_to_tpt_access(acc);
         mhp->attr.va_fbo = virt;
         mhp->attr.page_size = shift - 12;
         mhp->attr.len = (u32) length;
-        mhp->attr.pbl_size = i;
-        err = iwch_register_mem(rhp, php, mhp, shift, pages);
-        kfree(pages);
+
+        err = iwch_register_mem(rhp, php, mhp, shift);
         if (err)
-                goto err;
+                goto err_pbl;
 
         if (udata && !t3a_device(rhp)) {
                 uresp.pbl_addr = (mhp->attr.pbl_addr -
-                                 rhp->rdev.rnic_info.pbl_base) >> 3;
+                                 rhp->rdev.rnic_info.pbl_base) >> 3;
                 PDBG("%s user resp pbl_addr 0x%x\n", __func__,
                      uresp.pbl_addr);
 
@@ -661,6 +696,9 @@ static struct ib_mr *iwch_reg_user_mr(struct ib_pd *pd, u64 start, u64 length,
 
         return &mhp->ibmr;
 
+err_pbl:
+        iwch_free_pbl(mhp);
+
 err:
         ib_umem_release(mhp->umem);
         kfree(mhp);
diff --git a/drivers/infiniband/hw/cxgb3/iwch_provider.h b/drivers/infiniband/hw/cxgb3/iwch_provider.h
index db5100d27ca2..836163fc5429 100644
--- a/drivers/infiniband/hw/cxgb3/iwch_provider.h
+++ b/drivers/infiniband/hw/cxgb3/iwch_provider.h
@@ -340,14 +340,14 @@ int iwch_quiesce_qps(struct iwch_cq *chp);
 int iwch_resume_qps(struct iwch_cq *chp);
 void stop_read_rep_timer(struct iwch_qp *qhp);
 int iwch_register_mem(struct iwch_dev *rhp, struct iwch_pd *php,
-                                        struct iwch_mr *mhp,
-                                        int shift,
-                                        __be64 *page_list);
+                      struct iwch_mr *mhp, int shift);
 int iwch_reregister_mem(struct iwch_dev *rhp, struct iwch_pd *php,
                                         struct iwch_mr *mhp,
                                         int shift,
-                                        __be64 *page_list,
                                         int npages);
+int iwch_alloc_pbl(struct iwch_mr *mhp, int npages);
+void iwch_free_pbl(struct iwch_mr *mhp);
+int iwch_write_pbl(struct iwch_mr *mhp, __be64 *pages, int npages, int offset);
 int build_phys_page_list(struct ib_phys_buf *buffer_list,
                                         int num_phys_buf,
                                         u64 *iova_start,
diff --git a/drivers/infiniband/hw/cxgb3/iwch_qp.c b/drivers/infiniband/hw/cxgb3/iwch_qp.c
index 9b4be889c58e..79dbe5beae52 100644
--- a/drivers/infiniband/hw/cxgb3/iwch_qp.c
+++ b/drivers/infiniband/hw/cxgb3/iwch_qp.c
@@ -655,6 +655,7 @@ static void __flush_qp(struct iwch_qp *qhp, unsigned long *flag)
 {
         struct iwch_cq *rchp, *schp;
         int count;
+        int flushed;
 
         rchp = get_chp(qhp->rhp, qhp->attr.rcq);
         schp = get_chp(qhp->rhp, qhp->attr.scq);
@@ -669,20 +670,22 @@ static void __flush_qp(struct iwch_qp *qhp, unsigned long *flag)
         spin_lock(&qhp->lock);
         cxio_flush_hw_cq(&rchp->cq);
         cxio_count_rcqes(&rchp->cq, &qhp->wq, &count);
-        cxio_flush_rq(&qhp->wq, &rchp->cq, count);
+        flushed = cxio_flush_rq(&qhp->wq, &rchp->cq, count);
         spin_unlock(&qhp->lock);
         spin_unlock_irqrestore(&rchp->lock, *flag);
-        (*rchp->ibcq.comp_handler)(&rchp->ibcq, rchp->ibcq.cq_context);
+        if (flushed)
+                (*rchp->ibcq.comp_handler)(&rchp->ibcq, rchp->ibcq.cq_context);
 
         /* locking heirarchy: cq lock first, then qp lock. */
         spin_lock_irqsave(&schp->lock, *flag);
         spin_lock(&qhp->lock);
         cxio_flush_hw_cq(&schp->cq);
         cxio_count_scqes(&schp->cq, &qhp->wq, &count);
-        cxio_flush_sq(&qhp->wq, &schp->cq, count);
+        flushed = cxio_flush_sq(&qhp->wq, &schp->cq, count);
         spin_unlock(&qhp->lock);
         spin_unlock_irqrestore(&schp->lock, *flag);
-        (*schp->ibcq.comp_handler)(&schp->ibcq, schp->ibcq.cq_context);
+        if (flushed)
+                (*schp->ibcq.comp_handler)(&schp->ibcq, schp->ibcq.cq_context);
 
         /* deref */
         if (atomic_dec_and_test(&qhp->refcnt))
@@ -880,7 +883,6 @@ int iwch_modify_qp(struct iwch_dev *rhp, struct iwch_qp *qhp,
                                 ep = qhp->ep;
                                 get_ep(&ep->com);
                         }
-                        flush_qp(qhp, &flag);
                         break;
                 case IWCH_QP_STATE_TERMINATE:
                         qhp->attr.state = IWCH_QP_STATE_TERMINATE;
@@ -911,6 +913,7 @@ int iwch_modify_qp(struct iwch_dev *rhp, struct iwch_qp *qhp,
                 }
                 switch (attrs->next_state) {
                         case IWCH_QP_STATE_IDLE:
+                                flush_qp(qhp, &flag);
                                 qhp->attr.state = IWCH_QP_STATE_IDLE;
                                 qhp->attr.llp_stream_handle = NULL;
                                 put_ep(&qhp->ep->com);
diff --git a/drivers/infiniband/hw/ehca/ehca_classes.h b/drivers/infiniband/hw/ehca/ehca_classes.h
index 00bab60f6de4..1e9e99a13933 100644
--- a/drivers/infiniband/hw/ehca/ehca_classes.h
+++ b/drivers/infiniband/hw/ehca/ehca_classes.h
@@ -192,6 +192,8 @@ struct ehca_qp {
         int mtu_shift;
         u32 message_count;
         u32 packet_count;
+        atomic_t nr_events; /* events seen */
+        wait_queue_head_t wait_completion;
 };
 
 #define IS_SRQ(qp) (qp->ext_type == EQPT_SRQ)
diff --git a/drivers/infiniband/hw/ehca/ehca_hca.c b/drivers/infiniband/hw/ehca/ehca_hca.c
index 2515cbde7e65..bc3b37d2070f 100644
--- a/drivers/infiniband/hw/ehca/ehca_hca.c
+++ b/drivers/infiniband/hw/ehca/ehca_hca.c
@@ -101,7 +101,6 @@ int ehca_query_device(struct ib_device *ibdev, struct ib_device_attr *props)
         props->max_ee          = limit_uint(rblock->max_rd_ee_context);
         props->max_rdd         = limit_uint(rblock->max_rd_domain);
         props->max_fmr         = limit_uint(rblock->max_mr);
-        props->local_ca_ack_delay  = limit_uint(rblock->local_ca_ack_delay);
         props->max_qp_rd_atom  = limit_uint(rblock->max_rr_qp);
         props->max_ee_rd_atom  = limit_uint(rblock->max_rr_ee_context);
         props->max_res_rd_atom = limit_uint(rblock->max_rr_hca);
@@ -115,7 +114,7 @@ int ehca_query_device(struct ib_device *ibdev, struct ib_device_attr *props)
         }
 
         props->max_pkeys           = 16;
-        props->local_ca_ack_delay  = limit_uint(rblock->local_ca_ack_delay);
+        props->local_ca_ack_delay  = min_t(u8, rblock->local_ca_ack_delay, 255);
         props->max_raw_ipv6_qp     = limit_uint(rblock->max_raw_ipv6_qp);
         props->max_raw_ethy_qp     = limit_uint(rblock->max_raw_ethy_qp);
         props->max_mcast_grp       = limit_uint(rblock->max_mcast_grp);
@@ -136,7 +135,7 @@ query_device1:
         return ret;
 }
 
-static int map_mtu(struct ehca_shca *shca, u32 fw_mtu)
+static enum ib_mtu map_mtu(struct ehca_shca *shca, u32 fw_mtu)
 {
         switch (fw_mtu) {
         case 0x1:
@@ -156,7 +155,7 @@ static int map_mtu(struct ehca_shca *shca, u32 fw_mtu)
         }
 }
 
-static int map_number_of_vls(struct ehca_shca *shca, u32 vl_cap)
+static u8 map_number_of_vls(struct ehca_shca *shca, u32 vl_cap)
 {
         switch (vl_cap) {
         case 0x1:
diff --git a/drivers/infiniband/hw/ehca/ehca_irq.c b/drivers/infiniband/hw/ehca/ehca_irq.c
index ca5eb0cb628c..ce1ab0571be3 100644
--- a/drivers/infiniband/hw/ehca/ehca_irq.c
+++ b/drivers/infiniband/hw/ehca/ehca_irq.c
@@ -204,6 +204,8 @@ static void qp_event_callback(struct ehca_shca *shca, u64 eqe,
 
         read_lock(&ehca_qp_idr_lock);
         qp = idr_find(&ehca_qp_idr, token);
+        if (qp)
+                atomic_inc(&qp->nr_events);
         read_unlock(&ehca_qp_idr_lock);
 
         if (!qp)
@@ -223,6 +225,8 @@ static void qp_event_callback(struct ehca_shca *shca, u64 eqe,
         if (fatal && qp->ext_type == EQPT_SRQBASE)
                 dispatch_qp_event(shca, qp, IB_EVENT_QP_LAST_WQE_REACHED);
 
+        if (atomic_dec_and_test(&qp->nr_events))
+                wake_up(&qp->wait_completion);
         return;
 }
 
diff --git a/drivers/infiniband/hw/ehca/ehca_qp.c b/drivers/infiniband/hw/ehca/ehca_qp.c
index 18fba92fa7ae..3f59587338ea 100644
--- a/drivers/infiniband/hw/ehca/ehca_qp.c
+++ b/drivers/infiniband/hw/ehca/ehca_qp.c
@@ -566,6 +566,8 @@ static struct ehca_qp *internal_create_qp(
                 return ERR_PTR(-ENOMEM);
         }
 
+        atomic_set(&my_qp->nr_events, 0);
+        init_waitqueue_head(&my_qp->wait_completion);
         spin_lock_init(&my_qp->spinlock_s);
         spin_lock_init(&my_qp->spinlock_r);
         my_qp->qp_type = qp_type;
@@ -1934,6 +1936,9 @@ static int internal_destroy_qp(struct ib_device *dev, struct ehca_qp *my_qp,
         idr_remove(&ehca_qp_idr, my_qp->token);
         write_unlock_irqrestore(&ehca_qp_idr_lock, flags);
 
+        /* now wait until all pending events have completed */
+        wait_event(my_qp->wait_completion, !atomic_read(&my_qp->nr_events));
+
         h_ret = hipz_h_destroy_qp(shca->ipz_hca_handle, my_qp);
         if (h_ret != H_SUCCESS) {
                 ehca_err(dev, "hipz_h_destroy_qp() failed h_ret=%li "
diff --git a/drivers/infiniband/hw/ipath/ipath_driver.c b/drivers/infiniband/hw/ipath/ipath_driver.c
index acf30c06a0c0..ce7b7c34360e 100644
--- a/drivers/infiniband/hw/ipath/ipath_driver.c
+++ b/drivers/infiniband/hw/ipath/ipath_driver.c
@@ -1197,7 +1197,7 @@ void ipath_kreceive(struct ipath_portdata *pd)
         }
 
 reloop:
-        for (last = 0, i = 1; !last; i++) {
+        for (last = 0, i = 1; !last; i += !last) {
                 hdr = dd->ipath_f_get_msgheader(dd, rhf_addr);
                 eflags = ipath_hdrget_err_flags(rhf_addr);
                 etype = ipath_hdrget_rcv_type(rhf_addr);
@@ -1428,6 +1428,40 @@ static void ipath_update_pio_bufs(struct ipath_devdata *dd)
         spin_unlock_irqrestore(&ipath_pioavail_lock, flags);
 }
 
+/*
+ * used to force update of pioavailshadow if we can't get a pio buffer.
+ * Needed primarily due to exitting freeze mode after recovering
+ * from errors.  Done lazily, because it's safer (known to not
+ * be writing pio buffers).
+ */
+static void ipath_reset_availshadow(struct ipath_devdata *dd)
+{
+        int i, im;
+        unsigned long flags;
+
+        spin_lock_irqsave(&ipath_pioavail_lock, flags);
+        for (i = 0; i < dd->ipath_pioavregs; i++) {
+                u64 val, oldval;
+                /* deal with 6110 chip bug on high register #s */
+                im = (i > 3 && (dd->ipath_flags & IPATH_SWAP_PIOBUFS)) ?
+                        i ^ 1 : i;
+                val = le64_to_cpu(dd->ipath_pioavailregs_dma[im]);
+                /*
+                 * busy out the buffers not in the kernel avail list,
+                 * without changing the generation bits.
+                 */
+                oldval = dd->ipath_pioavailshadow[i];
+                dd->ipath_pioavailshadow[i] = val |
+                        ((~dd->ipath_pioavailkernel[i] <<
+                        INFINIPATH_SENDPIOAVAIL_BUSY_SHIFT) &
+                        0xaaaaaaaaaaaaaaaaULL); /* All BUSY bits in qword */
+                if (oldval != dd->ipath_pioavailshadow[i])
+                        ipath_dbg("shadow[%d] was %Lx, now %lx\n",
+                                i, oldval, dd->ipath_pioavailshadow[i]);
+        }
+        spin_unlock_irqrestore(&ipath_pioavail_lock, flags);
+}
+
 /**
  * ipath_setrcvhdrsize - set the receive header size
  * @dd: the infinipath device
@@ -1482,9 +1516,12 @@ static noinline void no_pio_bufs(struct ipath_devdata *dd)
          */
         ipath_stats.sps_nopiobufs++;
         if (!(++dd->ipath_consec_nopiobuf % 100000)) {
-                ipath_dbg("%u pio sends with no bufavail; dmacopy: "
-                        "%llx %llx %llx %llx; shadow:  %lx %lx %lx %lx\n",
+                ipath_force_pio_avail_update(dd); /* at start */
+                ipath_dbg("%u tries no piobufavail ts%lx; dmacopy: "
+                        "%llx %llx %llx %llx\n"
+                        "ipath  shadow:  %lx %lx %lx %lx\n",
                         dd->ipath_consec_nopiobuf,
+                        (unsigned long)get_cycles(),
                         (unsigned long long) le64_to_cpu(dma[0]),
                         (unsigned long long) le64_to_cpu(dma[1]),
                         (unsigned long long) le64_to_cpu(dma[2]),
@@ -1496,14 +1533,17 @@ static noinline void no_pio_bufs(struct ipath_devdata *dd)
                  */
                 if ((dd->ipath_piobcnt2k + dd->ipath_piobcnt4k) >
                     (sizeof(shadow[0]) * 4 * 4))
-                        ipath_dbg("2nd group: dmacopy: %llx %llx "
-                                  "%llx %llx; shadow: %lx %lx %lx %lx\n",
+                        ipath_dbg("2nd group: dmacopy: "
+                                  "%llx %llx %llx %llx\n"
+                                  "ipath  shadow:  %lx %lx %lx %lx\n",
                                   (unsigned long long)le64_to_cpu(dma[4]),
                                   (unsigned long long)le64_to_cpu(dma[5]),
                                   (unsigned long long)le64_to_cpu(dma[6]),
                                   (unsigned long long)le64_to_cpu(dma[7]),
-                                  shadow[4], shadow[5], shadow[6],
-                                  shadow[7]);
+                                  shadow[4], shadow[5], shadow[6], shadow[7]);
+
+                /* at end, so update likely happened */
+                ipath_reset_availshadow(dd);
         }
 }
 
@@ -1652,19 +1692,46 @@ void ipath_chg_pioavailkernel(struct ipath_devdata *dd, unsigned start,
                               unsigned len, int avail)
 {
         unsigned long flags;
-        unsigned end;
+        unsigned end, cnt = 0, next;
 
         /* There are two bits per send buffer (busy and generation) */
         start *= 2;
-        len *= 2;
-        end = start + len;
+        end = start + len * 2;
 
-        /* Set or clear the generation bits. */
         spin_lock_irqsave(&ipath_pioavail_lock, flags);
+        /* Set or clear the busy bit in the shadow. */
         while (start < end) {
                 if (avail) {
-                        __clear_bit(start + INFINIPATH_SENDPIOAVAIL_BUSY_SHIFT,
-                                dd->ipath_pioavailshadow);
+                        unsigned long dma;
+                        int i, im;
+                        /*
+                         * the BUSY bit will never be set, because we disarm
+                         * the user buffers before we hand them back to the
+                         * kernel.  We do have to make sure the generation
+                         * bit is set correctly in shadow, since it could
+                         * have changed many times while allocated to user.
+                         * We can't use the bitmap functions on the full
+                         * dma array because it is always little-endian, so
+                         * we have to flip to host-order first.
+                         * BITS_PER_LONG is slightly wrong, since it's
+                         * always 64 bits per register in chip...
+                         * We only work on 64 bit kernels, so that's OK.
+                         */
+                        /* deal with 6110 chip bug on high register #s */
+                        i = start / BITS_PER_LONG;
+                        im = (i > 3 && (dd->ipath_flags & IPATH_SWAP_PIOBUFS)) ?
+                                i ^ 1 : i;
+                        __clear_bit(INFINIPATH_SENDPIOAVAIL_BUSY_SHIFT
+                                + start, dd->ipath_pioavailshadow);
+                        dma = (unsigned long) le64_to_cpu(
+                                dd->ipath_pioavailregs_dma[im]);
+                        if (test_bit((INFINIPATH_SENDPIOAVAIL_CHECK_SHIFT
+                                + start) % BITS_PER_LONG, &dma))
+                                __set_bit(INFINIPATH_SENDPIOAVAIL_CHECK_SHIFT
+                                        + start, dd->ipath_pioavailshadow);
+                        else
+                                __clear_bit(INFINIPATH_SENDPIOAVAIL_CHECK_SHIFT
+                                        + start, dd->ipath_pioavailshadow);
                         __set_bit(start, dd->ipath_pioavailkernel);
                 } else {
                         __set_bit(start + INFINIPATH_SENDPIOAVAIL_BUSY_SHIFT,
@@ -1673,7 +1740,44 @@ void ipath_chg_pioavailkernel(struct ipath_devdata *dd, unsigned start,
                 }
                 start += 2;
         }
+
+        if (dd->ipath_pioupd_thresh) {
+                end = 2 * (dd->ipath_piobcnt2k + dd->ipath_piobcnt4k);
+                next = find_first_bit(dd->ipath_pioavailkernel, end);
+                while (next < end) {
+                        cnt++;
+                        next = find_next_bit(dd->ipath_pioavailkernel, end,
+                                        next + 1);
+                }
+        }
         spin_unlock_irqrestore(&ipath_pioavail_lock, flags);
+
+        /*
+         * When moving buffers from kernel to user, if number assigned to
+         * the user is less than the pio update threshold, and threshold
+         * is supported (cnt was computed > 0), drop the update threshold
+         * so we update at least once per allocated number of buffers.
+         * In any case, if the kernel buffers are less than the threshold,
+         * drop the threshold.  We don't bother increasing it, having once
+         * decreased it, since it would typically just cycle back and forth.
+         * If we don't decrease below buffers in use, we can wait a long
+         * time for an update, until some other context uses PIO buffers.
+         */
+        if (!avail && len < cnt)
+                cnt = len;
+        if (cnt < dd->ipath_pioupd_thresh) {
+                dd->ipath_pioupd_thresh = cnt;
+                ipath_dbg("Decreased pio update threshold to %u\n",
+                        dd->ipath_pioupd_thresh);
+                spin_lock_irqsave(&dd->ipath_sendctrl_lock, flags);
+                dd->ipath_sendctrl &= ~(INFINIPATH_S_UPDTHRESH_MASK
+                        << INFINIPATH_S_UPDTHRESH_SHIFT);
+                dd->ipath_sendctrl |= dd->ipath_pioupd_thresh
+                        << INFINIPATH_S_UPDTHRESH_SHIFT;
+                ipath_write_kreg(dd, dd->ipath_kregs->kr_sendctrl,
+                        dd->ipath_sendctrl);
+                spin_unlock_irqrestore(&dd->ipath_sendctrl_lock, flags);
+        }
 }
 
 /**
@@ -1794,8 +1898,8 @@ void ipath_cancel_sends(struct ipath_devdata *dd, int restore_sendctrl)
 
                 spin_lock_irqsave(&dd->ipath_sdma_lock, flags);
                 skip_cancel =
-                        !test_bit(IPATH_SDMA_DISABLED, statp) &&
-                        test_and_set_bit(IPATH_SDMA_ABORTING, statp);
+                        test_and_set_bit(IPATH_SDMA_ABORTING, statp)
+                        && !test_bit(IPATH_SDMA_DISABLED, statp);
                 spin_unlock_irqrestore(&dd->ipath_sdma_lock, flags);
                 if (skip_cancel)
                         goto bail;
@@ -1826,6 +1930,9 @@ void ipath_cancel_sends(struct ipath_devdata *dd, int restore_sendctrl)
         ipath_disarm_piobufs(dd, 0,
                 dd->ipath_piobcnt2k + dd->ipath_piobcnt4k);
 
+        if (dd->ipath_flags & IPATH_HAS_SEND_DMA)
+                set_bit(IPATH_SDMA_DISARMED, &dd->ipath_sdma_status);
+
         if (restore_sendctrl) {
                 /* else done by caller later if needed */
                 spin_lock_irqsave(&dd->ipath_sendctrl_lock, flags);
@@ -1845,7 +1952,6 @@ void ipath_cancel_sends(struct ipath_devdata *dd, int restore_sendctrl)
                 /* only wait so long for intr */
                 dd->ipath_sdma_abort_intr_timeout = jiffies + HZ;
                 dd->ipath_sdma_reset_wait = 200;
-                __set_bit(IPATH_SDMA_DISARMED, &dd->ipath_sdma_status);
                 if (!test_bit(IPATH_SDMA_SHUTDOWN, &dd->ipath_sdma_status))
                         tasklet_hi_schedule(&dd->ipath_sdma_abort_task);
                 spin_unlock_irqrestore(&dd->ipath_sdma_lock, flags);
diff --git a/drivers/infiniband/hw/ipath/ipath_file_ops.c b/drivers/infiniband/hw/ipath/ipath_file_ops.c
index 8b1752202e78..3295177c937e 100644
--- a/drivers/infiniband/hw/ipath/ipath_file_ops.c
+++ b/drivers/infiniband/hw/ipath/ipath_file_ops.c
@@ -173,47 +173,25 @@ static int ipath_get_base_info(struct file *fp,
                 (void *) dd->ipath_statusp -
                 (void *) dd->ipath_pioavailregs_dma;
         if (!shared) {
-                kinfo->spi_piocnt = dd->ipath_pbufsport;
+                kinfo->spi_piocnt = pd->port_piocnt;
                 kinfo->spi_piobufbase = (u64) pd->port_piobufs;
                 kinfo->__spi_uregbase = (u64) dd->ipath_uregbase +
                         dd->ipath_ureg_align * pd->port_port;
         } else if (master) {
-                kinfo->spi_piocnt = (dd->ipath_pbufsport / subport_cnt) +
-                                    (dd->ipath_pbufsport % subport_cnt);
+                kinfo->spi_piocnt = (pd->port_piocnt / subport_cnt) +
+                                    (pd->port_piocnt % subport_cnt);
                 /* Master's PIO buffers are after all the slave's */
                 kinfo->spi_piobufbase = (u64) pd->port_piobufs +
                         dd->ipath_palign *
-                        (dd->ipath_pbufsport - kinfo->spi_piocnt);
+                        (pd->port_piocnt - kinfo->spi_piocnt);
         } else {
                 unsigned slave = subport_fp(fp) - 1;
 
-                kinfo->spi_piocnt = dd->ipath_pbufsport / subport_cnt;
+                kinfo->spi_piocnt = pd->port_piocnt / subport_cnt;
                 kinfo->spi_piobufbase = (u64) pd->port_piobufs +
                         dd->ipath_palign * kinfo->spi_piocnt * slave;
         }
 
-        /*
-         * Set the PIO avail update threshold to no larger
-         * than the number of buffers per process. Note that
-         * we decrease it here, but won't ever increase it.
-         */
-        if (dd->ipath_pioupd_thresh &&
-            kinfo->spi_piocnt < dd->ipath_pioupd_thresh) {
-                unsigned long flags;
-
-                dd->ipath_pioupd_thresh = kinfo->spi_piocnt;
-                ipath_dbg("Decreased pio update threshold to %u\n",
-                        dd->ipath_pioupd_thresh);
-                spin_lock_irqsave(&dd->ipath_sendctrl_lock, flags);
-                dd->ipath_sendctrl &= ~(INFINIPATH_S_UPDTHRESH_MASK
-                        << INFINIPATH_S_UPDTHRESH_SHIFT);
-                dd->ipath_sendctrl |= dd->ipath_pioupd_thresh
-                        << INFINIPATH_S_UPDTHRESH_SHIFT;
-                ipath_write_kreg(dd, dd->ipath_kregs->kr_sendctrl,
-                        dd->ipath_sendctrl);
-                spin_unlock_irqrestore(&dd->ipath_sendctrl_lock, flags);
-        }
-
         if (shared) {
                 kinfo->spi_port_uregbase = (u64) dd->ipath_uregbase +
                         dd->ipath_ureg_align * pd->port_port;
@@ -1309,19 +1287,19 @@ static int ipath_mmap(struct file *fp, struct vm_area_struct *vma)
         ureg = dd->ipath_uregbase + dd->ipath_ureg_align * pd->port_port;
         if (!pd->port_subport_cnt) {
                 /* port is not shared */
-                piocnt = dd->ipath_pbufsport;
+                piocnt = pd->port_piocnt;
                 piobufs = pd->port_piobufs;
         } else if (!subport_fp(fp)) {
                 /* caller is the master */
-                piocnt = (dd->ipath_pbufsport / pd->port_subport_cnt) +
-                         (dd->ipath_pbufsport % pd->port_subport_cnt);
+                piocnt = (pd->port_piocnt / pd->port_subport_cnt) +
+                         (pd->port_piocnt % pd->port_subport_cnt);
                 piobufs = pd->port_piobufs +
-                        dd->ipath_palign * (dd->ipath_pbufsport - piocnt);
+                        dd->ipath_palign * (pd->port_piocnt - piocnt);
         } else {
                 unsigned slave = subport_fp(fp) - 1;
 
                 /* caller is a slave */
-                piocnt = dd->ipath_pbufsport / pd->port_subport_cnt;
+                piocnt = pd->port_piocnt / pd->port_subport_cnt;
                 piobufs = pd->port_piobufs + dd->ipath_palign * piocnt * slave;
         }
 
@@ -1633,9 +1611,6 @@ static int try_alloc_port(struct ipath_devdata *dd, int port,
                 port_fp(fp) = pd;
                 pd->port_pid = current->pid;
                 strncpy(pd->port_comm, current->comm, sizeof(pd->port_comm));
-                ipath_chg_pioavailkernel(dd,
-                        dd->ipath_pbufsport * (pd->port_port - 1),
-                        dd->ipath_pbufsport, 0);
                 ipath_stats.sps_ports++;
                 ret = 0;
         } else
@@ -1938,11 +1913,25 @@ static int ipath_do_user_init(struct file *fp,
 
         /* for now we do nothing with rcvhdrcnt: uinfo->spu_rcvhdrcnt */
 
+        /* some ports may get extra buffers, calculate that here */
+        if (pd->port_port <= dd->ipath_ports_extrabuf)
+                pd->port_piocnt = dd->ipath_pbufsport + 1;
+        else
+                pd->port_piocnt = dd->ipath_pbufsport;
+
         /* for right now, kernel piobufs are at end, so port 1 is at 0 */
+        if (pd->port_port <= dd->ipath_ports_extrabuf)
+                pd->port_pio_base = (dd->ipath_pbufsport + 1)
+                        * (pd->port_port - 1);
+        else
+                pd->port_pio_base = dd->ipath_ports_extrabuf +
+                        dd->ipath_pbufsport * (pd->port_port - 1);
         pd->port_piobufs = dd->ipath_piobufbase +
-                dd->ipath_pbufsport * (pd->port_port - 1) * dd->ipath_palign;
-        ipath_cdbg(VERBOSE, "Set base of piobufs for port %u to 0x%x\n",
-                   pd->port_port, pd->port_piobufs);
+                pd->port_pio_base * dd->ipath_palign;
+        ipath_cdbg(VERBOSE, "piobuf base for port %u is 0x%x, piocnt %u,"
+                " first pio %u\n", pd->port_port, pd->port_piobufs,
+                pd->port_piocnt, pd->port_pio_base);
+        ipath_chg_pioavailkernel(dd, pd->port_pio_base, pd->port_piocnt, 0);
 
         /*
          * Now allocate the rcvhdr Q and eager TIDs; skip the TID
@@ -2107,7 +2096,6 @@ static int ipath_close(struct inode *in, struct file *fp)
         }
 
         if (dd->ipath_kregbase) {
-                int i;
                 /* atomically clear receive enable port and intr avail. */
                 clear_bit(dd->ipath_r_portenable_shift + port,
                           &dd->ipath_rcvctrl);
@@ -2136,9 +2124,9 @@ static int ipath_close(struct inode *in, struct file *fp)
                 ipath_write_kreg_port(dd, dd->ipath_kregs->kr_rcvhdraddr,
                         pd->port_port, dd->ipath_dummy_hdrq_phys);
 
-                i = dd->ipath_pbufsport * (port - 1);
-                ipath_disarm_piobufs(dd, i, dd->ipath_pbufsport);
-                ipath_chg_pioavailkernel(dd, i, dd->ipath_pbufsport, 1);
+                ipath_disarm_piobufs(dd, pd->port_pio_base, pd->port_piocnt);
+                ipath_chg_pioavailkernel(dd, pd->port_pio_base,
+                        pd->port_piocnt, 1);
 
                 dd->ipath_f_clear_tids(dd, pd->port_port);
 
diff --git a/drivers/infiniband/hw/ipath/ipath_iba7220.c b/drivers/infiniband/hw/ipath/ipath_iba7220.c
index e3ec0d1bdf50..8eee7830f042 100644
--- a/drivers/infiniband/hw/ipath/ipath_iba7220.c
+++ b/drivers/infiniband/hw/ipath/ipath_iba7220.c
@@ -595,7 +595,7 @@ static void ipath_7220_txe_recover(struct ipath_devdata *dd)
 
         dev_info(&dd->pcidev->dev,
                 "Recovering from TXE PIO parity error\n");
-        ipath_disarm_senderrbufs(dd, 1);
+        ipath_disarm_senderrbufs(dd);
 }
 
 
@@ -675,10 +675,8 @@ static void ipath_7220_handle_hwerrors(struct ipath_devdata *dd, char *msg,
         ctrl = ipath_read_kreg32(dd, dd->ipath_kregs->kr_control);
         if ((ctrl & INFINIPATH_C_FREEZEMODE) && !ipath_diag_inuse) {
                 /*
-                 * Parity errors in send memory are recoverable,
-                 * just cancel the send (if indicated in * sendbuffererror),
-                 * count the occurrence, unfreeze (if no other handled
-                 * hardware error bits are set), and continue.
+                 * Parity errors in send memory are recoverable by h/w
+                 * just do housekeeping, exit freeze mode and continue.
                  */
                 if (hwerrs & ((INFINIPATH_HWE_TXEMEMPARITYERR_PIOBUF |
                                INFINIPATH_HWE_TXEMEMPARITYERR_PIOPBC)
@@ -687,13 +685,6 @@ static void ipath_7220_handle_hwerrors(struct ipath_devdata *dd, char *msg,
                         hwerrs &= ~((INFINIPATH_HWE_TXEMEMPARITYERR_PIOBUF |
                                      INFINIPATH_HWE_TXEMEMPARITYERR_PIOPBC)
                                     << INFINIPATH_HWE_TXEMEMPARITYERR_SHIFT);
-                        if (!hwerrs) {
-                                /* else leave in freeze mode */
-                                ipath_write_kreg(dd,
-                                                 dd->ipath_kregs->kr_control,
-                                                 dd->ipath_control);
-                                goto bail;
-                        }
                 }
                 if (hwerrs) {
                         /*
@@ -723,8 +714,8 @@ static void ipath_7220_handle_hwerrors(struct ipath_devdata *dd, char *msg,
                         *dd->ipath_statusp |= IPATH_STATUS_HWERROR;
                         dd->ipath_flags &= ~IPATH_INITTED;
                 } else {
-                        ipath_dbg("Clearing freezemode on ignored hardware "
-                                  "error\n");
+                        ipath_dbg("Clearing freezemode on ignored or "
+                                "recovered hardware error\n");
                         ipath_clear_freeze(dd);
                 }
         }
@@ -870,8 +861,9 @@ static int ipath_7220_boardname(struct ipath_devdata *dd, char *name,
                               "revision %u.%u!\n",
                               dd->ipath_majrev, dd->ipath_minrev);
                 ret = 1;
-        } else if (dd->ipath_minrev == 1) {
-                /* Rev1 chips are prototype. Complain, but allow use */
+        } else if (dd->ipath_minrev == 1 &&
+                !(dd->ipath_flags & IPATH_INITTED)) {
+                /* Rev1 chips are prototype. Complain at init, but allow use */
                 ipath_dev_err(dd, "Unsupported hardware "
                               "revision %u.%u, Contact support@qlogic.com\n",
                               dd->ipath_majrev, dd->ipath_minrev);
@@ -1966,7 +1958,7 @@ static void ipath_7220_config_ports(struct ipath_devdata *dd, ushort cfgports)
                          dd->ipath_rcvctrl);
         dd->ipath_p0_rcvegrcnt = 2048; /* always */
         if (dd->ipath_flags & IPATH_HAS_SEND_DMA)
-                dd->ipath_pioreserved = 1; /* reserve a buffer */
+                dd->ipath_pioreserved = 3; /* kpiobufs used for PIO */
 }
 
 
diff --git a/drivers/infiniband/hw/ipath/ipath_init_chip.c b/drivers/infiniband/hw/ipath/ipath_init_chip.c
index 27dd89476660..3e5baa43fc82 100644
--- a/drivers/infiniband/hw/ipath/ipath_init_chip.c
+++ b/drivers/infiniband/hw/ipath/ipath_init_chip.c
@@ -41,7 +41,7 @@
 /*
  * min buffers we want to have per port, after driver
  */
-#define IPATH_MIN_USER_PORT_BUFCNT 8
+#define IPATH_MIN_USER_PORT_BUFCNT 7
 
 /*
  * Number of ports we are configured to use (to allow for more pio
@@ -54,13 +54,9 @@ MODULE_PARM_DESC(cfgports, "Set max number of ports to use");
 
 /*
  * Number of buffers reserved for driver (verbs and layered drivers.)
- * Reserved at end of buffer list.   Initialized based on
- * number of PIO buffers if not set via module interface.
+ * Initialized based on number of PIO buffers if not set via module interface.
  * The problem with this is that it's global, but we'll use different
- * numbers for different chip types.  So the default value is not
- * very useful.  I've redefined it for the 1.3 release so that it's
- * zero unless set by the user to something else, in which case we
- * try to respect it.
+ * numbers for different chip types.
  */
 static ushort ipath_kpiobufs;
 
@@ -546,9 +542,12 @@ static void enable_chip(struct ipath_devdata *dd, int reinit)
                         pioavail = dd->ipath_pioavailregs_dma[i ^ 1];
                 else
                         pioavail = dd->ipath_pioavailregs_dma[i];
-                dd->ipath_pioavailshadow[i] = le64_to_cpu(pioavail) |
-                        (~dd->ipath_pioavailkernel[i] <<
-                        INFINIPATH_SENDPIOAVAIL_BUSY_SHIFT);
+                /*
+                 * don't need to worry about ipath_pioavailkernel here
+                 * because we will call ipath_chg_pioavailkernel() later
+                 * in initialization, to busy out buffers as needed
+                 */
+                dd->ipath_pioavailshadow[i] = le64_to_cpu(pioavail);
         }
         /* can get counters, stats, etc. */
         dd->ipath_flags |= IPATH_PRESENT;
@@ -708,12 +707,11 @@ static void verify_interrupt(unsigned long opaque)
 int ipath_init_chip(struct ipath_devdata *dd, int reinit)
 {
         int ret = 0;
-        u32 val32, kpiobufs;
+        u32 kpiobufs, defkbufs;
         u32 piobufs, uports;
         u64 val;
         struct ipath_portdata *pd;
         gfp_t gfp_flags = GFP_USER | __GFP_COMP;
-        unsigned long flags;
 
         ret = init_housekeeping(dd, reinit);
         if (ret)
@@ -753,56 +751,46 @@ int ipath_init_chip(struct ipath_devdata *dd, int reinit)
         dd->ipath_pioavregs = ALIGN(piobufs, sizeof(u64) * BITS_PER_BYTE / 2)
                 / (sizeof(u64) * BITS_PER_BYTE / 2);
         uports = dd->ipath_cfgports ? dd->ipath_cfgports - 1 : 0;
-        if (ipath_kpiobufs == 0) {
-                /* not set by user (this is default) */
-                if (piobufs > 144)
-                        kpiobufs = 32;
-                else
-                        kpiobufs = 16;
-        }
+        if (piobufs > 144)
+                defkbufs = 32 + dd->ipath_pioreserved;
         else
-                kpiobufs = ipath_kpiobufs;
+                defkbufs = 16 + dd->ipath_pioreserved;
 
-        if (kpiobufs + (uports * IPATH_MIN_USER_PORT_BUFCNT) > piobufs) {
+        if (ipath_kpiobufs && (ipath_kpiobufs +
+                (uports * IPATH_MIN_USER_PORT_BUFCNT)) > piobufs) {
                 int i = (int) piobufs -
                         (int) (uports * IPATH_MIN_USER_PORT_BUFCNT);
                 if (i < 1)
                         i = 1;
                 dev_info(&dd->pcidev->dev, "Allocating %d PIO bufs of "
                          "%d for kernel leaves too few for %d user ports "
-                         "(%d each); using %u\n", kpiobufs,
+                         "(%d each); using %u\n", ipath_kpiobufs,
                          piobufs, uports, IPATH_MIN_USER_PORT_BUFCNT, i);
                 /*
                  * shouldn't change ipath_kpiobufs, because could be
                  * different for different devices...
                  */
                 kpiobufs = i;
-        }
+        } else if (ipath_kpiobufs)
+                kpiobufs = ipath_kpiobufs;
+        else
+                kpiobufs = defkbufs;
         dd->ipath_lastport_piobuf = piobufs - kpiobufs;
         dd->ipath_pbufsport =
                 uports ? dd->ipath_lastport_piobuf / uports : 0;
-        val32 = dd->ipath_lastport_piobuf - (dd->ipath_pbufsport * uports);
-        if (val32 > 0) {
-                ipath_dbg("allocating %u pbufs/port leaves %u unused, "
-                          "add to kernel\n", dd->ipath_pbufsport, val32);
-                dd->ipath_lastport_piobuf -= val32;
-                kpiobufs += val32;
-                ipath_dbg("%u pbufs/port leaves %u unused, add to kernel\n",
-                          dd->ipath_pbufsport, val32);
-        }
+        /* if not an even divisor, some user ports get extra buffers */
+        dd->ipath_ports_extrabuf = dd->ipath_lastport_piobuf -
+                (dd->ipath_pbufsport * uports);
+        if (dd->ipath_ports_extrabuf)
+                ipath_dbg("%u pbufs/port leaves some unused, add 1 buffer to "
+                        "ports <= %u\n", dd->ipath_pbufsport,
+                        dd->ipath_ports_extrabuf);
         dd->ipath_lastpioindex = 0;
         dd->ipath_lastpioindexl = dd->ipath_piobcnt2k;
-        ipath_chg_pioavailkernel(dd, 0, piobufs, 1);
+        /* ipath_pioavailshadow initialized earlier */
         ipath_cdbg(VERBOSE, "%d PIO bufs for kernel out of %d total %u "
                    "each for %u user ports\n", kpiobufs,
                    piobufs, dd->ipath_pbufsport, uports);
-        if (dd->ipath_pioupd_thresh) {
-                if (dd->ipath_pbufsport < dd->ipath_pioupd_thresh)
-                        dd->ipath_pioupd_thresh = dd->ipath_pbufsport;
-                if (kpiobufs < dd->ipath_pioupd_thresh)
-                        dd->ipath_pioupd_thresh = kpiobufs;
-        }
-
         ret = dd->ipath_f_early_init(dd);
         if (ret) {
                 ipath_dev_err(dd, "Early initialization failure\n");
@@ -810,13 +798,6 @@ int ipath_init_chip(struct ipath_devdata *dd, int reinit)
         }
 
         /*
-         * Cancel any possible active sends from early driver load.
-         * Follows early_init because some chips have to initialize
-         * PIO buffers in early_init to avoid false parity errors.
-         */
-        ipath_cancel_sends(dd, 0);
-
-        /*
          * Early_init sets rcvhdrentsize and rcvhdrsize, so this must be
          * done after early_init.
          */
@@ -836,6 +817,7 @@ int ipath_init_chip(struct ipath_devdata *dd, int reinit)
 
         ipath_write_kreg(dd, dd->ipath_kregs->kr_sendpioavailaddr,
                          dd->ipath_pioavailregs_phys);
+
         /*
          * this is to detect s/w errors, which the h/w works around by
          * ignoring the low 6 bits of address, if it wasn't aligned.
@@ -862,12 +844,6 @@ int ipath_init_chip(struct ipath_devdata *dd, int reinit)
                          ~0ULL&~INFINIPATH_HWE_MEMBISTFAILED);
         ipath_write_kreg(dd, dd->ipath_kregs->kr_control, 0ULL);
 
-        spin_lock_irqsave(&dd->ipath_sendctrl_lock, flags);
-        dd->ipath_sendctrl = INFINIPATH_S_PIOENABLE;
-        ipath_write_kreg(dd, dd->ipath_kregs->kr_sendctrl, dd->ipath_sendctrl);
-        ipath_read_kreg64(dd, dd->ipath_kregs->kr_scratch);
-        spin_unlock_irqrestore(&dd->ipath_sendctrl_lock, flags);
-
         /*
          * before error clears, since we expect serdes pll errors during
          * this, the first time after reset
@@ -940,6 +916,19 @@ int ipath_init_chip(struct ipath_devdata *dd, int reinit)
         else
                 enable_chip(dd, reinit);
 
+        /* after enable_chip, so pioavailshadow setup */
+        ipath_chg_pioavailkernel(dd, 0, piobufs, 1);
+
+        /*
+         * Cancel any possible active sends from early driver load.
+         * Follows early_init because some chips have to initialize
+         * PIO buffers in early_init to avoid false parity errors.
+         * After enable and ipath_chg_pioavailkernel so we can safely
+         * enable pioavail updates and PIOENABLE; packets are now
+         * ready to go out.
+         */
+        ipath_cancel_sends(dd, 1);
+
         if (!reinit) {
                 /*
                  * Used when we close a port, for DMA already in flight
diff --git a/drivers/infiniband/hw/ipath/ipath_intr.c b/drivers/infiniband/hw/ipath/ipath_intr.c
index 1b58f4737c71..26900b3b7a4e 100644
--- a/drivers/infiniband/hw/ipath/ipath_intr.c
+++ b/drivers/infiniband/hw/ipath/ipath_intr.c
@@ -38,42 +38,12 @@
 #include "ipath_verbs.h"
 #include "ipath_common.h"
 
-/*
- * clear (write) a pio buffer, to clear a parity error.   This routine
- * should only be called when in freeze mode, and the buffer should be
- * canceled afterwards.
- */
-static void ipath_clrpiobuf(struct ipath_devdata *dd, u32 pnum)
-{
-        u32 __iomem *pbuf;
-        u32 dwcnt; /* dword count to write */
-        if (pnum < dd->ipath_piobcnt2k) {
-                pbuf = (u32 __iomem *) (dd->ipath_pio2kbase + pnum *
-                        dd->ipath_palign);
-                dwcnt = dd->ipath_piosize2k >> 2;
-        }
-        else {
-                pbuf = (u32 __iomem *) (dd->ipath_pio4kbase +
-                        (pnum - dd->ipath_piobcnt2k) * dd->ipath_4kalign);
-                dwcnt = dd->ipath_piosize4k >> 2;
-        }
-        dev_info(&dd->pcidev->dev,
-                "Rewrite PIO buffer %u, to recover from parity error\n",
-                pnum);
-
-        /* no flush required, since already in freeze */
-        writel(dwcnt + 1, pbuf);
-        while (--dwcnt)
-                writel(0, pbuf++);
-}
 
 /*
  * Called when we might have an error that is specific to a particular
  * PIO buffer, and may need to cancel that buffer, so it can be re-used.
- * If rewrite is true, and bits are set in the sendbufferror registers,
- * we'll write to the buffer, for error recovery on parity errors.
  */
-void ipath_disarm_senderrbufs(struct ipath_devdata *dd, int rewrite)
+void ipath_disarm_senderrbufs(struct ipath_devdata *dd)
 {
         u32 piobcnt;
         unsigned long sbuf[4];
@@ -109,11 +79,8 @@ void ipath_disarm_senderrbufs(struct ipath_devdata *dd, int rewrite)
                 }
 
                 for (i = 0; i < piobcnt; i++)
-                        if (test_bit(i, sbuf)) {
-                                if (rewrite)
-                                        ipath_clrpiobuf(dd, i);
+                        if (test_bit(i, sbuf))
                                 ipath_disarm_piobufs(dd, i, 1);
-                        }
                 /* ignore armlaunch errs for a bit */
                 dd->ipath_lastcancel = jiffies+3;
         }
@@ -164,7 +131,7 @@ static u64 handle_e_sum_errs(struct ipath_devdata *dd, ipath_err_t errs)
 {
         u64 ignore_this_time = 0;
 
-        ipath_disarm_senderrbufs(dd, 0);
+        ipath_disarm_senderrbufs(dd);
         if ((errs & E_SUM_LINK_PKTERRS) &&
             !(dd->ipath_flags & IPATH_LINKACTIVE)) {
                 /*
@@ -909,8 +876,8 @@ static int handle_errors(struct ipath_devdata *dd, ipath_err_t errs)
  * processes (causing armlaunch), send errors due to going into freeze mode,
  * etc., and try to avoid causing extra interrupts while doing so.
  * Forcibly update the in-memory pioavail register copies after cleanup
- * because the chip won't do it for anything changing while in freeze mode
- * (we don't want to wait for the next pio buffer state change).
+ * because the chip won't do it while in freeze mode (the register values
+ * themselves are kept correct).
  * Make sure that we don't lose any important interrupts by using the chip
  * feature that says that writing 0 to a bit in *clear that is set in
  * *status will cause an interrupt to be generated again (if allowed by
@@ -918,44 +885,23 @@ static int handle_errors(struct ipath_devdata *dd, ipath_err_t errs)
  */
 void ipath_clear_freeze(struct ipath_devdata *dd)
 {
-        int i, im;
-        u64 val;
-
         /* disable error interrupts, to avoid confusion */
         ipath_write_kreg(dd, dd->ipath_kregs->kr_errormask, 0ULL);
 
         /* also disable interrupts; errormask is sometimes overwriten */
         ipath_write_kreg(dd, dd->ipath_kregs->kr_intmask, 0ULL);
 
-        /*
-         * clear all sends, because they have may been
-         * completed by usercode while in freeze mode, and
-         * therefore would not be sent, and eventually
-         * might cause the process to run out of bufs
-         */
-        ipath_cancel_sends(dd, 0);
+        ipath_cancel_sends(dd, 1);
+
+        /* clear the freeze, and be sure chip saw it */
         ipath_write_kreg(dd, dd->ipath_kregs->kr_control,
                          dd->ipath_control);
+        ipath_read_kreg64(dd, dd->ipath_kregs->kr_scratch);
 
-        /* ensure pio avail updates continue */
+        /* force in-memory update now we are out of freeze */
         ipath_force_pio_avail_update(dd);
 
         /*
-         * We just enabled pioavailupdate, so dma copy is almost certainly
-         * not yet right, so read the registers directly.  Similar to init
-         */
-        for (i = 0; i < dd->ipath_pioavregs; i++) {
-                /* deal with 6110 chip bug */
-                im = (i > 3 && (dd->ipath_flags & IPATH_SWAP_PIOBUFS)) ?
-                        i ^ 1 : i;
-                val = ipath_read_kreg64(dd, (0x1000 / sizeof(u64)) + im);
-                dd->ipath_pioavailregs_dma[i] = cpu_to_le64(val);
-                dd->ipath_pioavailshadow[i] = val |
-                        (~dd->ipath_pioavailkernel[i] <<
-                        INFINIPATH_SENDPIOAVAIL_BUSY_SHIFT);
-        }
-
-        /*
          * force new interrupt if any hwerr, error or interrupt bits are
          * still set, and clear "safe" send packet errors related to freeze
          * and cancelling sends.  Re-enable error interrupts before possible
@@ -1312,10 +1258,8 @@ irqreturn_t ipath_intr(int irq, void *data)
                 ipath_read_kreg64(dd, dd->ipath_kregs->kr_scratch);
                 spin_unlock_irqrestore(&dd->ipath_sendctrl_lock, flags);
 
-                if (!(dd->ipath_flags & IPATH_HAS_SEND_DMA))
-                        handle_layer_pioavail(dd);
-                else
-                        ipath_dbg("unexpected BUFAVAIL intr\n");
+                /* always process; sdma verbs uses PIO for acks and VL15  */
+                handle_layer_pioavail(dd);
         }
 
         ret = IRQ_HANDLED;
diff --git a/drivers/infiniband/hw/ipath/ipath_kernel.h b/drivers/infiniband/hw/ipath/ipath_kernel.h
index 202337ae90dc..02b24a340599 100644
--- a/drivers/infiniband/hw/ipath/ipath_kernel.h
+++ b/drivers/infiniband/hw/ipath/ipath_kernel.h
@@ -117,6 +117,10 @@ struct ipath_portdata {
         u16 port_subport_cnt;
         /* non-zero if port is being shared. */
         u16 port_subport_id;
+        /* number of pio bufs for this port (all procs, if shared) */
+        u32 port_piocnt;
+        /* first pio buffer for this port */
+        u32 port_pio_base;
         /* chip offset of PIO buffers for this port */
         u32 port_piobufs;
         /* how many alloc_pages() chunks in port_rcvegrbuf_pages */
@@ -384,6 +388,8 @@ struct ipath_devdata {
         u32 ipath_lastrpkts;
         /* pio bufs allocated per port */
         u32 ipath_pbufsport;
+        /* if remainder on bufs/port, ports < extrabuf get 1 extra */
+        u32 ipath_ports_extrabuf;
         u32 ipath_pioupd_thresh; /* update threshold, some chips */
         /*
          * number of ports configured as max; zero is set to number chip
@@ -1011,7 +1017,7 @@ void ipath_get_eeprom_info(struct ipath_devdata *);
 int ipath_update_eeprom_log(struct ipath_devdata *dd);
 void ipath_inc_eeprom_err(struct ipath_devdata *dd, u32 eidx, u32 incr);
 u64 ipath_snap_cntr(struct ipath_devdata *, ipath_creg);
-void ipath_disarm_senderrbufs(struct ipath_devdata *, int);
+void ipath_disarm_senderrbufs(struct ipath_devdata *);
 void ipath_force_pio_avail_update(struct ipath_devdata *);
 void signal_ib_event(struct ipath_devdata *dd, enum ib_event_type ev);
 
diff --git a/drivers/infiniband/hw/ipath/ipath_rc.c b/drivers/infiniband/hw/ipath/ipath_rc.c
index c405dfba5531..08b11b567614 100644
--- a/drivers/infiniband/hw/ipath/ipath_rc.c
+++ b/drivers/infiniband/hw/ipath/ipath_rc.c
@@ -1746,7 +1746,11 @@ void ipath_rc_rcv(struct ipath_ibdev *dev, struct ipath_ib_header *hdr,
                 qp->r_wrid_valid = 0;
                 wc.wr_id = qp->r_wr_id;
                 wc.status = IB_WC_SUCCESS;
-                wc.opcode = IB_WC_RECV;
+                if (opcode == OP(RDMA_WRITE_LAST_WITH_IMMEDIATE) ||
+                    opcode == OP(RDMA_WRITE_ONLY_WITH_IMMEDIATE))
+                        wc.opcode = IB_WC_RECV_RDMA_WITH_IMM;
+                else
+                        wc.opcode = IB_WC_RECV;
                 wc.vendor_err = 0;
                 wc.qp = &qp->ibqp;
                 wc.src_qp = qp->remote_qpn;
diff --git a/drivers/infiniband/hw/ipath/ipath_ruc.c b/drivers/infiniband/hw/ipath/ipath_ruc.c
index 8ac5c1d82ccd..9e3fe61cbd08 100644
--- a/drivers/infiniband/hw/ipath/ipath_ruc.c
+++ b/drivers/infiniband/hw/ipath/ipath_ruc.c
@@ -481,9 +481,10 @@ done:
                 wake_up(&qp->wait);
 }
 
-static void want_buffer(struct ipath_devdata *dd)
+static void want_buffer(struct ipath_devdata *dd, struct ipath_qp *qp)
 {
-        if (!(dd->ipath_flags & IPATH_HAS_SEND_DMA)) {
+        if (!(dd->ipath_flags & IPATH_HAS_SEND_DMA) ||
+                qp->ibqp.qp_type == IB_QPT_SMI) {
                 unsigned long flags;
 
                 spin_lock_irqsave(&dd->ipath_sendctrl_lock, flags);
@@ -519,7 +520,7 @@ static void ipath_no_bufs_available(struct ipath_qp *qp,
         spin_lock_irqsave(&dev->pending_lock, flags);
         list_add_tail(&qp->piowait, &dev->piowait);
         spin_unlock_irqrestore(&dev->pending_lock, flags);
-        want_buffer(dev->dd);
+        want_buffer(dev->dd, qp);
         dev->n_piowait++;
 }
 
diff --git a/drivers/infiniband/hw/ipath/ipath_sdma.c b/drivers/infiniband/hw/ipath/ipath_sdma.c
index 1974df7a9f78..3697449c1ba4 100644
--- a/drivers/infiniband/hw/ipath/ipath_sdma.c
+++ b/drivers/infiniband/hw/ipath/ipath_sdma.c
@@ -308,13 +308,15 @@ static void sdma_abort_task(unsigned long opaque)
                 spin_unlock_irqrestore(&dd->ipath_sdma_lock, flags);
 
                 /*
-                 * Don't restart sdma here. Wait until link is up to ACTIVE.
-                 * VL15 MADs used to bring the link up use PIO, and multiple
-                 * link transitions otherwise cause the sdma engine to be
+                 * Don't restart sdma here (with the exception
+                 * below). Wait until link is up to ACTIVE.  VL15 MADs
+                 * used to bring the link up use PIO, and multiple link
+                 * transitions otherwise cause the sdma engine to be
                  * stopped and started multiple times.
-                 * The disable is done here, including the shadow, so the
-                 * state is kept consistent.
-                 * See ipath_restart_sdma() for the actual starting of sdma.
+                 * The disable is done here, including the shadow,
+                 * so the state is kept consistent.
+                 * See ipath_restart_sdma() for the actual starting
+                 * of sdma.
                  */
                 spin_lock_irqsave(&dd->ipath_sendctrl_lock, flags);
                 dd->ipath_sendctrl &= ~INFINIPATH_S_SDMAENABLE;
@@ -326,6 +328,13 @@ static void sdma_abort_task(unsigned long opaque)
                 /* make sure I see next message */
                 dd->ipath_sdma_abort_jiffies = 0;
 
+                /*
+                 * Not everything that takes SDMA offline is a link
+                 * status change.  If the link was up, restart SDMA.
+                 */
+                if (dd->ipath_flags & IPATH_LINKACTIVE)
+                        ipath_restart_sdma(dd);
+
                 goto done;
         }
 
@@ -427,7 +436,12 @@ int setup_sdma(struct ipath_devdata *dd)
                 goto done;
         }
 
-        dd->ipath_sdma_status = 0;
+        /*
+         * Set initial status as if we had been up, then gone down.
+         * This lets initial start on transition to ACTIVE be the
+         * same as restart after link flap.
+         */
+        dd->ipath_sdma_status = IPATH_SDMA_ABORT_ABORTED;
         dd->ipath_sdma_abort_jiffies = 0;
         dd->ipath_sdma_generation = 0;
         dd->ipath_sdma_descq_tail = 0;
@@ -449,16 +463,19 @@ int setup_sdma(struct ipath_devdata *dd)
         ipath_write_kreg(dd, dd->ipath_kregs->kr_senddmaheadaddr,
                          dd->ipath_sdma_head_phys);
 
-        /* Reserve all the former "kernel" piobufs */
-        n = dd->ipath_piobcnt2k + dd->ipath_piobcnt4k - dd->ipath_pioreserved;
-        for (i = dd->ipath_lastport_piobuf; i < n; ++i) {
+        /*
+         * Reserve all the former "kernel" piobufs, using high number range
+         * so we get as many 4K buffers as possible
+         */
+        n = dd->ipath_piobcnt2k + dd->ipath_piobcnt4k;
+        i = dd->ipath_lastport_piobuf + dd->ipath_pioreserved;
+        ipath_chg_pioavailkernel(dd, i, n - i , 0);
+        for (; i < n; ++i) {
                 unsigned word = i / 64;
                 unsigned bit = i & 63;
                 BUG_ON(word >= 3);
                 senddmabufmask[word] |= 1ULL << bit;
         }
-        ipath_chg_pioavailkernel(dd, dd->ipath_lastport_piobuf,
-                n - dd->ipath_lastport_piobuf, 0);
         ipath_write_kreg(dd, dd->ipath_kregs->kr_senddmabufmask0,
                          senddmabufmask[0]);
         ipath_write_kreg(dd, dd->ipath_kregs->kr_senddmabufmask1,
@@ -615,6 +632,9 @@ void ipath_restart_sdma(struct ipath_devdata *dd)
         ipath_read_kreg64(dd, dd->ipath_kregs->kr_scratch);
         spin_unlock_irqrestore(&dd->ipath_sendctrl_lock, flags);
 
+        /* notify upper layers */
+        ipath_ib_piobufavail(dd->verbs_dev);
+
 bail:
         return;
 }
diff --git a/drivers/infiniband/hw/ipath/ipath_verbs.c b/drivers/infiniband/hw/ipath/ipath_verbs.c
index e63927cce5b5..5015cd2e57bd 100644
--- a/drivers/infiniband/hw/ipath/ipath_verbs.c
+++ b/drivers/infiniband/hw/ipath/ipath_verbs.c
@@ -396,7 +396,6 @@ static int ipath_post_one_send(struct ipath_qp *qp, struct ib_send_wr *wr)
 
         wqe = get_swqe_ptr(qp, qp->s_head);
         wqe->wr = *wr;
-        wqe->ssn = qp->s_ssn++;
         wqe->length = 0;
         if (wr->num_sge) {
                 acc = wr->opcode >= IB_WR_RDMA_READ ?
@@ -422,6 +421,7 @@ static int ipath_post_one_send(struct ipath_qp *qp, struct ib_send_wr *wr)
                         goto bail_inval;
         } else if (wqe->length > to_idev(qp->ibqp.device)->dd->ipath_ibmtu)
                 goto bail_inval;
+        wqe->ssn = qp->s_ssn++;
         qp->s_head = next;
 
         ret = 0;
diff --git a/drivers/infiniband/hw/mlx4/cq.c b/drivers/infiniband/hw/mlx4/cq.c
index 2f199c5c4a72..4521319b1406 100644
--- a/drivers/infiniband/hw/mlx4/cq.c
+++ b/drivers/infiniband/hw/mlx4/cq.c
@@ -246,7 +246,7 @@ err_mtt:
         if (context)
                 ib_umem_release(cq->umem);
         else
-                mlx4_ib_free_cq_buf(dev, &cq->buf, entries);
+                mlx4_ib_free_cq_buf(dev, &cq->buf, cq->ibcq.cqe);
 
 err_db:
         if (!context)
@@ -434,7 +434,7 @@ int mlx4_ib_destroy_cq(struct ib_cq *cq)
                 mlx4_ib_db_unmap_user(to_mucontext(cq->uobject->context), &mcq->db);
                 ib_umem_release(mcq->umem);
         } else {
-                mlx4_ib_free_cq_buf(dev, &mcq->buf, cq->cqe + 1);
+                mlx4_ib_free_cq_buf(dev, &mcq->buf, cq->cqe);
                 mlx4_db_free(dev->dev, &mcq->db);
         }
 
diff --git a/drivers/infiniband/ulp/ipoib/ipoib.h b/drivers/infiniband/ulp/ipoib/ipoib.h
index 9044f8803532..ca126fc2b853 100644
--- a/drivers/infiniband/ulp/ipoib/ipoib.h
+++ b/drivers/infiniband/ulp/ipoib/ipoib.h
@@ -334,6 +334,7 @@ struct ipoib_dev_priv {
 #endif
         int     hca_caps;
         struct ipoib_ethtool_st ethtool;
+        struct timer_list poll_timer;
 };
 
 struct ipoib_ah {
@@ -404,6 +405,7 @@ extern struct workqueue_struct *ipoib_workqueue;
 
 int ipoib_poll(struct napi_struct *napi, int budget);
 void ipoib_ib_completion(struct ib_cq *cq, void *dev_ptr);
+void ipoib_send_comp_handler(struct ib_cq *cq, void *dev_ptr);
 
 struct ipoib_ah *ipoib_create_ah(struct net_device *dev,
                                  struct ib_pd *pd, struct ib_ah_attr *attr);
diff --git a/drivers/infiniband/ulp/ipoib/ipoib_ib.c b/drivers/infiniband/ulp/ipoib/ipoib_ib.c
index 97b815c1a3fc..f429bce24c20 100644
--- a/drivers/infiniband/ulp/ipoib/ipoib_ib.c
+++ b/drivers/infiniband/ulp/ipoib/ipoib_ib.c
@@ -461,6 +461,26 @@ void ipoib_ib_completion(struct ib_cq *cq, void *dev_ptr)
         netif_rx_schedule(dev, &priv->napi);
 }
 
+static void drain_tx_cq(struct net_device *dev)
+{
+        struct ipoib_dev_priv *priv = netdev_priv(dev);
+        unsigned long flags;
+
+        spin_lock_irqsave(&priv->tx_lock, flags);
+        while (poll_tx(priv))
+                ; /* nothing */
+
+        if (netif_queue_stopped(dev))
+                mod_timer(&priv->poll_timer, jiffies + 1);
+
+        spin_unlock_irqrestore(&priv->tx_lock, flags);
+}
+
+void ipoib_send_comp_handler(struct ib_cq *cq, void *dev_ptr)
+{
+        drain_tx_cq((struct net_device *)dev_ptr);
+}
+
 static inline int post_send(struct ipoib_dev_priv *priv,
                             unsigned int wr_id,
                             struct ib_ah *address, u32 qpn,
@@ -555,12 +575,22 @@ void ipoib_send(struct net_device *dev, struct sk_buff *skb,
         else
                 priv->tx_wr.send_flags &= ~IB_SEND_IP_CSUM;
 
+        if (++priv->tx_outstanding == ipoib_sendq_size) {
+                ipoib_dbg(priv, "TX ring full, stopping kernel net queue\n");
+                if (ib_req_notify_cq(priv->send_cq, IB_CQ_NEXT_COMP))
+                        ipoib_warn(priv, "request notify on send CQ failed\n");
+                netif_stop_queue(dev);
+        }
+
         if (unlikely(post_send(priv, priv->tx_head & (ipoib_sendq_size - 1),
                                address->ah, qpn, tx_req, phead, hlen))) {
                 ipoib_warn(priv, "post_send failed\n");
                 ++dev->stats.tx_errors;
+                --priv->tx_outstanding;
                 ipoib_dma_unmap_tx(priv->ca, tx_req);
                 dev_kfree_skb_any(skb);
+                if (netif_queue_stopped(dev))
+                        netif_wake_queue(dev);
         } else {
                 dev->trans_start = jiffies;
 
@@ -568,14 +598,11 @@ void ipoib_send(struct net_device *dev, struct sk_buff *skb,
                 ++priv->tx_head;
                 skb_orphan(skb);
 
-                if (++priv->tx_outstanding == ipoib_sendq_size) {
-                        ipoib_dbg(priv, "TX ring full, stopping kernel net queue\n");
-                        netif_stop_queue(dev);
-                }
         }
 
         if (unlikely(priv->tx_outstanding > MAX_SEND_CQE))
-                poll_tx(priv);
+                while (poll_tx(priv))
+                        ; /* nothing */
 }
 
 static void __ipoib_reap_ah(struct net_device *dev)
@@ -609,6 +636,11 @@ void ipoib_reap_ah(struct work_struct *work)
                                    round_jiffies_relative(HZ));
 }
 
+static void ipoib_ib_tx_timer_func(unsigned long ctx)
+{
+        drain_tx_cq((struct net_device *)ctx);
+}
+
 int ipoib_ib_dev_open(struct net_device *dev)
 {
         struct ipoib_dev_priv *priv = netdev_priv(dev);
@@ -645,6 +677,10 @@ int ipoib_ib_dev_open(struct net_device *dev)
         queue_delayed_work(ipoib_workqueue, &priv->ah_reap_task,
                            round_jiffies_relative(HZ));
 
+        init_timer(&priv->poll_timer);
+        priv->poll_timer.function = ipoib_ib_tx_timer_func;
+        priv->poll_timer.data = (unsigned long)dev;
+
         set_bit(IPOIB_FLAG_INITIALIZED, &priv->flags);
 
         return 0;
@@ -810,6 +846,7 @@ int ipoib_ib_dev_stop(struct net_device *dev, int flush)
         ipoib_dbg(priv, "All sends and receives done.\n");
 
 timeout:
+        del_timer_sync(&priv->poll_timer);
         qp_attr.qp_state = IB_QPS_RESET;
         if (ib_modify_qp(priv->qp, &qp_attr, IB_QP_STATE))
                 ipoib_warn(priv, "Failed to modify QP to RESET state\n");
diff --git a/drivers/infiniband/ulp/ipoib/ipoib_verbs.c b/drivers/infiniband/ulp/ipoib/ipoib_verbs.c
index c1e7ece1fd44..8766d29ce3b7 100644
--- a/drivers/infiniband/ulp/ipoib/ipoib_verbs.c
+++ b/drivers/infiniband/ulp/ipoib/ipoib_verbs.c
@@ -187,7 +187,8 @@ int ipoib_transport_dev_init(struct net_device *dev, struct ib_device *ca)
                 goto out_free_mr;
         }
 
-        priv->send_cq = ib_create_cq(priv->ca, NULL, NULL, dev, ipoib_sendq_size, 0);
+        priv->send_cq = ib_create_cq(priv->ca, ipoib_send_comp_handler, NULL,
+                                     dev, ipoib_sendq_size, 0);
         if (IS_ERR(priv->send_cq)) {
                 printk(KERN_WARNING "%s: failed to create send CQ\n", ca->name);
                 goto out_free_recv_cq;
diff --git a/drivers/input/misc/Kconfig b/drivers/input/misc/Kconfig
index 92b683411d5a..3ad8bd9f7543 100644
--- a/drivers/input/misc/Kconfig
+++ b/drivers/input/misc/Kconfig
@@ -14,7 +14,7 @@ if INPUT_MISC
 
 config INPUT_PCSPKR
         tristate "PC Speaker support"
-        depends on ALPHA || X86 || MIPS || PPC_PREP || PPC_CHRP || PPC_PSERIES
+        depends on PCSPKR_PLATFORM
         depends on SND_PCSP=n
         help
           Say Y here if you want the standard PC Speaker to be used for
diff --git a/drivers/input/serio/hp_sdc.c b/drivers/input/serio/hp_sdc.c
index 02b3ad8c0826..edfedd9a166c 100644
--- a/drivers/input/serio/hp_sdc.c
+++ b/drivers/input/serio/hp_sdc.c
@@ -69,6 +69,7 @@
 #include <linux/time.h>
 #include <linux/slab.h>
 #include <linux/hil.h>
+#include <linux/semaphore.h>
 #include <asm/io.h>
 #include <asm/system.h>
 
diff --git a/drivers/macintosh/adb.c b/drivers/macintosh/adb.c
index 20978205cd02..b8b9e44f7f4e 100644
--- a/drivers/macintosh/adb.c
+++ b/drivers/macintosh/adb.c
@@ -37,7 +37,7 @@
 #include <linux/device.h>
 #include <linux/kthread.h>
 #include <linux/platform_device.h>
-#include <linux/semaphore.h>
+#include <linux/mutex.h>
 
 #include <asm/uaccess.h>
 #ifdef CONFIG_PPC
@@ -102,7 +102,7 @@ static struct adb_handler {
 } adb_handler[16];
 
 /*
- * The adb_handler_sem mutex protects all accesses to the original_address
+ * The adb_handler_mutex mutex protects all accesses to the original_address
  * and handler_id fields of adb_handler[i] for all i, and changes to the
  * handler field.
  * Accesses to the handler field are protected by the adb_handler_lock
@@ -110,7 +110,7 @@ static struct adb_handler {
  * time adb_unregister returns, we know that the old handler isn't being
  * called.
  */
-static DECLARE_MUTEX(adb_handler_sem);
+static DEFINE_MUTEX(adb_handler_mutex);
 static DEFINE_RWLOCK(adb_handler_lock);
 
 #if 0
@@ -355,7 +355,7 @@ do_adb_reset_bus(void)
                 msleep(500);
         }
 
-        down(&adb_handler_sem);
+        mutex_lock(&adb_handler_mutex);
         write_lock_irq(&adb_handler_lock);
         memset(adb_handler, 0, sizeof(adb_handler));
         write_unlock_irq(&adb_handler_lock);
@@ -376,7 +376,7 @@ do_adb_reset_bus(void)
                 if (adb_controller->autopoll)
                         adb_controller->autopoll(autopoll_devs);
         }
-        up(&adb_handler_sem);
+        mutex_unlock(&adb_handler_mutex);
 
         blocking_notifier_call_chain(&adb_client_list,
                 ADB_MSG_POST_RESET, NULL);
@@ -454,7 +454,7 @@ adb_register(int default_id, int handler_id, struct adb_ids *ids,
 {
         int i;
 
-        down(&adb_handler_sem);
+        mutex_lock(&adb_handler_mutex);
         ids->nids = 0;
         for (i = 1; i < 16; i++) {
                 if ((adb_handler[i].original_address == default_id) &&
@@ -472,7 +472,7 @@ adb_register(int default_id, int handler_id, struct adb_ids *ids,
                         ids->id[ids->nids++] = i;
                 }
         }
-        up(&adb_handler_sem);
+        mutex_unlock(&adb_handler_mutex);
         return ids->nids;
 }
 
@@ -481,7 +481,7 @@ adb_unregister(int index)
 {
         int ret = -ENODEV;
 
-        down(&adb_handler_sem);
+        mutex_lock(&adb_handler_mutex);
         write_lock_irq(&adb_handler_lock);
         if (adb_handler[index].handler) {
                 while(adb_handler[index].busy) {
@@ -493,7 +493,7 @@ adb_unregister(int index)
                 adb_handler[index].handler = NULL;
         }
         write_unlock_irq(&adb_handler_lock);
-        up(&adb_handler_sem);
+        mutex_unlock(&adb_handler_mutex);
         return ret;
 }
 
@@ -557,19 +557,19 @@ adb_try_handler_change(int address, int new_id)
 {
         int ret;
 
-        down(&adb_handler_sem);
+        mutex_lock(&adb_handler_mutex);
         ret = try_handler_change(address, new_id);
-        up(&adb_handler_sem);
+        mutex_unlock(&adb_handler_mutex);
         return ret;
 }
 
 int
 adb_get_infos(int address, int *original_address, int *handler_id)
 {
-        down(&adb_handler_sem);
+        mutex_lock(&adb_handler_mutex);
         *original_address = adb_handler[address].original_address;
         *handler_id = adb_handler[address].handler_id;
-        up(&adb_handler_sem);
+        mutex_unlock(&adb_handler_mutex);
 
         return (*original_address != 0);
 }
@@ -628,10 +628,10 @@ do_adb_query(struct adb_request *req)
         case ADB_QUERY_GETDEVINFO:
                 if (req->nbytes < 3)
                         break;
-                down(&adb_handler_sem);
+                mutex_lock(&adb_handler_mutex);
                 req->reply[0] = adb_handler[req->data[2]].original_address;
                 req->reply[1] = adb_handler[req->data[2]].handler_id;
-                up(&adb_handler_sem);
+                mutex_unlock(&adb_handler_mutex);
                 req->complete = 1;
                 req->reply_len = 2;
                 adb_write_done(req);
diff --git a/drivers/macintosh/therm_pm72.c b/drivers/macintosh/therm_pm72.c
index 1e0a69a5e815..ddfb426a9abd 100644
--- a/drivers/macintosh/therm_pm72.c
+++ b/drivers/macintosh/therm_pm72.c
@@ -122,6 +122,7 @@
 #include <linux/kmod.h>
 #include <linux/i2c.h>
 #include <linux/kthread.h>
+#include <linux/mutex.h>
 #include <asm/prom.h>
 #include <asm/machdep.h>
 #include <asm/io.h>
@@ -169,7 +170,7 @@ static int				rackmac;
 static s32                              dimm_output_clamp;
 static int                              fcu_rpm_shift;
 static int                              fcu_tickle_ticks;
-static DECLARE_MUTEX(driver_lock);
+static DEFINE_MUTEX(driver_lock);
 
 /*
  * We have 3 types of CPU PID control. One is "split" old style control
@@ -729,9 +730,9 @@ static void fetch_cpu_pumps_minmax(void)
 static ssize_t show_##name(struct device *dev, struct device_attribute *attr, char *buf)        \
 {                                                               \
         ssize_t r;                                              \
-        down(&driver_lock);                                     \
+        mutex_lock(&driver_lock);                                       \
         r = sprintf(buf, "%d.%03d", FIX32TOPRINT(data));        \
-        up(&driver_lock);                                       \
+        mutex_unlock(&driver_lock);                                     \
         return r;                                               \
 }
 #define BUILD_SHOW_FUNC_INT(name, data)                         \
@@ -1803,11 +1804,11 @@ static int main_control_loop(void *x)
 {
         DBG("main_control_loop started\n");
 
-        down(&driver_lock);
+        mutex_lock(&driver_lock);
 
         if (start_fcu() < 0) {
                 printk(KERN_ERR "kfand: failed to start FCU\n");
-                up(&driver_lock);
+                mutex_unlock(&driver_lock);
                 goto out;
         }
 
@@ -1822,14 +1823,14 @@ static int main_control_loop(void *x)
 
         fcu_tickle_ticks = FCU_TICKLE_TICKS;
 
-        up(&driver_lock);
+        mutex_unlock(&driver_lock);
 
         while (state == state_attached) {
                 unsigned long elapsed, start;
 
                 start = jiffies;
 
-                down(&driver_lock);
+                mutex_lock(&driver_lock);
 
                 /* Tickle the FCU just in case */
                 if (--fcu_tickle_ticks < 0) {
@@ -1861,7 +1862,7 @@ static int main_control_loop(void *x)
                         do_monitor_slots(&slots_state);
                 else
                         do_monitor_drives(&drives_state);
-                up(&driver_lock);
+                mutex_unlock(&driver_lock);
 
                 if (critical_state == 1) {
                         printk(KERN_WARNING "Temperature control detected a critical condition\n");
@@ -2019,13 +2020,13 @@ static void detach_fcu(void)
  */
 static int therm_pm72_attach(struct i2c_adapter *adapter)
 {
-        down(&driver_lock);
+        mutex_lock(&driver_lock);
 
         /* Check state */
         if (state == state_detached)
                 state = state_attaching;
         if (state != state_attaching) {
-                up(&driver_lock);
+                mutex_unlock(&driver_lock);
                 return 0;
         }
 
@@ -2054,7 +2055,7 @@ static int therm_pm72_attach(struct i2c_adapter *adapter)
                 state = state_attached;
                 start_control_loops();
         }
-        up(&driver_lock);
+        mutex_unlock(&driver_lock);
 
         return 0;
 }
@@ -2065,16 +2066,16 @@ static int therm_pm72_attach(struct i2c_adapter *adapter)
  */
 static int therm_pm72_detach(struct i2c_adapter *adapter)
 {
-        down(&driver_lock);
+        mutex_lock(&driver_lock);
 
         if (state != state_detached)
                 state = state_detaching;
 
         /* Stop control loops if any */
         DBG("stopping control loops\n");
-        up(&driver_lock);
+        mutex_unlock(&driver_lock);
         stop_control_loops();
-        down(&driver_lock);
+        mutex_lock(&driver_lock);
 
         if (u3_0 != NULL && !strcmp(adapter->name, "u3 0")) {
                 DBG("lost U3-0, disposing control loops\n");
@@ -2090,7 +2091,7 @@ static int therm_pm72_detach(struct i2c_adapter *adapter)
         if (u3_0 == NULL && u3_1 == NULL)
                 state = state_detached;
 
-        up(&driver_lock);
+        mutex_unlock(&driver_lock);
 
         return 0;
 }
diff --git a/drivers/macintosh/windfarm_smu_sat.c b/drivers/macintosh/windfarm_smu_sat.c
index 797918d0e59c..7f2be4baaeda 100644
--- a/drivers/macintosh/windfarm_smu_sat.c
+++ b/drivers/macintosh/windfarm_smu_sat.c
@@ -13,7 +13,7 @@
 #include <linux/init.h>
 #include <linux/wait.h>
 #include <linux/i2c.h>
-#include <linux/semaphore.h>
+#include <linux/mutex.h>
 #include <asm/prom.h>
 #include <asm/smu.h>
 #include <asm/pmac_low_i2c.h>
@@ -36,7 +36,7 @@
 struct wf_sat {
         int                     nr;
         atomic_t                refcnt;
-        struct semaphore        mutex;
+        struct mutex            mutex;
         unsigned long           last_read; /* jiffies when cache last updated */
         u8                      cache[16];
         struct i2c_client       i2c;
@@ -163,7 +163,7 @@ static int wf_sat_get(struct wf_sensor *sr, s32 *value)
         if (sat->i2c.adapter == NULL)
                 return -ENODEV;
 
-        down(&sat->mutex);
+        mutex_lock(&sat->mutex);
         if (time_after(jiffies, (sat->last_read + MAX_AGE))) {
                 err = wf_sat_read_cache(sat);
                 if (err)
@@ -182,7 +182,7 @@ static int wf_sat_get(struct wf_sensor *sr, s32 *value)
         err = 0;
 
  fail:
-        up(&sat->mutex);
+        mutex_unlock(&sat->mutex);
         return err;
 }
 
@@ -233,7 +233,7 @@ static void wf_sat_create(struct i2c_adapter *adapter, struct device_node *dev)
         sat->nr = -1;
         sat->node = of_node_get(dev);
         atomic_set(&sat->refcnt, 0);
-        init_MUTEX(&sat->mutex);
+        mutex_init(&sat->mutex);
         sat->i2c.addr = (addr >> 1) & 0x7f;
         sat->i2c.adapter = adapter;
         sat->i2c.driver = &wf_sat_driver;
diff --git a/drivers/md/raid10.c b/drivers/md/raid10.c
index 5938fa962922..faf3d8912979 100644
--- a/drivers/md/raid10.c
+++ b/drivers/md/raid10.c
@@ -886,7 +886,7 @@ static int make_request(struct request_queue *q, struct bio * bio)
          */
         raid10_find_phys(conf, r10_bio);
  retry_write:
-        blocked_rdev = 0;
+        blocked_rdev = NULL;
         rcu_read_lock();
         for (i = 0;  i < conf->copies; i++) {
                 int d = r10_bio->devs[i].devnum;
diff --git a/drivers/media/Makefile b/drivers/media/Makefile
index 73f742c7e818..cc11c4c0e7e7 100644
--- a/drivers/media/Makefile
+++ b/drivers/media/Makefile
@@ -2,6 +2,8 @@
 # Makefile for the kernel multimedia device drivers.
 #
 
+obj-y := common/
+
 obj-$(CONFIG_VIDEO_MEDIA) += common/
 
 # Since hybrid devices are here, should be compiled if DVB and/or V4L
diff --git a/drivers/media/video/cx18/cx18-driver.c b/drivers/media/video/cx18/cx18-driver.c
index 8f5ed9b4bf83..3f55d47bc4b9 100644
--- a/drivers/media/video/cx18/cx18-driver.c
+++ b/drivers/media/video/cx18/cx18-driver.c
@@ -613,7 +613,7 @@ static int __devinit cx18_probe(struct pci_dev *dev,
         }
 
         cx = kzalloc(sizeof(struct cx18), GFP_ATOMIC);
-        if (cx == 0) {
+        if (!cx) {
                 spin_unlock(&cx18_cards_lock);
                 return -ENOMEM;
         }
diff --git a/drivers/media/video/saa7134/saa7134-video.c b/drivers/media/video/saa7134/saa7134-video.c
index a0baf2d0ba7f..48e1a01718ec 100644
--- a/drivers/media/video/saa7134/saa7134-video.c
+++ b/drivers/media/video/saa7134/saa7134-video.c
@@ -1634,7 +1634,7 @@ static int saa7134_s_fmt_overlay(struct file *file, void *priv,
         struct saa7134_fh *fh = priv;
         struct saa7134_dev *dev = fh->dev;
         int err;
-        unsigned int flags;
+        unsigned long flags;
 
         if (saa7134_no_overlay > 0) {
                 printk(KERN_ERR "V4L2_BUF_TYPE_VIDEO_OVERLAY: no_overlay\n");
diff --git a/drivers/misc/kgdbts.c b/drivers/misc/kgdbts.c
index 30a1af857c7a..fa394104339c 100644
--- a/drivers/misc/kgdbts.c
+++ b/drivers/misc/kgdbts.c
@@ -47,6 +47,7 @@
  *       to test the HW NMI watchdog
  * F## = Break at do_fork for ## iterations
  * S## = Break at sys_open for ## iterations
+ * I## = Run the single step test ## iterations
  *
  * NOTE: that the do_fork and sys_open tests are mutually exclusive.
  *
@@ -375,7 +376,7 @@ static void emul_sstep_get(char *arg)
                 break;
         case 1:
                 /* set breakpoint */
-                break_helper("Z0", 0, sstep_addr);
+                break_helper("Z0", NULL, sstep_addr);
                 break;
         case 2:
                 /* Continue */
@@ -383,7 +384,7 @@ static void emul_sstep_get(char *arg)
                 break;
         case 3:
                 /* Clear breakpoint */
-                break_helper("z0", 0, sstep_addr);
+                break_helper("z0", NULL, sstep_addr);
                 break;
         default:
                 eprintk("kgdbts: ERROR failed sstep get emulation\n");
@@ -465,11 +466,11 @@ static struct test_struct sw_breakpoint_test[] = {
         { "?", "S0*" }, /* Clear break points */
         { "kgdbts_break_test", "OK", sw_break, }, /* set sw breakpoint */
         { "c", "T0*", }, /* Continue */
-        { "g", "kgdbts_break_test", 0, check_and_rewind_pc },
+        { "g", "kgdbts_break_test", NULL, check_and_rewind_pc },
         { "write", "OK", write_regs },
         { "kgdbts_break_test", "OK", sw_rem_break }, /*remove breakpoint */
         { "D", "OK" }, /* Detach */
-        { "D", "OK", 0,  got_break }, /* If the test worked we made it here */
+        { "D", "OK", NULL,  got_break }, /* On success we made it here */
         { "", "" },
 };
 
@@ -499,14 +500,14 @@ static struct test_struct singlestep_break_test[] = {
         { "?", "S0*" }, /* Clear break points */
         { "kgdbts_break_test", "OK", sw_break, }, /* set sw breakpoint */
         { "c", "T0*", }, /* Continue */
-        { "g", "kgdbts_break_test", 0, check_and_rewind_pc },
+        { "g", "kgdbts_break_test", NULL, check_and_rewind_pc },
         { "write", "OK", write_regs }, /* Write registers */
         { "kgdbts_break_test", "OK", sw_rem_break }, /*remove breakpoint */
         { "s", "T0*", emul_sstep_get, emul_sstep_put }, /* Single step */
-        { "g", "kgdbts_break_test", 0, check_single_step },
+        { "g", "kgdbts_break_test", NULL, check_single_step },
         { "kgdbts_break_test", "OK", sw_break, }, /* set sw breakpoint */
         { "c", "T0*", }, /* Continue */
-        { "g", "kgdbts_break_test", 0, check_and_rewind_pc },
+        { "g", "kgdbts_break_test", NULL, check_and_rewind_pc },
         { "write", "OK", write_regs }, /* Write registers */
         { "D", "OK" }, /* Remove all breakpoints and continues */
         { "", "" },
@@ -520,14 +521,14 @@ static struct test_struct do_fork_test[] = {
         { "?", "S0*" }, /* Clear break points */
         { "do_fork", "OK", sw_break, }, /* set sw breakpoint */
         { "c", "T0*", }, /* Continue */
-        { "g", "do_fork", 0, check_and_rewind_pc }, /* check location */
+        { "g", "do_fork", NULL, check_and_rewind_pc }, /* check location */
         { "write", "OK", write_regs }, /* Write registers */
         { "do_fork", "OK", sw_rem_break }, /*remove breakpoint */
         { "s", "T0*", emul_sstep_get, emul_sstep_put }, /* Single step */
-        { "g", "do_fork", 0, check_single_step },
+        { "g", "do_fork", NULL, check_single_step },
         { "do_fork", "OK", sw_break, }, /* set sw breakpoint */
         { "7", "T0*", skip_back_repeat_test }, /* Loop based on repeat_test */
-        { "D", "OK", 0, final_ack_set }, /* detach and unregister I/O */
+        { "D", "OK", NULL, final_ack_set }, /* detach and unregister I/O */
         { "", "" },
 };
 
@@ -538,14 +539,14 @@ static struct test_struct sys_open_test[] = {
         { "?", "S0*" }, /* Clear break points */
         { "sys_open", "OK", sw_break, }, /* set sw breakpoint */
         { "c", "T0*", }, /* Continue */
-        { "g", "sys_open", 0, check_and_rewind_pc }, /* check location */
+        { "g", "sys_open", NULL, check_and_rewind_pc }, /* check location */
         { "write", "OK", write_regs }, /* Write registers */
         { "sys_open", "OK", sw_rem_break }, /*remove breakpoint */
         { "s", "T0*", emul_sstep_get, emul_sstep_put }, /* Single step */
-        { "g", "sys_open", 0, check_single_step },
+        { "g", "sys_open", NULL, check_single_step },
         { "sys_open", "OK", sw_break, }, /* set sw breakpoint */
         { "7", "T0*", skip_back_repeat_test }, /* Loop based on repeat_test */
-        { "D", "OK", 0, final_ack_set }, /* detach and unregister I/O */
+        { "D", "OK", NULL, final_ack_set }, /* detach and unregister I/O */
         { "", "" },
 };
 
@@ -556,11 +557,11 @@ static struct test_struct hw_breakpoint_test[] = {
         { "?", "S0*" }, /* Clear break points */
         { "kgdbts_break_test", "OK", hw_break, }, /* set hw breakpoint */
         { "c", "T0*", }, /* Continue */
-        { "g", "kgdbts_break_test", 0, check_and_rewind_pc },
+        { "g", "kgdbts_break_test", NULL, check_and_rewind_pc },
         { "write", "OK", write_regs },
         { "kgdbts_break_test", "OK", hw_rem_break }, /*remove breakpoint */
         { "D", "OK" }, /* Detach */
-        { "D", "OK", 0,  got_break }, /* If the test worked we made it here */
+        { "D", "OK", NULL,  got_break }, /* On success we made it here */
         { "", "" },
 };
 
@@ -570,12 +571,12 @@ static struct test_struct hw_breakpoint_test[] = {
 static struct test_struct hw_write_break_test[] = {
         { "?", "S0*" }, /* Clear break points */
         { "hw_break_val", "OK", hw_write_break, }, /* set hw breakpoint */
-        { "c", "T0*", 0, got_break }, /* Continue */
-        { "g", "silent", 0, check_and_rewind_pc },
+        { "c", "T0*", NULL, got_break }, /* Continue */
+        { "g", "silent", NULL, check_and_rewind_pc },
         { "write", "OK", write_regs },
         { "hw_break_val", "OK", hw_rem_write_break }, /*remove breakpoint */
         { "D", "OK" }, /* Detach */
-        { "D", "OK", 0,  got_break }, /* If the test worked we made it here */
+        { "D", "OK", NULL,  got_break }, /* On success we made it here */
         { "", "" },
 };
 
@@ -585,12 +586,12 @@ static struct test_struct hw_write_break_test[] = {
 static struct test_struct hw_access_break_test[] = {
         { "?", "S0*" }, /* Clear break points */
         { "hw_break_val", "OK", hw_access_break, }, /* set hw breakpoint */
-        { "c", "T0*", 0, got_break }, /* Continue */
-        { "g", "silent", 0, check_and_rewind_pc },
+        { "c", "T0*", NULL, got_break }, /* Continue */
+        { "g", "silent", NULL, check_and_rewind_pc },
         { "write", "OK", write_regs },
         { "hw_break_val", "OK", hw_rem_access_break }, /*remove breakpoint */
         { "D", "OK" }, /* Detach */
-        { "D", "OK", 0,  got_break }, /* If the test worked we made it here */
+        { "D", "OK", NULL,  got_break }, /* On success we made it here */
         { "", "" },
 };
 
@@ -599,9 +600,9 @@ static struct test_struct hw_access_break_test[] = {
  */
 static struct test_struct nmi_sleep_test[] = {
         { "?", "S0*" }, /* Clear break points */
-        { "c", "T0*", 0, got_break }, /* Continue */
+        { "c", "T0*", NULL, got_break }, /* Continue */
         { "D", "OK" }, /* Detach */
-        { "D", "OK", 0,  got_break }, /* If the test worked we made it here */
+        { "D", "OK", NULL,  got_break }, /* On success we made it here */
         { "", "" },
 };
 
@@ -874,18 +875,23 @@ static void kgdbts_run_tests(void)
 {
         char *ptr;
         int fork_test = 0;
-        int sys_open_test = 0;
+        int do_sys_open_test = 0;
+        int sstep_test = 1000;
         int nmi_sleep = 0;
+        int i;
 
         ptr = strstr(config, "F");
         if (ptr)
-                fork_test = simple_strtol(ptr+1, NULL, 10);
+                fork_test = simple_strtol(ptr + 1, NULL, 10);
         ptr = strstr(config, "S");
         if (ptr)
-                sys_open_test = simple_strtol(ptr+1, NULL, 10);
+                do_sys_open_test = simple_strtol(ptr + 1, NULL, 10);
         ptr = strstr(config, "N");
         if (ptr)
                 nmi_sleep = simple_strtol(ptr+1, NULL, 10);
+        ptr = strstr(config, "I");
+        if (ptr)
+                sstep_test = simple_strtol(ptr+1, NULL, 10);
 
         /* required internal KGDB tests */
         v1printk("kgdbts:RUN plant and detach test\n");
@@ -894,8 +900,13 @@ static void kgdbts_run_tests(void)
         run_breakpoint_test(0);
         v1printk("kgdbts:RUN bad memory access test\n");
         run_bad_read_test();
-        v1printk("kgdbts:RUN singlestep breakpoint test\n");
-        run_singlestep_break_test();
+        v1printk("kgdbts:RUN singlestep test %i iterations\n", sstep_test);
+        for (i = 0; i < sstep_test; i++) {
+                run_singlestep_break_test();
+                if (i % 100 == 0)
+                        v1printk("kgdbts:RUN singlestep [%i/%i]\n",
+                                 i, sstep_test);
+        }
 
         /* ===Optional tests=== */
 
@@ -922,7 +933,7 @@ static void kgdbts_run_tests(void)
                 repeat_test = fork_test;
                 printk(KERN_INFO "kgdbts:RUN do_fork for %i breakpoints\n",
                         repeat_test);
-                kthread_run(kgdbts_unreg_thread, 0, "kgdbts_unreg");
+                kthread_run(kgdbts_unreg_thread, NULL, "kgdbts_unreg");
                 run_do_fork_test();
                 return;
         }
@@ -931,11 +942,11 @@ static void kgdbts_run_tests(void)
          * executed because a kernel thread will be spawned at the very
          * end to unregister the debug hooks.
          */
-        if (sys_open_test) {
-                repeat_test = sys_open_test;
+        if (do_sys_open_test) {
+                repeat_test = do_sys_open_test;
                 printk(KERN_INFO "kgdbts:RUN sys_open for %i breakpoints\n",
                         repeat_test);
-                kthread_run(kgdbts_unreg_thread, 0, "kgdbts_unreg");
+                kthread_run(kgdbts_unreg_thread, NULL, "kgdbts_unreg");
                 run_sys_open_test();
                 return;
         }
diff --git a/drivers/net/3c59x.c b/drivers/net/3c59x.c
index 6f8e7d4cf74d..2edda8cc7f99 100644
--- a/drivers/net/3c59x.c
+++ b/drivers/net/3c59x.c
@@ -319,7 +319,7 @@ static struct vortex_chip_info {
         {"3c920B-EMB-WNM (ATI Radeon 9100 IGP)",
          PCI_USES_MASTER, IS_TORNADO|HAS_MII|HAS_HWCKSM, 128, },
         {"3c980 Cyclone",
-         PCI_USES_MASTER, IS_CYCLONE|HAS_HWCKSM, 128, },
+         PCI_USES_MASTER, IS_CYCLONE|HAS_HWCKSM|EXTRA_PREAMBLE, 128, },
 
         {"3c980C Python-T",
          PCI_USES_MASTER, IS_CYCLONE|HAS_NWAY|HAS_HWCKSM, 128, },
@@ -600,7 +600,6 @@ struct vortex_private {
         struct sk_buff* tx_skbuff[TX_RING_SIZE];
         unsigned int cur_rx, cur_tx;            /* The next free ring entry */
         unsigned int dirty_rx, dirty_tx;        /* The ring entries to be free()ed. */
-        struct net_device_stats stats;          /* Generic stats */
         struct vortex_extra_stats xstats;       /* NIC-specific extra stats */
         struct sk_buff *tx_skb;                         /* Packet being eaten by bus master ctrl.  */
         dma_addr_t tx_skb_dma;                          /* Allocated DMA address for bus master ctrl DMA.   */
@@ -1875,7 +1874,7 @@ static void vortex_tx_timeout(struct net_device *dev)
 
         issue_and_wait(dev, TxReset);
 
-        vp->stats.tx_errors++;
+        dev->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  &&  ioread32(ioaddr + DownListPtr) == 0)
@@ -1887,7 +1886,7 @@ static void vortex_tx_timeout(struct net_device *dev)
                         iowrite8(PKT_BUF_SZ>>8, ioaddr + TxFreeThreshold);
                 iowrite16(DownUnstall, ioaddr + EL3_CMD);
         } else {
-                vp->stats.tx_dropped++;
+                dev->stats.tx_dropped++;
                 netif_wake_queue(dev);
         }
 
@@ -1928,8 +1927,8 @@ vortex_error(struct net_device *dev, int status)
                         }
                         dump_tx_ring(dev);
                 }
-                if (tx_status & 0x14)  vp->stats.tx_fifo_errors++;
-                if (tx_status & 0x38)  vp->stats.tx_aborted_errors++;
+                if (tx_status & 0x14)  dev->stats.tx_fifo_errors++;
+                if (tx_status & 0x38)  dev->stats.tx_aborted_errors++;
                 if (tx_status & 0x08)  vp->xstats.tx_max_collisions++;
                 iowrite8(0, ioaddr + TxStatus);
                 if (tx_status & 0x30) {                 /* txJabber or txUnderrun */
@@ -2051,8 +2050,8 @@ vortex_start_xmit(struct sk_buff *skb, struct net_device *dev)
                                 if (vortex_debug > 2)
                                   printk(KERN_DEBUG "%s: Tx error, status %2.2x.\n",
                                                  dev->name, tx_status);
-                                if (tx_status & 0x04) vp->stats.tx_fifo_errors++;
-                                if (tx_status & 0x38) vp->stats.tx_aborted_errors++;
+                                if (tx_status & 0x04) dev->stats.tx_fifo_errors++;
+                                if (tx_status & 0x38) dev->stats.tx_aborted_errors++;
                                 if (tx_status & 0x30) {
                                         issue_and_wait(dev, TxReset);
                                 }
@@ -2350,7 +2349,7 @@ boomerang_interrupt(int irq, void *dev_id)
                                 } else {
                                         printk(KERN_DEBUG "boomerang_interrupt: no skb!\n");
                                 }
-                                /* vp->stats.tx_packets++;  Counted below. */
+                                /* dev->stats.tx_packets++;  Counted below. */
                                 dirty_tx++;
                         }
                         vp->dirty_tx = dirty_tx;
@@ -2409,12 +2408,12 @@ static int vortex_rx(struct net_device *dev)
                         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++;
-                        if (rx_error & 0x01)  vp->stats.rx_over_errors++;
-                        if (rx_error & 0x02)  vp->stats.rx_length_errors++;
-                        if (rx_error & 0x04)  vp->stats.rx_frame_errors++;
-                        if (rx_error & 0x08)  vp->stats.rx_crc_errors++;
-                        if (rx_error & 0x10)  vp->stats.rx_length_errors++;
+                        dev->stats.rx_errors++;
+                        if (rx_error & 0x01)  dev->stats.rx_over_errors++;
+                        if (rx_error & 0x02)  dev->stats.rx_length_errors++;
+                        if (rx_error & 0x04)  dev->stats.rx_frame_errors++;
+                        if (rx_error & 0x08)  dev->stats.rx_crc_errors++;
+                        if (rx_error & 0x10)  dev->stats.rx_length_errors++;
                 } else {
                         /* The packet length: up to 4.5K!. */
                         int pkt_len = rx_status & 0x1fff;
@@ -2446,7 +2445,7 @@ static int vortex_rx(struct net_device *dev)
                                 skb->protocol = eth_type_trans(skb, dev);
                                 netif_rx(skb);
                                 dev->last_rx = jiffies;
-                                vp->stats.rx_packets++;
+                                dev->stats.rx_packets++;
                                 /* Wait a limited time to go to next packet. */
                                 for (i = 200; i >= 0; i--)
                                         if ( ! (ioread16(ioaddr + EL3_STATUS) & CmdInProgress))
@@ -2455,7 +2454,7 @@ static int vortex_rx(struct net_device *dev)
                         } 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++;
+                        dev->stats.rx_dropped++;
                 }
                 issue_and_wait(dev, RxDiscard);
         }
@@ -2482,12 +2481,12 @@ boomerang_rx(struct net_device *dev)
                         unsigned char rx_error = rx_status >> 16;
                         if (vortex_debug > 2)
                                 printk(KERN_DEBUG " Rx error: status %2.2x.\n", rx_error);
-                        vp->stats.rx_errors++;
-                        if (rx_error & 0x01)  vp->stats.rx_over_errors++;
-                        if (rx_error & 0x02)  vp->stats.rx_length_errors++;
-                        if (rx_error & 0x04)  vp->stats.rx_frame_errors++;
-                        if (rx_error & 0x08)  vp->stats.rx_crc_errors++;
-                        if (rx_error & 0x10)  vp->stats.rx_length_errors++;
+                        dev->stats.rx_errors++;
+                        if (rx_error & 0x01)  dev->stats.rx_over_errors++;
+                        if (rx_error & 0x02)  dev->stats.rx_length_errors++;
+                        if (rx_error & 0x04)  dev->stats.rx_frame_errors++;
+                        if (rx_error & 0x08)  dev->stats.rx_crc_errors++;
+                        if (rx_error & 0x10)  dev->stats.rx_length_errors++;
                 } else {
                         /* The packet length: up to 4.5K!. */
                         int pkt_len = rx_status & 0x1fff;
@@ -2529,7 +2528,7 @@ boomerang_rx(struct net_device *dev)
                         }
                         netif_rx(skb);
                         dev->last_rx = jiffies;
-                        vp->stats.rx_packets++;
+                        dev->stats.rx_packets++;
                 }
                 entry = (++vp->cur_rx) % RX_RING_SIZE;
         }
@@ -2591,7 +2590,7 @@ vortex_down(struct net_device *dev, int final_down)
         del_timer_sync(&vp->rx_oom_timer);
         del_timer_sync(&vp->timer);
 
-        /* Turn off statistics ASAP.  We update vp->stats below. */
+        /* Turn off statistics ASAP.  We update dev->stats below. */
         iowrite16(StatsDisable, ioaddr + EL3_CMD);
 
         /* Disable the receiver and transmitter. */
@@ -2728,7 +2727,7 @@ static struct net_device_stats *vortex_get_stats(struct net_device *dev)
                 update_stats(ioaddr, dev);
                 spin_unlock_irqrestore (&vp->lock, flags);
         }
-        return &vp->stats;
+        return &dev->stats;
 }
 
 /*  Update statistics.
@@ -2748,18 +2747,18 @@ static void update_stats(void __iomem *ioaddr, struct net_device *dev)
         /* 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             += 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;
+        dev->stats.tx_carrier_errors            += ioread8(ioaddr + 0);
+        dev->stats.tx_heartbeat_errors          += ioread8(ioaddr + 1);
+        dev->stats.tx_window_errors             += ioread8(ioaddr + 4);
+        dev->stats.rx_fifo_errors               += ioread8(ioaddr + 5);
+        dev->stats.tx_packets                   += ioread8(ioaddr + 6);
+        dev->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                      += ioread16(ioaddr + 10);
-        vp->stats.tx_bytes                      += ioread16(ioaddr + 12);
+        dev->stats.rx_bytes                     += ioread16(ioaddr + 10);
+        dev->stats.tx_bytes                     += ioread16(ioaddr + 12);
         /* Extra stats for get_ethtool_stats() */
         vp->xstats.tx_multiple_collisions       += ioread8(ioaddr + 2);
         vp->xstats.tx_single_collisions         += ioread8(ioaddr + 3);
@@ -2767,14 +2766,14 @@ static void update_stats(void __iomem *ioaddr, struct net_device *dev)
         EL3WINDOW(4);
         vp->xstats.rx_bad_ssd                   += ioread8(ioaddr + 12);
 
-        vp->stats.collisions = vp->xstats.tx_multiple_collisions
+        dev->stats.collisions = vp->xstats.tx_multiple_collisions
                 + vp->xstats.tx_single_collisions
                 + vp->xstats.tx_max_collisions;
 
         {
                 u8 up = ioread8(ioaddr + 13);
-                vp->stats.rx_bytes += (up & 0x0f) << 16;
-                vp->stats.tx_bytes += (up & 0xf0) << 12;
+                dev->stats.rx_bytes += (up & 0x0f) << 16;
+                dev->stats.tx_bytes += (up & 0xf0) << 12;
         }
 
         EL3WINDOW(old_window >> 13);
diff --git a/drivers/net/Kconfig b/drivers/net/Kconfig
index af46341827f2..d27f54a2df77 100644
--- a/drivers/net/Kconfig
+++ b/drivers/net/Kconfig
@@ -1273,20 +1273,6 @@ config PCNET32
           To compile this driver as a module, choose M here. The module
           will be called pcnet32.
 
-config PCNET32_NAPI
-        bool "Use RX polling (NAPI)"
-        depends on PCNET32
-        help
-          NAPI is a new driver API designed to reduce CPU and interrupt load
-          when the driver is receiving lots of packets from the card. It is
-          still somewhat experimental and thus not yet enabled by default.
-
-          If your estimated Rx load is 10kpps or more, or if the card will be
-          deployed on potentially unfriendly networks (e.g. in a firewall),
-          then say Y here.
-
-          If in doubt, say N.
-
 config AMD8111_ETH
         tristate "AMD 8111 (new PCI lance) support"
         depends on NET_PCI && PCI
diff --git a/drivers/net/appletalk/cops.c b/drivers/net/appletalk/cops.c
index 82e9a5bd0dd2..a0b4c8516073 100644
--- a/drivers/net/appletalk/cops.c
+++ b/drivers/net/appletalk/cops.c
@@ -499,19 +499,13 @@ static void cops_reset(struct net_device *dev, int sleep)
         {
                 outb(0, ioaddr+DAYNA_RESET);    /* Assert the reset port */
                 inb(ioaddr+DAYNA_RESET);        /* Clear the reset */
-                if(sleep)
-                {
-                        long snap=jiffies;
-
-                        /* Let card finish initializing, about 1/3 second */
-                        while (time_before(jiffies, snap + HZ/3))
-                                schedule();
-                }
-                else
-                        mdelay(333);
+                if (sleep)
+                        msleep(333);
+                else
+                        mdelay(333);
         }
+
         netif_wake_queue(dev);
-        return;
 }
 
 static void cops_load (struct net_device *dev)
diff --git a/drivers/net/bonding/bond_main.c b/drivers/net/bonding/bond_main.c
index 6425603bc379..50a40e433154 100644
--- a/drivers/net/bonding/bond_main.c
+++ b/drivers/net/bonding/bond_main.c
@@ -1425,13 +1425,13 @@ int bond_enslave(struct net_device *bond_dev, struct net_device *slave_dev)
         res = netdev_set_master(slave_dev, bond_dev);
         if (res) {
                 dprintk("Error %d calling netdev_set_master\n", res);
-                goto err_close;
+                goto err_restore_mac;
         }
         /* open the slave since the application closed it */
         res = dev_open(slave_dev);
         if (res) {
                 dprintk("Openning slave %s failed\n", slave_dev->name);
-                goto err_restore_mac;
+                goto err_unset_master;
         }
 
         new_slave->dev = slave_dev;
@@ -1444,7 +1444,7 @@ int bond_enslave(struct net_device *bond_dev, struct net_device *slave_dev)
                  */
                 res = bond_alb_init_slave(bond, new_slave);
                 if (res) {
-                        goto err_unset_master;
+                        goto err_close;
                 }
         }
 
@@ -1619,7 +1619,7 @@ int bond_enslave(struct net_device *bond_dev, struct net_device *slave_dev)
 
         res = bond_create_slave_symlinks(bond_dev, slave_dev);
         if (res)
-                goto err_unset_master;
+                goto err_close;
 
         printk(KERN_INFO DRV_NAME
                ": %s: enslaving %s as a%s interface with a%s link.\n",
@@ -1631,12 +1631,12 @@ int bond_enslave(struct net_device *bond_dev, struct net_device *slave_dev)
         return 0;
 
 /* Undo stages on error */
-err_unset_master:
-        netdev_set_master(slave_dev, NULL);
-
 err_close:
         dev_close(slave_dev);
 
+err_unset_master:
+        netdev_set_master(slave_dev, NULL);
+
 err_restore_mac:
         if (!bond->params.fail_over_mac) {
                 memcpy(addr.sa_data, new_slave->perm_hwaddr, ETH_ALEN);
@@ -4936,7 +4936,9 @@ int bond_create(char *name, struct bond_params *params, struct bonding **newbond
         if (res < 0) {
                 rtnl_lock();
                 down_write(&bonding_rwsem);
-                goto out_bond;
+                bond_deinit(bond_dev);
+                unregister_netdevice(bond_dev);
+                goto out_rtnl;
         }
 
         return 0;
@@ -4990,9 +4992,10 @@ err:
                 destroy_workqueue(bond->wq);
         }
 
+        bond_destroy_sysfs();
+
         rtnl_lock();
         bond_free_all();
-        bond_destroy_sysfs();
         rtnl_unlock();
 out:
         return res;
@@ -5004,9 +5007,10 @@ static void __exit bonding_exit(void)
         unregister_netdevice_notifier(&bond_netdev_notifier);
         unregister_inetaddr_notifier(&bond_inetaddr_notifier);
 
+        bond_destroy_sysfs();
+
         rtnl_lock();
         bond_free_all();
-        bond_destroy_sysfs();
         rtnl_unlock();
 }
 
diff --git a/drivers/net/bonding/bond_sysfs.c b/drivers/net/bonding/bond_sysfs.c
index 979c2d05ff9c..68c41a00d93d 100644
--- a/drivers/net/bonding/bond_sysfs.c
+++ b/drivers/net/bonding/bond_sysfs.c
@@ -146,29 +146,29 @@ static ssize_t bonding_store_bonds(struct class *cls, const char *buffer, size_t
                                                 ": Unable remove bond %s due to open references.\n",
                                                 ifname);
                                         res = -EPERM;
-                                        goto out;
+                                        goto out_unlock;
                                 }
                                 printk(KERN_INFO DRV_NAME
                                         ": %s is being deleted...\n",
                                         bond->dev->name);
                                 bond_destroy(bond);
-                                up_write(&bonding_rwsem);
-                                rtnl_unlock();
-                                goto out;
+                                goto out_unlock;
                         }
 
                 printk(KERN_ERR DRV_NAME
                         ": unable to delete non-existent bond %s\n", ifname);
                 res = -ENODEV;
-                up_write(&bonding_rwsem);
-                rtnl_unlock();
-                goto out;
+                goto out_unlock;
         }
 
 err_no_cmd:
         printk(KERN_ERR DRV_NAME
                 ": no command found in bonding_masters. Use +ifname or -ifname.\n");
-        res = -EPERM;
+        return -EPERM;
+
+out_unlock:
+        up_write(&bonding_rwsem);
+        rtnl_unlock();
 
         /* Always return either count or an error.  If you return 0, you'll
          * get called forever, which is bad.
diff --git a/drivers/net/cxgb3/cxgb3_main.c b/drivers/net/cxgb3/cxgb3_main.c
index 05e5f59e87fa..ce949d5fae39 100644
--- a/drivers/net/cxgb3/cxgb3_main.c
+++ b/drivers/net/cxgb3/cxgb3_main.c
@@ -1894,11 +1894,11 @@ static int cxgb_extension_ioctl(struct net_device *dev, void __user *useraddr)
                 u8 *fw_data;
                 struct ch_mem_range t;
 
-                if (!capable(CAP_NET_ADMIN))
+                if (!capable(CAP_SYS_RAWIO))
                         return -EPERM;
                 if (copy_from_user(&t, useraddr, sizeof(t)))
                         return -EFAULT;
-
+                /* Check t.len sanity ? */
                 fw_data = kmalloc(t.len, GFP_KERNEL);
                 if (!fw_data)
                         return -ENOMEM;
diff --git a/drivers/net/e1000e/defines.h b/drivers/net/e1000e/defines.h
index 2a53875cddbf..f823b8ba5785 100644
--- a/drivers/net/e1000e/defines.h
+++ b/drivers/net/e1000e/defines.h
@@ -648,6 +648,8 @@
 #define IFE_E_PHY_ID         0x02A80330
 #define IFE_PLUS_E_PHY_ID    0x02A80320
 #define IFE_C_E_PHY_ID       0x02A80310
+#define BME1000_E_PHY_ID     0x01410CB0
+#define BME1000_E_PHY_ID_R2  0x01410CB1
 
 /* M88E1000 Specific Registers */
 #define M88E1000_PHY_SPEC_CTRL     0x10  /* PHY Specific Control Register */
@@ -701,6 +703,14 @@
 #define M88EC018_EPSCR_DOWNSHIFT_COUNTER_MASK  0x0E00
 #define M88EC018_EPSCR_DOWNSHIFT_COUNTER_5X    0x0800
 
+/* BME1000 PHY Specific Control Register */
+#define BME1000_PSCR_ENABLE_DOWNSHIFT   0x0800 /* 1 = enable downshift */
+
+
+#define PHY_PAGE_SHIFT 5
+#define PHY_REG(page, reg) (((page) << PHY_PAGE_SHIFT) | \
+                           ((reg) & MAX_PHY_REG_ADDRESS))
+
 /*
  * Bits...
  * 15-5: page
diff --git a/drivers/net/e1000e/e1000.h b/drivers/net/e1000e/e1000.h
index 38bfd0d261fe..d3bc6f8101fa 100644
--- a/drivers/net/e1000e/e1000.h
+++ b/drivers/net/e1000e/e1000.h
@@ -127,7 +127,7 @@ struct e1000_buffer {
                 /* arrays of page information for packet split */
                 struct e1000_ps_page *ps_pages;
         };
-
+        struct page *page;
 };
 
 struct e1000_ring {
@@ -304,6 +304,7 @@ struct e1000_info {
 #define FLAG_HAS_CTRLEXT_ON_LOAD          (1 << 5)
 #define FLAG_HAS_SWSM_ON_LOAD             (1 << 6)
 #define FLAG_HAS_JUMBO_FRAMES             (1 << 7)
+#define FLAG_IS_ICH                       (1 << 9)
 #define FLAG_HAS_SMART_POWER_DOWN         (1 << 11)
 #define FLAG_IS_QUAD_PORT_A               (1 << 12)
 #define FLAG_IS_QUAD_PORT                 (1 << 13)
@@ -386,6 +387,7 @@ extern void e1000e_set_kmrn_lock_loss_workaround_ich8lan(struct e1000_hw *hw,
                                                  bool state);
 extern void e1000e_igp3_phy_powerdown_workaround_ich8lan(struct e1000_hw *hw);
 extern void e1000e_gig_downshift_workaround_ich8lan(struct e1000_hw *hw);
+extern void e1000e_disable_gig_wol_ich8lan(struct e1000_hw *hw);
 
 extern s32 e1000e_check_for_copper_link(struct e1000_hw *hw);
 extern s32 e1000e_check_for_fiber_link(struct e1000_hw *hw);
@@ -443,6 +445,9 @@ extern s32 e1000e_get_phy_info_m88(struct e1000_hw *hw);
 extern s32 e1000e_read_phy_reg_m88(struct e1000_hw *hw, u32 offset, u16 *data);
 extern s32 e1000e_write_phy_reg_m88(struct e1000_hw *hw, u32 offset, u16 data);
 extern enum e1000_phy_type e1000e_get_phy_type_from_id(u32 phy_id);
+extern s32 e1000e_determine_phy_address(struct e1000_hw *hw);
+extern s32 e1000e_write_phy_reg_bm(struct e1000_hw *hw, u32 offset, u16 data);
+extern s32 e1000e_read_phy_reg_bm(struct e1000_hw *hw, u32 offset, u16 *data);
 extern void e1000e_phy_force_speed_duplex_setup(struct e1000_hw *hw, u16 *phy_ctrl);
 extern s32 e1000e_write_kmrn_reg(struct e1000_hw *hw, u32 offset, u16 data);
 extern s32 e1000e_read_kmrn_reg(struct e1000_hw *hw, u32 offset, u16 *data);
diff --git a/drivers/net/e1000e/ethtool.c b/drivers/net/e1000e/ethtool.c
index ce045acce63e..a14561f40db0 100644
--- a/drivers/net/e1000e/ethtool.c
+++ b/drivers/net/e1000e/ethtool.c
@@ -494,8 +494,12 @@ static int e1000_get_eeprom(struct net_device *netdev,
                 for (i = 0; i < last_word - first_word + 1; i++) {
                         ret_val = e1000_read_nvm(hw, first_word + i, 1,
                                                       &eeprom_buff[i]);
-                        if (ret_val)
+                        if (ret_val) {
+                                /* a read error occurred, throw away the
+                                 * result */
+                                memset(eeprom_buff, 0xff, sizeof(eeprom_buff));
                                 break;
+                        }
                 }
         }
 
@@ -803,8 +807,7 @@ static int e1000_reg_test(struct e1000_adapter *adapter, u64 *data)
         /* restore previous status */
         ew32(STATUS, before);
 
-        if ((mac->type != e1000_ich8lan) &&
-            (mac->type != e1000_ich9lan)) {
+        if (!(adapter->flags & FLAG_IS_ICH)) {
                 REG_PATTERN_TEST(E1000_FCAL, 0xFFFFFFFF, 0xFFFFFFFF);
                 REG_PATTERN_TEST(E1000_FCAH, 0x0000FFFF, 0xFFFFFFFF);
                 REG_PATTERN_TEST(E1000_FCT, 0x0000FFFF, 0xFFFFFFFF);
@@ -824,15 +827,13 @@ static int e1000_reg_test(struct e1000_adapter *adapter, u64 *data)
 
         REG_SET_AND_CHECK(E1000_RCTL, 0xFFFFFFFF, 0x00000000);
 
-        before = (((mac->type == e1000_ich8lan) ||
-                   (mac->type == e1000_ich9lan)) ? 0x06C3B33E : 0x06DFB3FE);
+        before = ((adapter->flags & FLAG_IS_ICH) ? 0x06C3B33E : 0x06DFB3FE);
         REG_SET_AND_CHECK(E1000_RCTL, before, 0x003FFFFB);
         REG_SET_AND_CHECK(E1000_TCTL, 0xFFFFFFFF, 0x00000000);
 
         REG_SET_AND_CHECK(E1000_RCTL, before, 0xFFFFFFFF);
         REG_PATTERN_TEST(E1000_RDBAL, 0xFFFFFFF0, 0xFFFFFFFF);
-        if ((mac->type != e1000_ich8lan) &&
-            (mac->type != e1000_ich9lan))
+        if (!(adapter->flags & FLAG_IS_ICH))
                 REG_PATTERN_TEST(E1000_TXCW, 0xC000FFFF, 0x0000FFFF);
         REG_PATTERN_TEST(E1000_TDBAL, 0xFFFFFFF0, 0xFFFFFFFF);
         REG_PATTERN_TEST(E1000_TIDV, 0x0000FFFF, 0x0000FFFF);
@@ -911,9 +912,7 @@ static int e1000_intr_test(struct e1000_adapter *adapter, u64 *data)
 
         /* Test each interrupt */
         for (i = 0; i < 10; i++) {
-
-                if (((adapter->hw.mac.type == e1000_ich8lan) ||
-                     (adapter->hw.mac.type == e1000_ich9lan)) && i == 8)
+                if ((adapter->flags & FLAG_IS_ICH) && (i == 8))
                         continue;
 
                 /* Interrupt to test */
@@ -1184,6 +1183,7 @@ static int e1000_integrated_phy_loopback(struct e1000_adapter *adapter)
         struct e1000_hw *hw = &adapter->hw;
         u32 ctrl_reg = 0;
         u32 stat_reg = 0;
+        u16 phy_reg = 0;
 
         hw->mac.autoneg = 0;
 
@@ -1211,6 +1211,28 @@ static int e1000_integrated_phy_loopback(struct e1000_adapter *adapter)
                              E1000_CTRL_SPD_100 |/* Force Speed to 100 */
                              E1000_CTRL_FD);     /* Force Duplex to FULL */
                 break;
+        case e1000_phy_bm:
+                /* Set Default MAC Interface speed to 1GB */
+                e1e_rphy(hw, PHY_REG(2, 21), &phy_reg);
+                phy_reg &= ~0x0007;
+                phy_reg |= 0x006;
+                e1e_wphy(hw, PHY_REG(2, 21), phy_reg);
+                /* Assert SW reset for above settings to take effect */
+                e1000e_commit_phy(hw);
+                mdelay(1);
+                /* Force Full Duplex */
+                e1e_rphy(hw, PHY_REG(769, 16), &phy_reg);
+                e1e_wphy(hw, PHY_REG(769, 16), phy_reg | 0x000C);
+                /* Set Link Up (in force link) */
+                e1e_rphy(hw, PHY_REG(776, 16), &phy_reg);
+                e1e_wphy(hw, PHY_REG(776, 16), phy_reg | 0x0040);
+                /* Force Link */
+                e1e_rphy(hw, PHY_REG(769, 16), &phy_reg);
+                e1e_wphy(hw, PHY_REG(769, 16), phy_reg | 0x0040);
+                /* Set Early Link Enable */
+                e1e_rphy(hw, PHY_REG(769, 20), &phy_reg);
+                e1e_wphy(hw, PHY_REG(769, 20), phy_reg | 0x0400);
+                /* fall through */
         default:
                 /* force 1000, set loopback */
                 e1e_wphy(hw, PHY_CONTROL, 0x4140);
@@ -1224,8 +1246,7 @@ static int e1000_integrated_phy_loopback(struct e1000_adapter *adapter)
                              E1000_CTRL_SPD_1000 |/* Force Speed to 1000 */
                              E1000_CTRL_FD);     /* Force Duplex to FULL */
 
-                if ((adapter->hw.mac.type == e1000_ich8lan) ||
-                    (adapter->hw.mac.type == e1000_ich9lan))
+                if (adapter->flags & FLAG_IS_ICH)
                         ctrl_reg |= E1000_CTRL_SLU;     /* Set Link Up */
         }
 
diff --git a/drivers/net/e1000e/hw.h b/drivers/net/e1000e/hw.h
index a930e6d9cf02..74f263acb172 100644
--- a/drivers/net/e1000e/hw.h
+++ b/drivers/net/e1000e/hw.h
@@ -216,6 +216,21 @@ enum e1e_registers {
 #define IGP01E1000_PHY_LINK_HEALTH      0x13 /* PHY Link Health */
 #define IGP02E1000_PHY_POWER_MGMT       0x19 /* Power Management */
 #define IGP01E1000_PHY_PAGE_SELECT      0x1F /* Page Select */
+#define BM_PHY_PAGE_SELECT              22   /* Page Select for BM */
+#define IGP_PAGE_SHIFT                  5
+#define PHY_REG_MASK                    0x1F
+
+#define BM_WUC_PAGE                     800
+#define BM_WUC_ADDRESS_OPCODE           0x11
+#define BM_WUC_DATA_OPCODE              0x12
+#define BM_WUC_ENABLE_PAGE              769
+#define BM_WUC_ENABLE_REG               17
+#define BM_WUC_ENABLE_BIT               (1 << 2)
+#define BM_WUC_HOST_WU_BIT              (1 << 4)
+
+#define BM_WUC  PHY_REG(BM_WUC_PAGE, 1)
+#define BM_WUFC PHY_REG(BM_WUC_PAGE, 2)
+#define BM_WUS  PHY_REG(BM_WUC_PAGE, 3)
 
 #define IGP01E1000_PHY_PCS_INIT_REG     0x00B4
 #define IGP01E1000_PHY_POLARITY_MASK    0x0078
@@ -331,10 +346,16 @@ enum e1e_registers {
 #define E1000_DEV_ID_ICH8_IFE_G                 0x10C5
 #define E1000_DEV_ID_ICH8_IGP_M                 0x104D
 #define E1000_DEV_ID_ICH9_IGP_AMT               0x10BD
+#define E1000_DEV_ID_ICH9_IGP_M_AMT             0x10F5
+#define E1000_DEV_ID_ICH9_IGP_M                 0x10BF
+#define E1000_DEV_ID_ICH9_IGP_M_V               0x10CB
 #define E1000_DEV_ID_ICH9_IGP_C                 0x294C
 #define E1000_DEV_ID_ICH9_IFE                   0x10C0
 #define E1000_DEV_ID_ICH9_IFE_GT                0x10C3
 #define E1000_DEV_ID_ICH9_IFE_G                 0x10C2
+#define E1000_DEV_ID_ICH10_R_BM_LM              0x10CC
+#define E1000_DEV_ID_ICH10_R_BM_LF              0x10CD
+#define E1000_DEV_ID_ICH10_R_BM_V               0x10CE
 
 #define E1000_FUNC_1 1
 
@@ -378,6 +399,7 @@ enum e1000_phy_type {
         e1000_phy_gg82563,
         e1000_phy_igp_3,
         e1000_phy_ife,
+        e1000_phy_bm,
 };
 
 enum e1000_bus_width {
diff --git a/drivers/net/e1000e/ich8lan.c b/drivers/net/e1000e/ich8lan.c
index 768485dbb2c6..9e38452a738c 100644
--- a/drivers/net/e1000e/ich8lan.c
+++ b/drivers/net/e1000e/ich8lan.c
@@ -38,6 +38,12 @@
  * 82566DM Gigabit Network Connection
  * 82566MC Gigabit Network Connection
  * 82566MM Gigabit Network Connection
+ * 82567LM Gigabit Network Connection
+ * 82567LF Gigabit Network Connection
+ * 82567LM-2 Gigabit Network Connection
+ * 82567LF-2 Gigabit Network Connection
+ * 82567V-2 Gigabit Network Connection
+ * 82562GT-3 10/100 Network Connection
  */
 
 #include <linux/netdevice.h>
@@ -198,6 +204,19 @@ static s32 e1000_init_phy_params_ich8lan(struct e1000_hw *hw)
         phy->addr                       = 1;
         phy->reset_delay_us             = 100;
 
+        /*
+         * We may need to do this twice - once for IGP and if that fails,
+         * we'll set BM func pointers and try again
+         */
+        ret_val = e1000e_determine_phy_address(hw);
+        if (ret_val) {
+                hw->phy.ops.write_phy_reg = e1000e_write_phy_reg_bm;
+                hw->phy.ops.read_phy_reg  = e1000e_read_phy_reg_bm;
+                ret_val = e1000e_determine_phy_address(hw);
+                if (ret_val)
+                        return ret_val;
+        }
+
         phy->id = 0;
         while ((e1000_phy_unknown == e1000e_get_phy_type_from_id(phy->id)) &&
                (i++ < 100)) {
@@ -219,6 +238,13 @@ static s32 e1000_init_phy_params_ich8lan(struct e1000_hw *hw)
                 phy->type = e1000_phy_ife;
                 phy->autoneg_mask = E1000_ALL_NOT_GIG;
                 break;
+        case BME1000_E_PHY_ID:
+                phy->type = e1000_phy_bm;
+                phy->autoneg_mask = AUTONEG_ADVERTISE_SPEED_DEFAULT;
+                hw->phy.ops.read_phy_reg = e1000e_read_phy_reg_bm;
+                hw->phy.ops.write_phy_reg = e1000e_write_phy_reg_bm;
+                hw->phy.ops.commit_phy = e1000e_phy_sw_reset;
+                break;
         default:
                 return -E1000_ERR_PHY;
                 break;
@@ -664,6 +690,7 @@ static s32 e1000_get_phy_info_ich8lan(struct e1000_hw *hw)
                 return e1000_get_phy_info_ife_ich8lan(hw);
                 break;
         case e1000_phy_igp_3:
+        case e1000_phy_bm:
                 return e1000e_get_phy_info_igp(hw);
                 break;
         default:
@@ -728,7 +755,7 @@ static s32 e1000_set_d0_lplu_state_ich8lan(struct e1000_hw *hw, bool active)
         s32 ret_val = 0;
         u16 data;
 
-        if (phy->type != e1000_phy_igp_3)
+        if (phy->type == e1000_phy_ife)
                 return ret_val;
 
         phy_ctrl = er32(PHY_CTRL);
@@ -1918,8 +1945,35 @@ static s32 e1000_setup_copper_link_ich8lan(struct e1000_hw *hw)
                 ret_val = e1000e_copper_link_setup_igp(hw);
                 if (ret_val)
                         return ret_val;
+        } else if (hw->phy.type == e1000_phy_bm) {
+                ret_val = e1000e_copper_link_setup_m88(hw);
+                if (ret_val)
+                        return ret_val;
         }
 
+        if (hw->phy.type == e1000_phy_ife) {
+                ret_val = e1e_rphy(hw, IFE_PHY_MDIX_CONTROL, &reg_data);
+                if (ret_val)
+                        return ret_val;
+
+                reg_data &= ~IFE_PMC_AUTO_MDIX;
+
+                switch (hw->phy.mdix) {
+                case 1:
+                        reg_data &= ~IFE_PMC_FORCE_MDIX;
+                        break;
+                case 2:
+                        reg_data |= IFE_PMC_FORCE_MDIX;
+                        break;
+                case 0:
+                default:
+                        reg_data |= IFE_PMC_AUTO_MDIX;
+                        break;
+                }
+                ret_val = e1e_wphy(hw, IFE_PHY_MDIX_CONTROL, reg_data);
+                if (ret_val)
+                        return ret_val;
+        }
         return e1000e_setup_copper_link(hw);
 }
 
@@ -2127,6 +2181,31 @@ void e1000e_gig_downshift_workaround_ich8lan(struct e1000_hw *hw)
 }
 
 /**
+ *  e1000e_disable_gig_wol_ich8lan - disable gig during WoL
+ *  @hw: pointer to the HW structure
+ *
+ *  During S0 to Sx transition, it is possible the link remains at gig
+ *  instead of negotiating to a lower speed.  Before going to Sx, set
+ *  'LPLU Enabled' and 'Gig Disable' to force link speed negotiation
+ *  to a lower speed.
+ *
+ *  Should only be called for ICH9 devices.
+ **/
+void e1000e_disable_gig_wol_ich8lan(struct e1000_hw *hw)
+{
+        u32 phy_ctrl;
+
+        if (hw->mac.type == e1000_ich9lan) {
+                phy_ctrl = er32(PHY_CTRL);
+                phy_ctrl |= E1000_PHY_CTRL_D0A_LPLU |
+                            E1000_PHY_CTRL_GBE_DISABLE;
+                ew32(PHY_CTRL, phy_ctrl);
+        }
+
+        return;
+}
+
+/**
  *  e1000_cleanup_led_ich8lan - Restore the default LED operation
  *  @hw: pointer to the HW structure
  *
@@ -2247,6 +2326,7 @@ static struct e1000_nvm_operations ich8_nvm_ops = {
 struct e1000_info e1000_ich8_info = {
         .mac                    = e1000_ich8lan,
         .flags                  = FLAG_HAS_WOL
+                                  | FLAG_IS_ICH
                                   | FLAG_RX_CSUM_ENABLED
                                   | FLAG_HAS_CTRLEXT_ON_LOAD
                                   | FLAG_HAS_AMT
@@ -2262,6 +2342,7 @@ struct e1000_info e1000_ich8_info = {
 struct e1000_info e1000_ich9_info = {
         .mac                    = e1000_ich9lan,
         .flags                  = FLAG_HAS_JUMBO_FRAMES
+                                  | FLAG_IS_ICH
                                   | FLAG_HAS_WOL
                                   | FLAG_RX_CSUM_ENABLED
                                   | FLAG_HAS_CTRLEXT_ON_LOAD
diff --git a/drivers/net/e1000e/netdev.c b/drivers/net/e1000e/netdev.c
index 8991ab8911e2..8cbb40f3a506 100644
--- a/drivers/net/e1000e/netdev.c
+++ b/drivers/net/e1000e/netdev.c
@@ -43,10 +43,11 @@
 #include <linux/if_vlan.h>
 #include <linux/cpu.h>
 #include <linux/smp.h>
+#include <linux/pm_qos_params.h>
 
 #include "e1000.h"
 
-#define DRV_VERSION "0.2.1"
+#define DRV_VERSION "0.3.3.3-k2"
 char e1000e_driver_name[] = "e1000e";
 const char e1000e_driver_version[] = DRV_VERSION;
 
@@ -341,6 +342,89 @@ no_buffers:
 }
 
 /**
+ * e1000_alloc_jumbo_rx_buffers - Replace used jumbo receive buffers
+ * @adapter: address of board private structure
+ * @rx_ring: pointer to receive ring structure
+ * @cleaned_count: number of buffers to allocate this pass
+ **/
+
+static void e1000_alloc_jumbo_rx_buffers(struct e1000_adapter *adapter,
+                                         int cleaned_count)
+{
+        struct net_device *netdev = adapter->netdev;
+        struct pci_dev *pdev = adapter->pdev;
+        struct e1000_rx_desc *rx_desc;
+        struct e1000_ring *rx_ring = adapter->rx_ring;
+        struct e1000_buffer *buffer_info;
+        struct sk_buff *skb;
+        unsigned int i;
+        unsigned int bufsz = 256 -
+                             16 /* for skb_reserve */ -
+                             NET_IP_ALIGN;
+
+        i = rx_ring->next_to_use;
+        buffer_info = &rx_ring->buffer_info[i];
+
+        while (cleaned_count--) {
+                skb = buffer_info->skb;
+                if (skb) {
+                        skb_trim(skb, 0);
+                        goto check_page;
+                }
+
+                skb = netdev_alloc_skb(netdev, bufsz);
+                if (unlikely(!skb)) {
+                        /* Better luck next round */
+                        adapter->alloc_rx_buff_failed++;
+                        break;
+                }
+
+                /* Make buffer alignment 2 beyond a 16 byte boundary
+                 * this will result in a 16 byte aligned IP header after
+                 * the 14 byte MAC header is removed
+                 */
+                skb_reserve(skb, NET_IP_ALIGN);
+
+                buffer_info->skb = skb;
+check_page:
+                /* allocate a new page if necessary */
+                if (!buffer_info->page) {
+                        buffer_info->page = alloc_page(GFP_ATOMIC);
+                        if (unlikely(!buffer_info->page)) {
+                                adapter->alloc_rx_buff_failed++;
+                                break;
+                        }
+                }
+
+                if (!buffer_info->dma)
+                        buffer_info->dma = pci_map_page(pdev,
+                                                        buffer_info->page, 0,
+                                                        PAGE_SIZE,
+                                                        PCI_DMA_FROMDEVICE);
+
+                rx_desc = E1000_RX_DESC(*rx_ring, i);
+                rx_desc->buffer_addr = cpu_to_le64(buffer_info->dma);
+
+                if (unlikely(++i == rx_ring->count))
+                        i = 0;
+                buffer_info = &rx_ring->buffer_info[i];
+        }
+
+        if (likely(rx_ring->next_to_use != i)) {
+                rx_ring->next_to_use = i;
+                if (unlikely(i-- == 0))
+                        i = (rx_ring->count - 1);
+
+                /* Force memory writes to complete before letting h/w
+                 * know there are new descriptors to fetch.  (Only
+                 * applicable for weak-ordered memory model archs,
+                 * such as IA-64). */
+                wmb();
+                writel(i, adapter->hw.hw_addr + rx_ring->tail);
+        }
+}
+
+/**
  * e1000_clean_rx_irq - Send received data up the network stack; legacy
  * @adapter: board private structure
  *
@@ -783,6 +867,186 @@ next_desc:
 }
 
 /**
+ * e1000_consume_page - helper function
+ **/
+static void e1000_consume_page(struct e1000_buffer *bi, struct sk_buff *skb,
+                               u16 length)
+{
+        bi->page = NULL;
+        skb->len += length;
+        skb->data_len += length;
+        skb->truesize += length;
+}
+
+/**
+ * e1000_clean_jumbo_rx_irq - Send received data up the network stack; legacy
+ * @adapter: board private structure
+ *
+ * the return value indicates whether actual cleaning was done, there
+ * is no guarantee that everything was cleaned
+ **/
+
+static bool e1000_clean_jumbo_rx_irq(struct e1000_adapter *adapter,
+                                     int *work_done, int work_to_do)
+{
+        struct net_device *netdev = adapter->netdev;
+        struct pci_dev *pdev = adapter->pdev;
+        struct e1000_ring *rx_ring = adapter->rx_ring;
+        struct e1000_rx_desc *rx_desc, *next_rxd;
+        struct e1000_buffer *buffer_info, *next_buffer;
+        u32 length;
+        unsigned int i;
+        int cleaned_count = 0;
+        bool cleaned = false;
+        unsigned int total_rx_bytes=0, total_rx_packets=0;
+
+        i = rx_ring->next_to_clean;
+        rx_desc = E1000_RX_DESC(*rx_ring, i);
+        buffer_info = &rx_ring->buffer_info[i];
+
+        while (rx_desc->status & E1000_RXD_STAT_DD) {
+                struct sk_buff *skb;
+                u8 status;
+
+                if (*work_done >= work_to_do)
+                        break;
+                (*work_done)++;
+
+                status = rx_desc->status;
+                skb = buffer_info->skb;
+                buffer_info->skb = NULL;
+
+                ++i;
+                if (i == rx_ring->count)
+                        i = 0;
+                next_rxd = E1000_RX_DESC(*rx_ring, i);
+                prefetch(next_rxd);
+
+                next_buffer = &rx_ring->buffer_info[i];
+
+                cleaned = true;
+                cleaned_count++;
+                pci_unmap_page(pdev, buffer_info->dma, PAGE_SIZE,
+                               PCI_DMA_FROMDEVICE);
+                buffer_info->dma = 0;
+
+                length = le16_to_cpu(rx_desc->length);
+
+                /* errors is only valid for DD + EOP descriptors */
+                if (unlikely((status & E1000_RXD_STAT_EOP) &&
+                    (rx_desc->errors & E1000_RXD_ERR_FRAME_ERR_MASK))) {
+                                /* recycle both page and skb */
+                                buffer_info->skb = skb;
+                                /* an error means any chain goes out the window
+                                 * too */
+                                if (rx_ring->rx_skb_top)
+                                        dev_kfree_skb(rx_ring->rx_skb_top);
+                                rx_ring->rx_skb_top = NULL;
+                                goto next_desc;
+                }
+
+#define rxtop rx_ring->rx_skb_top
+                if (!(status & E1000_RXD_STAT_EOP)) {
+                        /* this descriptor is only the beginning (or middle) */
+                        if (!rxtop) {
+                                /* this is the beginning of a chain */
+                                rxtop = skb;
+                                skb_fill_page_desc(rxtop, 0, buffer_info->page,
+                                                   0, length);
+                        } else {
+                                /* this is the middle of a chain */
+                                skb_fill_page_desc(rxtop,
+                                    skb_shinfo(rxtop)->nr_frags,
+                                    buffer_info->page, 0, length);
+                                /* re-use the skb, only consumed the page */
+                                buffer_info->skb = skb;
+                        }
+                        e1000_consume_page(buffer_info, rxtop, length);
+                        goto next_desc;
+                } else {
+                        if (rxtop) {
+                                /* end of the chain */
+                                skb_fill_page_desc(rxtop,
+                                    skb_shinfo(rxtop)->nr_frags,
+                                    buffer_info->page, 0, length);
+                                /* re-use the current skb, we only consumed the
+                                 * page */
+                                buffer_info->skb = skb;
+                                skb = rxtop;
+                                rxtop = NULL;
+                                e1000_consume_page(buffer_info, skb, length);
+                        } else {
+                                /* no chain, got EOP, this buf is the packet
+                                 * copybreak to save the put_page/alloc_page */
+                                if (length <= copybreak &&
+                                    skb_tailroom(skb) >= length) {
+                                        u8 *vaddr;
+                                        vaddr = kmap_atomic(buffer_info->page,
+                                                           KM_SKB_DATA_SOFTIRQ);
+                                        memcpy(skb_tail_pointer(skb), vaddr,
+                                               length);
+                                        kunmap_atomic(vaddr,
+                                                      KM_SKB_DATA_SOFTIRQ);
+                                        /* re-use the page, so don't erase
+                                         * buffer_info->page */
+                                        skb_put(skb, length);
+                                } else {
+                                        skb_fill_page_desc(skb, 0,
+                                                           buffer_info->page, 0,
+                                                           length);
+                                        e1000_consume_page(buffer_info, skb,
+                                                           length);
+                                }
+                        }
+                }
+
+                /* Receive Checksum Offload XXX recompute due to CRC strip? */
+                e1000_rx_checksum(adapter,
+                                  (u32)(status) |
+                                  ((u32)(rx_desc->errors) << 24),
+                                  le16_to_cpu(rx_desc->csum), skb);
+
+                /* probably a little skewed due to removing CRC */
+                total_rx_bytes += skb->len;
+                total_rx_packets++;
+
+                /* eth type trans needs skb->data to point to something */
+                if (!pskb_may_pull(skb, ETH_HLEN)) {
+                        ndev_err(netdev, "pskb_may_pull failed.\n");
+                        dev_kfree_skb(skb);
+                        goto next_desc;
+                }
+
+                e1000_receive_skb(adapter, netdev, skb, status,
+                                  rx_desc->special);
+
+next_desc:
+                rx_desc->status = 0;
+
+                /* return some buffers to hardware, one at a time is too slow */
+                if (unlikely(cleaned_count >= E1000_RX_BUFFER_WRITE)) {
+                        adapter->alloc_rx_buf(adapter, cleaned_count);
+                        cleaned_count = 0;
+                }
+
+                /* use prefetched values */
+                rx_desc = next_rxd;
+                buffer_info = next_buffer;
+        }
+        rx_ring->next_to_clean = i;
+
+        cleaned_count = e1000_desc_unused(rx_ring);
+        if (cleaned_count)
+                adapter->alloc_rx_buf(adapter, cleaned_count);
+
+        adapter->total_rx_bytes += total_rx_bytes;
+        adapter->total_rx_packets += total_rx_packets;
+        adapter->net_stats.rx_bytes += total_rx_bytes;
+        adapter->net_stats.rx_packets += total_rx_packets;
+        return cleaned;
+}
+
+/**
  * e1000_clean_rx_ring - Free Rx Buffers per Queue
  * @adapter: board private structure
  **/
@@ -802,6 +1066,10 @@ static void e1000_clean_rx_ring(struct e1000_adapter *adapter)
                                 pci_unmap_single(pdev, buffer_info->dma,
                                                  adapter->rx_buffer_len,
                                                  PCI_DMA_FROMDEVICE);
+                        else if (adapter->clean_rx == e1000_clean_jumbo_rx_irq)
+                                pci_unmap_page(pdev, buffer_info->dma,
+                                               PAGE_SIZE,
+                                               PCI_DMA_FROMDEVICE);
                         else if (adapter->clean_rx == e1000_clean_rx_irq_ps)
                                 pci_unmap_single(pdev, buffer_info->dma,
                                                  adapter->rx_ps_bsize0,
@@ -809,6 +1077,11 @@ static void e1000_clean_rx_ring(struct e1000_adapter *adapter)
                         buffer_info->dma = 0;
                 }
 
+                if (buffer_info->page) {
+                        put_page(buffer_info->page);
+                        buffer_info->page = NULL;
+                }
+
                 if (buffer_info->skb) {
                         dev_kfree_skb(buffer_info->skb);
                         buffer_info->skb = NULL;
@@ -1755,10 +2028,12 @@ static void e1000_setup_rctl(struct e1000_adapter *adapter)
          * a lot of memory, since we allocate 3 pages at all times
          * per packet.
          */
-        adapter->rx_ps_pages = 0;
         pages = PAGE_USE_COUNT(adapter->netdev->mtu);
-        if ((pages <= 3) && (PAGE_SIZE <= 16384) && (rctl & E1000_RCTL_LPE))
+        if (!(adapter->flags & FLAG_IS_ICH) && (pages <= 3) &&
+            (PAGE_SIZE <= 16384) && (rctl & E1000_RCTL_LPE))
                 adapter->rx_ps_pages = pages;
+        else
+                adapter->rx_ps_pages = 0;
 
         if (adapter->rx_ps_pages) {
                 /* Configure extra packet-split registers */
@@ -1819,9 +2094,12 @@ static void e1000_configure_rx(struct e1000_adapter *adapter)
                         sizeof(union e1000_rx_desc_packet_split);
                 adapter->clean_rx = e1000_clean_rx_irq_ps;
                 adapter->alloc_rx_buf = e1000_alloc_rx_buffers_ps;
+        } else if (adapter->netdev->mtu > ETH_FRAME_LEN + ETH_FCS_LEN) {
+                rdlen = rx_ring->count * sizeof(struct e1000_rx_desc);
+                adapter->clean_rx = e1000_clean_jumbo_rx_irq;
+                adapter->alloc_rx_buf = e1000_alloc_jumbo_rx_buffers;
         } else {
-                rdlen = rx_ring->count *
-                        sizeof(struct e1000_rx_desc);
+                rdlen = rx_ring->count * sizeof(struct e1000_rx_desc);
                 adapter->clean_rx = e1000_clean_rx_irq;
                 adapter->alloc_rx_buf = e1000_alloc_rx_buffers;
         }
@@ -1885,8 +2163,21 @@ static void e1000_configure_rx(struct e1000_adapter *adapter)
          * units), e.g. using jumbo frames when setting to E1000_ERT_2048
          */
         if ((adapter->flags & FLAG_HAS_ERT) &&
-            (adapter->netdev->mtu > ETH_DATA_LEN))
-                ew32(ERT, E1000_ERT_2048);
+            (adapter->netdev->mtu > ETH_DATA_LEN)) {
+                u32 rxdctl = er32(RXDCTL(0));
+                ew32(RXDCTL(0), rxdctl | 0x3);
+                ew32(ERT, E1000_ERT_2048 | (1 << 13));
+                /*
+                 * With jumbo frames and early-receive enabled, excessive
+                 * C4->C2 latencies result in dropped transactions.
+                 */
+                pm_qos_update_requirement(PM_QOS_CPU_DMA_LATENCY,
+                                          e1000e_driver_name, 55);
+        } else {
+                pm_qos_update_requirement(PM_QOS_CPU_DMA_LATENCY,
+                                          e1000e_driver_name,
+                                          PM_QOS_DEFAULT_VALUE);
+        }
 
         /* Enable Receives */
         ew32(RCTL, rctl);
@@ -2155,6 +2446,14 @@ void e1000e_reset(struct e1000_adapter *adapter)
 
         /* Allow time for pending master requests to run */
         mac->ops.reset_hw(hw);
+
+        /*
+         * For parts with AMT enabled, let the firmware know
+         * that the network interface is in control
+         */
+        if ((adapter->flags & FLAG_HAS_AMT) && e1000e_check_mng_mode(hw))
+                e1000_get_hw_control(adapter);
+
         ew32(WUC, 0);
 
         if (mac->ops.init_hw(hw))
@@ -3469,6 +3768,8 @@ static int e1000_change_mtu(struct net_device *netdev, int new_mtu)
          * means we reserve 2 more, this pushes us to allocate from the next
          * larger slab size.
          * i.e. RXBUFFER_2048 --> size-4096 slab
+         * However with the new *_jumbo_rx* routines, jumbo receives will use
+         * fragmented skbs
          */
 
         if (max_frame <= 256)
@@ -3626,6 +3927,9 @@ static int e1000_suspend(struct pci_dev *pdev, pm_message_t state)
                         ew32(CTRL_EXT, ctrl_ext);
                 }
 
+                if (adapter->flags & FLAG_IS_ICH)
+                        e1000e_disable_gig_wol_ich8lan(&adapter->hw);
+
                 /* Allow time for pending master requests to run */
                 e1000e_disable_pcie_master(&adapter->hw);
 
@@ -4292,6 +4596,13 @@ static struct pci_device_id e1000_pci_tbl[] = {
         { PCI_VDEVICE(INTEL, E1000_DEV_ID_ICH9_IFE_GT), board_ich9lan },
         { PCI_VDEVICE(INTEL, E1000_DEV_ID_ICH9_IGP_AMT), board_ich9lan },
         { PCI_VDEVICE(INTEL, E1000_DEV_ID_ICH9_IGP_C), board_ich9lan },
+        { PCI_VDEVICE(INTEL, E1000_DEV_ID_ICH9_IGP_M), board_ich9lan },
+        { PCI_VDEVICE(INTEL, E1000_DEV_ID_ICH9_IGP_M_AMT), board_ich9lan },
+        { PCI_VDEVICE(INTEL, E1000_DEV_ID_ICH9_IGP_M_V), board_ich9lan },
+
+        { PCI_VDEVICE(INTEL, E1000_DEV_ID_ICH10_R_BM_LM), board_ich9lan },
+        { PCI_VDEVICE(INTEL, E1000_DEV_ID_ICH10_R_BM_LF), board_ich9lan },
+        { PCI_VDEVICE(INTEL, E1000_DEV_ID_ICH10_R_BM_V), board_ich9lan },
 
         { }     /* terminate list */
 };
@@ -4326,7 +4637,9 @@ static int __init e1000_init_module(void)
         printk(KERN_INFO "%s: Copyright (c) 1999-2008 Intel Corporation.\n",
                e1000e_driver_name);
         ret = pci_register_driver(&e1000_driver);
-
+        pm_qos_add_requirement(PM_QOS_CPU_DMA_LATENCY, e1000e_driver_name,
+                               PM_QOS_DEFAULT_VALUE);
+                                
         return ret;
 }
 module_init(e1000_init_module);
@@ -4340,6 +4653,7 @@ module_init(e1000_init_module);
 static void __exit e1000_exit_module(void)
 {
         pci_unregister_driver(&e1000_driver);
+        pm_qos_remove_requirement(PM_QOS_CPU_DMA_LATENCY, e1000e_driver_name);
 }
 module_exit(e1000_exit_module);
 
diff --git a/drivers/net/e1000e/phy.c b/drivers/net/e1000e/phy.c
index e102332a6bee..b133dcf0e950 100644
--- a/drivers/net/e1000e/phy.c
+++ b/drivers/net/e1000e/phy.c
@@ -34,6 +34,9 @@ static s32 e1000_get_phy_cfg_done(struct e1000_hw *hw);
 static s32 e1000_phy_force_speed_duplex(struct e1000_hw *hw);
 static s32 e1000_set_d0_lplu_state(struct e1000_hw *hw, bool active);
 static s32 e1000_wait_autoneg(struct e1000_hw *hw);
+static u32 e1000_get_phy_addr_for_bm_page(u32 page, u32 reg);
+static s32 e1000_access_phy_wakeup_reg_bm(struct e1000_hw *hw, u32 offset,
+                                          u16 *data, bool read);
 
 /* Cable length tables */
 static const u16 e1000_m88_cable_length_table[] =
@@ -465,6 +468,10 @@ s32 e1000e_copper_link_setup_m88(struct e1000_hw *hw)
         if (phy->disable_polarity_correction == 1)
                 phy_data |= M88E1000_PSCR_POLARITY_REVERSAL;
 
+        /* Enable downshift on BM (disabled by default) */
+        if (phy->type == e1000_phy_bm)
+                phy_data |= BME1000_PSCR_ENABLE_DOWNSHIFT;
+
         ret_val = e1e_wphy(hw, M88E1000_PHY_SPEC_CTRL, phy_data);
         if (ret_val)
                 return ret_val;
@@ -1776,6 +1783,10 @@ enum e1000_phy_type e1000e_get_phy_type_from_id(u32 phy_id)
         case IFE_C_E_PHY_ID:
                 phy_type = e1000_phy_ife;
                 break;
+        case BME1000_E_PHY_ID:
+        case BME1000_E_PHY_ID_R2:
+                phy_type = e1000_phy_bm;
+                break;
         default:
                 phy_type = e1000_phy_unknown;
                 break;
@@ -1784,6 +1795,273 @@ enum e1000_phy_type e1000e_get_phy_type_from_id(u32 phy_id)
 }
 
 /**
+ *  e1000e_determine_phy_address - Determines PHY address.
+ *  @hw: pointer to the HW structure
+ *
+ *  This uses a trial and error method to loop through possible PHY
+ *  addresses. It tests each by reading the PHY ID registers and
+ *  checking for a match.
+ **/
+s32 e1000e_determine_phy_address(struct e1000_hw *hw)
+{
+        s32 ret_val = -E1000_ERR_PHY_TYPE;
+        u32 phy_addr= 0;
+        u32 i = 0;
+        enum e1000_phy_type phy_type = e1000_phy_unknown;
+
+        do {
+                for (phy_addr = 0; phy_addr < 4; phy_addr++) {
+                        hw->phy.addr = phy_addr;
+                        e1000e_get_phy_id(hw);
+                        phy_type = e1000e_get_phy_type_from_id(hw->phy.id);
+
+                        /* 
+                         * If phy_type is valid, break - we found our
+                         * PHY address
+                         */
+                        if (phy_type  != e1000_phy_unknown) {
+                                ret_val = 0;
+                                break;
+                        }
+                }
+                i++;
+        } while ((ret_val != 0) && (i < 100));
+
+        return ret_val;
+}
+
+/**
+ *  e1000_get_phy_addr_for_bm_page - Retrieve PHY page address
+ *  @page: page to access
+ *
+ *  Returns the phy address for the page requested.
+ **/
+static u32 e1000_get_phy_addr_for_bm_page(u32 page, u32 reg)
+{
+        u32 phy_addr = 2;
+
+        if ((page >= 768) || (page == 0 && reg == 25) || (reg == 31))
+                phy_addr = 1;
+
+        return phy_addr;
+}
+
+/**
+ *  e1000e_write_phy_reg_bm - Write BM PHY register
+ *  @hw: pointer to the HW structure
+ *  @offset: register offset to write to
+ *  @data: data to write at register offset
+ *
+ *  Acquires semaphore, if necessary, then writes the data to PHY register
+ *  at the offset.  Release any acquired semaphores before exiting.
+ **/
+s32 e1000e_write_phy_reg_bm(struct e1000_hw *hw, u32 offset, u16 data)
+{
+        s32 ret_val;
+        u32 page_select = 0;
+        u32 page = offset >> IGP_PAGE_SHIFT;
+        u32 page_shift = 0;
+
+        /* Page 800 works differently than the rest so it has its own func */
+        if (page == BM_WUC_PAGE) {
+                ret_val = e1000_access_phy_wakeup_reg_bm(hw, offset, &data,
+                                                         false);
+                goto out;
+        }
+
+        ret_val = hw->phy.ops.acquire_phy(hw);
+        if (ret_val)
+                goto out;
+
+        hw->phy.addr = e1000_get_phy_addr_for_bm_page(page, offset);
+
+        if (offset > MAX_PHY_MULTI_PAGE_REG) {
+                /*
+                 * Page select is register 31 for phy address 1 and 22 for
+                 * phy address 2 and 3. Page select is shifted only for
+                 * phy address 1.
+                 */
+                if (hw->phy.addr == 1) {
+                        page_shift = IGP_PAGE_SHIFT;
+                        page_select = IGP01E1000_PHY_PAGE_SELECT;
+                } else {
+                        page_shift = 0;
+                        page_select = BM_PHY_PAGE_SELECT;
+                }
+
+                /* Page is shifted left, PHY expects (page x 32) */
+                ret_val = e1000e_write_phy_reg_mdic(hw, page_select,
+                                                    (page << page_shift));
+                if (ret_val) {
+                        hw->phy.ops.release_phy(hw);
+                        goto out;
+                }
+        }
+
+        ret_val = e1000e_write_phy_reg_mdic(hw, MAX_PHY_REG_ADDRESS & offset,
+                                            data);
+
+        hw->phy.ops.release_phy(hw);
+
+out:
+        return ret_val;
+}
+
+/**
+ *  e1000e_read_phy_reg_bm - Read BM PHY register
+ *  @hw: pointer to the HW structure
+ *  @offset: register offset to be read
+ *  @data: pointer to the read data
+ *
+ *  Acquires semaphore, if necessary, then reads the PHY register at offset
+ *  and storing the retrieved information in data.  Release any acquired
+ *  semaphores before exiting.
+ **/
+s32 e1000e_read_phy_reg_bm(struct e1000_hw *hw, u32 offset, u16 *data)
+{
+        s32 ret_val;
+        u32 page_select = 0;
+        u32 page = offset >> IGP_PAGE_SHIFT;
+        u32 page_shift = 0;
+
+        /* Page 800 works differently than the rest so it has its own func */
+        if (page == BM_WUC_PAGE) {
+                ret_val = e1000_access_phy_wakeup_reg_bm(hw, offset, data,
+                                                         true);
+                goto out;
+        }
+
+        ret_val = hw->phy.ops.acquire_phy(hw);
+        if (ret_val)
+                goto out;
+
+        hw->phy.addr = e1000_get_phy_addr_for_bm_page(page, offset);
+
+        if (offset > MAX_PHY_MULTI_PAGE_REG) {
+                /*
+                 * Page select is register 31 for phy address 1 and 22 for
+                 * phy address 2 and 3. Page select is shifted only for
+                 * phy address 1.
+                 */
+                if (hw->phy.addr == 1) {
+                        page_shift = IGP_PAGE_SHIFT;
+                        page_select = IGP01E1000_PHY_PAGE_SELECT;
+                } else {
+                        page_shift = 0;
+                        page_select = BM_PHY_PAGE_SELECT;
+                }
+
+                /* Page is shifted left, PHY expects (page x 32) */
+                ret_val = e1000e_write_phy_reg_mdic(hw, page_select,
+                                                    (page << page_shift));
+                if (ret_val) {
+                        hw->phy.ops.release_phy(hw);
+                        goto out;
+                }
+        }
+
+        ret_val = e1000e_read_phy_reg_mdic(hw, MAX_PHY_REG_ADDRESS & offset,
+                                           data);
+        hw->phy.ops.release_phy(hw);
+
+out:
+        return ret_val;
+}
+
+/**
+ *  e1000_access_phy_wakeup_reg_bm - Read BM PHY wakeup register
+ *  @hw: pointer to the HW structure
+ *  @offset: register offset to be read or written
+ *  @data: pointer to the data to read or write
+ *  @read: determines if operation is read or write
+ *
+ *  Acquires semaphore, if necessary, then reads the PHY register at offset
+ *  and storing the retrieved information in data.  Release any acquired
+ *  semaphores before exiting. Note that procedure to read the wakeup
+ *  registers are different. It works as such:
+ *  1) Set page 769, register 17, bit 2 = 1
+ *  2) Set page to 800 for host (801 if we were manageability)
+ *  3) Write the address using the address opcode (0x11)
+ *  4) Read or write the data using the data opcode (0x12)
+ *  5) Restore 769_17.2 to its original value
+ **/
+static s32 e1000_access_phy_wakeup_reg_bm(struct e1000_hw *hw, u32 offset,
+                                          u16 *data, bool read)
+{
+        s32 ret_val;
+        u16 reg = ((u16)offset) & PHY_REG_MASK;
+        u16 phy_reg = 0;
+        u8  phy_acquired = 1;
+
+
+        ret_val = hw->phy.ops.acquire_phy(hw);
+        if (ret_val) {
+                phy_acquired = 0;
+                goto out;
+        }
+
+        /* All operations in this function are phy address 1 */
+        hw->phy.addr = 1;
+
+        /* Set page 769 */
+        e1000e_write_phy_reg_mdic(hw, IGP01E1000_PHY_PAGE_SELECT,
+                                  (BM_WUC_ENABLE_PAGE << IGP_PAGE_SHIFT));
+
+        ret_val = e1000e_read_phy_reg_mdic(hw, BM_WUC_ENABLE_REG, &phy_reg);
+        if (ret_val)
+                goto out;
+
+        /* First clear bit 4 to avoid a power state change */
+        phy_reg &= ~(BM_WUC_HOST_WU_BIT);
+        ret_val = e1000e_write_phy_reg_mdic(hw, BM_WUC_ENABLE_REG, phy_reg);
+        if (ret_val)
+                goto out;
+
+        /* Write bit 2 = 1, and clear bit 4 to 769_17 */
+        ret_val = e1000e_write_phy_reg_mdic(hw, BM_WUC_ENABLE_REG,
+                                            phy_reg | BM_WUC_ENABLE_BIT);
+        if (ret_val)
+                goto out;
+
+        /* Select page 800 */
+        ret_val = e1000e_write_phy_reg_mdic(hw, IGP01E1000_PHY_PAGE_SELECT,
+                                            (BM_WUC_PAGE << IGP_PAGE_SHIFT));
+
+        /* Write the page 800 offset value using opcode 0x11 */
+        ret_val = e1000e_write_phy_reg_mdic(hw, BM_WUC_ADDRESS_OPCODE, reg);
+        if (ret_val)
+                goto out;
+
+        if (read) {
+                /* Read the page 800 value using opcode 0x12 */
+                ret_val = e1000e_read_phy_reg_mdic(hw, BM_WUC_DATA_OPCODE,
+                                                   data);
+        } else {
+                /* Read the page 800 value using opcode 0x12 */
+                ret_val = e1000e_write_phy_reg_mdic(hw, BM_WUC_DATA_OPCODE,
+                                                    *data);
+        }
+
+        if (ret_val)
+                goto out;
+
+        /*
+         * Restore 769_17.2 to its original value
+         * Set page 769
+         */
+        e1000e_write_phy_reg_mdic(hw, IGP01E1000_PHY_PAGE_SELECT,
+                                  (BM_WUC_ENABLE_PAGE << IGP_PAGE_SHIFT));
+
+        /* Clear 769_17.2 */
+        ret_val = e1000e_write_phy_reg_mdic(hw, BM_WUC_ENABLE_REG, phy_reg);
+
+out:
+        if (phy_acquired == 1)
+                hw->phy.ops.release_phy(hw);
+        return ret_val;
+}
+
+/**
  *  e1000e_commit_phy - Soft PHY reset
  *  @hw: pointer to the HW structure
  *
diff --git a/drivers/net/eexpress.c b/drivers/net/eexpress.c
index 2eb82aba4a8b..795c594a4b7c 100644
--- a/drivers/net/eexpress.c
+++ b/drivers/net/eexpress.c
@@ -202,7 +202,7 @@ static unsigned short start_code[] = {
         0x0000,Cmd_MCast,
         0x0076,                 /* link to next command */
 #define CONF_NR_MULTICAST 0x44
-        0x0000,                 /* number of multicast addresses */
+        0x0000,                 /* number of bytes in multicast address(es) */
 #define CONF_MULTICAST 0x46
         0x0000, 0x0000, 0x0000, /* some addresses */
         0x0000, 0x0000, 0x0000,
@@ -1569,7 +1569,7 @@ static void eexp_hw_init586(struct net_device *dev)
 
 static void eexp_setup_filter(struct net_device *dev)
 {
-        struct dev_mc_list *dmi = dev->mc_list;
+        struct dev_mc_list *dmi;
         unsigned short ioaddr = dev->base_addr;
         int count = dev->mc_count;
         int i;
@@ -1580,9 +1580,9 @@ static void eexp_setup_filter(struct net_device *dev)
         }
 
         outw(CONF_NR_MULTICAST & ~31, ioaddr+SM_PTR);
-        outw(count, ioaddr+SHADOW(CONF_NR_MULTICAST));
-        for (i = 0; i < count; i++) {
-                unsigned short *data = (unsigned short *)dmi->dmi_addr;
+        outw(6*count, ioaddr+SHADOW(CONF_NR_MULTICAST));
+        for (i = 0, dmi = dev->mc_list; i < count; i++, dmi = dmi->next) {
+                unsigned short *data;
                 if (!dmi) {
                         printk(KERN_INFO "%s: too few multicast addresses\n", dev->name);
                         break;
@@ -1591,6 +1591,7 @@ static void eexp_setup_filter(struct net_device *dev)
                         printk(KERN_INFO "%s: invalid multicast address length given.\n", dev->name);
                         continue;
                 }
+                data = (unsigned short *)dmi->dmi_addr;
                 outw((CONF_MULTICAST+(6*i)) & ~31, ioaddr+SM_PTR);
                 outw(data[0], ioaddr+SHADOW(CONF_MULTICAST+(6*i)));
                 outw((CONF_MULTICAST+(6*i)+2) & ~31, ioaddr+SM_PTR);
diff --git a/drivers/net/fs_enet/mii-fec.c b/drivers/net/fs_enet/mii-fec.c
index ba75efc9f5b5..f0014cfbb275 100644
--- a/drivers/net/fs_enet/mii-fec.c
+++ b/drivers/net/fs_enet/mii-fec.c
@@ -194,7 +194,7 @@ static int __devinit fs_enet_mdio_probe(struct of_device *ofdev,
 
         ret = of_address_to_resource(ofdev->node, 0, &res);
         if (ret)
-                return ret;
+                goto out_res;
 
         snprintf(new_bus->id, MII_BUS_ID_SIZE, "%x", res.start);
 
@@ -236,6 +236,7 @@ out_free_irqs:
         kfree(new_bus->irq);
 out_unmap_regs:
         iounmap(fec->fecp);
+out_res:
 out_fec:
         kfree(fec);
 out_mii:
diff --git a/drivers/net/gianfar.c b/drivers/net/gianfar.c
index 587afe7be689..6f22f068d6ee 100644
--- a/drivers/net/gianfar.c
+++ b/drivers/net/gianfar.c
@@ -138,6 +138,7 @@ static int gfar_poll(struct napi_struct *napi, int budget);
 static void gfar_netpoll(struct net_device *dev);
 #endif
 int gfar_clean_rx_ring(struct net_device *dev, int rx_work_limit);
+static int gfar_clean_tx_ring(struct net_device *dev);
 static int gfar_process_frame(struct net_device *dev, struct sk_buff *skb, int length);
 static void gfar_vlan_rx_register(struct net_device *netdev,
                                 struct vlan_group *grp);
@@ -1141,7 +1142,7 @@ static int gfar_close(struct net_device *dev)
 }
 
 /* Changes the mac address if the controller is not running. */
-int gfar_set_mac_address(struct net_device *dev)
+static int gfar_set_mac_address(struct net_device *dev)
 {
         gfar_set_mac_for_addr(dev, 0, dev->dev_addr);
 
@@ -1260,7 +1261,7 @@ static void gfar_timeout(struct net_device *dev)
 }
 
 /* Interrupt Handler for Transmit complete */
-int gfar_clean_tx_ring(struct net_device *dev)
+static int gfar_clean_tx_ring(struct net_device *dev)
 {
         struct txbd8 *bdp;
         struct gfar_private *priv = netdev_priv(dev);
diff --git a/drivers/net/gianfar.h b/drivers/net/gianfar.h
index fd487be3993e..27f37c81e52c 100644
--- a/drivers/net/gianfar.h
+++ b/drivers/net/gianfar.h
@@ -782,5 +782,8 @@ extern void gfar_halt(struct net_device *dev);
 extern void gfar_phy_test(struct mii_bus *bus, struct phy_device *phydev,
                 int enable, u32 regnum, u32 read);
 void gfar_init_sysfs(struct net_device *dev);
+int gfar_local_mdio_write(struct gfar_mii __iomem *regs, int mii_id,
+                          int regnum, u16 value);
+int gfar_local_mdio_read(struct gfar_mii __iomem *regs, int mii_id, int regnum);
 
 #endif /* __GIANFAR_H */
diff --git a/drivers/net/gianfar_sysfs.c b/drivers/net/gianfar_sysfs.c
index 230878b94190..5116f68e01b9 100644
--- a/drivers/net/gianfar_sysfs.c
+++ b/drivers/net/gianfar_sysfs.c
@@ -103,10 +103,10 @@ static ssize_t gfar_set_rx_stash_size(struct device *dev,
 
         spin_lock_irqsave(&priv->rxlock, flags);
         if (length > priv->rx_buffer_size)
-                return count;
+                goto out;
 
         if (length == priv->rx_stash_size)
-                return count;
+                goto out;
 
         priv->rx_stash_size = length;
 
@@ -125,6 +125,7 @@ static ssize_t gfar_set_rx_stash_size(struct device *dev,
 
         gfar_write(&priv->regs->attr, temp);
 
+out:
         spin_unlock_irqrestore(&priv->rxlock, flags);
 
         return count;
@@ -154,10 +155,10 @@ static ssize_t gfar_set_rx_stash_index(struct device *dev,
 
         spin_lock_irqsave(&priv->rxlock, flags);
         if (index > priv->rx_stash_size)
-                return count;
+                goto out;
 
         if (index == priv->rx_stash_index)
-                return count;
+                goto out;
 
         priv->rx_stash_index = index;
 
@@ -166,6 +167,7 @@ static ssize_t gfar_set_rx_stash_index(struct device *dev,
         temp |= ATTRELI_EI(index);
         gfar_write(&priv->regs->attreli, flags);
 
+out:
         spin_unlock_irqrestore(&priv->rxlock, flags);
 
         return count;
diff --git a/drivers/net/irda/nsc-ircc.c b/drivers/net/irda/nsc-ircc.c
index a873d2b315ca..a7714da7c283 100644
--- a/drivers/net/irda/nsc-ircc.c
+++ b/drivers/net/irda/nsc-ircc.c
@@ -100,7 +100,9 @@ static int nsc_ircc_probe_39x(nsc_chip_t *chip, chipio_t *info);
 static int nsc_ircc_init_108(nsc_chip_t *chip, chipio_t *info);
 static int nsc_ircc_init_338(nsc_chip_t *chip, chipio_t *info);
 static int nsc_ircc_init_39x(nsc_chip_t *chip, chipio_t *info);
+#ifdef CONFIG_PNP
 static int nsc_ircc_pnp_probe(struct pnp_dev *dev, const struct pnp_device_id *id);
+#endif
 
 /* These are the known NSC chips */
 static nsc_chip_t chips[] = {
@@ -156,9 +158,11 @@ static const struct pnp_device_id nsc_ircc_pnp_table[] = {
 MODULE_DEVICE_TABLE(pnp, nsc_ircc_pnp_table);
 
 static struct pnp_driver nsc_ircc_pnp_driver = {
+#ifdef CONFIG_PNP
         .name = "nsc-ircc",
         .id_table = nsc_ircc_pnp_table,
         .probe = nsc_ircc_pnp_probe,
+#endif
 };
 
 /* Some prototypes */
@@ -916,6 +920,7 @@ static int nsc_ircc_probe_39x(nsc_chip_t *chip, chipio_t *info)
         return 0;
 }
 
+#ifdef CONFIG_PNP
 /* PNP probing */
 static int nsc_ircc_pnp_probe(struct pnp_dev *dev, const struct pnp_device_id *id)
 {
@@ -952,6 +957,7 @@ static int nsc_ircc_pnp_probe(struct pnp_dev *dev, const struct pnp_device_id *i
 
         return 0;
 }
+#endif
 
 /*
  * Function nsc_ircc_setup (info)
diff --git a/drivers/net/irda/smsc-ircc2.c b/drivers/net/irda/smsc-ircc2.c
index 1f26da761e9f..cfe0194fef71 100644
--- a/drivers/net/irda/smsc-ircc2.c
+++ b/drivers/net/irda/smsc-ircc2.c
@@ -376,6 +376,7 @@ MODULE_DEVICE_TABLE(pnp, smsc_ircc_pnp_table);
 
 static int pnp_driver_registered;
 
+#ifdef CONFIG_PNP
 static int __init smsc_ircc_pnp_probe(struct pnp_dev *dev,
                                       const struct pnp_device_id *dev_id)
 {
@@ -402,7 +403,9 @@ static struct pnp_driver smsc_ircc_pnp_driver = {
         .id_table       = smsc_ircc_pnp_table,
         .probe          = smsc_ircc_pnp_probe,
 };
-
+#else /* CONFIG_PNP */
+static struct pnp_driver smsc_ircc_pnp_driver;
+#endif
 
 /*******************************************************************************
  *
diff --git a/drivers/net/macvlan.c b/drivers/net/macvlan.c
index 2056cfc624dc..c36a03ae9bfb 100644
--- a/drivers/net/macvlan.c
+++ b/drivers/net/macvlan.c
@@ -450,7 +450,7 @@ static void macvlan_dellink(struct net_device *dev)
         unregister_netdevice(dev);
 
         if (list_empty(&port->vlans))
-                macvlan_port_destroy(dev);
+                macvlan_port_destroy(port->dev);
 }
 
 static struct rtnl_link_ops macvlan_link_ops __read_mostly = {
diff --git a/drivers/net/mlx4/mr.c b/drivers/net/mlx4/mr.c
index cb46446b2691..03a9abcce524 100644
--- a/drivers/net/mlx4/mr.c
+++ b/drivers/net/mlx4/mr.c
@@ -551,7 +551,7 @@ int mlx4_fmr_alloc(struct mlx4_dev *dev, u32 pd, u32 access, int max_pages,
         u64 mtt_seg;
         int err = -ENOMEM;
 
-        if (page_shift < 12 || page_shift >= 32)
+        if (page_shift < (ffs(dev->caps.page_size_cap) - 1) || page_shift >= 32)
                 return -EINVAL;
 
         /* All MTTs must fit in the same page */
diff --git a/drivers/net/mv643xx_eth.c b/drivers/net/mv643xx_eth.c
index 381b36e5f64c..b7915cdcc6a5 100644
--- a/drivers/net/mv643xx_eth.c
+++ b/drivers/net/mv643xx_eth.c
@@ -91,6 +91,11 @@
  */
 #define PHY_ADDR_REG                            0x0000
 #define SMI_REG                                 0x0004
+#define WINDOW_BASE(i)                          (0x0200 + ((i) << 3))
+#define WINDOW_SIZE(i)                          (0x0204 + ((i) << 3))
+#define WINDOW_REMAP_HIGH(i)                    (0x0280 + ((i) << 2))
+#define WINDOW_BAR_ENABLE                       0x0290
+#define WINDOW_PROTECT(i)                       (0x0294 + ((i) << 4))
 
 /*
  * Per-port registers.
@@ -507,9 +512,23 @@ struct mv643xx_mib_counters {
         u32 late_collision;
 };
 
+struct mv643xx_shared_private {
+        void __iomem *eth_base;
+
+        /* used to protect SMI_REG, which is shared across ports */
+        spinlock_t phy_lock;
+
+        u32 win_protect;
+
+        unsigned int t_clk;
+};
+
 struct mv643xx_private {
+        struct mv643xx_shared_private *shared;
         int port_num;                   /* User Ethernet port number    */
 
+        struct mv643xx_shared_private *shared_smi;
+
         u32 rx_sram_addr;               /* Base address of rx sram area */
         u32 rx_sram_size;               /* Size of rx sram area         */
         u32 tx_sram_addr;               /* Base address of tx sram area */
@@ -614,19 +633,14 @@ static const struct ethtool_ops mv643xx_ethtool_ops;
 static char mv643xx_driver_name[] = "mv643xx_eth";
 static char mv643xx_driver_version[] = "1.0";
 
-static void __iomem *mv643xx_eth_base;
-
-/* used to protect SMI_REG, which is shared across ports */
-static DEFINE_SPINLOCK(mv643xx_eth_phy_lock);
-
 static inline u32 rdl(struct mv643xx_private *mp, int offset)
 {
-        return readl(mv643xx_eth_base + offset);
+        return readl(mp->shared->eth_base + offset);
 }
 
 static inline void wrl(struct mv643xx_private *mp, int offset, u32 data)
 {
-        writel(data, mv643xx_eth_base + offset);
+        writel(data, mp->shared->eth_base + offset);
 }
 
 /*
@@ -1119,7 +1133,6 @@ static irqreturn_t mv643xx_eth_int_handler(int irq, void *dev_id)
  *
  * INPUT:
  *      struct mv643xx_private *mp      Ethernet port
- *      unsigned int t_clk              t_clk of the MV-643xx chip in HZ units
  *      unsigned int delay              Delay in usec
  *
  * OUTPUT:
@@ -1130,10 +1143,10 @@ static irqreturn_t mv643xx_eth_int_handler(int irq, void *dev_id)
  *
  */
 static unsigned int eth_port_set_rx_coal(struct mv643xx_private *mp,
-                                        unsigned int t_clk, unsigned int delay)
+                                        unsigned int delay)
 {
         unsigned int port_num = mp->port_num;
-        unsigned int coal = ((t_clk / 1000000) * delay) / 64;
+        unsigned int coal = ((mp->shared->t_clk / 1000000) * delay) / 64;
 
         /* Set RX Coalescing mechanism */
         wrl(mp, SDMA_CONFIG_REG(port_num),
@@ -1158,7 +1171,6 @@ static unsigned int eth_port_set_rx_coal(struct mv643xx_private *mp,
  *
  * INPUT:
  *      struct mv643xx_private *mp      Ethernet port
- *      unsigned int t_clk              t_clk of the MV-643xx chip in HZ units
  *      unsigned int delay              Delay in uSeconds
  *
  * OUTPUT:
@@ -1169,9 +1181,9 @@ static unsigned int eth_port_set_rx_coal(struct mv643xx_private *mp,
  *
  */
 static unsigned int eth_port_set_tx_coal(struct mv643xx_private *mp,
-                                        unsigned int t_clk, unsigned int delay)
+                                        unsigned int delay)
 {
-        unsigned int coal = ((t_clk / 1000000) * delay) / 64;
+        unsigned int coal = ((mp->shared->t_clk / 1000000) * delay) / 64;
 
         /* Set TX Coalescing mechanism */
         wrl(mp, TX_FIFO_URGENT_THRESHOLD_REG(mp->port_num), coal << 4);
@@ -1413,11 +1425,11 @@ static int mv643xx_eth_open(struct net_device *dev)
 
 #ifdef MV643XX_COAL
         mp->rx_int_coal =
-                eth_port_set_rx_coal(mp, 133000000, MV643XX_RX_COAL);
+                eth_port_set_rx_coal(mp, MV643XX_RX_COAL);
 #endif
 
         mp->tx_int_coal =
-                eth_port_set_tx_coal(mp, 133000000, MV643XX_TX_COAL);
+                eth_port_set_tx_coal(mp, MV643XX_TX_COAL);
 
         /* Unmask phy and link status changes interrupts */
         wrl(mp, INTERRUPT_EXTEND_MASK_REG(port_num), ETH_INT_UNMASK_ALL_EXT);
@@ -1827,6 +1839,11 @@ static int mv643xx_eth_probe(struct platform_device *pdev)
                 return -ENODEV;
         }
 
+        if (pd->shared == NULL) {
+                printk(KERN_ERR "No mv643xx_eth_platform_data->shared\n");
+                return -ENODEV;
+        }
+
         dev = alloc_etherdev(sizeof(struct mv643xx_private));
         if (!dev)
                 return -ENOMEM;
@@ -1877,8 +1894,16 @@ static int mv643xx_eth_probe(struct platform_device *pdev)
 
         spin_lock_init(&mp->lock);
 
+        mp->shared = platform_get_drvdata(pd->shared);
         port_num = mp->port_num = pd->port_number;
 
+        if (mp->shared->win_protect)
+                wrl(mp, WINDOW_PROTECT(port_num), mp->shared->win_protect);
+
+        mp->shared_smi = mp->shared;
+        if (pd->shared_smi != NULL)
+                mp->shared_smi = platform_get_drvdata(pd->shared_smi);
+
         /* set default config values */
         eth_port_uc_addr_get(mp, dev->dev_addr);
         mp->rx_ring_size = PORT_DEFAULT_RECEIVE_QUEUE_SIZE;
@@ -1983,30 +2008,91 @@ static int mv643xx_eth_remove(struct platform_device *pdev)
         return 0;
 }
 
+static void mv643xx_eth_conf_mbus_windows(struct mv643xx_shared_private *msp,
+                                          struct mbus_dram_target_info *dram)
+{
+        void __iomem *base = msp->eth_base;
+        u32 win_enable;
+        u32 win_protect;
+        int i;
+
+        for (i = 0; i < 6; i++) {
+                writel(0, base + WINDOW_BASE(i));
+                writel(0, base + WINDOW_SIZE(i));
+                if (i < 4)
+                        writel(0, base + WINDOW_REMAP_HIGH(i));
+        }
+
+        win_enable = 0x3f;
+        win_protect = 0;
+
+        for (i = 0; i < dram->num_cs; i++) {
+                struct mbus_dram_window *cs = dram->cs + i;
+
+                writel((cs->base & 0xffff0000) |
+                        (cs->mbus_attr << 8) |
+                        dram->mbus_dram_target_id, base + WINDOW_BASE(i));
+                writel((cs->size - 1) & 0xffff0000, base + WINDOW_SIZE(i));
+
+                win_enable &= ~(1 << i);
+                win_protect |= 3 << (2 * i);
+        }
+
+        writel(win_enable, base + WINDOW_BAR_ENABLE);
+        msp->win_protect = win_protect;
+}
+
 static int mv643xx_eth_shared_probe(struct platform_device *pdev)
 {
         static int mv643xx_version_printed = 0;
+        struct mv643xx_eth_shared_platform_data *pd = pdev->dev.platform_data;
+        struct mv643xx_shared_private *msp;
         struct resource *res;
+        int ret;
 
         if (!mv643xx_version_printed++)
                 printk(KERN_NOTICE "MV-643xx 10/100/1000 Ethernet Driver\n");
 
+        ret = -EINVAL;
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         if (res == NULL)
-                return -ENODEV;
+                goto out;
 
-        mv643xx_eth_base = ioremap(res->start, res->end - res->start + 1);
-        if (mv643xx_eth_base == NULL)
-                return -ENOMEM;
+        ret = -ENOMEM;
+        msp = kmalloc(sizeof(*msp), GFP_KERNEL);
+        if (msp == NULL)
+                goto out;
+        memset(msp, 0, sizeof(*msp));
+
+        msp->eth_base = ioremap(res->start, res->end - res->start + 1);
+        if (msp->eth_base == NULL)
+                goto out_free;
+
+        spin_lock_init(&msp->phy_lock);
+        msp->t_clk = (pd != NULL && pd->t_clk != 0) ? pd->t_clk : 133000000;
+
+        platform_set_drvdata(pdev, msp);
+
+        /*
+         * (Re-)program MBUS remapping windows if we are asked to.
+         */
+        if (pd != NULL && pd->dram != NULL)
+                mv643xx_eth_conf_mbus_windows(msp, pd->dram);
 
         return 0;
 
+out_free:
+        kfree(msp);
+out:
+        return ret;
 }
 
 static int mv643xx_eth_shared_remove(struct platform_device *pdev)
 {
-        iounmap(mv643xx_eth_base);
-        mv643xx_eth_base = NULL;
+        struct mv643xx_shared_private *msp = platform_get_drvdata(pdev);
+
+        iounmap(msp->eth_base);
+        kfree(msp);
 
         return 0;
 }
@@ -2906,15 +2992,16 @@ static void eth_port_reset(struct mv643xx_private *mp)
 static void eth_port_read_smi_reg(struct mv643xx_private *mp,
                                 unsigned int phy_reg, unsigned int *value)
 {
+        void __iomem *smi_reg = mp->shared_smi->eth_base + SMI_REG;
         int phy_addr = ethernet_phy_get(mp);
         unsigned long flags;
         int i;
 
         /* the SMI register is a shared resource */
-        spin_lock_irqsave(&mv643xx_eth_phy_lock, flags);
+        spin_lock_irqsave(&mp->shared_smi->phy_lock, flags);
 
         /* wait for the SMI register to become available */
-        for (i = 0; rdl(mp, SMI_REG) & ETH_SMI_BUSY; i++) {
+        for (i = 0; readl(smi_reg) & ETH_SMI_BUSY; i++) {
                 if (i == PHY_WAIT_ITERATIONS) {
                         printk("%s: PHY busy timeout\n", mp->dev->name);
                         goto out;
@@ -2922,11 +3009,11 @@ static void eth_port_read_smi_reg(struct mv643xx_private *mp,
                 udelay(PHY_WAIT_MICRO_SECONDS);
         }
 
-        wrl(mp, SMI_REG,
-                (phy_addr << 16) | (phy_reg << 21) | ETH_SMI_OPCODE_READ);
+        writel((phy_addr << 16) | (phy_reg << 21) | ETH_SMI_OPCODE_READ,
+                smi_reg);
 
         /* now wait for the data to be valid */
-        for (i = 0; !(rdl(mp, SMI_REG) & ETH_SMI_READ_VALID); i++) {
+        for (i = 0; !(readl(smi_reg) & ETH_SMI_READ_VALID); i++) {
                 if (i == PHY_WAIT_ITERATIONS) {
                         printk("%s: PHY read timeout\n", mp->dev->name);
                         goto out;
@@ -2934,9 +3021,9 @@ static void eth_port_read_smi_reg(struct mv643xx_private *mp,
                 udelay(PHY_WAIT_MICRO_SECONDS);
         }
 
-        *value = rdl(mp, SMI_REG) & 0xffff;
+        *value = readl(smi_reg) & 0xffff;
 out:
-        spin_unlock_irqrestore(&mv643xx_eth_phy_lock, flags);
+        spin_unlock_irqrestore(&mp->shared_smi->phy_lock, flags);
 }
 
 /*
@@ -2962,17 +3049,16 @@ out:
 static void eth_port_write_smi_reg(struct mv643xx_private *mp,
                                    unsigned int phy_reg, unsigned int value)
 {
-        int phy_addr;
-        int i;
+        void __iomem *smi_reg = mp->shared_smi->eth_base + SMI_REG;
+        int phy_addr = ethernet_phy_get(mp);
         unsigned long flags;
-
-        phy_addr = ethernet_phy_get(mp);
+        int i;
 
         /* the SMI register is a shared resource */
-        spin_lock_irqsave(&mv643xx_eth_phy_lock, flags);
+        spin_lock_irqsave(&mp->shared_smi->phy_lock, flags);
 
         /* wait for the SMI register to become available */
-        for (i = 0; rdl(mp, SMI_REG) & ETH_SMI_BUSY; i++) {
+        for (i = 0; readl(smi_reg) & ETH_SMI_BUSY; i++) {
                 if (i == PHY_WAIT_ITERATIONS) {
                         printk("%s: PHY busy timeout\n", mp->dev->name);
                         goto out;
@@ -2980,10 +3066,10 @@ static void eth_port_write_smi_reg(struct mv643xx_private *mp,
                 udelay(PHY_WAIT_MICRO_SECONDS);
         }
 
-        wrl(mp, SMI_REG, (phy_addr << 16) | (phy_reg << 21) |
-                                ETH_SMI_OPCODE_WRITE | (value & 0xffff));
+        writel((phy_addr << 16) | (phy_reg << 21) |
+                ETH_SMI_OPCODE_WRITE | (value & 0xffff), smi_reg);
 out:
-        spin_unlock_irqrestore(&mv643xx_eth_phy_lock, flags);
+        spin_unlock_irqrestore(&mp->shared_smi->phy_lock, flags);
 }
 
 /*
diff --git a/drivers/net/niu.c b/drivers/net/niu.c
index 4009c4ce96b4..57cfd72ffdf7 100644
--- a/drivers/net/niu.c
+++ b/drivers/net/niu.c
@@ -1,6 +1,6 @@
 /* niu.c: Neptune ethernet driver.
  *
- * Copyright (C) 2007 David S. Miller (davem@davemloft.net)
+ * Copyright (C) 2007, 2008 David S. Miller (davem@davemloft.net)
  */
 
 #include <linux/module.h>
@@ -33,8 +33,8 @@
 
 #define DRV_MODULE_NAME         "niu"
 #define PFX DRV_MODULE_NAME     ": "
-#define DRV_MODULE_VERSION      "0.8"
-#define DRV_MODULE_RELDATE      "April 24, 2008"
+#define DRV_MODULE_VERSION      "0.9"
+#define DRV_MODULE_RELDATE      "May 4, 2008"
 
 static char version[] __devinitdata =
         DRV_MODULE_NAME ".c:v" DRV_MODULE_VERSION " (" DRV_MODULE_RELDATE ")\n";
@@ -7264,8 +7264,11 @@ static int __devinit niu_get_and_validate_port(struct niu *np)
                                 parent->num_ports = nr64(ESPC_NUM_PORTS_MACS) &
                                         ESPC_NUM_PORTS_MACS_VAL;
 
+                                /* All of the current probing methods fail on
+                                 * Maramba on-board parts.
+                                 */
                                 if (!parent->num_ports)
-                                        return -ENODEV;
+                                        parent->num_ports = 4;
                         }
                 }
         }
diff --git a/drivers/net/pcnet32.c b/drivers/net/pcnet32.c
index 4eb322e5273d..a1c454dbc164 100644
--- a/drivers/net/pcnet32.c
+++ b/drivers/net/pcnet32.c
@@ -22,12 +22,8 @@
  *************************************************************************/
 
 #define DRV_NAME        "pcnet32"
-#ifdef CONFIG_PCNET32_NAPI
-#define DRV_VERSION     "1.34-NAPI"
-#else
-#define DRV_VERSION     "1.34"
-#endif
-#define DRV_RELDATE     "14.Aug.2007"
+#define DRV_VERSION     "1.35"
+#define DRV_RELDATE     "21.Apr.2008"
 #define PFX             DRV_NAME ": "
 
 static const char *const version =
@@ -445,30 +441,24 @@ static struct pcnet32_access pcnet32_dwio = {
 
 static void pcnet32_netif_stop(struct net_device *dev)
 {
-#ifdef CONFIG_PCNET32_NAPI
         struct pcnet32_private *lp = netdev_priv(dev);
-#endif
+
         dev->trans_start = jiffies;
-#ifdef CONFIG_PCNET32_NAPI
         napi_disable(&lp->napi);
-#endif
         netif_tx_disable(dev);
 }
 
 static void pcnet32_netif_start(struct net_device *dev)
 {
-#ifdef CONFIG_PCNET32_NAPI
         struct pcnet32_private *lp = netdev_priv(dev);
         ulong ioaddr = dev->base_addr;
         u16 val;
-#endif
+
         netif_wake_queue(dev);
-#ifdef CONFIG_PCNET32_NAPI
         val = lp->a.read_csr(ioaddr, CSR3);
         val &= 0x00ff;
         lp->a.write_csr(ioaddr, CSR3, val);
         napi_enable(&lp->napi);
-#endif
 }
 
 /*
@@ -911,11 +901,7 @@ static int pcnet32_loopback_test(struct net_device *dev, uint64_t * data1)
         rc = 1;                 /* default to fail */
 
         if (netif_running(dev))
-#ifdef CONFIG_PCNET32_NAPI
                 pcnet32_netif_stop(dev);
-#else
-                pcnet32_close(dev);
-#endif
 
         spin_lock_irqsave(&lp->lock, flags);
         lp->a.write_csr(ioaddr, CSR0, CSR0_STOP);       /* stop the chip */
@@ -1046,7 +1032,6 @@ static int pcnet32_loopback_test(struct net_device *dev, uint64_t * data1)
         x = a->read_bcr(ioaddr, 32);    /* reset internal loopback */
         a->write_bcr(ioaddr, 32, (x & ~0x0002));
 
-#ifdef CONFIG_PCNET32_NAPI
         if (netif_running(dev)) {
                 pcnet32_netif_start(dev);
                 pcnet32_restart(dev, CSR0_NORMAL);
@@ -1055,16 +1040,6 @@ static int pcnet32_loopback_test(struct net_device *dev, uint64_t * data1)
                 lp->a.write_bcr(ioaddr, 20, 4); /* return to 16bit mode */
         }
         spin_unlock_irqrestore(&lp->lock, flags);
-#else
-        if (netif_running(dev)) {
-                spin_unlock_irqrestore(&lp->lock, flags);
-                pcnet32_open(dev);
-        } else {
-                pcnet32_purge_rx_ring(dev);
-                lp->a.write_bcr(ioaddr, 20, 4); /* return to 16bit mode */
-                spin_unlock_irqrestore(&lp->lock, flags);
-        }
-#endif
 
         return (rc);
 }                               /* end pcnet32_loopback_test  */
@@ -1270,11 +1245,7 @@ static void pcnet32_rx_entry(struct net_device *dev,
         }
         dev->stats.rx_bytes += skb->len;
         skb->protocol = eth_type_trans(skb, dev);
-#ifdef CONFIG_PCNET32_NAPI
         netif_receive_skb(skb);
-#else
-        netif_rx(skb);
-#endif
         dev->last_rx = jiffies;
         dev->stats.rx_packets++;
         return;
@@ -1403,7 +1374,6 @@ static int pcnet32_tx(struct net_device *dev)
         return must_restart;
 }
 
-#ifdef CONFIG_PCNET32_NAPI
 static int pcnet32_poll(struct napi_struct *napi, int budget)
 {
         struct pcnet32_private *lp = container_of(napi, struct pcnet32_private, napi);
@@ -1442,7 +1412,6 @@ static int pcnet32_poll(struct napi_struct *napi, int budget)
         }
         return work_done;
 }
-#endif
 
 #define PCNET32_REGS_PER_PHY    32
 #define PCNET32_MAX_PHYS        32
@@ -1864,9 +1833,7 @@ pcnet32_probe1(unsigned long ioaddr, int shared, struct pci_dev *pdev)
         /* napi.weight is used in both the napi and non-napi cases */
         lp->napi.weight = lp->rx_ring_size / 2;
 
-#ifdef CONFIG_PCNET32_NAPI
         netif_napi_add(dev, &lp->napi, pcnet32_poll, lp->rx_ring_size / 2);
-#endif
 
         if (fdx && !(lp->options & PCNET32_PORT_ASEL) &&
             ((cards_found >= MAX_UNITS) || full_duplex[cards_found]))
@@ -2297,9 +2264,7 @@ static int pcnet32_open(struct net_device *dev)
                 goto err_free_ring;
         }
 
-#ifdef CONFIG_PCNET32_NAPI
         napi_enable(&lp->napi);
-#endif
 
         /* Re-initialize the PCNET32, and start it when done. */
         lp->a.write_csr(ioaddr, 1, (lp->init_dma_addr & 0xffff));
@@ -2623,7 +2588,6 @@ pcnet32_interrupt(int irq, void *dev_id)
                                        dev->name, csr0);
                         /* unlike for the lance, there is no restart needed */
                 }
-#ifdef CONFIG_PCNET32_NAPI
                 if (netif_rx_schedule_prep(dev, &lp->napi)) {
                         u16 val;
                         /* set interrupt masks */
@@ -2634,24 +2598,9 @@ pcnet32_interrupt(int irq, void *dev_id)
                         __netif_rx_schedule(dev, &lp->napi);
                         break;
                 }
-#else
-                pcnet32_rx(dev, lp->napi.weight);
-                if (pcnet32_tx(dev)) {
-                        /* reset the chip to clear the error condition, then restart */
-                        lp->a.reset(ioaddr);
-                        lp->a.write_csr(ioaddr, CSR4, 0x0915); /* auto tx pad */
-                        pcnet32_restart(dev, CSR0_START);
-                        netif_wake_queue(dev);
-                }
-#endif
                 csr0 = lp->a.read_csr(ioaddr, CSR0);
         }
 
-#ifndef CONFIG_PCNET32_NAPI
-        /* Set interrupt enable. */
-        lp->a.write_csr(ioaddr, CSR0, CSR0_INTEN);
-#endif
-
         if (netif_msg_intr(lp))
                 printk(KERN_DEBUG "%s: exiting interrupt, csr0=%#4.4x.\n",
                        dev->name, lp->a.read_csr(ioaddr, CSR0));
@@ -2670,9 +2619,7 @@ static int pcnet32_close(struct net_device *dev)
         del_timer_sync(&lp->watchdog_timer);
 
         netif_stop_queue(dev);
-#ifdef CONFIG_PCNET32_NAPI
         napi_disable(&lp->napi);
-#endif
 
         spin_lock_irqsave(&lp->lock, flags);
 
diff --git a/drivers/net/phy/phy.c b/drivers/net/phy/phy.c
index 3c18bb594957..45cc2914d347 100644
--- a/drivers/net/phy/phy.c
+++ b/drivers/net/phy/phy.c
@@ -547,7 +547,7 @@ static void phy_force_reduction(struct phy_device *phydev)
  * Must not be called from interrupt context, or while the
  * phydev->lock is held.
  */
-void phy_error(struct phy_device *phydev)
+static void phy_error(struct phy_device *phydev)
 {
         mutex_lock(&phydev->lock);
         phydev->state = PHY_HALTED;
diff --git a/drivers/net/tulip/uli526x.c b/drivers/net/tulip/uli526x.c
index a59c1f224aa8..2511ca7a12aa 100644
--- a/drivers/net/tulip/uli526x.c
+++ b/drivers/net/tulip/uli526x.c
@@ -434,10 +434,6 @@ static int uli526x_open(struct net_device *dev)
 
         ULI526X_DBUG(0, "uli526x_open", 0);
 
-        ret = request_irq(dev->irq, &uli526x_interrupt, IRQF_SHARED, dev->name, dev);
-        if (ret)
-                return ret;
-
         /* system variable init */
         db->cr6_data = CR6_DEFAULT | uli526x_cr6_user_set;
         db->tx_packet_cnt = 0;
@@ -456,6 +452,10 @@ static int uli526x_open(struct net_device *dev)
         /* Initialize ULI526X board */
         uli526x_init(dev);
 
+        ret = request_irq(dev->irq, &uli526x_interrupt, IRQF_SHARED, dev->name, dev);
+        if (ret)
+                return ret;
+
         /* Active System Interface */
         netif_wake_queue(dev);
 
@@ -1368,6 +1368,12 @@ static void update_cr6(u32 cr6_data, unsigned long ioaddr)
  *      This setup frame initialize ULI526X address filter mode
  */
 
+#ifdef __BIG_ENDIAN
+#define FLT_SHIFT 16
+#else
+#define FLT_SHIFT 0
+#endif
+
 static void send_filter_frame(struct net_device *dev, int mc_cnt)
 {
         struct uli526x_board_info *db = netdev_priv(dev);
@@ -1384,27 +1390,27 @@ static void send_filter_frame(struct net_device *dev, int mc_cnt)
 
         /* Node address */
         addrptr = (u16 *) dev->dev_addr;
-        *suptr++ = addrptr[0];
-        *suptr++ = addrptr[1];
-        *suptr++ = addrptr[2];
+        *suptr++ = addrptr[0] << FLT_SHIFT;
+        *suptr++ = addrptr[1] << FLT_SHIFT;
+        *suptr++ = addrptr[2] << FLT_SHIFT;
 
         /* broadcast address */
-        *suptr++ = 0xffff;
-        *suptr++ = 0xffff;
-        *suptr++ = 0xffff;
+        *suptr++ = 0xffff << FLT_SHIFT;
+        *suptr++ = 0xffff << FLT_SHIFT;
+        *suptr++ = 0xffff << FLT_SHIFT;
 
         /* fit the multicast address */
         for (mcptr = dev->mc_list, i = 0; i < mc_cnt; i++, mcptr = mcptr->next) {
                 addrptr = (u16 *) mcptr->dmi_addr;
-                *suptr++ = addrptr[0];
-                *suptr++ = addrptr[1];
-                *suptr++ = addrptr[2];
+                *suptr++ = addrptr[0] << FLT_SHIFT;
+                *suptr++ = addrptr[1] << FLT_SHIFT;
+                *suptr++ = addrptr[2] << FLT_SHIFT;
         }
 
         for (; i<14; i++) {
-                *suptr++ = 0xffff;
-                *suptr++ = 0xffff;
-                *suptr++ = 0xffff;
+                *suptr++ = 0xffff << FLT_SHIFT;
+                *suptr++ = 0xffff << FLT_SHIFT;
+                *suptr++ = 0xffff << FLT_SHIFT;
         }
 
         /* prepare the setup frame */
diff --git a/drivers/net/ucc_geth.c b/drivers/net/ucc_geth.c
index 281ce3d39532..ca0bdac07a78 100644
--- a/drivers/net/ucc_geth.c
+++ b/drivers/net/ucc_geth.c
@@ -62,7 +62,6 @@
 #endif                          /* UGETH_VERBOSE_DEBUG */
 #define UGETH_MSG_DEFAULT       (NETIF_MSG_IFUP << 1 ) - 1
 
-void uec_set_ethtool_ops(struct net_device *netdev);
 
 static DEFINE_SPINLOCK(ugeth_lock);
 
@@ -216,7 +215,8 @@ static struct list_head *dequeue(struct list_head *lh)
         }
 }
 
-static struct sk_buff *get_new_skb(struct ucc_geth_private *ugeth, u8 *bd)
+static struct sk_buff *get_new_skb(struct ucc_geth_private *ugeth,
+                u8 __iomem *bd)
 {
         struct sk_buff *skb = NULL;
 
@@ -236,21 +236,22 @@ static struct sk_buff *get_new_skb(struct ucc_geth_private *ugeth, u8 *bd)
 
         skb->dev = ugeth->dev;
 
-        out_be32(&((struct qe_bd *)bd)->buf,
+        out_be32(&((struct qe_bd __iomem *)bd)->buf,
                       dma_map_single(NULL,
                                      skb->data,
                                      ugeth->ug_info->uf_info.max_rx_buf_length +
                                      UCC_GETH_RX_DATA_BUF_ALIGNMENT,
                                      DMA_FROM_DEVICE));
 
-        out_be32((u32 *)bd, (R_E | R_I | (in_be32((u32 *)bd) & R_W)));
+        out_be32((u32 __iomem *)bd,
+                        (R_E | R_I | (in_be32((u32 __iomem*)bd) & R_W)));
 
         return skb;
 }
 
 static int rx_bd_buffer_set(struct ucc_geth_private *ugeth, u8 rxQ)
 {
-        u8 *bd;
+        u8 __iomem *bd;
         u32 bd_status;
         struct sk_buff *skb;
         int i;
@@ -259,7 +260,7 @@ static int rx_bd_buffer_set(struct ucc_geth_private *ugeth, u8 rxQ)
         i = 0;
 
         do {
-                bd_status = in_be32((u32*)bd);
+                bd_status = in_be32((u32 __iomem *)bd);
                 skb = get_new_skb(ugeth, bd);
 
                 if (!skb)       /* If can not allocate data buffer,
@@ -277,7 +278,7 @@ static int rx_bd_buffer_set(struct ucc_geth_private *ugeth, u8 rxQ)
 }
 
 static int fill_init_enet_entries(struct ucc_geth_private *ugeth,
-                                  volatile u32 *p_start,
+                                  u32 *p_start,
                                   u8 num_entries,
                                   u32 thread_size,
                                   u32 thread_alignment,
@@ -316,7 +317,7 @@ static int fill_init_enet_entries(struct ucc_geth_private *ugeth,
 }
 
 static int return_init_enet_entries(struct ucc_geth_private *ugeth,
-                                    volatile u32 *p_start,
+                                    u32 *p_start,
                                     u8 num_entries,
                                     enum qe_risc_allocation risc,
                                     int skip_page_for_first_entry)
@@ -326,21 +327,22 @@ static int return_init_enet_entries(struct ucc_geth_private *ugeth,
         int snum;
 
         for (i = 0; i < num_entries; i++) {
+                u32 val = *p_start;
+
                 /* Check that this entry was actually valid --
                 needed in case failed in allocations */
-                if ((*p_start & ENET_INIT_PARAM_RISC_MASK) == risc) {
+                if ((val & ENET_INIT_PARAM_RISC_MASK) == risc) {
                         snum =
-                            (u32) (*p_start & ENET_INIT_PARAM_SNUM_MASK) >>
+                            (u32) (val & ENET_INIT_PARAM_SNUM_MASK) >>
                             ENET_INIT_PARAM_SNUM_SHIFT;
                         qe_put_snum((u8) snum);
                         if (!((i == 0) && skip_page_for_first_entry)) {
                         /* First entry of Rx does not have page */
                                 init_enet_offset =
-                                    (in_be32(p_start) &
-                                     ENET_INIT_PARAM_PTR_MASK);
+                                    (val & ENET_INIT_PARAM_PTR_MASK);
                                 qe_muram_free(init_enet_offset);
                         }
-                        *(p_start++) = 0;       /* Just for cosmetics */
+                        *p_start++ = 0;
                 }
         }
 
@@ -349,7 +351,7 @@ static int return_init_enet_entries(struct ucc_geth_private *ugeth,
 
 #ifdef DEBUG
 static int dump_init_enet_entries(struct ucc_geth_private *ugeth,
-                                  volatile u32 *p_start,
+                                  u32 __iomem *p_start,
                                   u8 num_entries,
                                   u32 thread_size,
                                   enum qe_risc_allocation risc,
@@ -360,11 +362,13 @@ static int dump_init_enet_entries(struct ucc_geth_private *ugeth,
         int snum;
 
         for (i = 0; i < num_entries; i++) {
+                u32 val = in_be32(p_start);
+
                 /* Check that this entry was actually valid --
                 needed in case failed in allocations */
-                if ((*p_start & ENET_INIT_PARAM_RISC_MASK) == risc) {
+                if ((val & ENET_INIT_PARAM_RISC_MASK) == risc) {
                         snum =
-                            (u32) (*p_start & ENET_INIT_PARAM_SNUM_MASK) >>
+                            (u32) (val & ENET_INIT_PARAM_SNUM_MASK) >>
                             ENET_INIT_PARAM_SNUM_SHIFT;
                         qe_put_snum((u8) snum);
                         if (!((i == 0) && skip_page_for_first_entry)) {
@@ -440,7 +444,7 @@ static int hw_add_addr_in_paddr(struct ucc_geth_private *ugeth,
 
 static int hw_clear_addr_in_paddr(struct ucc_geth_private *ugeth, u8 paddr_num)
 {
-        struct ucc_geth_82xx_address_filtering_pram *p_82xx_addr_filt;
+        struct ucc_geth_82xx_address_filtering_pram __iomem *p_82xx_addr_filt;
 
         if (!(paddr_num < NUM_OF_PADDRS)) {
                 ugeth_warn("%s: Illagel paddr_num.", __FUNCTION__);
@@ -448,7 +452,7 @@ static int hw_clear_addr_in_paddr(struct ucc_geth_private *ugeth, u8 paddr_num)
         }
 
         p_82xx_addr_filt =
-            (struct ucc_geth_82xx_address_filtering_pram *) ugeth->p_rx_glbl_pram->
+            (struct ucc_geth_82xx_address_filtering_pram __iomem *) ugeth->p_rx_glbl_pram->
             addressfiltering;
 
         /* Writing address ff.ff.ff.ff.ff.ff disables address
@@ -463,11 +467,11 @@ static int hw_clear_addr_in_paddr(struct ucc_geth_private *ugeth, u8 paddr_num)
 static void hw_add_addr_in_hash(struct ucc_geth_private *ugeth,
                                 u8 *p_enet_addr)
 {
-        struct ucc_geth_82xx_address_filtering_pram *p_82xx_addr_filt;
+        struct ucc_geth_82xx_address_filtering_pram __iomem *p_82xx_addr_filt;
         u32 cecr_subblock;
 
         p_82xx_addr_filt =
-            (struct ucc_geth_82xx_address_filtering_pram *) ugeth->p_rx_glbl_pram->
+            (struct ucc_geth_82xx_address_filtering_pram __iomem *) ugeth->p_rx_glbl_pram->
             addressfiltering;
 
         cecr_subblock =
@@ -487,7 +491,7 @@ static void hw_add_addr_in_hash(struct ucc_geth_private *ugeth,
 static void magic_packet_detection_enable(struct ucc_geth_private *ugeth)
 {
         struct ucc_fast_private *uccf;
-        struct ucc_geth *ug_regs;
+        struct ucc_geth __iomem *ug_regs;
         u32 maccfg2, uccm;
 
         uccf = ugeth->uccf;
@@ -507,7 +511,7 @@ static void magic_packet_detection_enable(struct ucc_geth_private *ugeth)
 static void magic_packet_detection_disable(struct ucc_geth_private *ugeth)
 {
         struct ucc_fast_private *uccf;
-        struct ucc_geth *ug_regs;
+        struct ucc_geth __iomem *ug_regs;
         u32 maccfg2, uccm;
 
         uccf = ugeth->uccf;
@@ -538,13 +542,13 @@ static void get_statistics(struct ucc_geth_private *ugeth,
                            rx_firmware_statistics,
                            struct ucc_geth_hardware_statistics *hardware_statistics)
 {
-        struct ucc_fast *uf_regs;
-        struct ucc_geth *ug_regs;
+        struct ucc_fast __iomem *uf_regs;
+        struct ucc_geth __iomem *ug_regs;
         struct ucc_geth_tx_firmware_statistics_pram *p_tx_fw_statistics_pram;
         struct ucc_geth_rx_firmware_statistics_pram *p_rx_fw_statistics_pram;
 
         ug_regs = ugeth->ug_regs;
-        uf_regs = (struct ucc_fast *) ug_regs;
+        uf_regs = (struct ucc_fast __iomem *) ug_regs;
         p_tx_fw_statistics_pram = ugeth->p_tx_fw_statistics_pram;
         p_rx_fw_statistics_pram = ugeth->p_rx_fw_statistics_pram;
 
@@ -1132,9 +1136,9 @@ static void dump_regs(struct ucc_geth_private *ugeth)
 }
 #endif /* DEBUG */
 
-static void init_default_reg_vals(volatile u32 *upsmr_register,
-                                  volatile u32 *maccfg1_register,
-                                  volatile u32 *maccfg2_register)
+static void init_default_reg_vals(u32 __iomem *upsmr_register,
+                                  u32 __iomem *maccfg1_register,
+                                  u32 __iomem *maccfg2_register)
 {
         out_be32(upsmr_register, UCC_GETH_UPSMR_INIT);
         out_be32(maccfg1_register, UCC_GETH_MACCFG1_INIT);
@@ -1148,7 +1152,7 @@ static int init_half_duplex_params(int alt_beb,
                                    u8 alt_beb_truncation,
                                    u8 max_retransmissions,
                                    u8 collision_window,
-                                   volatile u32 *hafdup_register)
+                                   u32 __iomem *hafdup_register)
 {
         u32 value = 0;
 
@@ -1180,7 +1184,7 @@ static int init_inter_frame_gap_params(u8 non_btb_cs_ipg,
                                        u8 non_btb_ipg,
                                        u8 min_ifg,
                                        u8 btb_ipg,
-                                       volatile u32 *ipgifg_register)
+                                       u32 __iomem *ipgifg_register)
 {
         u32 value = 0;
 
@@ -1215,9 +1219,9 @@ int init_flow_control_params(u32 automatic_flow_control_mode,
                                     int tx_flow_control_enable,
                                     u16 pause_period,
                                     u16 extension_field,
-                                    volatile u32 *upsmr_register,
-                                    volatile u32 *uempr_register,
-                                    volatile u32 *maccfg1_register)
+                                    u32 __iomem *upsmr_register,
+                                    u32 __iomem *uempr_register,
+                                    u32 __iomem *maccfg1_register)
 {
         u32 value = 0;
 
@@ -1243,8 +1247,8 @@ int init_flow_control_params(u32 automatic_flow_control_mode,
 
 static int init_hw_statistics_gathering_mode(int enable_hardware_statistics,
                                              int auto_zero_hardware_statistics,
-                                             volatile u32 *upsmr_register,
-                                             volatile u16 *uescr_register)
+                                             u32 __iomem *upsmr_register,
+                                             u16 __iomem *uescr_register)
 {
         u32 upsmr_value = 0;
         u16 uescr_value = 0;
@@ -1270,12 +1274,12 @@ static int init_hw_statistics_gathering_mode(int enable_hardware_statistics,
 static int init_firmware_statistics_gathering_mode(int
                 enable_tx_firmware_statistics,
                 int enable_rx_firmware_statistics,
-                volatile u32 *tx_rmon_base_ptr,
+                u32 __iomem *tx_rmon_base_ptr,
                 u32 tx_firmware_statistics_structure_address,
-                volatile u32 *rx_rmon_base_ptr,
+                u32 __iomem *rx_rmon_base_ptr,
                 u32 rx_firmware_statistics_structure_address,
-                volatile u16 *temoder_register,
-                volatile u32 *remoder_register)
+                u16 __iomem *temoder_register,
+                u32 __iomem *remoder_register)
 {
         /* Note: this function does not check if */
         /* the parameters it receives are NULL   */
@@ -1307,8 +1311,8 @@ static int init_mac_station_addr_regs(u8 address_byte_0,
                                       u8 address_byte_3,
                                       u8 address_byte_4,
                                       u8 address_byte_5,
-                                      volatile u32 *macstnaddr1_register,
-                                      volatile u32 *macstnaddr2_register)
+                                      u32 __iomem *macstnaddr1_register,
+                                      u32 __iomem *macstnaddr2_register)
 {
         u32 value = 0;
 
@@ -1344,7 +1348,7 @@ static int init_mac_station_addr_regs(u8 address_byte_0,
 }
 
 static int init_check_frame_length_mode(int length_check,
-                                        volatile u32 *maccfg2_register)
+                                        u32 __iomem *maccfg2_register)
 {
         u32 value = 0;
 
@@ -1360,7 +1364,7 @@ static int init_check_frame_length_mode(int length_check,
 }
 
 static int init_preamble_length(u8 preamble_length,
-                                volatile u32 *maccfg2_register)
+                                u32 __iomem *maccfg2_register)
 {
         u32 value = 0;
 
@@ -1376,7 +1380,7 @@ static int init_preamble_length(u8 preamble_length,
 
 static int init_rx_parameters(int reject_broadcast,
                               int receive_short_frames,
-                              int promiscuous, volatile u32 *upsmr_register)
+                              int promiscuous, u32 __iomem *upsmr_register)
 {
         u32 value = 0;
 
@@ -1403,7 +1407,7 @@ static int init_rx_parameters(int reject_broadcast,
 }
 
 static int init_max_rx_buff_len(u16 max_rx_buf_len,
-                                volatile u16 *mrblr_register)
+                                u16 __iomem *mrblr_register)
 {
         /* max_rx_buf_len value must be a multiple of 128 */
         if ((max_rx_buf_len == 0)
@@ -1415,8 +1419,8 @@ static int init_max_rx_buff_len(u16 max_rx_buf_len,
 }
 
 static int init_min_frame_len(u16 min_frame_length,
-                              volatile u16 *minflr_register,
-                              volatile u16 *mrblr_register)
+                              u16 __iomem *minflr_register,
+                              u16 __iomem *mrblr_register)
 {
         u16 mrblr_value = 0;
 
@@ -1431,8 +1435,8 @@ static int init_min_frame_len(u16 min_frame_length,
 static int adjust_enet_interface(struct ucc_geth_private *ugeth)
 {
         struct ucc_geth_info *ug_info;
-        struct ucc_geth *ug_regs;
-        struct ucc_fast *uf_regs;
+        struct ucc_geth __iomem *ug_regs;
+        struct ucc_fast __iomem *uf_regs;
         int ret_val;
         u32 upsmr, maccfg2, tbiBaseAddress;
         u16 value;
@@ -1517,8 +1521,8 @@ static int adjust_enet_interface(struct ucc_geth_private *ugeth)
 static void adjust_link(struct net_device *dev)
 {
         struct ucc_geth_private *ugeth = netdev_priv(dev);
-        struct ucc_geth *ug_regs;
-        struct ucc_fast *uf_regs;
+        struct ucc_geth __iomem *ug_regs;
+        struct ucc_fast __iomem *uf_regs;
         struct phy_device *phydev = ugeth->phydev;
         unsigned long flags;
         int new_state = 0;
@@ -1678,9 +1682,9 @@ static int ugeth_graceful_stop_rx(struct ucc_geth_private * ugeth)
         uccf = ugeth->uccf;
 
         /* Clear acknowledge bit */
-        temp = ugeth->p_rx_glbl_pram->rxgstpack;
+        temp = in_8(&ugeth->p_rx_glbl_pram->rxgstpack);
         temp &= ~GRACEFUL_STOP_ACKNOWLEDGE_RX;
-        ugeth->p_rx_glbl_pram->rxgstpack = temp;
+        out_8(&ugeth->p_rx_glbl_pram->rxgstpack, temp);
 
         /* Keep issuing command and checking acknowledge bit until
         it is asserted, according to spec */
@@ -1692,7 +1696,7 @@ static int ugeth_graceful_stop_rx(struct ucc_geth_private * ugeth)
                 qe_issue_cmd(QE_GRACEFUL_STOP_RX, cecr_subblock,
                              QE_CR_PROTOCOL_ETHERNET, 0);
 
-                temp = ugeth->p_rx_glbl_pram->rxgstpack;
+                temp = in_8(&ugeth->p_rx_glbl_pram->rxgstpack);
         } while (!(temp & GRACEFUL_STOP_ACKNOWLEDGE_RX));
 
         uccf->stopped_rx = 1;
@@ -1991,19 +1995,20 @@ static int ugeth_82xx_filtering_clear_all_addr_in_hash(struct ucc_geth_private *
                                                        enum enet_addr_type
                                                        enet_addr_type)
 {
-        struct ucc_geth_82xx_address_filtering_pram *p_82xx_addr_filt;
+        struct ucc_geth_82xx_address_filtering_pram __iomem *p_82xx_addr_filt;
         struct ucc_fast_private *uccf;
         enum comm_dir comm_dir;
         struct list_head *p_lh;
         u16 i, num;
-        u32 *addr_h, *addr_l;
+        u32 __iomem *addr_h;
+        u32 __iomem *addr_l;
         u8 *p_counter;
 
         uccf = ugeth->uccf;
 
         p_82xx_addr_filt =
-            (struct ucc_geth_82xx_address_filtering_pram *) ugeth->p_rx_glbl_pram->
-            addressfiltering;
+            (struct ucc_geth_82xx_address_filtering_pram __iomem *)
+            ugeth->p_rx_glbl_pram->addressfiltering;
 
         if (enet_addr_type == ENET_ADDR_TYPE_GROUP) {
                 addr_h = &(p_82xx_addr_filt->gaddr_h);
@@ -2079,7 +2084,7 @@ static int ugeth_82xx_filtering_clear_addr_in_paddr(struct ucc_geth_private *uge
 static void ucc_geth_memclean(struct ucc_geth_private *ugeth)
 {
         u16 i, j;
-        u8 *bd;
+        u8 __iomem *bd;
 
         if (!ugeth)
                 return;
@@ -2154,8 +2159,8 @@ static void ucc_geth_memclean(struct ucc_geth_private *ugeth)
                 for (j = 0; j < ugeth->ug_info->bdRingLenTx[i]; j++) {
                         if (ugeth->tx_skbuff[i][j]) {
                                 dma_unmap_single(NULL,
-                                                 ((struct qe_bd *)bd)->buf,
-                                                 (in_be32((u32 *)bd) &
+                                                 in_be32(&((struct qe_bd __iomem *)bd)->buf),
+                                                 (in_be32((u32 __iomem *)bd) &
                                                   BD_LENGTH_MASK),
                                                  DMA_TO_DEVICE);
                                 dev_kfree_skb_any(ugeth->tx_skbuff[i][j]);
@@ -2182,7 +2187,7 @@ static void ucc_geth_memclean(struct ucc_geth_private *ugeth)
                         for (j = 0; j < ugeth->ug_info->bdRingLenRx[i]; j++) {
                                 if (ugeth->rx_skbuff[i][j]) {
                                         dma_unmap_single(NULL,
-                                                ((struct qe_bd *)bd)->buf,
+                                                in_be32(&((struct qe_bd __iomem *)bd)->buf),
                                                 ugeth->ug_info->
                                                 uf_info.max_rx_buf_length +
                                                 UCC_GETH_RX_DATA_BUF_ALIGNMENT,
@@ -2218,8 +2223,8 @@ static void ucc_geth_set_multi(struct net_device *dev)
 {
         struct ucc_geth_private *ugeth;
         struct dev_mc_list *dmi;
-        struct ucc_fast *uf_regs;
-        struct ucc_geth_82xx_address_filtering_pram *p_82xx_addr_filt;
+        struct ucc_fast __iomem *uf_regs;
+        struct ucc_geth_82xx_address_filtering_pram __iomem *p_82xx_addr_filt;
         int i;
 
         ugeth = netdev_priv(dev);
@@ -2228,14 +2233,14 @@ static void ucc_geth_set_multi(struct net_device *dev)
 
         if (dev->flags & IFF_PROMISC) {
 
-                uf_regs->upsmr |= UPSMR_PRO;
+                out_be32(&uf_regs->upsmr, in_be32(&uf_regs->upsmr) | UPSMR_PRO);
 
         } else {
 
-                uf_regs->upsmr &= ~UPSMR_PRO;
+                out_be32(&uf_regs->upsmr, in_be32(&uf_regs->upsmr)&~UPSMR_PRO);
 
                 p_82xx_addr_filt =
-                    (struct ucc_geth_82xx_address_filtering_pram *) ugeth->
+                    (struct ucc_geth_82xx_address_filtering_pram __iomem *) ugeth->
                     p_rx_glbl_pram->addressfiltering;
 
                 if (dev->flags & IFF_ALLMULTI) {
@@ -2270,7 +2275,7 @@ static void ucc_geth_set_multi(struct net_device *dev)
 
 static void ucc_geth_stop(struct ucc_geth_private *ugeth)
 {
-        struct ucc_geth *ug_regs = ugeth->ug_regs;
+        struct ucc_geth __iomem *ug_regs = ugeth->ug_regs;
         struct phy_device *phydev = ugeth->phydev;
         u32 tempval;
 
@@ -2419,20 +2424,20 @@ static int ucc_struct_init(struct ucc_geth_private *ugeth)
                 return -ENOMEM;
         }
 
-        ugeth->ug_regs = (struct ucc_geth *) ioremap(uf_info->regs, sizeof(struct ucc_geth));
+        ugeth->ug_regs = (struct ucc_geth __iomem *) ioremap(uf_info->regs, sizeof(struct ucc_geth));
 
         return 0;
 }
 
 static int ucc_geth_startup(struct ucc_geth_private *ugeth)
 {
-        struct ucc_geth_82xx_address_filtering_pram *p_82xx_addr_filt;
-        struct ucc_geth_init_pram *p_init_enet_pram;
+        struct ucc_geth_82xx_address_filtering_pram __iomem *p_82xx_addr_filt;
+        struct ucc_geth_init_pram __iomem *p_init_enet_pram;
         struct ucc_fast_private *uccf;
         struct ucc_geth_info *ug_info;
         struct ucc_fast_info *uf_info;
-        struct ucc_fast *uf_regs;
-        struct ucc_geth *ug_regs;
+        struct ucc_fast __iomem *uf_regs;
+        struct ucc_geth __iomem *ug_regs;
         int ret_val = -EINVAL;
         u32 remoder = UCC_GETH_REMODER_INIT;
         u32 init_enet_pram_offset, cecr_subblock, command, maccfg1;
@@ -2440,7 +2445,8 @@ static int ucc_geth_startup(struct ucc_geth_private *ugeth)
         u16 temoder = UCC_GETH_TEMODER_INIT;
         u16 test;
         u8 function_code = 0;
-        u8 *bd, *endOfRing;
+        u8 __iomem *bd;
+        u8 __iomem *endOfRing;
         u8 numThreadsRxNumerical, numThreadsTxNumerical;
 
         ugeth_vdbg("%s: IN", __FUNCTION__);
@@ -2602,11 +2608,11 @@ static int ucc_geth_startup(struct ucc_geth_private *ugeth)
                         if (UCC_GETH_TX_BD_RING_ALIGNMENT > 4)
                                 align = UCC_GETH_TX_BD_RING_ALIGNMENT;
                         ugeth->tx_bd_ring_offset[j] =
-                                kmalloc((u32) (length + align), GFP_KERNEL);
+                                (u32) kmalloc((u32) (length + align), GFP_KERNEL);
 
                         if (ugeth->tx_bd_ring_offset[j] != 0)
                                 ugeth->p_tx_bd_ring[j] =
-                                        (void*)((ugeth->tx_bd_ring_offset[j] +
+                                        (u8 __iomem *)((ugeth->tx_bd_ring_offset[j] +
                                         align) & ~(align - 1));
                 } else if (uf_info->bd_mem_part == MEM_PART_MURAM) {
                         ugeth->tx_bd_ring_offset[j] =
@@ -2614,7 +2620,7 @@ static int ucc_geth_startup(struct ucc_geth_private *ugeth)
                                            UCC_GETH_TX_BD_RING_ALIGNMENT);
                         if (!IS_ERR_VALUE(ugeth->tx_bd_ring_offset[j]))
                                 ugeth->p_tx_bd_ring[j] =
-                                    (u8 *) qe_muram_addr(ugeth->
+                                    (u8 __iomem *) qe_muram_addr(ugeth->
                                                          tx_bd_ring_offset[j]);
                 }
                 if (!ugeth->p_tx_bd_ring[j]) {
@@ -2626,8 +2632,8 @@ static int ucc_geth_startup(struct ucc_geth_private *ugeth)
                         return -ENOMEM;
                 }
                 /* Zero unused end of bd ring, according to spec */
-                memset(ugeth->p_tx_bd_ring[j] +
-                       ug_info->bdRingLenTx[j] * sizeof(struct qe_bd), 0,
+                memset_io((void __iomem *)(ugeth->p_tx_bd_ring[j] +
+                       ug_info->bdRingLenTx[j] * sizeof(struct qe_bd)), 0,
                        length - ug_info->bdRingLenTx[j] * sizeof(struct qe_bd));
         }
 
@@ -2639,10 +2645,10 @@ static int ucc_geth_startup(struct ucc_geth_private *ugeth)
                         if (UCC_GETH_RX_BD_RING_ALIGNMENT > 4)
                                 align = UCC_GETH_RX_BD_RING_ALIGNMENT;
                         ugeth->rx_bd_ring_offset[j] =
-                                kmalloc((u32) (length + align), GFP_KERNEL);
+                                (u32) kmalloc((u32) (length + align), GFP_KERNEL);
                         if (ugeth->rx_bd_ring_offset[j] != 0)
                                 ugeth->p_rx_bd_ring[j] =
-                                        (void*)((ugeth->rx_bd_ring_offset[j] +
+                                        (u8 __iomem *)((ugeth->rx_bd_ring_offset[j] +
                                         align) & ~(align - 1));
                 } else if (uf_info->bd_mem_part == MEM_PART_MURAM) {
                         ugeth->rx_bd_ring_offset[j] =
@@ -2650,7 +2656,7 @@ static int ucc_geth_startup(struct ucc_geth_private *ugeth)
                                            UCC_GETH_RX_BD_RING_ALIGNMENT);
                         if (!IS_ERR_VALUE(ugeth->rx_bd_ring_offset[j]))
                                 ugeth->p_rx_bd_ring[j] =
-                                    (u8 *) qe_muram_addr(ugeth->
+                                    (u8 __iomem *) qe_muram_addr(ugeth->
                                                          rx_bd_ring_offset[j]);
                 }
                 if (!ugeth->p_rx_bd_ring[j]) {
@@ -2685,14 +2691,14 @@ static int ucc_geth_startup(struct ucc_geth_private *ugeth)
                 bd = ugeth->confBd[j] = ugeth->txBd[j] = ugeth->p_tx_bd_ring[j];
                 for (i = 0; i < ug_info->bdRingLenTx[j]; i++) {
                         /* clear bd buffer */
-                        out_be32(&((struct qe_bd *)bd)->buf, 0);
+                        out_be32(&((struct qe_bd __iomem *)bd)->buf, 0);
                         /* set bd status and length */
-                        out_be32((u32 *)bd, 0);
+                        out_be32((u32 __iomem *)bd, 0);
                         bd += sizeof(struct qe_bd);
                 }
                 bd -= sizeof(struct qe_bd);
                 /* set bd status and length */
-                out_be32((u32 *)bd, T_W);       /* for last BD set Wrap bit */
+                out_be32((u32 __iomem *)bd, T_W); /* for last BD set Wrap bit */
         }
 
         /* Init Rx bds */
@@ -2717,14 +2723,14 @@ static int ucc_geth_startup(struct ucc_geth_private *ugeth)
                 bd = ugeth->rxBd[j] = ugeth->p_rx_bd_ring[j];
                 for (i = 0; i < ug_info->bdRingLenRx[j]; i++) {
                         /* set bd status and length */
-                        out_be32((u32 *)bd, R_I);
+                        out_be32((u32 __iomem *)bd, R_I);
                         /* clear bd buffer */
-                        out_be32(&((struct qe_bd *)bd)->buf, 0);
+                        out_be32(&((struct qe_bd __iomem *)bd)->buf, 0);
                         bd += sizeof(struct qe_bd);
                 }
                 bd -= sizeof(struct qe_bd);
                 /* set bd status and length */
-                out_be32((u32 *)bd, R_W); /* for last BD set Wrap bit */
+                out_be32((u32 __iomem *)bd, R_W); /* for last BD set Wrap bit */
         }
 
         /*
@@ -2744,10 +2750,10 @@ static int ucc_geth_startup(struct ucc_geth_private *ugeth)
                 return -ENOMEM;
         }
         ugeth->p_tx_glbl_pram =
-            (struct ucc_geth_tx_global_pram *) qe_muram_addr(ugeth->
+            (struct ucc_geth_tx_global_pram __iomem *) qe_muram_addr(ugeth->
                                                         tx_glbl_pram_offset);
         /* Zero out p_tx_glbl_pram */
-        memset(ugeth->p_tx_glbl_pram, 0, sizeof(struct ucc_geth_tx_global_pram));
+        memset_io((void __iomem *)ugeth->p_tx_glbl_pram, 0, sizeof(struct ucc_geth_tx_global_pram));
 
         /* Fill global PRAM */
 
@@ -2768,7 +2774,7 @@ static int ucc_geth_startup(struct ucc_geth_private *ugeth)
         }
 
         ugeth->p_thread_data_tx =
-            (struct ucc_geth_thread_data_tx *) qe_muram_addr(ugeth->
+            (struct ucc_geth_thread_data_tx __iomem *) qe_muram_addr(ugeth->
                                                         thread_dat_tx_offset);
         out_be32(&ugeth->p_tx_glbl_pram->tqptr, ugeth->thread_dat_tx_offset);
 
@@ -2779,7 +2785,8 @@ static int ucc_geth_startup(struct ucc_geth_private *ugeth)
 
         /* iphoffset */
         for (i = 0; i < TX_IP_OFFSET_ENTRY_MAX; i++)
-                ugeth->p_tx_glbl_pram->iphoffset[i] = ug_info->iphoffset[i];
+                out_8(&ugeth->p_tx_glbl_pram->iphoffset[i],
+                                ug_info->iphoffset[i]);
 
         /* SQPTR */
         /* Size varies with number of Tx queues */
@@ -2797,7 +2804,7 @@ static int ucc_geth_startup(struct ucc_geth_private *ugeth)
         }
 
         ugeth->p_send_q_mem_reg =
-            (struct ucc_geth_send_queue_mem_region *) qe_muram_addr(ugeth->
+            (struct ucc_geth_send_queue_mem_region __iomem *) qe_muram_addr(ugeth->
                         send_q_mem_reg_offset);
         out_be32(&ugeth->p_tx_glbl_pram->sqptr, ugeth->send_q_mem_reg_offset);
 
@@ -2841,25 +2848,26 @@ static int ucc_geth_startup(struct ucc_geth_private *ugeth)
                 }
 
                 ugeth->p_scheduler =
-                    (struct ucc_geth_scheduler *) qe_muram_addr(ugeth->
+                    (struct ucc_geth_scheduler __iomem *) qe_muram_addr(ugeth->
                                                            scheduler_offset);
                 out_be32(&ugeth->p_tx_glbl_pram->schedulerbasepointer,
                          ugeth->scheduler_offset);
                 /* Zero out p_scheduler */
-                memset(ugeth->p_scheduler, 0, sizeof(struct ucc_geth_scheduler));
+                memset_io((void __iomem *)ugeth->p_scheduler, 0, sizeof(struct ucc_geth_scheduler));
 
                 /* Set values in scheduler */
                 out_be32(&ugeth->p_scheduler->mblinterval,
                          ug_info->mblinterval);
                 out_be16(&ugeth->p_scheduler->nortsrbytetime,
                          ug_info->nortsrbytetime);
-                ugeth->p_scheduler->fracsiz = ug_info->fracsiz;
-                ugeth->p_scheduler->strictpriorityq = ug_info->strictpriorityq;
-                ugeth->p_scheduler->txasap = ug_info->txasap;
-                ugeth->p_scheduler->extrabw = ug_info->extrabw;
+                out_8(&ugeth->p_scheduler->fracsiz, ug_info->fracsiz);
+                out_8(&ugeth->p_scheduler->strictpriorityq,
+                                ug_info->strictpriorityq);
+                out_8(&ugeth->p_scheduler->txasap, ug_info->txasap);
+                out_8(&ugeth->p_scheduler->extrabw, ug_info->extrabw);
                 for (i = 0; i < NUM_TX_QUEUES; i++)
-                        ugeth->p_scheduler->weightfactor[i] =
-                            ug_info->weightfactor[i];
+                        out_8(&ugeth->p_scheduler->weightfactor[i],
+                            ug_info->weightfactor[i]);
 
                 /* Set pointers to cpucount registers in scheduler */
                 ugeth->p_cpucount[0] = &(ugeth->p_scheduler->cpucount0);
@@ -2890,10 +2898,10 @@ static int ucc_geth_startup(struct ucc_geth_private *ugeth)
                         return -ENOMEM;
                 }
                 ugeth->p_tx_fw_statistics_pram =
-                    (struct ucc_geth_tx_firmware_statistics_pram *)
+                    (struct ucc_geth_tx_firmware_statistics_pram __iomem *)
                     qe_muram_addr(ugeth->tx_fw_statistics_pram_offset);
                 /* Zero out p_tx_fw_statistics_pram */
-                memset(ugeth->p_tx_fw_statistics_pram,
+                memset_io((void __iomem *)ugeth->p_tx_fw_statistics_pram,
                        0, sizeof(struct ucc_geth_tx_firmware_statistics_pram));
         }
 
@@ -2930,10 +2938,10 @@ static int ucc_geth_startup(struct ucc_geth_private *ugeth)
                 return -ENOMEM;
         }
         ugeth->p_rx_glbl_pram =
-            (struct ucc_geth_rx_global_pram *) qe_muram_addr(ugeth->
+            (struct ucc_geth_rx_global_pram __iomem *) qe_muram_addr(ugeth->
                                                         rx_glbl_pram_offset);
         /* Zero out p_rx_glbl_pram */
-        memset(ugeth->p_rx_glbl_pram, 0, sizeof(struct ucc_geth_rx_global_pram));
+        memset_io((void __iomem *)ugeth->p_rx_glbl_pram, 0, sizeof(struct ucc_geth_rx_global_pram));
 
         /* Fill global PRAM */
 
@@ -2953,7 +2961,7 @@ static int ucc_geth_startup(struct ucc_geth_private *ugeth)
         }
 
         ugeth->p_thread_data_rx =
-            (struct ucc_geth_thread_data_rx *) qe_muram_addr(ugeth->
+            (struct ucc_geth_thread_data_rx __iomem *) qe_muram_addr(ugeth->
                                                         thread_dat_rx_offset);
         out_be32(&ugeth->p_rx_glbl_pram->rqptr, ugeth->thread_dat_rx_offset);
 
@@ -2976,10 +2984,10 @@ static int ucc_geth_startup(struct ucc_geth_private *ugeth)
                         return -ENOMEM;
                 }
                 ugeth->p_rx_fw_statistics_pram =
-                    (struct ucc_geth_rx_firmware_statistics_pram *)
+                    (struct ucc_geth_rx_firmware_statistics_pram __iomem *)
                     qe_muram_addr(ugeth->rx_fw_statistics_pram_offset);
                 /* Zero out p_rx_fw_statistics_pram */
-                memset(ugeth->p_rx_fw_statistics_pram, 0,
+                memset_io((void __iomem *)ugeth->p_rx_fw_statistics_pram, 0,
                        sizeof(struct ucc_geth_rx_firmware_statistics_pram));
         }
 
@@ -3000,7 +3008,7 @@ static int ucc_geth_startup(struct ucc_geth_private *ugeth)
         }
 
         ugeth->p_rx_irq_coalescing_tbl =
-            (struct ucc_geth_rx_interrupt_coalescing_table *)
+            (struct ucc_geth_rx_interrupt_coalescing_table __iomem *)
             qe_muram_addr(ugeth->rx_irq_coalescing_tbl_offset);
         out_be32(&ugeth->p_rx_glbl_pram->intcoalescingptr,
                  ugeth->rx_irq_coalescing_tbl_offset);
@@ -3069,11 +3077,11 @@ static int ucc_geth_startup(struct ucc_geth_private *ugeth)
         }
 
         ugeth->p_rx_bd_qs_tbl =
-            (struct ucc_geth_rx_bd_queues_entry *) qe_muram_addr(ugeth->
+            (struct ucc_geth_rx_bd_queues_entry __iomem *) qe_muram_addr(ugeth->
                                     rx_bd_qs_tbl_offset);
         out_be32(&ugeth->p_rx_glbl_pram->rbdqptr, ugeth->rx_bd_qs_tbl_offset);
         /* Zero out p_rx_bd_qs_tbl */
-        memset(ugeth->p_rx_bd_qs_tbl,
+        memset_io((void __iomem *)ugeth->p_rx_bd_qs_tbl,
                0,
                ug_info->numQueuesRx * (sizeof(struct ucc_geth_rx_bd_queues_entry) +
                                        sizeof(struct ucc_geth_rx_prefetched_bds)));
@@ -3133,7 +3141,7 @@ static int ucc_geth_startup(struct ucc_geth_private *ugeth)
                 &ugeth->p_rx_glbl_pram->remoder);
 
         /* function code register */
-        ugeth->p_rx_glbl_pram->rstate = function_code;
+        out_8(&ugeth->p_rx_glbl_pram->rstate, function_code);
 
         /* initialize extended filtering */
         if (ug_info->rxExtendedFiltering) {
@@ -3160,7 +3168,7 @@ static int ucc_geth_startup(struct ucc_geth_private *ugeth)
                 }
 
                 ugeth->p_exf_glbl_param =
-                    (struct ucc_geth_exf_global_pram *) qe_muram_addr(ugeth->
+                    (struct ucc_geth_exf_global_pram __iomem *) qe_muram_addr(ugeth->
                                  exf_glbl_param_offset);
                 out_be32(&ugeth->p_rx_glbl_pram->exfGlobalParam,
                          ugeth->exf_glbl_param_offset);
@@ -3175,7 +3183,7 @@ static int ucc_geth_startup(struct ucc_geth_private *ugeth)
                         ugeth_82xx_filtering_clear_addr_in_paddr(ugeth, (u8) j);
 
                 p_82xx_addr_filt =
-                    (struct ucc_geth_82xx_address_filtering_pram *) ugeth->
+                    (struct ucc_geth_82xx_address_filtering_pram __iomem *) ugeth->
                     p_rx_glbl_pram->addressfiltering;
 
                 ugeth_82xx_filtering_clear_all_addr_in_hash(ugeth,
@@ -3307,17 +3315,21 @@ static int ucc_geth_startup(struct ucc_geth_private *ugeth)
                 return -ENOMEM;
         }
         p_init_enet_pram =
-            (struct ucc_geth_init_pram *) qe_muram_addr(init_enet_pram_offset);
+            (struct ucc_geth_init_pram __iomem *) qe_muram_addr(init_enet_pram_offset);
 
         /* Copy shadow InitEnet command parameter structure into PRAM */
-        p_init_enet_pram->resinit1 = ugeth->p_init_enet_param_shadow->resinit1;
-        p_init_enet_pram->resinit2 = ugeth->p_init_enet_param_shadow->resinit2;
-        p_init_enet_pram->resinit3 = ugeth->p_init_enet_param_shadow->resinit3;
-        p_init_enet_pram->resinit4 = ugeth->p_init_enet_param_shadow->resinit4;
+        out_8(&p_init_enet_pram->resinit1,
+                        ugeth->p_init_enet_param_shadow->resinit1);
+        out_8(&p_init_enet_pram->resinit2,
+                        ugeth->p_init_enet_param_shadow->resinit2);
+        out_8(&p_init_enet_pram->resinit3,
+                        ugeth->p_init_enet_param_shadow->resinit3);
+        out_8(&p_init_enet_pram->resinit4,
+                        ugeth->p_init_enet_param_shadow->resinit4);
         out_be16(&p_init_enet_pram->resinit5,
                  ugeth->p_init_enet_param_shadow->resinit5);
-        p_init_enet_pram->largestexternallookupkeysize =
-            ugeth->p_init_enet_param_shadow->largestexternallookupkeysize;
+        out_8(&p_init_enet_pram->largestexternallookupkeysize,
+            ugeth->p_init_enet_param_shadow->largestexternallookupkeysize);
         out_be32(&p_init_enet_pram->rgftgfrxglobal,
                  ugeth->p_init_enet_param_shadow->rgftgfrxglobal);
         for (i = 0; i < ENET_INIT_PARAM_MAX_ENTRIES_RX; i++)
@@ -3371,7 +3383,7 @@ static int ucc_geth_start_xmit(struct sk_buff *skb, struct net_device *dev)
 #ifdef CONFIG_UGETH_TX_ON_DEMAND
         struct ucc_fast_private *uccf;
 #endif
-        u8 *bd;                 /* BD pointer */
+        u8 __iomem *bd;                 /* BD pointer */
         u32 bd_status;
         u8 txQ = 0;
 
@@ -3383,7 +3395,7 @@ static int ucc_geth_start_xmit(struct sk_buff *skb, struct net_device *dev)
 
         /* Start from the next BD that should be filled */
         bd = ugeth->txBd[txQ];
-        bd_status = in_be32((u32 *)bd);
+        bd_status = in_be32((u32 __iomem *)bd);
         /* Save the skb pointer so we can free it later */
         ugeth->tx_skbuff[txQ][ugeth->skb_curtx[txQ]] = skb;
 
@@ -3393,7 +3405,7 @@ static int ucc_geth_start_xmit(struct sk_buff *skb, struct net_device *dev)
              1) & TX_RING_MOD_MASK(ugeth->ug_info->bdRingLenTx[txQ]);
 
         /* set up the buffer descriptor */
-        out_be32(&((struct qe_bd *)bd)->buf,
+        out_be32(&((struct qe_bd __iomem *)bd)->buf,
                       dma_map_single(NULL, skb->data, skb->len, DMA_TO_DEVICE));
 
         /* printk(KERN_DEBUG"skb->data is 0x%x\n",skb->data); */
@@ -3401,7 +3413,7 @@ static int ucc_geth_start_xmit(struct sk_buff *skb, struct net_device *dev)
         bd_status = (bd_status & T_W) | T_R | T_I | T_L | skb->len;
 
         /* set bd status and length */
-        out_be32((u32 *)bd, bd_status);
+        out_be32((u32 __iomem *)bd, bd_status);
 
         dev->trans_start = jiffies;
 
@@ -3441,7 +3453,7 @@ static int ucc_geth_start_xmit(struct sk_buff *skb, struct net_device *dev)
 static int ucc_geth_rx(struct ucc_geth_private *ugeth, u8 rxQ, int rx_work_limit)
 {
         struct sk_buff *skb;
-        u8 *bd;
+        u8 __iomem *bd;
         u16 length, howmany = 0;
         u32 bd_status;
         u8 *bdBuffer;
@@ -3454,11 +3466,11 @@ static int ucc_geth_rx(struct ucc_geth_private *ugeth, u8 rxQ, int rx_work_limit
         /* collect received buffers */
         bd = ugeth->rxBd[rxQ];
 
-        bd_status = in_be32((u32 *)bd);
+        bd_status = in_be32((u32 __iomem *)bd);
 
         /* while there are received buffers and BD is full (~R_E) */
         while (!((bd_status & (R_E)) || (--rx_work_limit < 0))) {
-                bdBuffer = (u8 *) in_be32(&((struct qe_bd *)bd)->buf);
+                bdBuffer = (u8 *) in_be32(&((struct qe_bd __iomem *)bd)->buf);
                 length = (u16) ((bd_status & BD_LENGTH_MASK) - 4);
                 skb = ugeth->rx_skbuff[rxQ][ugeth->skb_currx[rxQ]];
 
@@ -3516,7 +3528,7 @@ static int ucc_geth_rx(struct ucc_geth_private *ugeth, u8 rxQ, int rx_work_limit
                 else
                         bd += sizeof(struct qe_bd);
 
-                bd_status = in_be32((u32 *)bd);
+                bd_status = in_be32((u32 __iomem *)bd);
         }
 
         ugeth->rxBd[rxQ] = bd;
@@ -3527,11 +3539,11 @@ static int ucc_geth_tx(struct net_device *dev, u8 txQ)
 {
         /* Start from the next BD that should be filled */
         struct ucc_geth_private *ugeth = netdev_priv(dev);
-        u8 *bd;                 /* BD pointer */
+        u8 __iomem *bd;         /* BD pointer */
         u32 bd_status;
 
         bd = ugeth->confBd[txQ];
-        bd_status = in_be32((u32 *)bd);
+        bd_status = in_be32((u32 __iomem *)bd);
 
         /* Normal processing. */
         while ((bd_status & T_R) == 0) {
@@ -3561,7 +3573,7 @@ static int ucc_geth_tx(struct net_device *dev, u8 txQ)
                         bd += sizeof(struct qe_bd);
                 else
                         bd = ugeth->p_tx_bd_ring[txQ];
-                bd_status = in_be32((u32 *)bd);
+                bd_status = in_be32((u32 __iomem *)bd);
         }
         ugeth->confBd[txQ] = bd;
         return 0;
@@ -3910,7 +3922,7 @@ static int ucc_geth_probe(struct of_device* ofdev, const struct of_device_id *ma
                         return -EINVAL;
                 }
         } else {
-                prop = of_get_property(np, "rx-clock", NULL);
+                prop = of_get_property(np, "tx-clock", NULL);
                 if (!prop) {
                         printk(KERN_ERR
                                 "ucc_geth: mising tx-clock-name property\n");
diff --git a/drivers/net/ucc_geth.h b/drivers/net/ucc_geth.h
index 9f8b7580a3a4..abc0e2242634 100644
--- a/drivers/net/ucc_geth.h
+++ b/drivers/net/ucc_geth.h
@@ -700,8 +700,8 @@ struct ucc_geth_82xx_address_filtering_pram {
         u32 iaddr_l;            /* individual address filter, low */
         u32 gaddr_h;            /* group address filter, high */
         u32 gaddr_l;            /* group address filter, low */
-        struct ucc_geth_82xx_enet_address taddr;
-        struct ucc_geth_82xx_enet_address paddr[NUM_OF_PADDRS];
+        struct ucc_geth_82xx_enet_address __iomem taddr;
+        struct ucc_geth_82xx_enet_address __iomem paddr[NUM_OF_PADDRS];
         u8 res0[0x40 - 0x38];
 } __attribute__ ((packed));
 
@@ -1186,40 +1186,40 @@ struct ucc_geth_private {
         struct ucc_fast_private *uccf;
         struct net_device *dev;
         struct napi_struct napi;
-        struct ucc_geth *ug_regs;
+        struct ucc_geth __iomem *ug_regs;
         struct ucc_geth_init_pram *p_init_enet_param_shadow;
-        struct ucc_geth_exf_global_pram *p_exf_glbl_param;
+        struct ucc_geth_exf_global_pram __iomem *p_exf_glbl_param;
         u32 exf_glbl_param_offset;
-        struct ucc_geth_rx_global_pram *p_rx_glbl_pram;
+        struct ucc_geth_rx_global_pram __iomem *p_rx_glbl_pram;
         u32 rx_glbl_pram_offset;
-        struct ucc_geth_tx_global_pram *p_tx_glbl_pram;
+        struct ucc_geth_tx_global_pram __iomem *p_tx_glbl_pram;
         u32 tx_glbl_pram_offset;
-        struct ucc_geth_send_queue_mem_region *p_send_q_mem_reg;
+        struct ucc_geth_send_queue_mem_region __iomem *p_send_q_mem_reg;
         u32 send_q_mem_reg_offset;
-        struct ucc_geth_thread_data_tx *p_thread_data_tx;
+        struct ucc_geth_thread_data_tx __iomem *p_thread_data_tx;
         u32 thread_dat_tx_offset;
-        struct ucc_geth_thread_data_rx *p_thread_data_rx;
+        struct ucc_geth_thread_data_rx __iomem *p_thread_data_rx;
         u32 thread_dat_rx_offset;
-        struct ucc_geth_scheduler *p_scheduler;
+        struct ucc_geth_scheduler __iomem *p_scheduler;
         u32 scheduler_offset;
-        struct ucc_geth_tx_firmware_statistics_pram *p_tx_fw_statistics_pram;
+        struct ucc_geth_tx_firmware_statistics_pram __iomem *p_tx_fw_statistics_pram;
         u32 tx_fw_statistics_pram_offset;
-        struct ucc_geth_rx_firmware_statistics_pram *p_rx_fw_statistics_pram;
+        struct ucc_geth_rx_firmware_statistics_pram __iomem *p_rx_fw_statistics_pram;
         u32 rx_fw_statistics_pram_offset;
-        struct ucc_geth_rx_interrupt_coalescing_table *p_rx_irq_coalescing_tbl;
+        struct ucc_geth_rx_interrupt_coalescing_table __iomem *p_rx_irq_coalescing_tbl;
         u32 rx_irq_coalescing_tbl_offset;
-        struct ucc_geth_rx_bd_queues_entry *p_rx_bd_qs_tbl;
+        struct ucc_geth_rx_bd_queues_entry __iomem *p_rx_bd_qs_tbl;
         u32 rx_bd_qs_tbl_offset;
-        u8 *p_tx_bd_ring[NUM_TX_QUEUES];
+        u8 __iomem *p_tx_bd_ring[NUM_TX_QUEUES];
         u32 tx_bd_ring_offset[NUM_TX_QUEUES];
-        u8 *p_rx_bd_ring[NUM_RX_QUEUES];
+        u8 __iomem *p_rx_bd_ring[NUM_RX_QUEUES];
         u32 rx_bd_ring_offset[NUM_RX_QUEUES];
-        u8 *confBd[NUM_TX_QUEUES];
-        u8 *txBd[NUM_TX_QUEUES];
-        u8 *rxBd[NUM_RX_QUEUES];
+        u8 __iomem *confBd[NUM_TX_QUEUES];
+        u8 __iomem *txBd[NUM_TX_QUEUES];
+        u8 __iomem *rxBd[NUM_RX_QUEUES];
         int badFrame[NUM_RX_QUEUES];
         u16 cpucount[NUM_TX_QUEUES];
-        volatile u16 *p_cpucount[NUM_TX_QUEUES];
+        u16 __iomem *p_cpucount[NUM_TX_QUEUES];
         int indAddrRegUsed[NUM_OF_PADDRS];
         u8 paddr[NUM_OF_PADDRS][ENET_NUM_OCTETS_PER_ADDRESS];   /* ethernet address */
         u8 numGroupAddrInHash;
@@ -1251,4 +1251,12 @@ struct ucc_geth_private {
         int oldlink;
 };
 
+void uec_set_ethtool_ops(struct net_device *netdev);
+int init_flow_control_params(u32 automatic_flow_control_mode,
+                int rx_flow_control_enable, int tx_flow_control_enable,
+                u16 pause_period, u16 extension_field,
+                u32 __iomem *upsmr_register, u32 __iomem *uempr_register,
+                u32 __iomem *maccfg1_register);
+
+
 #endif                          /* __UCC_GETH_H__ */
diff --git a/drivers/net/ucc_geth_ethtool.c b/drivers/net/ucc_geth_ethtool.c
index 9a9622c13e2b..299b7f176950 100644
--- a/drivers/net/ucc_geth_ethtool.c
+++ b/drivers/net/ucc_geth_ethtool.c
@@ -108,12 +108,6 @@ static char rx_fw_stat_gstrings[][ETH_GSTRING_LEN] = {
 #define UEC_TX_FW_STATS_LEN ARRAY_SIZE(tx_fw_stat_gstrings)
 #define UEC_RX_FW_STATS_LEN ARRAY_SIZE(rx_fw_stat_gstrings)
 
-extern int init_flow_control_params(u32 automatic_flow_control_mode,
-                int rx_flow_control_enable,
-                int tx_flow_control_enable, u16 pause_period,
-                u16 extension_field, volatile u32 *upsmr_register,
-                volatile u32 *uempr_register, volatile u32 *maccfg1_register);
-
 static int
 uec_get_settings(struct net_device *netdev, struct ethtool_cmd *ecmd)
 {
diff --git a/drivers/net/ucc_geth_mii.c b/drivers/net/ucc_geth_mii.c
index 2af490781005..940474736922 100644
--- a/drivers/net/ucc_geth_mii.c
+++ b/drivers/net/ucc_geth_mii.c
@@ -104,7 +104,7 @@ int uec_mdio_read(struct mii_bus *bus, int mii_id, int regnum)
 }
 
 /* Reset the MIIM registers, and wait for the bus to free */
-int uec_mdio_reset(struct mii_bus *bus)
+static int uec_mdio_reset(struct mii_bus *bus)
 {
         struct ucc_mii_mng __iomem *regs = (void __iomem *)bus->priv;
         unsigned int timeout = PHY_INIT_TIMEOUT;
@@ -240,7 +240,7 @@ reg_map_fail:
         return err;
 }
 
-int uec_mdio_remove(struct of_device *ofdev)
+static int uec_mdio_remove(struct of_device *ofdev)
 {
         struct device *device = &ofdev->dev;
         struct mii_bus *bus = dev_get_drvdata(device);
diff --git a/drivers/net/usb/asix.c b/drivers/net/usb/asix.c
index 6f245cfb6624..dc6f097062df 100644
--- a/drivers/net/usb/asix.c
+++ b/drivers/net/usb/asix.c
@@ -1381,6 +1381,10 @@ static const struct usb_device_id	products [] = {
         USB_DEVICE (0x0411, 0x003d),
         .driver_info =  (unsigned long) &ax8817x_info,
 }, {
+        // Buffalo LUA-U2-GT 10/100/1000
+        USB_DEVICE (0x0411, 0x006e),
+        .driver_info =  (unsigned long) &ax88178_info,
+}, {
         // Sitecom LN-029 "USB 2.0 10/100 Ethernet adapter"
         USB_DEVICE (0x6189, 0x182d),
         .driver_info =  (unsigned long) &ax8817x_info,
diff --git a/drivers/net/wan/lapbether.c b/drivers/net/wan/lapbether.c
index b5860b97a93e..24fd613466b7 100644
--- a/drivers/net/wan/lapbether.c
+++ b/drivers/net/wan/lapbether.c
@@ -459,6 +459,7 @@ static void __exit lapbeth_cleanup_driver(void)
         list_for_each_safe(entry, tmp, &lapbeth_devices) {
                 lapbeth = list_entry(entry, struct lapbethdev, node);
 
+                dev_put(lapbeth->ethdev);
                 unregister_netdevice(lapbeth->axdev);
         }
         rtnl_unlock();
diff --git a/drivers/net/wireless/iwlwifi/Kconfig b/drivers/net/wireless/iwlwifi/Kconfig
index d5b7a76fcaad..62fb89d82318 100644
--- a/drivers/net/wireless/iwlwifi/Kconfig
+++ b/drivers/net/wireless/iwlwifi/Kconfig
@@ -1,6 +1,5 @@
 config IWLWIFI
-        bool
-        default n
+        tristate
 
 config IWLCORE
         tristate "Intel Wireless Wifi Core"
diff --git a/drivers/pci/probe.c b/drivers/pci/probe.c
index 4a55bf380957..3706ce7972dd 100644
--- a/drivers/pci/probe.c
+++ b/drivers/pci/probe.c
@@ -842,13 +842,25 @@ static void set_pcie_port_type(struct pci_dev *pdev)
  * reading the dword at 0x100 which must either be 0 or a valid extended
  * capability header.
  */
-int pci_cfg_space_size_ext(struct pci_dev *dev, unsigned check_exp_pcix)
+int pci_cfg_space_size_ext(struct pci_dev *dev)
 {
-        int pos;
         u32 status;
 
-        if (!check_exp_pcix)
-                goto skip;
+        if (pci_read_config_dword(dev, 256, &status) != PCIBIOS_SUCCESSFUL)
+                goto fail;
+        if (status == 0xffffffff)
+                goto fail;
+
+        return PCI_CFG_SPACE_EXP_SIZE;
+
+ fail:
+        return PCI_CFG_SPACE_SIZE;
+}
+
+int pci_cfg_space_size(struct pci_dev *dev)
+{
+        int pos;
+        u32 status;
 
         pos = pci_find_capability(dev, PCI_CAP_ID_EXP);
         if (!pos) {
@@ -861,23 +873,12 @@ int pci_cfg_space_size_ext(struct pci_dev *dev, unsigned check_exp_pcix)
                         goto fail;
         }
 
- skip:
-        if (pci_read_config_dword(dev, 256, &status) != PCIBIOS_SUCCESSFUL)
-                goto fail;
-        if (status == 0xffffffff)
-                goto fail;
-
-        return PCI_CFG_SPACE_EXP_SIZE;
+        return pci_cfg_space_size_ext(dev);
 
  fail:
         return PCI_CFG_SPACE_SIZE;
 }
 
-int pci_cfg_space_size(struct pci_dev *dev)
-{
-        return pci_cfg_space_size_ext(dev, 1);
-}
-
 static void pci_release_bus_bridge_dev(struct device *dev)
 {
         kfree(dev);
diff --git a/drivers/rtc/rtc-ds1511.c b/drivers/rtc/rtc-ds1511.c
index a83a40b3ebaa..0f0d27d1c4ca 100644
--- a/drivers/rtc/rtc-ds1511.c
+++ b/drivers/rtc/rtc-ds1511.c
@@ -184,7 +184,7 @@ ds1511_wdog_disable(void)
 static int ds1511_rtc_set_time(struct device *dev, struct rtc_time *rtc_tm)
 {
         u8 mon, day, dow, hrs, min, sec, yrs, cen;
-        unsigned int flags;
+        unsigned long flags;
 
         /*
          * won't have to change this for a while
@@ -247,7 +247,7 @@ static int ds1511_rtc_set_time(struct device *dev, struct rtc_time *rtc_tm)
 static int ds1511_rtc_read_time(struct device *dev, struct rtc_time *rtc_tm)
 {
         unsigned int century;
-        unsigned int flags;
+        unsigned long flags;
 
         spin_lock_irqsave(&ds1511_lock, flags);
         rtc_disable_update();
diff --git a/drivers/s390/char/tty3270.c b/drivers/s390/char/tty3270.c
index c1f2adefad41..5043150019ac 100644
--- a/drivers/s390/char/tty3270.c
+++ b/drivers/s390/char/tty3270.c
@@ -965,8 +965,7 @@ tty3270_write_room(struct tty_struct *tty)
  * Insert character into the screen at the current position with the
  * current color and highlight. This function does NOT do cursor movement.
  */
-static int
-tty3270_put_character(struct tty3270 *tp, char ch)
+static void tty3270_put_character(struct tty3270 *tp, char ch)
 {
         struct tty3270_line *line;
         struct tty3270_cell *cell;
@@ -986,7 +985,6 @@ tty3270_put_character(struct tty3270 *tp, char ch)
         cell->character = tp->view.ascebc[(unsigned int) ch];
         cell->highlight = tp->highlight;
         cell->f_color = tp->f_color;
-        return 1;
 }
 
 /*
@@ -1612,16 +1610,15 @@ tty3270_write(struct tty_struct * tty,
 /*
  * Put single characters to the ttys character buffer
  */
-static void
-tty3270_put_char(struct tty_struct *tty, unsigned char ch)
+static int tty3270_put_char(struct tty_struct *tty, unsigned char ch)
 {
         struct tty3270 *tp;
 
         tp = tty->driver_data;
-        if (!tp)
-                return;
-        if (tp->char_count < TTY3270_CHAR_BUF_SIZE)
-                tp->char_buf[tp->char_count++] = ch;
+        if (!tp || tp->char_count >= TTY3270_CHAR_BUF_SIZE)
+                return 0;
+        tp->char_buf[tp->char_count++] = ch;
+        return 1;
 }
 
 /*
diff --git a/drivers/s390/cio/blacklist.c b/drivers/s390/cio/blacklist.c
index 40ef948fcb3a..9c21b8f43f9b 100644
--- a/drivers/s390/cio/blacklist.c
+++ b/drivers/s390/cio/blacklist.c
@@ -19,6 +19,7 @@
 
 #include <asm/cio.h>
 #include <asm/uaccess.h>
+#include <asm/cio.h>
 
 #include "blacklist.h"
 #include "cio.h"
@@ -43,164 +44,169 @@ typedef enum {add, free} range_action;
  * Function: blacklist_range
  * (Un-)blacklist the devices from-to
  */
-static void
-blacklist_range (range_action action, unsigned int from, unsigned int to,
-                 unsigned int ssid)
+static int blacklist_range(range_action action, unsigned int from_ssid,
+                           unsigned int to_ssid, unsigned int from,
+                           unsigned int to, int msgtrigger)
 {
-        if (!to)
-                to = from;
-
-        if (from > to || to > __MAX_SUBCHANNEL || ssid > __MAX_SSID) {
-                printk (KERN_WARNING "cio: Invalid blacklist range "
-                        "0.%x.%04x to 0.%x.%04x, skipping\n",
-                        ssid, from, ssid, to);
-                return;
+        if ((from_ssid > to_ssid) || ((from_ssid == to_ssid) && (from > to))) {
+                if (msgtrigger)
+                        printk(KERN_WARNING "cio: Invalid cio_ignore range "
+                               "0.%x.%04x-0.%x.%04x\n", from_ssid, from,
+                               to_ssid, to);
+                return 1;
         }
-        for (; from <= to; from++) {
+
+        while ((from_ssid < to_ssid) || ((from_ssid == to_ssid) &&
+               (from <= to))) {
                 if (action == add)
-                        set_bit (from, bl_dev[ssid]);
+                        set_bit(from, bl_dev[from_ssid]);
                 else
-                        clear_bit (from, bl_dev[ssid]);
+                        clear_bit(from, bl_dev[from_ssid]);
+                from++;
+                if (from > __MAX_SUBCHANNEL) {
+                        from_ssid++;
+                        from = 0;
+                }
         }
+
+        return 0;
 }
 
-/*
- * Function: blacklist_busid
- * Get devno/busid from given string.
- * Shamelessly grabbed from dasd_devmap.c.
- */
-static int
-blacklist_busid(char **str, int *id0, int *ssid, int *devno)
+static int pure_hex(char **cp, unsigned int *val, int min_digit,
+                    int max_digit, int max_val)
 {
-        int val, old_style;
-        char *sav;
+        int diff;
+        unsigned int value;
 
-        sav = *str;
+        diff = 0;
+        *val = 0;
 
-        /* check for leading '0x' */
-        old_style = 0;
-        if ((*str)[0] == '0' && (*str)[1] == 'x') {
-                *str += 2;
-                old_style = 1;
-        }
-        if (!isxdigit((*str)[0]))       /* We require at least one hex digit */
-                goto confused;
-        val = simple_strtoul(*str, str, 16);
-        if (old_style || (*str)[0] != '.') {
-                *id0 = *ssid = 0;
-                if (val < 0 || val > 0xffff)
-                        goto confused;
-                *devno = val;
-                if ((*str)[0] != ',' && (*str)[0] != '-' &&
-                    (*str)[0] != '\n' && (*str)[0] != '\0')
-                        goto confused;
-                return 0;
+        while (isxdigit(**cp) && (diff <= max_digit)) {
+
+                if (isdigit(**cp))
+                        value = **cp - '0';
+                else
+                        value = tolower(**cp) - 'a' + 10;
+                *val = *val * 16 + value;
+                (*cp)++;
+                diff++;
         }
-        /* New style x.y.z busid */
-        if (val < 0 || val > 0xff)
-                goto confused;
-        *id0 = val;
-        (*str)++;
-        if (!isxdigit((*str)[0]))       /* We require at least one hex digit */
-                goto confused;
-        val = simple_strtoul(*str, str, 16);
-        if (val < 0 || val > 0xff || (*str)++[0] != '.')
-                goto confused;
-        *ssid = val;
-        if (!isxdigit((*str)[0]))       /* We require at least one hex digit */
-                goto confused;
-        val = simple_strtoul(*str, str, 16);
-        if (val < 0 || val > 0xffff)
-                goto confused;
-        *devno = val;
-        if ((*str)[0] != ',' && (*str)[0] != '-' &&
-            (*str)[0] != '\n' && (*str)[0] != '\0')
-                goto confused;
+
+        if ((diff < min_digit) || (diff > max_digit) || (*val > max_val))
+                return 1;
+
         return 0;
-confused:
-        strsep(str, ",\n");
-        printk(KERN_WARNING "cio: Invalid cio_ignore parameter '%s'\n", sav);
-        return 1;
 }
 
-static int
-blacklist_parse_parameters (char *str, range_action action)
+static int parse_busid(char *str, int *cssid, int *ssid, int *devno,
+                       int msgtrigger)
 {
-        int from, to, from_id0, to_id0, from_ssid, to_ssid;
-
-        while (*str != 0 && *str != '\n') {
-                range_action ra = action;
-                while(*str == ',')
-                        str++;
-                if (*str == '!') {
-                        ra = !action;
-                        ++str;
+        char *str_work;
+        int val, rc, ret;
+
+        rc = 1;
+
+        if (*str == '\0')
+                goto out;
+
+        /* old style */
+        str_work = str;
+        val = simple_strtoul(str, &str_work, 16);
+
+        if (*str_work == '\0') {
+                if (val <= __MAX_SUBCHANNEL) {
+                        *devno = val;
+                        *ssid = 0;
+                        *cssid = 0;
+                        rc = 0;
                 }
+                goto out;
+        }
 
-                /*
-                 * Since we have to parse the proc commands and the
-                 * kernel arguments we have to check four cases
-                 */
-                if (strncmp(str,"all,",4) == 0 || strcmp(str,"all") == 0 ||
-                    strncmp(str,"all\n",4) == 0 || strncmp(str,"all ",4) == 0) {
-                        int j;
-
-                        str += 3;
-                        for (j=0; j <= __MAX_SSID; j++)
-                                blacklist_range(ra, 0, __MAX_SUBCHANNEL, j);
-                } else {
-                        int rc;
+        /* new style */
+        str_work = str;
+        ret = pure_hex(&str_work, cssid, 1, 2, __MAX_CSSID);
+        if (ret || (str_work[0] != '.'))
+                goto out;
+        str_work++;
+        ret = pure_hex(&str_work, ssid, 1, 1, __MAX_SSID);
+        if (ret || (str_work[0] != '.'))
+                goto out;
+        str_work++;
+        ret = pure_hex(&str_work, devno, 4, 4, __MAX_SUBCHANNEL);
+        if (ret || (str_work[0] != '\0'))
+                goto out;
+
+        rc = 0;
+out:
+        if (rc && msgtrigger)
+                printk(KERN_WARNING "cio: Invalid cio_ignore device '%s'\n",
+                       str);
+
+        return rc;
+}
 
-                        rc = blacklist_busid(&str, &from_id0,
-                                             &from_ssid, &from);
-                        if (rc)
-                                continue;
-                        to = from;
-                        to_id0 = from_id0;
-                        to_ssid = from_ssid;
-                        if (*str == '-') {
-                                str++;
-                                rc = blacklist_busid(&str, &to_id0,
-                                                     &to_ssid, &to);
-                                if (rc)
-                                        continue;
-                        }
-                        if (*str == '-') {
-                                printk(KERN_WARNING "cio: invalid cio_ignore "
-                                        "parameter '%s'\n",
-                                        strsep(&str, ",\n"));
-                                continue;
-                        }
-                        if ((from_id0 != to_id0) ||
-                            (from_ssid != to_ssid)) {
-                                printk(KERN_WARNING "cio: invalid cio_ignore "
-                                       "range %x.%x.%04x-%x.%x.%04x\n",
-                                       from_id0, from_ssid, from,
-                                       to_id0, to_ssid, to);
-                                continue;
+static int blacklist_parse_parameters(char *str, range_action action,
+                                      int msgtrigger)
+{
+        int from_cssid, to_cssid, from_ssid, to_ssid, from, to;
+        int rc, totalrc;
+        char *parm;
+        range_action ra;
+
+        totalrc = 0;
+
+        while ((parm = strsep(&str, ","))) {
+                rc = 0;
+                ra = action;
+                if (*parm == '!') {
+                        if (ra == add)
+                                ra = free;
+                        else
+                                ra = add;
+                        parm++;
+                }
+                if (strcmp(parm, "all") == 0) {
+                        from_cssid = 0;
+                        from_ssid = 0;
+                        from = 0;
+                        to_cssid = __MAX_CSSID;
+                        to_ssid = __MAX_SSID;
+                        to = __MAX_SUBCHANNEL;
+                } else {
+                        rc = parse_busid(strsep(&parm, "-"), &from_cssid,
+                                         &from_ssid, &from, msgtrigger);
+                        if (!rc) {
+                                if (parm != NULL)
+                                        rc = parse_busid(parm, &to_cssid,
+                                                         &to_ssid, &to,
+                                                         msgtrigger);
+                                else {
+                                        to_cssid = from_cssid;
+                                        to_ssid = from_ssid;
+                                        to = from;
+                                }
                         }
-                        blacklist_range (ra, from, to, to_ssid);
                 }
+                if (!rc) {
+                        rc = blacklist_range(ra, from_ssid, to_ssid, from, to,
+                                             msgtrigger);
+                        if (rc)
+                                totalrc = 1;
+                } else
+                        totalrc = 1;
         }
-        return 1;
+
+        return totalrc;
 }
 
-/* Parsing the commandline for blacklist parameters, e.g. to blacklist
- * bus ids 0.0.1234, 0.0.1235 and 0.0.1236, you could use any of:
- * - cio_ignore=1234-1236
- * - cio_ignore=0x1234-0x1235,1236
- * - cio_ignore=0x1234,1235-1236
- * - cio_ignore=1236 cio_ignore=1234-0x1236
- * - cio_ignore=1234 cio_ignore=1236 cio_ignore=0x1235
- * - cio_ignore=0.0.1234-0.0.1236
- * - cio_ignore=0.0.1234,0x1235,1236
- * - ...
- */
 static int __init
 blacklist_setup (char *str)
 {
         CIO_MSG_EVENT(6, "Reading blacklist parameters\n");
-        return blacklist_parse_parameters (str, add);
+        if (blacklist_parse_parameters(str, add, 1))
+                return 0;
+        return 1;
 }
 
 __setup ("cio_ignore=", blacklist_setup);
@@ -224,27 +230,23 @@ is_blacklisted (int ssid, int devno)
  * Function: blacklist_parse_proc_parameters
  * parse the stuff which is piped to /proc/cio_ignore
  */
-static void
-blacklist_parse_proc_parameters (char *buf)
+static int blacklist_parse_proc_parameters(char *buf)
 {
-        if (strncmp (buf, "free ", 5) == 0) {
-                blacklist_parse_parameters (buf + 5, free);
-        } else if (strncmp (buf, "add ", 4) == 0) {
-                /* 
-                 * We don't need to check for known devices since
-                 * css_probe_device will handle this correctly. 
-                 */
-                blacklist_parse_parameters (buf + 4, add);
-        } else {
-                printk (KERN_WARNING "cio: cio_ignore: Parse error; \n"
-                        KERN_WARNING "try using 'free all|<devno-range>,"
-                                     "<devno-range>,...'\n"
-                        KERN_WARNING "or 'add <devno-range>,"
-                                     "<devno-range>,...'\n");
-                return;
-        }
+        int rc;
+        char *parm;
+
+        parm = strsep(&buf, " ");
+
+        if (strcmp("free", parm) == 0)
+                rc = blacklist_parse_parameters(buf, free, 0);
+        else if (strcmp("add", parm) == 0)
+                rc = blacklist_parse_parameters(buf, add, 0);
+        else
+                return 1;
 
         css_schedule_reprobe();
+
+        return rc;
 }
 
 /* Iterator struct for all devices. */
@@ -328,6 +330,8 @@ cio_ignore_write(struct file *file, const char __user *user_buf,
                  size_t user_len, loff_t *offset)
 {
         char *buf;
+        size_t i;
+        ssize_t rc, ret;
 
         if (*offset)
                 return -EINVAL;
@@ -336,16 +340,27 @@ cio_ignore_write(struct file *file, const char __user *user_buf,
         buf = vmalloc (user_len + 1); /* maybe better use the stack? */
         if (buf == NULL)
                 return -ENOMEM;
+        memset(buf, 0, user_len + 1);
+
         if (strncpy_from_user (buf, user_buf, user_len) < 0) {
-                vfree (buf);
-                return -EFAULT;
+                rc = -EFAULT;
+                goto out_free;
         }
-        buf[user_len] = '\0';
 
-        blacklist_parse_proc_parameters (buf);
+        i = user_len - 1;
+        while ((i >= 0) && (isspace(buf[i]) || (buf[i] == 0))) {
+                buf[i] = '\0';
+                i--;
+        }
+        ret = blacklist_parse_proc_parameters(buf);
+        if (ret)
+                rc = -EINVAL;
+        else
+                rc = user_len;
 
+out_free:
         vfree (buf);
-        return user_len;
+        return rc;
 }
 
 static const struct seq_operations cio_ignore_proc_seq_ops = {
diff --git a/drivers/s390/cio/cio.c b/drivers/s390/cio/cio.c
index 08a578161306..82c6a2d45128 100644
--- a/drivers/s390/cio/cio.c
+++ b/drivers/s390/cio/cio.c
@@ -39,23 +39,6 @@ debug_info_t *cio_debug_msg_id;
 debug_info_t *cio_debug_trace_id;
 debug_info_t *cio_debug_crw_id;
 
-int cio_show_msg;
-
-static int __init
-cio_setup (char *parm)
-{
-        if (!strcmp (parm, "yes"))
-                cio_show_msg = 1;
-        else if (!strcmp (parm, "no"))
-                cio_show_msg = 0;
-        else
-                printk(KERN_ERR "cio: cio_setup: "
-                       "invalid cio_msg parameter '%s'", parm);
-        return 1;
-}
-
-__setup ("cio_msg=", cio_setup);
-
 /*
  * Function: cio_debug_init
  * Initializes three debug logs for common I/O:
@@ -166,7 +149,7 @@ cio_start_handle_notoper(struct subchannel *sch, __u8 lpm)
 
         stsch (sch->schid, &sch->schib);
 
-        CIO_MSG_EVENT(0, "cio_start: 'not oper' status for "
+        CIO_MSG_EVENT(2, "cio_start: 'not oper' status for "
                       "subchannel 0.%x.%04x!\n", sch->schid.ssid,
                       sch->schid.sch_no);
         sprintf(dbf_text, "no%s", sch->dev.bus_id);
@@ -567,10 +550,9 @@ cio_validate_subchannel (struct subchannel *sch, struct subchannel_id schid)
          * ... just being curious we check for non I/O subchannels
          */
         if (sch->st != 0) {
-                CIO_DEBUG(KERN_INFO, 0,
-                          "Subchannel 0.%x.%04x reports "
-                          "non-I/O subchannel type %04X\n",
-                          sch->schid.ssid, sch->schid.sch_no, sch->st);
+                CIO_MSG_EVENT(4, "Subchannel 0.%x.%04x reports "
+                              "non-I/O subchannel type %04X\n",
+                              sch->schid.ssid, sch->schid.sch_no, sch->st);
                 /* We stop here for non-io subchannels. */
                 err = sch->st;
                 goto out;
@@ -588,7 +570,7 @@ cio_validate_subchannel (struct subchannel *sch, struct subchannel_id schid)
                  * This device must not be known to Linux. So we simply
                  * say that there is no device and return ENODEV.
                  */
-                CIO_MSG_EVENT(4, "Blacklisted device detected "
+                CIO_MSG_EVENT(6, "Blacklisted device detected "
                               "at devno %04X, subchannel set %x\n",
                               sch->schib.pmcw.dev, sch->schid.ssid);
                 err = -ENODEV;
@@ -601,12 +583,11 @@ cio_validate_subchannel (struct subchannel *sch, struct subchannel_id schid)
         sch->lpm = sch->schib.pmcw.pam & sch->opm;
         sch->isc = 3;
 
-        CIO_DEBUG(KERN_INFO, 0,
-                  "Detected device %04x on subchannel 0.%x.%04X"
-                  " - PIM = %02X, PAM = %02X, POM = %02X\n",
-                  sch->schib.pmcw.dev, sch->schid.ssid,
-                  sch->schid.sch_no, sch->schib.pmcw.pim,
-                  sch->schib.pmcw.pam, sch->schib.pmcw.pom);
+        CIO_MSG_EVENT(6, "Detected device %04x on subchannel 0.%x.%04X "
+                      "- PIM = %02X, PAM = %02X, POM = %02X\n",
+                      sch->schib.pmcw.dev, sch->schid.ssid,
+                      sch->schid.sch_no, sch->schib.pmcw.pim,
+                      sch->schib.pmcw.pam, sch->schib.pmcw.pom);
 
         /*
          * We now have to initially ...
diff --git a/drivers/s390/cio/cio.h b/drivers/s390/cio/cio.h
index 3c75412904dc..6e933aebe013 100644
--- a/drivers/s390/cio/cio.h
+++ b/drivers/s390/cio/cio.h
@@ -118,6 +118,4 @@ extern void *cio_get_console_priv(void);
 #define cio_get_console_priv() NULL
 #endif
 
-extern int cio_show_msg;
-
 #endif
diff --git a/drivers/s390/cio/cio_debug.h b/drivers/s390/cio/cio_debug.h
index d7429ef6c666..e64e8278c42e 100644
--- a/drivers/s390/cio/cio_debug.h
+++ b/drivers/s390/cio/cio_debug.h
@@ -31,10 +31,4 @@ static inline void CIO_HEX_EVENT(int level, void *data, int length)
         }
 }
 
-#define CIO_DEBUG(printk_level, event_level, msg...) do {       \
-                if (cio_show_msg)                               \
-                        printk(printk_level "cio: " msg);       \
-                CIO_MSG_EVENT(event_level, msg);                \
-        } while (0)
-
 #endif
diff --git a/drivers/s390/cio/css.c b/drivers/s390/cio/css.c
index 595e327d2f76..a76956512b2d 100644
--- a/drivers/s390/cio/css.c
+++ b/drivers/s390/cio/css.c
@@ -570,7 +570,7 @@ static void reprobe_all(struct work_struct *unused)
 {
         int ret;
 
-        CIO_MSG_EVENT(2, "reprobe start\n");
+        CIO_MSG_EVENT(4, "reprobe start\n");
 
         need_reprobe = 0;
         /* Make sure initial subchannel scan is done. */
@@ -578,7 +578,7 @@ static void reprobe_all(struct work_struct *unused)
                    atomic_read(&ccw_device_init_count) == 0);
         ret = for_each_subchannel_staged(NULL, reprobe_subchannel, NULL);
 
-        CIO_MSG_EVENT(2, "reprobe done (rc=%d, need_reprobe=%d)\n", ret,
+        CIO_MSG_EVENT(4, "reprobe done (rc=%d, need_reprobe=%d)\n", ret,
                       need_reprobe);
 }
 
diff --git a/drivers/s390/cio/device.c b/drivers/s390/cio/device.c
index abfd601d237a..e22813db74a2 100644
--- a/drivers/s390/cio/device.c
+++ b/drivers/s390/cio/device.c
@@ -341,7 +341,7 @@ ccw_device_remove_disconnected(struct ccw_device *cdev)
                 rc = device_schedule_callback(&cdev->dev,
                                               ccw_device_remove_orphan_cb);
                 if (rc)
-                        CIO_MSG_EVENT(2, "Couldn't unregister orphan "
+                        CIO_MSG_EVENT(0, "Couldn't unregister orphan "
                                       "0.%x.%04x\n",
                                       cdev->private->dev_id.ssid,
                                       cdev->private->dev_id.devno);
@@ -351,7 +351,7 @@ ccw_device_remove_disconnected(struct ccw_device *cdev)
         rc = device_schedule_callback(cdev->dev.parent,
                                       ccw_device_remove_sch_cb);
         if (rc)
-                CIO_MSG_EVENT(2, "Couldn't unregister disconnected device "
+                CIO_MSG_EVENT(0, "Couldn't unregister disconnected device "
                               "0.%x.%04x\n",
                               cdev->private->dev_id.ssid,
                               cdev->private->dev_id.devno);
@@ -397,7 +397,7 @@ int ccw_device_set_offline(struct ccw_device *cdev)
         if (ret == 0)
                 wait_event(cdev->private->wait_q, dev_fsm_final_state(cdev));
         else {
-                CIO_MSG_EVENT(2, "ccw_device_offline returned %d, "
+                CIO_MSG_EVENT(0, "ccw_device_offline returned %d, "
                               "device 0.%x.%04x\n",
                               ret, cdev->private->dev_id.ssid,
                               cdev->private->dev_id.devno);
@@ -433,7 +433,7 @@ int ccw_device_set_online(struct ccw_device *cdev)
         if (ret == 0)
                 wait_event(cdev->private->wait_q, dev_fsm_final_state(cdev));
         else {
-                CIO_MSG_EVENT(2, "ccw_device_online returned %d, "
+                CIO_MSG_EVENT(0, "ccw_device_online returned %d, "
                               "device 0.%x.%04x\n",
                               ret, cdev->private->dev_id.ssid,
                               cdev->private->dev_id.devno);
@@ -451,7 +451,7 @@ int ccw_device_set_online(struct ccw_device *cdev)
         if (ret == 0)
                 wait_event(cdev->private->wait_q, dev_fsm_final_state(cdev));
         else
-                CIO_MSG_EVENT(2, "ccw_device_offline returned %d, "
+                CIO_MSG_EVENT(0, "ccw_device_offline returned %d, "
                               "device 0.%x.%04x\n",
                               ret, cdev->private->dev_id.ssid,
                               cdev->private->dev_id.devno);
@@ -803,7 +803,7 @@ static void sch_attach_disconnected_device(struct subchannel *sch,
         other_sch = to_subchannel(get_device(cdev->dev.parent));
         ret = device_move(&cdev->dev, &sch->dev);
         if (ret) {
-                CIO_MSG_EVENT(2, "Moving disconnected device 0.%x.%04x failed "
+                CIO_MSG_EVENT(0, "Moving disconnected device 0.%x.%04x failed "
                               "(ret=%d)!\n", cdev->private->dev_id.ssid,
                               cdev->private->dev_id.devno, ret);
                 put_device(&other_sch->dev);
@@ -933,7 +933,7 @@ io_subchannel_register(struct work_struct *work)
                         ret = device_reprobe(&cdev->dev);
                         if (ret)
                                 /* We can't do much here. */
-                                CIO_MSG_EVENT(2, "device_reprobe() returned"
+                                CIO_MSG_EVENT(0, "device_reprobe() returned"
                                               " %d for 0.%x.%04x\n", ret,
                                               cdev->private->dev_id.ssid,
                                               cdev->private->dev_id.devno);
@@ -1086,7 +1086,7 @@ static void ccw_device_move_to_sch(struct work_struct *work)
         rc = device_move(&cdev->dev, &sch->dev);
         mutex_unlock(&sch->reg_mutex);
         if (rc) {
-                CIO_MSG_EVENT(2, "Moving device 0.%x.%04x to subchannel "
+                CIO_MSG_EVENT(0, "Moving device 0.%x.%04x to subchannel "
                               "0.%x.%04x failed (ret=%d)!\n",
                               cdev->private->dev_id.ssid,
                               cdev->private->dev_id.devno, sch->schid.ssid,
@@ -1446,8 +1446,7 @@ ccw_device_remove (struct device *dev)
                         wait_event(cdev->private->wait_q,
                                    dev_fsm_final_state(cdev));
                 else
-                        //FIXME: we can't fail!
-                        CIO_MSG_EVENT(2, "ccw_device_offline returned %d, "
+                        CIO_MSG_EVENT(0, "ccw_device_offline returned %d, "
                                       "device 0.%x.%04x\n",
                                       ret, cdev->private->dev_id.ssid,
                                       cdev->private->dev_id.devno);
@@ -1524,7 +1523,7 @@ static int recovery_check(struct device *dev, void *data)
         spin_lock_irq(cdev->ccwlock);
         switch (cdev->private->state) {
         case DEV_STATE_DISCONNECTED:
-                CIO_MSG_EVENT(3, "recovery: trigger 0.%x.%04x\n",
+                CIO_MSG_EVENT(4, "recovery: trigger 0.%x.%04x\n",
                               cdev->private->dev_id.ssid,
                               cdev->private->dev_id.devno);
                 dev_fsm_event(cdev, DEV_EVENT_VERIFY);
@@ -1554,7 +1553,7 @@ static void recovery_work_func(struct work_struct *unused)
                 }
                 spin_unlock_irq(&recovery_lock);
         } else
-                CIO_MSG_EVENT(2, "recovery: end\n");
+                CIO_MSG_EVENT(4, "recovery: end\n");
 }
 
 static DECLARE_WORK(recovery_work, recovery_work_func);
@@ -1572,7 +1571,7 @@ void ccw_device_schedule_recovery(void)
 {
         unsigned long flags;
 
-        CIO_MSG_EVENT(2, "recovery: schedule\n");
+        CIO_MSG_EVENT(4, "recovery: schedule\n");
         spin_lock_irqsave(&recovery_lock, flags);
         if (!timer_pending(&recovery_timer) || (recovery_phase != 0)) {
                 recovery_phase = 0;
diff --git a/drivers/s390/cio/device_fsm.c b/drivers/s390/cio/device_fsm.c
index 99403b0a97a7..e268d5a77c12 100644
--- a/drivers/s390/cio/device_fsm.c
+++ b/drivers/s390/cio/device_fsm.c
@@ -322,10 +322,10 @@ ccw_device_recog_done(struct ccw_device *cdev, int state)
         same_dev = 0; /* Keep the compiler quiet... */
         switch (state) {
         case DEV_STATE_NOT_OPER:
-                CIO_DEBUG(KERN_WARNING, 2,
-                          "SenseID : unknown device %04x on subchannel "
-                          "0.%x.%04x\n", cdev->private->dev_id.devno,
-                          sch->schid.ssid, sch->schid.sch_no);
+                CIO_MSG_EVENT(2, "SenseID : unknown device %04x on "
+                              "subchannel 0.%x.%04x\n",
+                              cdev->private->dev_id.devno,
+                              sch->schid.ssid, sch->schid.sch_no);
                 break;
         case DEV_STATE_OFFLINE:
                 if (cdev->private->state == DEV_STATE_DISCONNECTED_SENSE_ID) {
@@ -348,20 +348,19 @@ ccw_device_recog_done(struct ccw_device *cdev, int state)
                         return;
                 }
                 /* Issue device info message. */
-                CIO_DEBUG(KERN_INFO, 2,
-                          "SenseID : device 0.%x.%04x reports: "
-                          "CU  Type/Mod = %04X/%02X, Dev Type/Mod = "
-                          "%04X/%02X\n",
-                          cdev->private->dev_id.ssid,
-                          cdev->private->dev_id.devno,
-                          cdev->id.cu_type, cdev->id.cu_model,
-                          cdev->id.dev_type, cdev->id.dev_model);
+                CIO_MSG_EVENT(4, "SenseID : device 0.%x.%04x reports: "
+                              "CU  Type/Mod = %04X/%02X, Dev Type/Mod = "
+                              "%04X/%02X\n",
+                              cdev->private->dev_id.ssid,
+                              cdev->private->dev_id.devno,
+                              cdev->id.cu_type, cdev->id.cu_model,
+                              cdev->id.dev_type, cdev->id.dev_model);
                 break;
         case DEV_STATE_BOXED:
-                CIO_DEBUG(KERN_WARNING, 2,
-                          "SenseID : boxed device %04x on subchannel "
-                          "0.%x.%04x\n", cdev->private->dev_id.devno,
-                          sch->schid.ssid, sch->schid.sch_no);
+                CIO_MSG_EVENT(0, "SenseID : boxed device %04x on "
+                              " subchannel 0.%x.%04x\n",
+                              cdev->private->dev_id.devno,
+                              sch->schid.ssid, sch->schid.sch_no);
                 break;
         }
         cdev->private->state = state;
@@ -443,9 +442,8 @@ ccw_device_done(struct ccw_device *cdev, int state)
 
 
         if (state == DEV_STATE_BOXED)
-                CIO_DEBUG(KERN_WARNING, 2,
-                          "Boxed device %04x on subchannel %04x\n",
-                          cdev->private->dev_id.devno, sch->schid.sch_no);
+                CIO_MSG_EVENT(0, "Boxed device %04x on subchannel %04x\n",
+                              cdev->private->dev_id.devno, sch->schid.sch_no);
 
         if (cdev->private->flags.donotify) {
                 cdev->private->flags.donotify = 0;
@@ -900,7 +898,7 @@ ccw_device_w4sense(struct ccw_device *cdev, enum dev_event dev_event)
                         /* Basic sense hasn't started. Try again. */
                         ccw_device_do_sense(cdev, irb);
                 else {
-                        CIO_MSG_EVENT(2, "Huh? 0.%x.%04x: unsolicited "
+                        CIO_MSG_EVENT(0, "0.%x.%04x: unsolicited "
                                       "interrupt during w4sense...\n",
                                       cdev->private->dev_id.ssid,
                                       cdev->private->dev_id.devno);
@@ -1169,8 +1167,10 @@ ccw_device_nop(struct ccw_device *cdev, enum dev_event dev_event)
 static void
 ccw_device_bug(struct ccw_device *cdev, enum dev_event dev_event)
 {
-        CIO_MSG_EVENT(0, "dev_jumptable[%i][%i] == NULL\n",
-                      cdev->private->state, dev_event);
+        CIO_MSG_EVENT(0, "Internal state [%i][%i] not handled for device "
+                      "0.%x.%04x\n", cdev->private->state, dev_event,
+                      cdev->private->dev_id.ssid,
+                      cdev->private->dev_id.devno);
         BUG();
 }
 
diff --git a/drivers/s390/cio/device_id.c b/drivers/s390/cio/device_id.c
index dc4d87f77f6c..cba7020517ed 100644
--- a/drivers/s390/cio/device_id.c
+++ b/drivers/s390/cio/device_id.c
@@ -214,7 +214,7 @@ ccw_device_check_sense_id(struct ccw_device *cdev)
                  *     sense id information. So, for intervention required,
                  *     we use the "whack it until it talks" strategy...
                  */
-                CIO_MSG_EVENT(2, "SenseID : device %04x on Subchannel "
+                CIO_MSG_EVENT(0, "SenseID : device %04x on Subchannel "
                               "0.%x.%04x reports cmd reject\n",
                               cdev->private->dev_id.devno, sch->schid.ssid,
                               sch->schid.sch_no);
@@ -239,7 +239,7 @@ ccw_device_check_sense_id(struct ccw_device *cdev)
 
                 lpm = to_io_private(sch)->orb.lpm;
                 if ((lpm & sch->schib.pmcw.pim & sch->schib.pmcw.pam) != 0)
-                        CIO_MSG_EVENT(2, "SenseID : path %02X for device %04x "
+                        CIO_MSG_EVENT(4, "SenseID : path %02X for device %04x "
                                       "on subchannel 0.%x.%04x is "
                                       "'not operational'\n", lpm,
                                       cdev->private->dev_id.devno,
diff --git a/drivers/s390/cio/device_pgid.c b/drivers/s390/cio/device_pgid.c
index c52449a1f9fc..ba559053402e 100644
--- a/drivers/s390/cio/device_pgid.c
+++ b/drivers/s390/cio/device_pgid.c
@@ -79,7 +79,7 @@ __ccw_device_sense_pgid_start(struct ccw_device *cdev)
                         /* ret is 0, -EBUSY, -EACCES or -ENODEV */
                         if (ret != -EACCES)
                                 return ret;
-                        CIO_MSG_EVENT(2, "SNID - Device %04x on Subchannel "
+                        CIO_MSG_EVENT(3, "SNID - Device %04x on Subchannel "
                                       "0.%x.%04x, lpm %02X, became 'not "
                                       "operational'\n",
                                       cdev->private->dev_id.devno,
@@ -159,7 +159,7 @@ __ccw_device_check_sense_pgid(struct ccw_device *cdev)
                 u8 lpm;
 
                 lpm = to_io_private(sch)->orb.lpm;
-                CIO_MSG_EVENT(2, "SNID - Device %04x on Subchannel 0.%x.%04x,"
+                CIO_MSG_EVENT(3, "SNID - Device %04x on Subchannel 0.%x.%04x,"
                               " lpm %02X, became 'not operational'\n",
                               cdev->private->dev_id.devno, sch->schid.ssid,
                               sch->schid.sch_no, lpm);
@@ -275,7 +275,7 @@ __ccw_device_do_pgid(struct ccw_device *cdev, __u8 func)
                         return ret;
         }
         /* PGID command failed on this path. */
-        CIO_MSG_EVENT(2, "SPID - Device %04x on Subchannel "
+        CIO_MSG_EVENT(3, "SPID - Device %04x on Subchannel "
                       "0.%x.%04x, lpm %02X, became 'not operational'\n",
                       cdev->private->dev_id.devno, sch->schid.ssid,
                       sch->schid.sch_no, cdev->private->imask);
@@ -317,7 +317,7 @@ static int __ccw_device_do_nop(struct ccw_device *cdev)
                         return ret;
         }
         /* nop command failed on this path. */
-        CIO_MSG_EVENT(2, "NOP - Device %04x on Subchannel "
+        CIO_MSG_EVENT(3, "NOP - Device %04x on Subchannel "
                       "0.%x.%04x, lpm %02X, became 'not operational'\n",
                       cdev->private->dev_id.devno, sch->schid.ssid,
                       sch->schid.sch_no, cdev->private->imask);
@@ -362,7 +362,7 @@ __ccw_device_check_pgid(struct ccw_device *cdev)
                 return -EAGAIN;
         }
         if (irb->scsw.cc == 3) {
-                CIO_MSG_EVENT(2, "SPID - Device %04x on Subchannel 0.%x.%04x,"
+                CIO_MSG_EVENT(3, "SPID - Device %04x on Subchannel 0.%x.%04x,"
                               " lpm %02X, became 'not operational'\n",
                               cdev->private->dev_id.devno, sch->schid.ssid,
                               sch->schid.sch_no, cdev->private->imask);
@@ -391,7 +391,7 @@ static int __ccw_device_check_nop(struct ccw_device *cdev)
                 return -ETIME;
         }
         if (irb->scsw.cc == 3) {
-                CIO_MSG_EVENT(2, "NOP - Device %04x on Subchannel 0.%x.%04x,"
+                CIO_MSG_EVENT(3, "NOP - Device %04x on Subchannel 0.%x.%04x,"
                               " lpm %02X, became 'not operational'\n",
                               cdev->private->dev_id.devno, sch->schid.ssid,
                               sch->schid.sch_no, cdev->private->imask);
diff --git a/drivers/s390/s390mach.c b/drivers/s390/s390mach.c
index 4d4b54277c43..5080f343ad74 100644
--- a/drivers/s390/s390mach.c
+++ b/drivers/s390/s390mach.c
@@ -48,10 +48,11 @@ s390_collect_crw_info(void *param)
         int ccode;
         struct semaphore *sem;
         unsigned int chain;
+        int ignore;
 
         sem = (struct semaphore *)param;
 repeat:
-        down_interruptible(sem);
+        ignore = down_interruptible(sem);
         chain = 0;
         while (1) {
                 if (unlikely(chain > 1)) {
diff --git a/drivers/sbus/char/bpp.c b/drivers/sbus/char/bpp.c
index 4fab0c23814c..b87037ec9805 100644
--- a/drivers/sbus/char/bpp.c
+++ b/drivers/sbus/char/bpp.c
@@ -41,7 +41,7 @@
 #define BPP_DELAY 100
 
 static const unsigned  BPP_MAJOR = LP_MAJOR;
-static const char* dev_name = "bpp";
+static const char *bpp_dev_name = "bpp";
 
 /* When switching from compatibility to a mode where I can read, try
    the following mode first. */
diff --git a/drivers/scsi/Kconfig b/drivers/scsi/Kconfig
index 46d7e400c8be..81ccbd7f9e34 100644
--- a/drivers/scsi/Kconfig
+++ b/drivers/scsi/Kconfig
@@ -1679,6 +1679,7 @@ config MAC_SCSI
 config SCSI_MAC_ESP
         tristate "Macintosh NCR53c9[46] SCSI"
         depends on MAC && SCSI
+        select SCSI_SPI_ATTRS
         help
           This is the NCR 53c9x SCSI controller found on most of the 68040
           based Macintoshes.
diff --git a/drivers/scsi/dpt_i2o.c b/drivers/scsi/dpt_i2o.c
index 0fb5bf4c43ac..8508816f303d 100644
--- a/drivers/scsi/dpt_i2o.c
+++ b/drivers/scsi/dpt_i2o.c
@@ -1967,45 +1967,6 @@ cleanup:
         return rcode;
 }
 
-
-/*
- * This routine returns information about the system.  This does not effect
- * any logic and if the info is wrong - it doesn't matter.
- */
-
-/* Get all the info we can not get from kernel services */
-static int adpt_system_info(void __user *buffer)
-{
-        sysInfo_S si;
-
-        memset(&si, 0, sizeof(si));
-
-        si.osType = OS_LINUX;
-        si.osMajorVersion = 0;
-        si.osMinorVersion = 0;
-        si.osRevision = 0;
-        si.busType = SI_PCI_BUS;
-        si.processorFamily = DPTI_sig.dsProcessorFamily;
-
-#if defined __i386__ 
-        adpt_i386_info(&si);
-#elif defined (__ia64__)
-        adpt_ia64_info(&si);
-#elif defined(__sparc__)
-        adpt_sparc_info(&si);
-#elif defined (__alpha__)
-        adpt_alpha_info(&si);
-#else
-        si.processorType = 0xff ;
-#endif
-        if(copy_to_user(buffer, &si, sizeof(si))){
-                printk(KERN_WARNING"dpti: Could not copy buffer TO user\n");
-                return -EFAULT;
-        }
-
-        return 0;
-}
-
 #if defined __ia64__ 
 static void adpt_ia64_info(sysInfo_S* si)
 {
@@ -2016,7 +1977,6 @@ static void adpt_ia64_info(sysInfo_S* si)
 }
 #endif
 
-
 #if defined __sparc__ 
 static void adpt_sparc_info(sysInfo_S* si)
 {
@@ -2026,7 +1986,6 @@ static void adpt_sparc_info(sysInfo_S* si)
         si->processorType = PROC_ULTRASPARC;
 }
 #endif
-
 #if defined __alpha__ 
 static void adpt_alpha_info(sysInfo_S* si)
 {
@@ -2038,7 +1997,6 @@ static void adpt_alpha_info(sysInfo_S* si)
 #endif
 
 #if defined __i386__
-
 static void adpt_i386_info(sysInfo_S* si)
 {
         // This is all the info we need for now
@@ -2059,9 +2017,45 @@ static void adpt_i386_info(sysInfo_S* si)
                 break;
         }
 }
+#endif
+
+/*
+ * This routine returns information about the system.  This does not effect
+ * any logic and if the info is wrong - it doesn't matter.
+ */
 
+/* Get all the info we can not get from kernel services */
+static int adpt_system_info(void __user *buffer)
+{
+        sysInfo_S si;
+
+        memset(&si, 0, sizeof(si));
+
+        si.osType = OS_LINUX;
+        si.osMajorVersion = 0;
+        si.osMinorVersion = 0;
+        si.osRevision = 0;
+        si.busType = SI_PCI_BUS;
+        si.processorFamily = DPTI_sig.dsProcessorFamily;
+
+#if defined __i386__
+        adpt_i386_info(&si);
+#elif defined (__ia64__)
+        adpt_ia64_info(&si);
+#elif defined(__sparc__)
+        adpt_sparc_info(&si);
+#elif defined (__alpha__)
+        adpt_alpha_info(&si);
+#else
+        si.processorType = 0xff ;
 #endif
+        if (copy_to_user(buffer, &si, sizeof(si))){
+                printk(KERN_WARNING"dpti: Could not copy buffer TO user\n");
+                return -EFAULT;
+        }
 
+        return 0;
+}
 
 static int adpt_ioctl(struct inode *inode, struct file *file, uint cmd,
               ulong arg)
diff --git a/drivers/scsi/dpti.h b/drivers/scsi/dpti.h
index 924cd5a51676..337746d46043 100644
--- a/drivers/scsi/dpti.h
+++ b/drivers/scsi/dpti.h
@@ -316,19 +316,6 @@ static int adpt_close(struct inode *inode, struct file *file);
 static void adpt_delay(int millisec);
 #endif
 
-#if defined __ia64__ 
-static void adpt_ia64_info(sysInfo_S* si);
-#endif
-#if defined __sparc__ 
-static void adpt_sparc_info(sysInfo_S* si);
-#endif
-#if defined __alpha__ 
-static void adpt_sparc_info(sysInfo_S* si);
-#endif
-#if defined __i386__
-static void adpt_i386_info(sysInfo_S* si);
-#endif
-
 #define PRINT_BUFFER_SIZE     512
 
 #define HBA_FLAGS_DBG_FLAGS_MASK         0xffff0000     // Mask for debug flags
diff --git a/drivers/serial/serial_core.c b/drivers/serial/serial_core.c
index 1e2b9d826f69..eab032733790 100644
--- a/drivers/serial/serial_core.c
+++ b/drivers/serial/serial_core.c
@@ -556,7 +556,7 @@ static int uart_chars_in_buffer(struct tty_struct *tty)
 static void uart_flush_buffer(struct tty_struct *tty)
 {
         struct uart_state *state = tty->driver_data;
-        struct uart_port *port = state->port;
+        struct uart_port *port;
         unsigned long flags;
 
         /*
@@ -568,6 +568,7 @@ static void uart_flush_buffer(struct tty_struct *tty)
                 return;
         }
 
+        port = state->port;
         pr_debug("uart_flush_buffer(%d) called\n", tty->index);
 
         spin_lock_irqsave(&port->lock, flags);
diff --git a/drivers/usb/host/Kconfig b/drivers/usb/host/Kconfig
index 33b467a8352d..1ef6df395e0c 100644
--- a/drivers/usb/host/Kconfig
+++ b/drivers/usb/host/Kconfig
@@ -129,7 +129,7 @@ config USB_ISP1760_PCI
 
 config USB_ISP1760_OF
         bool "Support for the OF platform bus"
-        depends on USB_ISP1760_HCD && OF
+        depends on USB_ISP1760_HCD && PPC_OF
         ---help---
           Enables support for the device present on the PowerPC
           OpenFirmware platform bus.
diff --git a/drivers/usb/serial/iuu_phoenix.c b/drivers/usb/serial/iuu_phoenix.c
index 8a217648b250..a01e987c7d32 100644
--- a/drivers/usb/serial/iuu_phoenix.c
+++ b/drivers/usb/serial/iuu_phoenix.c
@@ -643,7 +643,7 @@ static void read_buf_callback(struct urb *urb)
 static int iuu_bulk_write(struct usb_serial_port *port)
 {
         struct iuu_private *priv = usb_get_serial_port_data(port);
-        unsigned int flags;
+        unsigned long flags;
         int result;
         int i;
         char *buf_ptr = port->write_urb->transfer_buffer;
@@ -694,7 +694,7 @@ static void iuu_uart_read_callback(struct urb *urb)
 {
         struct usb_serial_port *port = urb->context;
         struct iuu_private *priv = usb_get_serial_port_data(port);
-        unsigned int flags;
+        unsigned long flags;
         int status;
         int error = 0;
         int len = 0;
@@ -759,7 +759,7 @@ static int iuu_uart_write(struct usb_serial_port *port, const u8 *buf,
                           int count)
 {
         struct iuu_private *priv = usb_get_serial_port_data(port);
-        unsigned int flags;
+        unsigned long flags;
         dbg("%s - enter", __func__);
 
         if (count > 256)
diff --git a/drivers/video/bw2.c b/drivers/video/bw2.c
index 275d9dab0c61..79f85dc402d6 100644
--- a/drivers/video/bw2.c
+++ b/drivers/video/bw2.c
@@ -329,7 +329,7 @@ static int __devinit bw2_probe(struct of_device *op, const struct of_device_id *
         if (!info->screen_base)
                 goto out_unmap_regs;
 
-        bw2_blank(0, info);
+        bw2_blank(FB_BLANK_UNBLANK, info);
 
         bw2_init_fix(info, linebytes);
 
diff --git a/drivers/video/cg3.c b/drivers/video/cg3.c
index 010ea53978f8..e31e26a6bb79 100644
--- a/drivers/video/cg3.c
+++ b/drivers/video/cg3.c
@@ -398,7 +398,7 @@ static int __devinit cg3_probe(struct of_device *op,
         if (!info->screen_base)
                 goto out_unmap_regs;
 
-        cg3_blank(0, info);
+        cg3_blank(FB_BLANK_UNBLANK, info);
 
         if (!of_find_property(dp, "width", NULL)) {
                 err = cg3_do_default_mode(par);
diff --git a/drivers/video/cg6.c b/drivers/video/cg6.c
index fc90db6da65a..8000bccecdc6 100644
--- a/drivers/video/cg6.c
+++ b/drivers/video/cg6.c
@@ -767,7 +767,7 @@ static int __devinit cg6_probe(struct of_device *op,
 
         cg6_bt_init(par);
         cg6_chip_init(info);
-        cg6_blank(0, info);
+        cg6_blank(FB_BLANK_UNBLANK, info);
 
         if (fb_alloc_cmap(&info->cmap, 256, 0))
                 goto out_unmap_regs;
diff --git a/drivers/video/ffb.c b/drivers/video/ffb.c
index 93dca3e2aa50..0f42a696d176 100644
--- a/drivers/video/ffb.c
+++ b/drivers/video/ffb.c
@@ -987,7 +987,7 @@ static int __devinit ffb_probe(struct of_device *op,
          * chosen console, it will have video outputs off in
          * the DAC.
          */
-        ffb_blank(0, info);
+        ffb_blank(FB_BLANK_UNBLANK, info);
 
         if (fb_alloc_cmap(&info->cmap, 256, 0))
                 goto out_unmap_dac;
diff --git a/drivers/video/leo.c b/drivers/video/leo.c
index f3160fc29795..fb129928d5d5 100644
--- a/drivers/video/leo.c
+++ b/drivers/video/leo.c
@@ -601,7 +601,7 @@ static int __devinit leo_probe(struct of_device *op, const struct of_device_id *
         leo_init_wids(info);
         leo_init_hw(info);
 
-        leo_blank(0, info);
+        leo_blank(FB_BLANK_UNBLANK, info);
 
         if (fb_alloc_cmap(&info->cmap, 256, 0))
                 goto out_unmap_regs;
diff --git a/drivers/video/p9100.c b/drivers/video/p9100.c
index c95874fe9076..676ffb06d1c7 100644
--- a/drivers/video/p9100.c
+++ b/drivers/video/p9100.c
@@ -295,7 +295,7 @@ static int __devinit p9100_probe(struct of_device *op, const struct of_device_id
         if (!info->screen_base)
                 goto out_unmap_regs;
 
-        p9100_blank(0, info);
+        p9100_blank(FB_BLANK_UNBLANK, info);
 
         if (fb_alloc_cmap(&info->cmap, 256, 0))
                 goto out_unmap_screen;
diff --git a/drivers/video/tcx.c b/drivers/video/tcx.c
index a71774305772..44e8c27ed0fc 100644
--- a/drivers/video/tcx.c
+++ b/drivers/video/tcx.c
@@ -84,7 +84,7 @@ struct tcx_tec {
 
 struct tcx_thc {
         u32 thc_rev;
-        u32 thc_pad0[511];
+        u32 thc_pad0[511];
         u32 thc_hs;             /* hsync timing */
         u32 thc_hsdvs;
         u32 thc_hd;
@@ -126,10 +126,10 @@ struct tcx_par {
 };
 
 /* Reset control plane so that WID is 8-bit plane. */
-static void __tcx_set_control_plane (struct tcx_par *par)
+static void __tcx_set_control_plane(struct tcx_par *par)
 {
         u32 __iomem *p, *pend;
-        
+
         if (par->lowdepth)
                 return;
 
@@ -143,8 +143,8 @@ static void __tcx_set_control_plane (struct tcx_par *par)
                 sbus_writel(tmp, p);
         }
 }
-                                                
-static void tcx_reset (struct fb_info *info)
+
+static void tcx_reset(struct fb_info *info)
 {
         struct tcx_par *par = (struct tcx_par *) info->par;
         unsigned long flags;
@@ -365,7 +365,8 @@ static void tcx_unmap_regs(struct of_device *op, struct fb_info *info,
                            info->screen_base, par->fbsize);
 }
 
-static int __devinit tcx_init_one(struct of_device *op)
+static int __devinit tcx_probe(struct of_device *op,
+                               const struct of_device_id *match)
 {
         struct device_node *dp = op->node;
         struct fb_info *info;
@@ -488,13 +489,6 @@ out_err:
         return err;
 }
 
-static int __devinit tcx_probe(struct of_device *dev, const struct of_device_id *match)
-{
-        struct of_device *op = to_of_device(&dev->dev);
-
-        return tcx_init_one(op);
-}
-
 static int __devexit tcx_remove(struct of_device *op)
 {
         struct fb_info *info = dev_get_drvdata(&op->dev);