193 files changed, 6077 insertions, 2811 deletions

diff --git a/drivers/acpi/numa.c b/drivers/acpi/numa.c
index 4dd0dabe81cb..8fcd6a15517f 100644
--- a/drivers/acpi/numa.c
+++ b/drivers/acpi/numa.c
@@ -228,7 +228,7 @@ int __init acpi_numa_init(void)
         return 0;
 }
 
-int __meminit acpi_get_pxm(acpi_handle h)
+int acpi_get_pxm(acpi_handle h)
 {
         unsigned long pxm;
         acpi_status status;
@@ -246,7 +246,7 @@ int __meminit acpi_get_pxm(acpi_handle h)
 }
 EXPORT_SYMBOL(acpi_get_pxm);
 
-int __meminit acpi_get_node(acpi_handle *handle)
+int acpi_get_node(acpi_handle *handle)
 {
         int pxm, node = -1;
 
diff --git a/drivers/acpi/sleep/main.c b/drivers/acpi/sleep/main.c
index f8c63410bcbf..52b23471dd69 100644
--- a/drivers/acpi/sleep/main.c
+++ b/drivers/acpi/sleep/main.c
@@ -29,7 +29,6 @@ static u32 acpi_suspend_states[] = {
         [PM_SUSPEND_ON] = ACPI_STATE_S0,
         [PM_SUSPEND_STANDBY] = ACPI_STATE_S1,
         [PM_SUSPEND_MEM] = ACPI_STATE_S3,
-        [PM_SUSPEND_DISK] = ACPI_STATE_S4,
         [PM_SUSPEND_MAX] = ACPI_STATE_S5
 };
 
@@ -94,14 +93,6 @@ static int acpi_pm_enter(suspend_state_t pm_state)
                 do_suspend_lowlevel();
                 break;
 
-        case PM_SUSPEND_DISK:
-                if (acpi_pm_ops.pm_disk_mode == PM_DISK_PLATFORM)
-                        status = acpi_enter_sleep_state(acpi_state);
-                break;
-        case PM_SUSPEND_MAX:
-                acpi_power_off();
-                break;
-
         default:
                 return -EINVAL;
         }
@@ -157,12 +148,13 @@ int acpi_suspend(u32 acpi_state)
         suspend_state_t states[] = {
                 [1] = PM_SUSPEND_STANDBY,
                 [3] = PM_SUSPEND_MEM,
-                [4] = PM_SUSPEND_DISK,
                 [5] = PM_SUSPEND_MAX
         };
 
         if (acpi_state < 6 && states[acpi_state])
                 return pm_suspend(states[acpi_state]);
+        if (acpi_state == 4)
+                return hibernate();
         return -EINVAL;
 }
 
@@ -189,6 +181,49 @@ static struct pm_ops acpi_pm_ops = {
         .finish = acpi_pm_finish,
 };
 
+#ifdef CONFIG_SOFTWARE_SUSPEND
+static int acpi_hibernation_prepare(void)
+{
+        return acpi_sleep_prepare(ACPI_STATE_S4);
+}
+
+static int acpi_hibernation_enter(void)
+{
+        acpi_status status = AE_OK;
+        unsigned long flags = 0;
+
+        ACPI_FLUSH_CPU_CACHE();
+
+        local_irq_save(flags);
+        acpi_enable_wakeup_device(ACPI_STATE_S4);
+        /* This shouldn't return.  If it returns, we have a problem */
+        status = acpi_enter_sleep_state(ACPI_STATE_S4);
+        local_irq_restore(flags);
+
+        return ACPI_SUCCESS(status) ? 0 : -EFAULT;
+}
+
+static void acpi_hibernation_finish(void)
+{
+        acpi_leave_sleep_state(ACPI_STATE_S4);
+        acpi_disable_wakeup_device(ACPI_STATE_S4);
+
+        /* reset firmware waking vector */
+        acpi_set_firmware_waking_vector((acpi_physical_address) 0);
+
+        if (init_8259A_after_S1) {
+                printk("Broken toshiba laptop -> kicking interrupts\n");
+                init_8259A(0);
+        }
+}
+
+static struct hibernation_ops acpi_hibernation_ops = {
+        .prepare = acpi_hibernation_prepare,
+        .enter = acpi_hibernation_enter,
+        .finish = acpi_hibernation_finish,
+};
+#endif /* CONFIG_SOFTWARE_SUSPEND */
+
 /*
  * Toshiba fails to preserve interrupts over S1, reinitialization
  * of 8259 is needed after S1 resume.
@@ -227,14 +262,18 @@ int __init acpi_sleep_init(void)
                         sleep_states[i] = 1;
                         printk(" S%d", i);
                 }
-                if (i == ACPI_STATE_S4) {
-                        if (sleep_states[i])
-                                acpi_pm_ops.pm_disk_mode = PM_DISK_PLATFORM;
-                }
         }
         printk(")\n");
 
         pm_set_ops(&acpi_pm_ops);
+
+#ifdef CONFIG_SOFTWARE_SUSPEND
+        if (sleep_states[ACPI_STATE_S4])
+                hibernation_set_ops(&acpi_hibernation_ops);
+#else
+        sleep_states[ACPI_STATE_S4] = 0;
+#endif
+
         return 0;
 }
 
diff --git a/drivers/acpi/sleep/proc.c b/drivers/acpi/sleep/proc.c
index 5a76e5be61d5..76b45f0b8341 100644
--- a/drivers/acpi/sleep/proc.c
+++ b/drivers/acpi/sleep/proc.c
@@ -60,7 +60,7 @@ acpi_system_write_sleep(struct file *file,
         state = simple_strtoul(str, NULL, 0);
 #ifdef CONFIG_SOFTWARE_SUSPEND
         if (state == 4) {
-                error = pm_suspend(PM_SUSPEND_DISK);
+                error = hibernate();
                 goto Done;
         }
 #endif
diff --git a/drivers/ata/Kconfig b/drivers/ata/Kconfig
index 45dbdc14915f..c7219663f2b9 100644
--- a/drivers/ata/Kconfig
+++ b/drivers/ata/Kconfig
@@ -435,7 +435,7 @@ config PATA_OPTIDMA
         help
           This option enables DMA/PIO support for the later OPTi
           controllers found on some old motherboards and in some
-          latops
+          laptops.
 
           If unsure, say N.
 
diff --git a/drivers/ata/libata-core.c b/drivers/ata/libata-core.c
index a7950885d18e..fef87dd70d17 100644
--- a/drivers/ata/libata-core.c
+++ b/drivers/ata/libata-core.c
@@ -1316,7 +1316,7 @@ void ata_port_flush_task(struct ata_port *ap)
         spin_unlock_irqrestore(ap->lock, flags);
 
         DPRINTK("flush #1\n");
-        flush_workqueue(ata_wq);
+        cancel_work_sync(&ap->port_task.work); /* akpm: seems unneeded */
 
         /*
          * At this point, if a task is running, it's guaranteed to see
@@ -1327,7 +1327,7 @@ void ata_port_flush_task(struct ata_port *ap)
                 if (ata_msg_ctl(ap))
                         ata_port_printk(ap, KERN_DEBUG, "%s: flush #2\n",
                                         __FUNCTION__);
-                flush_workqueue(ata_wq);
+                cancel_work_sync(&ap->port_task.work);
         }
 
         spin_lock_irqsave(ap->lock, flags);
@@ -6475,9 +6475,9 @@ void ata_port_detach(struct ata_port *ap)
         /* Flush hotplug task.  The sequence is similar to
          * ata_port_flush_task().
          */
-        flush_workqueue(ata_aux_wq);
+        cancel_work_sync(&ap->hotplug_task.work); /* akpm: why? */
         cancel_delayed_work(&ap->hotplug_task);
-        flush_workqueue(ata_aux_wq);
+        cancel_work_sync(&ap->hotplug_task.work);
 
  skip_eh:
         /* remove the associated SCSI host */
diff --git a/drivers/base/devres.c b/drivers/base/devres.c
index e177c9533b6c..e1c0730a3b99 100644
--- a/drivers/base/devres.c
+++ b/drivers/base/devres.c
@@ -101,19 +101,6 @@ static void add_dr(struct device *dev, struct devres_node *node)
         list_add_tail(&node->entry, &dev->devres_head);
 }
 
-/**
- * devres_alloc - Allocate device resource data
- * @release: Release function devres will be associated with
- * @size: Allocation size
- * @gfp: Allocation flags
- *
- * allocate devres of @size bytes.  The allocated area is zeroed, then
- * associated with @release.  The returned pointer can be passed to
- * other devres_*() functions.
- *
- * RETURNS:
- * Pointer to allocated devres on success, NULL on failure.
- */
 #ifdef CONFIG_DEBUG_DEVRES
 void * __devres_alloc(dr_release_t release, size_t size, gfp_t gfp,
                       const char *name)
@@ -128,6 +115,19 @@ void * __devres_alloc(dr_release_t release, size_t size, gfp_t gfp,
 }
 EXPORT_SYMBOL_GPL(__devres_alloc);
 #else
+/**
+ * devres_alloc - Allocate device resource data
+ * @release: Release function devres will be associated with
+ * @size: Allocation size
+ * @gfp: Allocation flags
+ *
+ * Allocate devres of @size bytes.  The allocated area is zeroed, then
+ * associated with @release.  The returned pointer can be passed to
+ * other devres_*() functions.
+ *
+ * RETURNS:
+ * Pointer to allocated devres on success, NULL on failure.
+ */
 void * devres_alloc(dr_release_t release, size_t size, gfp_t gfp)
 {
         struct devres *dr;
@@ -416,7 +416,7 @@ static int release_nodes(struct device *dev, struct list_head *first,
 }
 
 /**
- * devres_release_all - Release all resources
+ * devres_release_all - Release all managed resources
  * @dev: Device to release resources for
  *
  * Release all resources associated with @dev.  This function is
@@ -600,7 +600,7 @@ static int devm_kzalloc_match(struct device *dev, void *res, void *data)
 }
 
 /**
- * devm_kzalloc - Managed kzalloc
+ * devm_kzalloc - Resource-managed kzalloc
  * @dev: Device to allocate memory for
  * @size: Allocation size
  * @gfp: Allocation gfp flags
@@ -628,7 +628,7 @@ void * devm_kzalloc(struct device *dev, size_t size, gfp_t gfp)
 EXPORT_SYMBOL_GPL(devm_kzalloc);
 
 /**
- * devm_kfree - Managed kfree
+ * devm_kfree - Resource-managed kfree
  * @dev: Device this memory belongs to
  * @p: Memory to free
  *
diff --git a/drivers/base/platform.c b/drivers/base/platform.c
index eb84d9d44645..869ff8c00146 100644
--- a/drivers/base/platform.c
+++ b/drivers/base/platform.c
@@ -360,7 +360,7 @@ EXPORT_SYMBOL_GPL(platform_device_unregister);
  *      This function creates a simple platform device that requires minimal
  *      resource and memory management. Canned release function freeing
  *      memory allocated for the device allows drivers using such devices
- *      to be unloaded iwithout waiting for the last reference to the device
+ *      to be unloaded without waiting for the last reference to the device
  *      to be dropped.
  *
  *      This interface is primarily intended for use with legacy drivers
diff --git a/drivers/base/topology.c b/drivers/base/topology.c
index 067a9e8bc377..8d8cdfec6529 100644
--- a/drivers/base/topology.c
+++ b/drivers/base/topology.c
@@ -126,10 +126,13 @@ static int __cpuinit topology_cpu_callback(struct notifier_block *nfb,
 
         switch (action) {
         case CPU_UP_PREPARE:
+        case CPU_UP_PREPARE_FROZEN:
                 rc = topology_add_dev(cpu);
                 break;
         case CPU_UP_CANCELED:
+        case CPU_UP_CANCELED_FROZEN:
         case CPU_DEAD:
+        case CPU_DEAD_FROZEN:
                 topology_remove_dev(cpu);
                 break;
         }
diff --git a/drivers/block/loop.c b/drivers/block/loop.c
index af6d7274a7cc..18cdd8c77626 100644
--- a/drivers/block/loop.c
+++ b/drivers/block/loop.c
@@ -243,17 +243,13 @@ static int do_lo_send_aops(struct loop_device *lo, struct bio_vec *bvec,
                 transfer_result = lo_do_transfer(lo, WRITE, page, offset,
                                 bvec->bv_page, bv_offs, size, IV);
                 if (unlikely(transfer_result)) {
-                        char *kaddr;
-
                         /*
                          * The transfer failed, but we still write the data to
                          * keep prepare/commit calls balanced.
                          */
                         printk(KERN_ERR "loop: transfer error block %llu\n",
                                (unsigned long long)index);
-                        kaddr = kmap_atomic(page, KM_USER0);
-                        memset(kaddr + offset, 0, size);
-                        kunmap_atomic(kaddr, KM_USER0);
+                        zero_user_page(page, offset, size, KM_USER0);
                 }
                 flush_dcache_page(page);
                 ret = aops->commit_write(file, page, offset,
diff --git a/drivers/block/nbd.c b/drivers/block/nbd.c
index 090796bef78f..069ae39a9cd9 100644
--- a/drivers/block/nbd.c
+++ b/drivers/block/nbd.c
@@ -366,20 +366,25 @@ static struct disk_attribute pid_attr = {
         .show = pid_show,
 };
 
-static void nbd_do_it(struct nbd_device *lo)
+static int nbd_do_it(struct nbd_device *lo)
 {
         struct request *req;
+        int ret;
 
         BUG_ON(lo->magic != LO_MAGIC);
 
         lo->pid = current->pid;
-        sysfs_create_file(&lo->disk->kobj, &pid_attr.attr);
+        ret = sysfs_create_file(&lo->disk->kobj, &pid_attr.attr);
+        if (ret) {
+                printk(KERN_ERR "nbd: sysfs_create_file failed!");
+                return ret;
+        }
 
         while ((req = nbd_read_stat(lo)) != NULL)
                 nbd_end_request(req);
 
         sysfs_remove_file(&lo->disk->kobj, &pid_attr.attr);
-        return;
+        return 0;
 }
 
 static void nbd_clear_que(struct nbd_device *lo)
@@ -569,7 +574,9 @@ static int nbd_ioctl(struct inode *inode, struct file *file,
         case NBD_DO_IT:
                 if (!lo->file)
                         return -EINVAL;
-                nbd_do_it(lo);
+                error = nbd_do_it(lo);
+                if (error)
+                        return error;
                 /* on return tidy up in case we have a signal */
                 /* Forcibly shutdown the socket causing all listeners
                  * to error
diff --git a/drivers/block/rd.c b/drivers/block/rd.c
index 43d4ebcb3b44..a1512da32410 100644
--- a/drivers/block/rd.c
+++ b/drivers/block/rd.c
@@ -151,7 +151,7 @@ static int ramdisk_commit_write(struct file *file, struct page *page,
 }
 
 /*
- * ->writepage to the the blockdev's mapping has to redirty the page so that the
+ * ->writepage to the blockdev's mapping has to redirty the page so that the
  * VM doesn't go and steal it.  We return AOP_WRITEPAGE_ACTIVATE so that the VM
  * won't try to (pointlessly) write the page again for a while.
  *
diff --git a/drivers/char/Kconfig b/drivers/char/Kconfig
index 1e32fb834eb8..2df42fdcdc91 100644
--- a/drivers/char/Kconfig
+++ b/drivers/char/Kconfig
@@ -631,7 +631,8 @@ config HVC_CONSOLE
 
 config HVC_ISERIES
         bool "iSeries Hypervisor Virtual Console support"
-        depends on PPC_ISERIES && !VIOCONS
+        depends on PPC_ISERIES
+        default y
         select HVC_DRIVER
         help
           iSeries machines support a hypervisor virtual console.
diff --git a/drivers/char/drm/drm_dma.c b/drivers/char/drm/drm_dma.c
index 892db7096986..32ed19c9ec1c 100644
--- a/drivers/char/drm/drm_dma.c
+++ b/drivers/char/drm/drm_dma.c
@@ -65,7 +65,7 @@ int drm_dma_setup(drm_device_t * dev)
  * \param dev DRM device.
  *
  * Free all pages associated with DMA buffers, the buffers and pages lists, and
- * finally the the drm_device::dma structure itself.
+ * finally the drm_device::dma structure itself.
  */
 void drm_dma_takedown(drm_device_t * dev)
 {
diff --git a/drivers/char/drm/drm_vm.c b/drivers/char/drm/drm_vm.c
index 35540cfb43dd..b5c5b9fa84c3 100644
--- a/drivers/char/drm/drm_vm.c
+++ b/drivers/char/drm/drm_vm.c
@@ -157,7 +157,7 @@ static __inline__ struct page *drm_do_vm_nopage(struct vm_area_struct *vma,
  * \param address access address.
  * \return pointer to the page structure.
  *
- * Get the the mapping, find the real physical page to map, get the page, and
+ * Get the mapping, find the real physical page to map, get the page, and
  * return it.
  */
 static __inline__ struct page *drm_do_vm_shm_nopage(struct vm_area_struct *vma,
diff --git a/drivers/char/drm/r300_reg.h b/drivers/char/drm/r300_reg.h
index a881f96c983e..ecda760ae8c0 100644
--- a/drivers/char/drm/r300_reg.h
+++ b/drivers/char/drm/r300_reg.h
@@ -293,7 +293,7 @@ I am fairly certain that they are correct unless stated otherwise in comments.
 #       define R300_PVS_CNTL_1_PROGRAM_START_SHIFT   0
 #       define R300_PVS_CNTL_1_POS_END_SHIFT         10
 #       define R300_PVS_CNTL_1_PROGRAM_END_SHIFT     20
-/* Addresses are relative the the vertex program parameters area. */
+/* Addresses are relative to the vertex program parameters area. */
 #define R300_VAP_PVS_CNTL_2                 0x22D4
 #       define R300_PVS_CNTL_2_PARAM_OFFSET_SHIFT 0
 #       define R300_PVS_CNTL_2_PARAM_COUNT_SHIFT  16
diff --git a/drivers/char/genrtc.c b/drivers/char/genrtc.c
index 49f914e79216..9e1fc02967ff 100644
--- a/drivers/char/genrtc.c
+++ b/drivers/char/genrtc.c
@@ -12,7 +12,7 @@
  *
  *      This driver allows use of the real time clock (built into
  *      nearly all computers) from user space. It exports the /dev/rtc
- *      interface supporting various ioctl() and also the /proc/dev/rtc
+ *      interface supporting various ioctl() and also the /proc/driver/rtc
  *      pseudo-file for status information.
  *
  *      The ioctls can be used to set the interrupt behaviour where
@@ -377,7 +377,7 @@ static int gen_rtc_release(struct inode *inode, struct file *file)
 #ifdef CONFIG_PROC_FS
 
 /*
- *      Info exported via "/proc/rtc".
+ *      Info exported via "/proc/driver/rtc".
  */
 
 static int gen_rtc_proc_output(char *buf)
diff --git a/drivers/char/hw_random/Kconfig b/drivers/char/hw_random/Kconfig
index 5f3acd8e64b8..7cda04b33534 100644
--- a/drivers/char/hw_random/Kconfig
+++ b/drivers/char/hw_random/Kconfig
@@ -91,3 +91,17 @@ config HW_RANDOM_OMAP
           module will be called omap-rng.
 
           If unsure, say Y.
+
+config HW_RANDOM_PASEMI
+        tristate "PA Semi HW Random Number Generator support"
+        depends on HW_RANDOM && PPC_PASEMI
+        default HW_RANDOM
+        ---help---
+          This driver provides kernel-side support for the Random Number
+          Generator hardware found on PA6T-1682M processor.
+
+          To compile this driver as a module, choose M here: the
+          module will be called pasemi-rng.
+
+          If unsure, say Y.
+
diff --git a/drivers/char/hw_random/Makefile b/drivers/char/hw_random/Makefile
index c41fa19454e3..c8b7300e2fb1 100644
--- a/drivers/char/hw_random/Makefile
+++ b/drivers/char/hw_random/Makefile
@@ -10,3 +10,4 @@ obj-$(CONFIG_HW_RANDOM_GEODE) += geode-rng.o
 obj-$(CONFIG_HW_RANDOM_VIA) += via-rng.o
 obj-$(CONFIG_HW_RANDOM_IXP4XX) += ixp4xx-rng.o
 obj-$(CONFIG_HW_RANDOM_OMAP) += omap-rng.o
+obj-$(CONFIG_HW_RANDOM_PASEMI) += pasemi-rng.o
diff --git a/drivers/char/hw_random/pasemi-rng.c b/drivers/char/hw_random/pasemi-rng.c
new file mode 100644
index 000000000000..fa6040b6c8f2
--- /dev/null
+++ b/drivers/char/hw_random/pasemi-rng.c
@@ -0,0 +1,156 @@
+/*
+ * Copyright (C) 2006-2007 PA Semi, Inc
+ *
+ * Maintained by: Olof Johansson <olof@lixom.net>
+ *
+ * Driver for the PWRficient onchip rng
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 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; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+ */
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/platform_device.h>
+#include <linux/hw_random.h>
+#include <asm/of_platform.h>
+#include <asm/io.h>
+
+#define SDCRNG_CTL_REG                  0x00
+#define   SDCRNG_CTL_FVLD_M             0x0000f000
+#define   SDCRNG_CTL_FVLD_S             12
+#define   SDCRNG_CTL_KSZ                0x00000800
+#define   SDCRNG_CTL_RSRC_CRG           0x00000010
+#define   SDCRNG_CTL_RSRC_RRG           0x00000000
+#define   SDCRNG_CTL_CE                 0x00000004
+#define   SDCRNG_CTL_RE                 0x00000002
+#define   SDCRNG_CTL_DR                 0x00000001
+#define   SDCRNG_CTL_SELECT_RRG_RNG     (SDCRNG_CTL_RE | SDCRNG_CTL_RSRC_RRG)
+#define   SDCRNG_CTL_SELECT_CRG_RNG     (SDCRNG_CTL_CE | SDCRNG_CTL_RSRC_CRG)
+#define SDCRNG_VAL_REG                  0x20
+
+#define MODULE_NAME "pasemi_rng"
+
+static int pasemi_rng_data_present(struct hwrng *rng)
+{
+        void __iomem *rng_regs = (void __iomem *)rng->priv;
+
+        return (in_le32(rng_regs + SDCRNG_CTL_REG)
+                & SDCRNG_CTL_FVLD_M) ? 1 : 0;
+}
+
+static int pasemi_rng_data_read(struct hwrng *rng, u32 *data)
+{
+        void __iomem *rng_regs = (void __iomem *)rng->priv;
+        *data = in_le32(rng_regs + SDCRNG_VAL_REG);
+        return 4;
+}
+
+static int pasemi_rng_init(struct hwrng *rng)
+{
+        void __iomem *rng_regs = (void __iomem *)rng->priv;
+        u32 ctl;
+
+        ctl = SDCRNG_CTL_DR | SDCRNG_CTL_SELECT_RRG_RNG | SDCRNG_CTL_KSZ;
+        out_le32(rng_regs + SDCRNG_CTL_REG, ctl);
+        out_le32(rng_regs + SDCRNG_CTL_REG, ctl & ~SDCRNG_CTL_DR);
+
+        return 0;
+}
+
+static void pasemi_rng_cleanup(struct hwrng *rng)
+{
+        void __iomem *rng_regs = (void __iomem *)rng->priv;
+        u32 ctl;
+
+        ctl = SDCRNG_CTL_RE | SDCRNG_CTL_CE;
+        out_le32(rng_regs + SDCRNG_CTL_REG,
+                 in_le32(rng_regs + SDCRNG_CTL_REG) & ~ctl);
+}
+
+static struct hwrng pasemi_rng = {
+        .name           = MODULE_NAME,
+        .init           = pasemi_rng_init,
+        .cleanup        = pasemi_rng_cleanup,
+        .data_present   = pasemi_rng_data_present,
+        .data_read      = pasemi_rng_data_read,
+};
+
+static int __devinit rng_probe(struct of_device *ofdev,
+                               const struct of_device_id *match)
+{
+        void __iomem *rng_regs;
+        struct device_node *rng_np = ofdev->node;
+        struct resource res;
+        int err = 0;
+
+        err = of_address_to_resource(rng_np, 0, &res);
+        if (err)
+                return -ENODEV;
+
+        rng_regs = ioremap(res.start, 0x100);
+
+        if (!rng_regs)
+                return -ENOMEM;
+
+        pasemi_rng.priv = (unsigned long)rng_regs;
+
+        printk(KERN_INFO "Registering PA Semi RNG\n");
+
+        err = hwrng_register(&pasemi_rng);
+
+        if (err)
+                iounmap(rng_regs);
+
+        return err;
+}
+
+static int __devexit rng_remove(struct of_device *dev)
+{
+        void __iomem *rng_regs = (void __iomem *)pasemi_rng.priv;
+
+        hwrng_unregister(&pasemi_rng);
+        iounmap(rng_regs);
+
+        return 0;
+}
+
+static struct of_device_id rng_match[] = {
+        {
+                .compatible      = "1682m-rng",
+        },
+        {},
+};
+
+static struct of_platform_driver rng_driver = {
+        .name           = "pasemi-rng",
+        .match_table    = rng_match,
+        .probe          = rng_probe,
+        .remove         = rng_remove,
+};
+
+static int __init rng_init(void)
+{
+        return of_register_platform_driver(&rng_driver);
+}
+module_init(rng_init);
+
+static void __exit rng_exit(void)
+{
+        of_unregister_platform_driver(&rng_driver);
+}
+module_exit(rng_exit);
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Egor Martovetsky <egor@pasemi.com>");
+MODULE_DESCRIPTION("H/W RNG driver for PA Semi processor");
diff --git a/drivers/char/pcmcia/Kconfig b/drivers/char/pcmcia/Kconfig
index 27c1179ee527..f25facd97bb4 100644
--- a/drivers/char/pcmcia/Kconfig
+++ b/drivers/char/pcmcia/Kconfig
@@ -21,6 +21,7 @@ config SYNCLINK_CS
 config CARDMAN_4000
         tristate "Omnikey Cardman 4000 support"
         depends on PCMCIA
+        select BITREVERSE
         help
           Enable support for the Omnikey Cardman 4000 PCMCIA Smartcard
           reader.
diff --git a/drivers/char/pcmcia/cm4000_cs.c b/drivers/char/pcmcia/cm4000_cs.c
index e91b43a014b0..fee58e03dbe2 100644
--- a/drivers/char/pcmcia/cm4000_cs.c
+++ b/drivers/char/pcmcia/cm4000_cs.c
@@ -31,6 +31,7 @@
 #include <linux/init.h>
 #include <linux/fs.h>
 #include <linux/delay.h>
+#include <linux/bitrev.h>
 #include <asm/uaccess.h>
 #include <asm/io.h>
 
@@ -194,41 +195,17 @@ static inline unsigned char xinb(unsigned short port)
 }
 #endif
 
-#define b_0000  15
-#define b_0001  14
-#define b_0010  13
-#define b_0011  12
-#define b_0100  11
-#define b_0101  10
-#define b_0110  9
-#define b_0111  8
-#define b_1000  7
-#define b_1001  6
-#define b_1010  5
-#define b_1011  4
-#define b_1100  3
-#define b_1101  2
-#define b_1110  1
-#define b_1111  0
-
-static unsigned char irtab[16] = {
-        b_0000, b_1000, b_0100, b_1100,
-        b_0010, b_1010, b_0110, b_1110,
-        b_0001, b_1001, b_0101, b_1101,
-        b_0011, b_1011, b_0111, b_1111
-};
+static inline unsigned char invert_revert(unsigned char ch)
+{
+        return bitrev8(~ch);
+}
 
 static void str_invert_revert(unsigned char *b, int len)
 {
         int i;
 
         for (i = 0; i < len; i++)
-                b[i] = (irtab[b[i] & 0x0f] << 4) | irtab[b[i] >> 4];
-}
-
-static unsigned char invert_revert(unsigned char ch)
-{
-        return (irtab[ch & 0x0f] << 4) | irtab[ch >> 4];
+                b[i] = invert_revert(b[i]);
 }
 
 #define ATRLENCK(dev,pos) \
@@ -1114,7 +1091,7 @@ static ssize_t cmm_write(struct file *filp, const char __user *buf,
         /*
          * wait for atr to become valid.
          * note: it is important to lock this code. if we dont, the monitor
-         * could be run between test_bit and the the call the sleep on the
+         * could be run between test_bit and the call to sleep on the
          * atr-queue.  if *then* the monitor detects atr valid, it will wake up
          * any process on the atr-queue, *but* since we have been interrupted,
          * we do not yet sleep on this queue. this would result in a missed
@@ -1881,8 +1858,11 @@ static int cm4000_probe(struct pcmcia_device *link)
         init_waitqueue_head(&dev->readq);
 
         ret = cm4000_config(link, i);
-        if (ret)
+        if (ret) {
+                dev_table[i] = NULL;
+                kfree(dev);
                 return ret;
+        }
 
         class_device_create(cmm_class, NULL, MKDEV(major, i), NULL,
                             "cmm%d", i);
@@ -1907,7 +1887,7 @@ static void cm4000_detach(struct pcmcia_device *link)
         cm4000_release(link);
 
         dev_table[devno] = NULL;
-        kfree(dev);
+        kfree(dev);
 
         class_device_destroy(cmm_class, MKDEV(major, devno));
 
@@ -1956,12 +1936,14 @@ static int __init cmm_init(void)
         if (major < 0) {
                 printk(KERN_WARNING MODULE_NAME
                         ": could not get major number\n");
+                class_destroy(cmm_class);
                 return major;
         }
 
         rc = pcmcia_register_driver(&cm4000_driver);
         if (rc < 0) {
                 unregister_chrdev(major, DEVICE_NAME);
+                class_destroy(cmm_class);
                 return rc;
         }
 
diff --git a/drivers/char/pcmcia/cm4040_cs.c b/drivers/char/pcmcia/cm4040_cs.c
index f2e4ec4fd407..af88181a17f4 100644
--- a/drivers/char/pcmcia/cm4040_cs.c
+++ b/drivers/char/pcmcia/cm4040_cs.c
@@ -636,8 +636,11 @@ static int reader_probe(struct pcmcia_device *link)
         setup_timer(&dev->poll_timer, cm4040_do_poll, 0);
 
         ret = reader_config(link, i);
-        if (ret)
+        if (ret) {
+                dev_table[i] = NULL;
+                kfree(dev);
                 return ret;
+        }
 
         class_device_create(cmx_class, NULL, MKDEV(major, i), NULL,
                             "cmx%d", i);
@@ -708,12 +711,14 @@ static int __init cm4040_init(void)
         if (major < 0) {
                 printk(KERN_WARNING MODULE_NAME
                         ": could not get major number\n");
+                class_destroy(cmx_class);
                 return major;
         }
 
         rc = pcmcia_register_driver(&reader_driver);
         if (rc < 0) {
                 unregister_chrdev(major, DEVICE_NAME);
+                class_destroy(cmx_class);
                 return rc;
         }
 
diff --git a/drivers/char/tpm/Kconfig b/drivers/char/tpm/Kconfig
index fe00c7dfb649..11089be0691b 100644
--- a/drivers/char/tpm/Kconfig
+++ b/drivers/char/tpm/Kconfig
@@ -33,7 +33,7 @@ config TCG_NSC
         tristate "National Semiconductor TPM Interface"
         depends on TCG_TPM && PNPACPI
         ---help---
-          If you have a TPM security chip from National Semicondutor 
+          If you have a TPM security chip from National Semiconductor 
           say Yes and it will be accessible from within Linux.  To 
           compile this driver as a module, choose M here; the module 
           will be called tpm_nsc.
diff --git a/drivers/char/tty_io.c b/drivers/char/tty_io.c
index 7710a6a77d97..fc662e4ce58a 100644
--- a/drivers/char/tty_io.c
+++ b/drivers/char/tty_io.c
@@ -934,13 +934,6 @@ restart:
                 return -EINVAL;
 
         /*
-         *      No more input please, we are switching. The new ldisc
-         *      will update this value in the ldisc open function
-         */
-
-        tty->receive_room = 0;
-
-        /*
          *      Problem: What do we do if this blocks ?
          */
 
@@ -951,6 +944,13 @@ restart:
                 return 0;
         }
 
+        /*
+         *      No more input please, we are switching. The new ldisc
+         *      will update this value in the ldisc open function
+         */
+
+        tty->receive_room = 0;
+
         o_ldisc = tty->ldisc;
         o_tty = tty->link;
 
@@ -1573,11 +1573,11 @@ void no_tty(void)
 
 
 /**
- *      stop_tty        -       propogate flow control
+ *      stop_tty        -       propagate flow control
  *      @tty: tty to stop
  *
  *      Perform flow control to the driver. For PTY/TTY pairs we
- *      must also propogate the TIOCKPKT status. May be called
+ *      must also propagate the TIOCKPKT status. May be called
  *      on an already stopped device and will not re-call the driver
  *      method.
  *
@@ -1607,11 +1607,11 @@ void stop_tty(struct tty_struct *tty)
 EXPORT_SYMBOL(stop_tty);
 
 /**
- *      start_tty       -       propogate flow control
+ *      start_tty       -       propagate flow control
  *      @tty: tty to start
  *
  *      Start a tty that has been stopped if at all possible. Perform
- *      any neccessary wakeups and propogate the TIOCPKT status. If this
+ *      any neccessary wakeups and propagate the TIOCPKT status. If this
  *      is the tty was previous stopped and is being started then the
  *      driver start method is invoked and the line discipline woken.
  *
diff --git a/drivers/cpufreq/cpufreq.c b/drivers/cpufreq/cpufreq.c
index 893dbaf386fb..eb37fba9b7ef 100644
--- a/drivers/cpufreq/cpufreq.c
+++ b/drivers/cpufreq/cpufreq.c
@@ -1685,9 +1685,11 @@ static int cpufreq_cpu_callback(struct notifier_block *nfb,
         if (sys_dev) {
                 switch (action) {
                 case CPU_ONLINE:
+                case CPU_ONLINE_FROZEN:
                         cpufreq_add_dev(sys_dev);
                         break;
                 case CPU_DOWN_PREPARE:
+                case CPU_DOWN_PREPARE_FROZEN:
                         if (unlikely(lock_policy_rwsem_write(cpu)))
                                 BUG();
 
@@ -1699,6 +1701,7 @@ static int cpufreq_cpu_callback(struct notifier_block *nfb,
                         __cpufreq_remove_dev(sys_dev);
                         break;
                 case CPU_DOWN_FAILED:
+                case CPU_DOWN_FAILED_FROZEN:
                         cpufreq_add_dev(sys_dev);
                         break;
                 }
diff --git a/drivers/cpufreq/cpufreq_stats.c b/drivers/cpufreq/cpufreq_stats.c
index d1c7cac9316c..d2f0cbd8b8f3 100644
--- a/drivers/cpufreq/cpufreq_stats.c
+++ b/drivers/cpufreq/cpufreq_stats.c
@@ -313,9 +313,11 @@ static int cpufreq_stat_cpu_callback(struct notifier_block *nfb,
 
         switch (action) {
         case CPU_ONLINE:
+        case CPU_ONLINE_FROZEN:
                 cpufreq_update_policy(cpu);
                 break;
         case CPU_DEAD:
+        case CPU_DEAD_FROZEN:
                 cpufreq_stats_free_table(cpu);
                 break;
         }
diff --git a/drivers/crypto/Kconfig b/drivers/crypto/Kconfig
index f21fe66c9eef..f4c634504d1a 100644
--- a/drivers/crypto/Kconfig
+++ b/drivers/crypto/Kconfig
@@ -51,7 +51,7 @@ config CRYPTO_DEV_GEODE
         default m
         help
           Say 'Y' here to use the AMD Geode LX processor on-board AES
-          engine for the CryptoAPI AES alogrithm.
+          engine for the CryptoAPI AES algorithm.
 
           To compile this driver as a module, choose M here: the module
           will be called geode-aes.
diff --git a/drivers/hwmon/applesmc.c b/drivers/hwmon/applesmc.c
index 3215f9c87f32..b51c104a28a2 100644
--- a/drivers/hwmon/applesmc.c
+++ b/drivers/hwmon/applesmc.c
@@ -981,7 +981,7 @@ static SENSOR_DEVICE_ATTR_2(fan##offset##_output, S_IRUGO | S_IWUSR, \
 static SENSOR_DEVICE_ATTR(fan##offset##_manual, S_IRUGO | S_IWUSR, \
         applesmc_show_fan_manual, applesmc_store_fan_manual, offset-1); \
 \
-static SENSOR_DEVICE_ATTR(fan##offset##_position, S_IRUGO, \
+static SENSOR_DEVICE_ATTR(fan##offset##_label, S_IRUGO, \
         applesmc_show_fan_position, NULL, offset-1); \
 \
 static struct attribute *fan##offset##_attributes[] = { \
@@ -991,7 +991,7 @@ static struct attribute *fan##offset##_attributes[] = { \
         &sensor_dev_attr_fan##offset##_safe.dev_attr.attr, \
         &sensor_dev_attr_fan##offset##_output.dev_attr.attr, \
         &sensor_dev_attr_fan##offset##_manual.dev_attr.attr, \
-        &sensor_dev_attr_fan##offset##_position.dev_attr.attr, \
+        &sensor_dev_attr_fan##offset##_label.dev_attr.attr, \
         NULL \
 };
 
@@ -1190,7 +1190,8 @@ static int __init applesmc_init(void)
         if (ret)
                 goto out_region;
 
-        pdev = platform_device_register_simple("applesmc", -1, NULL, 0);
+        pdev = platform_device_register_simple("applesmc", APPLESMC_DATA_PORT,
+                                               NULL, 0);
         if (IS_ERR(pdev)) {
                 ret = PTR_ERR(pdev);
                 goto out_driver;
diff --git a/drivers/hwmon/coretemp.c b/drivers/hwmon/coretemp.c
index 03b1f650d1c4..75e3911810a3 100644
--- a/drivers/hwmon/coretemp.c
+++ b/drivers/hwmon/coretemp.c
@@ -309,9 +309,11 @@ static int coretemp_cpu_callback(struct notifier_block *nfb,
 
         switch (action) {
         case CPU_ONLINE:
+        case CPU_ONLINE_FROZEN:
                 coretemp_device_add(cpu);
                 break;
         case CPU_DEAD:
+        case CPU_DEAD_FROZEN:
                 coretemp_device_remove(cpu);
                 break;
         }
diff --git a/drivers/i2c/chips/tps65010.c b/drivers/i2c/chips/tps65010.c
index 7ed92dc3d833..3c3f2ebf3fc9 100644
--- a/drivers/i2c/chips/tps65010.c
+++ b/drivers/i2c/chips/tps65010.c
@@ -354,7 +354,7 @@ static void tps65010_interrupt(struct tps65010 *tps)
                          * also needs to get error handling and probably
                          * an #ifdef CONFIG_SOFTWARE_SUSPEND
                          */
-                        pm_suspend(PM_SUSPEND_DISK);
+                        hibernate();
 #endif
                         poll = 1;
                 }
diff --git a/drivers/ide/pci/siimage.c b/drivers/ide/pci/siimage.c
index c0188de3cc66..79cec50a242f 100644
--- a/drivers/ide/pci/siimage.c
+++ b/drivers/ide/pci/siimage.c
@@ -831,7 +831,7 @@ static void __devinit init_mmio_iops_siimage(ide_hwif_t *hwif)
 
         /*
          *      Now set up the hw. We have to do this ourselves as
-         *      the MMIO layout isnt the same as the the standard port
+         *      the MMIO layout isnt the same as the standard port
          *      based I/O
          */
 
diff --git a/drivers/ieee1394/nodemgr.c b/drivers/ieee1394/nodemgr.c
index 6a1a0572275e..835937e38529 100644
--- a/drivers/ieee1394/nodemgr.c
+++ b/drivers/ieee1394/nodemgr.c
@@ -1702,7 +1702,7 @@ static int nodemgr_host_thread(void *__hi)
                         generation = get_hpsb_generation(host);
 
                         /* If we get a reset before we are done waiting, then
-                         * start the the waiting over again */
+                         * start the waiting over again */
                         if (generation != g)
                                 g = generation, i = 0;
                 }
diff --git a/drivers/infiniband/hw/ehca/ehca_irq.c b/drivers/infiniband/hw/ehca/ehca_irq.c
index f284be1c9166..82dda2faf4d0 100644
--- a/drivers/infiniband/hw/ehca/ehca_irq.c
+++ b/drivers/infiniband/hw/ehca/ehca_irq.c
@@ -745,6 +745,7 @@ static int comp_pool_callback(struct notifier_block *nfb,
 
         switch (action) {
         case CPU_UP_PREPARE:
+        case CPU_UP_PREPARE_FROZEN:
                 ehca_gen_dbg("CPU: %x (CPU_PREPARE)", cpu);
                 if(!create_comp_task(pool, cpu)) {
                         ehca_gen_err("Can't create comp_task for cpu: %x", cpu);
@@ -752,24 +753,29 @@ static int comp_pool_callback(struct notifier_block *nfb,
                 }
                 break;
         case CPU_UP_CANCELED:
+        case CPU_UP_CANCELED_FROZEN:
                 ehca_gen_dbg("CPU: %x (CPU_CANCELED)", cpu);
                 cct = per_cpu_ptr(pool->cpu_comp_tasks, cpu);
                 kthread_bind(cct->task, any_online_cpu(cpu_online_map));
                 destroy_comp_task(pool, cpu);
                 break;
         case CPU_ONLINE:
+        case CPU_ONLINE_FROZEN:
                 ehca_gen_dbg("CPU: %x (CPU_ONLINE)", cpu);
                 cct = per_cpu_ptr(pool->cpu_comp_tasks, cpu);
                 kthread_bind(cct->task, cpu);
                 wake_up_process(cct->task);
                 break;
         case CPU_DOWN_PREPARE:
+        case CPU_DOWN_PREPARE_FROZEN:
                 ehca_gen_dbg("CPU: %x (CPU_DOWN_PREPARE)", cpu);
                 break;
         case CPU_DOWN_FAILED:
+        case CPU_DOWN_FAILED_FROZEN:
                 ehca_gen_dbg("CPU: %x (CPU_DOWN_FAILED)", cpu);
                 break;
         case CPU_DEAD:
+        case CPU_DEAD_FROZEN:
                 ehca_gen_dbg("CPU: %x (CPU_DEAD)", cpu);
                 destroy_comp_task(pool, cpu);
                 take_over_work(pool, cpu);
diff --git a/drivers/isdn/capi/Kconfig b/drivers/isdn/capi/Kconfig
index c921d6c522f5..c92f9d764fce 100644
--- a/drivers/isdn/capi/Kconfig
+++ b/drivers/isdn/capi/Kconfig
@@ -17,7 +17,7 @@ config CAPI_TRACE
         help
           If you say Y here, the kernelcapi driver can make verbose traces
           of CAPI messages. This feature can be enabled/disabled via IOCTL for
-          every controler (default disabled).
+          every controller (default disabled).
           This will increase the size of the kernelcapi module by 20 KB.
           If unsure, say Y.
 
diff --git a/drivers/isdn/gigaset/usb-gigaset.c b/drivers/isdn/gigaset/usb-gigaset.c
index c8e1c357cec8..a1263019df5e 100644
--- a/drivers/isdn/gigaset/usb-gigaset.c
+++ b/drivers/isdn/gigaset/usb-gigaset.c
@@ -138,8 +138,6 @@ struct usb_cardstate {
         char                    bchars[6];              /* for request 0x19 */
 };
 
-struct usb_bc_state {};
-
 static inline unsigned tiocm_to_gigaset(unsigned state)
 {
         return ((state & TIOCM_DTR) ? 1 : 0) | ((state & TIOCM_RTS) ? 2 : 0);
@@ -579,25 +577,21 @@ static int gigaset_brkchars(struct cardstate *cs, const unsigned char buf[6])
 
 static int gigaset_freebcshw(struct bc_state *bcs)
 {
-        if (!bcs->hw.usb)
-                return 0;
-        //FIXME
-        kfree(bcs->hw.usb);
+        /* unused */
         return 1;
 }
 
 /* Initialize the b-channel structure */
 static int gigaset_initbcshw(struct bc_state *bcs)
 {
-        bcs->hw.usb = kmalloc(sizeof(struct usb_bc_state), GFP_KERNEL);
-        if (!bcs->hw.usb)
-                return 0;
-
+        /* unused */
+        bcs->hw.usb = NULL;
         return 1;
 }
 
 static void gigaset_reinitbcshw(struct bc_state *bcs)
 {
+        /* nothing to do for M10x */
 }
 
 static void gigaset_freecshw(struct cardstate *cs)
diff --git a/drivers/isdn/hardware/eicon/divasync.h b/drivers/isdn/hardware/eicon/divasync.h
index af3eb9e795b5..85784a7ffb25 100644
--- a/drivers/isdn/hardware/eicon/divasync.h
+++ b/drivers/isdn/hardware/eicon/divasync.h
@@ -216,7 +216,7 @@ typedef struct
 #define SERIAL_HOOK_RING 0x85
 #define SERIAL_HOOK_DETACH 0x8f
  unsigned char Flags;           /* function refinements   */
- /* parameters passed by the the ATTACH request      */
+ /* parameters passed by the ATTACH request      */
  SERIAL_INT_CB InterruptHandler; /* called on each interrupt  */
  SERIAL_DPC_CB DeferredHandler; /* called on hook state changes */
  void   *HandlerContext; /* context for both handlers */
diff --git a/drivers/isdn/hisax/hfc_usb.c b/drivers/isdn/hisax/hfc_usb.c
index 99e70d4103b6..1f18f1993387 100644
--- a/drivers/isdn/hisax/hfc_usb.c
+++ b/drivers/isdn/hisax/hfc_usb.c
@@ -1217,11 +1217,11 @@ usb_init(hfcusb_data * hfc)
         /* aux = output, reset off */
         write_usb(hfc, HFCUSB_CIRM, 0x10);
 
-        /* set USB_SIZE to match the the wMaxPacketSize for INT or BULK transfers */
+        /* set USB_SIZE to match the wMaxPacketSize for INT or BULK transfers */
         write_usb(hfc, HFCUSB_USB_SIZE,
                   (hfc->packet_size / 8) | ((hfc->packet_size / 8) << 4));
 
-        /* set USB_SIZE_I to match the the wMaxPacketSize for ISO transfers */
+        /* set USB_SIZE_I to match the wMaxPacketSize for ISO transfers */
         write_usb(hfc, HFCUSB_USB_SIZE_I, hfc->iso_packet_size);
 
         /* enable PCM/GCI master mode */
diff --git a/drivers/kvm/kvm_main.c b/drivers/kvm/kvm_main.c
index c8b8cfa332bb..0d892600ff00 100644
--- a/drivers/kvm/kvm_main.c
+++ b/drivers/kvm/kvm_main.c
@@ -2889,7 +2889,9 @@ static int kvm_cpu_hotplug(struct notifier_block *notifier, unsigned long val,
 
         switch (val) {
         case CPU_DOWN_PREPARE:
+        case CPU_DOWN_PREPARE_FROZEN:
         case CPU_UP_CANCELED:
+        case CPU_UP_CANCELED_FROZEN:
                 printk(KERN_INFO "kvm: disabling virtualization on CPU%d\n",
                        cpu);
                 decache_vcpus_on_cpu(cpu);
@@ -2897,6 +2899,7 @@ static int kvm_cpu_hotplug(struct notifier_block *notifier, unsigned long val,
                                          NULL, 0, 1);
                 break;
         case CPU_ONLINE:
+        case CPU_ONLINE_FROZEN:
                 printk(KERN_INFO "kvm: enabling virtualization on CPU%d\n",
                        cpu);
                 smp_call_function_single(cpu, kvm_arch_ops->hardware_enable,
diff --git a/drivers/leds/leds-h1940.c b/drivers/leds/leds-h1940.c
index 1d49d2ade557..677c99325be5 100644
--- a/drivers/leds/leds-h1940.c
+++ b/drivers/leds/leds-h1940.c
@@ -1,5 +1,5 @@
 /*
- * drivers/leds/h1940-leds.c
+ * drivers/leds/leds-h1940.c
  * Copyright (c) Arnaud Patard <arnaud.patard@rtp-net.org>
  *
  * This file is subject to the terms and conditions of the GNU General Public
diff --git a/drivers/macintosh/Kconfig b/drivers/macintosh/Kconfig
index a32c91e27b3c..58926da0ae18 100644
--- a/drivers/macintosh/Kconfig
+++ b/drivers/macintosh/Kconfig
@@ -237,7 +237,7 @@ config PMAC_RACKMETER
         tristate "Support for Apple XServe front panel LEDs"
         depends on PPC_PMAC
         help
-          This driver procides some support to control the front panel
+          This driver provides some support to control the front panel
           blue LEDs "vu-meter" of the XServer macs.
 
 endif # MACINTOSH_DRIVERS
diff --git a/drivers/mca/mca-bus.c b/drivers/mca/mca-bus.c
index da862e4632dd..67b8e9453b19 100644
--- a/drivers/mca/mca-bus.c
+++ b/drivers/mca/mca-bus.c
@@ -47,19 +47,25 @@ static int mca_bus_match (struct device *dev, struct device_driver *drv)
 {
         struct mca_device *mca_dev = to_mca_device (dev);
         struct mca_driver *mca_drv = to_mca_driver (drv);
-        const short *mca_ids = mca_drv->id_table;
-        int i;
-
-        if (!mca_ids)
-                return 0;
-
-        for(i = 0; mca_ids[i]; i++) {
-                if (mca_ids[i] == mca_dev->pos_id) {
-                        mca_dev->index = i;
-                        return 1;
+        const unsigned short *mca_ids = mca_drv->id_table;
+        int i = 0;
+
+        if (mca_ids) {
+                for(i = 0; mca_ids[i]; i++) {
+                        if (mca_ids[i] == mca_dev->pos_id) {
+                                mca_dev->index = i;
+                                return 1;
+                        }
                 }
         }
-
+        /* If the integrated id is present, treat it as though it were an
+         * additional id in the id_table (it can't be because by definition,
+         * integrated id's overflow a short */
+        if (mca_drv->integrated_id && mca_dev->pos_id ==
+            mca_drv->integrated_id) {
+                mca_dev->index = i;
+                return 1;
+        }
         return 0;
 }
 
diff --git a/drivers/mca/mca-driver.c b/drivers/mca/mca-driver.c
index 2223466b3d8a..32cd39bcc715 100644
--- a/drivers/mca/mca-driver.c
+++ b/drivers/mca/mca-driver.c
@@ -36,12 +36,25 @@ int mca_register_driver(struct mca_driver *mca_drv)
                 mca_drv->driver.bus = &mca_bus_type;
                 if ((r = driver_register(&mca_drv->driver)) < 0)
                         return r;
+                mca_drv->integrated_id = 0;
         }
 
         return 0;
 }
 EXPORT_SYMBOL(mca_register_driver);
 
+int mca_register_driver_integrated(struct mca_driver *mca_driver,
+                                   int integrated_id)
+{
+        int r = mca_register_driver(mca_driver);
+
+        if (!r)
+                mca_driver->integrated_id = integrated_id;
+
+        return r;
+}
+EXPORT_SYMBOL(mca_register_driver_integrated);
+
 void mca_unregister_driver(struct mca_driver *mca_drv)
 {
         if (MCA_bus)
diff --git a/drivers/md/Kconfig b/drivers/md/Kconfig
index 4540ade6b6b5..7df934d69134 100644
--- a/drivers/md/Kconfig
+++ b/drivers/md/Kconfig
@@ -262,6 +262,15 @@ config DM_MULTIPATH_EMC
         ---help---
           Multipath support for EMC CX/AX series hardware.
 
+config DM_DELAY
+        tristate "I/O delaying target (EXPERIMENTAL)"
+        depends on BLK_DEV_DM && EXPERIMENTAL
+        ---help---
+        A target that delays reads and/or writes and can send
+        them to different devices.  Useful for testing.
+
+        If unsure, say N.
+
 endmenu
 
 endif
diff --git a/drivers/md/Makefile b/drivers/md/Makefile
index 34957a68d921..38754084eac7 100644
--- a/drivers/md/Makefile
+++ b/drivers/md/Makefile
@@ -31,6 +31,7 @@ obj-$(CONFIG_MD_FAULTY)		+= faulty.o
 obj-$(CONFIG_BLK_DEV_MD)        += md-mod.o
 obj-$(CONFIG_BLK_DEV_DM)        += dm-mod.o
 obj-$(CONFIG_DM_CRYPT)          += dm-crypt.o
+obj-$(CONFIG_DM_DELAY)          += dm-delay.o
 obj-$(CONFIG_DM_MULTIPATH)      += dm-multipath.o dm-round-robin.o
 obj-$(CONFIG_DM_MULTIPATH_EMC)  += dm-emc.o
 obj-$(CONFIG_DM_SNAPSHOT)       += dm-snapshot.o
diff --git a/drivers/md/dm-bio-list.h b/drivers/md/dm-bio-list.h
index da4349649f7f..c6be88826fae 100644
--- a/drivers/md/dm-bio-list.h
+++ b/drivers/md/dm-bio-list.h
@@ -8,17 +8,43 @@
 #define DM_BIO_LIST_H
 
 #include <linux/bio.h>
+#include <linux/prefetch.h>
 
 struct bio_list {
         struct bio *head;
         struct bio *tail;
 };
 
+static inline int bio_list_empty(const struct bio_list *bl)
+{
+        return bl->head == NULL;
+}
+
+#define BIO_LIST_INIT { .head = NULL, .tail = NULL }
+
+#define BIO_LIST(bl) \
+        struct bio_list bl = BIO_LIST_INIT
+
 static inline void bio_list_init(struct bio_list *bl)
 {
         bl->head = bl->tail = NULL;
 }
 
+#define bio_list_for_each(bio, bl) \
+        for (bio = (bl)->head; bio && ({ prefetch(bio->bi_next); 1; }); \
+             bio = bio->bi_next)
+
+static inline unsigned bio_list_size(const struct bio_list *bl)
+{
+        unsigned sz = 0;
+        struct bio *bio;
+
+        bio_list_for_each(bio, bl)
+                sz++;
+
+        return sz;
+}
+
 static inline void bio_list_add(struct bio_list *bl, struct bio *bio)
 {
         bio->bi_next = NULL;
diff --git a/drivers/md/dm-crypt.c b/drivers/md/dm-crypt.c
index d8121234c347..7b0fcfc9eaa5 100644
--- a/drivers/md/dm-crypt.c
+++ b/drivers/md/dm-crypt.c
@@ -33,7 +33,6 @@
 struct crypt_io {
         struct dm_target *target;
         struct bio *base_bio;
-        struct bio *first_clone;
         struct work_struct work;
         atomic_t pending;
         int error;
@@ -107,6 +106,8 @@ struct crypt_config {
 
 static struct kmem_cache *_crypt_io_pool;
 
+static void clone_init(struct crypt_io *, struct bio *);
+
 /*
  * Different IV generation algorithms:
  *
@@ -120,6 +121,9 @@ static struct kmem_cache *_crypt_io_pool;
  * benbi: the 64-bit "big-endian 'narrow block'-count", starting at 1
  *        (needed for LRW-32-AES and possible other narrow block modes)
  *
+ * null: the initial vector is always zero.  Provides compatibility with
+ *       obsolete loop_fish2 devices.  Do not use for new devices.
+ *
  * plumb: unimplemented, see:
  * http://article.gmane.org/gmane.linux.kernel.device-mapper.dm-crypt/454
  */
@@ -256,6 +260,13 @@ static int crypt_iv_benbi_gen(struct crypt_config *cc, u8 *iv, sector_t sector)
         return 0;
 }
 
+static int crypt_iv_null_gen(struct crypt_config *cc, u8 *iv, sector_t sector)
+{
+        memset(iv, 0, cc->iv_size);
+
+        return 0;
+}
+
 static struct crypt_iv_operations crypt_iv_plain_ops = {
         .generator = crypt_iv_plain_gen
 };
@@ -272,6 +283,10 @@ static struct crypt_iv_operations crypt_iv_benbi_ops = {
         .generator = crypt_iv_benbi_gen
 };
 
+static struct crypt_iv_operations crypt_iv_null_ops = {
+        .generator = crypt_iv_null_gen
+};
+
 static int
 crypt_convert_scatterlist(struct crypt_config *cc, struct scatterlist *out,
                           struct scatterlist *in, unsigned int length,
@@ -378,36 +393,21 @@ static int crypt_convert(struct crypt_config *cc,
  * This should never violate the device limitations
  * May return a smaller bio when running out of pages
  */
-static struct bio *
-crypt_alloc_buffer(struct crypt_config *cc, unsigned int size,
-                   struct bio *base_bio, unsigned int *bio_vec_idx)
+static struct bio *crypt_alloc_buffer(struct crypt_io *io, unsigned int size)
 {
+        struct crypt_config *cc = io->target->private;
         struct bio *clone;
         unsigned int nr_iovecs = (size + PAGE_SIZE - 1) >> PAGE_SHIFT;
         gfp_t gfp_mask = GFP_NOIO | __GFP_HIGHMEM;
         unsigned int i;
 
-        if (base_bio) {
-                clone = bio_alloc_bioset(GFP_NOIO, base_bio->bi_max_vecs, cc->bs);
-                __bio_clone(clone, base_bio);
-        } else
-                clone = bio_alloc_bioset(GFP_NOIO, nr_iovecs, cc->bs);
-
+        clone = bio_alloc_bioset(GFP_NOIO, nr_iovecs, cc->bs);
         if (!clone)
                 return NULL;
 
-        clone->bi_destructor = dm_crypt_bio_destructor;
-
-        /* if the last bio was not complete, continue where that one ended */
-        clone->bi_idx = *bio_vec_idx;
-        clone->bi_vcnt = *bio_vec_idx;
-        clone->bi_size = 0;
-        clone->bi_flags &= ~(1 << BIO_SEG_VALID);
-
-        /* clone->bi_idx pages have already been allocated */
-        size -= clone->bi_idx * PAGE_SIZE;
+        clone_init(io, clone);
 
-        for (i = clone->bi_idx; i < nr_iovecs; i++) {
+        for (i = 0; i < nr_iovecs; i++) {
                 struct bio_vec *bv = bio_iovec_idx(clone, i);
 
                 bv->bv_page = mempool_alloc(cc->page_pool, gfp_mask);
@@ -419,7 +419,7 @@ crypt_alloc_buffer(struct crypt_config *cc, unsigned int size,
                  * return a partially allocated bio, the caller will then try
                  * to allocate additional bios while submitting this partial bio
                  */
-                if ((i - clone->bi_idx) == (MIN_BIO_PAGES - 1))
+                if (i == (MIN_BIO_PAGES - 1))
                         gfp_mask = (gfp_mask | __GFP_NOWARN) & ~__GFP_WAIT;
 
                 bv->bv_offset = 0;
@@ -438,12 +438,6 @@ crypt_alloc_buffer(struct crypt_config *cc, unsigned int size,
                 return NULL;
         }
 
-        /*
-         * Remember the last bio_vec allocated to be able
-         * to correctly continue after the splitting.
-         */
-        *bio_vec_idx = clone->bi_vcnt;
-
         return clone;
 }
 
@@ -495,9 +489,6 @@ static void dec_pending(struct crypt_io *io, int error)
         if (!atomic_dec_and_test(&io->pending))
                 return;
 
-        if (io->first_clone)
-                bio_put(io->first_clone);
-
         bio_endio(io->base_bio, io->base_bio->bi_size, io->error);
 
         mempool_free(io, cc->io_pool);
@@ -562,6 +553,7 @@ static void clone_init(struct crypt_io *io, struct bio *clone)
         clone->bi_end_io  = crypt_endio;
         clone->bi_bdev    = cc->dev->bdev;
         clone->bi_rw      = io->base_bio->bi_rw;
+        clone->bi_destructor = dm_crypt_bio_destructor;
 }
 
 static void process_read(struct crypt_io *io)
@@ -585,7 +577,6 @@ static void process_read(struct crypt_io *io)
         }
 
         clone_init(io, clone);
-        clone->bi_destructor = dm_crypt_bio_destructor;
         clone->bi_idx = 0;
         clone->bi_vcnt = bio_segments(base_bio);
         clone->bi_size = base_bio->bi_size;
@@ -604,7 +595,6 @@ static void process_write(struct crypt_io *io)
         struct convert_context ctx;
         unsigned remaining = base_bio->bi_size;
         sector_t sector = base_bio->bi_sector - io->target->begin;
-        unsigned bvec_idx = 0;
 
         atomic_inc(&io->pending);
 
@@ -615,14 +605,14 @@ static void process_write(struct crypt_io *io)
          * so repeat the whole process until all the data can be handled.
          */
         while (remaining) {
-                clone = crypt_alloc_buffer(cc, base_bio->bi_size,
-                                           io->first_clone, &bvec_idx);
+                clone = crypt_alloc_buffer(io, remaining);
                 if (unlikely(!clone)) {
                         dec_pending(io, -ENOMEM);
                         return;
                 }
 
                 ctx.bio_out = clone;
+                ctx.idx_out = 0;
 
                 if (unlikely(crypt_convert(cc, &ctx) < 0)) {
                         crypt_free_buffer_pages(cc, clone, clone->bi_size);
@@ -631,31 +621,26 @@ static void process_write(struct crypt_io *io)
                         return;
                 }
 
-                clone_init(io, clone);
-                clone->bi_sector = cc->start + sector;
-
-                if (!io->first_clone) {
-                        /*
-                         * hold a reference to the first clone, because it
-                         * holds the bio_vec array and that can't be freed
-                         * before all other clones are released
-                         */
-                        bio_get(clone);
-                        io->first_clone = clone;
-                }
+                /* crypt_convert should have filled the clone bio */
+                BUG_ON(ctx.idx_out < clone->bi_vcnt);
 
+                clone->bi_sector = cc->start + sector;
                 remaining -= clone->bi_size;
                 sector += bio_sectors(clone);
 
-                /* prevent bio_put of first_clone */
+                /* Grab another reference to the io struct
+                 * before we kick off the request */
                 if (remaining)
                         atomic_inc(&io->pending);
 
                 generic_make_request(clone);
 
+                /* Do not reference clone after this - it
+                 * may be gone already. */
+
                 /* out of memory -> run queues */
                 if (remaining)
-                        congestion_wait(bio_data_dir(clone), HZ/100);
+                        congestion_wait(WRITE, HZ/100);
         }
 }
 
@@ -832,6 +817,8 @@ static int crypt_ctr(struct dm_target *ti, unsigned int argc, char **argv)
                 cc->iv_gen_ops = &crypt_iv_essiv_ops;
         else if (strcmp(ivmode, "benbi") == 0)
                 cc->iv_gen_ops = &crypt_iv_benbi_ops;
+        else if (strcmp(ivmode, "null") == 0)
+                cc->iv_gen_ops = &crypt_iv_null_ops;
         else {
                 ti->error = "Invalid IV mode";
                 goto bad2;
@@ -954,10 +941,12 @@ static int crypt_map(struct dm_target *ti, struct bio *bio,
         struct crypt_config *cc = ti->private;
         struct crypt_io *io;
 
+        if (bio_barrier(bio))
+                return -EOPNOTSUPP;
+
         io = mempool_alloc(cc->io_pool, GFP_NOIO);
         io->target = ti;
         io->base_bio = bio;
-        io->first_clone = NULL;
         io->error = io->post_process = 0;
         atomic_set(&io->pending, 0);
         kcryptd_queue_io(io);
@@ -1057,7 +1046,7 @@ error:
 
 static struct target_type crypt_target = {
         .name   = "crypt",
-        .version= {1, 3, 0},
+        .version= {1, 5, 0},
         .module = THIS_MODULE,
         .ctr    = crypt_ctr,
         .dtr    = crypt_dtr,
diff --git a/drivers/md/dm-delay.c b/drivers/md/dm-delay.c
new file mode 100644
index 000000000000..52c7cf9e5803
--- /dev/null
+++ b/drivers/md/dm-delay.c
@@ -0,0 +1,383 @@
+/*
+ * Copyright (C) 2005-2007 Red Hat GmbH
+ *
+ * A target that delays reads and/or writes and can send
+ * them to different devices.
+ *
+ * This file is released under the GPL.
+ */
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/blkdev.h>
+#include <linux/bio.h>
+#include <linux/slab.h>
+
+#include "dm.h"
+#include "dm-bio-list.h"
+
+#define DM_MSG_PREFIX "delay"
+
+struct delay_c {
+        struct timer_list delay_timer;
+        struct semaphore timer_lock;
+        struct work_struct flush_expired_bios;
+        struct list_head delayed_bios;
+        atomic_t may_delay;
+        mempool_t *delayed_pool;
+
+        struct dm_dev *dev_read;
+        sector_t start_read;
+        unsigned read_delay;
+        unsigned reads;
+
+        struct dm_dev *dev_write;
+        sector_t start_write;
+        unsigned write_delay;
+        unsigned writes;
+};
+
+struct delay_info {
+        struct delay_c *context;
+        struct list_head list;
+        struct bio *bio;
+        unsigned long expires;
+};
+
+static DEFINE_MUTEX(delayed_bios_lock);
+
+static struct workqueue_struct *kdelayd_wq;
+static struct kmem_cache *delayed_cache;
+
+static void handle_delayed_timer(unsigned long data)
+{
+        struct delay_c *dc = (struct delay_c *)data;
+
+        queue_work(kdelayd_wq, &dc->flush_expired_bios);
+}
+
+static void queue_timeout(struct delay_c *dc, unsigned long expires)
+{
+        down(&dc->timer_lock);
+
+        if (!timer_pending(&dc->delay_timer) || expires < dc->delay_timer.expires)
+                mod_timer(&dc->delay_timer, expires);
+
+        up(&dc->timer_lock);
+}
+
+static void flush_bios(struct bio *bio)
+{
+        struct bio *n;
+
+        while (bio) {
+                n = bio->bi_next;
+                bio->bi_next = NULL;
+                generic_make_request(bio);
+                bio = n;
+        }
+}
+
+static struct bio *flush_delayed_bios(struct delay_c *dc, int flush_all)
+{
+        struct delay_info *delayed, *next;
+        unsigned long next_expires = 0;
+        int start_timer = 0;
+        BIO_LIST(flush_bios);
+
+        mutex_lock(&delayed_bios_lock);
+        list_for_each_entry_safe(delayed, next, &dc->delayed_bios, list) {
+                if (flush_all || time_after_eq(jiffies, delayed->expires)) {
+                        list_del(&delayed->list);
+                        bio_list_add(&flush_bios, delayed->bio);
+                        if ((bio_data_dir(delayed->bio) == WRITE))
+                                delayed->context->writes--;
+                        else
+                                delayed->context->reads--;
+                        mempool_free(delayed, dc->delayed_pool);
+                        continue;
+                }
+
+                if (!start_timer) {
+                        start_timer = 1;
+                        next_expires = delayed->expires;
+                } else
+                        next_expires = min(next_expires, delayed->expires);
+        }
+
+        mutex_unlock(&delayed_bios_lock);
+
+        if (start_timer)
+                queue_timeout(dc, next_expires);
+
+        return bio_list_get(&flush_bios);
+}
+
+static void flush_expired_bios(struct work_struct *work)
+{
+        struct delay_c *dc;
+
+        dc = container_of(work, struct delay_c, flush_expired_bios);
+        flush_bios(flush_delayed_bios(dc, 0));
+}
+
+/*
+ * Mapping parameters:
+ *    <device> <offset> <delay> [<write_device> <write_offset> <write_delay>]
+ *
+ * With separate write parameters, the first set is only used for reads.
+ * Delays are specified in milliseconds.
+ */
+static int delay_ctr(struct dm_target *ti, unsigned int argc, char **argv)
+{
+        struct delay_c *dc;
+        unsigned long long tmpll;
+
+        if (argc != 3 && argc != 6) {
+                ti->error = "requires exactly 3 or 6 arguments";
+                return -EINVAL;
+        }
+
+        dc = kmalloc(sizeof(*dc), GFP_KERNEL);
+        if (!dc) {
+                ti->error = "Cannot allocate context";
+                return -ENOMEM;
+        }
+
+        dc->reads = dc->writes = 0;
+
+        if (sscanf(argv[1], "%llu", &tmpll) != 1) {
+                ti->error = "Invalid device sector";
+                goto bad;
+        }
+        dc->start_read = tmpll;
+
+        if (sscanf(argv[2], "%u", &dc->read_delay) != 1) {
+                ti->error = "Invalid delay";
+                goto bad;
+        }
+
+        if (dm_get_device(ti, argv[0], dc->start_read, ti->len,
+                          dm_table_get_mode(ti->table), &dc->dev_read)) {
+                ti->error = "Device lookup failed";
+                goto bad;
+        }
+
+        if (argc == 3) {
+                dc->dev_write = NULL;
+                goto out;
+        }
+
+        if (sscanf(argv[4], "%llu", &tmpll) != 1) {
+                ti->error = "Invalid write device sector";
+                goto bad;
+        }
+        dc->start_write = tmpll;
+
+        if (sscanf(argv[5], "%u", &dc->write_delay) != 1) {
+                ti->error = "Invalid write delay";
+                goto bad;
+        }
+
+        if (dm_get_device(ti, argv[3], dc->start_write, ti->len,
+                          dm_table_get_mode(ti->table), &dc->dev_write)) {
+                ti->error = "Write device lookup failed";
+                dm_put_device(ti, dc->dev_read);
+                goto bad;
+        }
+
+out:
+        dc->delayed_pool = mempool_create_slab_pool(128, delayed_cache);
+        if (!dc->delayed_pool) {
+                DMERR("Couldn't create delayed bio pool.");
+                goto bad;
+        }
+
+        init_timer(&dc->delay_timer);
+        dc->delay_timer.function = handle_delayed_timer;
+        dc->delay_timer.data = (unsigned long)dc;
+
+        INIT_WORK(&dc->flush_expired_bios, flush_expired_bios);
+        INIT_LIST_HEAD(&dc->delayed_bios);
+        init_MUTEX(&dc->timer_lock);
+        atomic_set(&dc->may_delay, 1);
+
+        ti->private = dc;
+        return 0;
+
+bad:
+        kfree(dc);
+        return -EINVAL;
+}
+
+static void delay_dtr(struct dm_target *ti)
+{
+        struct delay_c *dc = ti->private;
+
+        flush_workqueue(kdelayd_wq);
+
+        dm_put_device(ti, dc->dev_read);
+
+        if (dc->dev_write)
+                dm_put_device(ti, dc->dev_write);
+
+        mempool_destroy(dc->delayed_pool);
+        kfree(dc);
+}
+
+static int delay_bio(struct delay_c *dc, int delay, struct bio *bio)
+{
+        struct delay_info *delayed;
+        unsigned long expires = 0;
+
+        if (!delay || !atomic_read(&dc->may_delay))
+                return 1;
+
+        delayed = mempool_alloc(dc->delayed_pool, GFP_NOIO);
+
+        delayed->context = dc;
+        delayed->bio = bio;
+        delayed->expires = expires = jiffies + (delay * HZ / 1000);
+
+        mutex_lock(&delayed_bios_lock);
+
+        if (bio_data_dir(bio) == WRITE)
+                dc->writes++;
+        else
+                dc->reads++;
+
+        list_add_tail(&delayed->list, &dc->delayed_bios);
+
+        mutex_unlock(&delayed_bios_lock);
+
+        queue_timeout(dc, expires);
+
+        return 0;
+}
+
+static void delay_presuspend(struct dm_target *ti)
+{
+        struct delay_c *dc = ti->private;
+
+        atomic_set(&dc->may_delay, 0);
+        del_timer_sync(&dc->delay_timer);
+        flush_bios(flush_delayed_bios(dc, 1));
+}
+
+static void delay_resume(struct dm_target *ti)
+{
+        struct delay_c *dc = ti->private;
+
+        atomic_set(&dc->may_delay, 1);
+}
+
+static int delay_map(struct dm_target *ti, struct bio *bio,
+                     union map_info *map_context)
+{
+        struct delay_c *dc = ti->private;
+
+        if ((bio_data_dir(bio) == WRITE) && (dc->dev_write)) {
+                bio->bi_bdev = dc->dev_write->bdev;
+                bio->bi_sector = dc->start_write +
+                                 (bio->bi_sector - ti->begin);
+
+                return delay_bio(dc, dc->write_delay, bio);
+        }
+
+        bio->bi_bdev = dc->dev_read->bdev;
+        bio->bi_sector = dc->start_read +
+                         (bio->bi_sector - ti->begin);
+
+        return delay_bio(dc, dc->read_delay, bio);
+}
+
+static int delay_status(struct dm_target *ti, status_type_t type,
+                        char *result, unsigned maxlen)
+{
+        struct delay_c *dc = ti->private;
+        int sz = 0;
+
+        switch (type) {
+        case STATUSTYPE_INFO:
+                DMEMIT("%u %u", dc->reads, dc->writes);
+                break;
+
+        case STATUSTYPE_TABLE:
+                DMEMIT("%s %llu %u", dc->dev_read->name,
+                       (unsigned long long) dc->start_read,
+                       dc->read_delay);
+                if (dc->dev_write)
+                        DMEMIT("%s %llu %u", dc->dev_write->name,
+                               (unsigned long long) dc->start_write,
+                               dc->write_delay);
+                break;
+        }
+
+        return 0;
+}
+
+static struct target_type delay_target = {
+        .name        = "delay",
+        .version     = {1, 0, 2},
+        .module      = THIS_MODULE,
+        .ctr         = delay_ctr,
+        .dtr         = delay_dtr,
+        .map         = delay_map,
+        .presuspend  = delay_presuspend,
+        .resume      = delay_resume,
+        .status      = delay_status,
+};
+
+static int __init dm_delay_init(void)
+{
+        int r = -ENOMEM;
+
+        kdelayd_wq = create_workqueue("kdelayd");
+        if (!kdelayd_wq) {
+                DMERR("Couldn't start kdelayd");
+                goto bad_queue;
+        }
+
+        delayed_cache = kmem_cache_create("dm-delay",
+                                          sizeof(struct delay_info),
+                                          __alignof__(struct delay_info),
+                                          0, NULL, NULL);
+        if (!delayed_cache) {
+                DMERR("Couldn't create delayed bio cache.");
+                goto bad_memcache;
+        }
+
+        r = dm_register_target(&delay_target);
+        if (r < 0) {
+                DMERR("register failed %d", r);
+                goto bad_register;
+        }
+
+        return 0;
+
+bad_register:
+        kmem_cache_destroy(delayed_cache);
+bad_memcache:
+        destroy_workqueue(kdelayd_wq);
+bad_queue:
+        return r;
+}
+
+static void __exit dm_delay_exit(void)
+{
+        int r = dm_unregister_target(&delay_target);
+
+        if (r < 0)
+                DMERR("unregister failed %d", r);
+
+        kmem_cache_destroy(delayed_cache);
+        destroy_workqueue(kdelayd_wq);
+}
+
+/* Module hooks */
+module_init(dm_delay_init);
+module_exit(dm_delay_exit);
+
+MODULE_DESCRIPTION(DM_NAME " delay target");
+MODULE_AUTHOR("Heinz Mauelshagen <mauelshagen@redhat.com>");
+MODULE_LICENSE("GPL");
diff --git a/drivers/md/dm-exception-store.c b/drivers/md/dm-exception-store.c
index 99cdffa7fbfe..07e0a0c84f6e 100644
--- a/drivers/md/dm-exception-store.c
+++ b/drivers/md/dm-exception-store.c
@@ -1,7 +1,8 @@
 /*
- * dm-snapshot.c
+ * dm-exception-store.c
  *
  * Copyright (C) 2001-2002 Sistina Software (UK) Limited.
+ * Copyright (C) 2006 Red Hat GmbH
  *
  * This file is released under the GPL.
  */
@@ -123,6 +124,7 @@ struct pstore {
         atomic_t pending_count;
         uint32_t callback_count;
         struct commit_callback *callbacks;
+        struct dm_io_client *io_client;
 };
 
 static inline unsigned int sectors_to_pages(unsigned int sectors)
@@ -159,14 +161,20 @@ static void free_area(struct pstore *ps)
  */
 static int chunk_io(struct pstore *ps, uint32_t chunk, int rw)
 {
-        struct io_region where;
-        unsigned long bits;
-
-        where.bdev = ps->snap->cow->bdev;
-        where.sector = ps->snap->chunk_size * chunk;
-        where.count = ps->snap->chunk_size;
-
-        return dm_io_sync_vm(1, &where, rw, ps->area, &bits);
+        struct io_region where = {
+                .bdev = ps->snap->cow->bdev,
+                .sector = ps->snap->chunk_size * chunk,
+                .count = ps->snap->chunk_size,
+        };
+        struct dm_io_request io_req = {
+                .bi_rw = rw,
+                .mem.type = DM_IO_VMA,
+                .mem.ptr.vma = ps->area,
+                .client = ps->io_client,
+                .notify.fn = NULL,
+        };
+
+        return dm_io(&io_req, 1, &where, NULL);
 }
 
 /*
@@ -213,17 +221,18 @@ static int read_header(struct pstore *ps, int *new_snapshot)
                 chunk_size_supplied = 0;
         }
 
-        r = dm_io_get(sectors_to_pages(ps->snap->chunk_size));
-        if (r)
-                return r;
+        ps->io_client = dm_io_client_create(sectors_to_pages(ps->snap->
+                                                             chunk_size));
+        if (IS_ERR(ps->io_client))
+                return PTR_ERR(ps->io_client);
 
         r = alloc_area(ps);
         if (r)
-                goto bad1;
+                return r;
 
         r = chunk_io(ps, 0, READ);
         if (r)
-                goto bad2;
+                goto bad;
 
         dh = (struct disk_header *) ps->area;
 
@@ -235,7 +244,7 @@ static int read_header(struct pstore *ps, int *new_snapshot)
         if (le32_to_cpu(dh->magic) != SNAP_MAGIC) {
                 DMWARN("Invalid or corrupt snapshot");
                 r = -ENXIO;
-                goto bad2;
+                goto bad;
         }
 
         *new_snapshot = 0;
@@ -252,27 +261,22 @@ static int read_header(struct pstore *ps, int *new_snapshot)
                (unsigned long long)ps->snap->chunk_size);
 
         /* We had a bogus chunk_size. Fix stuff up. */
-        dm_io_put(sectors_to_pages(ps->snap->chunk_size));
         free_area(ps);
 
         ps->snap->chunk_size = chunk_size;
         ps->snap->chunk_mask = chunk_size - 1;
         ps->snap->chunk_shift = ffs(chunk_size) - 1;
 
-        r = dm_io_get(sectors_to_pages(chunk_size));
+        r = dm_io_client_resize(sectors_to_pages(ps->snap->chunk_size),
+                                ps->io_client);
         if (r)
                 return r;
 
         r = alloc_area(ps);
-        if (r)
-                goto bad1;
-
-        return 0;
+        return r;
 
-bad2:
+bad:
         free_area(ps);
-bad1:
-        dm_io_put(sectors_to_pages(ps->snap->chunk_size));
         return r;
 }
 
@@ -405,7 +409,7 @@ static void persistent_destroy(struct exception_store *store)
 {
         struct pstore *ps = get_info(store);
 
-        dm_io_put(sectors_to_pages(ps->snap->chunk_size));
+        dm_io_client_destroy(ps->io_client);
         vfree(ps->callbacks);
         free_area(ps);
         kfree(ps);
diff --git a/drivers/md/dm-hw-handler.h b/drivers/md/dm-hw-handler.h
index 32eff28e4adc..e0832e6fcf36 100644
--- a/drivers/md/dm-hw-handler.h
+++ b/drivers/md/dm-hw-handler.h
@@ -16,6 +16,7 @@
 struct hw_handler_type;
 struct hw_handler {
         struct hw_handler_type *type;
+        struct mapped_device *md;
         void *context;
 };
 
diff --git a/drivers/md/dm-io.c b/drivers/md/dm-io.c
index 8bdc8a87b249..352c6fbeac53 100644
--- a/drivers/md/dm-io.c
+++ b/drivers/md/dm-io.c
@@ -1,5 +1,6 @@
 /*
  * Copyright (C) 2003 Sistina Software
+ * Copyright (C) 2006 Red Hat GmbH
  *
  * This file is released under the GPL.
  */
@@ -12,13 +13,17 @@
 #include <linux/sched.h>
 #include <linux/slab.h>
 
-static struct bio_set *_bios;
+struct dm_io_client {
+        mempool_t *pool;
+        struct bio_set *bios;
+};
 
 /* FIXME: can we shrink this ? */
 struct io {
         unsigned long error;
         atomic_t count;
         struct task_struct *sleeper;
+        struct dm_io_client *client;
         io_notify_fn callback;
         void *context;
 };
@@ -26,63 +31,58 @@ struct io {
 /*
  * io contexts are only dynamically allocated for asynchronous
  * io.  Since async io is likely to be the majority of io we'll
- * have the same number of io contexts as buffer heads ! (FIXME:
- * must reduce this).
+ * have the same number of io contexts as bios! (FIXME: must reduce this).
  */
-static unsigned _num_ios;
-static mempool_t *_io_pool;
 
 static unsigned int pages_to_ios(unsigned int pages)
 {
         return 4 * pages;       /* too many ? */
 }
 
-static int resize_pool(unsigned int new_ios)
+/*
+ * Create a client with mempool and bioset.
+ */
+struct dm_io_client *dm_io_client_create(unsigned num_pages)
 {
-        int r = 0;
-
-        if (_io_pool) {
-                if (new_ios == 0) {
-                        /* free off the pool */
-                        mempool_destroy(_io_pool);
-                        _io_pool = NULL;
-                        bioset_free(_bios);
-
-                } else {
-                        /* resize the pool */
-                        r = mempool_resize(_io_pool, new_ios, GFP_KERNEL);
-                }
+        unsigned ios = pages_to_ios(num_pages);
+        struct dm_io_client *client;
 
-        } else {
-                /* create new pool */
-                _io_pool = mempool_create_kmalloc_pool(new_ios,
-                                                       sizeof(struct io));
-                if (!_io_pool)
-                        return -ENOMEM;
-
-                _bios = bioset_create(16, 16);
-                if (!_bios) {
-                        mempool_destroy(_io_pool);
-                        _io_pool = NULL;
-                        return -ENOMEM;
-                }
-        }
+        client = kmalloc(sizeof(*client), GFP_KERNEL);
+        if (!client)
+                return ERR_PTR(-ENOMEM);
+
+        client->pool = mempool_create_kmalloc_pool(ios, sizeof(struct io));
+        if (!client->pool)
+                goto bad;
 
-        if (!r)
-                _num_ios = new_ios;
+        client->bios = bioset_create(16, 16);
+        if (!client->bios)
+                goto bad;
 
-        return r;
+        return client;
+
+   bad:
+        if (client->pool)
+                mempool_destroy(client->pool);
+        kfree(client);
+        return ERR_PTR(-ENOMEM);
 }
+EXPORT_SYMBOL(dm_io_client_create);
 
-int dm_io_get(unsigned int num_pages)
+int dm_io_client_resize(unsigned num_pages, struct dm_io_client *client)
 {
-        return resize_pool(_num_ios + pages_to_ios(num_pages));
+        return mempool_resize(client->pool, pages_to_ios(num_pages),
+                              GFP_KERNEL);
 }
+EXPORT_SYMBOL(dm_io_client_resize);
 
-void dm_io_put(unsigned int num_pages)
+void dm_io_client_destroy(struct dm_io_client *client)
 {
-        resize_pool(_num_ios - pages_to_ios(num_pages));
+        mempool_destroy(client->pool);
+        bioset_free(client->bios);
+        kfree(client);
 }
+EXPORT_SYMBOL(dm_io_client_destroy);
 
 /*-----------------------------------------------------------------
  * We need to keep track of which region a bio is doing io for.
@@ -118,7 +118,7 @@ static void dec_count(struct io *io, unsigned int region, int error)
                         io_notify_fn fn = io->callback;
                         void *context = io->context;
 
-                        mempool_free(io, _io_pool);
+                        mempool_free(io, io->client->pool);
                         fn(r, context);
                 }
         }
@@ -126,7 +126,8 @@ static void dec_count(struct io *io, unsigned int region, int error)
 
 static int endio(struct bio *bio, unsigned int done, int error)
 {
-        struct io *io = (struct io *) bio->bi_private;
+        struct io *io;
+        unsigned region;
 
         /* keep going until we've finished */
         if (bio->bi_size)
@@ -135,10 +136,17 @@ static int endio(struct bio *bio, unsigned int done, int error)
         if (error && bio_data_dir(bio) == READ)
                 zero_fill_bio(bio);
 
-        dec_count(io, bio_get_region(bio), error);
+        /*
+         * The bio destructor in bio_put() may use the io object.
+         */
+        io = bio->bi_private;
+        region = bio_get_region(bio);
+
         bio->bi_max_vecs++;
         bio_put(bio);
 
+        dec_count(io, region, error);
+
         return 0;
 }
 
@@ -209,6 +217,9 @@ static void bvec_dp_init(struct dpages *dp, struct bio_vec *bvec)
         dp->context_ptr = bvec;
 }
 
+/*
+ * Functions for getting the pages from a VMA.
+ */
 static void vm_get_page(struct dpages *dp,
                  struct page **p, unsigned long *len, unsigned *offset)
 {
@@ -233,7 +244,34 @@ static void vm_dp_init(struct dpages *dp, void *data)
 
 static void dm_bio_destructor(struct bio *bio)
 {
-        bio_free(bio, _bios);
+        struct io *io = bio->bi_private;
+
+        bio_free(bio, io->client->bios);
+}
+
+/*
+ * Functions for getting the pages from kernel memory.
+ */
+static void km_get_page(struct dpages *dp, struct page **p, unsigned long *len,
+                        unsigned *offset)
+{
+        *p = virt_to_page(dp->context_ptr);
+        *offset = dp->context_u;
+        *len = PAGE_SIZE - dp->context_u;
+}
+
+static void km_next_page(struct dpages *dp)
+{
+        dp->context_ptr += PAGE_SIZE - dp->context_u;
+        dp->context_u = 0;
+}
+
+static void km_dp_init(struct dpages *dp, void *data)
+{
+        dp->get_page = km_get_page;
+        dp->next_page = km_next_page;
+        dp->context_u = ((unsigned long) data) & (PAGE_SIZE - 1);
+        dp->context_ptr = data;
 }
 
 /*-----------------------------------------------------------------
@@ -256,7 +294,7 @@ static void do_region(int rw, unsigned int region, struct io_region *where,
                  * to hide it from bio_add_page().
                  */
                 num_bvecs = (remaining / (PAGE_SIZE >> SECTOR_SHIFT)) + 2;
-                bio = bio_alloc_bioset(GFP_NOIO, num_bvecs, _bios);
+                bio = bio_alloc_bioset(GFP_NOIO, num_bvecs, io->client->bios);
                 bio->bi_sector = where->sector + (where->count - remaining);
                 bio->bi_bdev = where->bdev;
                 bio->bi_end_io = endio;
@@ -311,8 +349,9 @@ static void dispatch_io(int rw, unsigned int num_regions,
         dec_count(io, 0, 0);
 }
 
-static int sync_io(unsigned int num_regions, struct io_region *where,
-            int rw, struct dpages *dp, unsigned long *error_bits)
+static int sync_io(struct dm_io_client *client, unsigned int num_regions,
+                   struct io_region *where, int rw, struct dpages *dp,
+                   unsigned long *error_bits)
 {
         struct io io;
 
@@ -324,6 +363,7 @@ static int sync_io(unsigned int num_regions, struct io_region *where,
         io.error = 0;
         atomic_set(&io.count, 1); /* see dispatch_io() */
         io.sleeper = current;
+        io.client = client;
 
         dispatch_io(rw, num_regions, where, dp, &io, 1);
 
@@ -340,12 +380,15 @@ static int sync_io(unsigned int num_regions, struct io_region *where,
         if (atomic_read(&io.count))
                 return -EINTR;
 
-        *error_bits = io.error;
+        if (error_bits)
+                *error_bits = io.error;
+
         return io.error ? -EIO : 0;
 }
 
-static int async_io(unsigned int num_regions, struct io_region *where, int rw,
-             struct dpages *dp, io_notify_fn fn, void *context)
+static int async_io(struct dm_io_client *client, unsigned int num_regions,
+                    struct io_region *where, int rw, struct dpages *dp,
+                    io_notify_fn fn, void *context)
 {
         struct io *io;
 
@@ -355,10 +398,11 @@ static int async_io(unsigned int num_regions, struct io_region *where, int rw,
                 return -EIO;
         }
 
-        io = mempool_alloc(_io_pool, GFP_NOIO);
+        io = mempool_alloc(client->pool, GFP_NOIO);
         io->error = 0;
         atomic_set(&io->count, 1); /* see dispatch_io() */
         io->sleeper = NULL;
+        io->client = client;
         io->callback = fn;
         io->context = context;
 
@@ -366,61 +410,51 @@ static int async_io(unsigned int num_regions, struct io_region *where, int rw,
         return 0;
 }
 
-int dm_io_sync(unsigned int num_regions, struct io_region *where, int rw,
-               struct page_list *pl, unsigned int offset,
-               unsigned long *error_bits)
+static int dp_init(struct dm_io_request *io_req, struct dpages *dp)
 {
-        struct dpages dp;
-        list_dp_init(&dp, pl, offset);
-        return sync_io(num_regions, where, rw, &dp, error_bits);
-}
+        /* Set up dpages based on memory type */
+        switch (io_req->mem.type) {
+        case DM_IO_PAGE_LIST:
+                list_dp_init(dp, io_req->mem.ptr.pl, io_req->mem.offset);
+                break;
+
+        case DM_IO_BVEC:
+                bvec_dp_init(dp, io_req->mem.ptr.bvec);
+                break;
+
+        case DM_IO_VMA:
+                vm_dp_init(dp, io_req->mem.ptr.vma);
+                break;
+
+        case DM_IO_KMEM:
+                km_dp_init(dp, io_req->mem.ptr.addr);
+                break;
+
+        default:
+                return -EINVAL;
+        }
 
-int dm_io_sync_bvec(unsigned int num_regions, struct io_region *where, int rw,
-                    struct bio_vec *bvec, unsigned long *error_bits)
-{
-        struct dpages dp;
-        bvec_dp_init(&dp, bvec);
-        return sync_io(num_regions, where, rw, &dp, error_bits);
+        return 0;
 }
 
-int dm_io_sync_vm(unsigned int num_regions, struct io_region *where, int rw,
-                  void *data, unsigned long *error_bits)
+/*
+ * New collapsed (a)synchronous interface
+ */
+int dm_io(struct dm_io_request *io_req, unsigned num_regions,
+          struct io_region *where, unsigned long *sync_error_bits)
 {
+        int r;
         struct dpages dp;
-        vm_dp_init(&dp, data);
-        return sync_io(num_regions, where, rw, &dp, error_bits);
-}
 
-int dm_io_async(unsigned int num_regions, struct io_region *where, int rw,
-                struct page_list *pl, unsigned int offset,
-                io_notify_fn fn, void *context)
-{
-        struct dpages dp;
-        list_dp_init(&dp, pl, offset);
-        return async_io(num_regions, where, rw, &dp, fn, context);
-}
+        r = dp_init(io_req, &dp);
+        if (r)
+                return r;
 
-int dm_io_async_bvec(unsigned int num_regions, struct io_region *where, int rw,
-                     struct bio_vec *bvec, io_notify_fn fn, void *context)
-{
-        struct dpages dp;
-        bvec_dp_init(&dp, bvec);
-        return async_io(num_regions, where, rw, &dp, fn, context);
-}
+        if (!io_req->notify.fn)
+                return sync_io(io_req->client, num_regions, where,
+                               io_req->bi_rw, &dp, sync_error_bits);
 
-int dm_io_async_vm(unsigned int num_regions, struct io_region *where, int rw,
-                   void *data, io_notify_fn fn, void *context)
-{
-        struct dpages dp;
-        vm_dp_init(&dp, data);
-        return async_io(num_regions, where, rw, &dp, fn, context);
+        return async_io(io_req->client, num_regions, where, io_req->bi_rw,
+                        &dp, io_req->notify.fn, io_req->notify.context);
 }
-
-EXPORT_SYMBOL(dm_io_get);
-EXPORT_SYMBOL(dm_io_put);
-EXPORT_SYMBOL(dm_io_sync);
-EXPORT_SYMBOL(dm_io_async);
-EXPORT_SYMBOL(dm_io_sync_bvec);
-EXPORT_SYMBOL(dm_io_async_bvec);
-EXPORT_SYMBOL(dm_io_sync_vm);
-EXPORT_SYMBOL(dm_io_async_vm);
+EXPORT_SYMBOL(dm_io);
diff --git a/drivers/md/dm-io.h b/drivers/md/dm-io.h
index f9035bfd1a9f..f647e2cceaa6 100644
--- a/drivers/md/dm-io.h
+++ b/drivers/md/dm-io.h
@@ -12,7 +12,7 @@
 struct io_region {
         struct block_device *bdev;
         sector_t sector;
-        sector_t count;
+        sector_t count;         /* If this is zero the region is ignored. */
 };
 
 struct page_list {
@@ -20,55 +20,60 @@ struct page_list {
         struct page *page;
 };
 
-
-/*
- * 'error' is a bitset, with each bit indicating whether an error
- * occurred doing io to the corresponding region.
- */
 typedef void (*io_notify_fn)(unsigned long error, void *context);
 
+enum dm_io_mem_type {
+        DM_IO_PAGE_LIST,/* Page list */
+        DM_IO_BVEC,     /* Bio vector */
+        DM_IO_VMA,      /* Virtual memory area */
+        DM_IO_KMEM,     /* Kernel memory */
+};
+
+struct dm_io_memory {
+        enum dm_io_mem_type type;
+
+        union {
+                struct page_list *pl;
+                struct bio_vec *bvec;
+                void *vma;
+                void *addr;
+        } ptr;
+
+        unsigned offset;
+};
+
+struct dm_io_notify {
+        io_notify_fn fn;        /* Callback for asynchronous requests */
+        void *context;          /* Passed to callback */
+};
 
 /*
- * Before anyone uses the IO interface they should call
- * dm_io_get(), specifying roughly how many pages they are
- * expecting to perform io on concurrently.
- *
- * This function may block.
+ * IO request structure
  */
-int dm_io_get(unsigned int num_pages);
-void dm_io_put(unsigned int num_pages);
+struct dm_io_client;
+struct dm_io_request {
+        int bi_rw;                      /* READ|WRITE - not READA */
+        struct dm_io_memory mem;        /* Memory to use for io */
+        struct dm_io_notify notify;     /* Synchronous if notify.fn is NULL */
+        struct dm_io_client *client;    /* Client memory handler */
+};
 
 /*
- * Synchronous IO.
+ * For async io calls, users can alternatively use the dm_io() function below
+ * and dm_io_client_create() to create private mempools for the client.
  *
- * Please ensure that the rw flag in the next two functions is
- * either READ or WRITE, ie. we don't take READA.  Any
- * regions with a zero count field will be ignored.
+ * Create/destroy may block.
  */
-int dm_io_sync(unsigned int num_regions, struct io_region *where, int rw,
-               struct page_list *pl, unsigned int offset,
-               unsigned long *error_bits);
-
-int dm_io_sync_bvec(unsigned int num_regions, struct io_region *where, int rw,
-                    struct bio_vec *bvec, unsigned long *error_bits);
-
-int dm_io_sync_vm(unsigned int num_regions, struct io_region *where, int rw,
-                  void *data, unsigned long *error_bits);
+struct dm_io_client *dm_io_client_create(unsigned num_pages);
+int dm_io_client_resize(unsigned num_pages, struct dm_io_client *client);
+void dm_io_client_destroy(struct dm_io_client *client);
 
 /*
- * Aynchronous IO.
- *
- * The 'where' array may be safely allocated on the stack since
- * the function takes a copy.
+ * IO interface using private per-client pools.
+ * Each bit in the optional 'sync_error_bits' bitset indicates whether an
+ * error occurred doing io to the corresponding region.
  */
-int dm_io_async(unsigned int num_regions, struct io_region *where, int rw,
-                struct page_list *pl, unsigned int offset,
-                io_notify_fn fn, void *context);
-
-int dm_io_async_bvec(unsigned int num_regions, struct io_region *where, int rw,
-                     struct bio_vec *bvec, io_notify_fn fn, void *context);
-
-int dm_io_async_vm(unsigned int num_regions, struct io_region *where, int rw,
-                   void *data, io_notify_fn fn, void *context);
+int dm_io(struct dm_io_request *io_req, unsigned num_regions,
+          struct io_region *region, unsigned long *sync_error_bits);
 
 #endif
diff --git a/drivers/md/dm-log.c b/drivers/md/dm-log.c
index 6a9261351848..a66428d860fe 100644
--- a/drivers/md/dm-log.c
+++ b/drivers/md/dm-log.c
@@ -149,9 +149,12 @@ struct log_c {
                 FORCESYNC,      /* Force a sync to happen */
         } sync;
 
+        struct dm_io_request io_req;
+
         /*
          * Disk log fields
          */
+        int log_dev_failed;
         struct dm_dev *log_dev;
         struct log_header header;
 
@@ -199,13 +202,20 @@ static void header_from_disk(struct log_header *core, struct log_header *disk)
         core->nr_regions = le64_to_cpu(disk->nr_regions);
 }
 
+static int rw_header(struct log_c *lc, int rw)
+{
+        lc->io_req.bi_rw = rw;
+        lc->io_req.mem.ptr.vma = lc->disk_header;
+        lc->io_req.notify.fn = NULL;
+
+        return dm_io(&lc->io_req, 1, &lc->header_location, NULL);
+}
+
 static int read_header(struct log_c *log)
 {
         int r;
-        unsigned long ebits;
 
-        r = dm_io_sync_vm(1, &log->header_location, READ,
-                          log->disk_header, &ebits);
+        r = rw_header(log, READ);
         if (r)
                 return r;
 
@@ -233,11 +243,8 @@ static int read_header(struct log_c *log)
 
 static inline int write_header(struct log_c *log)
 {
-        unsigned long ebits;
-
         header_to_disk(&log->header, log->disk_header);
-        return dm_io_sync_vm(1, &log->header_location, WRITE,
-                             log->disk_header, &ebits);
+        return rw_header(log, WRITE);
 }
 
 /*----------------------------------------------------------------
@@ -256,6 +263,7 @@ static int create_log_context(struct dirty_log *log, struct dm_target *ti,
         uint32_t region_size;
         unsigned int region_count;
         size_t bitset_size, buf_size;
+        int r;
 
         if (argc < 1 || argc > 2) {
                 DMWARN("wrong number of arguments to mirror log");
@@ -315,6 +323,7 @@ static int create_log_context(struct dirty_log *log, struct dm_target *ti,
                 lc->disk_header = NULL;
         } else {
                 lc->log_dev = dev;
+                lc->log_dev_failed = 0;
                 lc->header_location.bdev = lc->log_dev->bdev;
                 lc->header_location.sector = 0;
 
@@ -324,6 +333,15 @@ static int create_log_context(struct dirty_log *log, struct dm_target *ti,
                 buf_size = dm_round_up((LOG_OFFSET << SECTOR_SHIFT) +
                                        bitset_size, ti->limits.hardsect_size);
                 lc->header_location.count = buf_size >> SECTOR_SHIFT;
+                lc->io_req.mem.type = DM_IO_VMA;
+                lc->io_req.client = dm_io_client_create(dm_div_up(buf_size,
+                                                                   PAGE_SIZE));
+                if (IS_ERR(lc->io_req.client)) {
+                        r = PTR_ERR(lc->io_req.client);
+                        DMWARN("couldn't allocate disk io client");
+                        kfree(lc);
+                        return -ENOMEM;
+                }
 
                 lc->disk_header = vmalloc(buf_size);
                 if (!lc->disk_header) {
@@ -424,6 +442,7 @@ static void disk_dtr(struct dirty_log *log)
 
         dm_put_device(lc->ti, lc->log_dev);
         vfree(lc->disk_header);
+        dm_io_client_destroy(lc->io_req.client);
         destroy_log_context(lc);
 }
 
@@ -437,6 +456,15 @@ static int count_bits32(uint32_t *addr, unsigned size)
         return count;
 }
 
+static void fail_log_device(struct log_c *lc)
+{
+        if (lc->log_dev_failed)
+                return;
+
+        lc->log_dev_failed = 1;
+        dm_table_event(lc->ti->table);
+}
+
 static int disk_resume(struct dirty_log *log)
 {
         int r;
@@ -446,8 +474,19 @@ static int disk_resume(struct dirty_log *log)
 
         /* read the disk header */
         r = read_header(lc);
-        if (r)
-                return r;
+        if (r) {
+                DMWARN("%s: Failed to read header on mirror log device",
+                       lc->log_dev->name);
+                fail_log_device(lc);
+                /*
+                 * If the log device cannot be read, we must assume
+                 * all regions are out-of-sync.  If we simply return
+                 * here, the state will be uninitialized and could
+                 * lead us to return 'in-sync' status for regions
+                 * that are actually 'out-of-sync'.
+                 */
+                lc->header.nr_regions = 0;
+        }
 
         /* set or clear any new bits -- device has grown */
         if (lc->sync == NOSYNC)
@@ -472,7 +511,14 @@ static int disk_resume(struct dirty_log *log)
         lc->header.nr_regions = lc->region_count;
 
         /* write the new header */
-        return write_header(lc);
+        r = write_header(lc);
+        if (r) {
+                DMWARN("%s: Failed to write header on mirror log device",
+                       lc->log_dev->name);
+                fail_log_device(lc);
+        }
+
+        return r;
 }
 
 static uint32_t core_get_region_size(struct dirty_log *log)
@@ -516,7 +562,9 @@ static int disk_flush(struct dirty_log *log)
                 return 0;
 
         r = write_header(lc);
-        if (!r)
+        if (r)
+                fail_log_device(lc);
+        else
                 lc->touched = 0;
 
         return r;
@@ -591,6 +639,7 @@ static int core_status(struct dirty_log *log, status_type_t status,
 
         switch(status) {
         case STATUSTYPE_INFO:
+                DMEMIT("1 %s", log->type->name);
                 break;
 
         case STATUSTYPE_TABLE:
@@ -606,17 +655,17 @@ static int disk_status(struct dirty_log *log, status_type_t status,
                        char *result, unsigned int maxlen)
 {
         int sz = 0;
-        char buffer[16];
         struct log_c *lc = log->context;
 
         switch(status) {
         case STATUSTYPE_INFO:
+                DMEMIT("3 %s %s %c", log->type->name, lc->log_dev->name,
+                       lc->log_dev_failed ? 'D' : 'A');
                 break;
 
         case STATUSTYPE_TABLE:
-                format_dev_t(buffer, lc->log_dev->bdev->bd_dev);
                 DMEMIT("%s %u %s %u ", log->type->name,
-                       lc->sync == DEFAULTSYNC ? 2 : 3, buffer,
+                       lc->sync == DEFAULTSYNC ? 2 : 3, lc->log_dev->name,
                        lc->region_size);
                 DMEMIT_SYNC;
         }
diff --git a/drivers/md/dm-mpath.c b/drivers/md/dm-mpath.c
index 3aa013506967..de54b39e6ffe 100644
--- a/drivers/md/dm-mpath.c
+++ b/drivers/md/dm-mpath.c
@@ -668,6 +668,9 @@ static int parse_hw_handler(struct arg_set *as, struct multipath *m)
                 return -EINVAL;
         }
 
+        m->hw_handler.md = dm_table_get_md(ti->table);
+        dm_put(m->hw_handler.md);
+
         r = hwht->create(&m->hw_handler, hw_argc - 1, as->argv);
         if (r) {
                 dm_put_hw_handler(hwht);
diff --git a/drivers/md/dm-raid1.c b/drivers/md/dm-raid1.c
index 23a642619bed..ef124b71ccc8 100644
--- a/drivers/md/dm-raid1.c
+++ b/drivers/md/dm-raid1.c
@@ -21,15 +21,11 @@
 #include <linux/workqueue.h>
 
 #define DM_MSG_PREFIX "raid1"
+#define DM_IO_PAGES 64
 
-static struct workqueue_struct *_kmirrord_wq;
-static struct work_struct _kmirrord_work;
-static DECLARE_WAIT_QUEUE_HEAD(_kmirrord_recovery_stopped);
+#define DM_RAID1_HANDLE_ERRORS 0x01
 
-static inline void wake(void)
-{
-        queue_work(_kmirrord_wq, &_kmirrord_work);
-}
+static DECLARE_WAIT_QUEUE_HEAD(_kmirrord_recovery_stopped);
 
 /*-----------------------------------------------------------------
  * Region hash
@@ -125,17 +121,23 @@ struct mirror_set {
         struct list_head list;
         struct region_hash rh;
         struct kcopyd_client *kcopyd_client;
+        uint64_t features;
 
         spinlock_t lock;        /* protects the next two lists */
         struct bio_list reads;
         struct bio_list writes;
 
+        struct dm_io_client *io_client;
+
         /* recovery */
         region_t nr_regions;
         int in_sync;
 
         struct mirror *default_mirror;  /* Default mirror */
 
+        struct workqueue_struct *kmirrord_wq;
+        struct work_struct kmirrord_work;
+
         unsigned int nr_mirrors;
         struct mirror mirror[0];
 };
@@ -153,6 +155,11 @@ static inline sector_t region_to_sector(struct region_hash *rh, region_t region)
         return region << rh->region_shift;
 }
 
+static void wake(struct mirror_set *ms)
+{
+        queue_work(ms->kmirrord_wq, &ms->kmirrord_work);
+}
+
 /* FIXME move this */
 static void queue_bio(struct mirror_set *ms, struct bio *bio, int rw);
 
@@ -398,8 +405,7 @@ static void rh_update_states(struct region_hash *rh)
                 mempool_free(reg, rh->region_pool);
         }
 
-        if (!list_empty(&recovered))
-                rh->log->type->flush(rh->log);
+        rh->log->type->flush(rh->log);
 
         list_for_each_entry_safe (reg, next, &clean, list)
                 mempool_free(reg, rh->region_pool);
@@ -471,7 +477,7 @@ static void rh_dec(struct region_hash *rh, region_t region)
         spin_unlock_irqrestore(&rh->region_lock, flags);
 
         if (should_wake)
-                wake();
+                wake(rh->ms);
 }
 
 /*
@@ -558,7 +564,7 @@ static void rh_recovery_end(struct region *reg, int success)
         list_add(&reg->list, &reg->rh->recovered_regions);
         spin_unlock_irq(&rh->region_lock);
 
-        wake();
+        wake(rh->ms);
 }
 
 static void rh_flush(struct region_hash *rh)
@@ -592,7 +598,7 @@ static void rh_start_recovery(struct region_hash *rh)
         for (i = 0; i < MAX_RECOVERY; i++)
                 up(&rh->recovery_count);
 
-        wake();
+        wake(rh->ms);
 }
 
 /*
@@ -735,7 +741,7 @@ static void do_reads(struct mirror_set *ms, struct bio_list *reads)
                 /*
                  * We can only read balance if the region is in sync.
                  */
-                if (rh_in_sync(&ms->rh, region, 0))
+                if (rh_in_sync(&ms->rh, region, 1))
                         m = choose_mirror(ms, bio->bi_sector);
                 else
                         m = ms->default_mirror;
@@ -792,6 +798,14 @@ static void do_write(struct mirror_set *ms, struct bio *bio)
         unsigned int i;
         struct io_region io[KCOPYD_MAX_REGIONS+1];
         struct mirror *m;
+        struct dm_io_request io_req = {
+                .bi_rw = WRITE,
+                .mem.type = DM_IO_BVEC,
+                .mem.ptr.bvec = bio->bi_io_vec + bio->bi_idx,
+                .notify.fn = write_callback,
+                .notify.context = bio,
+                .client = ms->io_client,
+        };
 
         for (i = 0; i < ms->nr_mirrors; i++) {
                 m = ms->mirror + i;
@@ -802,9 +816,8 @@ static void do_write(struct mirror_set *ms, struct bio *bio)
         }
 
         bio_set_ms(bio, ms);
-        dm_io_async_bvec(ms->nr_mirrors, io, WRITE,
-                         bio->bi_io_vec + bio->bi_idx,
-                         write_callback, bio);
+
+        (void) dm_io(&io_req, ms->nr_mirrors, io, NULL);
 }
 
 static void do_writes(struct mirror_set *ms, struct bio_list *writes)
@@ -870,11 +883,10 @@ static void do_writes(struct mirror_set *ms, struct bio_list *writes)
 /*-----------------------------------------------------------------
  * kmirrord
  *---------------------------------------------------------------*/
-static LIST_HEAD(_mirror_sets);
-static DECLARE_RWSEM(_mirror_sets_lock);
-
-static void do_mirror(struct mirror_set *ms)
+static void do_mirror(struct work_struct *work)
 {
+        struct mirror_set *ms =container_of(work, struct mirror_set,
+                                            kmirrord_work);
         struct bio_list reads, writes;
 
         spin_lock(&ms->lock);
@@ -890,16 +902,6 @@ static void do_mirror(struct mirror_set *ms)
         do_writes(ms, &writes);
 }
 
-static void do_work(struct work_struct *ignored)
-{
-        struct mirror_set *ms;
-
-        down_read(&_mirror_sets_lock);
-        list_for_each_entry (ms, &_mirror_sets, list)
-                do_mirror(ms);
-        up_read(&_mirror_sets_lock);
-}
-
 /*-----------------------------------------------------------------
  * Target functions
  *---------------------------------------------------------------*/
@@ -931,6 +933,13 @@ static struct mirror_set *alloc_context(unsigned int nr_mirrors,
         ms->in_sync = 0;
         ms->default_mirror = &ms->mirror[DEFAULT_MIRROR];
 
+        ms->io_client = dm_io_client_create(DM_IO_PAGES);
+        if (IS_ERR(ms->io_client)) {
+                ti->error = "Error creating dm_io client";
+                kfree(ms);
+                return NULL;
+        }
+
         if (rh_init(&ms->rh, ms, dl, region_size, ms->nr_regions)) {
                 ti->error = "Error creating dirty region hash";
                 kfree(ms);
@@ -946,6 +955,7 @@ static void free_context(struct mirror_set *ms, struct dm_target *ti,
         while (m--)
                 dm_put_device(ti, ms->mirror[m].dev);
 
+        dm_io_client_destroy(ms->io_client);
         rh_exit(&ms->rh);
         kfree(ms);
 }
@@ -978,23 +988,6 @@ static int get_mirror(struct mirror_set *ms, struct dm_target *ti,
         return 0;
 }
 
-static int add_mirror_set(struct mirror_set *ms)
-{
-        down_write(&_mirror_sets_lock);
-        list_add_tail(&ms->list, &_mirror_sets);
-        up_write(&_mirror_sets_lock);
-        wake();
-
-        return 0;
-}
-
-static void del_mirror_set(struct mirror_set *ms)
-{
-        down_write(&_mirror_sets_lock);
-        list_del(&ms->list);
-        up_write(&_mirror_sets_lock);
-}
-
 /*
  * Create dirty log: log_type #log_params <log_params>
  */
@@ -1037,16 +1030,55 @@ static struct dirty_log *create_dirty_log(struct dm_target *ti,
         return dl;
 }
 
+static int parse_features(struct mirror_set *ms, unsigned argc, char **argv,
+                          unsigned *args_used)
+{
+        unsigned num_features;
+        struct dm_target *ti = ms->ti;
+
+        *args_used = 0;
+
+        if (!argc)
+                return 0;
+
+        if (sscanf(argv[0], "%u", &num_features) != 1) {
+                ti->error = "Invalid number of features";
+                return -EINVAL;
+        }
+
+        argc--;
+        argv++;
+        (*args_used)++;
+
+        if (num_features > argc) {
+                ti->error = "Not enough arguments to support feature count";
+                return -EINVAL;
+        }
+
+        if (!strcmp("handle_errors", argv[0]))
+                ms->features |= DM_RAID1_HANDLE_ERRORS;
+        else {
+                ti->error = "Unrecognised feature requested";
+                return -EINVAL;
+        }
+
+        (*args_used)++;
+
+        return 0;
+}
+
 /*
  * Construct a mirror mapping:
  *
  * log_type #log_params <log_params>
  * #mirrors [mirror_path offset]{2,}
+ * [#features <features>]
  *
  * log_type is "core" or "disk"
  * #log_params is between 1 and 3
+ *
+ * If present, features must be "handle_errors".
  */
-#define DM_IO_PAGES 64
 static int mirror_ctr(struct dm_target *ti, unsigned int argc, char **argv)
 {
         int r;
@@ -1070,8 +1102,8 @@ static int mirror_ctr(struct dm_target *ti, unsigned int argc, char **argv)
 
         argv++, argc--;
 
-        if (argc != nr_mirrors * 2) {
-                ti->error = "Wrong number of mirror arguments";
+        if (argc < nr_mirrors * 2) {
+                ti->error = "Too few mirror arguments";
                 dm_destroy_dirty_log(dl);
                 return -EINVAL;
         }
@@ -1096,13 +1128,37 @@ static int mirror_ctr(struct dm_target *ti, unsigned int argc, char **argv)
         ti->private = ms;
         ti->split_io = ms->rh.region_size;
 
+        ms->kmirrord_wq = create_singlethread_workqueue("kmirrord");
+        if (!ms->kmirrord_wq) {
+                DMERR("couldn't start kmirrord");
+                free_context(ms, ti, m);
+                return -ENOMEM;
+        }
+        INIT_WORK(&ms->kmirrord_work, do_mirror);
+
+        r = parse_features(ms, argc, argv, &args_used);
+        if (r) {
+                free_context(ms, ti, ms->nr_mirrors);
+                return r;
+        }
+
+        argv += args_used;
+        argc -= args_used;
+
+        if (argc) {
+                ti->error = "Too many mirror arguments";
+                free_context(ms, ti, ms->nr_mirrors);
+                return -EINVAL;
+        }
+
         r = kcopyd_client_create(DM_IO_PAGES, &ms->kcopyd_client);
         if (r) {
+                destroy_workqueue(ms->kmirrord_wq);
                 free_context(ms, ti, ms->nr_mirrors);
                 return r;
         }
 
-        add_mirror_set(ms);
+        wake(ms);
         return 0;
 }
 
@@ -1110,8 +1166,9 @@ static void mirror_dtr(struct dm_target *ti)
 {
         struct mirror_set *ms = (struct mirror_set *) ti->private;
 
-        del_mirror_set(ms);
+        flush_workqueue(ms->kmirrord_wq);
         kcopyd_client_destroy(ms->kcopyd_client);
+        destroy_workqueue(ms->kmirrord_wq);
         free_context(ms, ti, ms->nr_mirrors);
 }
 
@@ -1127,7 +1184,7 @@ static void queue_bio(struct mirror_set *ms, struct bio *bio, int rw)
         spin_unlock(&ms->lock);
 
         if (should_wake)
-                wake();
+                wake(ms);
 }
 
 /*
@@ -1222,11 +1279,9 @@ static void mirror_resume(struct dm_target *ti)
 static int mirror_status(struct dm_target *ti, status_type_t type,
                          char *result, unsigned int maxlen)
 {
-        unsigned int m, sz;
+        unsigned int m, sz = 0;
         struct mirror_set *ms = (struct mirror_set *) ti->private;
 
-        sz = ms->rh.log->type->status(ms->rh.log, type, result, maxlen);
-
         switch (type) {
         case STATUSTYPE_INFO:
                 DMEMIT("%d ", ms->nr_mirrors);
@@ -1237,13 +1292,21 @@ static int mirror_status(struct dm_target *ti, status_type_t type,
                         (unsigned long long)ms->rh.log->type->
                                 get_sync_count(ms->rh.log),
                         (unsigned long long)ms->nr_regions);
+
+                sz = ms->rh.log->type->status(ms->rh.log, type, result, maxlen);
+
                 break;
 
         case STATUSTYPE_TABLE:
+                sz = ms->rh.log->type->status(ms->rh.log, type, result, maxlen);
+
                 DMEMIT("%d", ms->nr_mirrors);
                 for (m = 0; m < ms->nr_mirrors; m++)
                         DMEMIT(" %s %llu", ms->mirror[m].dev->name,
                                 (unsigned long long)ms->mirror[m].offset);
+
+                if (ms->features & DM_RAID1_HANDLE_ERRORS)
+                        DMEMIT(" 1 handle_errors");
         }
 
         return 0;
@@ -1251,7 +1314,7 @@ static int mirror_status(struct dm_target *ti, status_type_t type,
 
 static struct target_type mirror_target = {
         .name    = "mirror",
-        .version = {1, 0, 2},
+        .version = {1, 0, 3},
         .module  = THIS_MODULE,
         .ctr     = mirror_ctr,
         .dtr     = mirror_dtr,
@@ -1270,20 +1333,11 @@ static int __init dm_mirror_init(void)
         if (r)
                 return r;
 
-        _kmirrord_wq = create_singlethread_workqueue("kmirrord");
-        if (!_kmirrord_wq) {
-                DMERR("couldn't start kmirrord");
-                dm_dirty_log_exit();
-                return r;
-        }
-        INIT_WORK(&_kmirrord_work, do_work);
-
         r = dm_register_target(&mirror_target);
         if (r < 0) {
                 DMERR("%s: Failed to register mirror target",
                       mirror_target.name);
                 dm_dirty_log_exit();
-                destroy_workqueue(_kmirrord_wq);
         }
 
         return r;
@@ -1297,7 +1351,6 @@ static void __exit dm_mirror_exit(void)
         if (r < 0)
                 DMERR("%s: unregister failed %d", mirror_target.name, r);
 
-        destroy_workqueue(_kmirrord_wq);
         dm_dirty_log_exit();
 }
 
diff --git a/drivers/md/dm-table.c b/drivers/md/dm-table.c
index 05befa91807a..2fc199b0016b 100644
--- a/drivers/md/dm-table.c
+++ b/drivers/md/dm-table.c
@@ -425,13 +425,15 @@ static void close_dev(struct dm_dev *d, struct mapped_device *md)
 }
 
 /*
- * If possible (ie. blk_size[major] is set), this checks an area
- * of a destination device is valid.
+ * If possible, this checks an area of a destination device is valid.
  */
 static int check_device_area(struct dm_dev *dd, sector_t start, sector_t len)
 {
-        sector_t dev_size;
-        dev_size = dd->bdev->bd_inode->i_size >> SECTOR_SHIFT;
+        sector_t dev_size = dd->bdev->bd_inode->i_size >> SECTOR_SHIFT;
+
+        if (!dev_size)
+                return 1;
+
         return ((start < dev_size) && (len <= (dev_size - start)));
 }
 
diff --git a/drivers/md/dm.c b/drivers/md/dm.c
index 11a98df298ec..2717a355dc5b 100644
--- a/drivers/md/dm.c
+++ b/drivers/md/dm.c
@@ -1236,6 +1236,7 @@ void dm_put(struct mapped_device *md)
                 free_dev(md);
         }
 }
+EXPORT_SYMBOL_GPL(dm_put);
 
 /*
  * Process the deferred bios
diff --git a/drivers/md/kcopyd.c b/drivers/md/kcopyd.c
index b46f6c575f7e..dbc234e3c69f 100644
--- a/drivers/md/kcopyd.c
+++ b/drivers/md/kcopyd.c
@@ -1,5 +1,6 @@
 /*
  * Copyright (C) 2002 Sistina Software (UK) Limited.
+ * Copyright (C) 2006 Red Hat GmbH
  *
  * This file is released under the GPL.
  *
@@ -45,6 +46,8 @@ struct kcopyd_client {
         unsigned int nr_pages;
         unsigned int nr_free_pages;
 
+        struct dm_io_client *io_client;
+
         wait_queue_head_t destroyq;
         atomic_t nr_jobs;
 };
@@ -342,16 +345,20 @@ static void complete_io(unsigned long error, void *context)
 static int run_io_job(struct kcopyd_job *job)
 {
         int r;
+        struct dm_io_request io_req = {
+                .bi_rw = job->rw,
+                .mem.type = DM_IO_PAGE_LIST,
+                .mem.ptr.pl = job->pages,
+                .mem.offset = job->offset,
+                .notify.fn = complete_io,
+                .notify.context = job,
+                .client = job->kc->io_client,
+        };
 
         if (job->rw == READ)
-                r = dm_io_async(1, &job->source, job->rw,
-                                job->pages,
-                                job->offset, complete_io, job);
-
+                r = dm_io(&io_req, 1, &job->source, NULL);
         else
-                r = dm_io_async(job->num_dests, job->dests, job->rw,
-                                job->pages,
-                                job->offset, complete_io, job);
+                r = dm_io(&io_req, job->num_dests, job->dests, NULL);
 
         return r;
 }
@@ -670,8 +677,9 @@ int kcopyd_client_create(unsigned int nr_pages, struct kcopyd_client **result)
                 return r;
         }
 
-        r = dm_io_get(nr_pages);
-        if (r) {
+        kc->io_client = dm_io_client_create(nr_pages);
+        if (IS_ERR(kc->io_client)) {
+                r = PTR_ERR(kc->io_client);
                 client_free_pages(kc);
                 kfree(kc);
                 kcopyd_exit();
@@ -691,7 +699,7 @@ void kcopyd_client_destroy(struct kcopyd_client *kc)
         /* Wait for completion of all jobs submitted by this client. */
         wait_event(kc->destroyq, !atomic_read(&kc->nr_jobs));
 
-        dm_io_put(kc->nr_pages);
+        dm_io_client_destroy(kc->io_client);
         client_free_pages(kc);
         client_del(kc);
         kfree(kc);
diff --git a/drivers/md/md.c b/drivers/md/md.c
index 2b4315d7e5d6..2901d0c0ee9e 100644
--- a/drivers/md/md.c
+++ b/drivers/md/md.c
@@ -33,6 +33,7 @@
 */
 
 #include <linux/module.h>
+#include <linux/kernel.h>
 #include <linux/kthread.h>
 #include <linux/linkage.h>
 #include <linux/raid/md.h>
@@ -273,6 +274,7 @@ static mddev_t * mddev_find(dev_t unit)
         atomic_set(&new->active, 1);
         spin_lock_init(&new->write_lock);
         init_waitqueue_head(&new->sb_wait);
+        new->reshape_position = MaxSector;
 
         new->queue = blk_alloc_queue(GFP_KERNEL);
         if (!new->queue) {
@@ -589,14 +591,41 @@ abort:
         return ret;
 }
 
+
+static u32 md_csum_fold(u32 csum)
+{
+        csum = (csum & 0xffff) + (csum >> 16);
+        return (csum & 0xffff) + (csum >> 16);
+}
+
 static unsigned int calc_sb_csum(mdp_super_t * sb)
 {
+        u64 newcsum = 0;
+        u32 *sb32 = (u32*)sb;
+        int i;
         unsigned int disk_csum, csum;
 
         disk_csum = sb->sb_csum;
         sb->sb_csum = 0;
-        csum = csum_partial((void *)sb, MD_SB_BYTES, 0);
+
+        for (i = 0; i < MD_SB_BYTES/4 ; i++)
+                newcsum += sb32[i];
+        csum = (newcsum & 0xffffffff) + (newcsum>>32);
+
+
+#ifdef CONFIG_ALPHA
+        /* This used to use csum_partial, which was wrong for several
+         * reasons including that different results are returned on
+         * different architectures.  It isn't critical that we get exactly
+         * the same return value as before (we always csum_fold before
+         * testing, and that removes any differences).  However as we
+         * know that csum_partial always returned a 16bit value on
+         * alphas, do a fold to maximise conformity to previous behaviour.
+         */
+        sb->sb_csum = md_csum_fold(disk_csum);
+#else
         sb->sb_csum = disk_csum;
+#endif
         return csum;
 }
 
@@ -684,7 +713,7 @@ static int super_90_load(mdk_rdev_t *rdev, mdk_rdev_t *refdev, int minor_version
         if (sb->raid_disks <= 0)
                 goto abort;
 
-        if (csum_fold(calc_sb_csum(sb)) != csum_fold(sb->sb_csum)) {
+        if (md_csum_fold(calc_sb_csum(sb)) != md_csum_fold(sb->sb_csum)) {
                 printk(KERN_WARNING "md: invalid superblock checksum on %s\n",
                         b);
                 goto abort;
@@ -694,6 +723,17 @@ static int super_90_load(mdk_rdev_t *rdev, mdk_rdev_t *refdev, int minor_version
         rdev->data_offset = 0;
         rdev->sb_size = MD_SB_BYTES;
 
+        if (sb->state & (1<<MD_SB_BITMAP_PRESENT)) {
+                if (sb->level != 1 && sb->level != 4
+                    && sb->level != 5 && sb->level != 6
+                    && sb->level != 10) {
+                        /* FIXME use a better test */
+                        printk(KERN_WARNING
+                               "md: bitmaps not supported for this level.\n");
+                        goto abort;
+                }
+        }
+
         if (sb->level == LEVEL_MULTIPATH)
                 rdev->desc_nr = -1;
         else
@@ -792,16 +832,8 @@ static int super_90_validate(mddev_t *mddev, mdk_rdev_t *rdev)
                 mddev->max_disks = MD_SB_DISKS;
 
                 if (sb->state & (1<<MD_SB_BITMAP_PRESENT) &&
-                    mddev->bitmap_file == NULL) {
-                        if (mddev->level != 1 && mddev->level != 4
-                            && mddev->level != 5 && mddev->level != 6
-                            && mddev->level != 10) {
-                                /* FIXME use a better test */
-                                printk(KERN_WARNING "md: bitmaps not supported for this level.\n");
-                                return -EINVAL;
-                        }
+                    mddev->bitmap_file == NULL)
                         mddev->bitmap_offset = mddev->default_bitmap_offset;
-                }
 
         } else if (mddev->pers == NULL) {
                 /* Insist on good event counter while assembling */
@@ -1058,6 +1090,18 @@ static int super_1_load(mdk_rdev_t *rdev, mdk_rdev_t *refdev, int minor_version)
                        bdevname(rdev->bdev,b));
                 return -EINVAL;
         }
+        if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_BITMAP_OFFSET)) {
+                if (sb->level != cpu_to_le32(1) &&
+                    sb->level != cpu_to_le32(4) &&
+                    sb->level != cpu_to_le32(5) &&
+                    sb->level != cpu_to_le32(6) &&
+                    sb->level != cpu_to_le32(10)) {
+                        printk(KERN_WARNING
+                               "md: bitmaps not supported for this level.\n");
+                        return -EINVAL;
+                }
+        }
+
         rdev->preferred_minor = 0xffff;
         rdev->data_offset = le64_to_cpu(sb->data_offset);
         atomic_set(&rdev->corrected_errors, le32_to_cpu(sb->cnt_corrected_read));
@@ -1141,14 +1185,9 @@ static int super_1_validate(mddev_t *mddev, mdk_rdev_t *rdev)
                 mddev->max_disks =  (4096-256)/2;
 
                 if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_BITMAP_OFFSET) &&
-                    mddev->bitmap_file == NULL ) {
-                        if (mddev->level != 1 && mddev->level != 5 && mddev->level != 6
-                            && mddev->level != 10) {
-                                printk(KERN_WARNING "md: bitmaps not supported for this level.\n");
-                                return -EINVAL;
-                        }
+                    mddev->bitmap_file == NULL )
                         mddev->bitmap_offset = (__s32)le32_to_cpu(sb->bitmap_offset);
-                }
+
                 if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_RESHAPE_ACTIVE)) {
                         mddev->reshape_position = le64_to_cpu(sb->reshape_position);
                         mddev->delta_disks = le32_to_cpu(sb->delta_disks);
@@ -2204,6 +2243,10 @@ static ssize_t
 layout_show(mddev_t *mddev, char *page)
 {
         /* just a number, not meaningful for all levels */
+        if (mddev->reshape_position != MaxSector &&
+            mddev->layout != mddev->new_layout)
+                return sprintf(page, "%d (%d)\n",
+                               mddev->new_layout, mddev->layout);
         return sprintf(page, "%d\n", mddev->layout);
 }
 
@@ -2212,13 +2255,16 @@ layout_store(mddev_t *mddev, const char *buf, size_t len)
 {
         char *e;
         unsigned long n = simple_strtoul(buf, &e, 10);
-        if (mddev->pers)
-                return -EBUSY;
 
         if (!*buf || (*e && *e != '\n'))
                 return -EINVAL;
 
-        mddev->layout = n;
+        if (mddev->pers)
+                return -EBUSY;
+        if (mddev->reshape_position != MaxSector)
+                mddev->new_layout = n;
+        else
+                mddev->layout = n;
         return len;
 }
 static struct md_sysfs_entry md_layout =
@@ -2230,6 +2276,10 @@ raid_disks_show(mddev_t *mddev, char *page)
 {
         if (mddev->raid_disks == 0)
                 return 0;
+        if (mddev->reshape_position != MaxSector &&
+            mddev->delta_disks != 0)
+                return sprintf(page, "%d (%d)\n", mddev->raid_disks,
+                               mddev->raid_disks - mddev->delta_disks);
         return sprintf(page, "%d\n", mddev->raid_disks);
 }
 
@@ -2247,7 +2297,11 @@ raid_disks_store(mddev_t *mddev, const char *buf, size_t len)
 
         if (mddev->pers)
                 rv = update_raid_disks(mddev, n);
-        else
+        else if (mddev->reshape_position != MaxSector) {
+                int olddisks = mddev->raid_disks - mddev->delta_disks;
+                mddev->delta_disks = n - olddisks;
+                mddev->raid_disks = n;
+        } else
                 mddev->raid_disks = n;
         return rv ? rv : len;
 }
@@ -2257,6 +2311,10 @@ __ATTR(raid_disks, S_IRUGO|S_IWUSR, raid_disks_show, raid_disks_store);
 static ssize_t
 chunk_size_show(mddev_t *mddev, char *page)
 {
+        if (mddev->reshape_position != MaxSector &&
+            mddev->chunk_size != mddev->new_chunk)
+                return sprintf(page, "%d (%d)\n", mddev->new_chunk,
+                               mddev->chunk_size);
         return sprintf(page, "%d\n", mddev->chunk_size);
 }
 
@@ -2267,12 +2325,15 @@ chunk_size_store(mddev_t *mddev, const char *buf, size_t len)
         char *e;
         unsigned long n = simple_strtoul(buf, &e, 10);
 
-        if (mddev->pers)
-                return -EBUSY;
         if (!*buf || (*e && *e != '\n'))
                 return -EINVAL;
 
-        mddev->chunk_size = n;
+        if (mddev->pers)
+                return -EBUSY;
+        else if (mddev->reshape_position != MaxSector)
+                mddev->new_chunk = n;
+        else
+                mddev->chunk_size = n;
         return len;
 }
 static struct md_sysfs_entry md_chunk_size =
@@ -2637,8 +2698,7 @@ metadata_store(mddev_t *mddev, const char *buf, size_t len)
         minor = simple_strtoul(buf, &e, 10);
         if (e==buf || (*e && *e != '\n') )
                 return -EINVAL;
-        if (major >= sizeof(super_types)/sizeof(super_types[0]) ||
-            super_types[major].name == NULL)
+        if (major >= ARRAY_SIZE(super_types) || super_types[major].name == NULL)
                 return -ENOENT;
         mddev->major_version = major;
         mddev->minor_version = minor;
@@ -2859,6 +2919,37 @@ suspend_hi_store(mddev_t *mddev, const char *buf, size_t len)
 static struct md_sysfs_entry md_suspend_hi =
 __ATTR(suspend_hi, S_IRUGO|S_IWUSR, suspend_hi_show, suspend_hi_store);
 
+static ssize_t
+reshape_position_show(mddev_t *mddev, char *page)
+{
+        if (mddev->reshape_position != MaxSector)
+                return sprintf(page, "%llu\n",
+                               (unsigned long long)mddev->reshape_position);
+        strcpy(page, "none\n");
+        return 5;
+}
+
+static ssize_t
+reshape_position_store(mddev_t *mddev, const char *buf, size_t len)
+{
+        char *e;
+        unsigned long long new = simple_strtoull(buf, &e, 10);
+        if (mddev->pers)
+                return -EBUSY;
+        if (buf == e || (*e && *e != '\n'))
+                return -EINVAL;
+        mddev->reshape_position = new;
+        mddev->delta_disks = 0;
+        mddev->new_level = mddev->level;
+        mddev->new_layout = mddev->layout;
+        mddev->new_chunk = mddev->chunk_size;
+        return len;
+}
+
+static struct md_sysfs_entry md_reshape_position =
+__ATTR(reshape_position, S_IRUGO|S_IWUSR, reshape_position_show,
+       reshape_position_store);
+
 
 static struct attribute *md_default_attrs[] = {
         &md_level.attr,
@@ -2871,6 +2962,7 @@ static struct attribute *md_default_attrs[] = {
         &md_new_device.attr,
         &md_safe_delay.attr,
         &md_array_state.attr,
+        &md_reshape_position.attr,
         NULL,
 };
 
@@ -3012,6 +3104,7 @@ static int do_md_run(mddev_t * mddev)
         struct gendisk *disk;
         struct mdk_personality *pers;
         char b[BDEVNAME_SIZE];
+        struct block_device *bdev;
 
         if (list_empty(&mddev->disks))
                 /* cannot run an array with no devices.. */
@@ -3239,7 +3332,13 @@ static int do_md_run(mddev_t * mddev)
         md_wakeup_thread(mddev->thread);
         md_wakeup_thread(mddev->sync_thread); /* possibly kick off a reshape */
 
-        mddev->changed = 1;
+        bdev = bdget_disk(mddev->gendisk, 0);
+        if (bdev) {
+                bd_set_size(bdev, mddev->array_size << 1);
+                blkdev_ioctl(bdev->bd_inode, NULL, BLKRRPART, 0);
+                bdput(bdev);
+        }
+
         md_new_event(mddev);
         kobject_uevent(&mddev->gendisk->kobj, KOBJ_CHANGE);
         return 0;
@@ -3361,7 +3460,6 @@ static int do_md_stop(mddev_t * mddev, int mode)
                         mddev->pers = NULL;
 
                         set_capacity(disk, 0);
-                        mddev->changed = 1;
 
                         if (mddev->ro)
                                 mddev->ro = 0;
@@ -3409,6 +3507,7 @@ static int do_md_stop(mddev_t * mddev, int mode)
                 mddev->size = 0;
                 mddev->raid_disks = 0;
                 mddev->recovery_cp = 0;
+                mddev->reshape_position = MaxSector;
 
         } else if (mddev->pers)
                 printk(KERN_INFO "md: %s switched to read-only mode.\n",
@@ -4019,7 +4118,7 @@ static int set_array_info(mddev_t * mddev, mdu_array_info_t *info)
         if (info->raid_disks == 0) {
                 /* just setting version number for superblock loading */
                 if (info->major_version < 0 ||
-                    info->major_version >= sizeof(super_types)/sizeof(super_types[0]) ||
+                    info->major_version >= ARRAY_SIZE(super_types) ||
                     super_types[info->major_version].name == NULL) {
                         /* maybe try to auto-load a module? */
                         printk(KERN_INFO 
@@ -4500,20 +4599,6 @@ static int md_release(struct inode *inode, struct file * file)
         return 0;
 }
 
-static int md_media_changed(struct gendisk *disk)
-{
-        mddev_t *mddev = disk->private_data;
-
-        return mddev->changed;
-}
-
-static int md_revalidate(struct gendisk *disk)
-{
-        mddev_t *mddev = disk->private_data;
-
-        mddev->changed = 0;
-        return 0;
-}
 static struct block_device_operations md_fops =
 {
         .owner          = THIS_MODULE,
@@ -4521,8 +4606,6 @@ static struct block_device_operations md_fops =
         .release        = md_release,
         .ioctl          = md_ioctl,
         .getgeo         = md_getgeo,
-        .media_changed  = md_media_changed,
-        .revalidate_disk= md_revalidate,
 };
 
 static int md_thread(void * arg)
@@ -4941,15 +5024,6 @@ static int md_seq_open(struct inode *inode, struct file *file)
         return error;
 }
 
-static int md_seq_release(struct inode *inode, struct file *file)
-{
-        struct seq_file *m = file->private_data;
-        struct mdstat_info *mi = m->private;
-        m->private = NULL;
-        kfree(mi);
-        return seq_release(inode, file);
-}
-
 static unsigned int mdstat_poll(struct file *filp, poll_table *wait)
 {
         struct seq_file *m = filp->private_data;
@@ -4971,7 +5045,7 @@ static const struct file_operations md_seq_fops = {
         .open           = md_seq_open,
         .read           = seq_read,
         .llseek         = seq_lseek,
-        .release        = md_seq_release,
+        .release        = seq_release_private,
         .poll           = mdstat_poll,
 };
 
diff --git a/drivers/md/raid1.c b/drivers/md/raid1.c
index 97ee870b265d..1b7130cad21f 100644
--- a/drivers/md/raid1.c
+++ b/drivers/md/raid1.c
@@ -2063,7 +2063,6 @@ static int raid1_resize(mddev_t *mddev, sector_t sectors)
          */
         mddev->array_size = sectors>>1;
         set_capacity(mddev->gendisk, mddev->array_size << 1);
-        mddev->changed = 1;
         if (mddev->array_size > mddev->size && mddev->recovery_cp == MaxSector) {
                 mddev->recovery_cp = mddev->size << 1;
                 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
diff --git a/drivers/md/raid5.c b/drivers/md/raid5.c
index 8d59914f2057..a72e70ad0975 100644
--- a/drivers/md/raid5.c
+++ b/drivers/md/raid5.c
@@ -353,8 +353,8 @@ static int grow_stripes(raid5_conf_t *conf, int num)
         struct kmem_cache *sc;
         int devs = conf->raid_disks;
 
-        sprintf(conf->cache_name[0], "raid5/%s", mdname(conf->mddev));
-        sprintf(conf->cache_name[1], "raid5/%s-alt", mdname(conf->mddev));
+        sprintf(conf->cache_name[0], "raid5-%s", mdname(conf->mddev));
+        sprintf(conf->cache_name[1], "raid5-%s-alt", mdname(conf->mddev));
         conf->active_name = 0;
         sc = kmem_cache_create(conf->cache_name[conf->active_name],
                                sizeof(struct stripe_head)+(devs-1)*sizeof(struct r5dev),
@@ -3864,7 +3864,6 @@ static int raid5_resize(mddev_t *mddev, sector_t sectors)
         sectors &= ~((sector_t)mddev->chunk_size/512 - 1);
         mddev->array_size = (sectors * (mddev->raid_disks-conf->max_degraded))>>1;
         set_capacity(mddev->gendisk, mddev->array_size << 1);
-        mddev->changed = 1;
         if (sectors/2  > mddev->size && mddev->recovery_cp == MaxSector) {
                 mddev->recovery_cp = mddev->size << 1;
                 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
@@ -3999,7 +3998,6 @@ static void end_reshape(raid5_conf_t *conf)
                 conf->mddev->array_size = conf->mddev->size *
                         (conf->raid_disks - conf->max_degraded);
                 set_capacity(conf->mddev->gendisk, conf->mddev->array_size << 1);
-                conf->mddev->changed = 1;
 
                 bdev = bdget_disk(conf->mddev->gendisk, 0);
                 if (bdev) {
diff --git a/drivers/media/dvb/dvb-usb/dvb-usb-remote.c b/drivers/media/dvb/dvb-usb/dvb-usb-remote.c
index 68ed3a788083..9200a30dd1b9 100644
--- a/drivers/media/dvb/dvb-usb/dvb-usb-remote.c
+++ b/drivers/media/dvb/dvb-usb/dvb-usb-remote.c
@@ -3,7 +3,7 @@
  * Copyright (C) 2004-6 Patrick Boettcher (patrick.boettcher@desy.de)
  * see dvb-usb-init.c for copyright information.
  *
- * This file contains functions for initializing the the input-device and for handling remote-control-queries.
+ * This file contains functions for initializing the input-device and for handling remote-control-queries.
  */
 #include "dvb-usb-common.h"
 #include <linux/usb/input.h>
diff --git a/drivers/media/dvb/frontends/dib7000m.c b/drivers/media/dvb/frontends/dib7000m.c
index f5d40aa3d27f..f64546c6aeb5 100644
--- a/drivers/media/dvb/frontends/dib7000m.c
+++ b/drivers/media/dvb/frontends/dib7000m.c
@@ -266,7 +266,7 @@ static int dib7000m_sad_calib(struct dib7000m_state *state)
 {
 
 /* internal */
-//      dib7000m_write_word(state, 928, (3 << 14) | (1 << 12) | (524 << 0)); // sampling clock of the SAD is writting in set_bandwidth
+//      dib7000m_write_word(state, 928, (3 << 14) | (1 << 12) | (524 << 0)); // sampling clock of the SAD is written in set_bandwidth
         dib7000m_write_word(state, 929, (0 << 1) | (0 << 0));
         dib7000m_write_word(state, 930, 776); // 0.625*3.3 / 4096
 
diff --git a/drivers/media/dvb/frontends/dib7000p.c b/drivers/media/dvb/frontends/dib7000p.c
index 0349a4b5da3f..aece458cfe12 100644
--- a/drivers/media/dvb/frontends/dib7000p.c
+++ b/drivers/media/dvb/frontends/dib7000p.c
@@ -223,7 +223,7 @@ static int dib7000p_set_bandwidth(struct dvb_frontend *demod, u8 BW_Idx)
 static int dib7000p_sad_calib(struct dib7000p_state *state)
 {
 /* internal */
-//      dib7000p_write_word(state, 72, (3 << 14) | (1 << 12) | (524 << 0)); // sampling clock of the SAD is writting in set_bandwidth
+//      dib7000p_write_word(state, 72, (3 << 14) | (1 << 12) | (524 << 0)); // sampling clock of the SAD is written in set_bandwidth
         dib7000p_write_word(state, 73, (0 << 1) | (0 << 0));
         dib7000p_write_word(state, 74, 776); // 0.625*3.3 / 4096
 
diff --git a/drivers/media/dvb/frontends/tda10021.c b/drivers/media/dvb/frontends/tda10021.c
index 110536843e8e..e725f612a6b7 100644
--- a/drivers/media/dvb/frontends/tda10021.c
+++ b/drivers/media/dvb/frontends/tda10021.c
@@ -1,6 +1,6 @@
 /*
     TDA10021  - Single Chip Cable Channel Receiver driver module
-               used on the the Siemens DVB-C cards
+               used on the Siemens DVB-C cards
 
     Copyright (C) 1999 Convergence Integrated Media GmbH <ralph@convergence.de>
     Copyright (C) 2004 Markus Schulz <msc@antzsystem.de>
diff --git a/drivers/media/dvb/frontends/ves1x93.c b/drivers/media/dvb/frontends/ves1x93.c
index 54d7b07571b8..23fd0303c91b 100644
--- a/drivers/media/dvb/frontends/ves1x93.c
+++ b/drivers/media/dvb/frontends/ves1x93.c
@@ -306,7 +306,7 @@ static int ves1x93_read_status(struct dvb_frontend* fe, fe_status_t* status)
          * The ves1893 sometimes returns sync values that make no sense,
          * because, e.g., the SIGNAL bit is 0, while some of the higher
          * bits are 1 (and how can there be a CARRIER w/o a SIGNAL?).
-         * Tests showed that the the VITERBI and SYNC bits are returned
+         * Tests showed that the VITERBI and SYNC bits are returned
          * reliably, while the SIGNAL and CARRIER bits ar sometimes wrong.
          * If such a case occurs, we read the value again, until we get a
          * valid value.
diff --git a/drivers/media/video/em28xx/em28xx-i2c.c b/drivers/media/video/em28xx/em28xx-i2c.c
index 563a8319e608..54ccc6e1f92e 100644
--- a/drivers/media/video/em28xx/em28xx-i2c.c
+++ b/drivers/media/video/em28xx/em28xx-i2c.c
@@ -70,7 +70,7 @@ static int em2800_i2c_send_max4(struct em28xx *dev, unsigned char addr,
 
         ret = dev->em28xx_write_regs(dev, 4 - len, &b2[4 - len], 2 + len);
         if (ret != 2 + len) {
-                em28xx_warn("writting to i2c device failed (error=%i)\n", ret);
+                em28xx_warn("writing to i2c device failed (error=%i)\n", ret);
                 return -EIO;
         }
         for (write_timeout = EM2800_I2C_WRITE_TIMEOUT; write_timeout > 0;
diff --git a/drivers/media/video/em28xx/em28xx-video.c b/drivers/media/video/em28xx/em28xx-video.c
index bec67609500f..2c7b158ce7e1 100644
--- a/drivers/media/video/em28xx/em28xx-video.c
+++ b/drivers/media/video/em28xx/em28xx-video.c
@@ -1729,7 +1729,7 @@ static int em28xx_usb_probe(struct usb_interface *interface,
 
         endpoint = &interface->cur_altsetting->endpoint[1].desc;
 
-        /* check if the the device has the iso in endpoint at the correct place */
+        /* check if the device has the iso in endpoint at the correct place */
         if ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) !=
             USB_ENDPOINT_XFER_ISOC) {
                 em28xx_err(DRIVER_NAME " probing error: endpoint is non-ISO endpoint!\n");
diff --git a/drivers/media/video/pwc/philips.txt b/drivers/media/video/pwc/philips.txt
index f5e848410311..f9f3584281d8 100644
--- a/drivers/media/video/pwc/philips.txt
+++ b/drivers/media/video/pwc/philips.txt
@@ -54,9 +54,9 @@ fps
    Specifies the desired framerate. Is an integer in the range of 4-30.
 
 fbufs
-   This paramter specifies the number of internal buffers to use for storing
+   This parameter specifies the number of internal buffers to use for storing
    frames from the cam. This will help if the process that reads images from
-   the cam is a bit slow or momentarely busy. However, on slow machines it
+   the cam is a bit slow or momentarily busy. However, on slow machines it
    only introduces lag, so choose carefully. The default is 3, which is
    reasonable. You can set it between 2 and 5.
 
@@ -209,7 +209,7 @@ trace
 
      128   0x80   PWCX debugging                                      Off
 
-   For example, to trace the open() & read() fuctions, sum 8 + 4 = 12,
+   For example, to trace the open() & read() functions, sum 8 + 4 = 12,
    so you would supply trace=12 during insmod or modprobe. If
    you want to turn the initialization and probing tracing off, set trace=0.
    The default value for trace is 35 (0x23).
diff --git a/drivers/media/video/usbvideo/vicam.c b/drivers/media/video/usbvideo/vicam.c
index 876fd2768242..982b115193f8 100644
--- a/drivers/media/video/usbvideo/vicam.c
+++ b/drivers/media/video/usbvideo/vicam.c
@@ -28,7 +28,7 @@
  *
  * Portions of this code were also copied from usbvideo.c
  *
- * Special thanks to the the whole team at Sourceforge for help making
+ * Special thanks to the whole team at Sourceforge for help making
  * this driver become a reality.  Notably:
  * Andy Armstrong who reverse engineered the color encoding and
  * Pavel Machek and Chris Cheney who worked on reverse engineering the
diff --git a/drivers/message/fusion/lsi/mpi_history.txt b/drivers/message/fusion/lsi/mpi_history.txt
index d6b4c607453b..ddc7ae029dd3 100644
--- a/drivers/message/fusion/lsi/mpi_history.txt
+++ b/drivers/message/fusion/lsi/mpi_history.txt
@@ -571,7 +571,7 @@ mpi_fc.h
  *  11-02-00  01.01.01  Original release for post 1.0 work
  *  12-04-00  01.01.02  Added messages for Common Transport Send and
  *                      Primitive Send.
- *  01-09-01  01.01.03  Modifed some of the new flags to have an MPI prefix
+ *  01-09-01  01.01.03  Modified some of the new flags to have an MPI prefix
  *                      and modified the FcPrimitiveSend flags.
  *  01-25-01  01.01.04  Move InitiatorIndex in LinkServiceRsp reply to a larger
  *                      field.
diff --git a/drivers/message/fusion/mptbase.c b/drivers/message/fusion/mptbase.c
index 97471af4309c..5021d1a2a1d4 100644
--- a/drivers/message/fusion/mptbase.c
+++ b/drivers/message/fusion/mptbase.c
@@ -3585,7 +3585,7 @@ initChainBuffers(MPT_ADAPTER *ioc)
          * index = chain_idx
          *
          * Calculate the number of chain buffers needed(plus 1) per I/O
-         * then multiply the the maximum number of simultaneous cmds
+         * then multiply the maximum number of simultaneous cmds
          *
          * num_sge = num sge in request frame + last chain buffer
          * scale = num sge per chain buffer if no chain element
diff --git a/drivers/misc/tifm_7xx1.c b/drivers/misc/tifm_7xx1.c
index 1ba6c085419a..c08ad8f823d2 100644
--- a/drivers/misc/tifm_7xx1.c
+++ b/drivers/misc/tifm_7xx1.c
@@ -105,7 +105,8 @@ static unsigned char tifm_7xx1_toggle_sock_power(char __iomem *sock_addr)
             == TIFM_TYPE_XD)
                 msleep(40);
 
-        writel((s_state & 7) | 0x0c00, sock_addr + SOCK_CONTROL);
+        writel((s_state & TIFM_CTRL_POWER_MASK) | 0x0c00,
+               sock_addr + SOCK_CONTROL);
         /* wait for power to stabilize */
         msleep(20);
         for (cnt = 16; cnt <= 256; cnt <<= 1) {
@@ -122,6 +123,12 @@ static unsigned char tifm_7xx1_toggle_sock_power(char __iomem *sock_addr)
         return (readl(sock_addr + SOCK_PRESENT_STATE) >> 4) & 7;
 }
 
+inline static void tifm_7xx1_sock_power_off(char __iomem *sock_addr)
+{
+        writel((~TIFM_CTRL_POWER_MASK) & readl(sock_addr + SOCK_CONTROL),
+               sock_addr + SOCK_CONTROL);
+}
+
 inline static char __iomem *
 tifm_7xx1_sock_addr(char __iomem *base_addr, unsigned int sock_num)
 {
@@ -133,6 +140,7 @@ static void tifm_7xx1_switch_media(struct work_struct *work)
         struct tifm_adapter *fm = container_of(work, struct tifm_adapter,
                                                media_switcher);
         struct tifm_dev *sock;
+        char __iomem *sock_addr;
         unsigned long flags;
         unsigned char media_id;
         unsigned int socket_change_set, cnt;
@@ -158,11 +166,12 @@ static void tifm_7xx1_switch_media(struct work_struct *work)
                                "%s : demand removing card from socket %u:%u\n",
                                fm->cdev.class_id, fm->id, cnt);
                         fm->sockets[cnt] = NULL;
+                        sock_addr = sock->addr;
                         spin_unlock_irqrestore(&fm->lock, flags);
                         device_unregister(&sock->dev);
                         spin_lock_irqsave(&fm->lock, flags);
-                        writel(0x0e00, tifm_7xx1_sock_addr(fm->addr, cnt)
-                               + SOCK_CONTROL);
+                        tifm_7xx1_sock_power_off(sock_addr);
+                        writel(0x0e00, sock_addr + SOCK_CONTROL);
                 }
 
                 spin_unlock_irqrestore(&fm->lock, flags);
@@ -205,8 +214,16 @@ static void tifm_7xx1_switch_media(struct work_struct *work)
 
 static int tifm_7xx1_suspend(struct pci_dev *dev, pm_message_t state)
 {
+        struct tifm_adapter *fm = pci_get_drvdata(dev);
+        int cnt;
+
         dev_dbg(&dev->dev, "suspending host\n");
 
+        for (cnt = 0; cnt < fm->num_sockets; cnt++) {
+                if (fm->sockets[cnt])
+                        tifm_7xx1_sock_power_off(fm->sockets[cnt]->addr);
+        }
+
         pci_save_state(dev);
         pci_enable_wake(dev, pci_choose_state(dev, state), 0);
         pci_disable_device(dev);
@@ -357,6 +374,7 @@ err_out:
 static void tifm_7xx1_remove(struct pci_dev *dev)
 {
         struct tifm_adapter *fm = pci_get_drvdata(dev);
+        int cnt;
 
         fm->eject = tifm_7xx1_dummy_eject;
         writel(TIFM_IRQ_SETALL, fm->addr + FM_CLEAR_INTERRUPT_ENABLE);
@@ -365,6 +383,9 @@ static void tifm_7xx1_remove(struct pci_dev *dev)
 
         tifm_remove_adapter(fm);
 
+        for (cnt = 0; cnt < fm->num_sockets; cnt++)
+                tifm_7xx1_sock_power_off(tifm_7xx1_sock_addr(fm->addr, cnt));
+
         pci_set_drvdata(dev, NULL);
 
         iounmap(fm->addr);
diff --git a/drivers/mmc/Kconfig b/drivers/mmc/Kconfig
index 6c97491543db..45b7d53b949c 100644
--- a/drivers/mmc/Kconfig
+++ b/drivers/mmc/Kconfig
@@ -2,10 +2,8 @@
 # MMC subsystem configuration
 #
 
-menu "MMC/SD Card support"
-
-config MMC
-        tristate "MMC support"
+menuconfig MMC
+        tristate "MMC/SD card support"
         help
           MMC is the "multi-media card" bus protocol.
 
@@ -19,10 +17,12 @@ config MMC_DEBUG
           This is an option for use by developers; most people should
           say N here.  This enables MMC core and driver debugging.
 
+if MMC
+
 source "drivers/mmc/core/Kconfig"
 
 source "drivers/mmc/card/Kconfig"
 
 source "drivers/mmc/host/Kconfig"
 
-endmenu
+endif # MMC
diff --git a/drivers/mmc/card/Kconfig b/drivers/mmc/card/Kconfig
index 01a9fd376a1f..9320a8c73239 100644
--- a/drivers/mmc/card/Kconfig
+++ b/drivers/mmc/card/Kconfig
@@ -3,11 +3,10 @@
 #
 
 comment "MMC/SD Card Drivers"
-        depends MMC
 
 config MMC_BLOCK
         tristate "MMC block device driver"
-        depends on MMC && BLOCK
+        depends on BLOCK
         default y
         help
           Say Y here to enable the MMC block device driver support.
diff --git a/drivers/mmc/core/Kconfig b/drivers/mmc/core/Kconfig
index 94222b9a15ea..ab37a6d9d32a 100644
--- a/drivers/mmc/core/Kconfig
+++ b/drivers/mmc/core/Kconfig
@@ -4,7 +4,6 @@
 
 config MMC_UNSAFE_RESUME
         bool "Allow unsafe resume (DANGEROUS)"
-        depends on MMC != n
         help
           If you say Y here, the MMC layer will assume that all cards
           stayed in their respective slots during the suspend. The
diff --git a/drivers/mmc/core/core.c b/drivers/mmc/core/core.c
index 72c7cf4a9f9d..7385acfa1dd9 100644
--- a/drivers/mmc/core/core.c
+++ b/drivers/mmc/core/core.c
@@ -500,9 +500,10 @@ void __mmc_release_bus(struct mmc_host *host)
 void mmc_detect_change(struct mmc_host *host, unsigned long delay)
 {
 #ifdef CONFIG_MMC_DEBUG
-        mmc_claim_host(host);
+        unsigned long flags;
+        spin_lock_irqsave(&host->lock, flags);
         BUG_ON(host->removed);
-        mmc_release_host(host);
+        spin_unlock_irqrestore(&host->lock, flags);
 #endif
 
         mmc_schedule_delayed_work(&host->detect, delay);
@@ -625,9 +626,10 @@ EXPORT_SYMBOL(mmc_add_host);
 void mmc_remove_host(struct mmc_host *host)
 {
 #ifdef CONFIG_MMC_DEBUG
-        mmc_claim_host(host);
+        unsigned long flags;
+        spin_lock_irqsave(&host->lock, flags);
         host->removed = 1;
-        mmc_release_host(host);
+        spin_unlock_irqrestore(&host->lock, flags);
 #endif
 
         mmc_flush_scheduled_work();
diff --git a/drivers/mmc/host/Kconfig b/drivers/mmc/host/Kconfig
index ed4deab2203d..e23082fe88d0 100644
--- a/drivers/mmc/host/Kconfig
+++ b/drivers/mmc/host/Kconfig
@@ -3,11 +3,10 @@
 #
 
 comment "MMC/SD Host Controller Drivers"
-        depends on MMC
 
 config MMC_ARMMMCI
         tristate "ARM AMBA Multimedia Card Interface support"
-        depends on ARM_AMBA && MMC
+        depends on ARM_AMBA
         help
           This selects the ARM(R) AMBA(R) PrimeCell Multimedia Card
           Interface (PL180 and PL181) support.  If you have an ARM(R)
@@ -17,7 +16,7 @@ config MMC_ARMMMCI
 
 config MMC_PXA
         tristate "Intel PXA25x/26x/27x Multimedia Card Interface support"
-        depends on ARCH_PXA && MMC
+        depends on ARCH_PXA
         help
           This selects the Intel(R) PXA(R) Multimedia card Interface.
           If you have a PXA(R) platform with a Multimedia Card slot,
@@ -27,7 +26,7 @@ config MMC_PXA
 
 config MMC_SDHCI
         tristate "Secure Digital Host Controller Interface support  (EXPERIMENTAL)"
-        depends on PCI && MMC && EXPERIMENTAL
+        depends on PCI && EXPERIMENTAL
         help
           This select the generic Secure Digital Host Controller Interface.
           It is used by manufacturers such as Texas Instruments(R), Ricoh(R)
@@ -38,7 +37,7 @@ config MMC_SDHCI
 
 config MMC_OMAP
         tristate "TI OMAP Multimedia Card Interface support"
-        depends on ARCH_OMAP && MMC
+        depends on ARCH_OMAP
         select TPS65010 if MACH_OMAP_H2
         help
           This selects the TI OMAP Multimedia card Interface.
@@ -49,7 +48,7 @@ config MMC_OMAP
 
 config MMC_WBSD
         tristate "Winbond W83L51xD SD/MMC Card Interface support"
-        depends on MMC && ISA_DMA_API
+        depends on ISA_DMA_API
         help
           This selects the Winbond(R) W83L51xD Secure digital and
           Multimedia card Interface.
@@ -60,7 +59,7 @@ config MMC_WBSD
 
 config MMC_AU1X
         tristate "Alchemy AU1XX0 MMC Card Interface support"
-        depends on MMC && SOC_AU1200
+        depends on SOC_AU1200
         help
           This selects the AMD Alchemy(R) Multimedia card interface.
           If you have a Alchemy platform with a MMC slot, say Y or M here.
@@ -69,7 +68,7 @@ config MMC_AU1X
 
 config MMC_AT91
         tristate "AT91 SD/MMC Card Interface support"
-        depends on ARCH_AT91 && MMC
+        depends on ARCH_AT91
         help
           This selects the AT91 MCI controller.
 
@@ -77,7 +76,7 @@ config MMC_AT91
 
 config MMC_IMX
         tristate "Motorola i.MX Multimedia Card Interface support"
-        depends on ARCH_IMX && MMC
+        depends on ARCH_IMX
         help
           This selects the Motorola i.MX Multimedia card Interface.
           If you have a i.MX platform with a Multimedia Card slot,
@@ -87,7 +86,7 @@ config MMC_IMX
 
 config MMC_TIFM_SD
         tristate "TI Flash Media MMC/SD Interface support  (EXPERIMENTAL)"
-        depends on MMC && EXPERIMENTAL && PCI
+        depends on EXPERIMENTAL && PCI
         select TIFM_CORE
         help
           Say Y here if you want to be able to access MMC/SD cards with
diff --git a/drivers/mmc/host/tifm_sd.c b/drivers/mmc/host/tifm_sd.c
index 7511f961c67b..8b736e968447 100644
--- a/drivers/mmc/host/tifm_sd.c
+++ b/drivers/mmc/host/tifm_sd.c
@@ -1021,10 +1021,6 @@ static void tifm_sd_remove(struct tifm_dev *sock)
         mmc_remove_host(mmc);
         dev_dbg(&sock->dev, "after remove\n");
 
-        /* The meaning of the bit majority in this constant is unknown. */
-        writel(0xfff8 & readl(sock->addr + SOCK_CONTROL),
-               sock->addr + SOCK_CONTROL);
-
         mmc_free_host(mmc);
 }
 
@@ -1032,14 +1028,7 @@ static void tifm_sd_remove(struct tifm_dev *sock)
 
 static int tifm_sd_suspend(struct tifm_dev *sock, pm_message_t state)
 {
-        struct mmc_host *mmc = tifm_get_drvdata(sock);
-        int rc;
-
-        rc = mmc_suspend_host(mmc, state);
-        /* The meaning of the bit majority in this constant is unknown. */
-        writel(0xfff8 & readl(sock->addr + SOCK_CONTROL),
-               sock->addr + SOCK_CONTROL);
-        return rc;
+        return mmc_suspend_host(tifm_get_drvdata(sock), state);
 }
 
 static int tifm_sd_resume(struct tifm_dev *sock)
diff --git a/drivers/mtd/maps/Kconfig b/drivers/mtd/maps/Kconfig
index d990d8141ef5..5fcd8b3631ba 100644
--- a/drivers/mtd/maps/Kconfig
+++ b/drivers/mtd/maps/Kconfig
@@ -60,7 +60,7 @@ config MTD_PHYSMAP_BANKWIDTH
           (i.e., run-time calling physmap_configure()).
 
 config MTD_PHYSMAP_OF
-        tristate "Flash device in physical memory map based on OF descirption"
+        tristate "Flash device in physical memory map based on OF description"
         depends on PPC_OF && (MTD_CFI || MTD_JEDECPROBE || MTD_ROM)
         help
           This provides a 'mapping' driver which allows the NOR Flash and
diff --git a/drivers/mtd/maps/nettel.c b/drivers/mtd/maps/nettel.c
index 9f53c655af3a..7b96cd02f82b 100644
--- a/drivers/mtd/maps/nettel.c
+++ b/drivers/mtd/maps/nettel.c
@@ -358,7 +358,7 @@ int __init nettel_init(void)
         /* Turn other PAR off so the first probe doesn't find it */
         *intel1par = 0;
 
-        /* Probe for the the size of the first Intel flash */
+        /* Probe for the size of the first Intel flash */
         nettel_intel_map.size = maxsize;
         nettel_intel_map.phys = intel0addr;
         nettel_intel_map.virt = ioremap_nocache(intel0addr, maxsize);
diff --git a/drivers/mtd/onenand/onenand_base.c b/drivers/mtd/onenand/onenand_base.c
index 000794c6caf5..0537fac8de74 100644
--- a/drivers/mtd/onenand/onenand_base.c
+++ b/drivers/mtd/onenand/onenand_base.c
@@ -2192,7 +2192,7 @@ static int onenand_check_maf(int manuf)
  * @param mtd           MTD device structure
  *
  * OneNAND detection method:
- *   Compare the the values from command with ones from register
+ *   Compare the values from command with ones from register
  */
 static int onenand_probe(struct mtd_info *mtd)
 {
diff --git a/drivers/net/3c509.c b/drivers/net/3c509.c
index 9588da3a30e7..127f60841b10 100644
--- a/drivers/net/3c509.c
+++ b/drivers/net/3c509.c
@@ -95,8 +95,7 @@ static int max_interrupt_work = 10;
 #include <asm/io.h>
 #include <asm/irq.h>
 
-static char versionA[] __initdata = DRV_NAME ".c:" DRV_VERSION " " DRV_RELDATE " becker@scyld.com\n";
-static char versionB[] __initdata = "http://www.scyld.com/network/3c509.html\n";
+static char version[] __initdata = DRV_NAME ".c:" DRV_VERSION " " DRV_RELDATE " becker@scyld.com\n";
 
 #if defined(CONFIG_PM) && (defined(CONFIG_MCA) || defined(CONFIG_EISA))
 #define EL3_SUSPEND
@@ -360,7 +359,7 @@ static int __init el3_common_init(struct net_device *dev)
         printk(", IRQ %d.\n", dev->irq);
 
         if (el3_debug > 0)
-                printk(KERN_INFO "%s" KERN_INFO "%s", versionA, versionB);
+                printk(KERN_INFO "%s", version);
         return 0;
 
 }
diff --git a/drivers/net/3c59x.c b/drivers/net/3c59x.c
index 80924f76dee8..f26ca331615e 100644
--- a/drivers/net/3c59x.c
+++ b/drivers/net/3c59x.c
@@ -103,7 +103,7 @@ static int vortex_debug = 1;
 
 
 static char version[] __devinitdata =
-DRV_NAME ": Donald Becker and others. www.scyld.com/network/vortex.html\n";
+DRV_NAME ": Donald Becker and others.\n";
 
 MODULE_AUTHOR("Donald Becker <becker@scyld.com>");
 MODULE_DESCRIPTION("3Com 3c59x/3c9xx ethernet driver ");
diff --git a/drivers/net/atp.c b/drivers/net/atp.c
index 18aba838c1ff..82d78ff8399b 100644
--- a/drivers/net/atp.c
+++ b/drivers/net/atp.c
@@ -31,10 +31,8 @@
 
 */
 
-static const char versionA[] =
+static const char version[] =
 "atp.c:v1.09=ac 2002/10/01 Donald Becker <becker@scyld.com>\n";
-static const char versionB[] =
-"  http://www.scyld.com/network/atp.html\n";
 
 /* The user-configurable values.
    These may be modified when a driver module is loaded.*/
@@ -324,7 +322,7 @@ static int __init atp_probe1(long ioaddr)
 
 #ifndef MODULE
         if (net_debug)
-                printk(KERN_INFO "%s" KERN_INFO "%s", versionA, versionB);
+                printk(KERN_INFO "%s", version);
 #endif
 
         printk(KERN_NOTICE "%s: Pocket adapter found at %#3lx, IRQ %d, SAPROM "
@@ -926,7 +924,7 @@ static void set_rx_mode_8012(struct net_device *dev)
 
 static int __init atp_init_module(void) {
         if (debug)                                      /* Emit version even if no cards detected. */
-                printk(KERN_INFO "%s" KERN_INFO "%s", versionA, versionB);
+                printk(KERN_INFO "%s", version);
         return atp_init();
 }
 
diff --git a/drivers/net/bonding/bond_main.c b/drivers/net/bonding/bond_main.c
index 724bce51f936..223517dcbcfd 100644
--- a/drivers/net/bonding/bond_main.c
+++ b/drivers/net/bonding/bond_main.c
@@ -3461,7 +3461,7 @@ void bond_unregister_arp(struct bonding *bond)
 /*---------------------------- Hashing Policies -----------------------------*/
 
 /*
- * Hash for the the output device based upon layer 3 and layer 4 data. If
+ * Hash for the output device based upon layer 3 and layer 4 data. If
  * the packet is a frag or not TCP or UDP, just use layer 3 data.  If it is
  * altogether not IP, mimic bond_xmit_hash_policy_l2()
  */
diff --git a/drivers/net/e1000/e1000_main.c b/drivers/net/e1000/e1000_main.c
index 3a03a74c0609..637ae8f68791 100644
--- a/drivers/net/e1000/e1000_main.c
+++ b/drivers/net/e1000/e1000_main.c
@@ -1214,7 +1214,7 @@ e1000_remove(struct pci_dev *pdev)
         int i;
 #endif
 
-        flush_scheduled_work();
+        cancel_work_sync(&adapter->reset_task);
 
         e1000_release_manageability(adapter);
 
diff --git a/drivers/net/eepro.c b/drivers/net/eepro.c
index 39654e1e2bed..47680237f783 100644
--- a/drivers/net/eepro.c
+++ b/drivers/net/eepro.c
@@ -1126,7 +1126,7 @@ static void eepro_tx_timeout (struct net_device *dev)
         printk (KERN_ERR "%s: transmit timed out, %s?\n", dev->name,
                 "network cable problem");
         /* This is not a duplicate. One message for the console,
-           one for the the log file  */
+           one for the log file  */
         printk (KERN_DEBUG "%s: transmit timed out, %s?\n", dev->name,
                 "network cable problem");
         eepro_complete_selreset(ioaddr);
diff --git a/drivers/net/eepro100.c b/drivers/net/eepro100.c
index 6c267c38df97..9800341956a2 100644
--- a/drivers/net/eepro100.c
+++ b/drivers/net/eepro100.c
@@ -28,7 +28,7 @@
 */
 
 static const char * const version =
-"eepro100.c:v1.09j-t 9/29/99 Donald Becker http://www.scyld.com/network/eepro100.html\n"
+"eepro100.c:v1.09j-t 9/29/99 Donald Becker\n"
 "eepro100.c: $Revision: 1.36 $ 2000/11/17 Modified by Andrey V. Savochkin <saw@saw.sw.com.sg> and others\n";
 
 /* A few user-configurable values that apply to all boards.
diff --git a/drivers/net/epic100.c b/drivers/net/epic100.c
index 4e3f14c9c717..5e517946f46a 100644
--- a/drivers/net/epic100.c
+++ b/drivers/net/epic100.c
@@ -93,8 +93,6 @@ static int rx_copybreak;
 static char version[] __devinitdata =
 DRV_NAME ".c:v1.11 1/7/2001 Written by Donald Becker <becker@scyld.com>\n";
 static char version2[] __devinitdata =
-"  http://www.scyld.com/network/epic100.html\n";
-static char version3[] __devinitdata =
 "  (unofficial 2.4.x kernel port, version " DRV_VERSION ", " DRV_RELDATE ")\n";
 
 MODULE_AUTHOR("Donald Becker <becker@scyld.com>");
@@ -323,8 +321,8 @@ static int __devinit epic_init_one (struct pci_dev *pdev,
 #ifndef MODULE
         static int printed_version;
         if (!printed_version++)
-                printk (KERN_INFO "%s" KERN_INFO "%s" KERN_INFO "%s",
-                        version, version2, version3);
+                printk (KERN_INFO "%s" KERN_INFO "%s",
+                        version, version2);
 #endif
 
         card_idx++;
@@ -1596,8 +1594,8 @@ static int __init epic_init (void)
 {
 /* when a module, this is printed whether or not devices are found in probe */
 #ifdef MODULE
-        printk (KERN_INFO "%s" KERN_INFO "%s" KERN_INFO "%s",
-                version, version2, version3);
+        printk (KERN_INFO "%s" KERN_INFO "%s",
+                version, version2);
 #endif
 
         return pci_register_driver(&epic_driver);
diff --git a/drivers/net/hamradio/Kconfig b/drivers/net/hamradio/Kconfig
index 6e90619b3b41..36d2c7d4f4d0 100644
--- a/drivers/net/hamradio/Kconfig
+++ b/drivers/net/hamradio/Kconfig
@@ -140,7 +140,7 @@ config BAYCOM_SER_HDX
           modems that connect to a serial interface. The driver supports the
           ser12 design in half-duplex mode. This is the old driver.  It is
           still provided in case your serial interface chip does not work with
-          the full-duplex driver. This driver is depreciated.  To configure
+          the full-duplex driver. This driver is deprecated.  To configure
           the driver, use the sethdlc utility available in the standard ax25
           utilities package. For information on the modems, see
           <http://www.baycom.de/> and
diff --git a/drivers/net/irda/donauboe.h b/drivers/net/irda/donauboe.h
index 2ab173d9a0e4..1e67720f1066 100644
--- a/drivers/net/irda/donauboe.h
+++ b/drivers/net/irda/donauboe.h
@@ -113,7 +113,7 @@
 /* RxOver  overflow in Recv FIFO                                */
 /* SipRcv  received serial gap  (or other condition you set)    */
 /* Interrupts are enabled by writing a one to the IER register  */
-/* Interrupts are cleared by writting a one to the ISR register */
+/* Interrupts are cleared by writing a one to the ISR register */
 /*                                                              */
 /* 6. The remaining registers: 0x6 and 0x3 appear to be         */
 /*    reserved parts of 16 or 32 bit registersthe remainder     */
diff --git a/drivers/net/ixgb/ixgb_ee.c b/drivers/net/ixgb/ixgb_ee.c
index f15aebde7b90..52c99d01d568 100644
--- a/drivers/net/ixgb/ixgb_ee.c
+++ b/drivers/net/ixgb/ixgb_ee.c
@@ -315,7 +315,7 @@ ixgb_wait_eeprom_command(struct ixgb_hw *hw)
  * hw - Struct containing variables accessed by shared code
  *
  * Reads the first 64 16 bit words of the EEPROM and sums the values read.
- * If the the sum of the 64 16 bit words is 0xBABA, the EEPROM's checksum is
+ * If the sum of the 64 16 bit words is 0xBABA, the EEPROM's checksum is
  * valid.
  *
  * Returns:
diff --git a/drivers/net/meth.h b/drivers/net/meth.h
index 84960dae2a22..ea3b8fc86d1e 100644
--- a/drivers/net/meth.h
+++ b/drivers/net/meth.h
@@ -126,7 +126,7 @@ typedef struct rx_packet {
                                        /*   Note: when loopback is set this bit becomes collision control.  Setting this bit will */
                                        /*         cause a collision to be reported. */
 
-                                       /* Bits 5 and 6 are used to determine the the Destination address filter mode */
+                                       /* Bits 5 and 6 are used to determine the Destination address filter mode */
 #define METH_ACCEPT_MY 0                        /* 00: Accept PHY address only */
 #define METH_ACCEPT_MCAST 0x20  /* 01: Accept physical, broadcast, and multicast filter matches only */
 #define METH_ACCEPT_AMCAST 0x40 /* 10: Accept physical, broadcast, and all multicast packets */
diff --git a/drivers/net/natsemi.c b/drivers/net/natsemi.c
index 223e0e6264ba..4cf0d3fcb519 100644
--- a/drivers/net/natsemi.c
+++ b/drivers/net/natsemi.c
@@ -131,7 +131,6 @@ static const char version[] __devinitdata =
   KERN_INFO DRV_NAME " dp8381x driver, version "
       DRV_VERSION ", " DRV_RELDATE "\n"
   KERN_INFO "  originally by Donald Becker <becker@scyld.com>\n"
-  KERN_INFO "  http://www.scyld.com/network/natsemi.html\n"
   KERN_INFO "  2.4.x kernel port by Jeff Garzik, Tjeerd Mulder\n";
 
 MODULE_AUTHOR("Donald Becker <becker@scyld.com>");
diff --git a/drivers/net/ne2k-pci.c b/drivers/net/ne2k-pci.c
index 589785d1e762..995c0a5d4066 100644
--- a/drivers/net/ne2k-pci.c
+++ b/drivers/net/ne2k-pci.c
@@ -63,8 +63,7 @@ static int options[MAX_UNITS];
 
 /* These identify the driver base version and may not be removed. */
 static char version[] __devinitdata =
-KERN_INFO DRV_NAME ".c:v" DRV_VERSION " " DRV_RELDATE " D. Becker/P. Gortmaker\n"
-KERN_INFO "  http://www.scyld.com/network/ne2k-pci.html\n";
+KERN_INFO DRV_NAME ".c:v" DRV_VERSION " " DRV_RELDATE " D. Becker/P. Gortmaker\n";
 
 #if defined(__powerpc__)
 #define inl_le(addr)  le32_to_cpu(inl(addr))
diff --git a/drivers/net/phy/phy.c b/drivers/net/phy/phy.c
index eed433d6056a..f71dab347667 100644
--- a/drivers/net/phy/phy.c
+++ b/drivers/net/phy/phy.c
@@ -662,10 +662,10 @@ int phy_stop_interrupts(struct phy_device *phydev)
                 phy_error(phydev);
 
         /*
-         * Finish any pending work; we might have been scheduled
-         * to be called from keventd ourselves, though.
+         * Finish any pending work; we might have been scheduled to be called
+         * from keventd ourselves, but cancel_work_sync() handles that.
          */
-        run_scheduled_work(&phydev->phy_queue);
+        cancel_work_sync(&phydev->phy_queue);
 
         free_irq(phydev->irq, phydev);
 
diff --git a/drivers/net/sundance.c b/drivers/net/sundance.c
index f51ba31970aa..e1f912d04043 100644
--- a/drivers/net/sundance.c
+++ b/drivers/net/sundance.c
@@ -110,8 +110,7 @@ static char *media[MAX_UNITS];
 
 /* These identify the driver base version and may not be removed. */
 static char version[] =
-KERN_INFO DRV_NAME ".c:v" DRV_VERSION " " DRV_RELDATE "  Written by Donald Becker\n"
-KERN_INFO "  http://www.scyld.com/network/sundance.html\n";
+KERN_INFO DRV_NAME ".c:v" DRV_VERSION " " DRV_RELDATE "  Written by Donald Becker\n";
 
 MODULE_AUTHOR("Donald Becker <becker@scyld.com>");
 MODULE_DESCRIPTION("Sundance Alta Ethernet driver");
diff --git a/drivers/net/tg3.c b/drivers/net/tg3.c
index e5e901ecd808..923b9c725cc3 100644
--- a/drivers/net/tg3.c
+++ b/drivers/net/tg3.c
@@ -3716,10 +3716,8 @@ static void tg3_reset_task(struct work_struct *work)
         unsigned int restart_timer;
 
         tg3_full_lock(tp, 0);
-        tp->tg3_flags |= TG3_FLAG_IN_RESET_TASK;
 
         if (!netif_running(tp->dev)) {
-                tp->tg3_flags &= ~TG3_FLAG_IN_RESET_TASK;
                 tg3_full_unlock(tp);
                 return;
         }
@@ -3750,8 +3748,6 @@ static void tg3_reset_task(struct work_struct *work)
                 mod_timer(&tp->timer, jiffies + 1);
 
 out:
-        tp->tg3_flags &= ~TG3_FLAG_IN_RESET_TASK;
-
         tg3_full_unlock(tp);
 }
 
@@ -7390,12 +7386,7 @@ static int tg3_close(struct net_device *dev)
 {
         struct tg3 *tp = netdev_priv(dev);
 
-        /* Calling flush_scheduled_work() may deadlock because
-         * linkwatch_event() may be on the workqueue and it will try to get
-         * the rtnl_lock which we are holding.
-         */
-        while (tp->tg3_flags & TG3_FLAG_IN_RESET_TASK)
-                msleep(1);
+        cancel_work_sync(&tp->reset_task);
 
         netif_stop_queue(dev);
 
diff --git a/drivers/net/tg3.h b/drivers/net/tg3.h
index 4d334cf5a243..bd9f4f428e5b 100644
--- a/drivers/net/tg3.h
+++ b/drivers/net/tg3.h
@@ -2228,7 +2228,7 @@ struct tg3 {
 #define TG3_FLAG_JUMBO_RING_ENABLE      0x00800000
 #define TG3_FLAG_10_100_ONLY            0x01000000
 #define TG3_FLAG_PAUSE_AUTONEG          0x02000000
-#define TG3_FLAG_IN_RESET_TASK          0x04000000
+
 #define TG3_FLAG_40BIT_DMA_BUG          0x08000000
 #define TG3_FLAG_BROKEN_CHECKSUMS       0x10000000
 #define TG3_FLAG_SUPPORT_MSI            0x20000000
diff --git a/drivers/net/tulip/interrupt.c b/drivers/net/tulip/interrupt.c
index 9b08afbd1f65..ea896777bcaf 100644
--- a/drivers/net/tulip/interrupt.c
+++ b/drivers/net/tulip/interrupt.c
@@ -269,7 +269,7 @@ done:
             This would turn on IM for devices that is not contributing
             to backlog congestion with unnecessary latency.
 
-             We monitor the the device RX-ring and have:
+             We monitor the device RX-ring and have:
 
              HW Interrupt Mitigation either ON or OFF.
 
diff --git a/drivers/net/tulip/winbond-840.c b/drivers/net/tulip/winbond-840.c
index fa440706fb4a..38f3b99716b8 100644
--- a/drivers/net/tulip/winbond-840.c
+++ b/drivers/net/tulip/winbond-840.c
@@ -1021,7 +1021,7 @@ static int start_tx(struct sk_buff *skb, struct net_device *dev)
                 np->tx_ring[entry].length |= DescEndRing;
 
         /* Now acquire the irq spinlock.
-         * The difficult race is the the ordering between
+         * The difficult race is the ordering between
          * increasing np->cur_tx and setting DescOwned:
          * - if np->cur_tx is increased first the interrupt
          *   handler could consider the packet as transmitted
diff --git a/drivers/net/tulip/xircom_cb.c b/drivers/net/tulip/xircom_cb.c
index 985a1810ca59..2470b1ee33c0 100644
--- a/drivers/net/tulip/xircom_cb.c
+++ b/drivers/net/tulip/xircom_cb.c
@@ -1043,7 +1043,7 @@ static int enable_promisc(struct xircom_private *card)
 
 
 /*
-link_status() checks the the links status and will return 0 for no link, 10 for 10mbit link and 100 for.. guess what.
+link_status() checks the links status and will return 0 for no link, 10 for 10mbit link and 100 for.. guess what.
 
 Must be called in locked state with interrupts disabled
 */
diff --git a/drivers/net/typhoon.c b/drivers/net/typhoon.c
index f2dd7763cd0b..f72573594121 100644
--- a/drivers/net/typhoon.c
+++ b/drivers/net/typhoon.c
@@ -639,7 +639,7 @@ typhoon_issue_command(struct typhoon *tp, int num_cmd, struct cmd_desc *cmd,
 
         typhoon_inc_cmd_index(&ring->lastWrite, num_cmd);
 
-        /* "I feel a presence... another warrior is on the the mesa."
+        /* "I feel a presence... another warrior is on the mesa."
          */
         wmb();
         iowrite32(ring->lastWrite, tp->ioaddr + TYPHOON_REG_CMD_READY);
diff --git a/drivers/net/wireless/airport.c b/drivers/net/wireless/airport.c
index 38fac3bbcd82..7d5b8c2cc614 100644
--- a/drivers/net/wireless/airport.c
+++ b/drivers/net/wireless/airport.c
@@ -149,7 +149,7 @@ static int airport_hard_reset(struct orinoco_private *priv)
         /* Vitally important.  If we don't do this it seems we get an
          * interrupt somewhere during the power cycle, since
          * hw_unavailable is already set it doesn't get ACKed, we get
-         * into an interrupt loop and the the PMU decides to turn us
+         * into an interrupt loop and the PMU decides to turn us
          * off. */
         disable_irq(dev->irq);
 
diff --git a/drivers/net/wireless/prism54/isl_ioctl.c b/drivers/net/wireless/prism54/isl_ioctl.c
index 841b3c136ad9..283be4a70524 100644
--- a/drivers/net/wireless/prism54/isl_ioctl.c
+++ b/drivers/net/wireless/prism54/isl_ioctl.c
@@ -3054,7 +3054,7 @@ static const iw_handler prism54_handler[] = {
         (iw_handler) prism54_set_wap,   /* SIOCSIWAP */
         (iw_handler) prism54_get_wap,   /* SIOCGIWAP */
         (iw_handler) NULL,      /* -- hole -- */
-        (iw_handler) NULL,      /* SIOCGIWAPLIST depreciated */
+        (iw_handler) NULL,      /* SIOCGIWAPLIST deprecated */
         (iw_handler) prism54_set_scan,  /* SIOCSIWSCAN */
         (iw_handler) prism54_get_scan,  /* SIOCGIWSCAN */
         (iw_handler) prism54_set_essid, /* SIOCSIWESSID */
diff --git a/drivers/net/wireless/prism54/islpci_dev.c b/drivers/net/wireless/prism54/islpci_dev.c
index a037b11dac9d..084795355b74 100644
--- a/drivers/net/wireless/prism54/islpci_dev.c
+++ b/drivers/net/wireless/prism54/islpci_dev.c
@@ -115,7 +115,7 @@ isl_upload_firmware(islpci_private *priv)
                             ISL38XX_MEMORY_WINDOW_SIZE : fw_len;
                         u32 __iomem *dev_fw_ptr = device_base + ISL38XX_DIRECT_MEM_WIN;
 
-                        /* set the cards base address for writting the data */
+                        /* set the card's base address for writing the data */
                         isl38xx_w32_flush(device_base, reg,
                                           ISL38XX_DIR_MEM_BASE_REG);
                         wmb();  /* be paranoid */
diff --git a/drivers/net/wireless/wavelan_cs.c b/drivers/net/wireless/wavelan_cs.c
index 67b867f837ca..5740d4d4267c 100644
--- a/drivers/net/wireless/wavelan_cs.c
+++ b/drivers/net/wireless/wavelan_cs.c
@@ -176,7 +176,7 @@ psa_write(struct net_device *	dev,
   volatile u_char __iomem *verify = lp->mem + PSA_ADDR +
     (psaoff(0, psa_comp_number) << 1);
 
-  /* Authorize writting to PSA */
+  /* Authorize writing to PSA */
   hacr_write(base, HACR_PWR_STAT | HACR_ROM_WEN);
 
   while(n-- > 0)
@@ -1676,7 +1676,7 @@ wv_set_frequency(u_long		base,	/* i/o port of the card */
       fee_write(base, 0x60,
                 dac, 2);
 
-      /* We now should verify here that the EEprom writting was ok */
+      /* We now should verify here that the EEprom writing was ok */
 
       /* ReRead the first area */
       fee_read(base, 0x00,
diff --git a/drivers/net/wireless/wavelan_cs.p.h b/drivers/net/wireless/wavelan_cs.p.h
index 4d1c4905c749..4b9de0093a7b 100644
--- a/drivers/net/wireless/wavelan_cs.p.h
+++ b/drivers/net/wireless/wavelan_cs.p.h
@@ -120,7 +120,7 @@
  * the Wavelan itself (NCR -> AT&T -> Lucent).
  *
  * All started with Anders Klemets <klemets@paul.rutgers.edu>,
- * writting a Wavelan ISA driver for the MACH microkernel. Girish
+ * writing a Wavelan ISA driver for the MACH microkernel. Girish
  * Welling <welling@paul.rutgers.edu> had also worked on it.
  * Keith Moore modify this for the Pcmcia hardware.
  * 
diff --git a/drivers/net/yellowfin.c b/drivers/net/yellowfin.c
index 3f4a7cf9efea..f2a90a7fa2d6 100644
--- a/drivers/net/yellowfin.c
+++ b/drivers/net/yellowfin.c
@@ -109,7 +109,6 @@ static int gx_fix;
 /* These identify the driver base version and may not be removed. */
 static char version[] __devinitdata =
 KERN_INFO DRV_NAME ".c:v1.05  1/09/2001  Written by Donald Becker <becker@scyld.com>\n"
-KERN_INFO "  http://www.scyld.com/network/yellowfin.html\n"
 KERN_INFO "  (unofficial 2.4.x port, " DRV_VERSION ", " DRV_RELDATE ")\n";
 
 MODULE_AUTHOR("Donald Becker <becker@scyld.com>");
diff --git a/drivers/pci/pci-driver.c b/drivers/pci/pci-driver.c
index 3bb7739d26a5..8e58ea3d95c0 100644
--- a/drivers/pci/pci-driver.c
+++ b/drivers/pci/pci-driver.c
@@ -119,7 +119,7 @@ static inline int pci_create_newid_file(struct pci_driver *drv)
  * system is in its list of supported devices.  Returns the matching
  * pci_device_id structure or %NULL if there is no match.
  *
- * Depreciated, don't use this as it will not catch any dynamic ids
+ * Deprecated, don't use this as it will not catch any dynamic ids
  * that a driver might want to check for.
  */
 const struct pci_device_id *pci_match_id(const struct pci_device_id *ids,
diff --git a/drivers/rtc/Kconfig b/drivers/rtc/Kconfig
index 5e439836db2d..76422eded36e 100644
--- a/drivers/rtc/Kconfig
+++ b/drivers/rtc/Kconfig
@@ -98,7 +98,7 @@ config RTC_INTF_DEV_UIE_EMUL
         bool "RTC UIE emulation on dev interface"
         depends on RTC_INTF_DEV
         help
-          Provides an emulation for RTC_UIE if the underlaying rtc chip
+          Provides an emulation for RTC_UIE if the underlying rtc chip
           driver does not expose RTC_UIE ioctls.  Those requests generate
           once-per-second update interrupts, used for synchronization.
 
diff --git a/drivers/s390/char/sclp_rw.c b/drivers/s390/char/sclp_rw.c
index bbd5b8b66f42..d6b06ab81188 100644
--- a/drivers/s390/char/sclp_rw.c
+++ b/drivers/s390/char/sclp_rw.c
@@ -23,7 +23,7 @@
 
 /*
  * The room for the SCCB (only for writing) is not equal to a pages size
- * (as it is specified as the maximum size in the the SCLP documentation)
+ * (as it is specified as the maximum size in the SCLP documentation)
  * because of the additional data structure described above.
  */
 #define MAX_SCCB_ROOM (PAGE_SIZE - sizeof(struct sclp_buffer))
diff --git a/drivers/s390/net/qeth_main.c b/drivers/s390/net/qeth_main.c
index 29d176036e5c..0b96d49dd636 100644
--- a/drivers/s390/net/qeth_main.c
+++ b/drivers/s390/net/qeth_main.c
@@ -2860,7 +2860,7 @@ qeth_flush_buffers(struct qeth_qdio_out_q *queue, int under_int,
                         if (!atomic_read(&queue->set_pci_flags_count)){
                                 /*
                                  * there's no outstanding PCI any more, so we
-                                 * have to request a PCI to be sure the the PCI
+                                 * have to request a PCI to be sure that the PCI
                                  * will wake at some time in the future then we
                                  * can flush packed buffers that might still be
                                  * hanging around, which can happen if no
diff --git a/drivers/s390/scsi/zfcp_aux.c b/drivers/s390/scsi/zfcp_aux.c
index 1f9554e08013..324899c96efe 100644
--- a/drivers/s390/scsi/zfcp_aux.c
+++ b/drivers/s390/scsi/zfcp_aux.c
@@ -118,97 +118,32 @@ _zfcp_hex_dump(char *addr, int count)
 
 #define ZFCP_LOG_AREA                   ZFCP_LOG_AREA_FSF
 
-static int zfcp_reqlist_init(struct zfcp_adapter *adapter)
+static int zfcp_reqlist_alloc(struct zfcp_adapter *adapter)
 {
-        int i;
+        int idx;
 
         adapter->req_list = kcalloc(REQUEST_LIST_SIZE, sizeof(struct list_head),
                                     GFP_KERNEL);
-
         if (!adapter->req_list)
                 return -ENOMEM;
 
-        for (i=0; i<REQUEST_LIST_SIZE; i++)
-                INIT_LIST_HEAD(&adapter->req_list[i]);
-
+        for (idx = 0; idx < REQUEST_LIST_SIZE; idx++)
+                INIT_LIST_HEAD(&adapter->req_list[idx]);
         return 0;
 }
 
 static void zfcp_reqlist_free(struct zfcp_adapter *adapter)
 {
-        struct zfcp_fsf_req *request, *tmp;
-        unsigned int i;
-
-        for (i=0; i<REQUEST_LIST_SIZE; i++) {
-                if (list_empty(&adapter->req_list[i]))
-                        continue;
-
-                list_for_each_entry_safe(request, tmp,
-                                         &adapter->req_list[i], list)
-                        list_del(&request->list);
-        }
-
         kfree(adapter->req_list);
 }
 
-void zfcp_reqlist_add(struct zfcp_adapter *adapter,
-                      struct zfcp_fsf_req *fsf_req)
-{
-        unsigned int i;
-
-        i = fsf_req->req_id % REQUEST_LIST_SIZE;
-        list_add_tail(&fsf_req->list, &adapter->req_list[i]);
-}
-
-void zfcp_reqlist_remove(struct zfcp_adapter *adapter, unsigned long req_id)
-{
-        struct zfcp_fsf_req *request, *tmp;
-        unsigned int i, counter;
-        u64 dbg_tmp[2];
-
-        i = req_id % REQUEST_LIST_SIZE;
-        BUG_ON(list_empty(&adapter->req_list[i]));
-
-        counter = 0;
-        list_for_each_entry_safe(request, tmp, &adapter->req_list[i], list) {
-                if (request->req_id == req_id) {
-                        dbg_tmp[0] = (u64) atomic_read(&adapter->reqs_active);
-                        dbg_tmp[1] = (u64) counter;
-                        debug_event(adapter->erp_dbf, 4, (void *) dbg_tmp, 16);
-                        list_del(&request->list);
-                        break;
-                }
-                counter++;
-        }
-}
-
-struct zfcp_fsf_req *zfcp_reqlist_ismember(struct zfcp_adapter *adapter,
-                                           unsigned long req_id)
-{
-        struct zfcp_fsf_req *request, *tmp;
-        unsigned int i;
-
-        /* 0 is reserved as an invalid req_id */
-        if (req_id == 0)
-                return NULL;
-
-        i = req_id % REQUEST_LIST_SIZE;
-
-        list_for_each_entry_safe(request, tmp, &adapter->req_list[i], list)
-                if (request->req_id == req_id)
-                        return request;
-
-        return NULL;
-}
-
 int zfcp_reqlist_isempty(struct zfcp_adapter *adapter)
 {
-        unsigned int i;
+        unsigned int idx;
 
-        for (i=0; i<REQUEST_LIST_SIZE; i++)
-                if (!list_empty(&adapter->req_list[i]))
+        for (idx = 0; idx < REQUEST_LIST_SIZE; idx++)
+                if (!list_empty(&adapter->req_list[idx]))
                         return 0;
-
         return 1;
 }
 
@@ -913,6 +848,8 @@ zfcp_unit_enqueue(struct zfcp_port *port, fcp_lun_t fcp_lun)
         unit->sysfs_device.release = zfcp_sysfs_unit_release;
         dev_set_drvdata(&unit->sysfs_device, unit);
 
+        init_waitqueue_head(&unit->scsi_scan_wq);
+
         /* mark unit unusable as long as sysfs registration is not complete */
         atomic_set_mask(ZFCP_STATUS_COMMON_REMOVE, &unit->status);
 
@@ -1104,7 +1041,7 @@ zfcp_adapter_enqueue(struct ccw_device *ccw_device)
 
         /* initialize list of fsf requests */
         spin_lock_init(&adapter->req_list_lock);
-        retval = zfcp_reqlist_init(adapter);
+        retval = zfcp_reqlist_alloc(adapter);
         if (retval) {
                 ZFCP_LOG_INFO("request list initialization failed\n");
                 goto failed_low_mem_buffers;
@@ -1165,6 +1102,7 @@ zfcp_adapter_enqueue(struct ccw_device *ccw_device)
         zfcp_sysfs_adapter_remove_files(&adapter->ccw_device->dev);
  sysfs_failed:
         dev_set_drvdata(&ccw_device->dev, NULL);
+        zfcp_reqlist_free(adapter);
  failed_low_mem_buffers:
         zfcp_free_low_mem_buffers(adapter);
         if (qdio_free(ccw_device) != 0)
@@ -1497,7 +1435,7 @@ zfcp_fsf_incoming_els_plogi(struct zfcp_adapter *adapter,
 
         if (!port || (port->wwpn != (*(wwn_t *) &els_plogi->serv_param.wwpn))) {
                 ZFCP_LOG_DEBUG("ignored incoming PLOGI for nonexisting port "
-                               "with d_id 0x%08x on adapter %s\n",
+                               "with d_id 0x%06x on adapter %s\n",
                                status_buffer->d_id,
                                zfcp_get_busid_by_adapter(adapter));
         } else {
@@ -1522,7 +1460,7 @@ zfcp_fsf_incoming_els_logo(struct zfcp_adapter *adapter,
 
         if (!port || (port->wwpn != els_logo->nport_wwpn)) {
                 ZFCP_LOG_DEBUG("ignored incoming LOGO for nonexisting port "
-                               "with d_id 0x%08x on adapter %s\n",
+                               "with d_id 0x%06x on adapter %s\n",
                                status_buffer->d_id,
                                zfcp_get_busid_by_adapter(adapter));
         } else {
@@ -1704,7 +1642,7 @@ static void zfcp_ns_gid_pn_handler(unsigned long data)
         /* looks like a valid d_id */
         port->d_id = ct_iu_resp->d_id & ZFCP_DID_MASK;
         atomic_set_mask(ZFCP_STATUS_PORT_DID_DID, &port->status);
-        ZFCP_LOG_DEBUG("adapter %s:  wwpn=0x%016Lx ---> d_id=0x%08x\n",
+        ZFCP_LOG_DEBUG("adapter %s:  wwpn=0x%016Lx ---> d_id=0x%06x\n",
                        zfcp_get_busid_by_port(port), port->wwpn, port->d_id);
         goto out;
 
diff --git a/drivers/s390/scsi/zfcp_def.h b/drivers/s390/scsi/zfcp_def.h
index 32933ed54b8a..22649639230b 100644
--- a/drivers/s390/scsi/zfcp_def.h
+++ b/drivers/s390/scsi/zfcp_def.h
@@ -637,6 +637,7 @@ do { \
 #define ZFCP_STATUS_UNIT_SHARED                 0x00000004
 #define ZFCP_STATUS_UNIT_READONLY               0x00000008
 #define ZFCP_STATUS_UNIT_REGISTERED             0x00000010
+#define ZFCP_STATUS_UNIT_SCSI_WORK_PENDING      0x00000020
 
 /* FSF request status (this does not have a common part) */
 #define ZFCP_STATUS_FSFREQ_NOT_INIT             0x00000000
@@ -980,6 +981,10 @@ struct zfcp_unit {
         struct scsi_device     *device;        /* scsi device struct pointer */
         struct zfcp_erp_action erp_action;     /* pending error recovery */
         atomic_t               erp_counter;
+        wait_queue_head_t      scsi_scan_wq;   /* can be used to wait until
+                                                  all scsi_scan_target
+                                                  requests have been
+                                                  completed. */
 };
 
 /* FSF request */
@@ -1085,6 +1090,42 @@ extern void _zfcp_hex_dump(char *, int);
 #define zfcp_get_busid_by_unit(unit) (zfcp_get_busid_by_port(unit->port))
 
 /*
+ * Helper functions for request ID management.
+ */
+static inline int zfcp_reqlist_hash(unsigned long req_id)
+{
+        return req_id % REQUEST_LIST_SIZE;
+}
+
+static inline void zfcp_reqlist_add(struct zfcp_adapter *adapter,
+                                    struct zfcp_fsf_req *fsf_req)
+{
+        unsigned int idx;
+
+        idx = zfcp_reqlist_hash(fsf_req->req_id);
+        list_add_tail(&fsf_req->list, &adapter->req_list[idx]);
+}
+
+static inline void zfcp_reqlist_remove(struct zfcp_adapter *adapter,
+                                       struct zfcp_fsf_req *fsf_req)
+{
+        list_del(&fsf_req->list);
+}
+
+static inline struct zfcp_fsf_req *
+zfcp_reqlist_find(struct zfcp_adapter *adapter, unsigned long req_id)
+{
+        struct zfcp_fsf_req *request;
+        unsigned int idx;
+
+        idx = zfcp_reqlist_hash(req_id);
+        list_for_each_entry(request, &adapter->req_list[idx], list)
+                if (request->req_id == req_id)
+                        return request;
+        return NULL;
+}
+
+/*
  *  functions needed for reference/usage counting
  */
 
diff --git a/drivers/s390/scsi/zfcp_erp.c b/drivers/s390/scsi/zfcp_erp.c
index c1f2d4b14c2b..aef66bc2b6ca 100644
--- a/drivers/s390/scsi/zfcp_erp.c
+++ b/drivers/s390/scsi/zfcp_erp.c
@@ -179,7 +179,7 @@ static void zfcp_close_fsf(struct zfcp_adapter *adapter)
 static void zfcp_fsf_request_timeout_handler(unsigned long data)
 {
         struct zfcp_adapter *adapter = (struct zfcp_adapter *) data;
-        zfcp_erp_adapter_reopen(adapter, 0);
+        zfcp_erp_adapter_reopen(adapter, ZFCP_STATUS_COMMON_ERP_FAILED);
 }
 
 void zfcp_fsf_start_timer(struct zfcp_fsf_req *fsf_req, unsigned long timeout)
@@ -342,9 +342,9 @@ zfcp_erp_adisc(struct zfcp_port *port)
         adisc->wwpn = fc_host_port_name(adapter->scsi_host);
         adisc->wwnn = fc_host_node_name(adapter->scsi_host);
         adisc->nport_id = fc_host_port_id(adapter->scsi_host);
-        ZFCP_LOG_INFO("ADISC request from s_id 0x%08x to d_id 0x%08x "
+        ZFCP_LOG_INFO("ADISC request from s_id 0x%06x to d_id 0x%06x "
                       "(wwpn=0x%016Lx, wwnn=0x%016Lx, "
-                      "hard_nport_id=0x%08x, nport_id=0x%08x)\n",
+                      "hard_nport_id=0x%06x, nport_id=0x%06x)\n",
                       adisc->nport_id, send_els->d_id, (wwn_t) adisc->wwpn,
                       (wwn_t) adisc->wwnn, adisc->hard_nport_id,
                       adisc->nport_id);
@@ -352,7 +352,7 @@ zfcp_erp_adisc(struct zfcp_port *port)
         retval = zfcp_fsf_send_els(send_els);
         if (retval != 0) {
                 ZFCP_LOG_NORMAL("error: initiation of Send ELS failed for port "
-                                "0x%08x on adapter %s\n", send_els->d_id,
+                                "0x%06x on adapter %s\n", send_els->d_id,
                                 zfcp_get_busid_by_adapter(adapter));
                 goto freemem;
         }
@@ -398,7 +398,7 @@ zfcp_erp_adisc_handler(unsigned long data)
         if (send_els->status != 0) {
                 ZFCP_LOG_NORMAL("ELS request rejected/timed out, "
                                 "force physical port reopen "
-                                "(adapter %s, port d_id=0x%08x)\n",
+                                "(adapter %s, port d_id=0x%06x)\n",
                                 zfcp_get_busid_by_adapter(adapter), d_id);
                 debug_text_event(adapter->erp_dbf, 3, "forcreop");
                 if (zfcp_erp_port_forced_reopen(port, 0))
@@ -411,9 +411,9 @@ zfcp_erp_adisc_handler(unsigned long data)
 
         adisc = zfcp_sg_to_address(send_els->resp);
 
-        ZFCP_LOG_INFO("ADISC response from d_id 0x%08x to s_id "
-                      "0x%08x (wwpn=0x%016Lx, wwnn=0x%016Lx, "
-                      "hard_nport_id=0x%08x, nport_id=0x%08x)\n",
+        ZFCP_LOG_INFO("ADISC response from d_id 0x%06x to s_id "
+                      "0x%06x (wwpn=0x%016Lx, wwnn=0x%016Lx, "
+                      "hard_nport_id=0x%06x, nport_id=0x%06x)\n",
                       d_id, fc_host_port_id(adapter->scsi_host),
                       (wwn_t) adisc->wwpn, (wwn_t) adisc->wwnn,
                       adisc->hard_nport_id, adisc->nport_id);
@@ -847,8 +847,7 @@ zfcp_erp_strategy_check_fsfreq(struct zfcp_erp_action *erp_action)
         if (erp_action->fsf_req) {
                 /* take lock to ensure that request is not deleted meanwhile */
                 spin_lock(&adapter->req_list_lock);
-                if (zfcp_reqlist_ismember(adapter,
-                                            erp_action->fsf_req->req_id)) {
+                if (zfcp_reqlist_find(adapter, erp_action->fsf_req->req_id)) {
                         /* fsf_req still exists */
                         debug_text_event(adapter->erp_dbf, 3, "a_ca_req");
                         debug_event(adapter->erp_dbf, 3, &erp_action->fsf_req,
@@ -1377,7 +1376,7 @@ zfcp_erp_port_failed(struct zfcp_port *port)
 
         if (atomic_test_mask(ZFCP_STATUS_PORT_WKA, &port->status))
                 ZFCP_LOG_NORMAL("port erp failed (adapter %s, "
-                                "port d_id=0x%08x)\n",
+                                "port d_id=0x%06x)\n",
                                 zfcp_get_busid_by_port(port), port->d_id);
         else
                 ZFCP_LOG_NORMAL("port erp failed (adapter %s, wwpn=0x%016Lx)\n",
@@ -1591,6 +1590,62 @@ zfcp_erp_strategy_check_adapter(struct zfcp_adapter *adapter, int result)
         return result;
 }
 
+struct zfcp_erp_add_work {
+        struct zfcp_unit  *unit;
+        struct work_struct work;
+};
+
+/**
+ * zfcp_erp_scsi_scan
+ * @data: pointer to a struct zfcp_erp_add_work
+ *
+ * Registers a logical unit with the SCSI stack.
+ */
+static void zfcp_erp_scsi_scan(struct work_struct *work)
+{
+        struct zfcp_erp_add_work *p =
+                container_of(work, struct zfcp_erp_add_work, work);
+        struct zfcp_unit *unit = p->unit;
+        struct fc_rport *rport = unit->port->rport;
+        scsi_scan_target(&rport->dev, 0, rport->scsi_target_id,
+                         unit->scsi_lun, 0);
+        atomic_clear_mask(ZFCP_STATUS_UNIT_SCSI_WORK_PENDING, &unit->status);
+        wake_up(&unit->scsi_scan_wq);
+        zfcp_unit_put(unit);
+        kfree(p);
+}
+
+/**
+ * zfcp_erp_schedule_work
+ * @unit: pointer to unit which should be registered with SCSI stack
+ *
+ * Schedules work which registers a unit with the SCSI stack
+ */
+static void
+zfcp_erp_schedule_work(struct zfcp_unit *unit)
+{
+        struct zfcp_erp_add_work *p;
+
+        p = kmalloc(sizeof(*p), GFP_KERNEL);
+        if (!p) {
+                ZFCP_LOG_NORMAL("error: Out of resources. Could not register "
+                                "the FCP-LUN 0x%Lx connected to "
+                                "the port with WWPN 0x%Lx connected to "
+                                "the adapter %s with the SCSI stack.\n",
+                                unit->fcp_lun,
+                                unit->port->wwpn,
+                                zfcp_get_busid_by_unit(unit));
+                return;
+        }
+
+        zfcp_unit_get(unit);
+        memset(p, 0, sizeof(*p));
+        atomic_set_mask(ZFCP_STATUS_UNIT_SCSI_WORK_PENDING, &unit->status);
+        INIT_WORK(&p->work, zfcp_erp_scsi_scan);
+        p->unit = unit;
+        schedule_work(&p->work);
+}
+
 /*
  * function:    
  *
@@ -2401,7 +2456,7 @@ zfcp_erp_port_strategy_open_common(struct zfcp_erp_action *erp_action)
                                 retval = ZFCP_ERP_FAILED;
                         }
                 } else {
-                        ZFCP_LOG_DEBUG("port 0x%016Lx has d_id=0x%08x -> "
+                        ZFCP_LOG_DEBUG("port 0x%016Lx has d_id=0x%06x -> "
                                        "trying open\n", port->wwpn, port->d_id);
                         retval = zfcp_erp_port_strategy_open_port(erp_action);
                 }
@@ -2441,7 +2496,7 @@ zfcp_erp_port_strategy_open_nameserver(struct zfcp_erp_action *erp_action)
         case ZFCP_ERP_STEP_UNINITIALIZED:
         case ZFCP_ERP_STEP_PHYS_PORT_CLOSING:
         case ZFCP_ERP_STEP_PORT_CLOSING:
-                ZFCP_LOG_DEBUG("port 0x%016Lx has d_id=0x%08x -> trying open\n",
+                ZFCP_LOG_DEBUG("port 0x%016Lx has d_id=0x%06x -> trying open\n",
                                port->wwpn, port->d_id);
                 retval = zfcp_erp_port_strategy_open_port(erp_action);
                 break;
@@ -3092,9 +3147,9 @@ zfcp_erp_action_cleanup(int action, struct zfcp_adapter *adapter,
                     && port->rport) {
                         atomic_set_mask(ZFCP_STATUS_UNIT_REGISTERED,
                                         &unit->status);
-                        scsi_scan_target(&port->rport->dev, 0,
-                                         port->rport->scsi_target_id,
-                                         unit->scsi_lun, 0);
+                        if (atomic_test_mask(ZFCP_STATUS_UNIT_SCSI_WORK_PENDING,
+                                             &unit->status) == 0)
+                                zfcp_erp_schedule_work(unit);
                 }
                 zfcp_unit_put(unit);
                 break;
@@ -3121,7 +3176,7 @@ zfcp_erp_action_cleanup(int action, struct zfcp_adapter *adapter,
                                                 zfcp_get_busid_by_port(port),
                                                 port->wwpn);
                         else {
-                                scsi_flush_work(adapter->scsi_host);
+                                scsi_target_unblock(&port->rport->dev);
                                 port->rport->maxframe_size = port->maxframe_size;
                                 port->rport->supported_classes =
                                         port->supported_classes;
diff --git a/drivers/s390/scsi/zfcp_ext.h b/drivers/s390/scsi/zfcp_ext.h
index 01386ac688a2..991d45667a44 100644
--- a/drivers/s390/scsi/zfcp_ext.h
+++ b/drivers/s390/scsi/zfcp_ext.h
@@ -184,10 +184,6 @@ extern void zfcp_scsi_dbf_event_abort(const char *, struct zfcp_adapter *,
                                       unsigned long);
 extern void zfcp_scsi_dbf_event_devreset(const char *, u8, struct zfcp_unit *,
                                          struct scsi_cmnd *);
-extern void zfcp_reqlist_add(struct zfcp_adapter *, struct zfcp_fsf_req *);
-extern void zfcp_reqlist_remove(struct zfcp_adapter *, unsigned long);
-extern struct zfcp_fsf_req *zfcp_reqlist_ismember(struct zfcp_adapter *,
-                                                  unsigned long);
 extern int zfcp_reqlist_isempty(struct zfcp_adapter *);
 
 #endif  /* ZFCP_EXT_H */
diff --git a/drivers/s390/scsi/zfcp_fsf.c b/drivers/s390/scsi/zfcp_fsf.c
index 4c0a59afd5c8..a8b02542ac2d 100644
--- a/drivers/s390/scsi/zfcp_fsf.c
+++ b/drivers/s390/scsi/zfcp_fsf.c
@@ -828,7 +828,7 @@ zfcp_fsf_status_read_port_closed(struct zfcp_fsf_req *fsf_req)
 
         if (!port || (port->d_id != (status_buffer->d_id & ZFCP_DID_MASK))) {
                 ZFCP_LOG_NORMAL("bug: Reopen port indication received for"
-                                "nonexisting port with d_id 0x%08x on "
+                                "nonexisting port with d_id 0x%06x on "
                                 "adapter %s. Ignored.\n",
                                 status_buffer->d_id & ZFCP_DID_MASK,
                                 zfcp_get_busid_by_adapter(adapter));
@@ -853,7 +853,7 @@ zfcp_fsf_status_read_port_closed(struct zfcp_fsf_req *fsf_req)
                                 &status_buffer->status_subtype, sizeof (u32));
                 ZFCP_LOG_NORMAL("bug: Undefined status subtype received "
                                 "for a reopen indication on port with "
-                                "d_id 0x%08x on the adapter %s. "
+                                "d_id 0x%06x on the adapter %s. "
                                 "Ignored. (debug info 0x%x)\n",
                                 status_buffer->d_id,
                                 zfcp_get_busid_by_adapter(adapter),
@@ -1156,7 +1156,7 @@ zfcp_fsf_abort_fcp_command(unsigned long old_req_id,
         }
 
         ZFCP_LOG_DEBUG("Abort FCP Command request initiated "
-                       "(adapter%s, port d_id=0x%08x, "
+                       "(adapter%s, port d_id=0x%06x, "
                        "unit x%016Lx, old_req_id=0x%lx)\n",
                        zfcp_get_busid_by_adapter(adapter),
                        unit->port->d_id,
@@ -1554,7 +1554,7 @@ zfcp_fsf_send_ct_handler(struct zfcp_fsf_req *fsf_req)
 
         case FSF_ACCESS_DENIED:
                 ZFCP_LOG_NORMAL("access denied, cannot send generic service "
-                                "command (adapter %s, port d_id=0x%08x)\n",
+                                "command (adapter %s, port d_id=0x%06x)\n",
                                 zfcp_get_busid_by_port(port), port->d_id);
                 for (counter = 0; counter < 2; counter++) {
                         subtable = header->fsf_status_qual.halfword[counter * 2];
@@ -1576,7 +1576,7 @@ zfcp_fsf_send_ct_handler(struct zfcp_fsf_req *fsf_req)
 
         case FSF_GENERIC_COMMAND_REJECTED:
                 ZFCP_LOG_INFO("generic service command rejected "
-                              "(adapter %s, port d_id=0x%08x)\n",
+                              "(adapter %s, port d_id=0x%06x)\n",
                               zfcp_get_busid_by_port(port), port->d_id);
                 ZFCP_LOG_INFO("status qualifier:\n");
                 ZFCP_HEX_DUMP(ZFCP_LOG_LEVEL_INFO,
@@ -1602,7 +1602,7 @@ zfcp_fsf_send_ct_handler(struct zfcp_fsf_req *fsf_req)
 
         case FSF_PORT_BOXED:
                 ZFCP_LOG_INFO("port needs to be reopened "
-                              "(adapter %s, port d_id=0x%08x)\n",
+                              "(adapter %s, port d_id=0x%06x)\n",
                               zfcp_get_busid_by_port(port), port->d_id);
                 debug_text_event(adapter->erp_dbf, 2, "fsf_s_pboxed");
                 zfcp_erp_port_boxed(port);
@@ -1683,7 +1683,7 @@ zfcp_fsf_send_els(struct zfcp_send_els *els)
                                   NULL, &lock_flags, &fsf_req);
         if (ret < 0) {
                 ZFCP_LOG_INFO("error: creation of ELS request failed "
-                              "(adapter %s, port d_id: 0x%08x)\n",
+                              "(adapter %s, port d_id: 0x%06x)\n",
                               zfcp_get_busid_by_adapter(adapter), d_id);
                 goto failed_req;
         }
@@ -1708,7 +1708,7 @@ zfcp_fsf_send_els(struct zfcp_send_els *els)
                                                 ZFCP_MAX_SBALS_PER_ELS_REQ);
                 if (bytes <= 0) {
                         ZFCP_LOG_INFO("error: creation of ELS request failed "
-                                      "(adapter %s, port d_id: 0x%08x)\n",
+                                      "(adapter %s, port d_id: 0x%06x)\n",
                                       zfcp_get_busid_by_adapter(adapter), d_id);
                         if (bytes == 0) {
                                 ret = -ENOMEM;
@@ -1725,7 +1725,7 @@ zfcp_fsf_send_els(struct zfcp_send_els *els)
                                                 ZFCP_MAX_SBALS_PER_ELS_REQ);
                 if (bytes <= 0) {
                         ZFCP_LOG_INFO("error: creation of ELS request failed "
-                                      "(adapter %s, port d_id: 0x%08x)\n",
+                                      "(adapter %s, port d_id: 0x%06x)\n",
                                       zfcp_get_busid_by_adapter(adapter), d_id);
                         if (bytes == 0) {
                                 ret = -ENOMEM;
@@ -1739,7 +1739,7 @@ zfcp_fsf_send_els(struct zfcp_send_els *els)
                 /* reject request */
                 ZFCP_LOG_INFO("error: microcode does not support chained SBALs"
                               ", ELS request too big (adapter %s, "
-                              "port d_id: 0x%08x)\n",
+                              "port d_id: 0x%06x)\n",
                               zfcp_get_busid_by_adapter(adapter), d_id);
                 ret = -EOPNOTSUPP;
                 goto failed_send;
@@ -1760,13 +1760,13 @@ zfcp_fsf_send_els(struct zfcp_send_els *els)
         ret = zfcp_fsf_req_send(fsf_req);
         if (ret) {
                 ZFCP_LOG_DEBUG("error: initiation of ELS request failed "
-                               "(adapter %s, port d_id: 0x%08x)\n",
+                               "(adapter %s, port d_id: 0x%06x)\n",
                                zfcp_get_busid_by_adapter(adapter), d_id);
                 goto failed_send;
         }
 
         ZFCP_LOG_DEBUG("ELS request initiated (adapter %s, port d_id: "
-                       "0x%08x)\n", zfcp_get_busid_by_adapter(adapter), d_id);
+                       "0x%06x)\n", zfcp_get_busid_by_adapter(adapter), d_id);
         goto out;
 
  failed_send:
@@ -1859,7 +1859,7 @@ static int zfcp_fsf_send_els_handler(struct zfcp_fsf_req *fsf_req)
         case FSF_ELS_COMMAND_REJECTED:
                 ZFCP_LOG_INFO("ELS has been rejected because command filter "
                               "prohibited sending "
-                              "(adapter: %s, port d_id: 0x%08x)\n",
+                              "(adapter: %s, port d_id: 0x%06x)\n",
                               zfcp_get_busid_by_adapter(adapter), d_id);
 
                 break;
@@ -1907,7 +1907,7 @@ static int zfcp_fsf_send_els_handler(struct zfcp_fsf_req *fsf_req)
 
         case FSF_ACCESS_DENIED:
                 ZFCP_LOG_NORMAL("access denied, cannot send ELS command "
-                                "(adapter %s, port d_id=0x%08x)\n",
+                                "(adapter %s, port d_id=0x%06x)\n",
                                 zfcp_get_busid_by_adapter(adapter), d_id);
                 for (counter = 0; counter < 2; counter++) {
                         subtable = header->fsf_status_qual.halfword[counter * 2];
@@ -2070,7 +2070,7 @@ zfcp_fsf_exchange_config_evaluate(struct zfcp_fsf_req *fsf_req, int xchg_ok)
         ZFCP_LOG_NORMAL("The adapter %s reported the following characteristics:\n"
                         "WWNN 0x%016Lx, "
                         "WWPN 0x%016Lx, "
-                        "S_ID 0x%08x,\n"
+                        "S_ID 0x%06x,\n"
                         "adapter version 0x%x, "
                         "LIC version 0x%x, "
                         "FC link speed %d Gb/s\n",
@@ -3043,6 +3043,7 @@ zfcp_fsf_open_unit_handler(struct zfcp_fsf_req *fsf_req)
         queue_designator = &header->fsf_status_qual.fsf_queue_designator;
 
         atomic_clear_mask(ZFCP_STATUS_COMMON_ACCESS_DENIED |
+                          ZFCP_STATUS_COMMON_ACCESS_BOXED |
                           ZFCP_STATUS_UNIT_SHARED |
                           ZFCP_STATUS_UNIT_READONLY,
                           &unit->status);
@@ -4645,23 +4646,22 @@ zfcp_fsf_req_create(struct zfcp_adapter *adapter, u32 fsf_cmd, int req_flags,
         fsf_req->adapter = adapter;
         fsf_req->fsf_command = fsf_cmd;
         INIT_LIST_HEAD(&fsf_req->list);
-        
-        /* this is serialized (we are holding req_queue-lock of adapter */
-        if (adapter->req_no == 0)
-                adapter->req_no++;
-        fsf_req->req_id = adapter->req_no++;
-
         init_timer(&fsf_req->timer);
-        zfcp_fsf_req_qtcb_init(fsf_req);
 
         /* initialize waitqueue which may be used to wait on 
            this request completion */
         init_waitqueue_head(&fsf_req->completion_wq);
 
         ret = zfcp_fsf_req_sbal_get(adapter, req_flags, lock_flags);
-        if(ret < 0) {
+        if (ret < 0)
                 goto failed_sbals;
-        }
+
+        /* this is serialized (we are holding req_queue-lock of adapter) */
+        if (adapter->req_no == 0)
+                adapter->req_no++;
+        fsf_req->req_id = adapter->req_no++;
+
+        zfcp_fsf_req_qtcb_init(fsf_req);
 
         /*
          * We hold queue_lock here. Check if QDIOUP is set and let request fail
@@ -4788,7 +4788,7 @@ static int zfcp_fsf_req_send(struct zfcp_fsf_req *fsf_req)
                 retval = -EIO;
                 del_timer(&fsf_req->timer);
                 spin_lock(&adapter->req_list_lock);
-                zfcp_reqlist_remove(adapter, fsf_req->req_id);
+                zfcp_reqlist_remove(adapter, fsf_req);
                 spin_unlock(&adapter->req_list_lock);
                 /* undo changes in request queue made for this request */
                 zfcp_qdio_zero_sbals(req_queue->buffer,
diff --git a/drivers/s390/scsi/zfcp_qdio.c b/drivers/s390/scsi/zfcp_qdio.c
index 1e12a78e8edd..bdf5782b8a7a 100644
--- a/drivers/s390/scsi/zfcp_qdio.c
+++ b/drivers/s390/scsi/zfcp_qdio.c
@@ -222,7 +222,7 @@ zfcp_qdio_handler_error_check(struct zfcp_adapter *adapter, unsigned int status,
                 * Since we have been using this adapter, it is save to assume
                 * that it is not failed but recoverable. The card seems to
                 * report link-up events by self-initiated queue shutdown.
-                * That is why we need to clear the the link-down flag
+                * That is why we need to clear the link-down flag
                 * which is set again in case we have missed by a mile.
                 */
                zfcp_erp_adapter_reopen(
@@ -283,10 +283,10 @@ zfcp_qdio_request_handler(struct ccw_device *ccw_device,
 }
 
 /**
- * zfcp_qdio_reqid_check - checks for valid reqids or unsolicited status
+ * zfcp_qdio_reqid_check - checks for valid reqids.
  */
-static int zfcp_qdio_reqid_check(struct zfcp_adapter *adapter, 
-                                 unsigned long req_id)
+static void zfcp_qdio_reqid_check(struct zfcp_adapter *adapter,
+                                  unsigned long req_id)
 {
         struct zfcp_fsf_req *fsf_req;
         unsigned long flags;
@@ -294,23 +294,22 @@ static int zfcp_qdio_reqid_check(struct zfcp_adapter *adapter,
         debug_long_event(adapter->erp_dbf, 4, req_id);
 
         spin_lock_irqsave(&adapter->req_list_lock, flags);
-        fsf_req = zfcp_reqlist_ismember(adapter, req_id);
+        fsf_req = zfcp_reqlist_find(adapter, req_id);
 
-        if (!fsf_req) {
-                spin_unlock_irqrestore(&adapter->req_list_lock, flags);
-                ZFCP_LOG_NORMAL("error: unknown request id (%ld).\n", req_id);
-                zfcp_erp_adapter_reopen(adapter, 0);
-                return -EINVAL;
-        }
+        if (!fsf_req)
+                /*
+                 * Unknown request means that we have potentially memory
+                 * corruption and must stop the machine immediatly.
+                 */
+                panic("error: unknown request id (%ld) on adapter %s.\n",
+                      req_id, zfcp_get_busid_by_adapter(adapter));
 
-        zfcp_reqlist_remove(adapter, req_id);
+        zfcp_reqlist_remove(adapter, fsf_req);
         atomic_dec(&adapter->reqs_active);
         spin_unlock_irqrestore(&adapter->req_list_lock, flags);
 
         /* finish the FSF request */
         zfcp_fsf_req_complete(fsf_req);
-
-        return 0;
 }
 
 /*
@@ -374,27 +373,9 @@ zfcp_qdio_response_handler(struct ccw_device *ccw_device,
 
                         /* look for QDIO request identifiers in SB */
                         buffere = &buffer->element[buffere_index];
-                        retval = zfcp_qdio_reqid_check(adapter,
-                                        (unsigned long) buffere->addr);
-
-                        if (retval) {
-                                ZFCP_LOG_NORMAL("bug: unexpected inbound "
-                                                "packet on adapter %s "
-                                                "(reqid=0x%lx, "
-                                                "first_element=%d, "
-                                                "elements_processed=%d)\n",
-                                                zfcp_get_busid_by_adapter(adapter),
-                                                (unsigned long) buffere->addr,
-                                                first_element,
-                                                elements_processed);
-                                ZFCP_LOG_NORMAL("hex dump of inbound buffer "
-                                                "at address %p "
-                                                "(buffer_index=%d, "
-                                                "buffere_index=%d)\n", buffer,
-                                                buffer_index, buffere_index);
-                                ZFCP_HEX_DUMP(ZFCP_LOG_LEVEL_NORMAL,
-                                              (char *) buffer, SBAL_SIZE);
-                        }
+                        zfcp_qdio_reqid_check(adapter,
+                                              (unsigned long) buffere->addr);
+
                         /*
                          * A single used SBALE per inbound SBALE has been
                          * implemented by QDIO so far. Hope they will
diff --git a/drivers/s390/scsi/zfcp_scsi.c b/drivers/s390/scsi/zfcp_scsi.c
index 99db02062c3b..16e2d64658af 100644
--- a/drivers/s390/scsi/zfcp_scsi.c
+++ b/drivers/s390/scsi/zfcp_scsi.c
@@ -22,6 +22,7 @@
 #define ZFCP_LOG_AREA                   ZFCP_LOG_AREA_SCSI
 
 #include "zfcp_ext.h"
+#include <asm/atomic.h>
 
 static void zfcp_scsi_slave_destroy(struct scsi_device *sdp);
 static int zfcp_scsi_slave_alloc(struct scsi_device *sdp);
@@ -179,6 +180,10 @@ static void zfcp_scsi_slave_destroy(struct scsi_device *sdpnt)
         struct zfcp_unit *unit = (struct zfcp_unit *) sdpnt->hostdata;
 
         if (unit) {
+                zfcp_erp_wait(unit->port->adapter);
+                wait_event(unit->scsi_scan_wq,
+                           atomic_test_mask(ZFCP_STATUS_UNIT_SCSI_WORK_PENDING,
+                                            &unit->status) == 0);
                 atomic_clear_mask(ZFCP_STATUS_UNIT_REGISTERED, &unit->status);
                 sdpnt->hostdata = NULL;
                 unit->device = NULL;
@@ -402,8 +407,8 @@ static int zfcp_scsi_eh_abort_handler(struct scsi_cmnd *scpnt)
 
         /* Check whether corresponding fsf_req is still pending */
         spin_lock(&adapter->req_list_lock);
-        fsf_req = zfcp_reqlist_ismember(adapter, (unsigned long)
-                                        scpnt->host_scribble);
+        fsf_req = zfcp_reqlist_find(adapter,
+                                    (unsigned long) scpnt->host_scribble);
         spin_unlock(&adapter->req_list_lock);
         if (!fsf_req) {
                 write_unlock_irqrestore(&adapter->abort_lock, flags);
diff --git a/drivers/sbus/char/bpp.c b/drivers/sbus/char/bpp.c
index 74b999d77bbf..4fab0c23814c 100644
--- a/drivers/sbus/char/bpp.c
+++ b/drivers/sbus/char/bpp.c
@@ -156,7 +156,7 @@ static unsigned short get_pins(unsigned minor)
 #define BPP_ICR      0x18
 #define BPP_SIZE     0x1A
 
-/* BPP_CSR.  Bits of type RW1 are cleared with writting '1'. */
+/* BPP_CSR.  Bits of type RW1 are cleared with writing '1'. */
 #define P_DEV_ID_MASK   0xf0000000      /* R   */
 #define P_DEV_ID_ZEBRA  0x40000000
 #define P_DEV_ID_L64854 0xa0000000      /*      == NCR 89C100+89C105. Pity. */
diff --git a/drivers/scsi/aacraid/comminit.c b/drivers/scsi/aacraid/comminit.c
index 33682ce96a5d..3009ad8c4073 100644
--- a/drivers/scsi/aacraid/comminit.c
+++ b/drivers/scsi/aacraid/comminit.c
@@ -387,12 +387,11 @@ struct aac_dev *aac_init_adapter(struct aac_dev *dev)
          *      Ok now init the communication subsystem
          */
 
-        dev->queues = kmalloc(sizeof(struct aac_queue_block), GFP_KERNEL);
+        dev->queues = kzalloc(sizeof(struct aac_queue_block), GFP_KERNEL);
         if (dev->queues == NULL) {
                 printk(KERN_ERR "Error could not allocate comm region.\n");
                 return NULL;
         }
-        memset(dev->queues, 0, sizeof(struct aac_queue_block));
 
         if (aac_comm_init(dev)<0){
                 kfree(dev->queues);
diff --git a/drivers/scsi/aacraid/commsup.c b/drivers/scsi/aacraid/commsup.c
index 5824a757a753..9aca57eda943 100644
--- a/drivers/scsi/aacraid/commsup.c
+++ b/drivers/scsi/aacraid/commsup.c
@@ -1223,13 +1223,11 @@ int aac_check_health(struct aac_dev * aac)
                  * Warning: no sleep allowed while
                  * holding spinlock
                  */
-                hw_fib = kmalloc(sizeof(struct hw_fib), GFP_ATOMIC);
-                fib = kmalloc(sizeof(struct fib), GFP_ATOMIC);
+                hw_fib = kzalloc(sizeof(struct hw_fib), GFP_ATOMIC);
+                fib = kzalloc(sizeof(struct fib), GFP_ATOMIC);
                 if (fib && hw_fib) {
                         struct aac_aifcmd * aif;
 
-                        memset(hw_fib, 0, sizeof(struct hw_fib));
-                        memset(fib, 0, sizeof(struct fib));
                         fib->hw_fib_va = hw_fib;
                         fib->dev = aac;
                         aac_fib_init(fib);
diff --git a/drivers/scsi/aacraid/dpcsup.c b/drivers/scsi/aacraid/dpcsup.c
index 42c7dcda6d9b..fcd25f7d0bc6 100644
--- a/drivers/scsi/aacraid/dpcsup.c
+++ b/drivers/scsi/aacraid/dpcsup.c
@@ -248,16 +248,14 @@ unsigned int aac_intr_normal(struct aac_dev * dev, u32 Index)
                  * manage the linked lists.
                  */
                 if ((!dev->aif_thread)
-                 || (!(fib = kmalloc(sizeof(struct fib),GFP_ATOMIC))))
+                 || (!(fib = kzalloc(sizeof(struct fib),GFP_ATOMIC))))
                         return 1;
-                if (!(hw_fib = kmalloc(sizeof(struct hw_fib),GFP_ATOMIC))) {
+                if (!(hw_fib = kzalloc(sizeof(struct hw_fib),GFP_ATOMIC))) {
                         kfree (fib);
                         return 1;
                 }
-                memset(hw_fib, 0, sizeof(struct hw_fib));
                 memcpy(hw_fib, (struct hw_fib *)(((ptrdiff_t)(dev->regs.sa)) +
                   (index & ~0x00000002L)), sizeof(struct hw_fib));
-                memset(fib, 0, sizeof(struct fib));
                 INIT_LIST_HEAD(&fib->fiblink);
                 fib->type = FSAFS_NTC_FIB_CONTEXT;
                 fib->size = sizeof(struct fib);
diff --git a/drivers/scsi/aacraid/rx.c b/drivers/scsi/aacraid/rx.c
index 0c71315cbf1a..291cd14f4e98 100644
--- a/drivers/scsi/aacraid/rx.c
+++ b/drivers/scsi/aacraid/rx.c
@@ -539,8 +539,10 @@ int _aac_rx_init(struct aac_dev *dev)
         }
 
         /* Failure to reset here is an option ... */
+        dev->a_ops.adapter_sync_cmd = rx_sync_cmd;
+        dev->a_ops.adapter_enable_int = aac_rx_disable_interrupt;
         dev->OIMR = status = rx_readb (dev, MUnit.OIMR);
-        if ((((status & 0xff) != 0xff) || reset_devices) &&
+        if ((((status & 0x0c) != 0x0c) || reset_devices) &&
           !aac_rx_restart_adapter(dev, 0))
                 ++restart;
         /*
diff --git a/drivers/scsi/aic7xxx/aic79xx_pci.c b/drivers/scsi/aic7xxx/aic79xx_pci.c
index 8d72bbae96ad..0bada0028aa0 100644
--- a/drivers/scsi/aic7xxx/aic79xx_pci.c
+++ b/drivers/scsi/aic7xxx/aic79xx_pci.c
@@ -966,7 +966,7 @@ ahd_aic790X_setup(struct ahd_softc *ahd)
                               |  AHD_BUSFREEREV_BUG;
                 ahd->bugs |= AHD_LQOOVERRUN_BUG|AHD_EARLY_REQ_BUG;
 
-                /* If the user requested the the SLOWCRC bit to be set. */
+                /* If the user requested that the SLOWCRC bit to be set. */
                 if (aic79xx_slowcrc)
                         ahd->features |= AHD_AIC79XXB_SLOWCRC;
 
diff --git a/drivers/scsi/aic94xx/Makefile b/drivers/scsi/aic94xx/Makefile
index e6b70123940c..e78ce0fa44d2 100644
--- a/drivers/scsi/aic94xx/Makefile
+++ b/drivers/scsi/aic94xx/Makefile
@@ -6,7 +6,7 @@
 #
 # This file is licensed under GPLv2.
 #
-# This file is part of the the aic94xx driver.
+# This file is part of the aic94xx driver.
 #
 # The aic94xx driver is free software; you can redistribute it and/or
 # modify it under the terms of the GNU General Public License as
diff --git a/drivers/scsi/ch.c b/drivers/scsi/ch.c
index 2a2cc6cf1182..2311019304c0 100644
--- a/drivers/scsi/ch.c
+++ b/drivers/scsi/ch.c
@@ -319,10 +319,9 @@ ch_readconfig(scsi_changer *ch)
         int     result,id,lun,i;
         u_int   elem;
 
-        buffer = kmalloc(512, GFP_KERNEL | GFP_DMA);
+        buffer = kzalloc(512, GFP_KERNEL | GFP_DMA);
         if (!buffer)
                 return -ENOMEM;
-        memset(buffer,0,512);
         
         memset(cmd,0,sizeof(cmd));
         cmd[0] = MODE_SENSE;
@@ -530,10 +529,9 @@ ch_set_voltag(scsi_changer *ch, u_int elem,
         u_char  *buffer;
         int result;
 
-        buffer = kmalloc(512, GFP_KERNEL);
+        buffer = kzalloc(512, GFP_KERNEL);
         if (!buffer)
                 return -ENOMEM;
-        memset(buffer,0,512);
 
         dprintk("%s %s voltag: 0x%x => \"%s\"\n",
                 clear     ? "clear"     : "set",
@@ -922,11 +920,10 @@ static int ch_probe(struct device *dev)
         if (sd->type != TYPE_MEDIUM_CHANGER)
                 return -ENODEV;
     
-        ch = kmalloc(sizeof(*ch), GFP_KERNEL);
+        ch = kzalloc(sizeof(*ch), GFP_KERNEL);
         if (NULL == ch)
                 return -ENOMEM;
 
-        memset(ch,0,sizeof(*ch));
         ch->minor = ch_devcount;
         sprintf(ch->name,"ch%d",ch->minor);
         mutex_init(&ch->lock);
diff --git a/drivers/scsi/dc395x.c b/drivers/scsi/dc395x.c
index a965ed3548d5..564ea90ed3a0 100644
--- a/drivers/scsi/dc395x.c
+++ b/drivers/scsi/dc395x.c
@@ -541,7 +541,7 @@ static struct ParameterData __devinitdata cfg_data[] = {
 
 
 /*
- * Safe settings. If set to zero the the BIOS/default values with
+ * Safe settings. If set to zero the BIOS/default values with
  * command line overrides will be used. If set to 1 then safe and
  * slow settings will be used.
  */
@@ -617,7 +617,7 @@ static void __devinit fix_settings(void)
 
 /*
  * Mapping from the eeprom delay index value (index into this array)
- * to the the number of actual seconds that the delay should be for.
+ * to the number of actual seconds that the delay should be for.
  */
 static char __devinitdata eeprom_index_to_delay_map[] = 
         { 1, 3, 5, 10, 16, 30, 60, 120 };
@@ -4136,7 +4136,7 @@ static void __devinit trms1040_write_all(struct NvRamType *eeprom, unsigned long
  * @io_port:    base I/O address
  * @addr:       offset into SEEPROM
  *
- * Returns the the byte read.
+ * Returns the byte read.
  **/
 static u8 __devinit trms1040_get_data(unsigned long io_port, u8 addr)
 {
diff --git a/drivers/scsi/dpt_i2o.c b/drivers/scsi/dpt_i2o.c
index fb6433a56989..8c7d2bbf9b1a 100644
--- a/drivers/scsi/dpt_i2o.c
+++ b/drivers/scsi/dpt_i2o.c
@@ -1308,13 +1308,12 @@ static s32 adpt_i2o_reset_hba(adpt_hba* pHba)
                 schedule_timeout_uninterruptible(1);
         } while (m == EMPTY_QUEUE);
 
-        status = kmalloc(4, GFP_KERNEL|ADDR32);
+        status = kzalloc(4, GFP_KERNEL|ADDR32);
         if(status == NULL) {
                 adpt_send_nop(pHba, m);
                 printk(KERN_ERR"IOP reset failed - no free memory.\n");
                 return -ENOMEM;
         }
-        memset(status,0,4);
 
         msg[0]=EIGHT_WORD_MSG_SIZE|SGL_OFFSET_0;
         msg[1]=I2O_CMD_ADAPTER_RESET<<24|HOST_TID<<12|ADAPTER_TID;
@@ -1504,21 +1503,19 @@ static int adpt_i2o_parse_lct(adpt_hba* pHba)
                                         continue;
                                 }
                                 if( pHba->channel[bus_no].device[scsi_id] == NULL){
-                                        pDev =  kmalloc(sizeof(struct adpt_device),GFP_KERNEL);
+                                        pDev =  kzalloc(sizeof(struct adpt_device),GFP_KERNEL);
                                         if(pDev == NULL) {
                                                 return -ENOMEM;
                                         }
                                         pHba->channel[bus_no].device[scsi_id] = pDev;
-                                        memset(pDev,0,sizeof(struct adpt_device));
                                 } else {
                                         for( pDev = pHba->channel[bus_no].device[scsi_id];      
                                                         pDev->next_lun; pDev = pDev->next_lun){
                                         }
-                                        pDev->next_lun = kmalloc(sizeof(struct adpt_device),GFP_KERNEL);
+                                        pDev->next_lun = kzalloc(sizeof(struct adpt_device),GFP_KERNEL);
                                         if(pDev->next_lun == NULL) {
                                                 return -ENOMEM;
                                         }
-                                        memset(pDev->next_lun,0,sizeof(struct adpt_device));
                                         pDev = pDev->next_lun;
                                 }
                                 pDev->tid = tid;
@@ -1667,12 +1664,11 @@ static int adpt_i2o_passthru(adpt_hba* pHba, u32 __user *arg)
                 reply_size = REPLY_FRAME_SIZE;
         }
         reply_size *= 4;
-        reply = kmalloc(REPLY_FRAME_SIZE*4, GFP_KERNEL);
+        reply = kzalloc(REPLY_FRAME_SIZE*4, GFP_KERNEL);
         if(reply == NULL) {
                 printk(KERN_WARNING"%s: Could not allocate reply buffer\n",pHba->name);
                 return -ENOMEM;
         }
-        memset(reply,0,REPLY_FRAME_SIZE*4);
         sg_offset = (msg[0]>>4)&0xf;
         msg[2] = 0x40000000; // IOCTL context
         msg[3] = (u32)reply;
@@ -2444,7 +2440,7 @@ static s32 adpt_i2o_reparse_lct(adpt_hba* pHba)
                                 }
                                 pDev = pHba->channel[bus_no].device[scsi_id];   
                                 if( pDev == NULL){
-                                        pDev =  kmalloc(sizeof(struct adpt_device),GFP_KERNEL);
+                                        pDev =  kzalloc(sizeof(struct adpt_device),GFP_KERNEL);
                                         if(pDev == NULL) {
                                                 return -ENOMEM;
                                         }
@@ -2453,12 +2449,11 @@ static s32 adpt_i2o_reparse_lct(adpt_hba* pHba)
                                         while (pDev->next_lun) {
                                                 pDev = pDev->next_lun;
                                         }
-                                        pDev = pDev->next_lun = kmalloc(sizeof(struct adpt_device),GFP_KERNEL);
+                                        pDev = pDev->next_lun = kzalloc(sizeof(struct adpt_device),GFP_KERNEL);
                                         if(pDev == NULL) {
                                                 return -ENOMEM;
                                         }
                                 }
-                                memset(pDev,0,sizeof(struct adpt_device));
                                 pDev->tid = d->lct_data.tid;
                                 pDev->scsi_channel = bus_no;
                                 pDev->scsi_id = scsi_id;
diff --git a/drivers/scsi/ipr.c b/drivers/scsi/ipr.c
index 2c7b77e833f9..4baa79e68679 100644
--- a/drivers/scsi/ipr.c
+++ b/drivers/scsi/ipr.c
@@ -92,6 +92,7 @@ static unsigned int ipr_fastfail = 0;
 static unsigned int ipr_transop_timeout = 0;
 static unsigned int ipr_enable_cache = 1;
 static unsigned int ipr_debug = 0;
+static unsigned int ipr_dual_ioa_raid = 1;
 static DEFINE_SPINLOCK(ipr_driver_lock);
 
 /* This table describes the differences between DMA controller chips */
@@ -158,6 +159,8 @@ module_param_named(enable_cache, ipr_enable_cache, int, 0);
 MODULE_PARM_DESC(enable_cache, "Enable adapter's non-volatile write cache (default: 1)");
 module_param_named(debug, ipr_debug, int, 0);
 MODULE_PARM_DESC(debug, "Enable device driver debugging logging. Set to 1 to enable. (default: 0)");
+module_param_named(dual_ioa_raid, ipr_dual_ioa_raid, int, 0);
+MODULE_PARM_DESC(dual_ioa_raid, "Enable dual adapter RAID support. Set to 1 to enable. (default: 1)");
 MODULE_LICENSE("GPL");
 MODULE_VERSION(IPR_DRIVER_VERSION);
 
@@ -206,6 +209,8 @@ struct ipr_error_table_t ipr_error_table[] = {
         "8009: Impending cache battery pack failure"},
         {0x02040400, 0, 0,
         "34FF: Disk device format in progress"},
+        {0x02048000, 0, IPR_DEFAULT_LOG_LEVEL,
+        "9070: IOA requested reset"},
         {0x023F0000, 0, 0,
         "Synchronization required"},
         {0x024E0000, 0, 0,
@@ -951,6 +956,53 @@ static void ipr_process_ccn(struct ipr_cmnd *ipr_cmd)
 }
 
 /**
+ * strip_and_pad_whitespace - Strip and pad trailing whitespace.
+ * @i:          index into buffer
+ * @buf:                string to modify
+ *
+ * This function will strip all trailing whitespace, pad the end
+ * of the string with a single space, and NULL terminate the string.
+ *
+ * Return value:
+ *      new length of string
+ **/
+static int strip_and_pad_whitespace(int i, char *buf)
+{
+        while (i && buf[i] == ' ')
+                i--;
+        buf[i+1] = ' ';
+        buf[i+2] = '\0';
+        return i + 2;
+}
+
+/**
+ * ipr_log_vpd_compact - Log the passed extended VPD compactly.
+ * @prefix:             string to print at start of printk
+ * @hostrcb:    hostrcb pointer
+ * @vpd:                vendor/product id/sn struct
+ *
+ * Return value:
+ *      none
+ **/
+static void ipr_log_vpd_compact(char *prefix, struct ipr_hostrcb *hostrcb,
+                                struct ipr_vpd *vpd)
+{
+        char buffer[IPR_VENDOR_ID_LEN + IPR_PROD_ID_LEN + IPR_SERIAL_NUM_LEN + 3];
+        int i = 0;
+
+        memcpy(buffer, vpd->vpids.vendor_id, IPR_VENDOR_ID_LEN);
+        i = strip_and_pad_whitespace(IPR_VENDOR_ID_LEN - 1, buffer);
+
+        memcpy(&buffer[i], vpd->vpids.product_id, IPR_PROD_ID_LEN);
+        i = strip_and_pad_whitespace(i + IPR_PROD_ID_LEN - 1, buffer);
+
+        memcpy(&buffer[i], vpd->sn, IPR_SERIAL_NUM_LEN);
+        buffer[IPR_SERIAL_NUM_LEN + i] = '\0';
+
+        ipr_hcam_err(hostrcb, "%s VPID/SN: %s\n", prefix, buffer);
+}
+
+/**
  * ipr_log_vpd - Log the passed VPD to the error log.
  * @vpd:                vendor/product id/sn struct
  *
@@ -974,6 +1026,23 @@ static void ipr_log_vpd(struct ipr_vpd *vpd)
 }
 
 /**
+ * ipr_log_ext_vpd_compact - Log the passed extended VPD compactly.
+ * @prefix:             string to print at start of printk
+ * @hostrcb:    hostrcb pointer
+ * @vpd:                vendor/product id/sn/wwn struct
+ *
+ * Return value:
+ *      none
+ **/
+static void ipr_log_ext_vpd_compact(char *prefix, struct ipr_hostrcb *hostrcb,
+                                    struct ipr_ext_vpd *vpd)
+{
+        ipr_log_vpd_compact(prefix, hostrcb, &vpd->vpd);
+        ipr_hcam_err(hostrcb, "%s WWN: %08X%08X\n", prefix,
+                     be32_to_cpu(vpd->wwid[0]), be32_to_cpu(vpd->wwid[1]));
+}
+
+/**
  * ipr_log_ext_vpd - Log the passed extended VPD to the error log.
  * @vpd:                vendor/product id/sn/wwn struct
  *
@@ -1287,10 +1356,11 @@ static void ipr_log_enhanced_dual_ioa_error(struct ipr_ioa_cfg *ioa_cfg,
 
         error = &hostrcb->hcam.u.error.u.type_17_error;
         error->failure_reason[sizeof(error->failure_reason) - 1] = '\0';
+        strstrip(error->failure_reason);
 
-        ipr_err("%s\n", error->failure_reason);
-        ipr_err("Remote Adapter VPD:\n");
-        ipr_log_ext_vpd(&error->vpd);
+        ipr_hcam_err(hostrcb, "%s [PRC: %08X]\n", error->failure_reason,
+                     be32_to_cpu(hostrcb->hcam.u.error.prc));
+        ipr_log_ext_vpd_compact("Remote IOA", hostrcb, &error->vpd);
         ipr_log_hex_data(ioa_cfg, error->data,
                          be32_to_cpu(hostrcb->hcam.length) -
                          (offsetof(struct ipr_hostrcb_error, u) +
@@ -1312,10 +1382,11 @@ static void ipr_log_dual_ioa_error(struct ipr_ioa_cfg *ioa_cfg,
 
         error = &hostrcb->hcam.u.error.u.type_07_error;
         error->failure_reason[sizeof(error->failure_reason) - 1] = '\0';
+        strstrip(error->failure_reason);
 
-        ipr_err("%s\n", error->failure_reason);
-        ipr_err("Remote Adapter VPD:\n");
-        ipr_log_vpd(&error->vpd);
+        ipr_hcam_err(hostrcb, "%s [PRC: %08X]\n", error->failure_reason,
+                     be32_to_cpu(hostrcb->hcam.u.error.prc));
+        ipr_log_vpd_compact("Remote IOA", hostrcb, &error->vpd);
         ipr_log_hex_data(ioa_cfg, error->data,
                          be32_to_cpu(hostrcb->hcam.length) -
                          (offsetof(struct ipr_hostrcb_error, u) +
@@ -1672,12 +1743,15 @@ static void ipr_process_error(struct ipr_cmnd *ipr_cmd)
         struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
         struct ipr_hostrcb *hostrcb = ipr_cmd->u.hostrcb;
         u32 ioasc = be32_to_cpu(ipr_cmd->ioasa.ioasc);
+        u32 fd_ioasc = be32_to_cpu(hostrcb->hcam.u.error.failing_dev_ioasc);
 
         list_del(&hostrcb->queue);
         list_add_tail(&ipr_cmd->queue, &ioa_cfg->free_q);
 
         if (!ioasc) {
                 ipr_handle_log_data(ioa_cfg, hostrcb);
+                if (fd_ioasc == IPR_IOASC_NR_IOA_RESET_REQUIRED)
+                        ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_ABBREV);
         } else if (ioasc != IPR_IOASC_IOA_WAS_RESET) {
                 dev_err(&ioa_cfg->pdev->dev,
                         "Host RCB failed with IOASC: 0x%08X\n", ioasc);
@@ -2635,8 +2709,13 @@ static ssize_t ipr_store_diagnostics(struct class_device *class_dev,
         if (!capable(CAP_SYS_ADMIN))
                 return -EACCES;
 
-        wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
+        while(ioa_cfg->in_reset_reload) {
+                spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
+                wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
+                spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
+        }
+
         ioa_cfg->errors_logged = 0;
         ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NORMAL);
 
@@ -2958,6 +3037,11 @@ static int ipr_update_ioa_ucode(struct ipr_ioa_cfg *ioa_cfg,
         unsigned long lock_flags;
 
         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
+        while(ioa_cfg->in_reset_reload) {
+                spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
+                wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
+                spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
+        }
 
         if (ioa_cfg->ucode_sglist) {
                 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
@@ -4656,18 +4740,19 @@ static void ipr_erp_start(struct ipr_ioa_cfg *ioa_cfg,
         struct scsi_cmnd *scsi_cmd = ipr_cmd->scsi_cmd;
         struct ipr_resource_entry *res = scsi_cmd->device->hostdata;
         u32 ioasc = be32_to_cpu(ipr_cmd->ioasa.ioasc);
+        u32 masked_ioasc = ioasc & IPR_IOASC_IOASC_MASK;
 
         if (!res) {
                 ipr_scsi_eh_done(ipr_cmd);
                 return;
         }
 
-        if (!ipr_is_gscsi(res))
+        if (!ipr_is_gscsi(res) && masked_ioasc != IPR_IOASC_HW_DEV_BUS_STATUS)
                 ipr_gen_sense(ipr_cmd);
 
         ipr_dump_ioasa(ioa_cfg, ipr_cmd, res);
 
-        switch (ioasc & IPR_IOASC_IOASC_MASK) {
+        switch (masked_ioasc) {
         case IPR_IOASC_ABORTED_CMD_TERM_BY_HOST:
                 if (ipr_is_naca_model(res))
                         scsi_cmd->result |= (DID_ABORT << 16);
@@ -5363,6 +5448,7 @@ static int ipr_ioa_reset_done(struct ipr_cmnd *ipr_cmd)
                         ipr_send_hcam(ioa_cfg, IPR_HCAM_CDB_OP_CODE_CONFIG_CHANGE, hostrcb);
         }
 
+        scsi_report_bus_reset(ioa_cfg->host, IPR_VSET_BUS);
         dev_info(&ioa_cfg->pdev->dev, "IOA initialized.\n");
 
         ioa_cfg->reset_retries = 0;
@@ -5799,6 +5885,94 @@ static int ipr_ioafp_mode_sense_page28(struct ipr_cmnd *ipr_cmd)
 }
 
 /**
+ * ipr_ioafp_mode_select_page24 - Issue Mode Select to IOA
+ * @ipr_cmd:    ipr command struct
+ *
+ * This function enables dual IOA RAID support if possible.
+ *
+ * Return value:
+ *      IPR_RC_JOB_RETURN
+ **/
+static int ipr_ioafp_mode_select_page24(struct ipr_cmnd *ipr_cmd)
+{
+        struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
+        struct ipr_mode_pages *mode_pages = &ioa_cfg->vpd_cbs->mode_pages;
+        struct ipr_mode_page24 *mode_page;
+        int length;
+
+        ENTER;
+        mode_page = ipr_get_mode_page(mode_pages, 0x24,
+                                      sizeof(struct ipr_mode_page24));
+
+        if (mode_page)
+                mode_page->flags |= IPR_ENABLE_DUAL_IOA_AF;
+
+        length = mode_pages->hdr.length + 1;
+        mode_pages->hdr.length = 0;
+
+        ipr_build_mode_select(ipr_cmd, cpu_to_be32(IPR_IOA_RES_HANDLE), 0x11,
+                              ioa_cfg->vpd_cbs_dma + offsetof(struct ipr_misc_cbs, mode_pages),
+                              length);
+
+        ipr_cmd->job_step = ipr_ioafp_mode_sense_page28;
+        ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout, IPR_INTERNAL_TIMEOUT);
+
+        LEAVE;
+        return IPR_RC_JOB_RETURN;
+}
+
+/**
+ * ipr_reset_mode_sense_page24_failed - Handle failure of IOAFP mode sense
+ * @ipr_cmd:    ipr command struct
+ *
+ * This function handles the failure of a Mode Sense to the IOAFP.
+ * Some adapters do not handle all mode pages.
+ *
+ * Return value:
+ *      IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
+ **/
+static int ipr_reset_mode_sense_page24_failed(struct ipr_cmnd *ipr_cmd)
+{
+        u32 ioasc = be32_to_cpu(ipr_cmd->ioasa.ioasc);
+
+        if (ioasc == IPR_IOASC_IR_INVALID_REQ_TYPE_OR_PKT) {
+                ipr_cmd->job_step = ipr_ioafp_mode_sense_page28;
+                return IPR_RC_JOB_CONTINUE;
+        }
+
+        return ipr_reset_cmd_failed(ipr_cmd);
+}
+
+/**
+ * ipr_ioafp_mode_sense_page24 - Issue Page 24 Mode Sense to IOA
+ * @ipr_cmd:    ipr command struct
+ *
+ * This function send a mode sense to the IOA to retrieve
+ * the IOA Advanced Function Control mode page.
+ *
+ * Return value:
+ *      IPR_RC_JOB_RETURN
+ **/
+static int ipr_ioafp_mode_sense_page24(struct ipr_cmnd *ipr_cmd)
+{
+        struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
+
+        ENTER;
+        ipr_build_mode_sense(ipr_cmd, cpu_to_be32(IPR_IOA_RES_HANDLE),
+                             0x24, ioa_cfg->vpd_cbs_dma +
+                             offsetof(struct ipr_misc_cbs, mode_pages),
+                             sizeof(struct ipr_mode_pages));
+
+        ipr_cmd->job_step = ipr_ioafp_mode_select_page24;
+        ipr_cmd->job_step_failed = ipr_reset_mode_sense_page24_failed;
+
+        ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout, IPR_INTERNAL_TIMEOUT);
+
+        LEAVE;
+        return IPR_RC_JOB_RETURN;
+}
+
+/**
  * ipr_init_res_table - Initialize the resource table
  * @ipr_cmd:    ipr command struct
  *
@@ -5866,7 +6040,10 @@ static int ipr_init_res_table(struct ipr_cmnd *ipr_cmd)
                 }
         }
 
-        ipr_cmd->job_step = ipr_ioafp_mode_sense_page28;
+        if (ioa_cfg->dual_raid && ipr_dual_ioa_raid)
+                ipr_cmd->job_step = ipr_ioafp_mode_sense_page24;
+        else
+                ipr_cmd->job_step = ipr_ioafp_mode_sense_page28;
 
         LEAVE;
         return IPR_RC_JOB_CONTINUE;
@@ -5888,8 +6065,11 @@ static int ipr_ioafp_query_ioa_cfg(struct ipr_cmnd *ipr_cmd)
         struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
         struct ipr_ioadl_desc *ioadl = ipr_cmd->ioadl;
         struct ipr_inquiry_page3 *ucode_vpd = &ioa_cfg->vpd_cbs->page3_data;
+        struct ipr_inquiry_cap *cap = &ioa_cfg->vpd_cbs->cap;
 
         ENTER;
+        if (cap->cap & IPR_CAP_DUAL_IOA_RAID)
+                ioa_cfg->dual_raid = 1;
         dev_info(&ioa_cfg->pdev->dev, "Adapter firmware version: %02X%02X%02X%02X\n",
                  ucode_vpd->major_release, ucode_vpd->card_type,
                  ucode_vpd->minor_release[0], ucode_vpd->minor_release[1]);
@@ -5973,6 +6153,37 @@ static int ipr_inquiry_page_supported(struct ipr_inquiry_page0 *page0, u8 page)
 }
 
 /**
+ * ipr_ioafp_cap_inquiry - Send a Page 0xD0 Inquiry to the adapter.
+ * @ipr_cmd:    ipr command struct
+ *
+ * This function sends a Page 0xD0 inquiry to the adapter
+ * to retrieve adapter capabilities.
+ *
+ * Return value:
+ *      IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
+ **/
+static int ipr_ioafp_cap_inquiry(struct ipr_cmnd *ipr_cmd)
+{
+        struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
+        struct ipr_inquiry_page0 *page0 = &ioa_cfg->vpd_cbs->page0_data;
+        struct ipr_inquiry_cap *cap = &ioa_cfg->vpd_cbs->cap;
+
+        ENTER;
+        ipr_cmd->job_step = ipr_ioafp_query_ioa_cfg;
+        memset(cap, 0, sizeof(*cap));
+
+        if (ipr_inquiry_page_supported(page0, 0xD0)) {
+                ipr_ioafp_inquiry(ipr_cmd, 1, 0xD0,
+                                  ioa_cfg->vpd_cbs_dma + offsetof(struct ipr_misc_cbs, cap),
+                                  sizeof(struct ipr_inquiry_cap));
+                return IPR_RC_JOB_RETURN;
+        }
+
+        LEAVE;
+        return IPR_RC_JOB_CONTINUE;
+}
+
+/**
  * ipr_ioafp_page3_inquiry - Send a Page 3 Inquiry to the adapter.
  * @ipr_cmd:    ipr command struct
  *
@@ -5992,7 +6203,7 @@ static int ipr_ioafp_page3_inquiry(struct ipr_cmnd *ipr_cmd)
         if (!ipr_inquiry_page_supported(page0, 1))
                 ioa_cfg->cache_state = CACHE_NONE;
 
-        ipr_cmd->job_step = ipr_ioafp_query_ioa_cfg;
+        ipr_cmd->job_step = ipr_ioafp_cap_inquiry;
 
         ipr_ioafp_inquiry(ipr_cmd, 1, 3,
                           ioa_cfg->vpd_cbs_dma + offsetof(struct ipr_misc_cbs, page3_data),
@@ -6278,6 +6489,7 @@ static void ipr_get_unit_check_buffer(struct ipr_ioa_cfg *ioa_cfg)
         struct ipr_hostrcb *hostrcb;
         struct ipr_uc_sdt sdt;
         int rc, length;
+        u32 ioasc;
 
         mailbox = readl(ioa_cfg->ioa_mailbox);
 
@@ -6310,9 +6522,13 @@ static void ipr_get_unit_check_buffer(struct ipr_ioa_cfg *ioa_cfg)
                                         (__be32 *)&hostrcb->hcam,
                                         min(length, (int)sizeof(hostrcb->hcam)) / sizeof(__be32));
 
-        if (!rc)
+        if (!rc) {
                 ipr_handle_log_data(ioa_cfg, hostrcb);
-        else
+                ioasc = be32_to_cpu(hostrcb->hcam.u.error.failing_dev_ioasc);
+                if (ioasc == IPR_IOASC_NR_IOA_RESET_REQUIRED &&
+                    ioa_cfg->sdt_state == GET_DUMP)
+                        ioa_cfg->sdt_state = WAIT_FOR_DUMP;
+        } else
                 ipr_unit_check_no_data(ioa_cfg);
 
         list_add_tail(&hostrcb->queue, &ioa_cfg->hostrcb_free_q);
@@ -6425,6 +6641,48 @@ static int ipr_reset_start_bist(struct ipr_cmnd *ipr_cmd)
 }
 
 /**
+ * ipr_reset_slot_reset_done - Clear PCI reset to the adapter
+ * @ipr_cmd:    ipr command struct
+ *
+ * Description: This clears PCI reset to the adapter and delays two seconds.
+ *
+ * Return value:
+ *      IPR_RC_JOB_RETURN
+ **/
+static int ipr_reset_slot_reset_done(struct ipr_cmnd *ipr_cmd)
+{
+        ENTER;
+        pci_set_pcie_reset_state(ipr_cmd->ioa_cfg->pdev, pcie_deassert_reset);
+        ipr_cmd->job_step = ipr_reset_bist_done;
+        ipr_reset_start_timer(ipr_cmd, IPR_WAIT_FOR_BIST_TIMEOUT);
+        LEAVE;
+        return IPR_RC_JOB_RETURN;
+}
+
+/**
+ * ipr_reset_slot_reset - Reset the PCI slot of the adapter.
+ * @ipr_cmd:    ipr command struct
+ *
+ * Description: This asserts PCI reset to the adapter.
+ *
+ * Return value:
+ *      IPR_RC_JOB_RETURN
+ **/
+static int ipr_reset_slot_reset(struct ipr_cmnd *ipr_cmd)
+{
+        struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
+        struct pci_dev *pdev = ioa_cfg->pdev;
+
+        ENTER;
+        pci_block_user_cfg_access(pdev);
+        pci_set_pcie_reset_state(pdev, pcie_warm_reset);
+        ipr_cmd->job_step = ipr_reset_slot_reset_done;
+        ipr_reset_start_timer(ipr_cmd, IPR_PCI_RESET_TIMEOUT);
+        LEAVE;
+        return IPR_RC_JOB_RETURN;
+}
+
+/**
  * ipr_reset_allowed - Query whether or not IOA can be reset
  * @ioa_cfg:    ioa config struct
  *
@@ -6463,7 +6721,7 @@ static int ipr_reset_wait_to_start_bist(struct ipr_cmnd *ipr_cmd)
                 ipr_cmd->u.time_left -= IPR_CHECK_FOR_RESET_TIMEOUT;
                 ipr_reset_start_timer(ipr_cmd, IPR_CHECK_FOR_RESET_TIMEOUT);
         } else {
-                ipr_cmd->job_step = ipr_reset_start_bist;
+                ipr_cmd->job_step = ioa_cfg->reset;
                 rc = IPR_RC_JOB_CONTINUE;
         }
 
@@ -6496,7 +6754,7 @@ static int ipr_reset_alert(struct ipr_cmnd *ipr_cmd)
                 writel(IPR_UPROCI_RESET_ALERT, ioa_cfg->regs.set_uproc_interrupt_reg);
                 ipr_cmd->job_step = ipr_reset_wait_to_start_bist;
         } else {
-                ipr_cmd->job_step = ipr_reset_start_bist;
+                ipr_cmd->job_step = ioa_cfg->reset;
         }
 
         ipr_cmd->u.time_left = IPR_WAIT_FOR_RESET_TIMEOUT;
@@ -6591,12 +6849,14 @@ static int ipr_reset_shutdown_ioa(struct ipr_cmnd *ipr_cmd)
                 ipr_cmd->ioarcb.cmd_pkt.cdb[0] = IPR_IOA_SHUTDOWN;
                 ipr_cmd->ioarcb.cmd_pkt.cdb[1] = shutdown_type;
 
-                if (shutdown_type == IPR_SHUTDOWN_ABBREV)
-                        timeout = IPR_ABBREV_SHUTDOWN_TIMEOUT;
+                if (shutdown_type == IPR_SHUTDOWN_NORMAL)
+                        timeout = IPR_SHUTDOWN_TIMEOUT;
                 else if (shutdown_type == IPR_SHUTDOWN_PREPARE_FOR_NORMAL)
                         timeout = IPR_INTERNAL_TIMEOUT;
+                else if (ioa_cfg->dual_raid && ipr_dual_ioa_raid)
+                        timeout = IPR_DUAL_IOA_ABBR_SHUTDOWN_TO;
                 else
-                        timeout = IPR_SHUTDOWN_TIMEOUT;
+                        timeout = IPR_ABBREV_SHUTDOWN_TIMEOUT;
 
                 ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout, timeout);
 
@@ -6776,8 +7036,11 @@ static pci_ers_result_t ipr_pci_slot_reset(struct pci_dev *pdev)
         struct ipr_ioa_cfg *ioa_cfg = pci_get_drvdata(pdev);
 
         spin_lock_irqsave(ioa_cfg->host->host_lock, flags);
-        _ipr_initiate_ioa_reset(ioa_cfg, ipr_reset_restore_cfg_space,
-                                         IPR_SHUTDOWN_NONE);
+        if (ioa_cfg->needs_warm_reset)
+                ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
+        else
+                _ipr_initiate_ioa_reset(ioa_cfg, ipr_reset_restore_cfg_space,
+                                        IPR_SHUTDOWN_NONE);
         spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
         return PCI_ERS_RESULT_RECOVERED;
 }
@@ -7226,7 +7489,7 @@ static int __devinit ipr_probe_ioa(struct pci_dev *pdev,
         unsigned long ipr_regs_pci;
         void __iomem *ipr_regs;
         int rc = PCIBIOS_SUCCESSFUL;
-        volatile u32 mask, uproc;
+        volatile u32 mask, uproc, interrupts;
 
         ENTER;
 
@@ -7265,6 +7528,14 @@ static int __devinit ipr_probe_ioa(struct pci_dev *pdev,
         else
                 ioa_cfg->transop_timeout = IPR_OPERATIONAL_TIMEOUT;
 
+        rc = pci_read_config_byte(pdev, PCI_REVISION_ID, &ioa_cfg->revid);
+
+        if (rc != PCIBIOS_SUCCESSFUL) {
+                dev_err(&pdev->dev, "Failed to read PCI revision ID\n");
+                rc = -EIO;
+                goto out_scsi_host_put;
+        }
+
         ipr_regs_pci = pci_resource_start(pdev, 0);
 
         rc = pci_request_regions(pdev, IPR_NAME);
@@ -7333,9 +7604,14 @@ static int __devinit ipr_probe_ioa(struct pci_dev *pdev,
          * the card is in an unknown state and needs a hard reset
          */
         mask = readl(ioa_cfg->regs.sense_interrupt_mask_reg);
+        interrupts = readl(ioa_cfg->regs.sense_interrupt_reg);
         uproc = readl(ioa_cfg->regs.sense_uproc_interrupt_reg);
         if ((mask & IPR_PCII_HRRQ_UPDATED) == 0 || (uproc & IPR_UPROCI_RESET_ALERT))
                 ioa_cfg->needs_hard_reset = 1;
+        if (interrupts & IPR_PCII_ERROR_INTERRUPTS)
+                ioa_cfg->needs_hard_reset = 1;
+        if (interrupts & IPR_PCII_IOA_UNIT_CHECKED)
+                ioa_cfg->ioa_unit_checked = 1;
 
         ipr_mask_and_clear_interrupts(ioa_cfg, ~IPR_PCII_IOA_TRANS_TO_OPER);
         rc = request_irq(pdev->irq, ipr_isr, IRQF_SHARED, IPR_NAME, ioa_cfg);
@@ -7346,6 +7622,13 @@ static int __devinit ipr_probe_ioa(struct pci_dev *pdev,
                 goto cleanup_nolog;
         }
 
+        if ((dev_id->driver_data & IPR_USE_PCI_WARM_RESET) ||
+            (dev_id->device == PCI_DEVICE_ID_IBM_OBSIDIAN_E && !ioa_cfg->revid)) {
+                ioa_cfg->needs_warm_reset = 1;
+                ioa_cfg->reset = ipr_reset_slot_reset;
+        } else
+                ioa_cfg->reset = ipr_reset_start_bist;
+
         spin_lock(&ipr_driver_lock);
         list_add_tail(&ioa_cfg->queue, &ipr_ioa_head);
         spin_unlock(&ipr_driver_lock);
@@ -7428,6 +7711,12 @@ static void __ipr_remove(struct pci_dev *pdev)
         ENTER;
 
         spin_lock_irqsave(ioa_cfg->host->host_lock, host_lock_flags);
+        while(ioa_cfg->in_reset_reload) {
+                spin_unlock_irqrestore(ioa_cfg->host->host_lock, host_lock_flags);
+                wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
+                spin_lock_irqsave(ioa_cfg->host->host_lock, host_lock_flags);
+        }
+
         ipr_initiate_ioa_bringdown(ioa_cfg, IPR_SHUTDOWN_NORMAL);
 
         spin_unlock_irqrestore(ioa_cfg->host->host_lock, host_lock_flags);
@@ -7551,6 +7840,12 @@ static void ipr_shutdown(struct pci_dev *pdev)
         unsigned long lock_flags = 0;
 
         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
+        while(ioa_cfg->in_reset_reload) {
+                spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
+                wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
+                spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
+        }
+
         ipr_initiate_ioa_bringdown(ioa_cfg, IPR_SHUTDOWN_NORMAL);
         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
         wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
@@ -7577,19 +7872,22 @@ static struct pci_device_id ipr_pci_table[] __devinitdata = {
         { PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_OBSIDIAN,
               PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_572A, 0, 0, 0 },
         { PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_OBSIDIAN,
-              PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_572B, 0, 0, 0 },
+              PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_572B, 0, 0,
+              IPR_USE_LONG_TRANSOP_TIMEOUT },
         { PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_OBSIDIAN,
               PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_575C, 0, 0,
               IPR_USE_LONG_TRANSOP_TIMEOUT },
         { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_OBSIDIAN,
               PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_572A, 0, 0, 0 },
         { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_OBSIDIAN,
-              PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_572B, 0, 0, 0 },
+              PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_572B, 0, 0,
+              IPR_USE_LONG_TRANSOP_TIMEOUT},
         { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_OBSIDIAN,
               PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_575C, 0, 0,
               IPR_USE_LONG_TRANSOP_TIMEOUT },
         { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_OBSIDIAN_E,
-              PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_574E, 0, 0, 0 },
+              PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_574E, 0, 0,
+              IPR_USE_LONG_TRANSOP_TIMEOUT },
         { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_OBSIDIAN_E,
               PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_575D, 0, 0,
               IPR_USE_LONG_TRANSOP_TIMEOUT },
@@ -7597,7 +7895,7 @@ static struct pci_device_id ipr_pci_table[] __devinitdata = {
               PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57B3, 0, 0, 0 },
         { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_OBSIDIAN_E,
               PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57B7, 0, 0,
-              IPR_USE_LONG_TRANSOP_TIMEOUT },
+              IPR_USE_LONG_TRANSOP_TIMEOUT | IPR_USE_PCI_WARM_RESET },
         { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_SNIPE,
                 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_2780, 0, 0, 0 },
         { PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_SCAMP,
@@ -7627,6 +7925,7 @@ static struct pci_driver ipr_driver = {
         .remove = ipr_remove,
         .shutdown = ipr_shutdown,
         .err_handler = &ipr_err_handler,
+        .dynids.use_driver_data = 1
 };
 
 /**
diff --git a/drivers/scsi/ipr.h b/drivers/scsi/ipr.h
index bc53d7cebe0a..d93156671e93 100644
--- a/drivers/scsi/ipr.h
+++ b/drivers/scsi/ipr.h
@@ -37,8 +37,8 @@
 /*
  * Literals
  */
-#define IPR_DRIVER_VERSION "2.3.2"
-#define IPR_DRIVER_DATE "(March 23, 2007)"
+#define IPR_DRIVER_VERSION "2.4.1"
+#define IPR_DRIVER_DATE "(April 24, 2007)"
 
 /*
  * IPR_MAX_CMD_PER_LUN: This defines the maximum number of outstanding
@@ -91,6 +91,7 @@
  * IOASCs
  */
 #define IPR_IOASC_NR_INIT_CMD_REQUIRED          0x02040200
+#define IPR_IOASC_NR_IOA_RESET_REQUIRED         0x02048000
 #define IPR_IOASC_SYNC_REQUIRED                 0x023f0000
 #define IPR_IOASC_MED_DO_NOT_REALLOC            0x03110C00
 #define IPR_IOASC_HW_SEL_TIMEOUT                        0x04050000
@@ -111,6 +112,7 @@
 
 /* Driver data flags */
 #define IPR_USE_LONG_TRANSOP_TIMEOUT            0x00000001
+#define IPR_USE_PCI_WARM_RESET                  0x00000002
 
 #define IPR_DEFAULT_MAX_ERROR_DUMP                      984
 #define IPR_NUM_LOG_HCAMS                               2
@@ -179,6 +181,7 @@
 #define IPR_SHUTDOWN_TIMEOUT                    (ipr_fastfail ? 60 * HZ : 10 * 60 * HZ)
 #define IPR_VSET_RW_TIMEOUT                     (ipr_fastfail ? 30 * HZ : 2 * 60 * HZ)
 #define IPR_ABBREV_SHUTDOWN_TIMEOUT             (10 * HZ)
+#define IPR_DUAL_IOA_ABBR_SHUTDOWN_TO   (2 * 60 * HZ)
 #define IPR_DEVICE_RESET_TIMEOUT                (ipr_fastfail ? 10 * HZ : 30 * HZ)
 #define IPR_CANCEL_ALL_TIMEOUT          (ipr_fastfail ? 10 * HZ : 30 * HZ)
 #define IPR_ABORT_TASK_TIMEOUT          (ipr_fastfail ? 10 * HZ : 30 * HZ)
@@ -191,6 +194,7 @@
 #define IPR_WAIT_FOR_RESET_TIMEOUT              (2 * HZ)
 #define IPR_CHECK_FOR_RESET_TIMEOUT             (HZ / 10)
 #define IPR_WAIT_FOR_BIST_TIMEOUT               (2 * HZ)
+#define IPR_PCI_RESET_TIMEOUT                   (HZ / 2)
 #define IPR_DUMP_TIMEOUT                        (15 * HZ)
 
 /*
@@ -602,6 +606,12 @@ struct ipr_mode_page28 {
         struct ipr_dev_bus_entry bus[0];
 }__attribute__((packed));
 
+struct ipr_mode_page24 {
+        struct ipr_mode_page_hdr hdr;
+        u8 flags;
+#define IPR_ENABLE_DUAL_IOA_AF 0x80
+}__attribute__((packed));
+
 struct ipr_ioa_vpd {
         struct ipr_std_inq_data std_inq_data;
         u8 ascii_part_num[12];
@@ -624,6 +634,19 @@ struct ipr_inquiry_page3 {
         u8 patch_number[4];
 }__attribute__((packed));
 
+struct ipr_inquiry_cap {
+        u8 peri_qual_dev_type;
+        u8 page_code;
+        u8 reserved1;
+        u8 page_length;
+        u8 ascii_len;
+        u8 reserved2;
+        u8 sis_version[2];
+        u8 cap;
+#define IPR_CAP_DUAL_IOA_RAID           0x80
+        u8 reserved3[15];
+}__attribute__((packed));
+
 #define IPR_INQUIRY_PAGE0_ENTRIES 20
 struct ipr_inquiry_page0 {
         u8 peri_qual_dev_type;
@@ -962,6 +985,7 @@ struct ipr_misc_cbs {
         struct ipr_ioa_vpd ioa_vpd;
         struct ipr_inquiry_page0 page0_data;
         struct ipr_inquiry_page3 page3_data;
+        struct ipr_inquiry_cap cap;
         struct ipr_mode_pages mode_pages;
         struct ipr_supported_device supp_dev;
 };
@@ -1068,6 +1092,10 @@ struct ipr_ioa_cfg {
         u8 allow_cmds:1;
         u8 allow_ml_add_del:1;
         u8 needs_hard_reset:1;
+        u8 dual_raid:1;
+        u8 needs_warm_reset:1;
+
+        u8 revid;
 
         enum ipr_cache_state cache_state;
         u16 type; /* CCIN of the card */
@@ -1161,6 +1189,7 @@ struct ipr_ioa_cfg {
         struct pci_pool *ipr_cmd_pool;
 
         struct ipr_cmnd *reset_cmd;
+        int (*reset) (struct ipr_cmnd *);
 
         struct ata_host ata_host;
         char ipr_cmd_label[8];
diff --git a/drivers/scsi/libsas/sas_scsi_host.c b/drivers/scsi/libsas/sas_scsi_host.c
index 897a5e2c55e4..b4b52694497c 100644
--- a/drivers/scsi/libsas/sas_scsi_host.c
+++ b/drivers/scsi/libsas/sas_scsi_host.c
@@ -23,6 +23,8 @@
  *
  */
 
+#include <linux/kthread.h>
+
 #include "sas_internal.h"
 
 #include <scsi/scsi_host.h>
@@ -184,7 +186,7 @@ static int sas_queue_up(struct sas_task *task)
         list_add_tail(&task->list, &core->task_queue);
         core->task_queue_size += 1;
         spin_unlock_irqrestore(&core->task_queue_lock, flags);
-        up(&core->queue_thread_sema);
+        wake_up_process(core->queue_thread);
 
         return 0;
 }
@@ -819,7 +821,7 @@ static void sas_queue(struct sas_ha_struct *sas_ha)
         struct sas_internal *i = to_sas_internal(core->shost->transportt);
 
         spin_lock_irqsave(&core->task_queue_lock, flags);
-        while (!core->queue_thread_kill &&
+        while (!kthread_should_stop() &&
                !list_empty(&core->task_queue)) {
 
                 can_queue = sas_ha->lldd_queue_size - core->task_queue_size;
@@ -858,8 +860,6 @@ static void sas_queue(struct sas_ha_struct *sas_ha)
         spin_unlock_irqrestore(&core->task_queue_lock, flags);
 }
 
-static DECLARE_COMPLETION(queue_th_comp);
-
 /**
  * sas_queue_thread -- The Task Collector thread
  * @_sas_ha: pointer to struct sas_ha
@@ -867,40 +867,33 @@ static DECLARE_COMPLETION(queue_th_comp);
 static int sas_queue_thread(void *_sas_ha)
 {
         struct sas_ha_struct *sas_ha = _sas_ha;
-        struct scsi_core *core = &sas_ha->core;
 
-        daemonize("sas_queue_%d", core->shost->host_no);
         current->flags |= PF_NOFREEZE;
 
-        complete(&queue_th_comp);
-
         while (1) {
-                down_interruptible(&core->queue_thread_sema);
+                set_current_state(TASK_INTERRUPTIBLE);
+                schedule();
                 sas_queue(sas_ha);
-                if (core->queue_thread_kill)
+                if (kthread_should_stop())
                         break;
         }
 
-        complete(&queue_th_comp);
-
         return 0;
 }
 
 int sas_init_queue(struct sas_ha_struct *sas_ha)
 {
-        int res;
         struct scsi_core *core = &sas_ha->core;
 
         spin_lock_init(&core->task_queue_lock);
         core->task_queue_size = 0;
         INIT_LIST_HEAD(&core->task_queue);
-        init_MUTEX_LOCKED(&core->queue_thread_sema);
 
-        res = kernel_thread(sas_queue_thread, sas_ha, 0);
-        if (res >= 0)
-                wait_for_completion(&queue_th_comp);
-
-        return res < 0 ? res : 0;
+        core->queue_thread = kthread_run(sas_queue_thread, sas_ha,
+                                         "sas_queue_%d", core->shost->host_no);
+        if (IS_ERR(core->queue_thread))
+                return PTR_ERR(core->queue_thread);
+        return 0;
 }
 
 void sas_shutdown_queue(struct sas_ha_struct *sas_ha)
@@ -909,10 +902,7 @@ void sas_shutdown_queue(struct sas_ha_struct *sas_ha)
         struct scsi_core *core = &sas_ha->core;
         struct sas_task *task, *n;
 
-        init_completion(&queue_th_comp);
-        core->queue_thread_kill = 1;
-        up(&core->queue_thread_sema);
-        wait_for_completion(&queue_th_comp);
+        kthread_stop(core->queue_thread);
 
         if (!list_empty(&core->task_queue))
                 SAS_DPRINTK("HA: %llx: scsi core task queue is NOT empty!?\n",
diff --git a/drivers/scsi/lpfc/lpfc.h b/drivers/scsi/lpfc/lpfc.h
index a7de0bca5bdd..82e8f90c4617 100644
--- a/drivers/scsi/lpfc/lpfc.h
+++ b/drivers/scsi/lpfc/lpfc.h
@@ -1,7 +1,7 @@
 /*******************************************************************
  * This file is part of the Emulex Linux Device Driver for         *
  * Fibre Channel Host Bus Adapters.                                *
- * Copyright (C) 2004-2006 Emulex.  All rights reserved.           *
+ * Copyright (C) 2004-2007 Emulex.  All rights reserved.           *
  * EMULEX and SLI are trademarks of Emulex.                        *
  * www.emulex.com                                                  *
  * Portions Copyright (C) 2004-2005 Christoph Hellwig              *
@@ -27,10 +27,6 @@ struct lpfc_sli2_slim;
                                            requests */
 #define LPFC_MAX_NS_RETRY       3       /* Number of retry attempts to contact
                                            the NameServer  before giving up. */
-#define LPFC_DFT_HBA_Q_DEPTH    2048    /* max cmds per hba */
-#define LPFC_LC_HBA_Q_DEPTH     1024    /* max cmds per low cost hba */
-#define LPFC_LP101_HBA_Q_DEPTH  128     /* max cmds per low cost hba */
-
 #define LPFC_CMD_PER_LUN        3       /* max outstanding cmds per lun */
 #define LPFC_SG_SEG_CNT         64      /* sg element count per scsi cmnd */
 #define LPFC_IOCB_LIST_CNT      2250    /* list of IOCBs for fast-path usage. */
@@ -244,28 +240,23 @@ struct lpfc_hba {
 #define FC_FABRIC               0x100   /* We are fabric attached */
 #define FC_ESTABLISH_LINK       0x200   /* Reestablish Link */
 #define FC_RSCN_DISCOVERY       0x400   /* Authenticate all devices after RSCN*/
+#define FC_BLOCK_MGMT_IO        0x800   /* Don't allow mgmt mbx or iocb cmds */
 #define FC_LOADING              0x1000  /* HBA in process of loading drvr */
 #define FC_UNLOADING            0x2000  /* HBA in process of unloading drvr */
 #define FC_SCSI_SCAN_TMO        0x4000  /* scsi scan timer running */
 #define FC_ABORT_DISCOVERY      0x8000  /* we want to abort discovery */
 #define FC_NDISC_ACTIVE         0x10000 /* NPort discovery active */
 #define FC_BYPASSED_MODE        0x20000 /* NPort is in bypassed mode */
+#define FC_LOOPBACK_MODE        0x40000 /* NPort is in Loopback mode */
+                                        /* This flag is set while issuing */
+                                        /* INIT_LINK mailbox command */
+#define FC_IGNORE_ERATT         0x80000 /* intr handler should ignore ERATT */
 
         uint32_t fc_topology;   /* link topology, from LINK INIT */
 
         struct lpfc_stats fc_stat;
 
-        /* These are the head/tail pointers for the bind, plogi, adisc, unmap,
-         *  and map lists.  Their counters are immediately following.
-         */
-        struct list_head fc_plogi_list;
-        struct list_head fc_adisc_list;
-        struct list_head fc_reglogin_list;
-        struct list_head fc_prli_list;
-        struct list_head fc_nlpunmap_list;
-        struct list_head fc_nlpmap_list;
-        struct list_head fc_npr_list;
-        struct list_head fc_unused_list;
+        struct list_head fc_nodes;
 
         /* Keep counters for the number of entries in each list. */
         uint16_t fc_plogi_cnt;
@@ -387,13 +378,17 @@ struct lpfc_hba {
 
         mempool_t *mbox_mem_pool;
         mempool_t *nlp_mem_pool;
-        struct list_head freebufList;
-        struct list_head ctrspbuflist;
-        struct list_head rnidrspbuflist;
 
         struct fc_host_statistics link_stats;
 };
 
+static inline void
+lpfc_set_loopback_flag(struct lpfc_hba *phba) {
+        if (phba->cfg_topology == FLAGS_LOCAL_LB)
+                phba->fc_flag |= FC_LOOPBACK_MODE;
+        else
+                phba->fc_flag &= ~FC_LOOPBACK_MODE;
+}
 
 struct rnidrsp {
         void *buf;
diff --git a/drivers/scsi/lpfc/lpfc_attr.c b/drivers/scsi/lpfc/lpfc_attr.c
index f247e786af99..95fe77e816f8 100644
--- a/drivers/scsi/lpfc/lpfc_attr.c
+++ b/drivers/scsi/lpfc/lpfc_attr.c
@@ -1,7 +1,7 @@
 /*******************************************************************
  * This file is part of the Emulex Linux Device Driver for         *
  * Fibre Channel Host Bus Adapters.                                *
- * Copyright (C) 2004-2006 Emulex.  All rights reserved.           *
+ * Copyright (C) 2004-2007 Emulex.  All rights reserved.           *
  * EMULEX and SLI are trademarks of Emulex.                        *
  * www.emulex.com                                                  *
  * Portions Copyright (C) 2004-2005 Christoph Hellwig              *
@@ -20,6 +20,7 @@
  *******************************************************************/
 
 #include <linux/ctype.h>
+#include <linux/delay.h>
 #include <linux/pci.h>
 #include <linux/interrupt.h>
 
@@ -213,6 +214,7 @@ lpfc_issue_lip(struct Scsi_Host *host)
         int mbxstatus = MBXERR_ERROR;
 
         if ((phba->fc_flag & FC_OFFLINE_MODE) ||
+            (phba->fc_flag & FC_BLOCK_MGMT_IO) ||
             (phba->hba_state != LPFC_HBA_READY))
                 return -EPERM;
 
@@ -235,6 +237,7 @@ lpfc_issue_lip(struct Scsi_Host *host)
                                                      phba->fc_ratov * 2);
         }
 
+        lpfc_set_loopback_flag(phba);
         if (mbxstatus == MBX_TIMEOUT)
                 pmboxq->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
         else
@@ -247,19 +250,62 @@ lpfc_issue_lip(struct Scsi_Host *host)
 }
 
 static int
-lpfc_selective_reset(struct lpfc_hba *phba)
+lpfc_do_offline(struct lpfc_hba *phba, uint32_t type)
 {
         struct completion online_compl;
+        struct lpfc_sli_ring *pring;
+        struct lpfc_sli *psli;
         int status = 0;
+        int cnt = 0;
+        int i;
 
         init_completion(&online_compl);
         lpfc_workq_post_event(phba, &status, &online_compl,
-                              LPFC_EVT_OFFLINE);
+                              LPFC_EVT_OFFLINE_PREP);
+        wait_for_completion(&online_compl);
+
+        if (status != 0)
+                return -EIO;
+
+        psli = &phba->sli;
+
+        for (i = 0; i < psli->num_rings; i++) {
+                pring = &psli->ring[i];
+                /* The linkdown event takes 30 seconds to timeout. */
+                while (pring->txcmplq_cnt) {
+                        msleep(10);
+                        if (cnt++ > 3000) {
+                                lpfc_printf_log(phba,
+                                        KERN_WARNING, LOG_INIT,
+                                        "%d:0466 Outstanding IO when "
+                                        "bringing Adapter offline\n",
+                                        phba->brd_no);
+                                break;
+                        }
+                }
+        }
+
+        init_completion(&online_compl);
+        lpfc_workq_post_event(phba, &status, &online_compl, type);
         wait_for_completion(&online_compl);
 
         if (status != 0)
                 return -EIO;
 
+        return 0;
+}
+
+static int
+lpfc_selective_reset(struct lpfc_hba *phba)
+{
+        struct completion online_compl;
+        int status = 0;
+
+        status = lpfc_do_offline(phba, LPFC_EVT_OFFLINE);
+
+        if (status != 0)
+                return status;
+
         init_completion(&online_compl);
         lpfc_workq_post_event(phba, &status, &online_compl,
                               LPFC_EVT_ONLINE);
@@ -324,23 +370,19 @@ lpfc_board_mode_store(struct class_device *cdev, const char *buf, size_t count)
 
         init_completion(&online_compl);
 
-        if(strncmp(buf, "online", sizeof("online") - 1) == 0)
+        if(strncmp(buf, "online", sizeof("online") - 1) == 0) {
                 lpfc_workq_post_event(phba, &status, &online_compl,
                                       LPFC_EVT_ONLINE);
-        else if (strncmp(buf, "offline", sizeof("offline") - 1) == 0)
-                lpfc_workq_post_event(phba, &status, &online_compl,
-                                      LPFC_EVT_OFFLINE);
+                wait_for_completion(&online_compl);
+        } else if (strncmp(buf, "offline", sizeof("offline") - 1) == 0)
+                status = lpfc_do_offline(phba, LPFC_EVT_OFFLINE);
         else if (strncmp(buf, "warm", sizeof("warm") - 1) == 0)
-                lpfc_workq_post_event(phba, &status, &online_compl,
-                                      LPFC_EVT_WARM_START);
-        else if (strncmp(buf, "error", sizeof("error") - 1) == 0)
-                lpfc_workq_post_event(phba, &status, &online_compl,
-                                      LPFC_EVT_KILL);
+                status = lpfc_do_offline(phba, LPFC_EVT_WARM_START);
+        else if (strncmp(buf, "error", sizeof("error") - 1) == 0)
+                status = lpfc_do_offline(phba, LPFC_EVT_KILL);
         else
                 return -EINVAL;
 
-        wait_for_completion(&online_compl);
-
         if (!status)
                 return strlen(buf);
         else
@@ -645,9 +687,7 @@ lpfc_soft_wwpn_store(struct class_device *cdev, const char *buf, size_t count)
         dev_printk(KERN_NOTICE, &phba->pcidev->dev,
                    "lpfc%d: Reinitializing to use soft_wwpn\n", phba->brd_no);
 
-        init_completion(&online_compl);
-        lpfc_workq_post_event(phba, &stat1, &online_compl, LPFC_EVT_OFFLINE);
-        wait_for_completion(&online_compl);
+        stat1 = lpfc_do_offline(phba, LPFC_EVT_OFFLINE);
         if (stat1)
                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
                         "%d:0463 lpfc_soft_wwpn attribute set failed to reinit "
@@ -789,6 +829,18 @@ lpfc_nodev_tmo_init(struct lpfc_hba *phba, int val)
         return -EINVAL;
 }
 
+static void
+lpfc_update_rport_devloss_tmo(struct lpfc_hba *phba)
+{
+        struct lpfc_nodelist  *ndlp;
+
+        spin_lock_irq(phba->host->host_lock);
+        list_for_each_entry(ndlp, &phba->fc_nodes, nlp_listp)
+                if (ndlp->rport)
+                        ndlp->rport->dev_loss_tmo = phba->cfg_devloss_tmo;
+        spin_unlock_irq(phba->host->host_lock);
+}
+
 static int
 lpfc_nodev_tmo_set(struct lpfc_hba *phba, int val)
 {
@@ -804,6 +856,7 @@ lpfc_nodev_tmo_set(struct lpfc_hba *phba, int val)
         if (val >= LPFC_MIN_DEVLOSS_TMO && val <= LPFC_MAX_DEVLOSS_TMO) {
                 phba->cfg_nodev_tmo = val;
                 phba->cfg_devloss_tmo = val;
+                lpfc_update_rport_devloss_tmo(phba);
                 return 0;
         }
 
@@ -839,6 +892,7 @@ lpfc_devloss_tmo_set(struct lpfc_hba *phba, int val)
                 phba->cfg_nodev_tmo = val;
                 phba->cfg_devloss_tmo = val;
                 phba->dev_loss_tmo_changed = 1;
+                lpfc_update_rport_devloss_tmo(phba);
                 return 0;
         }
 
@@ -931,9 +985,10 @@ LPFC_ATTR_RW(topology, 0, 0, 6, "Select Fibre Channel topology");
 #       1  = 1 Gigabaud
 #       2  = 2 Gigabaud
 #       4  = 4 Gigabaud
-# Value range is [0,4]. Default value is 0.
+#       8  = 8 Gigabaud
+# Value range is [0,8]. Default value is 0.
 */
-LPFC_ATTR_R(link_speed, 0, 0, 4, "Select link speed");
+LPFC_ATTR_R(link_speed, 0, 0, 8, "Select link speed");
 
 /*
 # lpfc_fcp_class:  Determines FC class to use for the FCP protocol.
@@ -958,7 +1013,7 @@ LPFC_ATTR_R(ack0, 0, 0, 1, "Enable ACK0 support");
 /*
 # lpfc_cr_delay & lpfc_cr_count: Default values for I/O colaesing
 # cr_delay (msec) or cr_count outstanding commands. cr_delay can take
-# value [0,63]. cr_count can take value [0,255]. Default value of cr_delay
+# value [0,63]. cr_count can take value [1,255]. Default value of cr_delay
 # is 0. Default value of cr_count is 1. The cr_count feature is disabled if
 # cr_delay is set to 0.
 */
@@ -1227,11 +1282,11 @@ sysfs_mbox_read(struct kobject *kobj, char *buf, loff_t off, size_t count)
         struct lpfc_hba *phba = (struct lpfc_hba*)host->hostdata;
         int rc;
 
-        if (off > sizeof(MAILBOX_t))
+        if (off > MAILBOX_CMD_SIZE)
                 return -ERANGE;
 
-        if ((count + off) > sizeof(MAILBOX_t))
-                count = sizeof(MAILBOX_t) - off;
+        if ((count + off) > MAILBOX_CMD_SIZE)
+                count = MAILBOX_CMD_SIZE - off;
 
         if (off % 4 ||  count % 4 || (unsigned long)buf % 4)
                 return -EINVAL;
@@ -1307,6 +1362,12 @@ sysfs_mbox_read(struct kobject *kobj, char *buf, loff_t off, size_t count)
                         return -EPERM;
                 }
 
+                if (phba->fc_flag & FC_BLOCK_MGMT_IO) {
+                        sysfs_mbox_idle(phba);
+                        spin_unlock_irq(host->host_lock);
+                        return  -EAGAIN;
+                }
+
                 if ((phba->fc_flag & FC_OFFLINE_MODE) ||
                     (!(phba->sli.sli_flag & LPFC_SLI2_ACTIVE))){
 
@@ -1326,6 +1387,11 @@ sysfs_mbox_read(struct kobject *kobj, char *buf, loff_t off, size_t count)
                 }
 
                 if (rc != MBX_SUCCESS) {
+                        if (rc == MBX_TIMEOUT) {
+                                phba->sysfs_mbox.mbox->mbox_cmpl =
+                                        lpfc_sli_def_mbox_cmpl;
+                                phba->sysfs_mbox.mbox = NULL;
+                        }
                         sysfs_mbox_idle(phba);
                         spin_unlock_irq(host->host_lock);
                         return  (rc == MBX_TIMEOUT) ? -ETIME : -ENODEV;
@@ -1344,7 +1410,7 @@ sysfs_mbox_read(struct kobject *kobj, char *buf, loff_t off, size_t count)
 
         phba->sysfs_mbox.offset = off + count;
 
-        if (phba->sysfs_mbox.offset == sizeof(MAILBOX_t))
+        if (phba->sysfs_mbox.offset == MAILBOX_CMD_SIZE)
                 sysfs_mbox_idle(phba);
 
         spin_unlock_irq(phba->host->host_lock);
@@ -1358,7 +1424,7 @@ static struct bin_attribute sysfs_mbox_attr = {
                 .mode = S_IRUSR | S_IWUSR,
                 .owner = THIS_MODULE,
         },
-        .size = sizeof(MAILBOX_t),
+        .size = MAILBOX_CMD_SIZE,
         .read = sysfs_mbox_read,
         .write = sysfs_mbox_write,
 };
@@ -1494,6 +1560,9 @@ lpfc_get_host_speed(struct Scsi_Host *shost)
                         case LA_4GHZ_LINK:
                                 fc_host_speed(shost) = FC_PORTSPEED_4GBIT;
                         break;
+                        case LA_8GHZ_LINK:
+                                fc_host_speed(shost) = FC_PORTSPEED_8GBIT;
+                        break;
                         default:
                                 fc_host_speed(shost) = FC_PORTSPEED_UNKNOWN;
                         break;
@@ -1546,6 +1615,9 @@ lpfc_get_stats(struct Scsi_Host *shost)
         unsigned long seconds;
         int rc = 0;
 
+        if (phba->fc_flag & FC_BLOCK_MGMT_IO)
+                return NULL;
+
         pmboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
         if (!pmboxq)
                 return NULL;
@@ -1631,6 +1703,8 @@ lpfc_get_stats(struct Scsi_Host *shost)
         else
                 hs->seconds_since_last_reset = seconds - psli->stats_start;
 
+        mempool_free(pmboxq, phba->mbox_mem_pool);
+
         return hs;
 }
 
@@ -1644,6 +1718,9 @@ lpfc_reset_stats(struct Scsi_Host *shost)
         MAILBOX_t *pmb;
         int rc = 0;
 
+        if (phba->fc_flag & FC_BLOCK_MGMT_IO)
+                return;
+
         pmboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
         if (!pmboxq)
                 return;
@@ -1699,6 +1776,8 @@ lpfc_reset_stats(struct Scsi_Host *shost)
 
         psli->stats_start = get_seconds();
 
+        mempool_free(pmboxq, phba->mbox_mem_pool);
+
         return;
 }
 
@@ -1706,67 +1785,51 @@ lpfc_reset_stats(struct Scsi_Host *shost)
  * The LPFC driver treats linkdown handling as target loss events so there
  * are no sysfs handlers for link_down_tmo.
  */
-static void
-lpfc_get_starget_port_id(struct scsi_target *starget)
+
+static struct lpfc_nodelist *
+lpfc_get_node_by_target(struct scsi_target *starget)
 {
         struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
         struct lpfc_hba *phba = (struct lpfc_hba *) shost->hostdata;
-        uint32_t did = -1;
-        struct lpfc_nodelist *ndlp = NULL;
+        struct lpfc_nodelist *ndlp;
 
         spin_lock_irq(shost->host_lock);
-        /* Search the mapped list for this target ID */
-        list_for_each_entry(ndlp, &phba->fc_nlpmap_list, nlp_listp) {
-                if (starget->id == ndlp->nlp_sid) {
-                        did = ndlp->nlp_DID;
-                        break;
+        /* Search for this, mapped, target ID */
+        list_for_each_entry(ndlp, &phba->fc_nodes, nlp_listp) {
+                if (ndlp->nlp_state == NLP_STE_MAPPED_NODE &&
+                    starget->id == ndlp->nlp_sid) {
+                        spin_unlock_irq(shost->host_lock);
+                        return ndlp;
                 }
         }
         spin_unlock_irq(shost->host_lock);
+        return NULL;
+}
+
+static void
+lpfc_get_starget_port_id(struct scsi_target *starget)
+{
+        struct lpfc_nodelist *ndlp = lpfc_get_node_by_target(starget);
 
-        fc_starget_port_id(starget) = did;
+        fc_starget_port_id(starget) = ndlp ? ndlp->nlp_DID : -1;
 }
 
 static void
 lpfc_get_starget_node_name(struct scsi_target *starget)
 {
-        struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
-        struct lpfc_hba *phba = (struct lpfc_hba *) shost->hostdata;
-        u64 node_name = 0;
-        struct lpfc_nodelist *ndlp = NULL;
-
-        spin_lock_irq(shost->host_lock);
-        /* Search the mapped list for this target ID */
-        list_for_each_entry(ndlp, &phba->fc_nlpmap_list, nlp_listp) {
-                if (starget->id == ndlp->nlp_sid) {
-                        node_name = wwn_to_u64(ndlp->nlp_nodename.u.wwn);
-                        break;
-                }
-        }
-        spin_unlock_irq(shost->host_lock);
+        struct lpfc_nodelist *ndlp = lpfc_get_node_by_target(starget);
 
-        fc_starget_node_name(starget) = node_name;
+        fc_starget_node_name(starget) =
+                ndlp ? wwn_to_u64(ndlp->nlp_nodename.u.wwn) : 0;
 }
 
 static void
 lpfc_get_starget_port_name(struct scsi_target *starget)
 {
-        struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
-        struct lpfc_hba *phba = (struct lpfc_hba *) shost->hostdata;
-        u64 port_name = 0;
-        struct lpfc_nodelist *ndlp = NULL;
-
-        spin_lock_irq(shost->host_lock);
-        /* Search the mapped list for this target ID */
-        list_for_each_entry(ndlp, &phba->fc_nlpmap_list, nlp_listp) {
-                if (starget->id == ndlp->nlp_sid) {
-                        port_name = wwn_to_u64(ndlp->nlp_portname.u.wwn);
-                        break;
-                }
-        }
-        spin_unlock_irq(shost->host_lock);
+        struct lpfc_nodelist *ndlp = lpfc_get_node_by_target(starget);
 
-        fc_starget_port_name(starget) = port_name;
+        fc_starget_port_name(starget) =
+                ndlp ? wwn_to_u64(ndlp->nlp_portname.u.wwn) : 0;
 }
 
 static void
@@ -1895,25 +1958,8 @@ lpfc_get_cfgparam(struct lpfc_hba *phba)
                         sizeof(struct fcp_rsp) +
                         (phba->cfg_sg_seg_cnt * sizeof(struct ulp_bde64));
 
-        switch (phba->pcidev->device) {
-        case PCI_DEVICE_ID_LP101:
-        case PCI_DEVICE_ID_BSMB:
-        case PCI_DEVICE_ID_ZSMB:
-                phba->cfg_hba_queue_depth = LPFC_LP101_HBA_Q_DEPTH;
-                break;
-        case PCI_DEVICE_ID_RFLY:
-        case PCI_DEVICE_ID_PFLY:
-        case PCI_DEVICE_ID_BMID:
-        case PCI_DEVICE_ID_ZMID:
-        case PCI_DEVICE_ID_TFLY:
-                phba->cfg_hba_queue_depth = LPFC_LC_HBA_Q_DEPTH;
-                break;
-        default:
-                phba->cfg_hba_queue_depth = LPFC_DFT_HBA_Q_DEPTH;
-        }
 
-        if (phba->cfg_hba_queue_depth > lpfc_hba_queue_depth)
-                lpfc_hba_queue_depth_init(phba, lpfc_hba_queue_depth);
+        lpfc_hba_queue_depth_init(phba, lpfc_hba_queue_depth);
 
         return;
 }
diff --git a/drivers/scsi/lpfc/lpfc_crtn.h b/drivers/scsi/lpfc/lpfc_crtn.h
index 1251788ce2a3..b8c2a8862d8c 100644
--- a/drivers/scsi/lpfc/lpfc_crtn.h
+++ b/drivers/scsi/lpfc/lpfc_crtn.h
@@ -1,7 +1,7 @@
 /*******************************************************************
  * This file is part of the Emulex Linux Device Driver for         *
  * Fibre Channel Host Bus Adapters.                                *
- * Copyright (C) 2004-2006 Emulex.  All rights reserved.           *
+ * Copyright (C) 2004-2007 Emulex.  All rights reserved.           *
  * EMULEX and SLI are trademarks of Emulex.                        *
  * www.emulex.com                                                  *
  *                                                                 *
@@ -18,6 +18,8 @@
  * included with this package.                                     *
  *******************************************************************/
 
+typedef int (*node_filter)(struct lpfc_nodelist *ndlp, void *param);
+
 struct fc_rport;
 void lpfc_dump_mem(struct lpfc_hba *, LPFC_MBOXQ_t *, uint16_t);
 void lpfc_read_nv(struct lpfc_hba *, LPFC_MBOXQ_t *);
@@ -43,20 +45,24 @@ void lpfc_mbx_cmpl_reg_login(struct lpfc_hba *, LPFC_MBOXQ_t *);
 void lpfc_mbx_cmpl_fabric_reg_login(struct lpfc_hba *, LPFC_MBOXQ_t *);
 void lpfc_mbx_cmpl_ns_reg_login(struct lpfc_hba *, LPFC_MBOXQ_t *);
 void lpfc_mbx_cmpl_fdmi_reg_login(struct lpfc_hba *, LPFC_MBOXQ_t *);
-int lpfc_nlp_list(struct lpfc_hba *, struct lpfc_nodelist *, int);
+void lpfc_dequeue_node(struct lpfc_hba *, struct lpfc_nodelist *);
+void lpfc_nlp_set_state(struct lpfc_hba *, struct lpfc_nodelist *, int);
+void lpfc_drop_node(struct lpfc_hba *, struct lpfc_nodelist *);
 void lpfc_set_disctmo(struct lpfc_hba *);
 int lpfc_can_disctmo(struct lpfc_hba *);
 int lpfc_unreg_rpi(struct lpfc_hba *, struct lpfc_nodelist *);
 int lpfc_check_sli_ndlp(struct lpfc_hba *, struct lpfc_sli_ring *,
                     struct lpfc_iocbq *, struct lpfc_nodelist *);
-int lpfc_nlp_remove(struct lpfc_hba *, struct lpfc_nodelist *);
 void lpfc_nlp_init(struct lpfc_hba *, struct lpfc_nodelist *, uint32_t);
+struct lpfc_nodelist *lpfc_nlp_get(struct lpfc_nodelist *);
+int  lpfc_nlp_put(struct lpfc_nodelist *);
 struct lpfc_nodelist *lpfc_setup_disc_node(struct lpfc_hba *, uint32_t);
 void lpfc_disc_list_loopmap(struct lpfc_hba *);
 void lpfc_disc_start(struct lpfc_hba *);
 void lpfc_disc_flush_list(struct lpfc_hba *);
 void lpfc_disc_timeout(unsigned long);
 
+struct lpfc_nodelist *__lpfc_findnode_rpi(struct lpfc_hba * phba, uint16_t rpi);
 struct lpfc_nodelist *lpfc_findnode_rpi(struct lpfc_hba * phba, uint16_t rpi);
 
 int lpfc_workq_post_event(struct lpfc_hba *, void *, void *, uint32_t);
@@ -66,8 +72,7 @@ int lpfc_disc_state_machine(struct lpfc_hba *, struct lpfc_nodelist *, void *,
 
 int lpfc_check_sparm(struct lpfc_hba *, struct lpfc_nodelist *,
                      struct serv_parm *, uint32_t);
-int lpfc_els_abort(struct lpfc_hba *, struct lpfc_nodelist * ndlp,
-                        int);
+int lpfc_els_abort(struct lpfc_hba *, struct lpfc_nodelist * ndlp);
 int lpfc_els_abort_flogi(struct lpfc_hba *);
 int lpfc_initial_flogi(struct lpfc_hba *);
 int lpfc_issue_els_plogi(struct lpfc_hba *, uint32_t, uint8_t);
@@ -113,7 +118,10 @@ void lpfc_hba_init(struct lpfc_hba *, uint32_t *);
 int lpfc_post_buffer(struct lpfc_hba *, struct lpfc_sli_ring *, int, int);
 void lpfc_decode_firmware_rev(struct lpfc_hba *, char *, int);
 int lpfc_online(struct lpfc_hba *);
-int lpfc_offline(struct lpfc_hba *);
+void lpfc_block_mgmt_io(struct lpfc_hba *);
+void lpfc_unblock_mgmt_io(struct lpfc_hba *);
+void lpfc_offline_prep(struct lpfc_hba *);
+void lpfc_offline(struct lpfc_hba *);
 
 int lpfc_sli_setup(struct lpfc_hba *);
 int lpfc_sli_queue_setup(struct lpfc_hba *);
@@ -162,8 +170,8 @@ int lpfc_sli_ringpostbuf_put(struct lpfc_hba *, struct lpfc_sli_ring *,
 struct lpfc_dmabuf *lpfc_sli_ringpostbuf_get(struct lpfc_hba *,
                                              struct lpfc_sli_ring *,
                                              dma_addr_t);
-int lpfc_sli_issue_abort_iotag32(struct lpfc_hba *, struct lpfc_sli_ring *,
-                                 struct lpfc_iocbq *);
+int lpfc_sli_issue_abort_iotag(struct lpfc_hba *, struct lpfc_sli_ring *,
+                               struct lpfc_iocbq *);
 int lpfc_sli_sum_iocb(struct lpfc_hba *, struct lpfc_sli_ring *, uint16_t,
                           uint64_t, lpfc_ctx_cmd);
 int lpfc_sli_abort_iocb(struct lpfc_hba *, struct lpfc_sli_ring *, uint16_t,
@@ -172,9 +180,8 @@ int lpfc_sli_abort_iocb(struct lpfc_hba *, struct lpfc_sli_ring *, uint16_t,
 void lpfc_mbox_timeout(unsigned long);
 void lpfc_mbox_timeout_handler(struct lpfc_hba *);
 
-struct lpfc_nodelist *lpfc_findnode_did(struct lpfc_hba *, uint32_t, uint32_t);
-struct lpfc_nodelist *lpfc_findnode_wwpn(struct lpfc_hba *, uint32_t,
-                                        struct lpfc_name *);
+struct lpfc_nodelist *lpfc_findnode_did(struct lpfc_hba *, uint32_t);
+struct lpfc_nodelist *lpfc_findnode_wwpn(struct lpfc_hba *, struct lpfc_name *);
 
 int lpfc_sli_issue_mbox_wait(struct lpfc_hba * phba, LPFC_MBOXQ_t * pmboxq,
                          uint32_t timeout);
@@ -193,6 +200,9 @@ void lpfc_mbuf_free(struct lpfc_hba *, void *, dma_addr_t);
 
 /* Function prototypes. */
 const char* lpfc_info(struct Scsi_Host *);
+void lpfc_scan_start(struct Scsi_Host *);
+int lpfc_scan_finished(struct Scsi_Host *, unsigned long);
+
 void lpfc_get_cfgparam(struct lpfc_hba *);
 int lpfc_alloc_sysfs_attr(struct lpfc_hba *);
 void lpfc_free_sysfs_attr(struct lpfc_hba *);
diff --git a/drivers/scsi/lpfc/lpfc_ct.c b/drivers/scsi/lpfc/lpfc_ct.c
index a51a41b7f15d..34a9e3bb2614 100644
--- a/drivers/scsi/lpfc/lpfc_ct.c
+++ b/drivers/scsi/lpfc/lpfc_ct.c
@@ -1,7 +1,7 @@
 /*******************************************************************
  * This file is part of the Emulex Linux Device Driver for         *
  * Fibre Channel Host Bus Adapters.                                *
- * Copyright (C) 2004-2006 Emulex.  All rights reserved.           *
+ * Copyright (C) 2004-2007 Emulex.  All rights reserved.           *
  * EMULEX and SLI are trademarks of Emulex.                        *
  * www.emulex.com                                                  *
  *                                                                 *
@@ -334,21 +334,22 @@ lpfc_ns_rsp(struct lpfc_hba * phba, struct lpfc_dmabuf * mp, uint32_t Size)
 
         lpfc_set_disctmo(phba);
 
-        Cnt = Size  > FCELSSIZE ? FCELSSIZE : Size;
 
         list_add_tail(&head, &mp->list);
         list_for_each_entry_safe(mp, next_mp, &head, list) {
                 mlast = mp;
 
+                Cnt = Size  > FCELSSIZE ? FCELSSIZE : Size;
+
                 Size -= Cnt;
 
-                if (!ctptr)
+                if (!ctptr) {
                         ctptr = (uint32_t *) mlast->virt;
-                else
+                } else
                         Cnt -= 16;      /* subtract length of CT header */
 
                 /* Loop through entire NameServer list of DIDs */
-                while (Cnt) {
+                while (Cnt >= sizeof (uint32_t)) {
 
                         /* Get next DID from NameServer List */
                         CTentry = *ctptr++;
@@ -442,10 +443,8 @@ lpfc_cmpl_ct_cmd_gid_ft(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
                 if (phba->fc_ns_retry < LPFC_MAX_NS_RETRY) {
                         phba->fc_ns_retry++;
                         /* CT command is being retried */
-                        ndlp =
-                            lpfc_findnode_did(phba, NLP_SEARCH_UNMAPPED,
-                                              NameServer_DID);
-                        if (ndlp) {
+                        ndlp = lpfc_findnode_did(phba, NameServer_DID);
+                        if (ndlp && ndlp->nlp_state == NLP_STE_UNMAPPED_NODE) {
                                 if (lpfc_ns_cmd(phba, ndlp, SLI_CTNS_GID_FT) ==
                                     0) {
                                         goto out;
@@ -729,7 +728,7 @@ lpfc_cmpl_ct_cmd_fdmi(struct lpfc_hba * phba,
         uint16_t fdmi_cmd = CTcmd->CommandResponse.bits.CmdRsp;
         uint16_t fdmi_rsp = CTrsp->CommandResponse.bits.CmdRsp;
 
-        ndlp = lpfc_findnode_did(phba, NLP_SEARCH_ALL, FDMI_DID);
+        ndlp = lpfc_findnode_did(phba, FDMI_DID);
         if (fdmi_rsp == be16_to_cpu(SLI_CT_RESPONSE_FS_RJT)) {
                 /* FDMI rsp failed */
                 lpfc_printf_log(phba,
@@ -1039,6 +1038,9 @@ lpfc_fdmi_cmd(struct lpfc_hba * phba, struct lpfc_nodelist * ndlp, int cmdcode)
                                 case LA_4GHZ_LINK:
                                         ae->un.PortSpeed = HBA_PORTSPEED_4GBIT;
                                 break;
+                                case LA_8GHZ_LINK:
+                                        ae->un.PortSpeed = HBA_PORTSPEED_8GBIT;
+                                break;
                                 default:
                                         ae->un.PortSpeed =
                                                 HBA_PORTSPEED_UNKNOWN;
@@ -1161,7 +1163,7 @@ lpfc_fdmi_tmo_handler(struct lpfc_hba *phba)
 {
         struct lpfc_nodelist *ndlp;
 
-        ndlp = lpfc_findnode_did(phba, NLP_SEARCH_ALL, FDMI_DID);
+        ndlp = lpfc_findnode_did(phba, FDMI_DID);
         if (ndlp) {
                 if (init_utsname()->nodename[0] != '\0') {
                         lpfc_fdmi_cmd(phba, ndlp, SLI_MGMT_DHBA);
diff --git a/drivers/scsi/lpfc/lpfc_disc.h b/drivers/scsi/lpfc/lpfc_disc.h
index 9766f909c9c6..498059f3f7f4 100644
--- a/drivers/scsi/lpfc/lpfc_disc.h
+++ b/drivers/scsi/lpfc/lpfc_disc.h
@@ -1,7 +1,7 @@
 /*******************************************************************
  * This file is part of the Emulex Linux Device Driver for         *
  * Fibre Channel Host Bus Adapters.                                *
- * Copyright (C) 2004-2006 Emulex.  All rights reserved.           *
+ * Copyright (C) 2004-2007 Emulex.  All rights reserved.           *
  * EMULEX and SLI are trademarks of Emulex.                        *
  * www.emulex.com                                                  *
  *                                                                 *
@@ -31,6 +31,7 @@
 /* worker thread events */
 enum lpfc_work_type {
         LPFC_EVT_ONLINE,
+        LPFC_EVT_OFFLINE_PREP,
         LPFC_EVT_OFFLINE,
         LPFC_EVT_WARM_START,
         LPFC_EVT_KILL,
@@ -68,7 +69,6 @@ struct lpfc_nodelist {
         uint16_t        nlp_maxframe;           /* Max RCV frame size */
         uint8_t         nlp_class_sup;          /* Supported Classes */
         uint8_t         nlp_retry;              /* used for ELS retries */
-        uint8_t         nlp_disc_refcnt;        /* used for DSM */
         uint8_t         nlp_fcp_info;           /* class info, bits 0-3 */
 #define NLP_FCP_2_DEVICE   0x10                 /* FCP-2 device */
 
@@ -79,20 +79,10 @@ struct lpfc_nodelist {
         struct lpfc_work_evt els_retry_evt;
         unsigned long last_ramp_up_time;        /* jiffy of last ramp up */
         unsigned long last_q_full_time;         /* jiffy of last queue full */
+        struct kref     kref;
 };
 
 /* Defines for nlp_flag (uint32) */
-#define NLP_NO_LIST        0x0          /* Indicates immediately free node */
-#define NLP_UNUSED_LIST    0x1          /* Flg to indicate node will be freed */
-#define NLP_PLOGI_LIST     0x2          /* Flg to indicate sent PLOGI */
-#define NLP_ADISC_LIST     0x3          /* Flg to indicate sent ADISC */
-#define NLP_REGLOGIN_LIST  0x4          /* Flg to indicate sent REG_LOGIN */
-#define NLP_PRLI_LIST      0x5          /* Flg to indicate sent PRLI */
-#define NLP_UNMAPPED_LIST  0x6          /* Node is now unmapped */
-#define NLP_MAPPED_LIST    0x7          /* Node is now mapped */
-#define NLP_NPR_LIST       0x8          /* Node is in NPort Recovery state */
-#define NLP_JUST_DQ        0x9          /* just deque ndlp in lpfc_nlp_list */
-#define NLP_LIST_MASK      0xf          /* mask to see what list node is on */
 #define NLP_PLOGI_SND      0x20         /* sent PLOGI request for this entry */
 #define NLP_PRLI_SND       0x40         /* sent PRLI request for this entry */
 #define NLP_ADISC_SND      0x80         /* sent ADISC request for this entry */
@@ -108,20 +98,8 @@ struct lpfc_nodelist {
                                            ACC */
 #define NLP_NPR_ADISC      0x2000000    /* Issue ADISC when dq'ed from
                                            NPR list */
-#define NLP_DELAY_REMOVE   0x4000000    /* Defer removal till end of DSM */
 #define NLP_NODEV_REMOVE   0x8000000    /* Defer removal till discovery ends */
 
-/* Defines for list searchs */
-#define NLP_SEARCH_MAPPED    0x1        /* search mapped */
-#define NLP_SEARCH_UNMAPPED  0x2        /* search unmapped */
-#define NLP_SEARCH_PLOGI     0x4        /* search plogi */
-#define NLP_SEARCH_ADISC     0x8        /* search adisc */
-#define NLP_SEARCH_REGLOGIN  0x10       /* search reglogin */
-#define NLP_SEARCH_PRLI      0x20       /* search prli */
-#define NLP_SEARCH_NPR       0x40       /* search npr */
-#define NLP_SEARCH_UNUSED    0x80       /* search mapped */
-#define NLP_SEARCH_ALL       0xff       /* search all lists */
-
 /* There are 4 different double linked lists nodelist entries can reside on.
  * The Port Login (PLOGI) list and Address Discovery (ADISC) list are used
  * when Link Up discovery or Registered State Change Notification (RSCN)
diff --git a/drivers/scsi/lpfc/lpfc_els.c b/drivers/scsi/lpfc/lpfc_els.c
index a5f33a0dd4e7..638b3cd677bd 100644
--- a/drivers/scsi/lpfc/lpfc_els.c
+++ b/drivers/scsi/lpfc/lpfc_els.c
@@ -1,7 +1,7 @@
 /*******************************************************************
  * This file is part of the Emulex Linux Device Driver for         *
  * Fibre Channel Host Bus Adapters.                                *
- * Copyright (C) 2004-2006 Emulex.  All rights reserved.           *
+ * Copyright (C) 2004-2007 Emulex.  All rights reserved.           *
  * EMULEX and SLI are trademarks of Emulex.                        *
  * www.emulex.com                                                  *
  * Portions Copyright (C) 2004-2005 Christoph Hellwig              *
@@ -182,6 +182,7 @@ lpfc_prep_els_iocb(struct lpfc_hba * phba, uint8_t expectRsp,
                 icmd->un.elsreq64.bdl.bdeSize = (2 * sizeof (struct ulp_bde64));
                 icmd->un.elsreq64.remoteID = did;       /* DID */
                 icmd->ulpCommand = CMD_ELS_REQUEST64_CR;
+                icmd->ulpTimeout = phba->fc_ratov * 2;
         } else {
                 icmd->un.elsreq64.bdl.bdeSize = sizeof (struct ulp_bde64);
                 icmd->ulpCommand = CMD_XMIT_ELS_RSP64_CX;
@@ -208,9 +209,9 @@ lpfc_prep_els_iocb(struct lpfc_hba * phba, uint8_t expectRsp,
         }
 
         /* Save for completion so we can release these resources */
-        elsiocb->context1 = (uint8_t *) ndlp;
-        elsiocb->context2 = (uint8_t *) pcmd;
-        elsiocb->context3 = (uint8_t *) pbuflist;
+        elsiocb->context1 = lpfc_nlp_get(ndlp);
+        elsiocb->context2 = pcmd;
+        elsiocb->context3 = pbuflist;
         elsiocb->retry = retry;
         elsiocb->drvrTimeout = (phba->fc_ratov << 1) + LPFC_DRVR_TIMEOUT;
 
@@ -222,16 +223,16 @@ lpfc_prep_els_iocb(struct lpfc_hba * phba, uint8_t expectRsp,
                 /* Xmit ELS command <elsCmd> to remote NPORT <did> */
                 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
                                 "%d:0116 Xmit ELS command x%x to remote "
-                                "NPORT x%x Data: x%x x%x\n",
+                                "NPORT x%x I/O tag: x%x, HBA state: x%x\n",
                                 phba->brd_no, elscmd,
-                                did, icmd->ulpIoTag, phba->hba_state);
+                                did, elsiocb->iotag, phba->hba_state);
         } else {
                 /* Xmit ELS response <elsCmd> to remote NPORT <did> */
                 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
                                 "%d:0117 Xmit ELS response x%x to remote "
-                                "NPORT x%x Data: x%x x%x\n",
+                                "NPORT x%x I/O tag: x%x, size: x%x\n",
                                 phba->brd_no, elscmd,
-                                ndlp->nlp_DID, icmd->ulpIoTag, cmdSize);
+                                ndlp->nlp_DID, elsiocb->iotag, cmdSize);
         }
 
         return elsiocb;
@@ -304,7 +305,7 @@ lpfc_cmpl_els_flogi_fabric(struct lpfc_hba *phba, struct lpfc_nodelist *ndlp,
                 goto fail_free_mbox;
 
         mbox->mbox_cmpl = lpfc_mbx_cmpl_fabric_reg_login;
-        mbox->context2 = ndlp;
+        mbox->context2 = lpfc_nlp_get(ndlp);
 
         rc = lpfc_sli_issue_mbox(phba, mbox, MBX_NOWAIT | MBX_STOP_IOCB);
         if (rc == MBX_NOT_FINISHED)
@@ -313,6 +314,7 @@ lpfc_cmpl_els_flogi_fabric(struct lpfc_hba *phba, struct lpfc_nodelist *ndlp,
         return 0;
 
  fail_issue_reg_login:
+        lpfc_nlp_put(ndlp);
         mp = (struct lpfc_dmabuf *) mbox->context1;
         lpfc_mbuf_free(phba, mp->virt, mp->phys);
         kfree(mp);
@@ -368,9 +370,9 @@ lpfc_cmpl_els_flogi_nport(struct lpfc_hba *phba, struct lpfc_nodelist *ndlp,
                         mempool_free(mbox, phba->mbox_mem_pool);
                         goto fail;
                 }
-                mempool_free(ndlp, phba->nlp_mem_pool);
+                lpfc_nlp_put(ndlp);
 
-                ndlp = lpfc_findnode_did(phba, NLP_SEARCH_ALL, PT2PT_RemoteID);
+                ndlp = lpfc_findnode_did(phba, PT2PT_RemoteID);
                 if (!ndlp) {
                         /*
                          * Cannot find existing Fabric ndlp, so allocate a
@@ -387,12 +389,11 @@ lpfc_cmpl_els_flogi_nport(struct lpfc_hba *phba, struct lpfc_nodelist *ndlp,
                                 sizeof(struct lpfc_name));
                 memcpy(&ndlp->nlp_nodename, &sp->nodeName,
                                 sizeof(struct lpfc_name));
-                ndlp->nlp_state = NLP_STE_NPR_NODE;
-                lpfc_nlp_list(phba, ndlp, NLP_NPR_LIST);
+                lpfc_nlp_set_state(phba, ndlp, NLP_STE_NPR_NODE);
                 ndlp->nlp_flag |= NLP_NPR_2B_DISC;
         } else {
                 /* This side will wait for the PLOGI */
-                mempool_free( ndlp, phba->nlp_mem_pool);
+                lpfc_nlp_put(ndlp);
         }
 
         spin_lock_irq(phba->host->host_lock);
@@ -407,8 +408,8 @@ lpfc_cmpl_els_flogi_nport(struct lpfc_hba *phba, struct lpfc_nodelist *ndlp,
 }
 
 static void
-lpfc_cmpl_els_flogi(struct lpfc_hba * phba,
-                    struct lpfc_iocbq * cmdiocb, struct lpfc_iocbq * rspiocb)
+lpfc_cmpl_els_flogi(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
+                    struct lpfc_iocbq *rspiocb)
 {
         IOCB_t *irsp = &rspiocb->iocb;
         struct lpfc_nodelist *ndlp = cmdiocb->context1;
@@ -418,7 +419,7 @@ lpfc_cmpl_els_flogi(struct lpfc_hba * phba,
 
         /* Check to see if link went down during discovery */
         if (lpfc_els_chk_latt(phba)) {
-                lpfc_nlp_remove(phba, ndlp);
+                lpfc_nlp_put(ndlp);
                 goto out;
         }
 
@@ -433,13 +434,12 @@ lpfc_cmpl_els_flogi(struct lpfc_hba * phba,
                 phba->fc_flag &= ~(FC_FABRIC | FC_PUBLIC_LOOP);
                 spin_unlock_irq(phba->host->host_lock);
 
-                /* If private loop, then allow max outstandting els to be
+                /* If private loop, then allow max outstanding els to be
                  * LPFC_MAX_DISC_THREADS (32). Scanning in the case of no
                  * alpa map would take too long otherwise.
                  */
                 if (phba->alpa_map[0] == 0) {
-                        phba->cfg_discovery_threads =
-                            LPFC_MAX_DISC_THREADS;
+                        phba->cfg_discovery_threads = LPFC_MAX_DISC_THREADS;
                 }
 
                 /* FLOGI failure */
@@ -484,7 +484,7 @@ lpfc_cmpl_els_flogi(struct lpfc_hba * phba,
         }
 
 flogifail:
-        lpfc_nlp_remove(phba, ndlp);
+        lpfc_nlp_put(ndlp);
 
         if (irsp->ulpStatus != IOSTAT_LOCAL_REJECT ||
             (irsp->un.ulpWord[4] != IOERR_SLI_ABORTED &&
@@ -582,24 +582,8 @@ lpfc_els_abort_flogi(struct lpfc_hba * phba)
                 icmd = &iocb->iocb;
                 if (icmd->ulpCommand == CMD_ELS_REQUEST64_CR) {
                         ndlp = (struct lpfc_nodelist *)(iocb->context1);
-                        if (ndlp && (ndlp->nlp_DID == Fabric_DID)) {
-                                list_del(&iocb->list);
-                                pring->txcmplq_cnt--;
-
-                                if ((icmd->un.elsreq64.bdl.ulpIoTag32)) {
-                                        lpfc_sli_issue_abort_iotag32
-                                                (phba, pring, iocb);
-                                }
-                                if (iocb->iocb_cmpl) {
-                                        icmd->ulpStatus = IOSTAT_LOCAL_REJECT;
-                                        icmd->un.ulpWord[4] =
-                                            IOERR_SLI_ABORTED;
-                                        spin_unlock_irq(phba->host->host_lock);
-                                        (iocb->iocb_cmpl) (phba, iocb, iocb);
-                                        spin_lock_irq(phba->host->host_lock);
-                                } else
-                                        lpfc_sli_release_iocbq(phba, iocb);
-                        }
+                        if (ndlp && (ndlp->nlp_DID == Fabric_DID))
+                                lpfc_sli_issue_abort_iotag(phba, pring, iocb);
                 }
         }
         spin_unlock_irq(phba->host->host_lock);
@@ -608,12 +592,12 @@ lpfc_els_abort_flogi(struct lpfc_hba * phba)
 }
 
 int
-lpfc_initial_flogi(struct lpfc_hba * phba)
+lpfc_initial_flogi(struct lpfc_hba *phba)
 {
         struct lpfc_nodelist *ndlp;
 
         /* First look for the Fabric ndlp */
-        ndlp = lpfc_findnode_did(phba, NLP_SEARCH_ALL, Fabric_DID);
+        ndlp = lpfc_findnode_did(phba, Fabric_DID);
         if (!ndlp) {
                 /* Cannot find existing Fabric ndlp, so allocate a new one */
                 ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL);
@@ -621,10 +605,10 @@ lpfc_initial_flogi(struct lpfc_hba * phba)
                         return 0;
                 lpfc_nlp_init(phba, ndlp, Fabric_DID);
         } else {
-                lpfc_nlp_list(phba, ndlp, NLP_JUST_DQ);
+                lpfc_dequeue_node(phba, ndlp);
         }
         if (lpfc_issue_els_flogi(phba, ndlp, 0)) {
-                mempool_free( ndlp, phba->nlp_mem_pool);
+                lpfc_nlp_put(ndlp);
         }
         return 1;
 }
@@ -653,7 +637,7 @@ lpfc_more_plogi(struct lpfc_hba * phba)
 }
 
 static struct lpfc_nodelist *
-lpfc_plogi_confirm_nport(struct lpfc_hba * phba, struct lpfc_dmabuf *prsp,
+lpfc_plogi_confirm_nport(struct lpfc_hba *phba, struct lpfc_dmabuf *prsp,
                          struct lpfc_nodelist *ndlp)
 {
         struct lpfc_nodelist *new_ndlp;
@@ -670,12 +654,12 @@ lpfc_plogi_confirm_nport(struct lpfc_hba * phba, struct lpfc_dmabuf *prsp,
 
         lp = (uint32_t *) prsp->virt;
         sp = (struct serv_parm *) ((uint8_t *) lp + sizeof (uint32_t));
-        memset(name, 0, sizeof (struct lpfc_name));
+        memset(name, 0, sizeof(struct lpfc_name));
 
-        /* Now we to find out if the NPort we are logging into, matches the WWPN
+        /* Now we find out if the NPort we are logging into, matches the WWPN
          * we have for that ndlp. If not, we have some work to do.
          */
-        new_ndlp = lpfc_findnode_wwpn(phba, NLP_SEARCH_ALL, &sp->portName);
+        new_ndlp = lpfc_findnode_wwpn(phba, &sp->portName);
 
         if (new_ndlp == ndlp)
                 return ndlp;
@@ -695,18 +679,15 @@ lpfc_plogi_confirm_nport(struct lpfc_hba * phba, struct lpfc_dmabuf *prsp,
         lpfc_unreg_rpi(phba, new_ndlp);
         new_ndlp->nlp_DID = ndlp->nlp_DID;
         new_ndlp->nlp_prev_state = ndlp->nlp_prev_state;
-        new_ndlp->nlp_state = ndlp->nlp_state;
-        lpfc_nlp_list(phba, new_ndlp, ndlp->nlp_flag & NLP_LIST_MASK);
+        lpfc_nlp_set_state(phba, new_ndlp, ndlp->nlp_state);
 
         /* Move this back to NPR list */
-        if (memcmp(&ndlp->nlp_portname, name, sizeof(struct lpfc_name)) == 0) {
-                lpfc_nlp_list(phba, ndlp, NLP_NO_LIST);
-        }
+        if (memcmp(&ndlp->nlp_portname, name, sizeof(struct lpfc_name)) == 0)
+                lpfc_drop_node(phba, ndlp);
         else {
                 lpfc_unreg_rpi(phba, ndlp);
                 ndlp->nlp_DID = 0; /* Two ndlps cannot have the same did */
-                ndlp->nlp_state = NLP_STE_NPR_NODE;
-                lpfc_nlp_list(phba, ndlp, NLP_NPR_LIST);
+                lpfc_nlp_set_state(phba, ndlp, NLP_STE_NPR_NODE);
         }
         return new_ndlp;
 }
@@ -720,13 +701,11 @@ lpfc_cmpl_els_plogi(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
         struct lpfc_dmabuf *prsp;
         int disc, rc, did, type;
 
-
         /* we pass cmdiocb to state machine which needs rspiocb as well */
         cmdiocb->context_un.rsp_iocb = rspiocb;
 
         irsp = &rspiocb->iocb;
-        ndlp = lpfc_findnode_did(phba, NLP_SEARCH_ALL,
-                                                irsp->un.elsreq64.remoteID);
+        ndlp = lpfc_findnode_did(phba, irsp->un.elsreq64.remoteID);
         if (!ndlp)
                 goto out;
 
@@ -1354,7 +1333,7 @@ lpfc_issue_els_scr(struct lpfc_hba * phba, uint32_t nportid, uint8_t retry)
         elsiocb = lpfc_prep_els_iocb(phba, 1, cmdsize, retry, ndlp,
                                                 ndlp->nlp_DID, ELS_CMD_SCR);
         if (!elsiocb) {
-                mempool_free( ndlp, phba->nlp_mem_pool);
+                lpfc_nlp_put(ndlp);
                 return 1;
         }
 
@@ -1373,12 +1352,12 @@ lpfc_issue_els_scr(struct lpfc_hba * phba, uint32_t nportid, uint8_t retry)
         spin_lock_irq(phba->host->host_lock);
         if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) {
                 spin_unlock_irq(phba->host->host_lock);
-                mempool_free( ndlp, phba->nlp_mem_pool);
+                lpfc_nlp_put(ndlp);
                 lpfc_els_free_iocb(phba, elsiocb);
                 return 1;
         }
         spin_unlock_irq(phba->host->host_lock);
-        mempool_free( ndlp, phba->nlp_mem_pool);
+        lpfc_nlp_put(ndlp);
         return 0;
 }
 
@@ -1407,7 +1386,7 @@ lpfc_issue_els_farpr(struct lpfc_hba * phba, uint32_t nportid, uint8_t retry)
         elsiocb = lpfc_prep_els_iocb(phba, 1, cmdsize, retry, ndlp,
                                                 ndlp->nlp_DID, ELS_CMD_RNID);
         if (!elsiocb) {
-                mempool_free( ndlp, phba->nlp_mem_pool);
+                lpfc_nlp_put(ndlp);
                 return 1;
         }
 
@@ -1428,7 +1407,7 @@ lpfc_issue_els_farpr(struct lpfc_hba * phba, uint32_t nportid, uint8_t retry)
 
         memcpy(&fp->RportName, &phba->fc_portname, sizeof (struct lpfc_name));
         memcpy(&fp->RnodeName, &phba->fc_nodename, sizeof (struct lpfc_name));
-        if ((ondlp = lpfc_findnode_did(phba, NLP_SEARCH_ALL, nportid))) {
+        if ((ondlp = lpfc_findnode_did(phba, nportid))) {
                 memcpy(&fp->OportName, &ondlp->nlp_portname,
                        sizeof (struct lpfc_name));
                 memcpy(&fp->OnodeName, &ondlp->nlp_nodename,
@@ -1440,12 +1419,12 @@ lpfc_issue_els_farpr(struct lpfc_hba * phba, uint32_t nportid, uint8_t retry)
         spin_lock_irq(phba->host->host_lock);
         if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) {
                 spin_unlock_irq(phba->host->host_lock);
-                mempool_free( ndlp, phba->nlp_mem_pool);
+                lpfc_nlp_put(ndlp);
                 lpfc_els_free_iocb(phba, elsiocb);
                 return 1;
         }
         spin_unlock_irq(phba->host->host_lock);
-        mempool_free( ndlp, phba->nlp_mem_pool);
+        lpfc_nlp_put(ndlp);
         return 0;
 }
 
@@ -1554,29 +1533,25 @@ lpfc_els_retry_delay_handler(struct lpfc_nodelist *ndlp)
         case ELS_CMD_PLOGI:
                 if(!lpfc_issue_els_plogi(phba, ndlp->nlp_DID, retry)) {
                         ndlp->nlp_prev_state = ndlp->nlp_state;
-                        ndlp->nlp_state = NLP_STE_PLOGI_ISSUE;
-                        lpfc_nlp_list(phba, ndlp, NLP_PLOGI_LIST);
+                        lpfc_nlp_set_state(phba, ndlp, NLP_STE_PLOGI_ISSUE);
                 }
                 break;
         case ELS_CMD_ADISC:
                 if (!lpfc_issue_els_adisc(phba, ndlp, retry)) {
                         ndlp->nlp_prev_state = ndlp->nlp_state;
-                        ndlp->nlp_state = NLP_STE_ADISC_ISSUE;
-                        lpfc_nlp_list(phba, ndlp, NLP_ADISC_LIST);
+                        lpfc_nlp_set_state(phba, ndlp, NLP_STE_ADISC_ISSUE);
                 }
                 break;
         case ELS_CMD_PRLI:
                 if (!lpfc_issue_els_prli(phba, ndlp, retry)) {
                         ndlp->nlp_prev_state = ndlp->nlp_state;
-                        ndlp->nlp_state = NLP_STE_PRLI_ISSUE;
-                        lpfc_nlp_list(phba, ndlp, NLP_PRLI_LIST);
+                        lpfc_nlp_set_state(phba, ndlp, NLP_STE_PRLI_ISSUE);
                 }
                 break;
         case ELS_CMD_LOGO:
                 if (!lpfc_issue_els_logo(phba, ndlp, retry)) {
                         ndlp->nlp_prev_state = ndlp->nlp_state;
-                        ndlp->nlp_state = NLP_STE_NPR_NODE;
-                        lpfc_nlp_list(phba, ndlp, NLP_NPR_LIST);
+                        lpfc_nlp_set_state(phba, ndlp, NLP_STE_NPR_NODE);
                 }
                 break;
         }
@@ -1614,12 +1589,12 @@ lpfc_els_retry(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
                 cmd = *elscmd++;
         }
 
-        if(ndlp)
+        if (ndlp)
                 did = ndlp->nlp_DID;
         else {
                 /* We should only hit this case for retrying PLOGI */
                 did = irsp->un.elsreq64.remoteID;
-                ndlp = lpfc_findnode_did(phba, NLP_SEARCH_ALL, did);
+                ndlp = lpfc_findnode_did(phba, did);
                 if (!ndlp && (cmd != ELS_CMD_PLOGI))
                         return 1;
         }
@@ -1746,8 +1721,7 @@ lpfc_els_retry(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
                         ndlp->nlp_flag |= NLP_DELAY_TMO;
 
                         ndlp->nlp_prev_state = ndlp->nlp_state;
-                        ndlp->nlp_state = NLP_STE_NPR_NODE;
-                        lpfc_nlp_list(phba, ndlp, NLP_NPR_LIST);
+                        lpfc_nlp_set_state(phba, ndlp, NLP_STE_NPR_NODE);
                         ndlp->nlp_last_elscmd = cmd;
 
                         return 1;
@@ -1759,27 +1733,24 @@ lpfc_els_retry(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
                 case ELS_CMD_PLOGI:
                         if (ndlp) {
                                 ndlp->nlp_prev_state = ndlp->nlp_state;
-                                ndlp->nlp_state = NLP_STE_PLOGI_ISSUE;
-                                lpfc_nlp_list(phba, ndlp, NLP_PLOGI_LIST);
+                                lpfc_nlp_set_state(phba, ndlp,
+                                                   NLP_STE_PLOGI_ISSUE);
                         }
                         lpfc_issue_els_plogi(phba, did, cmdiocb->retry);
                         return 1;
                 case ELS_CMD_ADISC:
                         ndlp->nlp_prev_state = ndlp->nlp_state;
-                        ndlp->nlp_state = NLP_STE_ADISC_ISSUE;
-                        lpfc_nlp_list(phba, ndlp, NLP_ADISC_LIST);
+                        lpfc_nlp_set_state(phba, ndlp, NLP_STE_ADISC_ISSUE);
                         lpfc_issue_els_adisc(phba, ndlp, cmdiocb->retry);
                         return 1;
                 case ELS_CMD_PRLI:
                         ndlp->nlp_prev_state = ndlp->nlp_state;
-                        ndlp->nlp_state = NLP_STE_PRLI_ISSUE;
-                        lpfc_nlp_list(phba, ndlp, NLP_PRLI_LIST);
+                        lpfc_nlp_set_state(phba, ndlp, NLP_STE_PRLI_ISSUE);
                         lpfc_issue_els_prli(phba, ndlp, cmdiocb->retry);
                         return 1;
                 case ELS_CMD_LOGO:
                         ndlp->nlp_prev_state = ndlp->nlp_state;
-                        ndlp->nlp_state = NLP_STE_NPR_NODE;
-                        lpfc_nlp_list(phba, ndlp, NLP_NPR_LIST);
+                        lpfc_nlp_set_state(phba, ndlp, NLP_STE_NPR_NODE);
                         lpfc_issue_els_logo(phba, ndlp, cmdiocb->retry);
                         return 1;
                 }
@@ -1796,10 +1767,14 @@ lpfc_els_retry(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
 }
 
 int
-lpfc_els_free_iocb(struct lpfc_hba * phba, struct lpfc_iocbq * elsiocb)
+lpfc_els_free_iocb(struct lpfc_hba *phba, struct lpfc_iocbq *elsiocb)
 {
         struct lpfc_dmabuf *buf_ptr, *buf_ptr1;
 
+        if (elsiocb->context1) {
+                lpfc_nlp_put(elsiocb->context1);
+                elsiocb->context1 = NULL;
+        }
         /* context2  = cmd,  context2->next = rsp, context3 = bpl */
         if (elsiocb->context2) {
                 buf_ptr1 = (struct lpfc_dmabuf *) elsiocb->context2;
@@ -1843,7 +1818,7 @@ lpfc_cmpl_els_logo_acc(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
 
         switch (ndlp->nlp_state) {
         case NLP_STE_UNUSED_NODE:       /* node is just allocated */
-                lpfc_nlp_list(phba, ndlp, NLP_NO_LIST);
+                lpfc_drop_node(phba, ndlp);
                 break;
         case NLP_STE_NPR_NODE:          /* NPort Recovery mode */
                 lpfc_unreg_rpi(phba, ndlp);
@@ -1856,8 +1831,8 @@ lpfc_cmpl_els_logo_acc(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
 }
 
 static void
-lpfc_cmpl_els_acc(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
-                  struct lpfc_iocbq * rspiocb)
+lpfc_cmpl_els_acc(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
+                  struct lpfc_iocbq *rspiocb)
 {
         IOCB_t *irsp;
         struct lpfc_nodelist *ndlp;
@@ -1872,14 +1847,14 @@ lpfc_cmpl_els_acc(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
 
 
         /* Check to see if link went down during discovery */
-        if ((lpfc_els_chk_latt(phba)) || !ndlp) {
+        if (lpfc_els_chk_latt(phba) || !ndlp) {
                 if (mbox) {
                         mp = (struct lpfc_dmabuf *) mbox->context1;
                         if (mp) {
                                 lpfc_mbuf_free(phba, mp->virt, mp->phys);
                                 kfree(mp);
                         }
-                        mempool_free( mbox, phba->mbox_mem_pool);
+                        mempool_free(mbox, phba->mbox_mem_pool);
                 }
                 goto out;
         }
@@ -1899,15 +1874,15 @@ lpfc_cmpl_els_acc(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
                     && (ndlp->nlp_flag & NLP_ACC_REGLOGIN)) {
                         lpfc_unreg_rpi(phba, ndlp);
                         mbox->mbox_cmpl = lpfc_mbx_cmpl_reg_login;
-                        mbox->context2 = ndlp;
+                        mbox->context2 = lpfc_nlp_get(ndlp);
                         ndlp->nlp_prev_state = ndlp->nlp_state;
-                        ndlp->nlp_state = NLP_STE_REG_LOGIN_ISSUE;
-                        lpfc_nlp_list(phba, ndlp, NLP_REGLOGIN_LIST);
+                        lpfc_nlp_set_state(phba, ndlp, NLP_STE_REG_LOGIN_ISSUE);
                         if (lpfc_sli_issue_mbox(phba, mbox,
                                                 (MBX_NOWAIT | MBX_STOP_IOCB))
                             != MBX_NOT_FINISHED) {
                                 goto out;
                         }
+                        lpfc_nlp_put(ndlp);
                         /* NOTE: we should have messages for unsuccessful
                            reglogin */
                 } else {
@@ -1917,7 +1892,7 @@ lpfc_cmpl_els_acc(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
                                (irsp->un.ulpWord[4] == IOERR_LINK_DOWN) ||
                                (irsp->un.ulpWord[4] == IOERR_SLI_DOWN)))) {
                                 if (ndlp->nlp_flag & NLP_ACC_REGLOGIN) {
-                                        lpfc_nlp_list(phba, ndlp, NLP_NO_LIST);
+                                        lpfc_drop_node(phba, ndlp);
                                         ndlp = NULL;
                                 }
                         }
@@ -2012,15 +1987,16 @@ lpfc_els_rsp_acc(struct lpfc_hba * phba, uint32_t flag,
                 return 1;
         }
 
-        if (newnode)
+        if (newnode) {
+                lpfc_nlp_put(ndlp);
                 elsiocb->context1 = NULL;
+        }
 
         /* Xmit ELS ACC response tag <ulpIoTag> */
         lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
-                        "%d:0128 Xmit ELS ACC response tag x%x "
-                        "Data: x%x x%x x%x x%x x%x\n",
-                        phba->brd_no,
-                        elsiocb->iocb.ulpIoTag,
+                        "%d:0128 Xmit ELS ACC response tag x%x, XRI: x%x, "
+                        "DID: x%x, nlp_flag: x%x nlp_state: x%x RPI: x%x\n",
+                        phba->brd_no, elsiocb->iotag,
                         elsiocb->iocb.ulpContext, ndlp->nlp_DID,
                         ndlp->nlp_flag, ndlp->nlp_state, ndlp->nlp_rpi);
 
@@ -2077,10 +2053,9 @@ lpfc_els_rsp_reject(struct lpfc_hba * phba, uint32_t rejectError,
 
         /* Xmit ELS RJT <err> response tag <ulpIoTag> */
         lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
-                        "%d:0129 Xmit ELS RJT x%x response tag x%x "
-                        "Data: x%x x%x x%x x%x x%x\n",
-                        phba->brd_no,
-                        rejectError, elsiocb->iocb.ulpIoTag,
+                        "%d:0129 Xmit ELS RJT x%x response tag x%x xri x%x, "
+                        "did x%x, nlp_flag x%x, nlp_state x%x, rpi x%x\n",
+                        phba->brd_no, rejectError, elsiocb->iotag,
                         elsiocb->iocb.ulpContext, ndlp->nlp_DID,
                         ndlp->nlp_flag, ndlp->nlp_state, ndlp->nlp_rpi);
 
@@ -2119,18 +2094,18 @@ lpfc_els_rsp_adisc_acc(struct lpfc_hba * phba,
         if (!elsiocb)
                 return 1;
 
+        icmd = &elsiocb->iocb;
+        oldcmd = &oldiocb->iocb;
+        icmd->ulpContext = oldcmd->ulpContext;  /* Xri */
+
         /* Xmit ADISC ACC response tag <ulpIoTag> */
         lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
-                        "%d:0130 Xmit ADISC ACC response tag x%x "
-                        "Data: x%x x%x x%x x%x x%x\n",
-                        phba->brd_no,
-                        elsiocb->iocb.ulpIoTag,
+                        "%d:0130 Xmit ADISC ACC response iotag x%x xri: "
+                        "x%x, did x%x, nlp_flag x%x, nlp_state x%x rpi x%x\n",
+                        phba->brd_no, elsiocb->iotag,
                         elsiocb->iocb.ulpContext, ndlp->nlp_DID,
                         ndlp->nlp_flag, ndlp->nlp_state, ndlp->nlp_rpi);
 
-        icmd = &elsiocb->iocb;
-        oldcmd = &oldiocb->iocb;
-        icmd->ulpContext = oldcmd->ulpContext;  /* Xri */
         pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
 
         *((uint32_t *) (pcmd)) = ELS_CMD_ACC;
@@ -2155,8 +2130,8 @@ lpfc_els_rsp_adisc_acc(struct lpfc_hba * phba,
 }
 
 int
-lpfc_els_rsp_prli_acc(struct lpfc_hba * phba,
-                      struct lpfc_iocbq * oldiocb, struct lpfc_nodelist * ndlp)
+lpfc_els_rsp_prli_acc(struct lpfc_hba *phba, struct lpfc_iocbq *oldiocb,
+                      struct lpfc_nodelist *ndlp)
 {
         PRLI *npr;
         lpfc_vpd_t *vpd;
@@ -2178,18 +2153,18 @@ lpfc_els_rsp_prli_acc(struct lpfc_hba * phba,
         if (!elsiocb)
                 return 1;
 
+        icmd = &elsiocb->iocb;
+        oldcmd = &oldiocb->iocb;
+        icmd->ulpContext = oldcmd->ulpContext;  /* Xri */
+
         /* Xmit PRLI ACC response tag <ulpIoTag> */
         lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
-                        "%d:0131 Xmit PRLI ACC response tag x%x "
-                        "Data: x%x x%x x%x x%x x%x\n",
-                        phba->brd_no,
-                        elsiocb->iocb.ulpIoTag,
+                        "%d:0131 Xmit PRLI ACC response tag x%x xri x%x, "
+                        "did x%x, nlp_flag x%x, nlp_state x%x, rpi x%x\n",
+                        phba->brd_no, elsiocb->iotag,
                         elsiocb->iocb.ulpContext, ndlp->nlp_DID,
                         ndlp->nlp_flag, ndlp->nlp_state, ndlp->nlp_rpi);
 
-        icmd = &elsiocb->iocb;
-        oldcmd = &oldiocb->iocb;
-        icmd->ulpContext = oldcmd->ulpContext;  /* Xri */
         pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
 
         *((uint32_t *) (pcmd)) = (ELS_CMD_ACC | (ELS_CMD_PRLI & ~ELS_RSP_MASK));
@@ -2232,9 +2207,8 @@ lpfc_els_rsp_prli_acc(struct lpfc_hba * phba,
 }
 
 static int
-lpfc_els_rsp_rnid_acc(struct lpfc_hba * phba,
-                      uint8_t format,
-                      struct lpfc_iocbq * oldiocb, struct lpfc_nodelist * ndlp)
+lpfc_els_rsp_rnid_acc(struct lpfc_hba *phba, uint8_t format,
+                      struct lpfc_iocbq *oldiocb, struct lpfc_nodelist *ndlp)
 {
         RNID *rn;
         IOCB_t *icmd;
@@ -2259,17 +2233,17 @@ lpfc_els_rsp_rnid_acc(struct lpfc_hba * phba,
         if (!elsiocb)
                 return 1;
 
+        icmd = &elsiocb->iocb;
+        oldcmd = &oldiocb->iocb;
+        icmd->ulpContext = oldcmd->ulpContext;  /* Xri */
+
         /* Xmit RNID ACC response tag <ulpIoTag> */
         lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
                         "%d:0132 Xmit RNID ACC response tag x%x "
-                        "Data: x%x\n",
-                        phba->brd_no,
-                        elsiocb->iocb.ulpIoTag,
+                        "xri x%x\n",
+                        phba->brd_no, elsiocb->iotag,
                         elsiocb->iocb.ulpContext);
 
-        icmd = &elsiocb->iocb;
-        oldcmd = &oldiocb->iocb;
-        icmd->ulpContext = oldcmd->ulpContext;  /* Xri */
         pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
 
         *((uint32_t *) (pcmd)) = ELS_CMD_ACC;
@@ -2301,6 +2275,7 @@ lpfc_els_rsp_rnid_acc(struct lpfc_hba * phba,
 
         phba->fc_stat.elsXmitACC++;
         elsiocb->iocb_cmpl = lpfc_cmpl_els_acc;
+        lpfc_nlp_put(ndlp);
         elsiocb->context1 = NULL;  /* Don't need ndlp for cmpl,
                                     * it could be freed */
 
@@ -2315,32 +2290,31 @@ lpfc_els_rsp_rnid_acc(struct lpfc_hba * phba,
 }
 
 int
-lpfc_els_disc_adisc(struct lpfc_hba * phba)
+lpfc_els_disc_adisc(struct lpfc_hba *phba)
 {
         int sentadisc;
         struct lpfc_nodelist *ndlp, *next_ndlp;
 
         sentadisc = 0;
-        /* go thru NPR list and issue any remaining ELS ADISCs */
-        list_for_each_entry_safe(ndlp, next_ndlp, &phba->fc_npr_list,
-                        nlp_listp) {
-                if (ndlp->nlp_flag & NLP_NPR_2B_DISC) {
-                        if (ndlp->nlp_flag & NLP_NPR_ADISC) {
-                                ndlp->nlp_flag &= ~NLP_NPR_ADISC;
-                                ndlp->nlp_prev_state = ndlp->nlp_state;
-                                ndlp->nlp_state = NLP_STE_ADISC_ISSUE;
-                                lpfc_nlp_list(phba, ndlp,
-                                        NLP_ADISC_LIST);
-                                lpfc_issue_els_adisc(phba, ndlp, 0);
-                                sentadisc++;
-                                phba->num_disc_nodes++;
-                                if (phba->num_disc_nodes >=
-                                    phba->cfg_discovery_threads) {
-                                        spin_lock_irq(phba->host->host_lock);
-                                        phba->fc_flag |= FC_NLP_MORE;
-                                        spin_unlock_irq(phba->host->host_lock);
-                                        break;
-                                }
+        /* go thru NPR nodes and issue any remaining ELS ADISCs */
+        list_for_each_entry_safe(ndlp, next_ndlp, &phba->fc_nodes, nlp_listp) {
+                if (ndlp->nlp_state == NLP_STE_NPR_NODE &&
+                    (ndlp->nlp_flag & NLP_NPR_2B_DISC) != 0 &&
+                    (ndlp->nlp_flag & NLP_NPR_ADISC) != 0) {
+                        spin_lock_irq(phba->host->host_lock);
+                        ndlp->nlp_flag &= ~NLP_NPR_ADISC;
+                        spin_unlock_irq(phba->host->host_lock);
+                        ndlp->nlp_prev_state = ndlp->nlp_state;
+                        lpfc_nlp_set_state(phba, ndlp, NLP_STE_ADISC_ISSUE);
+                        lpfc_issue_els_adisc(phba, ndlp, 0);
+                        sentadisc++;
+                        phba->num_disc_nodes++;
+                        if (phba->num_disc_nodes >=
+                            phba->cfg_discovery_threads) {
+                                spin_lock_irq(phba->host->host_lock);
+                                phba->fc_flag |= FC_NLP_MORE;
+                                spin_unlock_irq(phba->host->host_lock);
+                                break;
                         }
                 }
         }
@@ -2360,24 +2334,22 @@ lpfc_els_disc_plogi(struct lpfc_hba * phba)
 
         sentplogi = 0;
         /* go thru NPR list and issue any remaining ELS PLOGIs */
-        list_for_each_entry_safe(ndlp, next_ndlp, &phba->fc_npr_list,
-                                nlp_listp) {
-                if ((ndlp->nlp_flag & NLP_NPR_2B_DISC) &&
-                   (!(ndlp->nlp_flag & NLP_DELAY_TMO))) {
-                        if (!(ndlp->nlp_flag & NLP_NPR_ADISC)) {
-                                ndlp->nlp_prev_state = ndlp->nlp_state;
-                                ndlp->nlp_state = NLP_STE_PLOGI_ISSUE;
-                                lpfc_nlp_list(phba, ndlp, NLP_PLOGI_LIST);
-                                lpfc_issue_els_plogi(phba, ndlp->nlp_DID, 0);
-                                sentplogi++;
-                                phba->num_disc_nodes++;
-                                if (phba->num_disc_nodes >=
-                                    phba->cfg_discovery_threads) {
-                                        spin_lock_irq(phba->host->host_lock);
-                                        phba->fc_flag |= FC_NLP_MORE;
-                                        spin_unlock_irq(phba->host->host_lock);
-                                        break;
-                                }
+        list_for_each_entry_safe(ndlp, next_ndlp, &phba->fc_nodes, nlp_listp) {
+                if (ndlp->nlp_state == NLP_STE_NPR_NODE &&
+                    (ndlp->nlp_flag & NLP_NPR_2B_DISC) != 0 &&
+                    (ndlp->nlp_flag & NLP_DELAY_TMO) == 0 &&
+                    (ndlp->nlp_flag & NLP_NPR_ADISC) == 0) {
+                        ndlp->nlp_prev_state = ndlp->nlp_state;
+                        lpfc_nlp_set_state(phba, ndlp, NLP_STE_PLOGI_ISSUE);
+                        lpfc_issue_els_plogi(phba, ndlp->nlp_DID, 0);
+                        sentplogi++;
+                        phba->num_disc_nodes++;
+                        if (phba->num_disc_nodes >=
+                            phba->cfg_discovery_threads) {
+                                spin_lock_irq(phba->host->host_lock);
+                                phba->fc_flag |= FC_NLP_MORE;
+                                spin_unlock_irq(phba->host->host_lock);
+                                break;
                         }
                 }
         }
@@ -2479,42 +2451,30 @@ lpfc_rscn_payload_check(struct lpfc_hba * phba, uint32_t did)
 }
 
 static int
-lpfc_rscn_recovery_check(struct lpfc_hba * phba)
+lpfc_rscn_recovery_check(struct lpfc_hba *phba)
 {
-        struct lpfc_nodelist *ndlp = NULL, *next_ndlp;
-        struct list_head *listp;
-        struct list_head *node_list[7];
-        int i;
+        struct lpfc_nodelist *ndlp = NULL;
 
         /* Look at all nodes effected by pending RSCNs and move
-         * them to NPR list.
+         * them to NPR state.
          */
-        node_list[0] = &phba->fc_npr_list;  /* MUST do this list first */
-        node_list[1] = &phba->fc_nlpmap_list;
-        node_list[2] = &phba->fc_nlpunmap_list;
-        node_list[3] = &phba->fc_prli_list;
-        node_list[4] = &phba->fc_reglogin_list;
-        node_list[5] = &phba->fc_adisc_list;
-        node_list[6] = &phba->fc_plogi_list;
-        for (i = 0; i < 7; i++) {
-                listp = node_list[i];
-                if (list_empty(listp))
-                        continue;
 
-                list_for_each_entry_safe(ndlp, next_ndlp, listp, nlp_listp) {
-                        if (!(lpfc_rscn_payload_check(phba, ndlp->nlp_DID)))
-                                continue;
+        list_for_each_entry(ndlp, &phba->fc_nodes, nlp_listp) {
+                if (ndlp->nlp_state == NLP_STE_UNUSED_NODE ||
+                    lpfc_rscn_payload_check(phba, ndlp->nlp_DID) == 0)
+                        continue;
 
-                        lpfc_disc_state_machine(phba, ndlp, NULL,
+                lpfc_disc_state_machine(phba, ndlp, NULL,
                                         NLP_EVT_DEVICE_RECOVERY);
 
-                        /* Make sure NLP_DELAY_TMO is NOT running
-                         * after a device recovery event.
-                         */
-                        if (ndlp->nlp_flag & NLP_DELAY_TMO)
-                                lpfc_cancel_retry_delay_tmo(phba, ndlp);
-                }
+                /*
+                 * Make sure NLP_DELAY_TMO is NOT running after a device
+                 * recovery event.
+                 */
+                if (ndlp->nlp_flag & NLP_DELAY_TMO)
+                        lpfc_cancel_retry_delay_tmo(phba, ndlp);
         }
+
         return 0;
 }
 
@@ -2639,8 +2599,8 @@ lpfc_els_handle_rscn(struct lpfc_hba * phba)
 
         /* To process RSCN, first compare RSCN data with NameServer */
         phba->fc_ns_retry = 0;
-        ndlp = lpfc_findnode_did(phba, NLP_SEARCH_UNMAPPED, NameServer_DID);
-        if (ndlp) {
+        ndlp = lpfc_findnode_did(phba, NameServer_DID);
+        if (ndlp && ndlp->nlp_state == NLP_STE_UNMAPPED_NODE) {
                 /* Good ndlp, issue CT Request to NameServer */
                 if (lpfc_ns_cmd(phba, ndlp, SLI_CTNS_GID_FT) == 0) {
                         /* Wait for NameServer query cmpl before we can
@@ -2650,7 +2610,7 @@ lpfc_els_handle_rscn(struct lpfc_hba * phba)
         } else {
                 /* If login to NameServer does not exist, issue one */
                 /* Good status, issue PLOGI to NameServer */
-                ndlp = lpfc_findnode_did(phba, NLP_SEARCH_ALL, NameServer_DID);
+                ndlp = lpfc_findnode_did(phba, NameServer_DID);
                 if (ndlp) {
                         /* Wait for NameServer login cmpl before we can
                            continue */
@@ -2664,8 +2624,7 @@ lpfc_els_handle_rscn(struct lpfc_hba * phba)
                         lpfc_nlp_init(phba, ndlp, NameServer_DID);
                         ndlp->nlp_type |= NLP_FABRIC;
                         ndlp->nlp_prev_state = ndlp->nlp_state;
-                        ndlp->nlp_state = NLP_STE_PLOGI_ISSUE;
-                        lpfc_nlp_list(phba, ndlp, NLP_PLOGI_LIST);
+                        lpfc_nlp_set_state(phba, ndlp, NLP_STE_PLOGI_ISSUE);
                         lpfc_issue_els_plogi(phba, NameServer_DID, 0);
                         /* Wait for NameServer login cmpl before we can
                            continue */
@@ -2734,8 +2693,9 @@ lpfc_els_rcv_flogi(struct lpfc_hba * phba,
                         mbox->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
                         rc = lpfc_sli_issue_mbox
                                 (phba, mbox, (MBX_NOWAIT | MBX_STOP_IOCB));
+                        lpfc_set_loopback_flag(phba);
                         if (rc == MBX_NOT_FINISHED) {
-                                mempool_free( mbox, phba->mbox_mem_pool);
+                                mempool_free(mbox, phba->mbox_mem_pool);
                         }
                         return 1;
                 } else if (rc > 0) {    /* greater than */
@@ -2800,8 +2760,8 @@ lpfc_els_rcv_rnid(struct lpfc_hba * phba,
 }
 
 static int
-lpfc_els_rcv_lirr(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
-                 struct lpfc_nodelist * ndlp)
+lpfc_els_rcv_lirr(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
+                 struct lpfc_nodelist *ndlp)
 {
         struct ls_rjt stat;
 
@@ -2815,7 +2775,7 @@ lpfc_els_rcv_lirr(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
 }
 
 static void
-lpfc_els_rsp_rps_acc(struct lpfc_hba * phba, LPFC_MBOXQ_t * pmb)
+lpfc_els_rsp_rps_acc(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
 {
         struct lpfc_sli *psli;
         struct lpfc_sli_ring *pring;
@@ -2838,14 +2798,15 @@ lpfc_els_rsp_rps_acc(struct lpfc_hba * phba, LPFC_MBOXQ_t * pmb)
         pmb->context2 = NULL;
 
         if (mb->mbxStatus) {
-                mempool_free( pmb, phba->mbox_mem_pool);
+                mempool_free(pmb, phba->mbox_mem_pool);
                 return;
         }
 
         cmdsize = sizeof(RPS_RSP) + sizeof(uint32_t);
-        mempool_free( pmb, phba->mbox_mem_pool);
+        mempool_free(pmb, phba->mbox_mem_pool);
         elsiocb = lpfc_prep_els_iocb(phba, 0, cmdsize, lpfc_max_els_tries, ndlp,
                                                 ndlp->nlp_DID, ELS_CMD_ACC);
+        lpfc_nlp_put(ndlp);
         if (!elsiocb)
                 return;
 
@@ -2875,15 +2836,15 @@ lpfc_els_rsp_rps_acc(struct lpfc_hba * phba, LPFC_MBOXQ_t * pmb)
 
         /* Xmit ELS RPS ACC response tag <ulpIoTag> */
         lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
-                        "%d:0118 Xmit ELS RPS ACC response tag x%x "
-                        "Data: x%x x%x x%x x%x x%x\n",
-                        phba->brd_no,
-                        elsiocb->iocb.ulpIoTag,
+                        "%d:0118 Xmit ELS RPS ACC response tag x%x xri x%x, "
+                        "did x%x, nlp_flag x%x, nlp_state x%x, rpi x%x\n",
+                        phba->brd_no, elsiocb->iotag,
                         elsiocb->iocb.ulpContext, ndlp->nlp_DID,
                         ndlp->nlp_flag, ndlp->nlp_state, ndlp->nlp_rpi);
 
         elsiocb->iocb_cmpl = lpfc_cmpl_els_acc;
         phba->fc_stat.elsXmitACC++;
+
         if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) {
                 lpfc_els_free_iocb(phba, elsiocb);
         }
@@ -2923,13 +2884,14 @@ lpfc_els_rcv_rps(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
                         lpfc_read_lnk_stat(phba, mbox);
                         mbox->context1 =
                             (void *)((unsigned long)cmdiocb->iocb.ulpContext);
-                        mbox->context2 = ndlp;
+                        mbox->context2 = lpfc_nlp_get(ndlp);
                         mbox->mbox_cmpl = lpfc_els_rsp_rps_acc;
                         if (lpfc_sli_issue_mbox (phba, mbox,
                             (MBX_NOWAIT | MBX_STOP_IOCB)) != MBX_NOT_FINISHED) {
                                 /* Mbox completion will send ELS Response */
                                 return 0;
                         }
+                        lpfc_nlp_put(ndlp);
                         mempool_free(mbox, phba->mbox_mem_pool);
                 }
         }
@@ -2984,10 +2946,9 @@ lpfc_els_rsp_rpl_acc(struct lpfc_hba * phba, uint16_t cmdsize,
 
         /* Xmit ELS RPL ACC response tag <ulpIoTag> */
         lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
-                        "%d:0120 Xmit ELS RPL ACC response tag x%x "
-                        "Data: x%x x%x x%x x%x x%x\n",
-                        phba->brd_no,
-                        elsiocb->iocb.ulpIoTag,
+                        "%d:0120 Xmit ELS RPL ACC response tag x%x xri x%x, "
+                        "did x%x, nlp_flag x%x, nlp_state x%x, rpi x%x\n",
+                        phba->brd_no, elsiocb->iotag,
                         elsiocb->iocb.ulpContext, ndlp->nlp_DID,
                         ndlp->nlp_flag, ndlp->nlp_state, ndlp->nlp_rpi);
 
@@ -3091,8 +3052,8 @@ lpfc_els_rcv_farp(struct lpfc_hba * phba,
                         /* Log back into the node before sending the FARP. */
                         if (fp->Rflags & FARP_REQUEST_PLOGI) {
                                 ndlp->nlp_prev_state = ndlp->nlp_state;
-                                ndlp->nlp_state = NLP_STE_PLOGI_ISSUE;
-                                lpfc_nlp_list(phba, ndlp, NLP_PLOGI_LIST);
+                                lpfc_nlp_set_state(phba, ndlp,
+                                                   NLP_STE_PLOGI_ISSUE);
                                 lpfc_issue_els_plogi(phba, ndlp->nlp_DID, 0);
                         }
 
@@ -3169,14 +3130,15 @@ lpfc_els_rcv_fan(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
                          */
 
                         list_for_each_entry_safe(ndlp, next_ndlp,
-                                &phba->fc_npr_list, nlp_listp) {
-
+                                                 &phba->fc_nodes, nlp_listp) {
+                                if (ndlp->nlp_state != NLP_STE_NPR_NODE)
+                                        continue;
                                 if (ndlp->nlp_type & NLP_FABRIC) {
                                         /*
                                          * Clean up old Fabric, Nameserver and
                                          * other NLP_FABRIC logins
                                          */
-                                        lpfc_nlp_list(phba, ndlp, NLP_NO_LIST);
+                                        lpfc_drop_node(phba, ndlp);
                                 } else if (!(ndlp->nlp_flag & NLP_NPR_ADISC)) {
                                         /* Fail outstanding I/O now since this
                                          * device is marked for PLOGI
@@ -3193,20 +3155,22 @@ lpfc_els_rcv_fan(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
                 /* Discovery not needed,
                  * move the nodes to their original state.
                  */
-                list_for_each_entry_safe(ndlp, next_ndlp, &phba->fc_npr_list,
-                        nlp_listp) {
+                list_for_each_entry_safe(ndlp, next_ndlp, &phba->fc_nodes,
+                                         nlp_listp) {
+                        if (ndlp->nlp_state != NLP_STE_NPR_NODE)
+                                continue;
 
                         switch (ndlp->nlp_prev_state) {
                         case NLP_STE_UNMAPPED_NODE:
                                 ndlp->nlp_prev_state = NLP_STE_NPR_NODE;
-                                ndlp->nlp_state = NLP_STE_UNMAPPED_NODE;
-                                lpfc_nlp_list(phba, ndlp, NLP_UNMAPPED_LIST);
+                                lpfc_nlp_set_state(phba, ndlp,
+                                                   NLP_STE_UNMAPPED_NODE);
                                 break;
 
                         case NLP_STE_MAPPED_NODE:
                                 ndlp->nlp_prev_state = NLP_STE_NPR_NODE;
-                                ndlp->nlp_state = NLP_STE_MAPPED_NODE;
-                                lpfc_nlp_list(phba, ndlp, NLP_MAPPED_LIST);
+                                lpfc_nlp_set_state(phba, ndlp,
+                                                   NLP_STE_MAPPED_NODE);
                                 break;
 
                         default:
@@ -3246,9 +3210,8 @@ lpfc_els_timeout_handler(struct lpfc_hba *phba)
         struct lpfc_iocbq *tmp_iocb, *piocb;
         IOCB_t *cmd = NULL;
         struct lpfc_dmabuf *pcmd;
-        struct list_head *dlp;
         uint32_t *elscmd;
-        uint32_t els_command;
+        uint32_t els_command=0;
         uint32_t timeout;
         uint32_t remote_ID;
 
@@ -3263,17 +3226,20 @@ lpfc_els_timeout_handler(struct lpfc_hba *phba)
         timeout = (uint32_t)(phba->fc_ratov << 1);
 
         pring = &phba->sli.ring[LPFC_ELS_RING];
-        dlp = &pring->txcmplq;
 
         list_for_each_entry_safe(piocb, tmp_iocb, &pring->txcmplq, list) {
                 cmd = &piocb->iocb;
 
-                if (piocb->iocb_flag & LPFC_IO_LIBDFC) {
+                if ((piocb->iocb_flag & LPFC_IO_LIBDFC) ||
+                        (piocb->iocb.ulpCommand == CMD_ABORT_XRI_CN) ||
+                        (piocb->iocb.ulpCommand == CMD_CLOSE_XRI_CN)) {
                         continue;
                 }
                 pcmd = (struct lpfc_dmabuf *) piocb->context2;
-                elscmd = (uint32_t *) (pcmd->virt);
-                els_command = *elscmd;
+                if (pcmd) {
+                        elscmd = (uint32_t *) (pcmd->virt);
+                        els_command = *elscmd;
+                }
 
                 if ((els_command == ELS_CMD_FARP)
                     || (els_command == ELS_CMD_FARPR)) {
@@ -3289,19 +3255,10 @@ lpfc_els_timeout_handler(struct lpfc_hba *phba)
                         continue;
                 }
 
-                list_del(&piocb->list);
-                pring->txcmplq_cnt--;
-
                 if (cmd->ulpCommand == CMD_GEN_REQUEST64_CR) {
                         struct lpfc_nodelist *ndlp;
-                        spin_unlock_irq(phba->host->host_lock);
-                        ndlp = lpfc_findnode_rpi(phba, cmd->ulpContext);
-                        spin_lock_irq(phba->host->host_lock);
+                        ndlp = __lpfc_findnode_rpi(phba, cmd->ulpContext);
                         remote_ID = ndlp->nlp_DID;
-                        if (cmd->un.elsreq64.bdl.ulpIoTag32) {
-                                lpfc_sli_issue_abort_iotag32(phba,
-                                        pring, piocb);
-                        }
                 } else {
                         remote_ID = cmd->un.elsreq64.remoteID;
                 }
@@ -3313,17 +3270,7 @@ lpfc_els_timeout_handler(struct lpfc_hba *phba)
                                 phba->brd_no, els_command,
                                 remote_ID, cmd->ulpCommand, cmd->ulpIoTag);
 
-                /*
-                 * The iocb has timed out; abort it.
-                 */
-                if (piocb->iocb_cmpl) {
-                        cmd->ulpStatus = IOSTAT_LOCAL_REJECT;
-                        cmd->un.ulpWord[4] = IOERR_SLI_ABORTED;
-                        spin_unlock_irq(phba->host->host_lock);
-                        (piocb->iocb_cmpl) (phba, piocb, piocb);
-                        spin_lock_irq(phba->host->host_lock);
-                } else
-                        lpfc_sli_release_iocbq(phba, piocb);
+                lpfc_sli_issue_abort_iotag(phba, pring, piocb);
         }
         if (phba->sli.ring[LPFC_ELS_RING].txcmplq_cnt)
                 mod_timer(&phba->els_tmofunc, jiffies + HZ * timeout);
@@ -3332,16 +3279,13 @@ lpfc_els_timeout_handler(struct lpfc_hba *phba)
 }
 
 void
-lpfc_els_flush_cmd(struct lpfc_hba * phba)
+lpfc_els_flush_cmd(struct lpfc_hba *phba)
 {
-        struct lpfc_sli_ring *pring;
+        LIST_HEAD(completions);
+        struct lpfc_sli_ring *pring = &phba->sli.ring[LPFC_ELS_RING];
         struct lpfc_iocbq *tmp_iocb, *piocb;
         IOCB_t *cmd = NULL;
-        struct lpfc_dmabuf *pcmd;
-        uint32_t *elscmd;
-        uint32_t els_command;
 
-        pring = &phba->sli.ring[LPFC_ELS_RING];
         spin_lock_irq(phba->host->host_lock);
         list_for_each_entry_safe(piocb, tmp_iocb, &pring->txq, list) {
                 cmd = &piocb->iocb;
@@ -3351,29 +3295,15 @@ lpfc_els_flush_cmd(struct lpfc_hba * phba)
                 }
 
                 /* Do not flush out the QUE_RING and ABORT/CLOSE iocbs */
-                if ((cmd->ulpCommand == CMD_QUE_RING_BUF_CN) ||
-                    (cmd->ulpCommand == CMD_QUE_RING_BUF64_CN) ||
-                    (cmd->ulpCommand == CMD_CLOSE_XRI_CN) ||
-                    (cmd->ulpCommand == CMD_ABORT_XRI_CN)) {
+                if (cmd->ulpCommand == CMD_QUE_RING_BUF_CN ||
+                    cmd->ulpCommand == CMD_QUE_RING_BUF64_CN ||
+                    cmd->ulpCommand == CMD_CLOSE_XRI_CN ||
+                    cmd->ulpCommand == CMD_ABORT_XRI_CN)
                         continue;
-                }
 
-                pcmd = (struct lpfc_dmabuf *) piocb->context2;
-                elscmd = (uint32_t *) (pcmd->virt);
-                els_command = *elscmd;
+                list_move_tail(&piocb->list, &completions);
+                pring->txq_cnt--;
 
-                list_del(&piocb->list);
-                pring->txcmplq_cnt--;
-
-                cmd->ulpStatus = IOSTAT_LOCAL_REJECT;
-                cmd->un.ulpWord[4] = IOERR_SLI_ABORTED;
-
-                if (piocb->iocb_cmpl) {
-                        spin_unlock_irq(phba->host->host_lock);
-                        (piocb->iocb_cmpl) (phba, piocb, piocb);
-                        spin_lock_irq(phba->host->host_lock);
-                } else
-                        lpfc_sli_release_iocbq(phba, piocb);
         }
 
         list_for_each_entry_safe(piocb, tmp_iocb, &pring->txcmplq, list) {
@@ -3382,24 +3312,24 @@ lpfc_els_flush_cmd(struct lpfc_hba * phba)
                 if (piocb->iocb_flag & LPFC_IO_LIBDFC) {
                         continue;
                 }
-                pcmd = (struct lpfc_dmabuf *) piocb->context2;
-                elscmd = (uint32_t *) (pcmd->virt);
-                els_command = *elscmd;
 
-                list_del(&piocb->list);
-                pring->txcmplq_cnt--;
+                lpfc_sli_issue_abort_iotag(phba, pring, piocb);
+        }
+        spin_unlock_irq(phba->host->host_lock);
 
-                cmd->ulpStatus = IOSTAT_LOCAL_REJECT;
-                cmd->un.ulpWord[4] = IOERR_SLI_ABORTED;
+        while(!list_empty(&completions)) {
+                piocb = list_get_first(&completions, struct lpfc_iocbq, list);
+                cmd = &piocb->iocb;
+                list_del(&piocb->list);
 
                 if (piocb->iocb_cmpl) {
-                        spin_unlock_irq(phba->host->host_lock);
+                        cmd->ulpStatus = IOSTAT_LOCAL_REJECT;
+                        cmd->un.ulpWord[4] = IOERR_SLI_ABORTED;
                         (piocb->iocb_cmpl) (phba, piocb, piocb);
-                        spin_lock_irq(phba->host->host_lock);
                 } else
                         lpfc_sli_release_iocbq(phba, piocb);
         }
-        spin_unlock_irq(phba->host->host_lock);
+
         return;
 }
 
@@ -3468,7 +3398,7 @@ lpfc_els_unsol_event(struct lpfc_hba * phba,
         }
 
         did = icmd->un.rcvels.remoteID;
-        ndlp = lpfc_findnode_did(phba, NLP_SEARCH_ALL, did);
+        ndlp = lpfc_findnode_did(phba, did);
         if (!ndlp) {
                 /* Cannot find existing Fabric ndlp, so allocate a new one */
                 ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL);
@@ -3484,12 +3414,13 @@ lpfc_els_unsol_event(struct lpfc_hba * phba,
                 if ((did & Fabric_DID_MASK) == Fabric_DID_MASK) {
                         ndlp->nlp_type |= NLP_FABRIC;
                 }
-                ndlp->nlp_state = NLP_STE_UNUSED_NODE;
-                lpfc_nlp_list(phba, ndlp, NLP_UNUSED_LIST);
+                lpfc_nlp_set_state(phba, ndlp, NLP_STE_UNUSED_NODE);
         }
 
         phba->fc_stat.elsRcvFrame++;
-        elsiocb->context1 = ndlp;
+        if (elsiocb->context1)
+                lpfc_nlp_put(elsiocb->context1);
+        elsiocb->context1 = lpfc_nlp_get(ndlp);
         elsiocb->context2 = mp;
 
         if ((cmd & ELS_CMD_MASK) == ELS_CMD_RSCN) {
@@ -3513,9 +3444,8 @@ lpfc_els_unsol_event(struct lpfc_hba * phba,
         case ELS_CMD_FLOGI:
                 phba->fc_stat.elsRcvFLOGI++;
                 lpfc_els_rcv_flogi(phba, elsiocb, ndlp, newnode);
-                if (newnode) {
-                        lpfc_nlp_list(phba, ndlp, NLP_NO_LIST);
-                }
+                if (newnode)
+                        lpfc_drop_node(phba, ndlp);
                 break;
         case ELS_CMD_LOGO:
                 phba->fc_stat.elsRcvLOGO++;
@@ -3536,9 +3466,8 @@ lpfc_els_unsol_event(struct lpfc_hba * phba,
         case ELS_CMD_RSCN:
                 phba->fc_stat.elsRcvRSCN++;
                 lpfc_els_rcv_rscn(phba, elsiocb, ndlp, newnode);
-                if (newnode) {
-                        lpfc_nlp_list(phba, ndlp, NLP_NO_LIST);
-                }
+                if (newnode)
+                        lpfc_drop_node(phba, ndlp);
                 break;
         case ELS_CMD_ADISC:
                 phba->fc_stat.elsRcvADISC++;
@@ -3579,30 +3508,26 @@ lpfc_els_unsol_event(struct lpfc_hba * phba,
         case ELS_CMD_LIRR:
                 phba->fc_stat.elsRcvLIRR++;
                 lpfc_els_rcv_lirr(phba, elsiocb, ndlp);
-                if (newnode) {
-                        lpfc_nlp_list(phba, ndlp, NLP_NO_LIST);
-                }
+                if (newnode)
+                        lpfc_drop_node(phba, ndlp);
                 break;
         case ELS_CMD_RPS:
                 phba->fc_stat.elsRcvRPS++;
                 lpfc_els_rcv_rps(phba, elsiocb, ndlp);
-                if (newnode) {
-                        lpfc_nlp_list(phba, ndlp, NLP_NO_LIST);
-                }
+                if (newnode)
+                        lpfc_drop_node(phba, ndlp);
                 break;
         case ELS_CMD_RPL:
                 phba->fc_stat.elsRcvRPL++;
                 lpfc_els_rcv_rpl(phba, elsiocb, ndlp);
-                if (newnode) {
-                        lpfc_nlp_list(phba, ndlp, NLP_NO_LIST);
-                }
+                if (newnode)
+                        lpfc_drop_node(phba, ndlp);
                 break;
         case ELS_CMD_RNID:
                 phba->fc_stat.elsRcvRNID++;
                 lpfc_els_rcv_rnid(phba, elsiocb, ndlp);
-                if (newnode) {
-                        lpfc_nlp_list(phba, ndlp, NLP_NO_LIST);
-                }
+                if (newnode)
+                        lpfc_drop_node(phba, ndlp);
                 break;
         default:
                 /* Unsupported ELS command, reject */
@@ -3612,9 +3537,8 @@ lpfc_els_unsol_event(struct lpfc_hba * phba,
                 lpfc_printf_log(phba, KERN_ERR, LOG_ELS,
                                 "%d:0115 Unknown ELS command x%x received from "
                                 "NPORT x%x\n", phba->brd_no, cmd, did);
-                if (newnode) {
-                        lpfc_nlp_list(phba, ndlp, NLP_NO_LIST);
-                }
+                if (newnode)
+                        lpfc_drop_node(phba, ndlp);
                 break;
         }
 
@@ -3627,6 +3551,8 @@ lpfc_els_unsol_event(struct lpfc_hba * phba,
                 lpfc_els_rsp_reject(phba, stat.un.lsRjtError, elsiocb, ndlp);
         }
 
+        lpfc_nlp_put(elsiocb->context1);
+        elsiocb->context1 = NULL;
         if (elsiocb->context2) {
                 lpfc_mbuf_free(phba, mp->virt, mp->phys);
                 kfree(mp);
diff --git a/drivers/scsi/lpfc/lpfc_hbadisc.c b/drivers/scsi/lpfc/lpfc_hbadisc.c
index c39564e85e94..61caa8d379e2 100644
--- a/drivers/scsi/lpfc/lpfc_hbadisc.c
+++ b/drivers/scsi/lpfc/lpfc_hbadisc.c
@@ -1,7 +1,7 @@
 /*******************************************************************
  * This file is part of the Emulex Linux Device Driver for         *
  * Fibre Channel Host Bus Adapters.                                *
- * Copyright (C) 2004-2006 Emulex.  All rights reserved.           *
+ * Copyright (C) 2004-2007 Emulex.  All rights reserved.           *
  * EMULEX and SLI are trademarks of Emulex.                        *
  * www.emulex.com                                                  *
  * Portions Copyright (C) 2004-2005 Christoph Hellwig              *
@@ -109,6 +109,9 @@ lpfc_dev_loss_tmo_callbk(struct fc_rport *rport)
                 return;
         }
 
+        if (ndlp->nlp_state == NLP_STE_MAPPED_NODE)
+                return;
+
         name = (uint8_t *)&ndlp->nlp_portname;
         phba = ndlp->nlp_phba;
 
@@ -147,11 +150,17 @@ lpfc_dev_loss_tmo_callbk(struct fc_rport *rport)
                                 ndlp->nlp_state, ndlp->nlp_rpi);
         }
 
-        ndlp->rport = NULL;
-        rdata->pnode = NULL;
-
-        if (!(phba->fc_flag & FC_UNLOADING))
+        if (!(phba->fc_flag & FC_UNLOADING) &&
+            !(ndlp->nlp_flag & NLP_DELAY_TMO) &&
+            !(ndlp->nlp_flag & NLP_NPR_2B_DISC) &&
+            (ndlp->nlp_state != NLP_STE_UNMAPPED_NODE))
                 lpfc_disc_state_machine(phba, ndlp, NULL, NLP_EVT_DEVICE_RM);
+        else {
+                rdata->pnode = NULL;
+                ndlp->rport = NULL;
+                lpfc_nlp_put(ndlp);
+                put_device(&rport->dev);
+        }
 
         return;
 }
@@ -182,29 +191,35 @@ lpfc_work_list_done(struct lpfc_hba * phba)
                                 *(int *)(evtp->evt_arg1)  = 0;
                         complete((struct completion *)(evtp->evt_arg2));
                         break;
-                case LPFC_EVT_OFFLINE:
+                case LPFC_EVT_OFFLINE_PREP:
                         if (phba->hba_state >= LPFC_LINK_DOWN)
-                                lpfc_offline(phba);
+                                lpfc_offline_prep(phba);
+                        *(int *)(evtp->evt_arg1) = 0;
+                        complete((struct completion *)(evtp->evt_arg2));
+                        break;
+                case LPFC_EVT_OFFLINE:
+                        lpfc_offline(phba);
                         lpfc_sli_brdrestart(phba);
                         *(int *)(evtp->evt_arg1) =
-                                lpfc_sli_brdready(phba,HS_FFRDY | HS_MBRDY);
+                                lpfc_sli_brdready(phba, HS_FFRDY | HS_MBRDY);
+                        lpfc_unblock_mgmt_io(phba);
                         complete((struct completion *)(evtp->evt_arg2));
                         break;
                 case LPFC_EVT_WARM_START:
-                        if (phba->hba_state >= LPFC_LINK_DOWN)
-                                lpfc_offline(phba);
+                        lpfc_offline(phba);
                         lpfc_reset_barrier(phba);
                         lpfc_sli_brdreset(phba);
                         lpfc_hba_down_post(phba);
                         *(int *)(evtp->evt_arg1) =
                                 lpfc_sli_brdready(phba, HS_MBRDY);
+                        lpfc_unblock_mgmt_io(phba);
                         complete((struct completion *)(evtp->evt_arg2));
                         break;
                 case LPFC_EVT_KILL:
-                        if (phba->hba_state >= LPFC_LINK_DOWN)
-                                lpfc_offline(phba);
+                        lpfc_offline(phba);
                         *(int *)(evtp->evt_arg1)
                                 = (phba->stopped) ? 0 : lpfc_sli_brdkill(phba);
+                        lpfc_unblock_mgmt_io(phba);
                         complete((struct completion *)(evtp->evt_arg2));
                         break;
                 }
@@ -359,13 +374,12 @@ lpfc_workq_post_event(struct lpfc_hba * phba, void *arg1, void *arg2,
 }
 
 int
-lpfc_linkdown(struct lpfc_hba * phba)
+lpfc_linkdown(struct lpfc_hba *phba)
 {
         struct lpfc_sli       *psli;
         struct lpfc_nodelist  *ndlp, *next_ndlp;
-        struct list_head *listp, *node_list[7];
-        LPFC_MBOXQ_t     *mb;
-        int               rc, i;
+        LPFC_MBOXQ_t          *mb;
+        int                   rc;
 
         psli = &phba->sli;
         /* sysfs or selective reset may call this routine to clean up */
@@ -397,31 +411,16 @@ lpfc_linkdown(struct lpfc_hba * phba)
         /* Cleanup any outstanding ELS commands */
         lpfc_els_flush_cmd(phba);
 
-        /* Issue a LINK DOWN event to all nodes */
-        node_list[0] = &phba->fc_npr_list;  /* MUST do this list first */
-        node_list[1] = &phba->fc_nlpmap_list;
-        node_list[2] = &phba->fc_nlpunmap_list;
-        node_list[3] = &phba->fc_prli_list;
-        node_list[4] = &phba->fc_reglogin_list;
-        node_list[5] = &phba->fc_adisc_list;
-        node_list[6] = &phba->fc_plogi_list;
-        for (i = 0; i < 7; i++) {
-                listp = node_list[i];
-                if (list_empty(listp))
-                        continue;
-
-                list_for_each_entry_safe(ndlp, next_ndlp, listp, nlp_listp) {
-
+        /*
+         * Issue a LINK DOWN event to all nodes.
+         */
+        list_for_each_entry_safe(ndlp, next_ndlp, &phba->fc_nodes, nlp_listp) {
+                                /* free any ndlp's on unused list */
+                if (ndlp->nlp_state == NLP_STE_UNUSED_NODE)
+                        lpfc_drop_node(phba, ndlp);
+                else            /* otherwise, force node recovery. */
                         rc = lpfc_disc_state_machine(phba, ndlp, NULL,
-                                             NLP_EVT_DEVICE_RECOVERY);
-
-                }
-        }
-
-        /* free any ndlp's on unused list */
-        list_for_each_entry_safe(ndlp, next_ndlp, &phba->fc_unused_list,
-                                nlp_listp) {
-                lpfc_nlp_list(phba, ndlp, NLP_NO_LIST);
+                                                     NLP_EVT_DEVICE_RECOVERY);
         }
 
         /* Setup myDID for link up if we are in pt2pt mode */
@@ -452,11 +451,9 @@ lpfc_linkdown(struct lpfc_hba * phba)
 }
 
 static int
-lpfc_linkup(struct lpfc_hba * phba)
+lpfc_linkup(struct lpfc_hba *phba)
 {
         struct lpfc_nodelist *ndlp, *next_ndlp;
-        struct list_head *listp, *node_list[7];
-        int i;
 
         fc_host_post_event(phba->host, fc_get_event_number(),
                         FCH_EVT_LINKUP, 0);
@@ -470,29 +467,20 @@ lpfc_linkup(struct lpfc_hba * phba)
         spin_unlock_irq(phba->host->host_lock);
 
 
-        node_list[0] = &phba->fc_plogi_list;
-        node_list[1] = &phba->fc_adisc_list;
-        node_list[2] = &phba->fc_reglogin_list;
-        node_list[3] = &phba->fc_prli_list;
-        node_list[4] = &phba->fc_nlpunmap_list;
-        node_list[5] = &phba->fc_nlpmap_list;
-        node_list[6] = &phba->fc_npr_list;
-        for (i = 0; i < 7; i++) {
-                listp = node_list[i];
-                if (list_empty(listp))
-                        continue;
-
-                list_for_each_entry_safe(ndlp, next_ndlp, listp, nlp_listp) {
-                        if (phba->fc_flag & FC_LBIT) {
+        if (phba->fc_flag & FC_LBIT) {
+                list_for_each_entry(ndlp, &phba->fc_nodes, nlp_listp) {
+                        if (ndlp->nlp_state != NLP_STE_UNUSED_NODE) {
                                 if (ndlp->nlp_type & NLP_FABRIC) {
-                                        /* On Linkup its safe to clean up the
+                                        /*
+                                         * On Linkup its safe to clean up the
                                          * ndlp from Fabric connections.
                                          */
-                                        lpfc_nlp_list(phba, ndlp,
-                                                        NLP_UNUSED_LIST);
+                                        lpfc_nlp_set_state(phba, ndlp,
+                                                           NLP_STE_UNUSED_NODE);
                                 } else if (!(ndlp->nlp_flag & NLP_NPR_ADISC)) {
-                                        /* Fail outstanding IO now since device
-                                         * is marked for PLOGI.
+                                        /*
+                                         * Fail outstanding IO now since
+                                         * device is marked for PLOGI.
                                          */
                                         lpfc_unreg_rpi(phba, ndlp);
                                 }
@@ -501,9 +489,10 @@ lpfc_linkup(struct lpfc_hba * phba)
         }
 
         /* free any ndlp's on unused list */
-        list_for_each_entry_safe(ndlp, next_ndlp, &phba->fc_unused_list,
-                                nlp_listp) {
-                lpfc_nlp_list(phba, ndlp, NLP_NO_LIST);
+        list_for_each_entry_safe(ndlp, next_ndlp, &phba->fc_nodes,
+                                 nlp_listp) {
+                if (ndlp->nlp_state == NLP_STE_UNUSED_NODE)
+                        lpfc_drop_node(phba, ndlp);
         }
 
         return 0;
@@ -734,6 +723,9 @@ lpfc_mbx_process_link_up(struct lpfc_hba *phba, READ_LA_VAR *la)
                 case LA_4GHZ_LINK:
                         phba->fc_linkspeed = LA_4GHZ_LINK;
                         break;
+                case LA_8GHZ_LINK:
+                        phba->fc_linkspeed = LA_8GHZ_LINK;
+                        break;
                 default:
                         phba->fc_linkspeed = LA_UNKNW_LINK;
                         break;
@@ -889,12 +881,21 @@ lpfc_mbx_cmpl_read_la(struct lpfc_hba * phba, LPFC_MBOXQ_t * pmb)
 
         if (la->attType == AT_LINK_UP) {
                 phba->fc_stat.LinkUp++;
-                lpfc_printf_log(phba, KERN_ERR, LOG_LINK_EVENT,
+                if (phba->fc_flag & FC_LOOPBACK_MODE) {
+                        lpfc_printf_log(phba, KERN_INFO, LOG_LINK_EVENT,
+                                "%d:1306 Link Up Event in loop back mode "
+                                "x%x received Data: x%x x%x x%x x%x\n",
+                                phba->brd_no, la->eventTag, phba->fc_eventTag,
+                                la->granted_AL_PA, la->UlnkSpeed,
+                                phba->alpa_map[0]);
+                } else {
+                        lpfc_printf_log(phba, KERN_ERR, LOG_LINK_EVENT,
                                 "%d:1303 Link Up Event x%x received "
                                 "Data: x%x x%x x%x x%x\n",
                                 phba->brd_no, la->eventTag, phba->fc_eventTag,
                                 la->granted_AL_PA, la->UlnkSpeed,
                                 phba->alpa_map[0]);
+                }
                 lpfc_mbx_process_link_up(phba, la);
         } else {
                 phba->fc_stat.LinkDown++;
@@ -940,6 +941,7 @@ lpfc_mbx_cmpl_reg_login(struct lpfc_hba * phba, LPFC_MBOXQ_t * pmb)
         lpfc_mbuf_free(phba, mp->virt, mp->phys);
         kfree(mp);
         mempool_free( pmb, phba->mbox_mem_pool);
+        lpfc_nlp_put(ndlp);
 
         return;
 }
@@ -966,11 +968,14 @@ lpfc_mbx_cmpl_fabric_reg_login(struct lpfc_hba * phba, LPFC_MBOXQ_t * pmb)
         ndlp = (struct lpfc_nodelist *) pmb->context2;
         mp = (struct lpfc_dmabuf *) (pmb->context1);
 
+        pmb->context1 = NULL;
+        pmb->context2 = NULL;
+
         if (mb->mbxStatus) {
                 lpfc_mbuf_free(phba, mp->virt, mp->phys);
                 kfree(mp);
-                mempool_free( pmb, phba->mbox_mem_pool);
-                mempool_free( ndlp, phba->nlp_mem_pool);
+                mempool_free(pmb, phba->mbox_mem_pool);
+                lpfc_nlp_put(ndlp);
 
                 /* FLOGI failed, so just use loop map to make discovery list */
                 lpfc_disc_list_loopmap(phba);
@@ -980,12 +985,11 @@ lpfc_mbx_cmpl_fabric_reg_login(struct lpfc_hba * phba, LPFC_MBOXQ_t * pmb)
                 return;
         }
 
-        pmb->context1 = NULL;
-
         ndlp->nlp_rpi = mb->un.varWords[0];
         ndlp->nlp_type |= NLP_FABRIC;
-        ndlp->nlp_state = NLP_STE_UNMAPPED_NODE;
-        lpfc_nlp_list(phba, ndlp, NLP_UNMAPPED_LIST);
+        lpfc_nlp_set_state(phba, ndlp, NLP_STE_UNMAPPED_NODE);
+
+        lpfc_nlp_put(ndlp);     /* Drop the reference from the mbox */
 
         if (phba->hba_state == LPFC_FABRIC_CFG_LINK) {
                 /* This NPort has been assigned an NPort_ID by the fabric as a
@@ -996,7 +1000,7 @@ lpfc_mbx_cmpl_fabric_reg_login(struct lpfc_hba * phba, LPFC_MBOXQ_t * pmb)
                  */
                 lpfc_issue_els_scr(phba, SCR_DID, 0);
 
-                ndlp = lpfc_findnode_did(phba, NLP_SEARCH_ALL, NameServer_DID);
+                ndlp = lpfc_findnode_did(phba, NameServer_DID);
                 if (!ndlp) {
                         /* Allocate a new node instance. If the pool is empty,
                          * start the discovery process and skip the Nameserver
@@ -1008,15 +1012,14 @@ lpfc_mbx_cmpl_fabric_reg_login(struct lpfc_hba * phba, LPFC_MBOXQ_t * pmb)
                                 lpfc_disc_start(phba);
                                 lpfc_mbuf_free(phba, mp->virt, mp->phys);
                                 kfree(mp);
-                                mempool_free( pmb, phba->mbox_mem_pool);
+                                mempool_free(pmb, phba->mbox_mem_pool);
                                 return;
                         } else {
                                 lpfc_nlp_init(phba, ndlp, NameServer_DID);
                                 ndlp->nlp_type |= NLP_FABRIC;
                         }
                 }
-                ndlp->nlp_state = NLP_STE_PLOGI_ISSUE;
-                lpfc_nlp_list(phba, ndlp, NLP_PLOGI_LIST);
+                lpfc_nlp_set_state(phba, ndlp, NLP_STE_PLOGI_ISSUE);
                 lpfc_issue_els_plogi(phba, NameServer_DID, 0);
                 if (phba->cfg_fdmi_on) {
                         ndlp_fdmi = mempool_alloc(phba->nlp_mem_pool,
@@ -1032,7 +1035,7 @@ lpfc_mbx_cmpl_fabric_reg_login(struct lpfc_hba * phba, LPFC_MBOXQ_t * pmb)
 
         lpfc_mbuf_free(phba, mp->virt, mp->phys);
         kfree(mp);
-        mempool_free( pmb, phba->mbox_mem_pool);
+        mempool_free(pmb, phba->mbox_mem_pool);
         return;
 }
 
@@ -1057,10 +1060,11 @@ lpfc_mbx_cmpl_ns_reg_login(struct lpfc_hba * phba, LPFC_MBOXQ_t * pmb)
         mp = (struct lpfc_dmabuf *) (pmb->context1);
 
         if (mb->mbxStatus) {
+                lpfc_nlp_put(ndlp);
                 lpfc_mbuf_free(phba, mp->virt, mp->phys);
                 kfree(mp);
-                mempool_free( pmb, phba->mbox_mem_pool);
-                lpfc_nlp_list(phba, ndlp, NLP_NO_LIST);
+                mempool_free(pmb, phba->mbox_mem_pool);
+                lpfc_drop_node(phba, ndlp);
 
                 /* RegLogin failed, so just use loop map to make discovery
                    list */
@@ -1075,8 +1079,7 @@ lpfc_mbx_cmpl_ns_reg_login(struct lpfc_hba * phba, LPFC_MBOXQ_t * pmb)
 
         ndlp->nlp_rpi = mb->un.varWords[0];
         ndlp->nlp_type |= NLP_FABRIC;
-        ndlp->nlp_state = NLP_STE_UNMAPPED_NODE;
-        lpfc_nlp_list(phba, ndlp, NLP_UNMAPPED_LIST);
+        lpfc_nlp_set_state(phba, ndlp, NLP_STE_UNMAPPED_NODE);
 
         if (phba->hba_state < LPFC_HBA_READY) {
                 /* Link up discovery requires Fabrib registration. */
@@ -1093,6 +1096,7 @@ lpfc_mbx_cmpl_ns_reg_login(struct lpfc_hba * phba, LPFC_MBOXQ_t * pmb)
                 lpfc_disc_start(phba);
         }
 
+        lpfc_nlp_put(ndlp);
         lpfc_mbuf_free(phba, mp->virt, mp->phys);
         kfree(mp);
         mempool_free( pmb, phba->mbox_mem_pool);
@@ -1101,8 +1105,7 @@ lpfc_mbx_cmpl_ns_reg_login(struct lpfc_hba * phba, LPFC_MBOXQ_t * pmb)
 }
 
 static void
-lpfc_register_remote_port(struct lpfc_hba * phba,
-                            struct lpfc_nodelist * ndlp)
+lpfc_register_remote_port(struct lpfc_hba *phba, struct lpfc_nodelist *ndlp)
 {
         struct fc_rport *rport;
         struct lpfc_rport_data *rdata;
@@ -1114,8 +1117,19 @@ lpfc_register_remote_port(struct lpfc_hba * phba,
         rport_ids.port_id = ndlp->nlp_DID;
         rport_ids.roles = FC_RPORT_ROLE_UNKNOWN;
 
+        /*
+         * We leave our node pointer in rport->dd_data when we unregister a
+         * FCP target port.  But fc_remote_port_add zeros the space to which
+         * rport->dd_data points.  So, if we're reusing a previously
+         * registered port, drop the reference that we took the last time we
+         * registered the port.
+         */
+        if (ndlp->rport && ndlp->rport->dd_data &&
+            *(struct lpfc_rport_data **) ndlp->rport->dd_data) {
+                lpfc_nlp_put(ndlp);
+        }
         ndlp->rport = rport = fc_remote_port_add(phba->host, 0, &rport_ids);
-        if (!rport) {
+        if (!rport || !get_device(&rport->dev)) {
                 dev_printk(KERN_WARNING, &phba->pcidev->dev,
                            "Warning: fc_remote_port_add failed\n");
                 return;
@@ -1125,7 +1139,7 @@ lpfc_register_remote_port(struct lpfc_hba * phba,
         rport->maxframe_size = ndlp->nlp_maxframe;
         rport->supported_classes = ndlp->nlp_class_sup;
         rdata = rport->dd_data;
-        rdata->pnode = ndlp;
+        rdata->pnode = lpfc_nlp_get(ndlp);
 
         if (ndlp->nlp_type & NLP_FCP_TARGET)
                 rport_ids.roles |= FC_RPORT_ROLE_FCP_TARGET;
@@ -1145,8 +1159,7 @@ lpfc_register_remote_port(struct lpfc_hba * phba,
 }
 
 static void
-lpfc_unregister_remote_port(struct lpfc_hba * phba,
-                            struct lpfc_nodelist * ndlp)
+lpfc_unregister_remote_port(struct lpfc_hba *phba, struct lpfc_nodelist *ndlp)
 {
         struct fc_rport *rport = ndlp->rport;
         struct lpfc_rport_data *rdata = rport->dd_data;
@@ -1154,6 +1167,8 @@ lpfc_unregister_remote_port(struct lpfc_hba * phba,
         if (rport->scsi_target_id == -1) {
                 ndlp->rport = NULL;
                 rdata->pnode = NULL;
+                lpfc_nlp_put(ndlp);
+                put_device(&rport->dev);
         }
 
         fc_remote_port_delete(rport);
@@ -1161,178 +1176,70 @@ lpfc_unregister_remote_port(struct lpfc_hba * phba,
         return;
 }
 
-int
-lpfc_nlp_list(struct lpfc_hba * phba, struct lpfc_nodelist * nlp, int list)
+static void
+lpfc_nlp_counters(struct lpfc_hba *phba, int state, int count)
 {
-        enum { none, unmapped, mapped } rport_add = none, rport_del = none;
-        struct lpfc_sli      *psli;
-
-        psli = &phba->sli;
-        /* Sanity check to ensure we are not moving to / from the same list */
-        if ((nlp->nlp_flag & NLP_LIST_MASK) == list)
-                if (list != NLP_NO_LIST)
-                        return 0;
-
         spin_lock_irq(phba->host->host_lock);
-        switch (nlp->nlp_flag & NLP_LIST_MASK) {
-        case NLP_NO_LIST: /* Not on any list */
+        switch (state) {
+        case NLP_STE_UNUSED_NODE:
+                phba->fc_unused_cnt += count;
                 break;
-        case NLP_UNUSED_LIST:
-                phba->fc_unused_cnt--;
-                list_del(&nlp->nlp_listp);
+        case NLP_STE_PLOGI_ISSUE:
+                phba->fc_plogi_cnt += count;
                 break;
-        case NLP_PLOGI_LIST:
-                phba->fc_plogi_cnt--;
-                list_del(&nlp->nlp_listp);
+        case NLP_STE_ADISC_ISSUE:
+                phba->fc_adisc_cnt += count;
                 break;
-        case NLP_ADISC_LIST:
-                phba->fc_adisc_cnt--;
-                list_del(&nlp->nlp_listp);
+        case NLP_STE_REG_LOGIN_ISSUE:
+                phba->fc_reglogin_cnt += count;
                 break;
-        case NLP_REGLOGIN_LIST:
-                phba->fc_reglogin_cnt--;
-                list_del(&nlp->nlp_listp);
+        case NLP_STE_PRLI_ISSUE:
+                phba->fc_prli_cnt += count;
                 break;
-        case NLP_PRLI_LIST:
-                phba->fc_prli_cnt--;
-                list_del(&nlp->nlp_listp);
+        case NLP_STE_UNMAPPED_NODE:
+                phba->fc_unmap_cnt += count;
                 break;
-        case NLP_UNMAPPED_LIST:
-                phba->fc_unmap_cnt--;
-                list_del(&nlp->nlp_listp);
-                nlp->nlp_flag &= ~NLP_TGT_NO_SCSIID;
-                nlp->nlp_type &= ~NLP_FC_NODE;
-                phba->nport_event_cnt++;
-                if (nlp->rport)
-                        rport_del = unmapped;
+        case NLP_STE_MAPPED_NODE:
+                phba->fc_map_cnt += count;
                 break;
-        case NLP_MAPPED_LIST:
-                phba->fc_map_cnt--;
-                list_del(&nlp->nlp_listp);
-                phba->nport_event_cnt++;
-                if (nlp->rport)
-                        rport_del = mapped;
-                break;
-        case NLP_NPR_LIST:
-                phba->fc_npr_cnt--;
-                list_del(&nlp->nlp_listp);
-                /* Stop delay tmo if taking node off NPR list */
-                if ((nlp->nlp_flag & NLP_DELAY_TMO) &&
-                   (list != NLP_NPR_LIST)) {
-                        spin_unlock_irq(phba->host->host_lock);
-                        lpfc_cancel_retry_delay_tmo(phba, nlp);
-                        spin_lock_irq(phba->host->host_lock);
-                }
+        case NLP_STE_NPR_NODE:
+                phba->fc_npr_cnt += count;
                 break;
         }
+        spin_unlock_irq(phba->host->host_lock);
+}
 
-        nlp->nlp_flag &= ~NLP_LIST_MASK;
-
-        /* Add NPort <did> to <num> list */
-        lpfc_printf_log(phba,
-                        KERN_INFO,
-                        LOG_NODE,
-                        "%d:0904 Add NPort x%x to %d list Data: x%x\n",
-                        phba->brd_no,
-                        nlp->nlp_DID, list, nlp->nlp_flag);
-
-        switch (list) {
-        case NLP_NO_LIST: /* No list, just remove it */
-                spin_unlock_irq(phba->host->host_lock);
-                lpfc_nlp_remove(phba, nlp);
-                spin_lock_irq(phba->host->host_lock);
-                /* as node removed - stop further transport calls */
-                rport_del = none;
-                break;
-        case NLP_UNUSED_LIST:
-                nlp->nlp_flag |= list;
-                /* Put it at the end of the unused list */
-                list_add_tail(&nlp->nlp_listp, &phba->fc_unused_list);
-                phba->fc_unused_cnt++;
-                break;
-        case NLP_PLOGI_LIST:
-                nlp->nlp_flag |= list;
-                /* Put it at the end of the plogi list */
-                list_add_tail(&nlp->nlp_listp, &phba->fc_plogi_list);
-                phba->fc_plogi_cnt++;
-                break;
-        case NLP_ADISC_LIST:
-                nlp->nlp_flag |= list;
-                /* Put it at the end of the adisc list */
-                list_add_tail(&nlp->nlp_listp, &phba->fc_adisc_list);
-                phba->fc_adisc_cnt++;
-                break;
-        case NLP_REGLOGIN_LIST:
-                nlp->nlp_flag |= list;
-                /* Put it at the end of the reglogin list */
-                list_add_tail(&nlp->nlp_listp, &phba->fc_reglogin_list);
-                phba->fc_reglogin_cnt++;
-                break;
-        case NLP_PRLI_LIST:
-                nlp->nlp_flag |= list;
-                /* Put it at the end of the prli list */
-                list_add_tail(&nlp->nlp_listp, &phba->fc_prli_list);
-                phba->fc_prli_cnt++;
-                break;
-        case NLP_UNMAPPED_LIST:
-                rport_add = unmapped;
-                /* ensure all vestiges of "mapped" significance are gone */
-                nlp->nlp_type &= ~(NLP_FCP_TARGET | NLP_FCP_INITIATOR);
-                nlp->nlp_flag |= list;
-                /* Put it at the end of the unmap list */
-                list_add_tail(&nlp->nlp_listp, &phba->fc_nlpunmap_list);
-                phba->fc_unmap_cnt++;
-                phba->nport_event_cnt++;
-                nlp->nlp_flag &= ~NLP_NODEV_REMOVE;
-                nlp->nlp_type |= NLP_FC_NODE;
-                break;
-        case NLP_MAPPED_LIST:
-                rport_add = mapped;
-                nlp->nlp_flag |= list;
-                /* Put it at the end of the map list */
-                list_add_tail(&nlp->nlp_listp, &phba->fc_nlpmap_list);
-                phba->fc_map_cnt++;
+static void
+lpfc_nlp_state_cleanup(struct lpfc_hba *phba, struct lpfc_nodelist *ndlp,
+                       int old_state, int new_state)
+{
+        if (new_state == NLP_STE_UNMAPPED_NODE) {
+                ndlp->nlp_type &= ~(NLP_FCP_TARGET | NLP_FCP_INITIATOR);
+                ndlp->nlp_flag &= ~NLP_NODEV_REMOVE;
+                ndlp->nlp_type |= NLP_FC_NODE;
+        }
+        if (new_state == NLP_STE_MAPPED_NODE)
+                ndlp->nlp_flag &= ~NLP_NODEV_REMOVE;
+        if (new_state == NLP_STE_NPR_NODE)
+                ndlp->nlp_flag &= ~NLP_RCV_PLOGI;
+
+        /* Transport interface */
+        if (ndlp->rport && (old_state == NLP_STE_MAPPED_NODE ||
+                            old_state == NLP_STE_UNMAPPED_NODE)) {
                 phba->nport_event_cnt++;
-                nlp->nlp_flag &= ~NLP_NODEV_REMOVE;
-                break;
-        case NLP_NPR_LIST:
-                nlp->nlp_flag |= list;
-                /* Put it at the end of the npr list */
-                list_add_tail(&nlp->nlp_listp, &phba->fc_npr_list);
-                phba->fc_npr_cnt++;
-
-                nlp->nlp_flag &= ~NLP_RCV_PLOGI;
-                break;
-        case NLP_JUST_DQ:
-                break;
+                lpfc_unregister_remote_port(phba, ndlp);
         }
 
-        spin_unlock_irq(phba->host->host_lock);
-
-        /*
-         * We make all the calls into the transport after we have
-         * moved the node between lists. This so that we don't
-         * release the lock while in-between lists.
-         */
-
-        /* Don't upcall midlayer if we're unloading */
-        if (!(phba->fc_flag & FC_UNLOADING)) {
-                /*
-                 * We revalidate the rport pointer as the "add" function
-                 * may have removed the remote port.
-                 */
-                if ((rport_del != none) && nlp->rport)
-                        lpfc_unregister_remote_port(phba, nlp);
-
-                if (rport_add != none) {
+        if (new_state ==  NLP_STE_MAPPED_NODE ||
+            new_state == NLP_STE_UNMAPPED_NODE) {
+                phba->nport_event_cnt++;
                         /*
                          * Tell the fc transport about the port, if we haven't
                          * already. If we have, and it's a scsi entity, be
                          * sure to unblock any attached scsi devices
                          */
-                        if ((!nlp->rport) || (nlp->rport->port_state ==
-                                        FC_PORTSTATE_BLOCKED))
-                                lpfc_register_remote_port(phba, nlp);
+                        lpfc_register_remote_port(phba, ndlp);
+        }
 
                         /*
                          * if we added to Mapped list, but the remote port
@@ -1340,19 +1247,95 @@ lpfc_nlp_list(struct lpfc_hba * phba, struct lpfc_nodelist * nlp, int list)
                          * our presentable range - move the node to the
                          * Unmapped List
                          */
-                        if ((rport_add == mapped) &&
-                            ((!nlp->rport) ||
-                             (nlp->rport->scsi_target_id == -1) ||
-                             (nlp->rport->scsi_target_id >= LPFC_MAX_TARGET))) {
-                                nlp->nlp_state = NLP_STE_UNMAPPED_NODE;
-                                spin_lock_irq(phba->host->host_lock);
-                                nlp->nlp_flag |= NLP_TGT_NO_SCSIID;
-                                spin_unlock_irq(phba->host->host_lock);
-                                lpfc_nlp_list(phba, nlp, NLP_UNMAPPED_LIST);
-                        }
-                }
+        if (new_state == NLP_STE_MAPPED_NODE &&
+            (!ndlp->rport ||
+             ndlp->rport->scsi_target_id == -1 ||
+             ndlp->rport->scsi_target_id >= LPFC_MAX_TARGET)) {
+                spin_lock_irq(phba->host->host_lock);
+                ndlp->nlp_flag |= NLP_TGT_NO_SCSIID;
+                spin_unlock_irq(phba->host->host_lock);
+                lpfc_nlp_set_state(phba, ndlp, NLP_STE_UNMAPPED_NODE);
         }
-        return 0;
+}
+
+static char *
+lpfc_nlp_state_name(char *buffer, size_t size, int state)
+{
+        static char *states[] = {
+                [NLP_STE_UNUSED_NODE] = "UNUSED",
+                [NLP_STE_PLOGI_ISSUE] = "PLOGI",
+                [NLP_STE_ADISC_ISSUE] = "ADISC",
+                [NLP_STE_REG_LOGIN_ISSUE] = "REGLOGIN",
+                [NLP_STE_PRLI_ISSUE] = "PRLI",
+                [NLP_STE_UNMAPPED_NODE] = "UNMAPPED",
+                [NLP_STE_MAPPED_NODE] = "MAPPED",
+                [NLP_STE_NPR_NODE] = "NPR",
+        };
+
+        if (state < ARRAY_SIZE(states) && states[state])
+                strlcpy(buffer, states[state], size);
+        else
+                snprintf(buffer, size, "unknown (%d)", state);
+        return buffer;
+}
+
+void
+lpfc_nlp_set_state(struct lpfc_hba *phba, struct lpfc_nodelist *ndlp, int state)
+{
+        int  old_state = ndlp->nlp_state;
+        char name1[16], name2[16];
+
+        lpfc_printf_log(phba, KERN_INFO, LOG_NODE,
+                        "%d:0904 NPort state transition x%06x, %s -> %s\n",
+                        phba->brd_no,
+                        ndlp->nlp_DID,
+                        lpfc_nlp_state_name(name1, sizeof(name1), old_state),
+                        lpfc_nlp_state_name(name2, sizeof(name2), state));
+        if (old_state == NLP_STE_NPR_NODE &&
+            (ndlp->nlp_flag & NLP_DELAY_TMO) != 0 &&
+            state != NLP_STE_NPR_NODE)
+                lpfc_cancel_retry_delay_tmo(phba, ndlp);
+        if (old_state == NLP_STE_UNMAPPED_NODE) {
+                ndlp->nlp_flag &= ~NLP_TGT_NO_SCSIID;
+                ndlp->nlp_type &= ~NLP_FC_NODE;
+        }
+
+        if (list_empty(&ndlp->nlp_listp)) {
+                spin_lock_irq(phba->host->host_lock);
+                list_add_tail(&ndlp->nlp_listp, &phba->fc_nodes);
+                spin_unlock_irq(phba->host->host_lock);
+        } else if (old_state)
+                lpfc_nlp_counters(phba, old_state, -1);
+
+        ndlp->nlp_state = state;
+        lpfc_nlp_counters(phba, state, 1);
+        lpfc_nlp_state_cleanup(phba, ndlp, old_state, state);
+}
+
+void
+lpfc_dequeue_node(struct lpfc_hba *phba, struct lpfc_nodelist *ndlp)
+{
+        if ((ndlp->nlp_flag & NLP_DELAY_TMO) != 0)
+                lpfc_cancel_retry_delay_tmo(phba, ndlp);
+        if (ndlp->nlp_state && !list_empty(&ndlp->nlp_listp))
+                lpfc_nlp_counters(phba, ndlp->nlp_state, -1);
+        spin_lock_irq(phba->host->host_lock);
+        list_del_init(&ndlp->nlp_listp);
+        spin_unlock_irq(phba->host->host_lock);
+        lpfc_nlp_state_cleanup(phba, ndlp, ndlp->nlp_state, 0);
+}
+
+void
+lpfc_drop_node(struct lpfc_hba *phba, struct lpfc_nodelist *ndlp)
+{
+        if ((ndlp->nlp_flag & NLP_DELAY_TMO) != 0)
+                lpfc_cancel_retry_delay_tmo(phba, ndlp);
+        if (ndlp->nlp_state && !list_empty(&ndlp->nlp_listp))
+                lpfc_nlp_counters(phba, ndlp->nlp_state, -1);
+        spin_lock_irq(phba->host->host_lock);
+        list_del_init(&ndlp->nlp_listp);
+        spin_unlock_irq(phba->host->host_lock);
+        lpfc_nlp_put(ndlp);
 }
 
 /*
@@ -1464,6 +1447,7 @@ lpfc_check_sli_ndlp(struct lpfc_hba * phba,
 static int
 lpfc_no_rpi(struct lpfc_hba * phba, struct lpfc_nodelist * ndlp)
 {
+        LIST_HEAD(completions);
         struct lpfc_sli *psli;
         struct lpfc_sli_ring *pring;
         struct lpfc_iocbq *iocb, *next_iocb;
@@ -1492,29 +1476,29 @@ lpfc_no_rpi(struct lpfc_hba * phba, struct lpfc_nodelist * ndlp)
                                      (phba, pring, iocb, ndlp))) {
                                         /* It matches, so deque and call compl
                                            with an error */
-                                        list_del(&iocb->list);
+                                        list_move_tail(&iocb->list,
+                                                       &completions);
                                         pring->txq_cnt--;
-                                        if (iocb->iocb_cmpl) {
-                                                icmd = &iocb->iocb;
-                                                icmd->ulpStatus =
-                                                    IOSTAT_LOCAL_REJECT;
-                                                icmd->un.ulpWord[4] =
-                                                    IOERR_SLI_ABORTED;
-                                                spin_unlock_irq(phba->host->
-                                                                host_lock);
-                                                (iocb->iocb_cmpl) (phba,
-                                                                   iocb, iocb);
-                                                spin_lock_irq(phba->host->
-                                                              host_lock);
-                                        } else
-                                                lpfc_sli_release_iocbq(phba,
-                                                                       iocb);
                                 }
                         }
                         spin_unlock_irq(phba->host->host_lock);
 
                 }
         }
+
+        while (!list_empty(&completions)) {
+                iocb = list_get_first(&completions, struct lpfc_iocbq, list);
+                list_del(&iocb->list);
+
+                if (iocb->iocb_cmpl) {
+                        icmd = &iocb->iocb;
+                        icmd->ulpStatus = IOSTAT_LOCAL_REJECT;
+                        icmd->un.ulpWord[4] = IOERR_SLI_ABORTED;
+                        (iocb->iocb_cmpl) (phba, iocb, iocb);
+                } else
+                        lpfc_sli_release_iocbq(phba, iocb);
+        }
+
         return 0;
 }
 
@@ -1554,7 +1538,7 @@ lpfc_unreg_rpi(struct lpfc_hba * phba, struct lpfc_nodelist * ndlp)
  * so it can be freed.
  */
 static int
-lpfc_freenode(struct lpfc_hba * phba, struct lpfc_nodelist * ndlp)
+lpfc_cleanup_node(struct lpfc_hba * phba, struct lpfc_nodelist * ndlp)
 {
         LPFC_MBOXQ_t       *mb;
         LPFC_MBOXQ_t       *nextmb;
@@ -1567,17 +1551,7 @@ lpfc_freenode(struct lpfc_hba * phba, struct lpfc_nodelist * ndlp)
                         phba->brd_no, ndlp->nlp_DID, ndlp->nlp_flag,
                         ndlp->nlp_state, ndlp->nlp_rpi);
 
-        lpfc_nlp_list(phba, ndlp, NLP_JUST_DQ);
-
-        /*
-         * if unloading the driver - just leave the remote port in place.
-         * The driver unload will force the attached devices to detach
-         * and flush cache's w/o generating flush errors.
-         */
-        if ((ndlp->rport) && !(phba->fc_flag & FC_UNLOADING)) {
-                lpfc_unregister_remote_port(phba, ndlp);
-                ndlp->nlp_sid = NLP_NO_SID;
-        }
+        lpfc_dequeue_node(phba, ndlp);
 
         /* cleanup any ndlp on mbox q waiting for reglogin cmpl */
         if ((mb = phba->sli.mbox_active)) {
@@ -1599,11 +1573,12 @@ lpfc_freenode(struct lpfc_hba * phba, struct lpfc_nodelist * ndlp)
                         }
                         list_del(&mb->list);
                         mempool_free(mb, phba->mbox_mem_pool);
+                        lpfc_nlp_put(ndlp);
                 }
         }
         spin_unlock_irq(phba->host->host_lock);
 
-        lpfc_els_abort(phba,ndlp,0);
+        lpfc_els_abort(phba,ndlp);
         spin_lock_irq(phba->host->host_lock);
         ndlp->nlp_flag &= ~NLP_DELAY_TMO;
         spin_unlock_irq(phba->host->host_lock);
@@ -1624,27 +1599,27 @@ lpfc_freenode(struct lpfc_hba * phba, struct lpfc_nodelist * ndlp)
  * If we are in the middle of using the nlp in the discovery state
  * machine, defer the free till we reach the end of the state machine.
  */
-int
-lpfc_nlp_remove(struct lpfc_hba * phba, struct lpfc_nodelist * ndlp)
+static void
+lpfc_nlp_remove(struct lpfc_hba *phba, struct lpfc_nodelist *ndlp)
 {
+        struct lpfc_rport_data *rdata;
 
         if (ndlp->nlp_flag & NLP_DELAY_TMO) {
                 lpfc_cancel_retry_delay_tmo(phba, ndlp);
         }
 
-        if (ndlp->nlp_disc_refcnt) {
-                spin_lock_irq(phba->host->host_lock);
-                ndlp->nlp_flag |= NLP_DELAY_REMOVE;
-                spin_unlock_irq(phba->host->host_lock);
-        } else {
-                lpfc_freenode(phba, ndlp);
-                mempool_free( ndlp, phba->nlp_mem_pool);
+        lpfc_cleanup_node(phba, ndlp);
+
+        if ((ndlp->rport) && !(phba->fc_flag & FC_UNLOADING)) {
+                put_device(&ndlp->rport->dev);
+                rdata = ndlp->rport->dd_data;
+                rdata->pnode = NULL;
+                ndlp->rport = NULL;
         }
-        return 0;
 }
 
 static int
-lpfc_matchdid(struct lpfc_hba * phba, struct lpfc_nodelist * ndlp, uint32_t did)
+lpfc_matchdid(struct lpfc_hba *phba, struct lpfc_nodelist *ndlp, uint32_t did)
 {
         D_ID mydid;
         D_ID ndlpdid;
@@ -1693,57 +1668,36 @@ lpfc_matchdid(struct lpfc_hba * phba, struct lpfc_nodelist * ndlp, uint32_t did)
         return 0;
 }
 
-/* Search for a nodelist entry on a specific list */
+/* Search for a nodelist entry */
 struct lpfc_nodelist *
-lpfc_findnode_did(struct lpfc_hba * phba, uint32_t order, uint32_t did)
+lpfc_findnode_did(struct lpfc_hba *phba, uint32_t did)
 {
         struct lpfc_nodelist *ndlp;
-        struct list_head *lists[]={&phba->fc_nlpunmap_list,
-                                   &phba->fc_nlpmap_list,
-                                   &phba->fc_plogi_list,
-                                   &phba->fc_adisc_list,
-                                   &phba->fc_reglogin_list,
-                                   &phba->fc_prli_list,
-                                   &phba->fc_npr_list,
-                                   &phba->fc_unused_list};
-        uint32_t search[]={NLP_SEARCH_UNMAPPED,
-                           NLP_SEARCH_MAPPED,
-                           NLP_SEARCH_PLOGI,
-                           NLP_SEARCH_ADISC,
-                           NLP_SEARCH_REGLOGIN,
-                           NLP_SEARCH_PRLI,
-                           NLP_SEARCH_NPR,
-                           NLP_SEARCH_UNUSED};
-        int i;
         uint32_t data1;
 
         spin_lock_irq(phba->host->host_lock);
-        for (i = 0; i < ARRAY_SIZE(lists); i++ ) {
-                if (!(order & search[i]))
-                        continue;
-                list_for_each_entry(ndlp, lists[i], nlp_listp) {
-                        if (lpfc_matchdid(phba, ndlp, did)) {
-                                data1 = (((uint32_t) ndlp->nlp_state << 24) |
-                                         ((uint32_t) ndlp->nlp_xri << 16) |
-                                         ((uint32_t) ndlp->nlp_type << 8) |
-                                         ((uint32_t) ndlp->nlp_rpi & 0xff));
-                                lpfc_printf_log(phba, KERN_INFO, LOG_NODE,
-                                                "%d:0929 FIND node DID "
-                                                " Data: x%p x%x x%x x%x\n",
-                                                phba->brd_no,
-                                                ndlp, ndlp->nlp_DID,
-                                                ndlp->nlp_flag, data1);
-                                spin_unlock_irq(phba->host->host_lock);
-                                return ndlp;
-                        }
+        list_for_each_entry(ndlp, &phba->fc_nodes, nlp_listp) {
+                if (lpfc_matchdid(phba, ndlp, did)) {
+                        data1 = (((uint32_t) ndlp->nlp_state << 24) |
+                                 ((uint32_t) ndlp->nlp_xri << 16) |
+                                 ((uint32_t) ndlp->nlp_type << 8) |
+                                 ((uint32_t) ndlp->nlp_rpi & 0xff));
+                        lpfc_printf_log(phba, KERN_INFO, LOG_NODE,
+                                        "%d:0929 FIND node DID "
+                                        " Data: x%p x%x x%x x%x\n",
+                                        phba->brd_no,
+                                        ndlp, ndlp->nlp_DID,
+                                        ndlp->nlp_flag, data1);
+                        spin_unlock_irq(phba->host->host_lock);
+                        return ndlp;
                 }
         }
         spin_unlock_irq(phba->host->host_lock);
 
         /* FIND node did <did> NOT FOUND */
         lpfc_printf_log(phba, KERN_INFO, LOG_NODE,
-                        "%d:0932 FIND node did x%x NOT FOUND Data: x%x\n",
-                        phba->brd_no, did, order);
+                        "%d:0932 FIND node did x%x NOT FOUND.\n",
+                        phba->brd_no, did);
         return NULL;
 }
 
@@ -1751,9 +1705,8 @@ struct lpfc_nodelist *
 lpfc_setup_disc_node(struct lpfc_hba * phba, uint32_t did)
 {
         struct lpfc_nodelist *ndlp;
-        uint32_t flg;
 
-        ndlp = lpfc_findnode_did(phba, NLP_SEARCH_ALL, did);
+        ndlp = lpfc_findnode_did(phba, did);
         if (!ndlp) {
                 if ((phba->fc_flag & FC_RSCN_MODE) &&
                    ((lpfc_rscn_payload_check(phba, did) == 0)))
@@ -1763,8 +1716,7 @@ lpfc_setup_disc_node(struct lpfc_hba * phba, uint32_t did)
                 if (!ndlp)
                         return NULL;
                 lpfc_nlp_init(phba, ndlp, did);
-                ndlp->nlp_state = NLP_STE_NPR_NODE;
-                lpfc_nlp_list(phba, ndlp, NLP_NPR_LIST);
+                lpfc_nlp_set_state(phba, ndlp, NLP_STE_NPR_NODE);
                 ndlp->nlp_flag |= NLP_NPR_2B_DISC;
                 return ndlp;
         }
@@ -1780,11 +1732,10 @@ lpfc_setup_disc_node(struct lpfc_hba * phba, uint32_t did)
                 } else
                         ndlp = NULL;
         } else {
-                flg = ndlp->nlp_flag & NLP_LIST_MASK;
-                if ((flg == NLP_ADISC_LIST) || (flg == NLP_PLOGI_LIST))
+                if (ndlp->nlp_state == NLP_STE_ADISC_ISSUE ||
+                    ndlp->nlp_state == NLP_STE_PLOGI_ISSUE)
                         return NULL;
-                ndlp->nlp_state = NLP_STE_NPR_NODE;
-                lpfc_nlp_list(phba, ndlp, NLP_NPR_LIST);
+                lpfc_nlp_set_state(phba, ndlp, NLP_STE_NPR_NODE);
                 ndlp->nlp_flag |= NLP_NPR_2B_DISC;
         }
         return ndlp;
@@ -1842,8 +1793,9 @@ lpfc_disc_start(struct lpfc_hba * phba)
         struct lpfc_sli *psli;
         LPFC_MBOXQ_t *mbox;
         struct lpfc_nodelist *ndlp, *next_ndlp;
-        uint32_t did_changed, num_sent;
+        uint32_t num_sent;
         uint32_t clear_la_pending;
+        int did_changed;
         int rc;
 
         psli = &phba->sli;
@@ -1877,14 +1829,13 @@ lpfc_disc_start(struct lpfc_hba * phba)
                         phba->fc_plogi_cnt, phba->fc_adisc_cnt);
 
         /* If our did changed, we MUST do PLOGI */
-        list_for_each_entry_safe(ndlp, next_ndlp, &phba->fc_npr_list,
-                                nlp_listp) {
-                if (ndlp->nlp_flag & NLP_NPR_2B_DISC) {
-                        if (did_changed) {
-                                spin_lock_irq(phba->host->host_lock);
-                                ndlp->nlp_flag &= ~NLP_NPR_ADISC;
-                                spin_unlock_irq(phba->host->host_lock);
-                        }
+        list_for_each_entry_safe(ndlp, next_ndlp, &phba->fc_nodes, nlp_listp) {
+                if (ndlp->nlp_state == NLP_STE_NPR_NODE &&
+                    (ndlp->nlp_flag & NLP_NPR_2B_DISC) != 0 &&
+                    did_changed) {
+                        spin_lock_irq(phba->host->host_lock);
+                        ndlp->nlp_flag &= ~NLP_NPR_ADISC;
+                        spin_unlock_irq(phba->host->host_lock);
                 }
         }
 
@@ -1944,11 +1895,11 @@ lpfc_disc_start(struct lpfc_hba * phba)
 static void
 lpfc_free_tx(struct lpfc_hba * phba, struct lpfc_nodelist * ndlp)
 {
+        LIST_HEAD(completions);
         struct lpfc_sli *psli;
         IOCB_t     *icmd;
         struct lpfc_iocbq    *iocb, *next_iocb;
         struct lpfc_sli_ring *pring;
-        struct lpfc_dmabuf   *mp;
 
         psli = &phba->sli;
         pring = &psli->ring[LPFC_ELS_RING];
@@ -1956,6 +1907,7 @@ lpfc_free_tx(struct lpfc_hba * phba, struct lpfc_nodelist * ndlp)
         /* Error matching iocb on txq or txcmplq
          * First check the txq.
          */
+        spin_lock_irq(phba->host->host_lock);
         list_for_each_entry_safe(iocb, next_iocb, &pring->txq, list) {
                 if (iocb->context1 != ndlp) {
                         continue;
@@ -1964,9 +1916,8 @@ lpfc_free_tx(struct lpfc_hba * phba, struct lpfc_nodelist * ndlp)
                 if ((icmd->ulpCommand == CMD_ELS_REQUEST64_CR) ||
                     (icmd->ulpCommand == CMD_XMIT_ELS_RSP64_CX)) {
 
-                        list_del(&iocb->list);
+                        list_move_tail(&iocb->list, &completions);
                         pring->txq_cnt--;
-                        lpfc_els_free_iocb(phba, iocb);
                 }
         }
 
@@ -1978,43 +1929,22 @@ lpfc_free_tx(struct lpfc_hba * phba, struct lpfc_nodelist * ndlp)
                 icmd = &iocb->iocb;
                 if ((icmd->ulpCommand == CMD_ELS_REQUEST64_CR) ||
                     (icmd->ulpCommand == CMD_XMIT_ELS_RSP64_CX)) {
+                        lpfc_sli_issue_abort_iotag(phba, pring, iocb);
+                }
+        }
+        spin_unlock_irq(phba->host->host_lock);
 
-                        iocb->iocb_cmpl = NULL;
-                        /* context2 = cmd, context2->next = rsp, context3 =
-                           bpl */
-                        if (iocb->context2) {
-                                /* Free the response IOCB before handling the
-                                   command. */
-
-                                mp = (struct lpfc_dmabuf *) (iocb->context2);
-                                mp = list_get_first(&mp->list,
-                                                    struct lpfc_dmabuf,
-                                                    list);
-                                if (mp) {
-                                        /* Delay before releasing rsp buffer to
-                                         * give UNREG mbox a chance to take
-                                         * effect.
-                                         */
-                                        list_add(&mp->list,
-                                                &phba->freebufList);
-                                }
-                                lpfc_mbuf_free(phba,
-                                               ((struct lpfc_dmabuf *)
-                                                iocb->context2)->virt,
-                                               ((struct lpfc_dmabuf *)
-                                                iocb->context2)->phys);
-                                kfree(iocb->context2);
-                        }
+        while (!list_empty(&completions)) {
+                iocb = list_get_first(&completions, struct lpfc_iocbq, list);
+                list_del(&iocb->list);
 
-                        if (iocb->context3) {
-                                lpfc_mbuf_free(phba,
-                                               ((struct lpfc_dmabuf *)
-                                                iocb->context3)->virt,
-                                               ((struct lpfc_dmabuf *)
-                                                iocb->context3)->phys);
-                                kfree(iocb->context3);
-                        }
-                }
+                if (iocb->iocb_cmpl) {
+                        icmd = &iocb->iocb;
+                        icmd->ulpStatus = IOSTAT_LOCAL_REJECT;
+                        icmd->un.ulpWord[4] = IOERR_SLI_ABORTED;
+                        (iocb->iocb_cmpl) (phba, iocb, iocb);
+                } else
+                        lpfc_sli_release_iocbq(phba, iocb);
         }
 
         return;
@@ -2025,21 +1955,16 @@ lpfc_disc_flush_list(struct lpfc_hba * phba)
 {
         struct lpfc_nodelist *ndlp, *next_ndlp;
 
-        if (phba->fc_plogi_cnt) {
-                list_for_each_entry_safe(ndlp, next_ndlp, &phba->fc_plogi_list,
-                                        nlp_listp) {
-                        lpfc_free_tx(phba, ndlp);
-                        lpfc_nlp_remove(phba, ndlp);
-                }
-        }
-        if (phba->fc_adisc_cnt) {
-                list_for_each_entry_safe(ndlp, next_ndlp, &phba->fc_adisc_list,
-                                        nlp_listp) {
-                        lpfc_free_tx(phba, ndlp);
-                        lpfc_nlp_remove(phba, ndlp);
+        if (phba->fc_plogi_cnt || phba->fc_adisc_cnt) {
+                list_for_each_entry_safe(ndlp, next_ndlp, &phba->fc_nodes,
+                                         nlp_listp) {
+                        if (ndlp->nlp_state == NLP_STE_PLOGI_ISSUE ||
+                            ndlp->nlp_state == NLP_STE_ADISC_ISSUE) {
+                                lpfc_free_tx(phba, ndlp);
+                                lpfc_nlp_put(ndlp);
+                        }
                 }
         }
-        return;
 }
 
 /*****************************************************************************/
@@ -2108,11 +2033,13 @@ lpfc_disc_timeout_handler(struct lpfc_hba *phba)
                                  phba->brd_no);
 
                 /* Start discovery by sending FLOGI, clean up old rpis */
-                list_for_each_entry_safe(ndlp, next_ndlp, &phba->fc_npr_list,
-                                        nlp_listp) {
+                list_for_each_entry_safe(ndlp, next_ndlp, &phba->fc_nodes,
+                                         nlp_listp) {
+                        if (ndlp->nlp_state != NLP_STE_NPR_NODE)
+                                continue;
                         if (ndlp->nlp_type & NLP_FABRIC) {
                                 /* Clean up the ndlp on Fabric connections */
-                                lpfc_nlp_list(phba, ndlp, NLP_NO_LIST);
+                                lpfc_drop_node(phba, ndlp);
                         } else if (!(ndlp->nlp_flag & NLP_NPR_ADISC)) {
                                 /* Fail outstanding IO now since device
                                  * is marked for PLOGI.
@@ -2153,9 +2080,9 @@ lpfc_disc_timeout_handler(struct lpfc_hba *phba)
                                 "login\n", phba->brd_no);
 
                 /* Next look for NameServer ndlp */
-                ndlp = lpfc_findnode_did(phba, NLP_SEARCH_ALL, NameServer_DID);
+                ndlp = lpfc_findnode_did(phba, NameServer_DID);
                 if (ndlp)
-                        lpfc_nlp_remove(phba, ndlp);
+                        lpfc_nlp_put(ndlp);
                 /* Start discovery */
                 lpfc_disc_start(phba);
                 break;
@@ -2168,9 +2095,8 @@ lpfc_disc_timeout_handler(struct lpfc_hba *phba)
                                 phba->brd_no,
                                 phba->fc_ns_retry, LPFC_MAX_NS_RETRY);
 
-                ndlp = lpfc_findnode_did(phba, NLP_SEARCH_UNMAPPED,
-                                                                NameServer_DID);
-                if (ndlp) {
+                ndlp = lpfc_findnode_did(phba, NameServer_DID);
+                if (ndlp && ndlp->nlp_state == NLP_STE_UNMAPPED_NODE) {
                         if (phba->fc_ns_retry < LPFC_MAX_NS_RETRY) {
                                 /* Try it one more time */
                                 rc = lpfc_ns_cmd(phba, ndlp, SLI_CTNS_GID_FT);
@@ -2220,6 +2146,7 @@ lpfc_disc_timeout_handler(struct lpfc_hba *phba)
                 initlinkmbox->mb.un.varInitLnk.lipsr_AL_PA = 0;
                 rc = lpfc_sli_issue_mbox(phba, initlinkmbox,
                                          (MBX_NOWAIT | MBX_STOP_IOCB));
+                lpfc_set_loopback_flag(phba);
                 if (rc == MBX_NOT_FINISHED)
                         mempool_free(initlinkmbox, phba->mbox_mem_pool);
 
@@ -2317,8 +2244,7 @@ lpfc_mbx_cmpl_fdmi_reg_login(struct lpfc_hba * phba, LPFC_MBOXQ_t * pmb)
 
         ndlp->nlp_rpi = mb->un.varWords[0];
         ndlp->nlp_type |= NLP_FABRIC;
-        ndlp->nlp_state = NLP_STE_UNMAPPED_NODE;
-        lpfc_nlp_list(phba, ndlp, NLP_UNMAPPED_LIST);
+        lpfc_nlp_set_state(phba, ndlp, NLP_STE_UNMAPPED_NODE);
 
         /* Start issuing Fabric-Device Management Interface (FDMI)
          * command to 0xfffffa (FDMI well known port)
@@ -2333,87 +2259,100 @@ lpfc_mbx_cmpl_fdmi_reg_login(struct lpfc_hba * phba, LPFC_MBOXQ_t * pmb)
                 mod_timer(&phba->fc_fdmitmo, jiffies + HZ * 60);
         }
 
+                                /* Mailbox took a reference to the node */
+        lpfc_nlp_put(ndlp);
         lpfc_mbuf_free(phba, mp->virt, mp->phys);
         kfree(mp);
-        mempool_free( pmb, phba->mbox_mem_pool);
+        mempool_free(pmb, phba->mbox_mem_pool);
 
         return;
 }
 
+static int
+lpfc_filter_by_rpi(struct lpfc_nodelist *ndlp, void *param)
+{
+        uint16_t *rpi = param;
+
+        return ndlp->nlp_rpi == *rpi;
+}
+
+static int
+lpfc_filter_by_wwpn(struct lpfc_nodelist *ndlp, void *param)
+{
+        return memcmp(&ndlp->nlp_portname, param,
+                      sizeof(ndlp->nlp_portname)) == 0;
+}
+
+/*
+ * Search node lists for a remote port matching filter criteria
+ * Caller needs to hold host_lock before calling this routine.
+ */
+struct lpfc_nodelist *
+__lpfc_find_node(struct lpfc_hba *phba, node_filter filter, void *param)
+{
+        struct lpfc_nodelist *ndlp;
+
+        list_for_each_entry(ndlp, &phba->fc_nodes, nlp_listp) {
+                if (ndlp->nlp_state != NLP_STE_UNUSED_NODE &&
+                    filter(ndlp, param))
+                        return ndlp;
+        }
+        return NULL;
+}
+
 /*
- * This routine looks up the ndlp  lists
- * for the given RPI. If rpi found
- * it return the node list pointer
- * else return NULL.
+ * Search node lists for a remote port matching filter criteria
+ * This routine is used when the caller does NOT have host_lock.
  */
 struct lpfc_nodelist *
+lpfc_find_node(struct lpfc_hba *phba, node_filter filter, void *param)
+{
+        struct lpfc_nodelist *ndlp;
+
+        spin_lock_irq(phba->host->host_lock);
+        ndlp = __lpfc_find_node(phba, filter, param);
+        spin_unlock_irq(phba->host->host_lock);
+        return ndlp;
+}
+
+/*
+ * This routine looks up the ndlp lists for the given RPI. If rpi found it
+ * returns the node list pointer else return NULL.
+ */
+struct lpfc_nodelist *
+__lpfc_findnode_rpi(struct lpfc_hba *phba, uint16_t rpi)
+{
+        return __lpfc_find_node(phba, lpfc_filter_by_rpi, &rpi);
+}
+
+struct lpfc_nodelist *
 lpfc_findnode_rpi(struct lpfc_hba * phba, uint16_t rpi)
 {
         struct lpfc_nodelist *ndlp;
-        struct list_head * lists[]={&phba->fc_nlpunmap_list,
-                                    &phba->fc_nlpmap_list,
-                                    &phba->fc_plogi_list,
-                                    &phba->fc_adisc_list,
-                                    &phba->fc_reglogin_list};
-        int i;
 
         spin_lock_irq(phba->host->host_lock);
-        for (i = 0; i < ARRAY_SIZE(lists); i++ )
-                list_for_each_entry(ndlp, lists[i], nlp_listp)
-                        if (ndlp->nlp_rpi == rpi) {
-                                spin_unlock_irq(phba->host->host_lock);
-                                return ndlp;
-                        }
+        ndlp = __lpfc_findnode_rpi(phba, rpi);
         spin_unlock_irq(phba->host->host_lock);
-        return NULL;
+        return ndlp;
 }
 
 /*
- * This routine looks up the ndlp  lists
- * for the given WWPN. If WWPN found
- * it return the node list pointer
- * else return NULL.
+ * This routine looks up the ndlp lists for the given WWPN. If WWPN found it
+ * returns the node list pointer else return NULL.
  */
 struct lpfc_nodelist *
-lpfc_findnode_wwpn(struct lpfc_hba * phba, uint32_t order,
-                   struct lpfc_name * wwpn)
+lpfc_findnode_wwpn(struct lpfc_hba *phba, struct lpfc_name *wwpn)
 {
         struct lpfc_nodelist *ndlp;
-        struct list_head * lists[]={&phba->fc_nlpunmap_list,
-                                    &phba->fc_nlpmap_list,
-                                    &phba->fc_npr_list,
-                                    &phba->fc_plogi_list,
-                                    &phba->fc_adisc_list,
-                                    &phba->fc_reglogin_list,
-                                    &phba->fc_prli_list};
-        uint32_t search[]={NLP_SEARCH_UNMAPPED,
-                           NLP_SEARCH_MAPPED,
-                           NLP_SEARCH_NPR,
-                           NLP_SEARCH_PLOGI,
-                           NLP_SEARCH_ADISC,
-                           NLP_SEARCH_REGLOGIN,
-                           NLP_SEARCH_PRLI};
-        int i;
 
         spin_lock_irq(phba->host->host_lock);
-        for (i = 0; i < ARRAY_SIZE(lists); i++ ) {
-                if (!(order & search[i]))
-                        continue;
-                list_for_each_entry(ndlp, lists[i], nlp_listp) {
-                        if (memcmp(&ndlp->nlp_portname, wwpn,
-                                   sizeof(struct lpfc_name)) == 0) {
-                                spin_unlock_irq(phba->host->host_lock);
-                                return ndlp;
-                        }
-                }
-        }
+        ndlp = __lpfc_find_node(phba, lpfc_filter_by_wwpn, wwpn);
         spin_unlock_irq(phba->host->host_lock);
         return NULL;
 }
 
 void
-lpfc_nlp_init(struct lpfc_hba * phba, struct lpfc_nodelist * ndlp,
-                 uint32_t did)
+lpfc_nlp_init(struct lpfc_hba *phba, struct lpfc_nodelist *ndlp, uint32_t did)
 {
         memset(ndlp, 0, sizeof (struct lpfc_nodelist));
         INIT_LIST_HEAD(&ndlp->els_retry_evt.evt_listp);
@@ -2423,5 +2362,30 @@ lpfc_nlp_init(struct lpfc_hba * phba, struct lpfc_nodelist * ndlp,
         ndlp->nlp_DID = did;
         ndlp->nlp_phba = phba;
         ndlp->nlp_sid = NLP_NO_SID;
+        INIT_LIST_HEAD(&ndlp->nlp_listp);
+        kref_init(&ndlp->kref);
         return;
 }
+
+void
+lpfc_nlp_release(struct kref *kref)
+{
+        struct lpfc_nodelist *ndlp = container_of(kref, struct lpfc_nodelist,
+                                                  kref);
+        lpfc_nlp_remove(ndlp->nlp_phba, ndlp);
+        mempool_free(ndlp, ndlp->nlp_phba->nlp_mem_pool);
+}
+
+struct lpfc_nodelist *
+lpfc_nlp_get(struct lpfc_nodelist *ndlp)
+{
+        if (ndlp)
+                kref_get(&ndlp->kref);
+        return ndlp;
+}
+
+int
+lpfc_nlp_put(struct lpfc_nodelist *ndlp)
+{
+        return ndlp ? kref_put(&ndlp->kref, lpfc_nlp_release) : 0;
+}
diff --git a/drivers/scsi/lpfc/lpfc_hw.h b/drivers/scsi/lpfc/lpfc_hw.h
index f79cb6136906..2623a9bc7775 100644
--- a/drivers/scsi/lpfc/lpfc_hw.h
+++ b/drivers/scsi/lpfc/lpfc_hw.h
@@ -1,7 +1,7 @@
 /*******************************************************************
  * This file is part of the Emulex Linux Device Driver for         *
  * Fibre Channel Host Bus Adapters.                                *
- * Copyright (C) 2004-2006 Emulex.  All rights reserved.           *
+ * Copyright (C) 2004-2007 Emulex.  All rights reserved.           *
  * EMULEX and SLI are trademarks of Emulex.                        *
  * www.emulex.com                                                  *
  *                                                                 *
@@ -1078,6 +1078,8 @@ typedef struct {
 /* Start FireFly Register definitions */
 #define PCI_VENDOR_ID_EMULEX        0x10df
 #define PCI_DEVICE_ID_FIREFLY       0x1ae5
+#define PCI_DEVICE_ID_SAT_SMB       0xf011
+#define PCI_DEVICE_ID_SAT_MID       0xf015
 #define PCI_DEVICE_ID_RFLY          0xf095
 #define PCI_DEVICE_ID_PFLY          0xf098
 #define PCI_DEVICE_ID_LP101         0xf0a1
@@ -1089,6 +1091,9 @@ typedef struct {
 #define PCI_DEVICE_ID_NEPTUNE       0xf0f5
 #define PCI_DEVICE_ID_NEPTUNE_SCSP  0xf0f6
 #define PCI_DEVICE_ID_NEPTUNE_DCSP  0xf0f7
+#define PCI_DEVICE_ID_SAT           0xf100
+#define PCI_DEVICE_ID_SAT_SCSP      0xf111
+#define PCI_DEVICE_ID_SAT_DCSP      0xf112
 #define PCI_DEVICE_ID_SUPERFLY      0xf700
 #define PCI_DEVICE_ID_DRAGONFLY     0xf800
 #define PCI_DEVICE_ID_CENTAUR       0xf900
@@ -1098,6 +1103,7 @@ typedef struct {
 #define PCI_DEVICE_ID_LP10000S      0xfc00
 #define PCI_DEVICE_ID_LP11000S      0xfc10
 #define PCI_DEVICE_ID_LPE11000S     0xfc20
+#define PCI_DEVICE_ID_SAT_S         0xfc40
 #define PCI_DEVICE_ID_HELIOS        0xfd00
 #define PCI_DEVICE_ID_HELIOS_SCSP   0xfd11
 #define PCI_DEVICE_ID_HELIOS_DCSP   0xfd12
@@ -1118,6 +1124,7 @@ typedef struct {
 #define HELIOS_JEDEC_ID             0x0364
 #define ZEPHYR_JEDEC_ID             0x0577
 #define VIPER_JEDEC_ID              0x4838
+#define SATURN_JEDEC_ID             0x1004
 
 #define JEDEC_ID_MASK               0x0FFFF000
 #define JEDEC_ID_SHIFT              12
@@ -1565,7 +1572,7 @@ typedef struct {
 #define LINK_SPEED_1G   1       /* 1 Gigabaud */
 #define LINK_SPEED_2G   2       /* 2 Gigabaud */
 #define LINK_SPEED_4G   4       /* 4 Gigabaud */
-#define LINK_SPEED_8G   8       /* 4 Gigabaud */
+#define LINK_SPEED_8G   8       /* 8 Gigabaud */
 #define LINK_SPEED_10G   16      /* 10 Gigabaud */
 
 } INIT_LINK_VAR;
diff --git a/drivers/scsi/lpfc/lpfc_init.c b/drivers/scsi/lpfc/lpfc_init.c
index dcf6106f557a..dcb4ba0ecee1 100644
--- a/drivers/scsi/lpfc/lpfc_init.c
+++ b/drivers/scsi/lpfc/lpfc_init.c
@@ -1,7 +1,7 @@
 /*******************************************************************
  * This file is part of the Emulex Linux Device Driver for         *
  * Fibre Channel Host Bus Adapters.                                *
- * Copyright (C) 2004-2006 Emulex.  All rights reserved.           *
+ * Copyright (C) 2004-2007 Emulex.  All rights reserved.           *
  * EMULEX and SLI are trademarks of Emulex.                        *
  * www.emulex.com                                                  *
  * Portions Copyright (C) 2004-2005 Christoph Hellwig              *
@@ -386,12 +386,12 @@ lpfc_config_port_post(struct lpfc_hba * phba)
          * Setup the ring 0 (els)  timeout handler
          */
         timeout = phba->fc_ratov << 1;
-        phba->els_tmofunc.expires = jiffies + HZ * timeout;
-        add_timer(&phba->els_tmofunc);
+        mod_timer(&phba->els_tmofunc, jiffies + HZ * timeout);
 
         lpfc_init_link(phba, pmb, phba->cfg_topology, phba->cfg_link_speed);
         pmb->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
         rc = lpfc_sli_issue_mbox(phba, pmb, MBX_NOWAIT);
+        lpfc_set_loopback_flag(phba);
         if (rc != MBX_SUCCESS) {
                 lpfc_printf_log(phba,
                                 KERN_ERR,
@@ -418,33 +418,6 @@ lpfc_config_port_post(struct lpfc_hba * phba)
         return (0);
 }
 
-static int
-lpfc_discovery_wait(struct lpfc_hba *phba)
-{
-        int i = 0;
-
-        while ((phba->hba_state != LPFC_HBA_READY) ||
-               (phba->num_disc_nodes) || (phba->fc_prli_sent) ||
-               ((phba->fc_map_cnt == 0) && (i<2)) ||
-               (phba->sli.sli_flag & LPFC_SLI_MBOX_ACTIVE)) {
-                /* Check every second for 30 retries. */
-                i++;
-                if (i > 30) {
-                        return -ETIMEDOUT;
-                }
-                if ((i >= 15) && (phba->hba_state <= LPFC_LINK_DOWN)) {
-                        /* The link is down.  Set linkdown timeout */
-                        return -ETIMEDOUT;
-                }
-
-                /* Delay for 1 second to give discovery time to complete. */
-                msleep(1000);
-
-        }
-
-        return 0;
-}
-
 /************************************************************************/
 /*                                                                      */
 /*    lpfc_hba_down_prep                                                */
@@ -550,12 +523,15 @@ lpfc_handle_eratt(struct lpfc_hba * phba)
                  * There was a firmware error.  Take the hba offline and then
                  * attempt to restart it.
                  */
+                lpfc_offline_prep(phba);
                 lpfc_offline(phba);
                 lpfc_sli_brdrestart(phba);
                 if (lpfc_online(phba) == 0) {   /* Initialize the HBA */
                         mod_timer(&phba->fc_estabtmo, jiffies + HZ * 60);
+                        lpfc_unblock_mgmt_io(phba);
                         return;
                 }
+                lpfc_unblock_mgmt_io(phba);
         } else {
                 /* The if clause above forces this code path when the status
                  * failure is a value other than FFER6.  Do not call the offline
@@ -573,7 +549,9 @@ lpfc_handle_eratt(struct lpfc_hba * phba)
                                 SCSI_NL_VID_TYPE_PCI | PCI_VENDOR_ID_EMULEX);
 
                 psli->sli_flag &= ~LPFC_SLI2_ACTIVE;
+                lpfc_offline_prep(phba);
                 lpfc_offline(phba);
+                lpfc_unblock_mgmt_io(phba);
                 phba->hba_state = LPFC_HBA_ERROR;
                 lpfc_hba_down_post(phba);
         }
@@ -633,7 +611,7 @@ lpfc_handle_latt_free_mbuf:
 lpfc_handle_latt_free_mp:
         kfree(mp);
 lpfc_handle_latt_free_pmb:
-        kfree(pmb);
+        mempool_free(pmb, phba->mbox_mem_pool);
 lpfc_handle_latt_err_exit:
         /* Enable Link attention interrupts */
         spin_lock_irq(phba->host->host_lock);
@@ -925,6 +903,24 @@ lpfc_get_hba_model_desc(struct lpfc_hba * phba, uint8_t * mdp, uint8_t * descp)
                 m = (typeof(m)){"LPe11000-S", max_speed,
                         "PCIe"};
                 break;
+        case PCI_DEVICE_ID_SAT:
+                m = (typeof(m)){"LPe12000", max_speed, "PCIe"};
+                break;
+        case PCI_DEVICE_ID_SAT_MID:
+                m = (typeof(m)){"LPe1250", max_speed, "PCIe"};
+                break;
+        case PCI_DEVICE_ID_SAT_SMB:
+                m = (typeof(m)){"LPe121", max_speed, "PCIe"};
+                break;
+        case PCI_DEVICE_ID_SAT_DCSP:
+                m = (typeof(m)){"LPe12002-SP", max_speed, "PCIe"};
+                break;
+        case PCI_DEVICE_ID_SAT_SCSP:
+                m = (typeof(m)){"LPe12000-SP", max_speed, "PCIe"};
+                break;
+        case PCI_DEVICE_ID_SAT_S:
+                m = (typeof(m)){"LPe12000-S", max_speed, "PCIe"};
+                break;
         default:
                 m = (typeof(m)){ NULL };
                 break;
@@ -1174,69 +1170,17 @@ lpfc_hba_init(struct lpfc_hba *phba, uint32_t *hbainit)
 }
 
 static void
-lpfc_cleanup(struct lpfc_hba * phba, uint32_t save_bind)
+lpfc_cleanup(struct lpfc_hba * phba)
 {
         struct lpfc_nodelist *ndlp, *next_ndlp;
 
         /* clean up phba - lpfc specific */
         lpfc_can_disctmo(phba);
-        list_for_each_entry_safe(ndlp, next_ndlp, &phba->fc_nlpunmap_list,
-                                nlp_listp) {
-                lpfc_nlp_remove(phba, ndlp);
-        }
+        list_for_each_entry_safe(ndlp, next_ndlp, &phba->fc_nodes, nlp_listp)
+                lpfc_nlp_put(ndlp);
 
-        list_for_each_entry_safe(ndlp, next_ndlp, &phba->fc_nlpmap_list,
-                                 nlp_listp) {
-                lpfc_nlp_remove(phba, ndlp);
-        }
-
-        list_for_each_entry_safe(ndlp, next_ndlp, &phba->fc_unused_list,
-                                nlp_listp) {
-                lpfc_nlp_list(phba, ndlp, NLP_NO_LIST);
-        }
-
-        list_for_each_entry_safe(ndlp, next_ndlp, &phba->fc_plogi_list,
-                                nlp_listp) {
-                lpfc_nlp_remove(phba, ndlp);
-        }
-
-        list_for_each_entry_safe(ndlp, next_ndlp, &phba->fc_adisc_list,
-                                nlp_listp) {
-                lpfc_nlp_remove(phba, ndlp);
-        }
-
-        list_for_each_entry_safe(ndlp, next_ndlp, &phba->fc_reglogin_list,
-                                nlp_listp) {
-                lpfc_nlp_remove(phba, ndlp);
-        }
+        INIT_LIST_HEAD(&phba->fc_nodes);
 
-        list_for_each_entry_safe(ndlp, next_ndlp, &phba->fc_prli_list,
-                                nlp_listp) {
-                lpfc_nlp_remove(phba, ndlp);
-        }
-
-        list_for_each_entry_safe(ndlp, next_ndlp, &phba->fc_npr_list,
-                                nlp_listp) {
-                lpfc_nlp_remove(phba, ndlp);
-        }
-
-        INIT_LIST_HEAD(&phba->fc_nlpmap_list);
-        INIT_LIST_HEAD(&phba->fc_nlpunmap_list);
-        INIT_LIST_HEAD(&phba->fc_unused_list);
-        INIT_LIST_HEAD(&phba->fc_plogi_list);
-        INIT_LIST_HEAD(&phba->fc_adisc_list);
-        INIT_LIST_HEAD(&phba->fc_reglogin_list);
-        INIT_LIST_HEAD(&phba->fc_prli_list);
-        INIT_LIST_HEAD(&phba->fc_npr_list);
-
-        phba->fc_map_cnt   = 0;
-        phba->fc_unmap_cnt = 0;
-        phba->fc_plogi_cnt = 0;
-        phba->fc_adisc_cnt = 0;
-        phba->fc_reglogin_cnt = 0;
-        phba->fc_prli_cnt  = 0;
-        phba->fc_npr_cnt   = 0;
-        phba->fc_unused_cnt= 0;
         return;
 }
 
@@ -1262,21 +1206,6 @@ lpfc_stop_timer(struct lpfc_hba * phba)
 {
         struct lpfc_sli *psli = &phba->sli;
 
-        /* Instead of a timer, this has been converted to a
-         * deferred procedding list.
-         */
-        while (!list_empty(&phba->freebufList)) {
-
-                struct lpfc_dmabuf *mp = NULL;
-
-                list_remove_head((&phba->freebufList), mp,
-                                 struct lpfc_dmabuf, list);
-                if (mp) {
-                        lpfc_mbuf_free(phba, mp->virt, mp->phys);
-                        kfree(mp);
-                }
-        }
-
         del_timer_sync(&phba->fcp_poll_timer);
         del_timer_sync(&phba->fc_estabtmo);
         del_timer_sync(&phba->fc_disctmo);
@@ -1302,60 +1231,76 @@ lpfc_online(struct lpfc_hba * phba)
                        "%d:0458 Bring Adapter online\n",
                        phba->brd_no);
 
-        if (!lpfc_sli_queue_setup(phba))
+        lpfc_block_mgmt_io(phba);
+
+        if (!lpfc_sli_queue_setup(phba)) {
+                lpfc_unblock_mgmt_io(phba);
                 return 1;
+        }
 
-        if (lpfc_sli_hba_setup(phba))   /* Initialize the HBA */
+        if (lpfc_sli_hba_setup(phba)) { /* Initialize the HBA */
+                lpfc_unblock_mgmt_io(phba);
                 return 1;
+        }
 
         spin_lock_irq(phba->host->host_lock);
         phba->fc_flag &= ~FC_OFFLINE_MODE;
         spin_unlock_irq(phba->host->host_lock);
 
+        lpfc_unblock_mgmt_io(phba);
         return 0;
 }
 
-int
-lpfc_offline(struct lpfc_hba * phba)
+void
+lpfc_block_mgmt_io(struct lpfc_hba * phba)
 {
-        struct lpfc_sli_ring *pring;
-        struct lpfc_sli *psli;
         unsigned long iflag;
-        int i;
-        int cnt = 0;
 
-        if (!phba)
-                return 0;
+        spin_lock_irqsave(phba->host->host_lock, iflag);
+        phba->fc_flag |= FC_BLOCK_MGMT_IO;
+        spin_unlock_irqrestore(phba->host->host_lock, iflag);
+}
+
+void
+lpfc_unblock_mgmt_io(struct lpfc_hba * phba)
+{
+        unsigned long iflag;
+
+        spin_lock_irqsave(phba->host->host_lock, iflag);
+        phba->fc_flag &= ~FC_BLOCK_MGMT_IO;
+        spin_unlock_irqrestore(phba->host->host_lock, iflag);
+}
+
+void
+lpfc_offline_prep(struct lpfc_hba * phba)
+{
+        struct lpfc_nodelist  *ndlp, *next_ndlp;
 
         if (phba->fc_flag & FC_OFFLINE_MODE)
-                return 0;
+                return;
 
-        psli = &phba->sli;
+        lpfc_block_mgmt_io(phba);
 
         lpfc_linkdown(phba);
+
+        /* Issue an unreg_login to all nodes */
+        list_for_each_entry_safe(ndlp, next_ndlp, &phba->fc_nodes, nlp_listp)
+                if (ndlp->nlp_state != NLP_STE_UNUSED_NODE)
+                        lpfc_unreg_rpi(phba, ndlp);
+
         lpfc_sli_flush_mbox_queue(phba);
+}
 
-        for (i = 0; i < psli->num_rings; i++) {
-                pring = &psli->ring[i];
-                /* The linkdown event takes 30 seconds to timeout. */
-                while (pring->txcmplq_cnt) {
-                        mdelay(10);
-                        if (cnt++ > 3000) {
-                                lpfc_printf_log(phba,
-                                        KERN_WARNING, LOG_INIT,
-                                        "%d:0466 Outstanding IO when "
-                                        "bringing Adapter offline\n",
-                                        phba->brd_no);
-                                break;
-                        }
-                }
-        }
+void
+lpfc_offline(struct lpfc_hba * phba)
+{
+        unsigned long iflag;
 
+        if (phba->fc_flag & FC_OFFLINE_MODE)
+                return;
 
         /* stop all timers associated with this hba */
         lpfc_stop_timer(phba);
-        phba->work_hba_events = 0;
-        phba->work_ha = 0;
 
         lpfc_printf_log(phba,
                        KERN_WARNING,
@@ -1366,11 +1311,12 @@ lpfc_offline(struct lpfc_hba * phba)
         /* Bring down the SLI Layer and cleanup.  The HBA is offline
            now.  */
         lpfc_sli_hba_down(phba);
-        lpfc_cleanup(phba, 1);
+        lpfc_cleanup(phba);
         spin_lock_irqsave(phba->host->host_lock, iflag);
+        phba->work_hba_events = 0;
+        phba->work_ha = 0;
         phba->fc_flag |= FC_OFFLINE_MODE;
         spin_unlock_irqrestore(phba->host->host_lock, iflag);
-        return 0;
 }
 
 /******************************************************************************
@@ -1407,6 +1353,156 @@ lpfc_scsi_free(struct lpfc_hba * phba)
         return 0;
 }
 
+void lpfc_remove_device(struct lpfc_hba *phba)
+{
+        unsigned long iflag;
+
+        lpfc_free_sysfs_attr(phba);
+
+        spin_lock_irqsave(phba->host->host_lock, iflag);
+        phba->fc_flag |= FC_UNLOADING;
+
+        spin_unlock_irqrestore(phba->host->host_lock, iflag);
+
+        fc_remove_host(phba->host);
+        scsi_remove_host(phba->host);
+
+        kthread_stop(phba->worker_thread);
+
+        /*
+         * Bring down the SLI Layer. This step disable all interrupts,
+         * clears the rings, discards all mailbox commands, and resets
+         * the HBA.
+         */
+        lpfc_sli_hba_down(phba);
+        lpfc_sli_brdrestart(phba);
+
+        /* Release the irq reservation */
+        free_irq(phba->pcidev->irq, phba);
+        pci_disable_msi(phba->pcidev);
+
+        lpfc_cleanup(phba);
+        lpfc_stop_timer(phba);
+        phba->work_hba_events = 0;
+
+        /*
+         * Call scsi_free before mem_free since scsi bufs are released to their
+         * corresponding pools here.
+         */
+        lpfc_scsi_free(phba);
+        lpfc_mem_free(phba);
+
+        /* Free resources associated with SLI2 interface */
+        dma_free_coherent(&phba->pcidev->dev, SLI2_SLIM_SIZE,
+                          phba->slim2p, phba->slim2p_mapping);
+
+        /* unmap adapter SLIM and Control Registers */
+        iounmap(phba->ctrl_regs_memmap_p);
+        iounmap(phba->slim_memmap_p);
+
+        pci_release_regions(phba->pcidev);
+        pci_disable_device(phba->pcidev);
+
+        idr_remove(&lpfc_hba_index, phba->brd_no);
+        scsi_host_put(phba->host);
+}
+
+void lpfc_scan_start(struct Scsi_Host *host)
+{
+        struct lpfc_hba *phba = (struct lpfc_hba*)host->hostdata;
+
+        if (lpfc_alloc_sysfs_attr(phba))
+                goto error;
+
+        phba->MBslimaddr = phba->slim_memmap_p;
+        phba->HAregaddr = phba->ctrl_regs_memmap_p + HA_REG_OFFSET;
+        phba->CAregaddr = phba->ctrl_regs_memmap_p + CA_REG_OFFSET;
+        phba->HSregaddr = phba->ctrl_regs_memmap_p + HS_REG_OFFSET;
+        phba->HCregaddr = phba->ctrl_regs_memmap_p + HC_REG_OFFSET;
+
+        if (lpfc_sli_hba_setup(phba))
+                goto error;
+
+        /*
+         * hba setup may have changed the hba_queue_depth so we need to adjust
+         * the value of can_queue.
+         */
+        host->can_queue = phba->cfg_hba_queue_depth - 10;
+        return;
+
+error:
+        lpfc_remove_device(phba);
+}
+
+int lpfc_scan_finished(struct Scsi_Host *shost, unsigned long time)
+{
+        struct lpfc_hba *phba = (struct lpfc_hba *)shost->hostdata;
+
+        if (!phba->host)
+                return 1;
+        if (time >= 30 * HZ)
+                goto finished;
+
+        if (phba->hba_state != LPFC_HBA_READY)
+                return 0;
+        if (phba->num_disc_nodes || phba->fc_prli_sent)
+                return 0;
+        if ((phba->fc_map_cnt == 0) && (time < 2 * HZ))
+                return 0;
+        if (phba->sli.sli_flag & LPFC_SLI_MBOX_ACTIVE)
+                return 0;
+        if ((phba->hba_state > LPFC_LINK_DOWN) || (time < 15 * HZ))
+                return 0;
+
+finished:
+        if (phba->cfg_poll & DISABLE_FCP_RING_INT) {
+                spin_lock_irq(shost->host_lock);
+                lpfc_poll_start_timer(phba);
+                spin_unlock_irq(shost->host_lock);
+        }
+
+        /*
+         * set fixed host attributes
+         * Must done after lpfc_sli_hba_setup()
+         */
+
+        fc_host_node_name(shost) = wwn_to_u64(phba->fc_nodename.u.wwn);
+        fc_host_port_name(shost) = wwn_to_u64(phba->fc_portname.u.wwn);
+        fc_host_supported_classes(shost) = FC_COS_CLASS3;
+
+        memset(fc_host_supported_fc4s(shost), 0,
+                sizeof(fc_host_supported_fc4s(shost)));
+        fc_host_supported_fc4s(shost)[2] = 1;
+        fc_host_supported_fc4s(shost)[7] = 1;
+
+        lpfc_get_hba_sym_node_name(phba, fc_host_symbolic_name(shost));
+
+        fc_host_supported_speeds(shost) = 0;
+        if (phba->lmt & LMT_10Gb)
+                fc_host_supported_speeds(shost) |= FC_PORTSPEED_10GBIT;
+        if (phba->lmt & LMT_4Gb)
+                fc_host_supported_speeds(shost) |= FC_PORTSPEED_4GBIT;
+        if (phba->lmt & LMT_2Gb)
+                fc_host_supported_speeds(shost) |= FC_PORTSPEED_2GBIT;
+        if (phba->lmt & LMT_1Gb)
+                fc_host_supported_speeds(shost) |= FC_PORTSPEED_1GBIT;
+
+        fc_host_maxframe_size(shost) =
+                ((((uint32_t) phba->fc_sparam.cmn.bbRcvSizeMsb & 0x0F) << 8) |
+                 (uint32_t) phba->fc_sparam.cmn.bbRcvSizeLsb);
+
+        /* This value is also unchanging */
+        memset(fc_host_active_fc4s(shost), 0,
+                sizeof(fc_host_active_fc4s(shost)));
+        fc_host_active_fc4s(shost)[2] = 1;
+        fc_host_active_fc4s(shost)[7] = 1;
+
+        spin_lock_irq(shost->host_lock);
+        phba->fc_flag &= ~FC_LOADING;
+        spin_unlock_irq(shost->host_lock);
+
+        return 1;
+}
 
 static int __devinit
 lpfc_pci_probe_one(struct pci_dev *pdev, const struct pci_device_id *pid)
@@ -1445,9 +1541,6 @@ lpfc_pci_probe_one(struct pci_dev *pdev, const struct pci_device_id *pid)
                 goto out_put_host;
 
         host->unique_id = phba->brd_no;
-        INIT_LIST_HEAD(&phba->ctrspbuflist);
-        INIT_LIST_HEAD(&phba->rnidrspbuflist);
-        INIT_LIST_HEAD(&phba->freebufList);
 
         /* Initialize timers used by driver */
         init_timer(&phba->fc_estabtmo);
@@ -1482,16 +1575,7 @@ lpfc_pci_probe_one(struct pci_dev *pdev, const struct pci_device_id *pid)
         host->max_lun = phba->cfg_max_luns;
         host->this_id = -1;
 
-        /* Initialize all internally managed lists. */
-        INIT_LIST_HEAD(&phba->fc_nlpmap_list);
-        INIT_LIST_HEAD(&phba->fc_nlpunmap_list);
-        INIT_LIST_HEAD(&phba->fc_unused_list);
-        INIT_LIST_HEAD(&phba->fc_plogi_list);
-        INIT_LIST_HEAD(&phba->fc_adisc_list);
-        INIT_LIST_HEAD(&phba->fc_reglogin_list);
-        INIT_LIST_HEAD(&phba->fc_prli_list);
-        INIT_LIST_HEAD(&phba->fc_npr_list);
-
+        INIT_LIST_HEAD(&phba->fc_nodes);
 
         pci_set_master(pdev);
         retval = pci_set_mwi(pdev);
@@ -1609,13 +1693,6 @@ lpfc_pci_probe_one(struct pci_dev *pdev, const struct pci_device_id *pid)
 
         host->transportt = lpfc_transport_template;
         pci_set_drvdata(pdev, host);
-        error = scsi_add_host(host, &pdev->dev);
-        if (error)
-                goto out_kthread_stop;
-
-        error = lpfc_alloc_sysfs_attr(phba);
-        if (error)
-                goto out_remove_host;
 
         if (phba->cfg_use_msi) {
                 error = pci_enable_msi(phba->pcidev);
@@ -1631,73 +1708,15 @@ lpfc_pci_probe_one(struct pci_dev *pdev, const struct pci_device_id *pid)
                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
                         "%d:0451 Enable interrupt handler failed\n",
                         phba->brd_no);
-                goto out_free_sysfs_attr;
+                goto out_kthread_stop;
         }
-        phba->MBslimaddr = phba->slim_memmap_p;
-        phba->HAregaddr = phba->ctrl_regs_memmap_p + HA_REG_OFFSET;
-        phba->CAregaddr = phba->ctrl_regs_memmap_p + CA_REG_OFFSET;
-        phba->HSregaddr = phba->ctrl_regs_memmap_p + HS_REG_OFFSET;
-        phba->HCregaddr = phba->ctrl_regs_memmap_p + HC_REG_OFFSET;
 
-        error = lpfc_sli_hba_setup(phba);
-        if (error) {
-                error = -ENODEV;
+        error = scsi_add_host(host, &pdev->dev);
+        if (error)
                 goto out_free_irq;
-        }
-
-        /*
-         * hba setup may have changed the hba_queue_depth so we need to adjust
-         * the value of can_queue.
-         */
-        host->can_queue = phba->cfg_hba_queue_depth - 10;
-
-        lpfc_discovery_wait(phba);
 
-        if (phba->cfg_poll & DISABLE_FCP_RING_INT) {
-                spin_lock_irq(phba->host->host_lock);
-                lpfc_poll_start_timer(phba);
-                spin_unlock_irq(phba->host->host_lock);
-        }
+        scsi_scan_host(host);
 
-        /*
-         * set fixed host attributes
-         * Must done after lpfc_sli_hba_setup()
-         */
-
-        fc_host_node_name(host) = wwn_to_u64(phba->fc_nodename.u.wwn);
-        fc_host_port_name(host) = wwn_to_u64(phba->fc_portname.u.wwn);
-        fc_host_supported_classes(host) = FC_COS_CLASS3;
-
-        memset(fc_host_supported_fc4s(host), 0,
-                sizeof(fc_host_supported_fc4s(host)));
-        fc_host_supported_fc4s(host)[2] = 1;
-        fc_host_supported_fc4s(host)[7] = 1;
-
-        lpfc_get_hba_sym_node_name(phba, fc_host_symbolic_name(host));
-
-        fc_host_supported_speeds(host) = 0;
-        if (phba->lmt & LMT_10Gb)
-                fc_host_supported_speeds(host) |= FC_PORTSPEED_10GBIT;
-        if (phba->lmt & LMT_4Gb)
-                fc_host_supported_speeds(host) |= FC_PORTSPEED_4GBIT;
-        if (phba->lmt & LMT_2Gb)
-                fc_host_supported_speeds(host) |= FC_PORTSPEED_2GBIT;
-        if (phba->lmt & LMT_1Gb)
-                fc_host_supported_speeds(host) |= FC_PORTSPEED_1GBIT;
-
-        fc_host_maxframe_size(host) =
-                ((((uint32_t) phba->fc_sparam.cmn.bbRcvSizeMsb & 0x0F) << 8) |
-                 (uint32_t) phba->fc_sparam.cmn.bbRcvSizeLsb);
-
-        /* This value is also unchanging */
-        memset(fc_host_active_fc4s(host), 0,
-                sizeof(fc_host_active_fc4s(host)));
-        fc_host_active_fc4s(host)[2] = 1;
-        fc_host_active_fc4s(host)[7] = 1;
-
-        spin_lock_irq(phba->host->host_lock);
-        phba->fc_flag &= ~FC_LOADING;
-        spin_unlock_irq(phba->host->host_lock);
         return 0;
 
 out_free_irq:
@@ -1705,11 +1724,6 @@ out_free_irq:
         phba->work_hba_events = 0;
         free_irq(phba->pcidev->irq, phba);
         pci_disable_msi(phba->pcidev);
-out_free_sysfs_attr:
-        lpfc_free_sysfs_attr(phba);
-out_remove_host:
-        fc_remove_host(phba->host);
-        scsi_remove_host(phba->host);
 out_kthread_stop:
         kthread_stop(phba->worker_thread);
 out_free_iocbq:
@@ -1747,56 +1761,8 @@ lpfc_pci_remove_one(struct pci_dev *pdev)
 {
         struct Scsi_Host   *host = pci_get_drvdata(pdev);
         struct lpfc_hba    *phba = (struct lpfc_hba *)host->hostdata;
-        unsigned long iflag;
-
-        lpfc_free_sysfs_attr(phba);
-
-        spin_lock_irqsave(phba->host->host_lock, iflag);
-        phba->fc_flag |= FC_UNLOADING;
-
-        spin_unlock_irqrestore(phba->host->host_lock, iflag);
 
-        fc_remove_host(phba->host);
-        scsi_remove_host(phba->host);
-
-        kthread_stop(phba->worker_thread);
-
-        /*
-         * Bring down the SLI Layer. This step disable all interrupts,
-         * clears the rings, discards all mailbox commands, and resets
-         * the HBA.
-         */
-        lpfc_sli_hba_down(phba);
-        lpfc_sli_brdrestart(phba);
-
-        /* Release the irq reservation */
-        free_irq(phba->pcidev->irq, phba);
-        pci_disable_msi(phba->pcidev);
-
-        lpfc_cleanup(phba, 0);
-        lpfc_stop_timer(phba);
-        phba->work_hba_events = 0;
-
-        /*
-         * Call scsi_free before mem_free since scsi bufs are released to their
-         * corresponding pools here.
-         */
-        lpfc_scsi_free(phba);
-        lpfc_mem_free(phba);
-
-        /* Free resources associated with SLI2 interface */
-        dma_free_coherent(&pdev->dev, SLI2_SLIM_SIZE,
-                          phba->slim2p, phba->slim2p_mapping);
-
-        /* unmap adapter SLIM and Control Registers */
-        iounmap(phba->ctrl_regs_memmap_p);
-        iounmap(phba->slim_memmap_p);
-
-        pci_release_regions(phba->pcidev);
-        pci_disable_device(phba->pcidev);
-
-        idr_remove(&lpfc_hba_index, phba->brd_no);
-        scsi_host_put(phba->host);
+        lpfc_remove_device(phba);
 
         pci_set_drvdata(pdev, NULL);
 }
@@ -1941,6 +1907,18 @@ static struct pci_device_id lpfc_id_table[] = {
                 PCI_ANY_ID, PCI_ANY_ID, },
         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_LPE11000S,
                 PCI_ANY_ID, PCI_ANY_ID, },
+        {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_SAT,
+                PCI_ANY_ID, PCI_ANY_ID, },
+        {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_SAT_MID,
+                PCI_ANY_ID, PCI_ANY_ID, },
+        {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_SAT_SMB,
+                PCI_ANY_ID, PCI_ANY_ID, },
+        {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_SAT_DCSP,
+                PCI_ANY_ID, PCI_ANY_ID, },
+        {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_SAT_SCSP,
+                PCI_ANY_ID, PCI_ANY_ID, },
+        {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_SAT_S,
+                PCI_ANY_ID, PCI_ANY_ID, },
         { 0 }
 };
 
diff --git a/drivers/scsi/lpfc/lpfc_mbox.c b/drivers/scsi/lpfc/lpfc_mbox.c
index 4d016c2a1b26..8041c3f06f7b 100644
--- a/drivers/scsi/lpfc/lpfc_mbox.c
+++ b/drivers/scsi/lpfc/lpfc_mbox.c
@@ -1,7 +1,7 @@
 /*******************************************************************
  * This file is part of the Emulex Linux Device Driver for         *
  * Fibre Channel Host Bus Adapters.                                *
- * Copyright (C) 2004-2006 Emulex.  All rights reserved.           *
+ * Copyright (C) 2004-2007 Emulex.  All rights reserved.           *
  * EMULEX and SLI are trademarks of Emulex.                        *
  * www.emulex.com                                                  *
  * Portions Copyright (C) 2004-2005 Christoph Hellwig              *
@@ -212,6 +212,7 @@ lpfc_init_link(struct lpfc_hba * phba,
                         case LINK_SPEED_1G:
                         case LINK_SPEED_2G:
                         case LINK_SPEED_4G:
+                        case LINK_SPEED_8G:
                                 mb->un.varInitLnk.link_flags |=
                                                         FLAGS_LINK_SPEED;
                                 mb->un.varInitLnk.link_speed = linkspeed;
diff --git a/drivers/scsi/lpfc/lpfc_nportdisc.c b/drivers/scsi/lpfc/lpfc_nportdisc.c
index 0c7e731dc45a..b309841e3846 100644
--- a/drivers/scsi/lpfc/lpfc_nportdisc.c
+++ b/drivers/scsi/lpfc/lpfc_nportdisc.c
@@ -1,7 +1,7 @@
 /*******************************************************************
  * This file is part of the Emulex Linux Device Driver for         *
  * Fibre Channel Host Bus Adapters.                                *
- * Copyright (C) 2004-2006 Emulex.  All rights reserved.           *
+ * Copyright (C) 2004-2007 Emulex.  All rights reserved.           *
  * EMULEX and SLI are trademarks of Emulex.                        *
  * www.emulex.com                                                  *
  * Portions Copyright (C) 2004-2005 Christoph Hellwig              *
@@ -168,14 +168,13 @@ lpfc_check_elscmpl_iocb(struct lpfc_hba * phba,
  * routine effectively results in a "software abort".
  */
 int
-lpfc_els_abort(struct lpfc_hba * phba, struct lpfc_nodelist * ndlp,
-        int send_abts)
+lpfc_els_abort(struct lpfc_hba * phba, struct lpfc_nodelist * ndlp)
 {
+        LIST_HEAD(completions);
         struct lpfc_sli *psli;
         struct lpfc_sli_ring *pring;
         struct lpfc_iocbq *iocb, *next_iocb;
-        IOCB_t *icmd;
-        int    found = 0;
+        IOCB_t *cmd;
 
         /* Abort outstanding I/O on NPort <nlp_DID> */
         lpfc_printf_log(phba, KERN_INFO, LOG_DISCOVERY,
@@ -188,75 +187,39 @@ lpfc_els_abort(struct lpfc_hba * phba, struct lpfc_nodelist * ndlp,
         pring = &psli->ring[LPFC_ELS_RING];
 
         /* First check the txq */
-        do {
-                found = 0;
-                spin_lock_irq(phba->host->host_lock);
-                list_for_each_entry_safe(iocb, next_iocb, &pring->txq, list) {
-                        /* Check to see if iocb matches the nport we are looking
-                           for */
-                        if ((lpfc_check_sli_ndlp(phba, pring, iocb, ndlp))) {
-                                found = 1;
-                                /* It matches, so deque and call compl with an
-                                   error */
-                                list_del(&iocb->list);
-                                pring->txq_cnt--;
-                                if (iocb->iocb_cmpl) {
-                                        icmd = &iocb->iocb;
-                                        icmd->ulpStatus = IOSTAT_LOCAL_REJECT;
-                                        icmd->un.ulpWord[4] = IOERR_SLI_ABORTED;
-                                        spin_unlock_irq(phba->host->host_lock);
-                                        (iocb->iocb_cmpl) (phba, iocb, iocb);
-                                        spin_lock_irq(phba->host->host_lock);
-                                } else
-                                        lpfc_sli_release_iocbq(phba, iocb);
-                                break;
-                        }
+        spin_lock_irq(phba->host->host_lock);
+        list_for_each_entry_safe(iocb, next_iocb, &pring->txq, list) {
+                /* Check to see if iocb matches the nport we are looking
+                   for */
+                if (lpfc_check_sli_ndlp(phba, pring, iocb, ndlp)) {
+                        /* It matches, so deque and call compl with an
+                           error */
+                        list_move_tail(&iocb->list, &completions);
+                        pring->txq_cnt--;
                 }
-                spin_unlock_irq(phba->host->host_lock);
-        } while (found);
+        }
 
-        /* Everything on txcmplq will be returned by firmware
-         * with a no rpi / linkdown / abort error.  For ring 0,
-         * ELS discovery, we want to get rid of it right here.
-         */
         /* Next check the txcmplq */
-        do {
-                found = 0;
-                spin_lock_irq(phba->host->host_lock);
-                list_for_each_entry_safe(iocb, next_iocb, &pring->txcmplq,
-                                         list) {
-                        /* Check to see if iocb matches the nport we are looking
-                           for */
-                        if ((lpfc_check_sli_ndlp (phba, pring, iocb, ndlp))) {
-                                found = 1;
-                                /* It matches, so deque and call compl with an
-                                   error */
-                                list_del(&iocb->list);
-                                pring->txcmplq_cnt--;
-
-                                icmd = &iocb->iocb;
-                                /* If the driver is completing an ELS
-                                 * command early, flush it out of the firmware.
-                                 */
-                                if (send_abts &&
-                                   (icmd->ulpCommand == CMD_ELS_REQUEST64_CR) &&
-                                   (icmd->un.elsreq64.bdl.ulpIoTag32)) {
-                                        lpfc_sli_issue_abort_iotag32(phba,
-                                                             pring, iocb);
-                                }
-                                if (iocb->iocb_cmpl) {
-                                        icmd->ulpStatus = IOSTAT_LOCAL_REJECT;
-                                        icmd->un.ulpWord[4] = IOERR_SLI_ABORTED;
-                                        spin_unlock_irq(phba->host->host_lock);
-                                        (iocb->iocb_cmpl) (phba, iocb, iocb);
-                                        spin_lock_irq(phba->host->host_lock);
-                                } else
-                                        lpfc_sli_release_iocbq(phba, iocb);
-                                break;
-                        }
-                }
-                spin_unlock_irq(phba->host->host_lock);
-        } while(found);
+        list_for_each_entry_safe(iocb, next_iocb, &pring->txcmplq, list) {
+                /* Check to see if iocb matches the nport we are looking
+                   for */
+                if (lpfc_check_sli_ndlp(phba, pring, iocb, ndlp))
+                        lpfc_sli_issue_abort_iotag(phba, pring, iocb);
+        }
+        spin_unlock_irq(phba->host->host_lock);
+
+        while (!list_empty(&completions)) {
+                iocb = list_get_first(&completions, struct lpfc_iocbq, list);
+                cmd = &iocb->iocb;
+                list_del(&iocb->list);
+
+                if (iocb->iocb_cmpl) {
+                        cmd->ulpStatus = IOSTAT_LOCAL_REJECT;
+                        cmd->un.ulpWord[4] = IOERR_SLI_ABORTED;
+                        (iocb->iocb_cmpl) (phba, iocb, iocb);
+                } else
+                        lpfc_sli_release_iocbq(phba, iocb);
+        }
 
         /* If we are delaying issuing an ELS command, cancel it */
         if (ndlp->nlp_flag & NLP_DELAY_TMO)
@@ -390,7 +353,10 @@ lpfc_rcv_plogi(struct lpfc_hba * phba,
          * queue this mbox command to be processed later.
          */
         mbox->mbox_cmpl = lpfc_mbx_cmpl_reg_login;
-        mbox->context2  = ndlp;
+        /*
+         * mbox->context2 = lpfc_nlp_get(ndlp) deferred until mailbox
+         * command issued in lpfc_cmpl_els_acc().
+         */
         ndlp->nlp_flag |= (NLP_ACC_REGLOGIN | NLP_RCV_PLOGI);
 
         /*
@@ -404,7 +370,7 @@ lpfc_rcv_plogi(struct lpfc_hba * phba,
          */
         if (ndlp->nlp_state == NLP_STE_PLOGI_ISSUE) {
                 /* software abort outstanding PLOGI */
-                lpfc_els_abort(phba, ndlp, 1);
+                lpfc_els_abort(phba, ndlp);
         }
 
         lpfc_els_rsp_acc(phba, ELS_CMD_PLOGI, cmdiocb, ndlp, mbox, 0);
@@ -471,8 +437,7 @@ lpfc_rcv_padisc(struct lpfc_hba * phba,
         spin_unlock_irq(phba->host->host_lock);
         ndlp->nlp_last_elscmd = ELS_CMD_PLOGI;
         ndlp->nlp_prev_state = ndlp->nlp_state;
-        ndlp->nlp_state = NLP_STE_NPR_NODE;
-        lpfc_nlp_list(phba, ndlp, NLP_NPR_LIST);
+        lpfc_nlp_set_state(phba, ndlp, NLP_STE_NPR_NODE);
         return 0;
 }
 
@@ -502,12 +467,10 @@ lpfc_rcv_logo(struct lpfc_hba * phba,
 
                 ndlp->nlp_last_elscmd = ELS_CMD_PLOGI;
                 ndlp->nlp_prev_state = ndlp->nlp_state;
-                ndlp->nlp_state = NLP_STE_NPR_NODE;
-                lpfc_nlp_list(phba, ndlp, NLP_NPR_LIST);
+                lpfc_nlp_set_state(phba, ndlp, NLP_STE_NPR_NODE);
         } else {
                 ndlp->nlp_prev_state = ndlp->nlp_state;
-                ndlp->nlp_state = NLP_STE_UNUSED_NODE;
-                lpfc_nlp_list(phba, ndlp, NLP_UNUSED_LIST);
+                lpfc_nlp_set_state(phba, ndlp, NLP_STE_UNUSED_NODE);
         }
 
         spin_lock_irq(phba->host->host_lock);
@@ -601,11 +564,10 @@ lpfc_rcv_plogi_unused_node(struct lpfc_hba * phba,
 
         if (lpfc_rcv_plogi(phba, ndlp, cmdiocb)) {
                 ndlp->nlp_prev_state = NLP_STE_UNUSED_NODE;
-                ndlp->nlp_state = NLP_STE_UNUSED_NODE;
-                lpfc_nlp_list(phba, ndlp, NLP_UNUSED_LIST);
+                lpfc_nlp_set_state(phba, ndlp, NLP_STE_UNUSED_NODE);
                 return ndlp->nlp_state;
         }
-        lpfc_nlp_list(phba, ndlp, NLP_NO_LIST);
+        lpfc_drop_node(phba, ndlp);
         return NLP_STE_FREED_NODE;
 }
 
@@ -614,7 +576,7 @@ lpfc_rcv_els_unused_node(struct lpfc_hba * phba,
                          struct lpfc_nodelist * ndlp, void *arg, uint32_t evt)
 {
         lpfc_issue_els_logo(phba, ndlp, 0);
-        lpfc_nlp_list(phba, ndlp, NLP_UNUSED_LIST);
+        lpfc_nlp_set_state(phba, ndlp, NLP_STE_UNUSED_NODE);
         return ndlp->nlp_state;
 }
 
@@ -630,7 +592,7 @@ lpfc_rcv_logo_unused_node(struct lpfc_hba * phba,
         ndlp->nlp_flag |= NLP_LOGO_ACC;
         spin_unlock_irq(phba->host->host_lock);
         lpfc_els_rsp_acc(phba, ELS_CMD_ACC, cmdiocb, ndlp, NULL, 0);
-        lpfc_nlp_list(phba, ndlp, NLP_UNUSED_LIST);
+        lpfc_nlp_set_state(phba, ndlp, NLP_STE_UNUSED_NODE);
 
         return ndlp->nlp_state;
 }
@@ -639,7 +601,7 @@ static uint32_t
 lpfc_cmpl_logo_unused_node(struct lpfc_hba * phba,
                           struct lpfc_nodelist * ndlp, void *arg, uint32_t evt)
 {
-        lpfc_nlp_list(phba, ndlp, NLP_NO_LIST);
+        lpfc_drop_node(phba, ndlp);
         return NLP_STE_FREED_NODE;
 }
 
@@ -647,7 +609,7 @@ static uint32_t
 lpfc_device_rm_unused_node(struct lpfc_hba * phba,
                            struct lpfc_nodelist * ndlp, void *arg, uint32_t evt)
 {
-        lpfc_nlp_list(phba, ndlp, NLP_NO_LIST);
+        lpfc_drop_node(phba, ndlp);
         return NLP_STE_FREED_NODE;
 }
 
@@ -697,7 +659,7 @@ lpfc_rcv_logo_plogi_issue(struct lpfc_hba * phba,
         cmdiocb = (struct lpfc_iocbq *) arg;
 
         /* software abort outstanding PLOGI */
-        lpfc_els_abort(phba, ndlp, 1);
+        lpfc_els_abort(phba, ndlp);
 
         lpfc_rcv_logo(phba, ndlp, cmdiocb, ELS_CMD_LOGO);
         return ndlp->nlp_state;
@@ -712,7 +674,7 @@ lpfc_rcv_els_plogi_issue(struct lpfc_hba * phba,
         cmdiocb = (struct lpfc_iocbq *) arg;
 
         /* software abort outstanding PLOGI */
-        lpfc_els_abort(phba, ndlp, 1);
+        lpfc_els_abort(phba, ndlp);
 
         if (evt == NLP_EVT_RCV_LOGO) {
                 lpfc_els_rsp_acc(phba, ELS_CMD_ACC, cmdiocb, ndlp, NULL, 0);
@@ -727,8 +689,7 @@ lpfc_rcv_els_plogi_issue(struct lpfc_hba * phba,
         spin_unlock_irq(phba->host->host_lock);
         ndlp->nlp_last_elscmd = ELS_CMD_PLOGI;
         ndlp->nlp_prev_state = NLP_STE_PLOGI_ISSUE;
-        ndlp->nlp_state = NLP_STE_NPR_NODE;
-        lpfc_nlp_list(phba, ndlp, NLP_NPR_LIST);
+        lpfc_nlp_set_state(phba, ndlp, NLP_STE_NPR_NODE);
 
         return ndlp->nlp_state;
 }
@@ -803,32 +764,26 @@ lpfc_cmpl_plogi_plogi_issue(struct lpfc_hba * phba,
                 goto out;
 
         lpfc_unreg_rpi(phba, ndlp);
-        if (lpfc_reg_login
-            (phba, irsp->un.elsreq64.remoteID,
-             (uint8_t *) sp, mbox, 0) == 0) {
+        if (lpfc_reg_login(phba, irsp->un.elsreq64.remoteID, (uint8_t *) sp,
+                           mbox, 0) == 0) {
                 switch (ndlp->nlp_DID) {
                 case NameServer_DID:
-                        mbox->mbox_cmpl =
-                                lpfc_mbx_cmpl_ns_reg_login;
+                        mbox->mbox_cmpl = lpfc_mbx_cmpl_ns_reg_login;
                         break;
                 case FDMI_DID:
-                        mbox->mbox_cmpl =
-                                lpfc_mbx_cmpl_fdmi_reg_login;
+                        mbox->mbox_cmpl = lpfc_mbx_cmpl_fdmi_reg_login;
                         break;
                 default:
-                        mbox->mbox_cmpl =
-                                lpfc_mbx_cmpl_reg_login;
+                        mbox->mbox_cmpl = lpfc_mbx_cmpl_reg_login;
                 }
-                mbox->context2 = ndlp;
+                mbox->context2 = lpfc_nlp_get(ndlp);
                 if (lpfc_sli_issue_mbox(phba, mbox,
                                         (MBX_NOWAIT | MBX_STOP_IOCB))
                     != MBX_NOT_FINISHED) {
-                        ndlp->nlp_state =
-                                NLP_STE_REG_LOGIN_ISSUE;
-                        lpfc_nlp_list(phba, ndlp,
-                                      NLP_REGLOGIN_LIST);
+                        lpfc_nlp_set_state(phba, ndlp, NLP_STE_REG_LOGIN_ISSUE);
                         return ndlp->nlp_state;
                 }
+                lpfc_nlp_put(ndlp);
                 mp = (struct lpfc_dmabuf *)mbox->context1;
                 lpfc_mbuf_free(phba, mp->virt, mp->phys);
                 kfree(mp);
@@ -841,7 +796,7 @@ lpfc_cmpl_plogi_plogi_issue(struct lpfc_hba * phba,
  out:
         /* Free this node since the driver cannot login or has the wrong
            sparm */
-        lpfc_nlp_list(phba, ndlp, NLP_NO_LIST);
+        lpfc_drop_node(phba, ndlp);
         return NLP_STE_FREED_NODE;
 }
 
@@ -855,9 +810,9 @@ lpfc_device_rm_plogi_issue(struct lpfc_hba * phba,
         }
         else {
                 /* software abort outstanding PLOGI */
-                lpfc_els_abort(phba, ndlp, 1);
+                lpfc_els_abort(phba, ndlp);
 
-                lpfc_nlp_list(phba, ndlp, NLP_NO_LIST);
+                lpfc_drop_node(phba, ndlp);
                 return NLP_STE_FREED_NODE;
         }
 }
@@ -868,11 +823,10 @@ lpfc_device_recov_plogi_issue(struct lpfc_hba * phba,
                             uint32_t evt)
 {
         /* software abort outstanding PLOGI */
-        lpfc_els_abort(phba, ndlp, 1);
+        lpfc_els_abort(phba, ndlp);
 
         ndlp->nlp_prev_state = NLP_STE_PLOGI_ISSUE;
-        ndlp->nlp_state = NLP_STE_NPR_NODE;
-        lpfc_nlp_list(phba, ndlp, NLP_NPR_LIST);
+        lpfc_nlp_set_state(phba, ndlp, NLP_STE_NPR_NODE);
         spin_lock_irq(phba->host->host_lock);
         ndlp->nlp_flag &= ~(NLP_NODEV_REMOVE | NLP_NPR_2B_DISC);
         spin_unlock_irq(phba->host->host_lock);
@@ -888,7 +842,7 @@ lpfc_rcv_plogi_adisc_issue(struct lpfc_hba * phba,
         struct lpfc_iocbq *cmdiocb;
 
         /* software abort outstanding ADISC */
-        lpfc_els_abort(phba, ndlp, 1);
+        lpfc_els_abort(phba, ndlp);
 
         cmdiocb = (struct lpfc_iocbq *) arg;
 
@@ -896,8 +850,7 @@ lpfc_rcv_plogi_adisc_issue(struct lpfc_hba * phba,
                 return ndlp->nlp_state;
         }
         ndlp->nlp_prev_state = NLP_STE_ADISC_ISSUE;
-        ndlp->nlp_state = NLP_STE_PLOGI_ISSUE;
-        lpfc_nlp_list(phba, ndlp, NLP_PLOGI_LIST);
+        lpfc_nlp_set_state(phba, ndlp, NLP_STE_PLOGI_ISSUE);
         lpfc_issue_els_plogi(phba, ndlp->nlp_DID, 0);
 
         return ndlp->nlp_state;
@@ -926,7 +879,7 @@ lpfc_rcv_logo_adisc_issue(struct lpfc_hba * phba,
         cmdiocb = (struct lpfc_iocbq *) arg;
 
         /* software abort outstanding ADISC */
-        lpfc_els_abort(phba, ndlp, 0);
+        lpfc_els_abort(phba, ndlp);
 
         lpfc_rcv_logo(phba, ndlp, cmdiocb, ELS_CMD_LOGO);
         return ndlp->nlp_state;
@@ -987,20 +940,17 @@ lpfc_cmpl_adisc_adisc_issue(struct lpfc_hba * phba,
                 memset(&ndlp->nlp_portname, 0, sizeof (struct lpfc_name));
 
                 ndlp->nlp_prev_state = NLP_STE_ADISC_ISSUE;
-                ndlp->nlp_state = NLP_STE_NPR_NODE;
-                lpfc_nlp_list(phba, ndlp, NLP_NPR_LIST);
+                lpfc_nlp_set_state(phba, ndlp, NLP_STE_NPR_NODE);
                 lpfc_unreg_rpi(phba, ndlp);
                 return ndlp->nlp_state;
         }
 
         if (ndlp->nlp_type & NLP_FCP_TARGET) {
                 ndlp->nlp_prev_state = NLP_STE_ADISC_ISSUE;
-                ndlp->nlp_state = NLP_STE_MAPPED_NODE;
-                lpfc_nlp_list(phba, ndlp, NLP_MAPPED_LIST);
+                lpfc_nlp_set_state(phba, ndlp, NLP_STE_MAPPED_NODE);
         } else {
                 ndlp->nlp_prev_state = NLP_STE_ADISC_ISSUE;
-                ndlp->nlp_state = NLP_STE_UNMAPPED_NODE;
-                lpfc_nlp_list(phba, ndlp, NLP_UNMAPPED_LIST);
+                lpfc_nlp_set_state(phba, ndlp, NLP_STE_UNMAPPED_NODE);
         }
         return ndlp->nlp_state;
 }
@@ -1016,9 +966,9 @@ lpfc_device_rm_adisc_issue(struct lpfc_hba * phba,
         }
         else {
                 /* software abort outstanding ADISC */
-                lpfc_els_abort(phba, ndlp, 1);
+                lpfc_els_abort(phba, ndlp);
 
-                lpfc_nlp_list(phba, ndlp, NLP_NO_LIST);
+                lpfc_drop_node(phba, ndlp);
                 return NLP_STE_FREED_NODE;
         }
 }
@@ -1029,11 +979,10 @@ lpfc_device_recov_adisc_issue(struct lpfc_hba * phba,
                             uint32_t evt)
 {
         /* software abort outstanding ADISC */
-        lpfc_els_abort(phba, ndlp, 1);
+        lpfc_els_abort(phba, ndlp);
 
         ndlp->nlp_prev_state = NLP_STE_ADISC_ISSUE;
-        ndlp->nlp_state = NLP_STE_NPR_NODE;
-        lpfc_nlp_list(phba, ndlp, NLP_NPR_LIST);
+        lpfc_nlp_set_state(phba, ndlp, NLP_STE_NPR_NODE);
         spin_lock_irq(phba->host->host_lock);
         ndlp->nlp_flag &= ~(NLP_NODEV_REMOVE | NLP_NPR_2B_DISC);
         ndlp->nlp_flag |= NLP_NPR_ADISC;
@@ -1074,9 +1023,36 @@ lpfc_rcv_logo_reglogin_issue(struct lpfc_hba * phba,
                              uint32_t evt)
 {
         struct lpfc_iocbq *cmdiocb;
+        LPFC_MBOXQ_t      *mb;
+        LPFC_MBOXQ_t      *nextmb;
+        struct lpfc_dmabuf *mp;
 
         cmdiocb = (struct lpfc_iocbq *) arg;
 
+        /* cleanup any ndlp on mbox q waiting for reglogin cmpl */
+        if ((mb = phba->sli.mbox_active)) {
+                if ((mb->mb.mbxCommand == MBX_REG_LOGIN64) &&
+                   (ndlp == (struct lpfc_nodelist *) mb->context2)) {
+                        mb->context2 = NULL;
+                        mb->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
+                }
+        }
+
+        spin_lock_irq(phba->host->host_lock);
+        list_for_each_entry_safe(mb, nextmb, &phba->sli.mboxq, list) {
+                if ((mb->mb.mbxCommand == MBX_REG_LOGIN64) &&
+                   (ndlp == (struct lpfc_nodelist *) mb->context2)) {
+                        mp = (struct lpfc_dmabuf *) (mb->context1);
+                        if (mp) {
+                                lpfc_mbuf_free(phba, mp->virt, mp->phys);
+                                kfree(mp);
+                        }
+                        list_del(&mb->list);
+                        mempool_free(mb, phba->mbox_mem_pool);
+                }
+        }
+        spin_unlock_irq(phba->host->host_lock);
+
         lpfc_rcv_logo(phba, ndlp, cmdiocb, ELS_CMD_LOGO);
         return ndlp->nlp_state;
 }
@@ -1133,8 +1109,7 @@ lpfc_cmpl_reglogin_reglogin_issue(struct lpfc_hba * phba,
                  */
                 if (mb->mbxStatus == MBXERR_RPI_FULL) {
                         ndlp->nlp_prev_state = NLP_STE_UNUSED_NODE;
-                        ndlp->nlp_state = NLP_STE_UNUSED_NODE;
-                        lpfc_nlp_list(phba, ndlp, NLP_UNUSED_LIST);
+                        lpfc_nlp_set_state(phba, ndlp, NLP_STE_UNUSED_NODE);
                         return ndlp->nlp_state;
                 }
 
@@ -1147,8 +1122,7 @@ lpfc_cmpl_reglogin_reglogin_issue(struct lpfc_hba * phba,
 
                 lpfc_issue_els_logo(phba, ndlp, 0);
                 ndlp->nlp_prev_state = NLP_STE_REG_LOGIN_ISSUE;
-                ndlp->nlp_state = NLP_STE_NPR_NODE;
-                lpfc_nlp_list(phba, ndlp, NLP_NPR_LIST);
+                lpfc_nlp_set_state(phba, ndlp, NLP_STE_NPR_NODE);
                 return ndlp->nlp_state;
         }
 
@@ -1157,13 +1131,11 @@ lpfc_cmpl_reglogin_reglogin_issue(struct lpfc_hba * phba,
         /* Only if we are not a fabric nport do we issue PRLI */
         if (!(ndlp->nlp_type & NLP_FABRIC)) {
                 ndlp->nlp_prev_state = NLP_STE_REG_LOGIN_ISSUE;
-                ndlp->nlp_state = NLP_STE_PRLI_ISSUE;
-                lpfc_nlp_list(phba, ndlp, NLP_PRLI_LIST);
+                lpfc_nlp_set_state(phba, ndlp, NLP_STE_PRLI_ISSUE);
                 lpfc_issue_els_prli(phba, ndlp, 0);
         } else {
                 ndlp->nlp_prev_state = NLP_STE_REG_LOGIN_ISSUE;
-                ndlp->nlp_state = NLP_STE_UNMAPPED_NODE;
-                lpfc_nlp_list(phba, ndlp, NLP_UNMAPPED_LIST);
+                lpfc_nlp_set_state(phba, ndlp, NLP_STE_UNMAPPED_NODE);
         }
         return ndlp->nlp_state;
 }
@@ -1178,7 +1150,7 @@ lpfc_device_rm_reglogin_issue(struct lpfc_hba * phba,
                 return ndlp->nlp_state;
         }
         else {
-                lpfc_nlp_list(phba, ndlp, NLP_NO_LIST);
+                lpfc_drop_node(phba, ndlp);
                 return NLP_STE_FREED_NODE;
         }
 }
@@ -1189,8 +1161,7 @@ lpfc_device_recov_reglogin_issue(struct lpfc_hba * phba,
                                uint32_t evt)
 {
         ndlp->nlp_prev_state = NLP_STE_REG_LOGIN_ISSUE;
-        ndlp->nlp_state = NLP_STE_NPR_NODE;
-        lpfc_nlp_list(phba, ndlp, NLP_NPR_LIST);
+        lpfc_nlp_set_state(phba, ndlp, NLP_STE_NPR_NODE);
         spin_lock_irq(phba->host->host_lock);
         ndlp->nlp_flag &= ~(NLP_NODEV_REMOVE | NLP_NPR_2B_DISC);
         spin_unlock_irq(phba->host->host_lock);
@@ -1230,7 +1201,7 @@ lpfc_rcv_logo_prli_issue(struct lpfc_hba * phba,
         cmdiocb = (struct lpfc_iocbq *) arg;
 
         /* Software abort outstanding PRLI before sending acc */
-        lpfc_els_abort(phba, ndlp, 1);
+        lpfc_els_abort(phba, ndlp);
 
         lpfc_rcv_logo(phba, ndlp, cmdiocb, ELS_CMD_LOGO);
         return ndlp->nlp_state;
@@ -1279,8 +1250,7 @@ lpfc_cmpl_prli_prli_issue(struct lpfc_hba * phba,
         irsp = &rspiocb->iocb;
         if (irsp->ulpStatus) {
                 ndlp->nlp_prev_state = NLP_STE_PRLI_ISSUE;
-                ndlp->nlp_state = NLP_STE_UNMAPPED_NODE;
-                lpfc_nlp_list(phba, ndlp, NLP_UNMAPPED_LIST);
+                lpfc_nlp_set_state(phba, ndlp, NLP_STE_UNMAPPED_NODE);
                 return ndlp->nlp_state;
         }
 
@@ -1298,8 +1268,7 @@ lpfc_cmpl_prli_prli_issue(struct lpfc_hba * phba,
         }
 
         ndlp->nlp_prev_state = NLP_STE_PRLI_ISSUE;
-        ndlp->nlp_state = NLP_STE_MAPPED_NODE;
-        lpfc_nlp_list(phba, ndlp, NLP_MAPPED_LIST);
+        lpfc_nlp_set_state(phba, ndlp, NLP_STE_MAPPED_NODE);
         return ndlp->nlp_state;
 }
 
@@ -1330,9 +1299,9 @@ lpfc_device_rm_prli_issue(struct lpfc_hba * phba,
         }
         else {
                 /* software abort outstanding PLOGI */
-                lpfc_els_abort(phba, ndlp, 1);
+                lpfc_els_abort(phba, ndlp);
 
-                lpfc_nlp_list(phba, ndlp, NLP_NO_LIST);
+                lpfc_drop_node(phba, ndlp);
                 return NLP_STE_FREED_NODE;
         }
 }
@@ -1359,11 +1328,10 @@ lpfc_device_recov_prli_issue(struct lpfc_hba * phba,
                            struct lpfc_nodelist * ndlp, void *arg, uint32_t evt)
 {
         /* software abort outstanding PRLI */
-        lpfc_els_abort(phba, ndlp, 1);
+        lpfc_els_abort(phba, ndlp);
 
         ndlp->nlp_prev_state = NLP_STE_PRLI_ISSUE;
-        ndlp->nlp_state = NLP_STE_NPR_NODE;
-        lpfc_nlp_list(phba, ndlp, NLP_NPR_LIST);
+        lpfc_nlp_set_state(phba, ndlp, NLP_STE_NPR_NODE);
         spin_lock_irq(phba->host->host_lock);
         ndlp->nlp_flag &= ~(NLP_NODEV_REMOVE | NLP_NPR_2B_DISC);
         spin_unlock_irq(phba->host->host_lock);
@@ -1436,8 +1404,7 @@ lpfc_device_recov_unmap_node(struct lpfc_hba * phba,
                            struct lpfc_nodelist * ndlp, void *arg, uint32_t evt)
 {
         ndlp->nlp_prev_state = NLP_STE_UNMAPPED_NODE;
-        ndlp->nlp_state = NLP_STE_NPR_NODE;
-        lpfc_nlp_list(phba, ndlp, NLP_NPR_LIST);
+        lpfc_nlp_set_state(phba, ndlp, NLP_STE_NPR_NODE);
         ndlp->nlp_flag &= ~(NLP_NODEV_REMOVE | NLP_NPR_2B_DISC);
         lpfc_disc_set_adisc(phba, ndlp);
 
@@ -1518,8 +1485,7 @@ lpfc_device_recov_mapped_node(struct lpfc_hba * phba,
                             uint32_t evt)
 {
         ndlp->nlp_prev_state = NLP_STE_MAPPED_NODE;
-        ndlp->nlp_state = NLP_STE_NPR_NODE;
-        lpfc_nlp_list(phba, ndlp, NLP_NPR_LIST);
+        lpfc_nlp_set_state(phba, ndlp, NLP_STE_NPR_NODE);
         spin_lock_irq(phba->host->host_lock);
         ndlp->nlp_flag &= ~(NLP_NODEV_REMOVE | NLP_NPR_2B_DISC);
         spin_unlock_irq(phba->host->host_lock);
@@ -1551,8 +1517,7 @@ lpfc_rcv_plogi_npr_node(struct lpfc_hba * phba,
         /* send PLOGI immediately, move to PLOGI issue state */
         if (!(ndlp->nlp_flag & NLP_DELAY_TMO)) {
                 ndlp->nlp_prev_state = NLP_STE_NPR_NODE;
-                ndlp->nlp_state = NLP_STE_PLOGI_ISSUE;
-                lpfc_nlp_list(phba, ndlp, NLP_PLOGI_LIST);
+                lpfc_nlp_set_state(phba, ndlp, NLP_STE_PLOGI_ISSUE);
                 lpfc_issue_els_plogi(phba, ndlp->nlp_DID, 0);
         }
 
@@ -1580,16 +1545,13 @@ lpfc_rcv_prli_npr_node(struct lpfc_hba * phba,
                         ndlp->nlp_flag &= ~NLP_NPR_ADISC;
                         spin_unlock_irq(phba->host->host_lock);
                         ndlp->nlp_prev_state = NLP_STE_NPR_NODE;
-                        ndlp->nlp_state = NLP_STE_ADISC_ISSUE;
-                        lpfc_nlp_list(phba, ndlp, NLP_ADISC_LIST);
+                        lpfc_nlp_set_state(phba, ndlp, NLP_STE_ADISC_ISSUE);
                         lpfc_issue_els_adisc(phba, ndlp, 0);
                 } else {
                         ndlp->nlp_prev_state = NLP_STE_NPR_NODE;
-                        ndlp->nlp_state = NLP_STE_PLOGI_ISSUE;
-                        lpfc_nlp_list(phba, ndlp, NLP_PLOGI_LIST);
+                        lpfc_nlp_set_state(phba, ndlp, NLP_STE_PLOGI_ISSUE);
                         lpfc_issue_els_plogi(phba, ndlp->nlp_DID, 0);
                 }
-
         }
         return ndlp->nlp_state;
 }
@@ -1627,13 +1589,11 @@ lpfc_rcv_padisc_npr_node(struct lpfc_hba * phba,
                 !(ndlp->nlp_flag & NLP_NPR_2B_DISC)){
                 if (ndlp->nlp_flag & NLP_NPR_ADISC) {
                         ndlp->nlp_prev_state = NLP_STE_NPR_NODE;
-                        ndlp->nlp_state = NLP_STE_ADISC_ISSUE;
-                        lpfc_nlp_list(phba, ndlp, NLP_ADISC_LIST);
+                        lpfc_nlp_set_state(phba, ndlp, NLP_STE_ADISC_ISSUE);
                         lpfc_issue_els_adisc(phba, ndlp, 0);
                 } else {
                         ndlp->nlp_prev_state = NLP_STE_NPR_NODE;
-                        ndlp->nlp_state = NLP_STE_PLOGI_ISSUE;
-                        lpfc_nlp_list(phba, ndlp, NLP_PLOGI_LIST);
+                        lpfc_nlp_set_state(phba, ndlp, NLP_STE_PLOGI_ISSUE);
                         lpfc_issue_els_plogi(phba, ndlp->nlp_DID, 0);
                 }
         }
@@ -1682,7 +1642,7 @@ lpfc_cmpl_plogi_npr_node(struct lpfc_hba * phba,
 
         irsp = &rspiocb->iocb;
         if (irsp->ulpStatus) {
-                lpfc_nlp_list(phba, ndlp, NLP_NO_LIST);
+                lpfc_drop_node(phba, ndlp);
                 return NLP_STE_FREED_NODE;
         }
         return ndlp->nlp_state;
@@ -1700,7 +1660,7 @@ lpfc_cmpl_prli_npr_node(struct lpfc_hba * phba,
 
         irsp = &rspiocb->iocb;
         if (irsp->ulpStatus && (ndlp->nlp_flag & NLP_NODEV_REMOVE)) {
-                lpfc_nlp_list(phba, ndlp, NLP_NO_LIST);
+                lpfc_drop_node(phba, ndlp);
                 return NLP_STE_FREED_NODE;
         }
         return ndlp->nlp_state;
@@ -1728,7 +1688,7 @@ lpfc_cmpl_adisc_npr_node(struct lpfc_hba * phba,
 
         irsp = &rspiocb->iocb;
         if (irsp->ulpStatus && (ndlp->nlp_flag & NLP_NODEV_REMOVE)) {
-                lpfc_nlp_list(phba, ndlp, NLP_NO_LIST);
+                lpfc_drop_node(phba, ndlp);
                 return NLP_STE_FREED_NODE;
         }
         return ndlp->nlp_state;
@@ -1749,7 +1709,7 @@ lpfc_cmpl_reglogin_npr_node(struct lpfc_hba * phba,
                 ndlp->nlp_rpi = mb->un.varWords[0];
         else {
                 if (ndlp->nlp_flag & NLP_NODEV_REMOVE) {
-                        lpfc_nlp_list(phba, ndlp, NLP_NO_LIST);
+                        lpfc_drop_node(phba, ndlp);
                         return NLP_STE_FREED_NODE;
                 }
         }
@@ -1765,7 +1725,7 @@ lpfc_device_rm_npr_node(struct lpfc_hba * phba,
                 ndlp->nlp_flag |= NLP_NODEV_REMOVE;
                 return ndlp->nlp_state;
         }
-        lpfc_nlp_list(phba, ndlp, NLP_NO_LIST);
+        lpfc_drop_node(phba, ndlp);
         return NLP_STE_FREED_NODE;
 }
 
@@ -1964,7 +1924,7 @@ lpfc_disc_state_machine(struct lpfc_hba * phba,
         uint32_t(*func) (struct lpfc_hba *, struct lpfc_nodelist *, void *,
                          uint32_t);
 
-        ndlp->nlp_disc_refcnt++;
+        lpfc_nlp_get(ndlp);
         cur_state = ndlp->nlp_state;
 
         /* DSM in event <evt> on NPort <nlp_DID> in state <cur_state> */
@@ -1987,18 +1947,7 @@ lpfc_disc_state_machine(struct lpfc_hba * phba,
                        phba->brd_no,
                        rc, ndlp->nlp_DID, ndlp->nlp_flag);
 
-        ndlp->nlp_disc_refcnt--;
+        lpfc_nlp_put(ndlp);
 
-        /* Check to see if ndlp removal is deferred */
-        if ((ndlp->nlp_disc_refcnt == 0)
-            && (ndlp->nlp_flag & NLP_DELAY_REMOVE)) {
-                spin_lock_irq(phba->host->host_lock);
-                ndlp->nlp_flag &= ~NLP_DELAY_REMOVE;
-                spin_unlock_irq(phba->host->host_lock);
-                lpfc_nlp_remove(phba, ndlp);
-                return NLP_STE_FREED_NODE;
-        }
-        if (rc == NLP_STE_FREED_NODE)
-                return NLP_STE_FREED_NODE;
         return rc;
 }
diff --git a/drivers/scsi/lpfc/lpfc_scsi.c b/drivers/scsi/lpfc/lpfc_scsi.c
index c3e68e0d8f74..9a12d05e99e4 100644
--- a/drivers/scsi/lpfc/lpfc_scsi.c
+++ b/drivers/scsi/lpfc/lpfc_scsi.c
@@ -1,7 +1,7 @@
 /*******************************************************************
  * This file is part of the Emulex Linux Device Driver for         *
  * Fibre Channel Host Bus Adapters.                                *
- * Copyright (C) 2004-2006 Emulex.  All rights reserved.           *
+ * Copyright (C) 2004-2007 Emulex.  All rights reserved.           *
  * EMULEX and SLI are trademarks of Emulex.                        *
  * www.emulex.com                                                  *
  * Portions Copyright (C) 2004-2005 Christoph Hellwig              *
@@ -146,6 +146,10 @@ lpfc_get_scsi_buf(struct lpfc_hba * phba)
 
         spin_lock_irqsave(&phba->scsi_buf_list_lock, iflag);
         list_remove_head(scsi_buf_list, lpfc_cmd, struct lpfc_scsi_buf, list);
+        if (lpfc_cmd) {
+                lpfc_cmd->seg_cnt = 0;
+                lpfc_cmd->nonsg_phys = 0;
+        }
         spin_unlock_irqrestore(&phba->scsi_buf_list_lock, iflag);
         return  lpfc_cmd;
 }
@@ -288,13 +292,13 @@ lpfc_scsi_unprep_dma_buf(struct lpfc_hba * phba, struct lpfc_scsi_buf * psb)
 }
 
 static void
-lpfc_handle_fcp_err(struct lpfc_scsi_buf *lpfc_cmd)
+lpfc_handle_fcp_err(struct lpfc_scsi_buf *lpfc_cmd, struct lpfc_iocbq *rsp_iocb)
 {
         struct scsi_cmnd *cmnd = lpfc_cmd->pCmd;
         struct fcp_cmnd *fcpcmd = lpfc_cmd->fcp_cmnd;
         struct fcp_rsp *fcprsp = lpfc_cmd->fcp_rsp;
         struct lpfc_hba *phba = lpfc_cmd->scsi_hba;
-        uint32_t fcpi_parm = lpfc_cmd->cur_iocbq.iocb.un.fcpi.fcpi_parm;
+        uint32_t fcpi_parm = rsp_iocb->iocb.un.fcpi.fcpi_parm;
         uint32_t resp_info = fcprsp->rspStatus2;
         uint32_t scsi_status = fcprsp->rspStatus3;
         uint32_t *lp;
@@ -356,6 +360,24 @@ lpfc_handle_fcp_err(struct lpfc_scsi_buf *lpfc_cmd)
                                 fcpi_parm, cmnd->cmnd[0], cmnd->underflow);
 
                 /*
+                 * If there is an under run check if under run reported by
+                 * storage array is same as the under run reported by HBA.
+                 * If this is not same, there is a dropped frame.
+                 */
+                if ((cmnd->sc_data_direction == DMA_FROM_DEVICE) &&
+                        fcpi_parm &&
+                        (cmnd->resid != fcpi_parm)) {
+                        lpfc_printf_log(phba, KERN_WARNING,
+                                LOG_FCP | LOG_FCP_ERROR,
+                                "%d:0735 FCP Read Check Error and Underrun "
+                                "Data: x%x x%x x%x x%x\n", phba->brd_no,
+                                be32_to_cpu(fcpcmd->fcpDl),
+                                cmnd->resid,
+                                fcpi_parm, cmnd->cmnd[0]);
+                        cmnd->resid = cmnd->request_bufflen;
+                        host_status = DID_ERROR;
+                }
+                /*
                  * The cmnd->underflow is the minimum number of bytes that must
                  * be transfered for this command.  Provided a sense condition
                  * is not present, make sure the actual amount transferred is at
@@ -435,7 +457,7 @@ lpfc_scsi_cmd_iocb_cmpl(struct lpfc_hba *phba, struct lpfc_iocbq *pIocbIn,
                 switch (lpfc_cmd->status) {
                 case IOSTAT_FCP_RSP_ERROR:
                         /* Call FCP RSP handler to determine result */
-                        lpfc_handle_fcp_err(lpfc_cmd);
+                        lpfc_handle_fcp_err(lpfc_cmd,pIocbOut);
                         break;
                 case IOSTAT_NPORT_BSY:
                 case IOSTAT_FABRIC_BSY:
@@ -466,10 +488,10 @@ lpfc_scsi_cmd_iocb_cmpl(struct lpfc_hba *phba, struct lpfc_iocbq *pIocbIn,
 
         result = cmd->result;
         sdev = cmd->device;
+        lpfc_scsi_unprep_dma_buf(phba, lpfc_cmd);
         cmd->scsi_done(cmd);
 
         if (phba->cfg_poll & ENABLE_FCP_RING_POLLING) {
-                lpfc_scsi_unprep_dma_buf(phba, lpfc_cmd);
                 lpfc_release_scsi_buf(phba, lpfc_cmd);
                 return;
         }
@@ -527,7 +549,6 @@ lpfc_scsi_cmd_iocb_cmpl(struct lpfc_hba *phba, struct lpfc_iocbq *pIocbIn,
                 }
         }
 
-        lpfc_scsi_unprep_dma_buf(phba, lpfc_cmd);
         lpfc_release_scsi_buf(phba, lpfc_cmd);
 }
 
@@ -670,6 +691,18 @@ lpfc_scsi_prep_task_mgmt_cmd(struct lpfc_hba *phba,
         return (1);
 }
 
+static void
+lpfc_tskmgmt_def_cmpl(struct lpfc_hba *phba,
+                        struct lpfc_iocbq *cmdiocbq,
+                        struct lpfc_iocbq *rspiocbq)
+{
+        struct lpfc_scsi_buf *lpfc_cmd =
+                (struct lpfc_scsi_buf *) cmdiocbq->context1;
+        if (lpfc_cmd)
+                lpfc_release_scsi_buf(phba, lpfc_cmd);
+        return;
+}
+
 static int
 lpfc_scsi_tgt_reset(struct lpfc_scsi_buf * lpfc_cmd, struct lpfc_hba * phba,
                     unsigned  tgt_id, unsigned int lun,
@@ -706,8 +739,9 @@ lpfc_scsi_tgt_reset(struct lpfc_scsi_buf * lpfc_cmd, struct lpfc_hba * phba,
                                        &phba->sli.ring[phba->sli.fcp_ring],
                                        iocbq, iocbqrsp, lpfc_cmd->timeout);
         if (ret != IOCB_SUCCESS) {
+                if (ret == IOCB_TIMEDOUT)
+                        iocbq->iocb_cmpl = lpfc_tskmgmt_def_cmpl;
                 lpfc_cmd->status = IOSTAT_DRIVER_REJECT;
-                ret = FAILED;
         } else {
                 ret = SUCCESS;
                 lpfc_cmd->result = iocbqrsp->iocb.un.ulpWord[4];
@@ -974,7 +1008,7 @@ lpfc_abort_handler(struct scsi_cmnd *cmnd)
 }
 
 static int
-lpfc_reset_lun_handler(struct scsi_cmnd *cmnd)
+lpfc_device_reset_handler(struct scsi_cmnd *cmnd)
 {
         struct Scsi_Host *shost = cmnd->device->host;
         struct lpfc_hba *phba = (struct lpfc_hba *)shost->hostdata;
@@ -984,6 +1018,7 @@ lpfc_reset_lun_handler(struct scsi_cmnd *cmnd)
         struct lpfc_nodelist *pnode = rdata->pnode;
         uint32_t cmd_result = 0, cmd_status = 0;
         int ret = FAILED;
+        int iocb_status = IOCB_SUCCESS;
         int cnt, loopcnt;
 
         lpfc_block_error_handler(cmnd);
@@ -995,7 +1030,7 @@ lpfc_reset_lun_handler(struct scsi_cmnd *cmnd)
          */
         while ( 1 ) {
                 if (!pnode)
-                        return FAILED;
+                        goto out;
 
                 if (pnode->nlp_state != NLP_STE_MAPPED_NODE) {
                         spin_unlock_irq(phba->host->host_lock);
@@ -1013,7 +1048,7 @@ lpfc_reset_lun_handler(struct scsi_cmnd *cmnd)
                         }
                         pnode = rdata->pnode;
                         if (!pnode)
-                                return FAILED;
+                                goto out;
                 }
                 if (pnode->nlp_state == NLP_STE_MAPPED_NODE)
                         break;
@@ -1028,7 +1063,7 @@ lpfc_reset_lun_handler(struct scsi_cmnd *cmnd)
         lpfc_cmd->rdata = rdata;
 
         ret = lpfc_scsi_prep_task_mgmt_cmd(phba, lpfc_cmd, cmnd->device->lun,
-                                           FCP_LUN_RESET);
+                                           FCP_TARGET_RESET);
         if (!ret)
                 goto out_free_scsi_buf;
 
@@ -1040,16 +1075,21 @@ lpfc_reset_lun_handler(struct scsi_cmnd *cmnd)
                 goto out_free_scsi_buf;
 
         lpfc_printf_log(phba, KERN_INFO, LOG_FCP,
-                        "%d:0703 Issue LUN Reset to TGT %d LUN %d "
-                        "Data: x%x x%x\n", phba->brd_no, cmnd->device->id,
+                        "%d:0703 Issue target reset to TGT %d LUN %d rpi x%x "
+                        "nlp_flag x%x\n", phba->brd_no, cmnd->device->id,
                         cmnd->device->lun, pnode->nlp_rpi, pnode->nlp_flag);
 
-        ret = lpfc_sli_issue_iocb_wait(phba,
+        iocb_status = lpfc_sli_issue_iocb_wait(phba,
                                        &phba->sli.ring[phba->sli.fcp_ring],
                                        iocbq, iocbqrsp, lpfc_cmd->timeout);
-        if (ret == IOCB_SUCCESS)
-                ret = SUCCESS;
 
+        if (iocb_status == IOCB_TIMEDOUT)
+                iocbq->iocb_cmpl = lpfc_tskmgmt_def_cmpl;
+
+        if (iocb_status == IOCB_SUCCESS)
+                ret = SUCCESS;
+        else
+                ret = iocb_status;
 
         cmd_result = iocbqrsp->iocb.un.ulpWord[4];
         cmd_status = iocbqrsp->iocb.ulpStatus;
@@ -1087,18 +1127,19 @@ lpfc_reset_lun_handler(struct scsi_cmnd *cmnd)
 
         if (cnt) {
                 lpfc_printf_log(phba, KERN_ERR, LOG_FCP,
-                        "%d:0719 LUN Reset I/O flush failure: cnt x%x\n",
+                        "%d:0719 device reset I/O flush failure: cnt x%x\n",
                         phba->brd_no, cnt);
                 ret = FAILED;
         }
 
 out_free_scsi_buf:
-        lpfc_release_scsi_buf(phba, lpfc_cmd);
-
+        if (iocb_status != IOCB_TIMEDOUT) {
+                lpfc_release_scsi_buf(phba, lpfc_cmd);
+        }
         lpfc_printf_log(phba, KERN_ERR, LOG_FCP,
-                        "%d:0713 SCSI layer issued LUN reset (%d, %d) "
-                        "Data: x%x x%x x%x\n",
-                        phba->brd_no, cmnd->device->id,cmnd->device->lun,
+                        "%d:0713 SCSI layer issued device reset (%d, %d) "
+                        "return x%x status x%x result x%x\n",
+                        phba->brd_no, cmnd->device->id, cmnd->device->lun,
                         ret, cmd_status, cmd_result);
 
 out:
@@ -1107,7 +1148,7 @@ out:
 }
 
 static int
-lpfc_reset_bus_handler(struct scsi_cmnd *cmnd)
+lpfc_bus_reset_handler(struct scsi_cmnd *cmnd)
 {
         struct Scsi_Host *shost = cmnd->device->host;
         struct lpfc_hba *phba = (struct lpfc_hba *)shost->hostdata;
@@ -1134,10 +1175,12 @@ lpfc_reset_bus_handler(struct scsi_cmnd *cmnd)
          * fail, this routine returns failure to the midlayer.
          */
         for (i = 0; i < LPFC_MAX_TARGET; i++) {
-                /* Search the mapped list for this target ID */
+                /* Search for mapped node by target ID */
                 match = 0;
-                list_for_each_entry(ndlp, &phba->fc_nlpmap_list, nlp_listp) {
-                        if ((i == ndlp->nlp_sid) && ndlp->rport) {
+                list_for_each_entry(ndlp, &phba->fc_nodes, nlp_listp) {
+                        if (ndlp->nlp_state == NLP_STE_MAPPED_NODE &&
+                            i == ndlp->nlp_sid &&
+                            ndlp->rport) {
                                 match = 1;
                                 break;
                         }
@@ -1152,13 +1195,17 @@ lpfc_reset_bus_handler(struct scsi_cmnd *cmnd)
                                 "%d:0700 Bus Reset on target %d failed\n",
                                 phba->brd_no, i);
                         err_count++;
+                        break;
                 }
         }
 
+        if (ret != IOCB_TIMEDOUT)
+                lpfc_release_scsi_buf(phba, lpfc_cmd);
+
         if (err_count == 0)
                 ret = SUCCESS;
-
-        lpfc_release_scsi_buf(phba, lpfc_cmd);
+        else
+                ret = FAILED;
 
         /*
          * All outstanding txcmplq I/Os should have been aborted by
@@ -1299,11 +1346,13 @@ struct scsi_host_template lpfc_template = {
         .info                   = lpfc_info,
         .queuecommand           = lpfc_queuecommand,
         .eh_abort_handler       = lpfc_abort_handler,
-        .eh_device_reset_handler= lpfc_reset_lun_handler,
-        .eh_bus_reset_handler   = lpfc_reset_bus_handler,
+        .eh_device_reset_handler= lpfc_device_reset_handler,
+        .eh_bus_reset_handler   = lpfc_bus_reset_handler,
         .slave_alloc            = lpfc_slave_alloc,
         .slave_configure        = lpfc_slave_configure,
         .slave_destroy          = lpfc_slave_destroy,
+        .scan_finished          = lpfc_scan_finished,
+        .scan_start             = lpfc_scan_start,
         .this_id                = -1,
         .sg_tablesize           = LPFC_SG_SEG_CNT,
         .cmd_per_lun            = LPFC_CMD_PER_LUN,
diff --git a/drivers/scsi/lpfc/lpfc_sli.c b/drivers/scsi/lpfc/lpfc_sli.c
index 9fb6960a8ada..a1e721459e2b 100644
--- a/drivers/scsi/lpfc/lpfc_sli.c
+++ b/drivers/scsi/lpfc/lpfc_sli.c
@@ -1,7 +1,7 @@
 /*******************************************************************
  * This file is part of the Emulex Linux Device Driver for         *
  * Fibre Channel Host Bus Adapters.                                *
- * Copyright (C) 2004-2006 Emulex.  All rights reserved.           *
+ * Copyright (C) 2004-2007 Emulex.  All rights reserved.           *
  * EMULEX and SLI are trademarks of Emulex.                        *
  * www.emulex.com                                                  *
  * Portions Copyright (C) 2004-2005 Christoph Hellwig              *
@@ -528,6 +528,7 @@ lpfc_sli_wake_mbox_wait(struct lpfc_hba * phba, LPFC_MBOXQ_t * pmboxq)
          * If pdone_q is empty, the driver thread gave up waiting and
          * continued running.
          */
+        pmboxq->mbox_flag |= LPFC_MBX_WAKE;
         pdone_q = (wait_queue_head_t *) pmboxq->context1;
         if (pdone_q)
                 wake_up_interruptible(pdone_q);
@@ -538,11 +539,32 @@ void
 lpfc_sli_def_mbox_cmpl(struct lpfc_hba * phba, LPFC_MBOXQ_t * pmb)
 {
         struct lpfc_dmabuf *mp;
+        uint16_t rpi;
+        int rc;
+
         mp = (struct lpfc_dmabuf *) (pmb->context1);
+
         if (mp) {
                 lpfc_mbuf_free(phba, mp->virt, mp->phys);
                 kfree(mp);
         }
+
+        /*
+         * If a REG_LOGIN succeeded  after node is destroyed or node
+         * is in re-discovery driver need to cleanup the RPI.
+         */
+        if (!(phba->fc_flag & FC_UNLOADING) &&
+                (pmb->mb.mbxCommand == MBX_REG_LOGIN64) &&
+                (!pmb->mb.mbxStatus)) {
+
+                rpi = pmb->mb.un.varWords[0];
+                lpfc_unreg_login(phba, rpi, pmb);
+                pmb->mbox_cmpl=lpfc_sli_def_mbox_cmpl;
+                rc = lpfc_sli_issue_mbox(phba, pmb, MBX_NOWAIT);
+                if (rc != MBX_NOT_FINISHED)
+                        return;
+        }
+
         mempool_free( pmb, phba->mbox_mem_pool);
         return;
 }
@@ -693,25 +715,8 @@ lpfc_sli_handle_mb_event(struct lpfc_hba * phba)
                 } else {
                         spin_unlock_irq(phba->host->host_lock);
                         /* Turn on IOCB processing */
-                        for (i = 0; i < phba->sli.num_rings; i++) {
+                        for (i = 0; i < phba->sli.num_rings; i++)
                                 lpfc_sli_turn_on_ring(phba, i);
-                        }
-
-                        /* Free any lpfc_dmabuf's waiting for mbox cmd cmpls */
-                        while (!list_empty(&phba->freebufList)) {
-                                struct lpfc_dmabuf *mp;
-
-                                mp = NULL;
-                                list_remove_head((&phba->freebufList),
-                                                 mp,
-                                                 struct lpfc_dmabuf,
-                                                 list);
-                                if (mp) {
-                                        lpfc_mbuf_free(phba, mp->virt,
-                                                       mp->phys);
-                                        kfree(mp);
-                                }
-                        }
                 }
 
         } while (process_next);
@@ -833,6 +838,14 @@ lpfc_sli_process_sol_iocb(struct lpfc_hba * phba, struct lpfc_sli_ring * pring,
                          * All other are passed to the completion callback.
                          */
                         if (pring->ringno == LPFC_ELS_RING) {
+                                if (cmdiocbp->iocb_flag & LPFC_DRIVER_ABORTED) {
+                                        cmdiocbp->iocb_flag &=
+                                                ~LPFC_DRIVER_ABORTED;
+                                        saveq->iocb.ulpStatus =
+                                                IOSTAT_LOCAL_REJECT;
+                                        saveq->iocb.un.ulpWord[4] =
+                                                IOERR_SLI_ABORTED;
+                                }
                                 spin_unlock_irqrestore(phba->host->host_lock,
                                                        iflag);
                                 (cmdiocbp->iocb_cmpl) (phba, cmdiocbp, saveq);
@@ -1464,8 +1477,9 @@ lpfc_sli_handle_slow_ring_event(struct lpfc_hba * phba,
 int
 lpfc_sli_abort_iocb_ring(struct lpfc_hba *phba, struct lpfc_sli_ring *pring)
 {
+        LIST_HEAD(completions);
         struct lpfc_iocbq *iocb, *next_iocb;
-        IOCB_t *icmd = NULL, *cmd = NULL;
+        IOCB_t *cmd = NULL;
         int errcnt;
 
         errcnt = 0;
@@ -1474,46 +1488,28 @@ lpfc_sli_abort_iocb_ring(struct lpfc_hba *phba, struct lpfc_sli_ring *pring)
          * First do the txq.
          */
         spin_lock_irq(phba->host->host_lock);
-        list_for_each_entry_safe(iocb, next_iocb, &pring->txq, list) {
-                list_del_init(&iocb->list);
-                if (iocb->iocb_cmpl) {
-                        icmd = &iocb->iocb;
-                        icmd->ulpStatus = IOSTAT_LOCAL_REJECT;
-                        icmd->un.ulpWord[4] = IOERR_SLI_ABORTED;
-                        spin_unlock_irq(phba->host->host_lock);
-                        (iocb->iocb_cmpl) (phba, iocb, iocb);
-                        spin_lock_irq(phba->host->host_lock);
-                } else
-                        lpfc_sli_release_iocbq(phba, iocb);
-        }
+        list_splice_init(&pring->txq, &completions);
         pring->txq_cnt = 0;
-        INIT_LIST_HEAD(&(pring->txq));
 
         /* Next issue ABTS for everything on the txcmplq */
-        list_for_each_entry_safe(iocb, next_iocb, &pring->txcmplq, list) {
-                cmd = &iocb->iocb;
+        list_for_each_entry_safe(iocb, next_iocb, &pring->txcmplq, list)
+                lpfc_sli_issue_abort_iotag(phba, pring, iocb);
 
-                /*
-                 * Imediate abort of IOCB, deque and call compl
-                 */
+        spin_unlock_irq(phba->host->host_lock);
 
-                list_del_init(&iocb->list);
-                pring->txcmplq_cnt--;
+        while (!list_empty(&completions)) {
+                iocb = list_get_first(&completions, struct lpfc_iocbq, list);
+                cmd = &iocb->iocb;
+                list_del(&iocb->list);
 
                 if (iocb->iocb_cmpl) {
                         cmd->ulpStatus = IOSTAT_LOCAL_REJECT;
                         cmd->un.ulpWord[4] = IOERR_SLI_ABORTED;
-                        spin_unlock_irq(phba->host->host_lock);
                         (iocb->iocb_cmpl) (phba, iocb, iocb);
-                        spin_lock_irq(phba->host->host_lock);
                 } else
                         lpfc_sli_release_iocbq(phba, iocb);
         }
 
-        INIT_LIST_HEAD(&pring->txcmplq);
-        pring->txcmplq_cnt = 0;
-        spin_unlock_irq(phba->host->host_lock);
-
         return errcnt;
 }
 
@@ -1588,6 +1584,7 @@ void lpfc_reset_barrier(struct lpfc_hba * phba)
         hc_copy = readl(phba->HCregaddr);
         writel((hc_copy & ~HC_ERINT_ENA), phba->HCregaddr);
         readl(phba->HCregaddr); /* flush */
+        phba->fc_flag |= FC_IGNORE_ERATT;
 
         if (readl(phba->HAregaddr) & HA_ERATT) {
                 /* Clear Chip error bit */
@@ -1630,6 +1627,7 @@ clear_errat:
         }
 
 restore_hc:
+        phba->fc_flag &= ~FC_IGNORE_ERATT;
         writel(hc_copy, phba->HCregaddr);
         readl(phba->HCregaddr); /* flush */
 }
@@ -1665,6 +1663,7 @@ lpfc_sli_brdkill(struct lpfc_hba * phba)
         status &= ~HC_ERINT_ENA;
         writel(status, phba->HCregaddr);
         readl(phba->HCregaddr); /* flush */
+        phba->fc_flag |= FC_IGNORE_ERATT;
         spin_unlock_irq(phba->host->host_lock);
 
         lpfc_kill_board(phba, pmb);
@@ -1674,6 +1673,9 @@ lpfc_sli_brdkill(struct lpfc_hba * phba)
         if (retval != MBX_SUCCESS) {
                 if (retval != MBX_BUSY)
                         mempool_free(pmb, phba->mbox_mem_pool);
+                spin_lock_irq(phba->host->host_lock);
+                phba->fc_flag &= ~FC_IGNORE_ERATT;
+                spin_unlock_irq(phba->host->host_lock);
                 return 1;
         }
 
@@ -1700,6 +1702,7 @@ lpfc_sli_brdkill(struct lpfc_hba * phba)
         }
         spin_lock_irq(phba->host->host_lock);
         psli->sli_flag &= ~LPFC_SLI_MBOX_ACTIVE;
+        phba->fc_flag &= ~FC_IGNORE_ERATT;
         spin_unlock_irq(phba->host->host_lock);
 
         psli->mbox_active = NULL;
@@ -1985,42 +1988,6 @@ lpfc_sli_hba_setup_exit:
         return rc;
 }
 
-static void
-lpfc_mbox_abort(struct lpfc_hba * phba)
-{
-        LPFC_MBOXQ_t *pmbox;
-        MAILBOX_t *mb;
-
-        if (phba->sli.mbox_active) {
-                del_timer_sync(&phba->sli.mbox_tmo);
-                phba->work_hba_events &= ~WORKER_MBOX_TMO;
-                pmbox = phba->sli.mbox_active;
-                mb = &pmbox->mb;
-                phba->sli.mbox_active = NULL;
-                if (pmbox->mbox_cmpl) {
-                        mb->mbxStatus = MBX_NOT_FINISHED;
-                        (pmbox->mbox_cmpl) (phba, pmbox);
-                }
-                phba->sli.sli_flag &= ~LPFC_SLI_MBOX_ACTIVE;
-        }
-
-        /* Abort all the non active mailbox commands. */
-        spin_lock_irq(phba->host->host_lock);
-        pmbox = lpfc_mbox_get(phba);
-        while (pmbox) {
-                mb = &pmbox->mb;
-                if (pmbox->mbox_cmpl) {
-                        mb->mbxStatus = MBX_NOT_FINISHED;
-                        spin_unlock_irq(phba->host->host_lock);
-                        (pmbox->mbox_cmpl) (phba, pmbox);
-                        spin_lock_irq(phba->host->host_lock);
-                }
-                pmbox = lpfc_mbox_get(phba);
-        }
-        spin_unlock_irq(phba->host->host_lock);
-        return;
-}
-
 /*! lpfc_mbox_timeout
  *
  * \pre
@@ -2055,6 +2022,8 @@ lpfc_mbox_timeout_handler(struct lpfc_hba *phba)
 {
         LPFC_MBOXQ_t *pmbox;
         MAILBOX_t *mb;
+        struct lpfc_sli *psli = &phba->sli;
+        struct lpfc_sli_ring *pring;
 
         spin_lock_irq(phba->host->host_lock);
         if (!(phba->work_hba_events & WORKER_MBOX_TMO)) {
@@ -2062,8 +2031,6 @@ lpfc_mbox_timeout_handler(struct lpfc_hba *phba)
                 return;
         }
 
-        phba->work_hba_events &= ~WORKER_MBOX_TMO;
-
         pmbox = phba->sli.mbox_active;
         mb = &pmbox->mb;
 
@@ -2078,17 +2045,32 @@ lpfc_mbox_timeout_handler(struct lpfc_hba *phba)
                 phba->sli.sli_flag,
                 phba->sli.mbox_active);
 
-        phba->sli.mbox_active = NULL;
-        if (pmbox->mbox_cmpl) {
-                mb->mbxStatus = MBX_NOT_FINISHED;
-                spin_unlock_irq(phba->host->host_lock);
-                (pmbox->mbox_cmpl) (phba, pmbox);
-                spin_lock_irq(phba->host->host_lock);
-        }
-        phba->sli.sli_flag &= ~LPFC_SLI_MBOX_ACTIVE;
-
+        /* Setting state unknown so lpfc_sli_abort_iocb_ring
+         * would get IOCB_ERROR from lpfc_sli_issue_iocb, allowing
+         * it to fail all oustanding SCSI IO.
+         */
+        phba->hba_state = LPFC_STATE_UNKNOWN;
+        phba->work_hba_events &= ~WORKER_MBOX_TMO;
+        phba->fc_flag |= FC_ESTABLISH_LINK;
+        psli->sli_flag &= ~LPFC_SLI2_ACTIVE;
         spin_unlock_irq(phba->host->host_lock);
-        lpfc_mbox_abort(phba);
+
+        pring = &psli->ring[psli->fcp_ring];
+        lpfc_sli_abort_iocb_ring(phba, pring);
+
+        lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
+                        "%d:0316 Resetting board due to mailbox timeout\n",
+                        phba->brd_no);
+        /*
+         * lpfc_offline calls lpfc_sli_hba_down which will clean up
+         * on oustanding mailbox commands.
+         */
+        lpfc_offline_prep(phba);
+        lpfc_offline(phba);
+        lpfc_sli_brdrestart(phba);
+        if (lpfc_online(phba) == 0)             /* Initialize the HBA */
+                mod_timer(&phba->fc_estabtmo, jiffies + HZ * 60);
+        lpfc_unblock_mgmt_io(phba);
         return;
 }
 
@@ -2320,9 +2302,7 @@ lpfc_sli_issue_mbox(struct lpfc_hba * phba, LPFC_MBOXQ_t * pmbox, uint32_t flag)
                         spin_unlock_irqrestore(phba->host->host_lock,
                                                drvr_flag);
 
-                        /* Can be in interrupt context, do not sleep */
-                        /* (or might be called with interrupts disabled) */
-                        mdelay(1);
+                        msleep(1);
 
                         spin_lock_irqsave(phba->host->host_lock, drvr_flag);
 
@@ -2430,7 +2410,7 @@ lpfc_sli_issue_iocb(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
 
         if (unlikely(phba->hba_state == LPFC_LINK_DOWN)) {
                 /*
-                 * Only CREATE_XRI, CLOSE_XRI, ABORT_XRI, and QUE_RING_BUF
+                 * Only CREATE_XRI, CLOSE_XRI, and QUE_RING_BUF
                  * can be issued if the link is not up.
                  */
                 switch (piocb->iocb.ulpCommand) {
@@ -2444,6 +2424,8 @@ lpfc_sli_issue_iocb(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
                                 piocb->iocb_cmpl = NULL;
                         /*FALLTHROUGH*/
                 case CMD_CREATE_XRI_CR:
+                case CMD_CLOSE_XRI_CN:
+                case CMD_CLOSE_XRI_CX:
                         break;
                 default:
                         goto iocb_busy;
@@ -2637,11 +2619,12 @@ lpfc_sli_queue_setup(struct lpfc_hba * phba)
 int
 lpfc_sli_hba_down(struct lpfc_hba * phba)
 {
+        LIST_HEAD(completions);
         struct lpfc_sli *psli;
         struct lpfc_sli_ring *pring;
         LPFC_MBOXQ_t *pmb;
-        struct lpfc_iocbq *iocb, *next_iocb;
-        IOCB_t *icmd = NULL;
+        struct lpfc_iocbq *iocb;
+        IOCB_t *cmd = NULL;
         int i;
         unsigned long flags = 0;
 
@@ -2649,7 +2632,6 @@ lpfc_sli_hba_down(struct lpfc_hba * phba)
         lpfc_hba_down_prep(phba);
 
         spin_lock_irqsave(phba->host->host_lock, flags);
-
         for (i = 0; i < psli->num_rings; i++) {
                 pring = &psli->ring[i];
                 pring->flag |= LPFC_DEFERRED_RING_EVENT;
@@ -2658,28 +2640,25 @@ lpfc_sli_hba_down(struct lpfc_hba * phba)
                  * Error everything on the txq since these iocbs have not been
                  * given to the FW yet.
                  */
+                list_splice_init(&pring->txq, &completions);
                 pring->txq_cnt = 0;
 
-                list_for_each_entry_safe(iocb, next_iocb, &pring->txq, list) {
-                        list_del_init(&iocb->list);
-                        if (iocb->iocb_cmpl) {
-                                icmd = &iocb->iocb;
-                                icmd->ulpStatus = IOSTAT_LOCAL_REJECT;
-                                icmd->un.ulpWord[4] = IOERR_SLI_DOWN;
-                                spin_unlock_irqrestore(phba->host->host_lock,
-                                                       flags);
-                                (iocb->iocb_cmpl) (phba, iocb, iocb);
-                                spin_lock_irqsave(phba->host->host_lock, flags);
-                        } else
-                                lpfc_sli_release_iocbq(phba, iocb);
-                }
+        }
+        spin_unlock_irqrestore(phba->host->host_lock, flags);
 
-                INIT_LIST_HEAD(&(pring->txq));
+        while (!list_empty(&completions)) {
+                iocb = list_get_first(&completions, struct lpfc_iocbq, list);
+                cmd = &iocb->iocb;
+                list_del(&iocb->list);
 
+                if (iocb->iocb_cmpl) {
+                        cmd->ulpStatus = IOSTAT_LOCAL_REJECT;
+                        cmd->un.ulpWord[4] = IOERR_SLI_DOWN;
+                        (iocb->iocb_cmpl) (phba, iocb, iocb);
+                } else
+                        lpfc_sli_release_iocbq(phba, iocb);
         }
 
-        spin_unlock_irqrestore(phba->host->host_lock, flags);
-
         /* Return any active mbox cmds */
         del_timer_sync(&psli->mbox_tmo);
         spin_lock_irqsave(phba->host->host_lock, flags);
@@ -2768,85 +2747,138 @@ lpfc_sli_ringpostbuf_get(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
 }
 
 static void
-lpfc_sli_abort_elsreq_cmpl(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
-                           struct lpfc_iocbq * rspiocb)
+lpfc_sli_abort_els_cmpl(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
+                        struct lpfc_iocbq * rspiocb)
 {
-        struct lpfc_dmabuf *buf_ptr, *buf_ptr1;
-        /* Free the resources associated with the ELS_REQUEST64 IOCB the driver
-         * just aborted.
-         * In this case, context2  = cmd,  context2->next = rsp, context3 = bpl
-         */
-        if (cmdiocb->context2) {
-                buf_ptr1 = (struct lpfc_dmabuf *) cmdiocb->context2;
-
-                /* Free the response IOCB before completing the abort
-                   command.  */
-                buf_ptr = NULL;
-                list_remove_head((&buf_ptr1->list), buf_ptr,
-                                 struct lpfc_dmabuf, list);
-                if (buf_ptr) {
-                        lpfc_mbuf_free(phba, buf_ptr->virt, buf_ptr->phys);
-                        kfree(buf_ptr);
-                }
-                lpfc_mbuf_free(phba, buf_ptr1->virt, buf_ptr1->phys);
-                kfree(buf_ptr1);
-        }
+        IOCB_t *irsp;
+        uint16_t abort_iotag, abort_context;
+        struct lpfc_iocbq *abort_iocb, *rsp_ab_iocb;
+        struct lpfc_sli_ring *pring = &phba->sli.ring[LPFC_ELS_RING];
+
+        abort_iocb = NULL;
+        irsp = &rspiocb->iocb;
+
+        spin_lock_irq(phba->host->host_lock);
 
-        if (cmdiocb->context3) {
-                buf_ptr = (struct lpfc_dmabuf *) cmdiocb->context3;
-                lpfc_mbuf_free(phba, buf_ptr->virt, buf_ptr->phys);
-                kfree(buf_ptr);
+        if (irsp->ulpStatus) {
+                abort_context = cmdiocb->iocb.un.acxri.abortContextTag;
+                abort_iotag = cmdiocb->iocb.un.acxri.abortIoTag;
+
+                if (abort_iotag != 0 && abort_iotag <= phba->sli.last_iotag)
+                        abort_iocb = phba->sli.iocbq_lookup[abort_iotag];
+
+                lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
+                                "%d:0327 Cannot abort els iocb %p"
+                                " with tag %x context %x\n",
+                                phba->brd_no, abort_iocb,
+                                abort_iotag, abort_context);
+
+                /*
+                 * make sure we have the right iocbq before taking it
+                 * off the txcmplq and try to call completion routine.
+                 */
+                if (abort_iocb &&
+                    abort_iocb->iocb.ulpContext == abort_context &&
+                    abort_iocb->iocb_flag & LPFC_DRIVER_ABORTED) {
+                        list_del(&abort_iocb->list);
+                        pring->txcmplq_cnt--;
+
+                        rsp_ab_iocb = lpfc_sli_get_iocbq(phba);
+                        if (rsp_ab_iocb == NULL)
+                                lpfc_sli_release_iocbq(phba, abort_iocb);
+                        else {
+                                abort_iocb->iocb_flag &=
+                                        ~LPFC_DRIVER_ABORTED;
+                                rsp_ab_iocb->iocb.ulpStatus =
+                                        IOSTAT_LOCAL_REJECT;
+                                rsp_ab_iocb->iocb.un.ulpWord[4] =
+                                        IOERR_SLI_ABORTED;
+                                spin_unlock_irq(phba->host->host_lock);
+                                (abort_iocb->iocb_cmpl)
+                                        (phba, abort_iocb, rsp_ab_iocb);
+                                spin_lock_irq(phba->host->host_lock);
+                                lpfc_sli_release_iocbq(phba, rsp_ab_iocb);
+                        }
+                }
         }
 
         lpfc_sli_release_iocbq(phba, cmdiocb);
+        spin_unlock_irq(phba->host->host_lock);
         return;
 }
 
 int
-lpfc_sli_issue_abort_iotag32(struct lpfc_hba * phba,
-                             struct lpfc_sli_ring * pring,
-                             struct lpfc_iocbq * cmdiocb)
+lpfc_sli_issue_abort_iotag(struct lpfc_hba * phba,
+                           struct lpfc_sli_ring * pring,
+                           struct lpfc_iocbq * cmdiocb)
 {
         struct lpfc_iocbq *abtsiocbp;
         IOCB_t *icmd = NULL;
         IOCB_t *iabt = NULL;
+        int retval = IOCB_ERROR;
+
+        /* There are certain command types we don't want
+         * to abort.
+         */
+        icmd = &cmdiocb->iocb;
+        if ((icmd->ulpCommand == CMD_ABORT_XRI_CN) ||
+            (icmd->ulpCommand == CMD_CLOSE_XRI_CN))
+                return 0;
+
+        /* If we're unloading, interrupts are disabled so we
+         * need to cleanup the iocb here.
+         */
+        if (phba->fc_flag & FC_UNLOADING)
+                goto abort_iotag_exit;
 
         /* issue ABTS for this IOCB based on iotag */
         abtsiocbp = lpfc_sli_get_iocbq(phba);
         if (abtsiocbp == NULL)
                 return 0;
 
+        /* This signals the response to set the correct status
+         * before calling the completion handler.
+         */
+        cmdiocb->iocb_flag |= LPFC_DRIVER_ABORTED;
+
         iabt = &abtsiocbp->iocb;
-        icmd = &cmdiocb->iocb;
-        switch (icmd->ulpCommand) {
-        case CMD_ELS_REQUEST64_CR:
-                /* Even though we abort the ELS command, the firmware may access
-                 * the BPL or other resources before it processes our
-                 * ABORT_MXRI64. Thus we must delay reusing the cmdiocb
-                 * resources till the actual abort request completes.
-                 */
-                abtsiocbp->context1 = (void *)((unsigned long)icmd->ulpCommand);
-                abtsiocbp->context2 = cmdiocb->context2;
-                abtsiocbp->context3 = cmdiocb->context3;
-                cmdiocb->context2 = NULL;
-                cmdiocb->context3 = NULL;
-                abtsiocbp->iocb_cmpl = lpfc_sli_abort_elsreq_cmpl;
-                break;
-        default:
-                lpfc_sli_release_iocbq(phba, abtsiocbp);
-                return 0;
-        }
+        iabt->un.acxri.abortType = ABORT_TYPE_ABTS;
+        iabt->un.acxri.abortContextTag = icmd->ulpContext;
+        iabt->un.acxri.abortIoTag = icmd->ulpIoTag;
+        iabt->ulpLe = 1;
+        iabt->ulpClass = icmd->ulpClass;
 
-        iabt->un.amxri.abortType = ABORT_TYPE_ABTS;
-        iabt->un.amxri.iotag32 = icmd->un.elsreq64.bdl.ulpIoTag32;
+        if (phba->hba_state >= LPFC_LINK_UP)
+                iabt->ulpCommand = CMD_ABORT_XRI_CN;
+        else
+                iabt->ulpCommand = CMD_CLOSE_XRI_CN;
 
-        iabt->ulpLe = 1;
-        iabt->ulpClass = CLASS3;
-        iabt->ulpCommand = CMD_ABORT_MXRI64_CN;
+        abtsiocbp->iocb_cmpl = lpfc_sli_abort_els_cmpl;
 
-        if (lpfc_sli_issue_iocb(phba, pring, abtsiocbp, 0) == IOCB_ERROR) {
-                lpfc_sli_release_iocbq(phba, abtsiocbp);
-                return 0;
+        lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
+                        "%d:0339 Abort xri x%x, original iotag x%x, abort "
+                        "cmd iotag x%x\n",
+                        phba->brd_no, iabt->un.acxri.abortContextTag,
+                        iabt->un.acxri.abortIoTag, abtsiocbp->iotag);
+        retval = lpfc_sli_issue_iocb(phba, pring, abtsiocbp, 0);
+
+abort_iotag_exit:
+
+        /* If we could not issue an abort dequeue the iocb and handle
+         * the completion here.
+         */
+        if (retval == IOCB_ERROR) {
+                list_del(&cmdiocb->list);
+                pring->txcmplq_cnt--;
+
+                if (cmdiocb->iocb_cmpl) {
+                        icmd->ulpStatus = IOSTAT_LOCAL_REJECT;
+                        icmd->un.ulpWord[4] = IOERR_SLI_ABORTED;
+                        spin_unlock_irq(phba->host->host_lock);
+                        (cmdiocb->iocb_cmpl) (phba, cmdiocb, cmdiocb);
+                        spin_lock_irq(phba->host->host_lock);
+                } else
+                        lpfc_sli_release_iocbq(phba, cmdiocb);
         }
 
         return 1;
@@ -2918,9 +2950,11 @@ void
 lpfc_sli_abort_fcp_cmpl(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
                            struct lpfc_iocbq * rspiocb)
 {
-        spin_lock_irq(phba->host->host_lock);
+        unsigned long iflags;
+
+        spin_lock_irqsave(phba->host->host_lock, iflags);
         lpfc_sli_release_iocbq(phba, cmdiocb);
-        spin_unlock_irq(phba->host->host_lock);
+        spin_unlock_irqrestore(phba->host->host_lock, iflags);
         return;
 }
 
@@ -3043,22 +3077,22 @@ lpfc_sli_issue_iocb_wait(struct lpfc_hba * phba,
                                 timeout_req);
                 spin_lock_irq(phba->host->host_lock);
 
-                if (timeleft == 0) {
+                if (piocb->iocb_flag & LPFC_IO_WAKE) {
+                        lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
+                                        "%d:0331 IOCB wake signaled\n",
+                                        phba->brd_no);
+                } else if (timeleft == 0) {
                         lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
                                         "%d:0338 IOCB wait timeout error - no "
                                         "wake response Data x%x\n",
                                         phba->brd_no, timeout);
                         retval = IOCB_TIMEDOUT;
-                } else if (!(piocb->iocb_flag & LPFC_IO_WAKE)) {
+                } else {
                         lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
                                         "%d:0330 IOCB wake NOT set, "
                                         "Data x%x x%lx\n", phba->brd_no,
                                         timeout, (timeleft / jiffies));
                         retval = IOCB_TIMEDOUT;
-                } else {
-                        lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
-                                        "%d:0331 IOCB wake signaled\n",
-                                        phba->brd_no);
                 }
         } else {
                 lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
@@ -3087,8 +3121,6 @@ lpfc_sli_issue_mbox_wait(struct lpfc_hba * phba, LPFC_MBOXQ_t * pmboxq,
                          uint32_t timeout)
 {
         DECLARE_WAIT_QUEUE_HEAD_ONSTACK(done_q);
-        DECLARE_WAITQUEUE(wq_entry, current);
-        uint32_t timeleft = 0;
         int retval;
 
         /* The caller must leave context1 empty. */
@@ -3101,27 +3133,25 @@ lpfc_sli_issue_mbox_wait(struct lpfc_hba * phba, LPFC_MBOXQ_t * pmboxq,
         /* setup context field to pass wait_queue pointer to wake function  */
         pmboxq->context1 = &done_q;
 
-        /* start to sleep before we wait, to avoid races */
-        set_current_state(TASK_INTERRUPTIBLE);
-        add_wait_queue(&done_q, &wq_entry);
-
         /* now issue the command */
         retval = lpfc_sli_issue_mbox(phba, pmboxq, MBX_NOWAIT);
 
         if (retval == MBX_BUSY || retval == MBX_SUCCESS) {
-                timeleft = schedule_timeout(timeout * HZ);
+                wait_event_interruptible_timeout(done_q,
+                                pmboxq->mbox_flag & LPFC_MBX_WAKE,
+                                timeout * HZ);
+
                 pmboxq->context1 = NULL;
-                /* if schedule_timeout returns 0, we timed out and were not
-                   woken up */
-                if ((timeleft == 0) || signal_pending(current))
-                        retval = MBX_TIMEOUT;
-                else
+                /*
+                 * if LPFC_MBX_WAKE flag is set the mailbox is completed
+                 * else do not free the resources.
+                 */
+                if (pmboxq->mbox_flag & LPFC_MBX_WAKE)
                         retval = MBX_SUCCESS;
+                else
+                        retval = MBX_TIMEOUT;
         }
 
-
-        set_current_state(TASK_RUNNING);
-        remove_wait_queue(&done_q, &wq_entry);
         return retval;
 }
 
@@ -3184,6 +3214,11 @@ lpfc_intr_handler(int irq, void *dev_id)
          */
         spin_lock(phba->host->host_lock);
         ha_copy = readl(phba->HAregaddr);
+        /* If somebody is waiting to handle an eratt don't process it
+         * here.  The brdkill function will do this.
+         */
+        if (phba->fc_flag & FC_IGNORE_ERATT)
+                ha_copy &= ~HA_ERATT;
         writel((ha_copy & ~(HA_LATT | HA_ERATT)), phba->HAregaddr);
         readl(phba->HAregaddr); /* flush */
         spin_unlock(phba->host->host_lock);
diff --git a/drivers/scsi/lpfc/lpfc_sli.h b/drivers/scsi/lpfc/lpfc_sli.h
index a43549959dc7..41c38d324ab0 100644
--- a/drivers/scsi/lpfc/lpfc_sli.h
+++ b/drivers/scsi/lpfc/lpfc_sli.h
@@ -1,7 +1,7 @@
 /*******************************************************************
  * This file is part of the Emulex Linux Device Driver for         *
  * Fibre Channel Host Bus Adapters.                                *
- * Copyright (C) 2004-2006 Emulex.  All rights reserved.           *
+ * Copyright (C) 2004-2007 Emulex.  All rights reserved.           *
  * EMULEX and SLI are trademarks of Emulex.                        *
  * www.emulex.com                                                  *
  *                                                                 *
@@ -39,9 +39,10 @@ struct lpfc_iocbq {
         IOCB_t iocb;            /* IOCB cmd */
         uint8_t retry;          /* retry counter for IOCB cmd - if needed */
         uint8_t iocb_flag;
-#define LPFC_IO_LIBDFC  1       /* libdfc iocb */
-#define LPFC_IO_WAKE    2       /* High Priority Queue signal flag */
-#define LPFC_IO_FCP     4       /* FCP command -- iocbq in scsi_buf */
+#define LPFC_IO_LIBDFC          1       /* libdfc iocb */
+#define LPFC_IO_WAKE            2       /* High Priority Queue signal flag */
+#define LPFC_IO_FCP             4       /* FCP command -- iocbq in scsi_buf */
+#define LPFC_DRIVER_ABORTED     8       /* driver aborted this request */
 
         uint8_t abort_count;
         uint8_t rsvd2;
@@ -67,6 +68,8 @@ struct lpfc_iocbq {
 #define IOCB_ERROR          2
 #define IOCB_TIMEDOUT       3
 
+#define LPFC_MBX_WAKE   1
+
 typedef struct lpfcMboxq {
         /* MBOXQs are used in single linked lists */
         struct list_head list;  /* ptr to next mailbox command */
@@ -75,6 +78,7 @@ typedef struct lpfcMboxq {
         void *context2;         /* caller context information */
 
         void (*mbox_cmpl) (struct lpfc_hba *, struct lpfcMboxq *);
+        uint8_t mbox_flag;
 
 } LPFC_MBOXQ_t;
 
diff --git a/drivers/scsi/lpfc/lpfc_version.h b/drivers/scsi/lpfc/lpfc_version.h
index a61ef3d1e7f1..92a9107019d2 100644
--- a/drivers/scsi/lpfc/lpfc_version.h
+++ b/drivers/scsi/lpfc/lpfc_version.h
@@ -1,7 +1,7 @@
 /*******************************************************************
  * This file is part of the Emulex Linux Device Driver for         *
  * Fibre Channel Host Bus Adapters.                                *
- * Copyright (C) 2004-2006 Emulex.  All rights reserved.           *
+ * Copyright (C) 2004-2007 Emulex.  All rights reserved.           *
  * EMULEX and SLI are trademarks of Emulex.                        *
  * www.emulex.com                                                  *
  *                                                                 *
@@ -18,12 +18,12 @@
  * included with this package.                                     *
  *******************************************************************/
 
-#define LPFC_DRIVER_VERSION "8.1.11"
+#define LPFC_DRIVER_VERSION "8.1.12"
 
 #define LPFC_DRIVER_NAME "lpfc"
 
 #define LPFC_MODULE_DESC "Emulex LightPulse Fibre Channel SCSI driver " \
                 LPFC_DRIVER_VERSION
-#define LPFC_COPYRIGHT "Copyright(c) 2004-2006 Emulex.  All rights reserved."
+#define LPFC_COPYRIGHT "Copyright(c) 2004-2007 Emulex.  All rights reserved."
 
 #define DFC_API_VERSION "0.0.0"
diff --git a/drivers/scsi/megaraid.c b/drivers/scsi/megaraid.c
index 7fc6e06ea7e1..3cce75d70263 100644
--- a/drivers/scsi/megaraid.c
+++ b/drivers/scsi/megaraid.c
@@ -1754,7 +1754,8 @@ __mega_busywait_mbox (adapter_t *adapter)
         for (counter = 0; counter < 10000; counter++) {
                 if (!mbox->m_in.busy)
                         return 0;
-                udelay(100); yield();
+                udelay(100);
+                cond_resched();
         }
         return -1;              /* give up after 1 second */
 }
@@ -3177,7 +3178,10 @@ proc_rdrv(adapter_t *adapter, char *page, int start, int end )
 
         return len;
 }
-
+#else
+static inline void mega_create_proc_entry(int index, struct proc_dir_entry *parent)
+{
+}
 #endif
 
 
@@ -4342,7 +4346,7 @@ mega_support_cluster(adapter_t *adapter)
         return 0;
 }
 
-
+#ifdef CONFIG_PROC_FS
 /**
  * mega_adapinq()
  * @adapter - pointer to our soft state
@@ -4447,7 +4451,7 @@ mega_internal_dev_inquiry(adapter_t *adapter, u8 ch, u8 tgt,
 
         return rval;
 }
-
+#endif
 
 /**
  * mega_internal_command()
@@ -4965,7 +4969,6 @@ megaraid_remove_one(struct pci_dev *pdev)
 {
         struct Scsi_Host *host = pci_get_drvdata(pdev);
         adapter_t *adapter = (adapter_t *)host->hostdata;
-        char    buf[12] = { 0 };
 
         scsi_remove_host(host);
 
@@ -5011,8 +5014,11 @@ megaraid_remove_one(struct pci_dev *pdev)
                 remove_proc_entry("raiddrives-30-39",
                                 adapter->controller_proc_dir_entry);
 #endif
-                sprintf(buf, "hba%d", adapter->host->host_no);
-                remove_proc_entry(buf, mega_proc_dir_entry);
+                {
+                        char    buf[12] = { 0 };
+                        sprintf(buf, "hba%d", adapter->host->host_no);
+                        remove_proc_entry(buf, mega_proc_dir_entry);
+                }
         }
 #endif
 
diff --git a/drivers/scsi/megaraid.h b/drivers/scsi/megaraid.h
index c6e74643abe2..ee70bd4ae4ba 100644
--- a/drivers/scsi/megaraid.h
+++ b/drivers/scsi/megaraid.h
@@ -1002,7 +1002,6 @@ static int megaraid_reset(Scsi_Cmnd *);
 static int megaraid_abort_and_reset(adapter_t *, Scsi_Cmnd *, int);
 static int megaraid_biosparam(struct scsi_device *, struct block_device *,
                 sector_t, int []);
-static int mega_print_inquiry(char *, char *);
 
 static int mega_build_sglist (adapter_t *adapter, scb_t *scb,
                               u32 *buffer, u32 *length);
@@ -1024,6 +1023,7 @@ static int mega_init_scb (adapter_t *);
 static int mega_is_bios_enabled (adapter_t *);
 
 #ifdef CONFIG_PROC_FS
+static int mega_print_inquiry(char *, char *);
 static void mega_create_proc_entry(int, struct proc_dir_entry *);
 static int proc_read_config(char *, char **, off_t, int, int *, void *);
 static int proc_read_stat(char *, char **, off_t, int, int *, void *);
@@ -1040,10 +1040,10 @@ static int proc_rdrv_20(char *, char **, off_t, int, int *, void *);
 static int proc_rdrv_30(char *, char **, off_t, int, int *, void *);
 static int proc_rdrv_40(char *, char **, off_t, int, int *, void *);
 static int proc_rdrv(adapter_t *, char *, int, int);
-#endif
 
 static int mega_adapinq(adapter_t *, dma_addr_t);
 static int mega_internal_dev_inquiry(adapter_t *, u8, u8, dma_addr_t);
+#endif
 
 static int mega_support_ext_cdb(adapter_t *);
 static mega_passthru* mega_prepare_passthru(adapter_t *, scb_t *,
diff --git a/drivers/scsi/megaraid/megaraid_mm.c b/drivers/scsi/megaraid/megaraid_mm.c
index f33a678f0897..e075a52ac104 100644
--- a/drivers/scsi/megaraid/megaraid_mm.c
+++ b/drivers/scsi/megaraid/megaraid_mm.c
@@ -60,7 +60,7 @@ EXPORT_SYMBOL(mraid_mm_unregister_adp);
 EXPORT_SYMBOL(mraid_mm_adapter_app_handle);
 
 static int majorno;
-static uint32_t drvr_ver        = 0x02200206;
+static uint32_t drvr_ver        = 0x02200207;
 
 static int adapters_count_g;
 static struct list_head adapters_list_g;
diff --git a/drivers/scsi/mesh.c b/drivers/scsi/mesh.c
index cf3666d7d97a..e64d1a19d8d7 100644
--- a/drivers/scsi/mesh.c
+++ b/drivers/scsi/mesh.c
@@ -185,7 +185,7 @@ struct mesh_state {
  * Driver is too messy, we need a few prototypes...
  */
 static void mesh_done(struct mesh_state *ms, int start_next);
-static void mesh_interrupt(int irq, void *dev_id);
+static void mesh_interrupt(struct mesh_state *ms);
 static void cmd_complete(struct mesh_state *ms);
 static void set_dma_cmds(struct mesh_state *ms, struct scsi_cmnd *cmd);
 static void halt_dma(struct mesh_state *ms);
@@ -466,7 +466,7 @@ static void mesh_start_cmd(struct mesh_state *ms, struct scsi_cmnd *cmd)
                                 dlog(ms, "intr b4 arb, intr/exc/err/fc=%.8x",
                                      MKWORD(mr->interrupt, mr->exception,
                                             mr->error, mr->fifo_count));
-                                mesh_interrupt(0, (void *)ms);
+                                mesh_interrupt(ms);
                                 if (ms->phase != arbitrating)
                                         return;
                         }
@@ -504,7 +504,7 @@ static void mesh_start_cmd(struct mesh_state *ms, struct scsi_cmnd *cmd)
                 dlog(ms, "intr after disresel, intr/exc/err/fc=%.8x",
                      MKWORD(mr->interrupt, mr->exception,
                             mr->error, mr->fifo_count));
-                mesh_interrupt(0, (void *)ms);
+                mesh_interrupt(ms);
                 if (ms->phase != arbitrating)
                         return;
                 dlog(ms, "after intr after disresel, intr/exc/err/fc=%.8x",
@@ -1018,10 +1018,11 @@ static void handle_reset(struct mesh_state *ms)
 static irqreturn_t do_mesh_interrupt(int irq, void *dev_id)
 {
         unsigned long flags;
-        struct Scsi_Host *dev = ((struct mesh_state *)dev_id)->host;
+        struct mesh_state *ms = dev_id;
+        struct Scsi_Host *dev = ms->host;
         
         spin_lock_irqsave(dev->host_lock, flags);
-        mesh_interrupt(irq, dev_id);
+        mesh_interrupt(ms);
         spin_unlock_irqrestore(dev->host_lock, flags);
         return IRQ_HANDLED;
 }
@@ -1661,9 +1662,8 @@ static int mesh_queue(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *))
  * handler (do_mesh_interrupt) or by other functions in
  * exceptional circumstances
  */
-static void mesh_interrupt(int irq, void *dev_id)
+static void mesh_interrupt(struct mesh_state *ms)
 {
-        struct mesh_state *ms = (struct mesh_state *) dev_id;
         volatile struct mesh_regs __iomem *mr = ms->mesh;
         int intr;
 
diff --git a/drivers/scsi/qla1280.c b/drivers/scsi/qla1280.c
index 6777e8a69153..54d8bdf86852 100644
--- a/drivers/scsi/qla1280.c
+++ b/drivers/scsi/qla1280.c
@@ -4293,7 +4293,7 @@ qla1280_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
         ha->devnum = devnum;    /* specifies microcode load address */
 
 #ifdef QLA_64BIT_PTR
-        if (pci_set_dma_mask(ha->pdev, (dma_addr_t) ~ 0ULL)) {
+        if (pci_set_dma_mask(ha->pdev, DMA_64BIT_MASK)) {
                 if (pci_set_dma_mask(ha->pdev, DMA_32BIT_MASK)) {
                         printk(KERN_WARNING "scsi(%li): Unable to set a "
                                "suitable DMA mask - aborting\n", ha->host_no);
diff --git a/drivers/scsi/qla2xxx/qla_init.c b/drivers/scsi/qla2xxx/qla_init.c
index 3e296ab845b6..2a45aec4ff29 100644
--- a/drivers/scsi/qla2xxx/qla_init.c
+++ b/drivers/scsi/qla2xxx/qla_init.c
@@ -13,7 +13,6 @@
 
 #ifdef CONFIG_SPARC
 #include <asm/prom.h>
-#include <asm/pbm.h>
 #endif
 
 /* XXX(hch): this is ugly, but we don't want to pull in exioctl.h */
@@ -130,18 +129,17 @@ qla2x00_initialize_adapter(scsi_qla_host_t *ha)
 int
 qla2100_pci_config(scsi_qla_host_t *ha)
 {
-        uint16_t w, mwi;
+        int ret;
+        uint16_t w;
         uint32_t d;
         unsigned long flags;
         struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
 
         pci_set_master(ha->pdev);
-        mwi = 0;
-        if (pci_set_mwi(ha->pdev))
-                mwi = PCI_COMMAND_INVALIDATE;
+        ret = pci_set_mwi(ha->pdev);
 
         pci_read_config_word(ha->pdev, PCI_COMMAND, &w);
-        w |= mwi | (PCI_COMMAND_PARITY | PCI_COMMAND_SERR);
+        w |= (PCI_COMMAND_PARITY | PCI_COMMAND_SERR);
         pci_write_config_word(ha->pdev, PCI_COMMAND, w);
 
         /* Reset expansion ROM address decode enable */
@@ -166,22 +164,22 @@ qla2100_pci_config(scsi_qla_host_t *ha)
 int
 qla2300_pci_config(scsi_qla_host_t *ha)
 {
-        uint16_t        w, mwi;
+        int             ret;
+        uint16_t        w;
         uint32_t        d;
         unsigned long   flags = 0;
         uint32_t        cnt;
         struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
 
         pci_set_master(ha->pdev);
-        mwi = 0;
-        if (pci_set_mwi(ha->pdev))
-                mwi = PCI_COMMAND_INVALIDATE;
+        ret = pci_set_mwi(ha->pdev);
 
         pci_read_config_word(ha->pdev, PCI_COMMAND, &w);
-        w |= mwi | (PCI_COMMAND_PARITY | PCI_COMMAND_SERR);
+        w |= (PCI_COMMAND_PARITY | PCI_COMMAND_SERR);
 
         if (IS_QLA2322(ha) || IS_QLA6322(ha))
                 w &= ~PCI_COMMAND_INTX_DISABLE;
+        pci_write_config_word(ha->pdev, PCI_COMMAND, w);
 
         /*
          * If this is a 2300 card and not 2312, reset the
@@ -210,7 +208,7 @@ qla2300_pci_config(scsi_qla_host_t *ha)
                 ha->fb_rev = RD_FB_CMD_REG(ha, reg);
 
                 if (ha->fb_rev == FPM_2300)
-                        w &= ~PCI_COMMAND_INVALIDATE;
+                        pci_clear_mwi(ha->pdev);
 
                 /* Deselect FPM registers. */
                 WRT_REG_WORD(&reg->ctrl_status, 0x0);
@@ -227,7 +225,6 @@ qla2300_pci_config(scsi_qla_host_t *ha)
 
                 spin_unlock_irqrestore(&ha->hardware_lock, flags);
         }
-        pci_write_config_word(ha->pdev, PCI_COMMAND, w);
 
         pci_write_config_byte(ha->pdev, PCI_LATENCY_TIMER, 0x80);
 
@@ -253,19 +250,18 @@ qla2300_pci_config(scsi_qla_host_t *ha)
 int
 qla24xx_pci_config(scsi_qla_host_t *ha)
 {
-        uint16_t w, mwi;
+        int ret;
+        uint16_t w;
         uint32_t d;
         unsigned long flags = 0;
         struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;
         int pcix_cmd_reg, pcie_dctl_reg;
 
         pci_set_master(ha->pdev);
-        mwi = 0;
-        if (pci_set_mwi(ha->pdev))
-                mwi = PCI_COMMAND_INVALIDATE;
+        ret = pci_set_mwi(ha->pdev);
 
         pci_read_config_word(ha->pdev, PCI_COMMAND, &w);
-        w |= mwi | (PCI_COMMAND_PARITY | PCI_COMMAND_SERR);
+        w |= (PCI_COMMAND_PARITY | PCI_COMMAND_SERR);
         w &= ~PCI_COMMAND_INTX_DISABLE;
         pci_write_config_word(ha->pdev, PCI_COMMAND, w);
 
@@ -1400,9 +1396,8 @@ static void qla2xxx_nvram_wwn_from_ofw(scsi_qla_host_t *ha, nvram_t *nv)
 {
 #ifdef CONFIG_SPARC
         struct pci_dev *pdev = ha->pdev;
-        struct pcidev_cookie *pcp = pdev->sysdata;
-        struct device_node *dp = pcp->prom_node;
-        u8 *val;
+        struct device_node *dp = pci_device_to_OF_node(pdev);
+        const u8 *val;
         int len;
 
         val = of_get_property(dp, "port-wwn", &len);
@@ -3373,9 +3368,8 @@ static void qla24xx_nvram_wwn_from_ofw(scsi_qla_host_t *ha, struct nvram_24xx *n
 {
 #ifdef CONFIG_SPARC
         struct pci_dev *pdev = ha->pdev;
-        struct pcidev_cookie *pcp = pdev->sysdata;
-        struct device_node *dp = pcp->prom_node;
-        u8 *val;
+        struct device_node *dp = pci_device_to_OF_node(pdev);
+        const u8 *val;
         int len;
 
         val = of_get_property(dp, "port-wwn", &len);
@@ -3931,6 +3925,8 @@ qla2x00_try_to_stop_firmware(scsi_qla_host_t *ha)
 
         if (!IS_QLA24XX(ha) && !IS_QLA54XX(ha))
                 return;
+        if (!ha->fw_major_version)
+                return;
 
         ret = qla2x00_stop_firmware(ha);
         for (retries = 5; ret != QLA_SUCCESS && retries ; retries--) {
diff --git a/drivers/scsi/qla2xxx/qla_isr.c b/drivers/scsi/qla2xxx/qla_isr.c
index d4885616cd39..ca463469063d 100644
--- a/drivers/scsi/qla2xxx/qla_isr.c
+++ b/drivers/scsi/qla2xxx/qla_isr.c
@@ -1726,6 +1726,17 @@ qla2x00_request_irqs(scsi_qla_host_t *ha)
         qla_printk(KERN_WARNING, ha,
             "MSI-X: Falling back-to INTa mode -- %d.\n", ret);
 skip_msix:
+
+        if (!IS_QLA24XX(ha))
+                goto skip_msi;
+
+        ret = pci_enable_msi(ha->pdev);
+        if (!ret) {
+                DEBUG2(qla_printk(KERN_INFO, ha, "MSI: Enabled.\n"));
+                ha->flags.msi_enabled = 1;
+        }
+skip_msi:
+
         ret = request_irq(ha->pdev->irq, ha->isp_ops.intr_handler,
             IRQF_DISABLED|IRQF_SHARED, QLA2XXX_DRIVER_NAME, ha);
         if (!ret) {
@@ -1746,6 +1757,8 @@ qla2x00_free_irqs(scsi_qla_host_t *ha)
 
         if (ha->flags.msix_enabled)
                 qla24xx_disable_msix(ha);
-        else if (ha->flags.inta_enabled)
+        else if (ha->flags.inta_enabled) {
                 free_irq(ha->host->irq, ha);
+                pci_disable_msi(ha->pdev);
+        }
 }
diff --git a/drivers/scsi/qla2xxx/qla_os.c b/drivers/scsi/qla2xxx/qla_os.c
index b78919a318e2..dd076da86a46 100644
--- a/drivers/scsi/qla2xxx/qla_os.c
+++ b/drivers/scsi/qla2xxx/qla_os.c
@@ -36,7 +36,7 @@ module_param(ql2xlogintimeout, int, S_IRUGO|S_IRUSR);
 MODULE_PARM_DESC(ql2xlogintimeout,
                 "Login timeout value in seconds.");
 
-int qlport_down_retry = 30;
+int qlport_down_retry;
 module_param(qlport_down_retry, int, S_IRUGO|S_IRUSR);
 MODULE_PARM_DESC(qlport_down_retry,
                 "Maximum number of command retries to a port that returns "
@@ -1577,9 +1577,7 @@ qla2x00_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
                 goto probe_failed;
         }
 
-        if (qla2x00_initialize_adapter(ha) &&
-            !(ha->device_flags & DFLG_NO_CABLE)) {
-
+        if (qla2x00_initialize_adapter(ha)) {
                 qla_printk(KERN_WARNING, ha,
                     "Failed to initialize adapter\n");
 
diff --git a/drivers/scsi/qla2xxx/qla_version.h b/drivers/scsi/qla2xxx/qla_version.h
index dc85495c337f..c375a4efbc71 100644
--- a/drivers/scsi/qla2xxx/qla_version.h
+++ b/drivers/scsi/qla2xxx/qla_version.h
@@ -7,7 +7,7 @@
 /*
  * Driver version
  */
-#define QLA2XXX_VERSION      "8.01.07-k6"
+#define QLA2XXX_VERSION      "8.01.07-k7"
 
 #define QLA_DRIVER_MAJOR_VER    8
 #define QLA_DRIVER_MINOR_VER    1
diff --git a/drivers/scsi/qla4xxx/ql4_dbg.c b/drivers/scsi/qla4xxx/ql4_dbg.c
index 7b4e077a39c1..6437d024b0dd 100644
--- a/drivers/scsi/qla4xxx/ql4_dbg.c
+++ b/drivers/scsi/qla4xxx/ql4_dbg.c
@@ -8,6 +8,8 @@
 #include "ql4_def.h"
 #include <scsi/scsi_dbg.h>
 
+#if 0
+
 static void qla4xxx_print_srb_info(struct srb * srb)
 {
         printk("%s: srb = 0x%p, flags=0x%02x\n", __func__, srb, srb->flags);
@@ -195,3 +197,5 @@ void qla4xxx_dump_buffer(void *b, uint32_t size)
         if (cnt % 16)
                 printk(KERN_DEBUG "\n");
 }
+
+#endif  /*  0  */
diff --git a/drivers/scsi/qla4xxx/ql4_glbl.h b/drivers/scsi/qla4xxx/ql4_glbl.h
index e021eb5db2b2..5b00cb04e7c0 100644
--- a/drivers/scsi/qla4xxx/ql4_glbl.h
+++ b/drivers/scsi/qla4xxx/ql4_glbl.h
@@ -43,8 +43,6 @@ int qla4xxx_get_fwddb_entry(struct scsi_qla_host *ha,
                             uint16_t *tcp_source_port_num,
                             uint16_t *connection_id);
 
-struct ddb_entry * qla4xxx_alloc_ddb(struct scsi_qla_host * ha,
-                                     uint32_t fw_ddb_index);
 int qla4xxx_set_ddb_entry(struct scsi_qla_host * ha, uint16_t fw_ddb_index,
                           dma_addr_t fw_ddb_entry_dma);
 
@@ -55,18 +53,11 @@ void qla4xxx_get_crash_record(struct scsi_qla_host * ha);
 struct ddb_entry *qla4xxx_alloc_sess(struct scsi_qla_host *ha);
 int qla4xxx_add_sess(struct ddb_entry *);
 void qla4xxx_destroy_sess(struct ddb_entry *ddb_entry);
-int qla4xxx_conn_close_sess_logout(struct scsi_qla_host * ha,
-                                   uint16_t fw_ddb_index,
-                                   uint16_t connection_id,
-                                   uint16_t option);
-int qla4xxx_clear_database_entry(struct scsi_qla_host * ha,
-                                 uint16_t fw_ddb_index);
 int qla4xxx_is_nvram_configuration_valid(struct scsi_qla_host * ha);
 int qla4xxx_get_fw_version(struct scsi_qla_host * ha);
 void qla4xxx_interrupt_service_routine(struct scsi_qla_host * ha,
                                        uint32_t intr_status);
 int qla4xxx_init_rings(struct scsi_qla_host * ha);
-void qla4xxx_dump_buffer(void *b, uint32_t size);
 struct srb * qla4xxx_del_from_active_array(struct scsi_qla_host *ha, uint32_t index);
 void qla4xxx_srb_compl(struct scsi_qla_host *ha, struct srb *srb);
 int qla4xxx_reinitialize_ddb_list(struct scsi_qla_host * ha);
diff --git a/drivers/scsi/qla4xxx/ql4_init.c b/drivers/scsi/qla4xxx/ql4_init.c
index b907b06d72ab..6365df268612 100644
--- a/drivers/scsi/qla4xxx/ql4_init.c
+++ b/drivers/scsi/qla4xxx/ql4_init.c
@@ -7,9 +7,8 @@
 
 #include "ql4_def.h"
 
-/*
- * QLogic ISP4xxx Hardware Support Function Prototypes.
- */
+static struct ddb_entry * qla4xxx_alloc_ddb(struct scsi_qla_host *ha,
+                                            uint32_t fw_ddb_index);
 
 static void ql4xxx_set_mac_number(struct scsi_qla_host *ha)
 {
@@ -48,7 +47,8 @@ static void ql4xxx_set_mac_number(struct scsi_qla_host *ha)
  * This routine deallocates and unlinks the specified ddb_entry from the
  * adapter's
  **/
-void qla4xxx_free_ddb(struct scsi_qla_host *ha, struct ddb_entry *ddb_entry)
+static void qla4xxx_free_ddb(struct scsi_qla_host *ha,
+                             struct ddb_entry *ddb_entry)
 {
         /* Remove device entry from list */
         list_del_init(&ddb_entry->list);
@@ -370,9 +370,9 @@ static struct ddb_entry* qla4xxx_get_ddb_entry(struct scsi_qla_host *ha,
  * must be initialized prior to calling this routine
  *
  **/
-int qla4xxx_update_ddb_entry(struct scsi_qla_host *ha,
-                             struct ddb_entry *ddb_entry,
-                             uint32_t fw_ddb_index)
+static int qla4xxx_update_ddb_entry(struct scsi_qla_host *ha,
+                                    struct ddb_entry *ddb_entry,
+                                    uint32_t fw_ddb_index)
 {
         struct dev_db_entry *fw_ddb_entry = NULL;
         dma_addr_t fw_ddb_entry_dma;
@@ -450,8 +450,8 @@ int qla4xxx_update_ddb_entry(struct scsi_qla_host *ha,
  * This routine allocates a ddb_entry, ititializes some values, and
  * inserts it into the ddb list.
  **/
-struct ddb_entry * qla4xxx_alloc_ddb(struct scsi_qla_host *ha,
-                                     uint32_t fw_ddb_index)
+static struct ddb_entry * qla4xxx_alloc_ddb(struct scsi_qla_host *ha,
+                                            uint32_t fw_ddb_index)
 {
         struct ddb_entry *ddb_entry;
 
diff --git a/drivers/scsi/qla4xxx/ql4_iocb.c b/drivers/scsi/qla4xxx/ql4_iocb.c
index d41ce380eedc..a216a1781afb 100644
--- a/drivers/scsi/qla4xxx/ql4_iocb.c
+++ b/drivers/scsi/qla4xxx/ql4_iocb.c
@@ -19,8 +19,8 @@
  *      - advances the request_in pointer
  *      - checks for queue full
  **/
-int qla4xxx_get_req_pkt(struct scsi_qla_host *ha,
-                        struct queue_entry **queue_entry)
+static int qla4xxx_get_req_pkt(struct scsi_qla_host *ha,
+                               struct queue_entry **queue_entry)
 {
         uint16_t request_in;
         uint8_t status = QLA_SUCCESS;
@@ -62,8 +62,8 @@ int qla4xxx_get_req_pkt(struct scsi_qla_host *ha,
  *
  * This routine issues a marker IOCB.
  **/
-int qla4xxx_send_marker_iocb(struct scsi_qla_host *ha,
-                             struct ddb_entry *ddb_entry, int lun)
+static int qla4xxx_send_marker_iocb(struct scsi_qla_host *ha,
+                                    struct ddb_entry *ddb_entry, int lun)
 {
         struct marker_entry *marker_entry;
         unsigned long flags = 0;
@@ -96,7 +96,7 @@ exit_send_marker:
         return status;
 }
 
-struct continuation_t1_entry* qla4xxx_alloc_cont_entry(
+static struct continuation_t1_entry* qla4xxx_alloc_cont_entry(
         struct scsi_qla_host *ha)
 {
         struct continuation_t1_entry *cont_entry;
@@ -120,7 +120,7 @@ struct continuation_t1_entry* qla4xxx_alloc_cont_entry(
         return cont_entry;
 }
 
-uint16_t qla4xxx_calc_request_entries(uint16_t dsds)
+static uint16_t qla4xxx_calc_request_entries(uint16_t dsds)
 {
         uint16_t iocbs;
 
@@ -133,9 +133,9 @@ uint16_t qla4xxx_calc_request_entries(uint16_t dsds)
         return iocbs;
 }
 
-void qla4xxx_build_scsi_iocbs(struct srb *srb,
-                              struct command_t3_entry *cmd_entry,
-                              uint16_t tot_dsds)
+static void qla4xxx_build_scsi_iocbs(struct srb *srb,
+                                     struct command_t3_entry *cmd_entry,
+                                     uint16_t tot_dsds)
 {
         struct scsi_qla_host *ha;
         uint16_t avail_dsds;
diff --git a/drivers/scsi/qla4xxx/ql4_mbx.c b/drivers/scsi/qla4xxx/ql4_mbx.c
index 7f28657eef3f..f116ff917237 100644
--- a/drivers/scsi/qla4xxx/ql4_mbx.c
+++ b/drivers/scsi/qla4xxx/ql4_mbx.c
@@ -20,9 +20,9 @@
  * If outCount is 0, this routine completes successfully WITHOUT waiting
  * for the mailbox command to complete.
  **/
-int qla4xxx_mailbox_command(struct scsi_qla_host *ha, uint8_t inCount,
-                            uint8_t outCount, uint32_t *mbx_cmd,
-                            uint32_t *mbx_sts)
+static int qla4xxx_mailbox_command(struct scsi_qla_host *ha, uint8_t inCount,
+                                   uint8_t outCount, uint32_t *mbx_cmd,
+                                   uint32_t *mbx_sts)
 {
         int status = QLA_ERROR;
         uint8_t i;
@@ -170,6 +170,8 @@ mbox_exit:
 }
 
 
+#if 0
+
 /**
  * qla4xxx_issue_iocb - issue mailbox iocb command
  * @ha: adapter state pointer.
@@ -243,6 +245,8 @@ int qla4xxx_clear_database_entry(struct scsi_qla_host * ha,
         return QLA_SUCCESS;
 }
 
+#endif  /*  0  */
+
 /**
  * qla4xxx_initialize_fw_cb - initializes firmware control block.
  * @ha: Pointer to host adapter structure.
@@ -570,6 +574,7 @@ int qla4xxx_set_ddb_entry(struct scsi_qla_host * ha, uint16_t fw_ddb_index,
         return qla4xxx_mailbox_command(ha, 4, 1, &mbox_cmd[0], &mbox_sts[0]);
 }
 
+#if 0
 int qla4xxx_conn_open_session_login(struct scsi_qla_host * ha,
                                     uint16_t fw_ddb_index)
 {
@@ -594,6 +599,7 @@ int qla4xxx_conn_open_session_login(struct scsi_qla_host * ha,
 
                 return status;
 }
+#endif  /*  0  */
 
 /**
  * qla4xxx_get_crash_record - retrieves crash record.
@@ -649,6 +655,7 @@ exit_get_crash_record:
                                   crash_record, crash_record_dma);
 }
 
+#if 0
 /**
  * qla4xxx_get_conn_event_log - retrieves connection event log
  * @ha: Pointer to host adapter structure.
@@ -738,6 +745,7 @@ exit_get_event_log:
                 dma_free_coherent(&ha->pdev->dev, event_log_size, event_log,
                                   event_log_dma);
 }
+#endif  /*  0  */
 
 /**
  * qla4xxx_reset_lun - issues LUN Reset
@@ -834,7 +842,8 @@ int qla4xxx_get_fw_version(struct scsi_qla_host * ha)
         return QLA_SUCCESS;
 }
 
-int qla4xxx_get_default_ddb(struct scsi_qla_host *ha, dma_addr_t dma_addr)
+static int qla4xxx_get_default_ddb(struct scsi_qla_host *ha,
+                                   dma_addr_t dma_addr)
 {
         uint32_t mbox_cmd[MBOX_REG_COUNT];
         uint32_t mbox_sts[MBOX_REG_COUNT];
@@ -855,7 +864,7 @@ int qla4xxx_get_default_ddb(struct scsi_qla_host *ha, dma_addr_t dma_addr)
         return QLA_SUCCESS;
 }
 
-int qla4xxx_req_ddb_entry(struct scsi_qla_host *ha, uint32_t *ddb_index)
+static int qla4xxx_req_ddb_entry(struct scsi_qla_host *ha, uint32_t *ddb_index)
 {
         uint32_t mbox_cmd[MBOX_REG_COUNT];
         uint32_t mbox_sts[MBOX_REG_COUNT];
diff --git a/drivers/scsi/qla4xxx/ql4_os.c b/drivers/scsi/qla4xxx/ql4_os.c
index 0bfddf893ed0..da21f5fbbf87 100644
--- a/drivers/scsi/qla4xxx/ql4_os.c
+++ b/drivers/scsi/qla4xxx/ql4_os.c
@@ -14,7 +14,7 @@
 /*
  * Driver version
  */
-char qla4xxx_version_str[40];
+static char qla4xxx_version_str[40];
 
 /*
  * SRB allocation cache
@@ -45,8 +45,7 @@ int ql4_mod_unload = 0;
 /*
  * SCSI host template entry points
  */
-
-void qla4xxx_config_dma_addressing(struct scsi_qla_host *ha);
+static void qla4xxx_config_dma_addressing(struct scsi_qla_host *ha);
 
 /*
  * iSCSI template entry points
@@ -1352,7 +1351,7 @@ static void __devexit qla4xxx_remove_adapter(struct pci_dev *pdev)
  * At exit, the @ha's flags.enable_64bit_addressing set to indicated
  * supported addressing method.
  */
-void qla4xxx_config_dma_addressing(struct scsi_qla_host *ha)
+static void qla4xxx_config_dma_addressing(struct scsi_qla_host *ha)
 {
         int retval;
 
@@ -1627,7 +1626,7 @@ static struct pci_device_id qla4xxx_pci_tbl[] = {
 };
 MODULE_DEVICE_TABLE(pci, qla4xxx_pci_tbl);
 
-struct pci_driver qla4xxx_pci_driver = {
+static struct pci_driver qla4xxx_pci_driver = {
         .name           = DRIVER_NAME,
         .id_table       = qla4xxx_pci_tbl,
         .probe          = qla4xxx_probe_adapter,
diff --git a/drivers/scsi/scsi_error.c b/drivers/scsi/scsi_error.c
index 3963e7013bd9..e8350c562d24 100644
--- a/drivers/scsi/scsi_error.c
+++ b/drivers/scsi/scsi_error.c
@@ -38,7 +38,6 @@
 #include "scsi_logging.h"
 
 #define SENSE_TIMEOUT           (10*HZ)
-#define START_UNIT_TIMEOUT      (30*HZ)
 
 /*
  * These should *probably* be handled by the host itself.
@@ -936,7 +935,7 @@ static int scsi_eh_try_stu(struct scsi_cmnd *scmd)
 
                 for (i = 0; rtn == NEEDS_RETRY && i < 2; i++)
                         rtn = scsi_send_eh_cmnd(scmd, stu_command, 6,
-                                                START_UNIT_TIMEOUT, 0);
+                                                scmd->device->timeout, 0);
 
                 if (rtn == SUCCESS)
                         return 0;
diff --git a/drivers/scsi/scsi_lib.c b/drivers/scsi/scsi_lib.c
index 61fbcdcbb009..1f5a07bf2a75 100644
--- a/drivers/scsi/scsi_lib.c
+++ b/drivers/scsi/scsi_lib.c
@@ -173,7 +173,7 @@ int scsi_queue_insert(struct scsi_cmnd *cmd, int reason)
  * @retries:    number of times to retry request
  * @flags:      or into request flags;
  *
- * returns the req->errors value which is the the scsi_cmnd result
+ * returns the req->errors value which is the scsi_cmnd result
  * field.
  **/
 int scsi_execute(struct scsi_device *sdev, const unsigned char *cmd,
diff --git a/drivers/scsi/scsi_transport_fc.c b/drivers/scsi/scsi_transport_fc.c
index 14c4f065b2b8..b4d1ece46f78 100644
--- a/drivers/scsi/scsi_transport_fc.c
+++ b/drivers/scsi/scsi_transport_fc.c
@@ -1718,31 +1718,12 @@ fc_starget_delete(struct work_struct *work)
         struct fc_rport *rport =
                 container_of(work, struct fc_rport, stgt_delete_work);
         struct Scsi_Host *shost = rport_to_shost(rport);
-        unsigned long flags;
         struct fc_internal *i = to_fc_internal(shost->transportt);
 
-        /*
-         * Involve the LLDD if possible. All io on the rport is to
-         * be terminated, either as part of the dev_loss_tmo callback
-         * processing, or via the terminate_rport_io function.
-         */
-        if (i->f->dev_loss_tmo_callbk)
-                i->f->dev_loss_tmo_callbk(rport);
-        else if (i->f->terminate_rport_io)
+        /* Involve the LLDD if possible to terminate all io on the rport. */
+        if (i->f->terminate_rport_io)
                 i->f->terminate_rport_io(rport);
 
-        spin_lock_irqsave(shost->host_lock, flags);
-        if (rport->flags & FC_RPORT_DEVLOSS_PENDING) {
-                spin_unlock_irqrestore(shost->host_lock, flags);
-                if (!cancel_delayed_work(&rport->fail_io_work))
-                        fc_flush_devloss(shost);
-                if (!cancel_delayed_work(&rport->dev_loss_work))
-                        fc_flush_devloss(shost);
-                spin_lock_irqsave(shost->host_lock, flags);
-                rport->flags &= ~FC_RPORT_DEVLOSS_PENDING;
-        }
-        spin_unlock_irqrestore(shost->host_lock, flags);
-
         scsi_remove_target(&rport->dev);
 }
 
@@ -1760,6 +1741,7 @@ fc_rport_final_delete(struct work_struct *work)
         struct device *dev = &rport->dev;
         struct Scsi_Host *shost = rport_to_shost(rport);
         struct fc_internal *i = to_fc_internal(shost->transportt);
+        unsigned long flags;
 
         /*
          * if a scan is pending, flush the SCSI Host work_q so that 
@@ -1768,13 +1750,37 @@ fc_rport_final_delete(struct work_struct *work)
         if (rport->flags & FC_RPORT_SCAN_PENDING)
                 scsi_flush_work(shost);
 
+        /* involve the LLDD to terminate all pending i/o */
+        if (i->f->terminate_rport_io)
+                i->f->terminate_rport_io(rport);
+
+        /*
+         * Cancel any outstanding timers. These should really exist
+         * only when rmmod'ing the LLDD and we're asking for
+         * immediate termination of the rports
+         */
+        spin_lock_irqsave(shost->host_lock, flags);
+        if (rport->flags & FC_RPORT_DEVLOSS_PENDING) {
+                spin_unlock_irqrestore(shost->host_lock, flags);
+                if (!cancel_delayed_work(&rport->fail_io_work))
+                        fc_flush_devloss(shost);
+                if (!cancel_delayed_work(&rport->dev_loss_work))
+                        fc_flush_devloss(shost);
+                spin_lock_irqsave(shost->host_lock, flags);
+                rport->flags &= ~FC_RPORT_DEVLOSS_PENDING;
+        }
+        spin_unlock_irqrestore(shost->host_lock, flags);
+
         /* Delete SCSI target and sdevs */
         if (rport->scsi_target_id != -1)
                 fc_starget_delete(&rport->stgt_delete_work);
-        else if (i->f->dev_loss_tmo_callbk)
+
+        /*
+         * Notify the driver that the rport is now dead. The LLDD will
+         * also guarantee that any communication to the rport is terminated
+         */
+        if (i->f->dev_loss_tmo_callbk)
                 i->f->dev_loss_tmo_callbk(rport);
-        else if (i->f->terminate_rport_io)
-                i->f->terminate_rport_io(rport);
 
         transport_remove_device(dev);
         device_del(dev);
@@ -1963,8 +1969,6 @@ fc_remote_port_add(struct Scsi_Host *shost, int channel,
                         }
 
                         if (match) {
-                                struct delayed_work *work =
-                                                        &rport->dev_loss_work;
 
                                 memcpy(&rport->node_name, &ids->node_name,
                                         sizeof(rport->node_name));
@@ -1982,46 +1986,61 @@ fc_remote_port_add(struct Scsi_Host *shost, int channel,
                                                 fci->f->dd_fcrport_size);
 
                                 /*
-                                 * If we were blocked, we were a target.
-                                 * If no longer a target, we leave the timer
-                                 * running in case the port changes roles
-                                 * prior to the timer expiring. If the timer
-                                 * fires, the target will be torn down.
+                                 * If we were not a target, cancel the
+                                 * io terminate and rport timers, and
+                                 * we're done.
+                                 *
+                                 * If we were a target, but our new role
+                                 * doesn't indicate a target, leave the
+                                 * timers running expecting the role to
+                                 * change as the target fully logs in. If
+                                 * it doesn't, the target will be torn down.
+                                 *
+                                 * If we were a target, and our role shows
+                                 * we're still a target, cancel the timers
+                                 * and kick off a scan.
                                  */
-                                if (!(ids->roles & FC_RPORT_ROLE_FCP_TARGET))
-                                        return rport;
 
-                                /* restart the target */
+                                /* was a target, not in roles */
+                                if ((rport->scsi_target_id != -1) &&
+                                    (!(ids->roles & FC_RPORT_ROLE_FCP_TARGET)))
+                                        return rport;
 
                                 /*
-                                 * Stop the target timers first. Take no action
-                                 * on the del_timer failure as the state
-                                 * machine state change will validate the
-                                 * transaction.
+                                 * Stop the fail io and dev_loss timers.
+                                 * If they flush, the port_state will
+                                 * be checked and will NOOP the function.
                                  */
                                 if (!cancel_delayed_work(&rport->fail_io_work))
                                         fc_flush_devloss(shost);
-                                if (!cancel_delayed_work(work))
+                                if (!cancel_delayed_work(&rport->dev_loss_work))
                                         fc_flush_devloss(shost);
 
                                 spin_lock_irqsave(shost->host_lock, flags);
 
                                 rport->flags &= ~FC_RPORT_DEVLOSS_PENDING;
 
-                                /* initiate a scan of the target */
-                                rport->flags |= FC_RPORT_SCAN_PENDING;
-                                scsi_queue_work(shost, &rport->scan_work);
-
-                                spin_unlock_irqrestore(shost->host_lock, flags);
-
-                                scsi_target_unblock(&rport->dev);
+                                /* if target, initiate a scan */
+                                if (rport->scsi_target_id != -1) {
+                                        rport->flags |= FC_RPORT_SCAN_PENDING;
+                                        scsi_queue_work(shost,
+                                                        &rport->scan_work);
+                                        spin_unlock_irqrestore(shost->host_lock,
+                                                        flags);
+                                        scsi_target_unblock(&rport->dev);
+                                } else
+                                        spin_unlock_irqrestore(shost->host_lock,
+                                                        flags);
 
                                 return rport;
                         }
                 }
         }
 
-        /* Search the bindings array */
+        /*
+         * Search the bindings array
+         * Note: if never a FCP target, you won't be on this list
+         */
         if (fc_host->tgtid_bind_type != FC_TGTID_BIND_NONE) {
 
                 /* search for a matching consistent binding */
@@ -2158,15 +2177,24 @@ fc_remote_port_delete(struct fc_rport  *rport)
 
         spin_lock_irqsave(shost->host_lock, flags);
 
-        /* If no scsi target id mapping, delete it */
-        if (rport->scsi_target_id == -1) {
-                list_del(&rport->peers);
-                rport->port_state = FC_PORTSTATE_DELETED;
-                fc_queue_work(shost, &rport->rport_delete_work);
+        if (rport->port_state != FC_PORTSTATE_ONLINE) {
                 spin_unlock_irqrestore(shost->host_lock, flags);
                 return;
         }
 
+        /*
+         * In the past, we if this was not an FCP-Target, we would
+         * unconditionally just jump to deleting the rport.
+         * However, rports can be used as node containers by the LLDD,
+         * and its not appropriate to just terminate the rport at the
+         * first sign of a loss in connectivity. The LLDD may want to
+         * send ELS traffic to re-validate the login. If the rport is
+         * immediately deleted, it makes it inappropriate for a node
+         * container.
+         * So... we now unconditionally wait dev_loss_tmo before
+         * destroying an rport.
+         */
+
         rport->port_state = FC_PORTSTATE_BLOCKED;
 
         rport->flags |= FC_RPORT_DEVLOSS_PENDING;
@@ -2263,11 +2291,11 @@ fc_remote_port_rolechg(struct fc_rport  *rport, u32 roles)
 EXPORT_SYMBOL(fc_remote_port_rolechg);
 
 /**
- * fc_timeout_deleted_rport - Timeout handler for a deleted remote port that
- *                       was a SCSI target (thus was blocked), and failed
- *                       to return in the alloted time.
+ * fc_timeout_deleted_rport - Timeout handler for a deleted remote port,
+ *                      which we blocked, and has now failed to return
+ *                      in the allotted time.
  * 
- * @work:       rport target that failed to reappear in the alloted time.
+ * @work:       rport target that failed to reappear in the allotted time.
  **/
 static void
 fc_timeout_deleted_rport(struct work_struct *work)
@@ -2283,10 +2311,12 @@ fc_timeout_deleted_rport(struct work_struct *work)
         rport->flags &= ~FC_RPORT_DEVLOSS_PENDING;
 
         /*
-         * If the port is ONLINE, then it came back. Validate it's still an
-         * FCP target. If not, tear down the scsi_target on it.
+         * If the port is ONLINE, then it came back. If it was a SCSI
+         * target, validate it still is. If not, tear down the
+         * scsi_target on it.
          */
         if ((rport->port_state == FC_PORTSTATE_ONLINE) &&
+            (rport->scsi_target_id != -1) &&
             !(rport->roles & FC_RPORT_ROLE_FCP_TARGET)) {
                 dev_printk(KERN_ERR, &rport->dev,
                         "blocked FC remote port time out: no longer"
@@ -2297,18 +2327,24 @@ fc_timeout_deleted_rport(struct work_struct *work)
                 return;
         }
 
+        /* NOOP state - we're flushing workq's */
         if (rport->port_state != FC_PORTSTATE_BLOCKED) {
                 spin_unlock_irqrestore(shost->host_lock, flags);
                 dev_printk(KERN_ERR, &rport->dev,
-                        "blocked FC remote port time out: leaving target alone\n");
+                        "blocked FC remote port time out: leaving"
+                        " rport%s alone\n",
+                        (rport->scsi_target_id != -1) ?  " and starget" : "");
                 return;
         }
 
-        if (fc_host->tgtid_bind_type == FC_TGTID_BIND_NONE) {
+        if ((fc_host->tgtid_bind_type == FC_TGTID_BIND_NONE) ||
+            (rport->scsi_target_id == -1)) {
                 list_del(&rport->peers);
                 rport->port_state = FC_PORTSTATE_DELETED;
                 dev_printk(KERN_ERR, &rport->dev,
-                        "blocked FC remote port time out: removing target\n");
+                        "blocked FC remote port time out: removing"
+                        " rport%s\n",
+                        (rport->scsi_target_id != -1) ?  " and starget" : "");
                 fc_queue_work(shost, &rport->rport_delete_work);
                 spin_unlock_irqrestore(shost->host_lock, flags);
                 return;
diff --git a/drivers/scsi/tmscsim.c b/drivers/scsi/tmscsim.c
index 3158949ffa62..e7b85e832eb5 100644
--- a/drivers/scsi/tmscsim.c
+++ b/drivers/scsi/tmscsim.c
@@ -351,6 +351,27 @@ static u8  dc390_clock_speed[] = {100,80,67,57,50, 40, 31, 20};
  * (DCBs, SRBs, Queueing)
  *
  **********************************************************************/
+static void inline dc390_start_segment(struct dc390_srb* pSRB)
+{
+        struct scatterlist *psgl = pSRB->pSegmentList;
+
+        /* start new sg segment */
+        pSRB->SGBusAddr = sg_dma_address(psgl);
+        pSRB->SGToBeXferLen = sg_dma_len(psgl);
+}
+
+static unsigned long inline dc390_advance_segment(struct dc390_srb* pSRB, u32 residue)
+{
+        unsigned long xfer = pSRB->SGToBeXferLen - residue;
+
+        /* xfer more bytes transferred */
+        pSRB->SGBusAddr += xfer;
+        pSRB->TotalXferredLen += xfer;
+        pSRB->SGToBeXferLen = residue;
+
+        return xfer;
+}
+
 static struct dc390_dcb __inline__ *dc390_findDCB ( struct dc390_acb* pACB, u8 id, u8 lun)
 {
    struct dc390_dcb* pDCB = pACB->pLinkDCB; if (!pDCB) return NULL;
@@ -625,70 +646,6 @@ dc390_StartSCSI( struct dc390_acb* pACB, struct dc390_dcb* pDCB, struct dc390_sr
     return 0;
 }
 
-//#define DMA_INT EN_DMA_INT /*| EN_PAGE_INT*/
-#define DMA_INT 0
-
-#if DMA_INT
-/* This is similar to AM53C974.c ... */
-static u8 
-dc390_dma_intr (struct dc390_acb* pACB)
-{
-  struct dc390_srb* pSRB;
-  u8 dstate;
-  DEBUG0(u16 pstate; struct pci_dev *pdev = pACB->pdev);
-  
-  DEBUG0(pci_read_config_word(pdev, PCI_STATUS, &pstate));
-  DEBUG0(if (pstate & (PCI_STATUS_SIG_SYSTEM_ERROR | PCI_STATUS_DETECTED_PARITY))\
-        { printk(KERN_WARNING "DC390: PCI state = %04x!\n", pstate); \
-          pci_write_config_word(pdev, PCI_STATUS, (PCI_STATUS_SIG_SYSTEM_ERROR | PCI_STATUS_DETECTED_PARITY));});
-
-  dstate = DC390_read8 (DMA_Status); 
-
-  if (! pACB->pActiveDCB || ! pACB->pActiveDCB->pActiveSRB) return dstate;
-  else pSRB  = pACB->pActiveDCB->pActiveSRB;
-  
-  if (dstate & (DMA_XFER_ABORT | DMA_XFER_ERROR | POWER_DOWN | PCI_MS_ABORT))
-    {
-        printk (KERN_ERR "DC390: DMA error (%02x)!\n", dstate);
-        return dstate;
-    }
-  if (dstate & DMA_XFER_DONE)
-    {
-        u32 residual, xferCnt; int ctr = 6000000;
-        if (! (DC390_read8 (DMA_Cmd) & READ_DIRECTION))
-          {
-            do
-              {
-                DEBUG1(printk (KERN_DEBUG "DC390: read residual bytes ... \n"));
-                dstate = DC390_read8 (DMA_Status);
-                residual = DC390_read8 (CtcReg_Low) | DC390_read8 (CtcReg_Mid) << 8 |
-                  DC390_read8 (CtcReg_High) << 16;
-                residual += DC390_read8 (Current_Fifo) & 0x1f;
-              } while (residual && ! (dstate & SCSI_INTERRUPT) && --ctr);
-            if (!ctr) printk (KERN_CRIT "DC390: dma_intr: DMA aborted unfinished: %06x bytes remain!!\n", DC390_read32 (DMA_Wk_ByteCntr));
-            /* residual =  ... */
-          }
-        else
-            residual = 0;
-        
-        /* ??? */
-        
-        xferCnt = pSRB->SGToBeXferLen - residual;
-        pSRB->SGBusAddr += xferCnt;
-        pSRB->TotalXferredLen += xferCnt;
-        pSRB->SGToBeXferLen = residual;
-# ifdef DC390_DEBUG0
-        printk (KERN_INFO "DC390: DMA: residual = %i, xfer = %i\n", 
-                (unsigned int)residual, (unsigned int)xferCnt);
-# endif
-        
-        DC390_write8 (DMA_Cmd, DMA_IDLE_CMD);
-    }
-  dc390_laststatus &= ~0xff000000; dc390_laststatus |= dstate << 24;
-  return dstate;
-}
-#endif
-
 
 static void __inline__
 dc390_InvalidCmd(struct dc390_acb* pACB)
@@ -708,9 +665,6 @@ DC390_Interrupt(void *dev_id)
     u8  phase;
     void   (*stateV)( struct dc390_acb*, struct dc390_srb*, u8 *);
     u8  istate, istatus;
-#if DMA_INT
-    u8  dstatus;
-#endif
 
     sstatus = DC390_read8 (Scsi_Status);
     if( !(sstatus & INTERRUPT) )
@@ -718,22 +672,9 @@ DC390_Interrupt(void *dev_id)
 
     DEBUG1(printk (KERN_DEBUG "sstatus=%02x,", sstatus));
 
-#if DMA_INT
-    spin_lock_irq(pACB->pScsiHost->host_lock);
-    dstatus = dc390_dma_intr (pACB);
-    spin_unlock_irq(pACB->pScsiHost->host_lock);
-
-    DEBUG1(printk (KERN_DEBUG "dstatus=%02x,", dstatus));
-    if (! (dstatus & SCSI_INTERRUPT))
-      {
-        DEBUG0(printk (KERN_WARNING "DC390 Int w/o SCSI actions (only DMA?)\n"));
-        return IRQ_NONE;
-      }
-#else
     //DC390_write32 (DMA_ScsiBusCtrl, WRT_ERASE_DMA_STAT | EN_INT_ON_PCI_ABORT);
     //dstatus = DC390_read8 (DMA_Status);
     //DC390_write32 (DMA_ScsiBusCtrl, EN_INT_ON_PCI_ABORT);
-#endif
 
     spin_lock_irq(pACB->pScsiHost->host_lock);
 
@@ -821,11 +762,10 @@ static irqreturn_t do_DC390_Interrupt(int irq, void *dev_id)
 }
 
 static void
-dc390_DataOut_0( struct dc390_acb* pACB, struct dc390_srb* pSRB, u8 *psstatus)
+dc390_DataOut_0(struct dc390_acb* pACB, struct dc390_srb* pSRB, u8 *psstatus)
 {
     u8   sstatus;
-    struct scatterlist *psgl;
-    u32    ResidCnt, xferCnt;
+    u32  ResidCnt;
     u8   dstate = 0;
 
     sstatus = *psstatus;
@@ -856,42 +796,35 @@ dc390_DataOut_0( struct dc390_acb* pACB, struct dc390_srb* pSRB, u8 *psstatus)
             if( pSRB->SGIndex < pSRB->SGcount )
             {
                 pSRB->pSegmentList++;
-                psgl = pSRB->pSegmentList;
 
-                pSRB->SGBusAddr = cpu_to_le32(pci_dma_lo32(sg_dma_address(psgl)));
-                pSRB->SGToBeXferLen = cpu_to_le32(sg_dma_len(psgl));
+                dc390_start_segment(pSRB);
             }
             else
                 pSRB->SGToBeXferLen = 0;
         }
         else
         {
-            ResidCnt  = (u32) DC390_read8 (Current_Fifo) & 0x1f;
-            ResidCnt |= (u32) DC390_read8 (CtcReg_High) << 16;
-            ResidCnt |= (u32) DC390_read8 (CtcReg_Mid) << 8; 
-            ResidCnt += (u32) DC390_read8 (CtcReg_Low);
-
-            xferCnt = pSRB->SGToBeXferLen - ResidCnt;
-            pSRB->SGBusAddr += xferCnt;
-            pSRB->TotalXferredLen += xferCnt;
-            pSRB->SGToBeXferLen = ResidCnt;
+            ResidCnt = ((u32) DC390_read8 (Current_Fifo) & 0x1f) +
+                    (((u32) DC390_read8 (CtcReg_High) << 16) |
+                     ((u32) DC390_read8 (CtcReg_Mid) << 8) |
+                     (u32) DC390_read8 (CtcReg_Low));
+
+            dc390_advance_segment(pSRB, ResidCnt);
         }
     }
     if ((*psstatus & 7) != SCSI_DATA_OUT)
     {
-            DC390_write8 (DMA_Cmd, WRITE_DIRECTION+DMA_IDLE_CMD); /* | DMA_INT */
+            DC390_write8 (DMA_Cmd, WRITE_DIRECTION+DMA_IDLE_CMD);
             DC390_write8 (ScsiCmd, CLEAR_FIFO_CMD);
     }       
 }
 
 static void
-dc390_DataIn_0( struct dc390_acb* pACB, struct dc390_srb* pSRB, u8 *psstatus)
+dc390_DataIn_0(struct dc390_acb* pACB, struct dc390_srb* pSRB, u8 *psstatus)
 {
     u8   sstatus, residual, bval;
-    struct scatterlist *psgl;
-    u32    ResidCnt, i;
+    u32  ResidCnt, i;
     unsigned long   xferCnt;
-    u8      *ptr;
 
     sstatus = *psstatus;
 
@@ -922,19 +855,17 @@ dc390_DataIn_0( struct dc390_acb* pACB, struct dc390_srb* pSRB, u8 *psstatus)
             DEBUG1(ResidCnt = ((unsigned long) DC390_read8 (CtcReg_High) << 16) \
                 + ((unsigned long) DC390_read8 (CtcReg_Mid) << 8)               \
                 + ((unsigned long) DC390_read8 (CtcReg_Low)));
-            DEBUG1(printk (KERN_DEBUG "Count_2_Zero (ResidCnt=%i,ToBeXfer=%li),", ResidCnt, pSRB->SGToBeXferLen));
+            DEBUG1(printk (KERN_DEBUG "Count_2_Zero (ResidCnt=%u,ToBeXfer=%lu),", ResidCnt, pSRB->SGToBeXferLen));
 
-            DC390_write8 (DMA_Cmd, READ_DIRECTION+DMA_IDLE_CMD); /* | DMA_INT */
+            DC390_write8 (DMA_Cmd, READ_DIRECTION+DMA_IDLE_CMD);
 
             pSRB->TotalXferredLen += pSRB->SGToBeXferLen;
             pSRB->SGIndex++;
             if( pSRB->SGIndex < pSRB->SGcount )
             {
                 pSRB->pSegmentList++;
-                psgl = pSRB->pSegmentList;
 
-                pSRB->SGBusAddr = cpu_to_le32(pci_dma_lo32(sg_dma_address(psgl)));
-                pSRB->SGToBeXferLen = cpu_to_le32(sg_dma_len(psgl));
+                dc390_start_segment(pSRB);
             }
             else
                 pSRB->SGToBeXferLen = 0;
@@ -973,47 +904,45 @@ din_1:
             }
             /* It seems a DMA Blast abort isn't that bad ... */
             if (!i) printk (KERN_ERR "DC390: DMA Blast aborted unfinished!\n");
-            //DC390_write8 (DMA_Cmd, READ_DIRECTION+DMA_IDLE_CMD); /* | DMA_INT */
-            dc390_laststatus &= ~0xff000000; dc390_laststatus |= bval << 24;
+            //DC390_write8 (DMA_Cmd, READ_DIRECTION+DMA_IDLE_CMD);
+            dc390_laststatus &= ~0xff000000;
+            dc390_laststatus |= bval << 24;
 
             DEBUG1(printk (KERN_DEBUG "Blast: Read %i times DMA_Status %02x", 0xa000-i, bval));
-            ResidCnt = (u32) DC390_read8 (CtcReg_High);
-            ResidCnt <<= 8;
-            ResidCnt |= (u32) DC390_read8 (CtcReg_Mid);
-            ResidCnt <<= 8;
-            ResidCnt |= (u32) DC390_read8 (CtcReg_Low);
-
-            xferCnt = pSRB->SGToBeXferLen - ResidCnt;
-            pSRB->SGBusAddr += xferCnt;
-            pSRB->TotalXferredLen += xferCnt;
-            pSRB->SGToBeXferLen = ResidCnt;
-
-            if( residual )
-            {
-                static int feedback_requested;
+            ResidCnt = (((u32) DC390_read8 (CtcReg_High) << 16) |
+                        ((u32) DC390_read8 (CtcReg_Mid) << 8)) |
+                    (u32) DC390_read8 (CtcReg_Low);
+
+            xferCnt = dc390_advance_segment(pSRB, ResidCnt);
+
+            if (residual) {
+                size_t count = 1;
+                size_t offset = pSRB->SGBusAddr - sg_dma_address(pSRB->pSegmentList);
+                unsigned long flags;
+                u8 *ptr;
+
                 bval = DC390_read8 (ScsiFifo);      /* get one residual byte */
 
-                if (!feedback_requested) {
-                        feedback_requested = 1;
-                        printk(KERN_WARNING "%s: Please, contact <linux-scsi@vger.kernel.org> "
-                               "to help improve support for your system.\n", __FILE__);
+                local_irq_save(flags);
+                ptr = scsi_kmap_atomic_sg(pSRB->pSegmentList, pSRB->SGcount, &offset, &count);
+                if (likely(ptr)) {
+                        *(ptr + offset) = bval;
+                        scsi_kunmap_atomic_sg(ptr);
                 }
+                local_irq_restore(flags);
+                WARN_ON(!ptr);
 
-                ptr = (u8 *) bus_to_virt( pSRB->SGBusAddr );
-                *ptr = bval;
-                pSRB->SGBusAddr++; xferCnt++;
-                pSRB->TotalXferredLen++;
-                pSRB->SGToBeXferLen--;
+                /* 1 more byte read */
+                xferCnt += dc390_advance_segment(pSRB, pSRB->SGToBeXferLen - 1);
             }
-            DEBUG1(printk (KERN_DEBUG "Xfered: %li, Total: %li, Remaining: %li\n", xferCnt,\
+            DEBUG1(printk (KERN_DEBUG "Xfered: %lu, Total: %lu, Remaining: %lu\n", xferCnt,\
                            pSRB->TotalXferredLen, pSRB->SGToBeXferLen));
-
         }
     }
     if ((*psstatus & 7) != SCSI_DATA_IN)
     {
             DC390_write8 (ScsiCmd, CLEAR_FIFO_CMD);
-            DC390_write8 (DMA_Cmd, READ_DIRECTION+DMA_IDLE_CMD); /* | DMA_INT */
+            DC390_write8 (DMA_Cmd, READ_DIRECTION+DMA_IDLE_CMD);
     }
 }
 
@@ -1216,7 +1145,7 @@ dc390_MsgIn_set_sync (struct dc390_acb* pACB, struct dc390_srb* pSRB)
 
 
 /* handle RESTORE_PTR */
-/* I presume, this command is already mapped, so, have to remap. */
+/* This doesn't look very healthy... to-be-fixed */
 static void 
 dc390_restore_ptr (struct dc390_acb* pACB, struct dc390_srb* pSRB)
 {
@@ -1225,6 +1154,7 @@ dc390_restore_ptr (struct dc390_acb* pACB, struct dc390_srb* pSRB)
     pSRB->TotalXferredLen = 0;
     pSRB->SGIndex = 0;
     if (pcmd->use_sg) {
+        size_t saved;
         pSRB->pSegmentList = (struct scatterlist *)pcmd->request_buffer;
         psgl = pSRB->pSegmentList;
         //dc390_pci_sync(pSRB);
@@ -1236,15 +1166,16 @@ dc390_restore_ptr (struct dc390_acb* pACB, struct dc390_srb* pSRB)
             if( pSRB->SGIndex < pSRB->SGcount )
             {
                 pSRB->pSegmentList++;
-                psgl = pSRB->pSegmentList;
-                pSRB->SGBusAddr = cpu_to_le32(pci_dma_lo32(sg_dma_address(psgl)));
-                pSRB->SGToBeXferLen = cpu_to_le32(sg_dma_len(psgl));
+
+                dc390_start_segment(pSRB);
             }
             else
                 pSRB->SGToBeXferLen = 0;
         }
-        pSRB->SGToBeXferLen -= (pSRB->Saved_Ptr - pSRB->TotalXferredLen);
-        pSRB->SGBusAddr += (pSRB->Saved_Ptr - pSRB->TotalXferredLen);
+
+        saved = pSRB->Saved_Ptr - pSRB->TotalXferredLen;
+        pSRB->SGToBeXferLen -= saved;
+        pSRB->SGBusAddr += saved;
         printk (KERN_INFO "DC390: Pointer restored. Segment %i, Total %li, Bus %08lx\n",
                 pSRB->SGIndex, pSRB->Saved_Ptr, pSRB->SGBusAddr);
 
@@ -1365,7 +1296,6 @@ dc390_MsgIn_0( struct dc390_acb* pACB, struct dc390_srb* pSRB, u8 *psstatus)
 static void
 dc390_DataIO_Comm( struct dc390_acb* pACB, struct dc390_srb* pSRB, u8 ioDir)
 {
-    struct scatterlist *psgl;
     unsigned long  lval;
     struct dc390_dcb*   pDCB = pACB->pActiveDCB;
 
@@ -1391,12 +1321,11 @@ dc390_DataIO_Comm( struct dc390_acb* pACB, struct dc390_srb* pSRB, u8 ioDir)
 
     if( pSRB->SGIndex < pSRB->SGcount )
     {
-        DC390_write8 (DMA_Cmd, DMA_IDLE_CMD | ioDir /* | DMA_INT */);
+        DC390_write8 (DMA_Cmd, DMA_IDLE_CMD | ioDir);
         if( !pSRB->SGToBeXferLen )
         {
-            psgl = pSRB->pSegmentList;
-            pSRB->SGBusAddr = cpu_to_le32(pci_dma_lo32(sg_dma_address(psgl)));
-            pSRB->SGToBeXferLen = cpu_to_le32(sg_dma_len(psgl));
+            dc390_start_segment(pSRB);
+
             DEBUG1(printk (KERN_DEBUG " DC390: Next SG segment."));
         }
         lval = pSRB->SGToBeXferLen;
@@ -1410,12 +1339,12 @@ dc390_DataIO_Comm( struct dc390_acb* pACB, struct dc390_srb* pSRB, u8 ioDir)
         DC390_write32 (DMA_XferCnt, pSRB->SGToBeXferLen);
         DC390_write32 (DMA_XferAddr, pSRB->SGBusAddr);
 
-        //DC390_write8 (DMA_Cmd, DMA_IDLE_CMD | ioDir); /* | DMA_INT; */
+        //DC390_write8 (DMA_Cmd, DMA_IDLE_CMD | ioDir);
         pSRB->SRBState = SRB_DATA_XFER;
 
         DC390_write8 (ScsiCmd, DMA_COMMAND+INFO_XFER_CMD);
 
-        DC390_write8 (DMA_Cmd, DMA_START_CMD | ioDir | DMA_INT);
+        DC390_write8 (DMA_Cmd, DMA_START_CMD | ioDir);
         //DEBUG1(DC390_write32 (DMA_ScsiBusCtrl, WRT_ERASE_DMA_STAT | EN_INT_ON_PCI_ABORT));
         //DEBUG1(printk (KERN_DEBUG "DC390: DMA_Status: %02x\n", DC390_read8 (DMA_Status)));
         //DEBUG1(DC390_write32 (DMA_ScsiBusCtrl, EN_INT_ON_PCI_ABORT));
@@ -1436,8 +1365,8 @@ dc390_DataIO_Comm( struct dc390_acb* pACB, struct dc390_srb* pSRB, u8 ioDir)
         pSRB->SRBState |= SRB_XFERPAD;
         DC390_write8 (ScsiCmd, DMA_COMMAND+XFER_PAD_BYTE);
 /*
-        DC390_write8 (DMA_Cmd, DMA_IDLE_CMD | ioDir); // | DMA_INT;
-        DC390_write8 (DMA_Cmd, DMA_START_CMD | ioDir | DMA_INT);
+        DC390_write8 (DMA_Cmd, DMA_IDLE_CMD | ioDir);
+        DC390_write8 (DMA_Cmd, DMA_START_CMD | ioDir);
 */
     }
 }
diff --git a/drivers/scsi/tmscsim.h b/drivers/scsi/tmscsim.h
index 9b66fa8d38d9..c3d8c80cfb38 100644
--- a/drivers/scsi/tmscsim.h
+++ b/drivers/scsi/tmscsim.h
@@ -19,14 +19,6 @@
 
 #define SEL_TIMEOUT             153     /* 250 ms selection timeout (@ 40 MHz) */
 
-#define pci_dma_lo32(a)                 (a & 0xffffffff)
-
-typedef u8              UCHAR;  /*  8 bits */
-typedef u16             USHORT; /* 16 bits */
-typedef u32             UINT;   /* 32 bits */
-typedef unsigned long   ULONG;  /* 32/64 bits */
-
-
 /*
 ;-----------------------------------------------------------------------
 ; SCSI Request Block
@@ -43,7 +35,9 @@ struct scatterlist	*pSegmentList;
 
 struct scatterlist Segmentx;    /* make a one entry of S/G list table */
 
-unsigned long   SGBusAddr;      /*;a segment starting address as seen by AM53C974A*/
+unsigned long   SGBusAddr;      /*;a segment starting address as seen by AM53C974A
+                                  in CPU endianness. We're only getting 32-bit bus
+                                  addresses by default */
 unsigned long   SGToBeXferLen;  /*; to be xfer length */
 unsigned long   TotalXferredLen;
 unsigned long   SavedTotXLen;
diff --git a/drivers/spi/atmel_spi.c b/drivers/spi/atmel_spi.c
index 66e7bc985797..1d8a2f6bb8eb 100644
--- a/drivers/spi/atmel_spi.c
+++ b/drivers/spi/atmel_spi.c
@@ -22,10 +22,7 @@
 #include <asm/io.h>
 #include <asm/arch/board.h>
 #include <asm/arch/gpio.h>
-
-#ifdef CONFIG_ARCH_AT91
 #include <asm/arch/cpu.h>
-#endif
 
 #include "atmel_spi.h"
 
@@ -552,10 +549,8 @@ static int __init atmel_spi_probe(struct platform_device *pdev)
                 goto out_free_buffer;
         as->irq = irq;
         as->clk = clk;
-#ifdef CONFIG_ARCH_AT91
         if (!cpu_is_at91rm9200())
                 as->new_1 = 1;
-#endif
 
         ret = request_irq(irq, atmel_spi_interrupt, 0,
                         pdev->dev.bus_id, master);
diff --git a/drivers/usb/atm/usbatm.c b/drivers/usb/atm/usbatm.c
index b082d95bbbaa..11e9b15ca45a 100644
--- a/drivers/usb/atm/usbatm.c
+++ b/drivers/usb/atm/usbatm.c
@@ -1033,7 +1033,7 @@ static int usbatm_do_heavy_init(void *arg)
 
 static int usbatm_heavy_init(struct usbatm_data *instance)
 {
-        int ret = kernel_thread(usbatm_do_heavy_init, instance, CLONE_KERNEL);
+        int ret = kernel_thread(usbatm_do_heavy_init, instance, CLONE_FS | CLONE_FILES);
 
         if (ret < 0) {
                 usb_err(instance, "%s: failed to create kernel_thread (%d)!\n", __func__, ret);
diff --git a/drivers/usb/misc/auerswald.c b/drivers/usb/misc/auerswald.c
index b5332e679c46..88fb56d5db8f 100644
--- a/drivers/usb/misc/auerswald.c
+++ b/drivers/usb/misc/auerswald.c
@@ -1307,7 +1307,7 @@ static int auerswald_addservice (pauerswald_t cp, pauerscon_t scp)
 }
 
 
-/* remove a service from the the device
+/* remove a service from the device
    scp->id must be set! */
 static void auerswald_removeservice (pauerswald_t cp, pauerscon_t scp)
 {
diff --git a/drivers/usb/net/usbnet.h b/drivers/usb/net/usbnet.h
index cbb53e065d6c..82db5a8e528e 100644
--- a/drivers/usb/net/usbnet.h
+++ b/drivers/usb/net/usbnet.h
@@ -129,7 +129,7 @@ extern void usbnet_disconnect(struct usb_interface *);
 
 
 /* Drivers that reuse some of the standard USB CDC infrastructure
- * (notably, using multiple interfaces according to the the CDC
+ * (notably, using multiple interfaces according to the CDC
  * union descriptor) get some helper code.
  */
 struct cdc_state {
diff --git a/drivers/usb/serial/Kconfig b/drivers/usb/serial/Kconfig
index ba5d1dc03036..3efe67092f15 100644
--- a/drivers/usb/serial/Kconfig
+++ b/drivers/usb/serial/Kconfig
@@ -558,7 +558,7 @@ config USB_SERIAL_DEBUG
         tristate "USB Debugging Device"
         depends on USB_SERIAL
         help
-          Say Y here if you have a USB debugging device used to recieve
+          Say Y here if you have a USB debugging device used to receive
           debugging data from another machine.  The most common of these
           devices is the NetChip TurboCONNECT device.
 
diff --git a/drivers/usb/serial/aircable.c b/drivers/usb/serial/aircable.c
index b675735bfbee..fbc8c27d5d99 100644
--- a/drivers/usb/serial/aircable.c
+++ b/drivers/usb/serial/aircable.c
@@ -9,7 +9,7 @@
  * The device works as an standard CDC device, it has 2 interfaces, the first
  * one is for firmware access and the second is the serial one.
  * The protocol is very simply, there are two posibilities reading or writing.
- * When writting the first urb must have a Header that starts with 0x20 0x29 the
+ * When writing the first urb must have a Header that starts with 0x20 0x29 the
  * next two bytes must say how much data will be sended.
  * When reading the process is almost equal except that the header starts with
  * 0x00 0x20.
@@ -18,7 +18,7 @@
  * buffer: The First and Second byte is used for a Header, the Third and Fourth
  * tells the  device the amount of information the package holds.
  * Packages are 60 bytes long Header Stuff.
- * When writting to the device the first two bytes of the header are 0x20 0x29
+ * When writing to the device the first two bytes of the header are 0x20 0x29
  * When reading the bytes are 0x00 0x20, or 0x00 0x10, there is an strange
  * situation, when too much data arrives to the device because it sends the data
  * but with out the header. I will use a simply hack to override this situation,
diff --git a/drivers/usb/serial/io_edgeport.c b/drivers/usb/serial/io_edgeport.c
index 18f74ac76565..4807f960150b 100644
--- a/drivers/usb/serial/io_edgeport.c
+++ b/drivers/usb/serial/io_edgeport.c
@@ -2465,7 +2465,7 @@ static int send_cmd_write_uart_register (struct edgeport_port *edge_port, __u8 r
             ((edge_serial->is_epic) &&
              (!edge_serial->epic_descriptor.Supports.IOSPWriteMCR) &&
              (regNum == MCR))) {
-                dbg("SendCmdWriteUartReg - Not writting to MCR Register");
+                dbg("SendCmdWriteUartReg - Not writing to MCR Register");
                 return 0;
         }
 
@@ -2473,7 +2473,7 @@ static int send_cmd_write_uart_register (struct edgeport_port *edge_port, __u8 r
             ((edge_serial->is_epic) &&
              (!edge_serial->epic_descriptor.Supports.IOSPWriteLCR) &&
              (regNum == LCR))) {
-                dbg ("SendCmdWriteUartReg - Not writting to LCR Register");
+                dbg ("SendCmdWriteUartReg - Not writing to LCR Register");
                 return 0;
         }
 
diff --git a/drivers/video/Kconfig b/drivers/video/Kconfig
index 1132ba5ff391..9a256d2ff9dc 100644
--- a/drivers/video/Kconfig
+++ b/drivers/video/Kconfig
@@ -1348,6 +1348,20 @@ config FB_VOODOO1
           Please read the <file:Documentation/fb/README-sstfb.txt> for supported
           options and other important info  support.
 
+config FB_VT8623
+        tristate "VIA VT8623 support"
+        depends on FB && PCI
+        select FB_CFB_FILLRECT
+        select FB_CFB_COPYAREA
+        select FB_CFB_IMAGEBLIT
+        select FB_TILEBLITTING
+        select FB_SVGALIB
+        select VGASTATE
+        select FONT_8x16 if FRAMEBUFFER_CONSOLE
+        ---help---
+          Driver for CastleRock integrated graphics core in the
+          VIA VT8623 [Apollo CLE266] chipset.
+
 config FB_CYBLA
         tristate "Cyberblade/i1 support"
         depends on FB && PCI && X86_32 && !64BIT
@@ -1401,6 +1415,20 @@ config FB_TRIDENT_ACCEL
         This will compile the Trident frame buffer device with
         acceleration functions.
 
+config FB_ARK
+        tristate "ARK 2000PV support"
+        depends on FB && PCI
+        select FB_CFB_FILLRECT
+        select FB_CFB_COPYAREA
+        select FB_CFB_IMAGEBLIT
+        select FB_TILEBLITTING
+        select FB_SVGALIB
+        select VGASTATE
+        select FONT_8x16 if FRAMEBUFFER_CONSOLE
+        ---help---
+          Driver for PCI graphics boards with ARK 2000PV chip
+          and ICS 5342 RAMDAC.
+
 config FB_PM3
         tristate "Permedia3 support"
         depends on FB && PCI && BROKEN
diff --git a/drivers/video/Makefile b/drivers/video/Makefile
index a916c204274f..0b70567458fb 100644
--- a/drivers/video/Makefile
+++ b/drivers/video/Makefile
@@ -54,10 +54,12 @@ obj-$(CONFIG_FB_VALKYRIE)         += valkyriefb.o
 obj-$(CONFIG_FB_CT65550)          += chipsfb.o
 obj-$(CONFIG_FB_IMSTT)            += imsttfb.o
 obj-$(CONFIG_FB_FM2)              += fm2fb.o
+obj-$(CONFIG_FB_VT8623)           += vt8623fb.o
 obj-$(CONFIG_FB_CYBLA)            += cyblafb.o
 obj-$(CONFIG_FB_TRIDENT)          += tridentfb.o
 obj-$(CONFIG_FB_LE80578)          += vermilion/
 obj-$(CONFIG_FB_S3)               += s3fb.o
+obj-$(CONFIG_FB_ARK)              += arkfb.o
 obj-$(CONFIG_FB_STI)              += stifb.o
 obj-$(CONFIG_FB_FFB)              += ffb.o sbuslib.o
 obj-$(CONFIG_FB_CG6)              += cg6.o sbuslib.o
diff --git a/drivers/video/arkfb.c b/drivers/video/arkfb.c
new file mode 100644
index 000000000000..ba6fede5c466
--- /dev/null
+++ b/drivers/video/arkfb.c
@@ -0,0 +1,1200 @@
+/*
+ *  linux/drivers/video/arkfb.c -- Frame buffer device driver for ARK 2000PV
+ *  with ICS 5342 dac (it is easy to add support for different dacs).
+ *
+ *  Copyright (c) 2007 Ondrej Zajicek <santiago@crfreenet.org>
+ *
+ *  This file is subject to the terms and conditions of the GNU General Public
+ *  License.  See the file COPYING in the main directory of this archive for
+ *  more details.
+ *
+ *  Code is based on s3fb
+ */
+
+#include <linux/version.h>
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/errno.h>
+#include <linux/string.h>
+#include <linux/mm.h>
+#include <linux/tty.h>
+#include <linux/slab.h>
+#include <linux/delay.h>
+#include <linux/fb.h>
+#include <linux/svga.h>
+#include <linux/init.h>
+#include <linux/pci.h>
+#include <linux/console.h> /* Why should fb driver call console functions? because acquire_console_sem() */
+#include <video/vga.h>
+
+#ifdef CONFIG_MTRR
+#include <asm/mtrr.h>
+#endif
+
+struct arkfb_info {
+        int mclk_freq;
+        int mtrr_reg;
+
+        struct dac_info *dac;
+        struct vgastate state;
+        struct mutex open_lock;
+        unsigned int ref_count;
+        u32 pseudo_palette[16];
+};
+
+
+/* ------------------------------------------------------------------------- */
+
+
+static const struct svga_fb_format arkfb_formats[] = {
+        { 0,  {0, 6, 0},  {0, 6, 0},  {0, 6, 0}, {0, 0, 0}, 0,
+                FB_TYPE_TEXT, FB_AUX_TEXT_SVGA_STEP4,   FB_VISUAL_PSEUDOCOLOR, 8, 8},
+        { 4,  {0, 6, 0},  {0, 6, 0},  {0, 6, 0}, {0, 0, 0}, 0,
+                FB_TYPE_PACKED_PIXELS, 0,               FB_VISUAL_PSEUDOCOLOR, 8, 16},
+        { 4,  {0, 6, 0},  {0, 6, 0},  {0, 6, 0}, {0, 0, 0}, 1,
+                FB_TYPE_INTERLEAVED_PLANES, 1,          FB_VISUAL_PSEUDOCOLOR, 8, 16},
+        { 8,  {0, 6, 0},  {0, 6, 0},  {0, 6, 0}, {0, 0, 0}, 0,
+                FB_TYPE_PACKED_PIXELS, 0,               FB_VISUAL_PSEUDOCOLOR, 8, 8},
+        {16,  {10, 5, 0}, {5, 5, 0},  {0, 5, 0}, {0, 0, 0}, 0,
+                FB_TYPE_PACKED_PIXELS, 0,               FB_VISUAL_TRUECOLOR, 4, 4},
+        {16,  {11, 5, 0}, {5, 6, 0},  {0, 5, 0}, {0, 0, 0}, 0,
+                FB_TYPE_PACKED_PIXELS, 0,               FB_VISUAL_TRUECOLOR, 4, 4},
+        {24,  {16, 8, 0}, {8, 8, 0},  {0, 8, 0}, {0, 0, 0}, 0,
+                FB_TYPE_PACKED_PIXELS, 0,               FB_VISUAL_TRUECOLOR, 8, 8},
+        {32,  {16, 8, 0}, {8, 8, 0},  {0, 8, 0}, {0, 0, 0}, 0,
+                FB_TYPE_PACKED_PIXELS, 0,               FB_VISUAL_TRUECOLOR, 2, 2},
+        SVGA_FORMAT_END
+};
+
+
+/* CRT timing register sets */
+
+static const struct vga_regset ark_h_total_regs[]        = {{0x00, 0, 7}, {0x41, 7, 7}, VGA_REGSET_END};
+static const struct vga_regset ark_h_display_regs[]      = {{0x01, 0, 7}, {0x41, 6, 6}, VGA_REGSET_END};
+static const struct vga_regset ark_h_blank_start_regs[]  = {{0x02, 0, 7}, {0x41, 5, 5}, VGA_REGSET_END};
+static const struct vga_regset ark_h_blank_end_regs[]    = {{0x03, 0, 4}, {0x05, 7, 7   }, VGA_REGSET_END};
+static const struct vga_regset ark_h_sync_start_regs[]   = {{0x04, 0, 7}, {0x41, 4, 4}, VGA_REGSET_END};
+static const struct vga_regset ark_h_sync_end_regs[]     = {{0x05, 0, 4}, VGA_REGSET_END};
+
+static const struct vga_regset ark_v_total_regs[]        = {{0x06, 0, 7}, {0x07, 0, 0}, {0x07, 5, 5}, {0x40, 7, 7}, VGA_REGSET_END};
+static const struct vga_regset ark_v_display_regs[]      = {{0x12, 0, 7}, {0x07, 1, 1}, {0x07, 6, 6}, {0x40, 6, 6}, VGA_REGSET_END};
+static const struct vga_regset ark_v_blank_start_regs[]  = {{0x15, 0, 7}, {0x07, 3, 3}, {0x09, 5, 5}, {0x40, 5, 5}, VGA_REGSET_END};
+// const struct vga_regset ark_v_blank_end_regs[]    = {{0x16, 0, 6}, VGA_REGSET_END};
+static const struct vga_regset ark_v_blank_end_regs[]    = {{0x16, 0, 7}, VGA_REGSET_END};
+static const struct vga_regset ark_v_sync_start_regs[]   = {{0x10, 0, 7}, {0x07, 2, 2}, {0x07, 7, 7}, {0x40, 4, 4}, VGA_REGSET_END};
+static const struct vga_regset ark_v_sync_end_regs[]     = {{0x11, 0, 3}, VGA_REGSET_END};
+
+static const struct vga_regset ark_line_compare_regs[]   = {{0x18, 0, 7}, {0x07, 4, 4}, {0x09, 6, 6}, VGA_REGSET_END};
+static const struct vga_regset ark_start_address_regs[]  = {{0x0d, 0, 7}, {0x0c, 0, 7}, {0x40, 0, 2}, VGA_REGSET_END};
+static const struct vga_regset ark_offset_regs[]         = {{0x13, 0, 7}, {0x41, 3, 3}, VGA_REGSET_END};
+
+static const struct svga_timing_regs ark_timing_regs     = {
+        ark_h_total_regs, ark_h_display_regs, ark_h_blank_start_regs,
+        ark_h_blank_end_regs, ark_h_sync_start_regs, ark_h_sync_end_regs,
+        ark_v_total_regs, ark_v_display_regs, ark_v_blank_start_regs,
+        ark_v_blank_end_regs, ark_v_sync_start_regs, ark_v_sync_end_regs,
+};
+
+
+/* ------------------------------------------------------------------------- */
+
+
+/* Module parameters */
+
+static char *mode = "640x480-8@60";
+
+#ifdef CONFIG_MTRR
+static int mtrr = 1;
+#endif
+
+MODULE_AUTHOR("(c) 2007 Ondrej Zajicek <santiago@crfreenet.org>");
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("fbdev driver for ARK 2000PV");
+
+module_param(mode, charp, 0444);
+MODULE_PARM_DESC(mode, "Default video mode ('640x480-8@60', etc)");
+
+#ifdef CONFIG_MTRR
+module_param(mtrr, int, 0444);
+MODULE_PARM_DESC(mtrr, "Enable write-combining with MTRR (1=enable, 0=disable, default=1)");
+#endif
+
+static int threshold = 4;
+
+module_param(threshold, int, 0644);
+MODULE_PARM_DESC(threshold, "FIFO threshold");
+
+
+/* ------------------------------------------------------------------------- */
+
+
+static void arkfb_settile(struct fb_info *info, struct fb_tilemap *map)
+{
+        const u8 *font = map->data;
+        u8 __iomem *fb = (u8 __iomem *)info->screen_base;
+        int i, c;
+
+        if ((map->width != 8) || (map->height != 16) ||
+            (map->depth != 1) || (map->length != 256)) {
+                printk(KERN_ERR "fb%d: unsupported font parameters: width %d, "
+                       "height %d, depth %d, length %d\n", info->node,
+                       map->width, map->height, map->depth, map->length);
+                return;
+        }
+
+        fb += 2;
+        for (c = 0; c < map->length; c++) {
+                for (i = 0; i < map->height; i++) {
+                        fb_writeb(font[i], &fb[i * 4]);
+                        fb_writeb(font[i], &fb[i * 4 + (128 * 8)]);
+                }
+                fb += 128;
+
+                if ((c % 8) == 7)
+                        fb += 128*8;
+
+                font += map->height;
+        }
+}
+
+static struct fb_tile_ops arkfb_tile_ops = {
+        .fb_settile     = arkfb_settile,
+        .fb_tilecopy    = svga_tilecopy,
+        .fb_tilefill    = svga_tilefill,
+        .fb_tileblit    = svga_tileblit,
+        .fb_tilecursor  = svga_tilecursor,
+        .fb_get_tilemax = svga_get_tilemax,
+};
+
+
+/* ------------------------------------------------------------------------- */
+
+
+/* image data is MSB-first, fb structure is MSB-first too */
+static inline u32 expand_color(u32 c)
+{
+        return ((c & 1) | ((c & 2) << 7) | ((c & 4) << 14) | ((c & 8) << 21)) * 0xFF;
+}
+
+/* arkfb_iplan_imageblit silently assumes that almost everything is 8-pixel aligned */
+static void arkfb_iplan_imageblit(struct fb_info *info, const struct fb_image *image)
+{
+        u32 fg = expand_color(image->fg_color);
+        u32 bg = expand_color(image->bg_color);
+        const u8 *src1, *src;
+        u8 __iomem *dst1;
+        u32 __iomem *dst;
+        u32 val;
+        int x, y;
+
+        src1 = image->data;
+        dst1 = info->screen_base + (image->dy * info->fix.line_length)
+                 + ((image->dx / 8) * 4);
+
+        for (y = 0; y < image->height; y++) {
+                src = src1;
+                dst = (u32 __iomem *) dst1;
+                for (x = 0; x < image->width; x += 8) {
+                        val = *(src++) * 0x01010101;
+                        val = (val & fg) | (~val & bg);
+                        fb_writel(val, dst++);
+                }
+                src1 += image->width / 8;
+                dst1 += info->fix.line_length;
+        }
+
+}
+
+/* arkfb_iplan_fillrect silently assumes that almost everything is 8-pixel aligned */
+static void arkfb_iplan_fillrect(struct fb_info *info, const struct fb_fillrect *rect)
+{
+        u32 fg = expand_color(rect->color);
+        u8 __iomem *dst1;
+        u32 __iomem *dst;
+        int x, y;
+
+        dst1 = info->screen_base + (rect->dy * info->fix.line_length)
+                 + ((rect->dx / 8) * 4);
+
+        for (y = 0; y < rect->height; y++) {
+                dst = (u32 __iomem *) dst1;
+                for (x = 0; x < rect->width; x += 8) {
+                        fb_writel(fg, dst++);
+                }
+                dst1 += info->fix.line_length;
+        }
+
+}
+
+
+/* image data is MSB-first, fb structure is high-nibble-in-low-byte-first */
+static inline u32 expand_pixel(u32 c)
+{
+        return (((c &  1) << 24) | ((c &  2) << 27) | ((c &  4) << 14) | ((c &   8) << 17) |
+                ((c & 16) <<  4) | ((c & 32) <<  7) | ((c & 64) >>  6) | ((c & 128) >>  3)) * 0xF;
+}
+
+/* arkfb_cfb4_imageblit silently assumes that almost everything is 8-pixel aligned */
+static void arkfb_cfb4_imageblit(struct fb_info *info, const struct fb_image *image)
+{
+        u32 fg = image->fg_color * 0x11111111;
+        u32 bg = image->bg_color * 0x11111111;
+        const u8 *src1, *src;
+        u8 __iomem *dst1;
+        u32 __iomem *dst;
+        u32 val;
+        int x, y;
+
+        src1 = image->data;
+        dst1 = info->screen_base + (image->dy * info->fix.line_length)
+                 + ((image->dx / 8) * 4);
+
+        for (y = 0; y < image->height; y++) {
+                src = src1;
+                dst = (u32 __iomem *) dst1;
+                for (x = 0; x < image->width; x += 8) {
+                        val = expand_pixel(*(src++));
+                        val = (val & fg) | (~val & bg);
+                        fb_writel(val, dst++);
+                }
+                src1 += image->width / 8;
+                dst1 += info->fix.line_length;
+        }
+
+}
+
+static void arkfb_imageblit(struct fb_info *info, const struct fb_image *image)
+{
+        if ((info->var.bits_per_pixel == 4) && (image->depth == 1)
+            && ((image->width % 8) == 0) && ((image->dx % 8) == 0)) {
+                if (info->fix.type == FB_TYPE_INTERLEAVED_PLANES)
+                        arkfb_iplan_imageblit(info, image);
+                else
+                        arkfb_cfb4_imageblit(info, image);
+        } else
+                cfb_imageblit(info, image);
+}
+
+static void arkfb_fillrect(struct fb_info *info, const struct fb_fillrect *rect)
+{
+        if ((info->var.bits_per_pixel == 4)
+            && ((rect->width % 8) == 0) && ((rect->dx % 8) == 0)
+            && (info->fix.type == FB_TYPE_INTERLEAVED_PLANES))
+                arkfb_iplan_fillrect(info, rect);
+         else
+                cfb_fillrect(info, rect);
+}
+
+
+/* ------------------------------------------------------------------------- */
+
+
+enum
+{
+        DAC_PSEUDO8_8,
+        DAC_RGB1555_8,
+        DAC_RGB0565_8,
+        DAC_RGB0888_8,
+        DAC_RGB8888_8,
+        DAC_PSEUDO8_16,
+        DAC_RGB1555_16,
+        DAC_RGB0565_16,
+        DAC_RGB0888_16,
+        DAC_RGB8888_16,
+        DAC_MAX
+};
+
+struct dac_ops {
+        int (*dac_get_mode)(struct dac_info *info);
+        int (*dac_set_mode)(struct dac_info *info, int mode);
+        int (*dac_get_freq)(struct dac_info *info, int channel);
+        int (*dac_set_freq)(struct dac_info *info, int channel, u32 freq);
+        void (*dac_release)(struct dac_info *info);
+};
+
+typedef void (*dac_read_regs_t)(void *data, u8 *code, int count);
+typedef void (*dac_write_regs_t)(void *data, u8 *code, int count);
+
+struct dac_info
+{
+        struct dac_ops *dacops;
+        dac_read_regs_t dac_read_regs;
+        dac_write_regs_t dac_write_regs;
+        void *data;
+};
+
+
+static inline u8 dac_read_reg(struct dac_info *info, u8 reg)
+{
+        u8 code[2] = {reg, 0};
+        info->dac_read_regs(info->data, code, 1);
+        return code[1];
+}
+
+static inline void dac_read_regs(struct dac_info *info, u8 *code, int count)
+{
+        info->dac_read_regs(info->data, code, count);
+}
+
+static inline void dac_write_reg(struct dac_info *info, u8 reg, u8 val)
+{
+        u8 code[2] = {reg, val};
+        info->dac_write_regs(info->data, code, 1);
+}
+
+static inline void dac_write_regs(struct dac_info *info, u8 *code, int count)
+{
+        info->dac_write_regs(info->data, code, count);
+}
+
+static inline int dac_set_mode(struct dac_info *info, int mode)
+{
+        return info->dacops->dac_set_mode(info, mode);
+}
+
+static inline int dac_set_freq(struct dac_info *info, int channel, u32 freq)
+{
+        return info->dacops->dac_set_freq(info, channel, freq);
+}
+
+static inline void dac_release(struct dac_info *info)
+{
+        info->dacops->dac_release(info);
+}
+
+
+/* ------------------------------------------------------------------------- */
+
+
+/* ICS5342 DAC */
+
+struct ics5342_info
+{
+        struct dac_info dac;
+        u8 mode;
+};
+
+#define DAC_PAR(info) ((struct ics5342_info *) info)
+
+/* LSB is set to distinguish unused slots */
+static const u8 ics5342_mode_table[DAC_MAX] = {
+        [DAC_PSEUDO8_8]  = 0x01, [DAC_RGB1555_8]  = 0x21, [DAC_RGB0565_8]  = 0x61,
+        [DAC_RGB0888_8]  = 0x41, [DAC_PSEUDO8_16] = 0x11, [DAC_RGB1555_16] = 0x31,
+        [DAC_RGB0565_16] = 0x51, [DAC_RGB0888_16] = 0x91, [DAC_RGB8888_16] = 0x71
+};
+
+static int ics5342_set_mode(struct dac_info *info, int mode)
+{
+        u8 code;
+
+        if (mode >= DAC_MAX)
+                return -EINVAL;
+
+        code = ics5342_mode_table[mode];
+
+        if (! code)
+                return -EINVAL;
+
+        dac_write_reg(info, 6, code & 0xF0);
+        DAC_PAR(info)->mode = mode;
+
+        return 0;
+}
+
+static const struct svga_pll ics5342_pll = {3, 129, 3, 33, 0, 3,
+        60000, 250000, 14318};
+
+/* pd4 - allow only posdivider 4 (r=2) */
+static const struct svga_pll ics5342_pll_pd4 = {3, 129, 3, 33, 2, 2,
+        60000, 335000, 14318};
+
+/* 270 MHz should be upper bound for VCO clock according to specs,
+   but that is too restrictive in pd4 case */
+
+static int ics5342_set_freq(struct dac_info *info, int channel, u32 freq)
+{
+        u16 m, n, r;
+
+        /* only postdivider 4 (r=2) is valid in mode DAC_PSEUDO8_16 */
+        int rv = svga_compute_pll((DAC_PAR(info)->mode == DAC_PSEUDO8_16)
+                                  ? &ics5342_pll_pd4 : &ics5342_pll,
+                                  freq, &m, &n, &r, 0);
+
+        if (rv < 0) {
+                return -EINVAL;
+        } else {
+                u8 code[6] = {4, 3, 5, m-2, 5, (n-2) | (r << 5)};
+                dac_write_regs(info, code, 3);
+                return 0;
+        }
+}
+
+static void ics5342_release(struct dac_info *info)
+{
+        ics5342_set_mode(info, DAC_PSEUDO8_8);
+        kfree(info);
+}
+
+static struct dac_ops ics5342_ops = {
+        .dac_set_mode   = ics5342_set_mode,
+        .dac_set_freq   = ics5342_set_freq,
+        .dac_release    = ics5342_release
+};
+
+
+static struct dac_info * ics5342_init(dac_read_regs_t drr, dac_write_regs_t dwr, void *data)
+{
+        struct dac_info *info = kzalloc(sizeof(struct ics5342_info), GFP_KERNEL);
+
+        if (! info)
+                return NULL;
+
+        info->dacops = &ics5342_ops;
+        info->dac_read_regs = drr;
+        info->dac_write_regs = dwr;
+        info->data = data;
+        DAC_PAR(info)->mode = DAC_PSEUDO8_8; /* estimation */
+        return info;
+}
+
+
+/* ------------------------------------------------------------------------- */
+
+
+static unsigned short dac_regs[4] = {0x3c8, 0x3c9, 0x3c6, 0x3c7};
+
+static void ark_dac_read_regs(void *data, u8 *code, int count)
+{
+        u8 regval = vga_rseq(NULL, 0x1C);
+
+        while (count != 0)
+        {
+                vga_wseq(NULL, 0x1C, regval | (code[0] & 4) ? 0x80 : 0);
+                code[1] = vga_r(NULL, dac_regs[code[0] & 3]);
+                count--;
+                code += 2;
+        }
+
+        vga_wseq(NULL, 0x1C, regval);
+}
+
+static void ark_dac_write_regs(void *data, u8 *code, int count)
+{
+        u8 regval = vga_rseq(NULL, 0x1C);
+
+        while (count != 0)
+        {
+                vga_wseq(NULL, 0x1C, regval | (code[0] & 4) ? 0x80 : 0);
+                vga_w(NULL, dac_regs[code[0] & 3], code[1]);
+                count--;
+                code += 2;
+        }
+
+        vga_wseq(NULL, 0x1C, regval);
+}
+
+
+static void ark_set_pixclock(struct fb_info *info, u32 pixclock)
+{
+        struct arkfb_info *par = info->par;
+        u8 regval;
+
+        int rv = dac_set_freq(par->dac, 0, 1000000000 / pixclock);
+        if (rv < 0) {
+                printk(KERN_ERR "fb%d: cannot set requested pixclock, keeping old value\n", info->node);
+                return;
+        }
+
+        /* Set VGA misc register  */
+        regval = vga_r(NULL, VGA_MIS_R);
+        vga_w(NULL, VGA_MIS_W, regval | VGA_MIS_ENB_PLL_LOAD);
+}
+
+
+/* Open framebuffer */
+
+static int arkfb_open(struct fb_info *info, int user)
+{
+        struct arkfb_info *par = info->par;
+
+        mutex_lock(&(par->open_lock));
+        if (par->ref_count == 0) {
+                memset(&(par->state), 0, sizeof(struct vgastate));
+                par->state.flags = VGA_SAVE_MODE | VGA_SAVE_FONTS | VGA_SAVE_CMAP;
+                par->state.num_crtc = 0x60;
+                par->state.num_seq = 0x30;
+                save_vga(&(par->state));
+        }
+
+        par->ref_count++;
+        mutex_unlock(&(par->open_lock));
+
+        return 0;
+}
+
+/* Close framebuffer */
+
+static int arkfb_release(struct fb_info *info, int user)
+{
+        struct arkfb_info *par = info->par;
+
+        mutex_lock(&(par->open_lock));
+        if (par->ref_count == 0) {
+                mutex_unlock(&(par->open_lock));
+                return -EINVAL;
+        }
+
+        if (par->ref_count == 1) {
+                restore_vga(&(par->state));
+                dac_set_mode(par->dac, DAC_PSEUDO8_8);
+        }
+
+        par->ref_count--;
+        mutex_unlock(&(par->open_lock));
+
+        return 0;
+}
+
+/* Validate passed in var */
+
+static int arkfb_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
+{
+        int rv, mem, step;
+
+        /* Find appropriate format */
+        rv = svga_match_format (arkfb_formats, var, NULL);
+        if (rv < 0)
+        {
+                printk(KERN_ERR "fb%d: unsupported mode requested\n", info->node);
+                return rv;
+        }
+
+        /* Do not allow to have real resoulution larger than virtual */
+        if (var->xres > var->xres_virtual)
+                var->xres_virtual = var->xres;
+
+        if (var->yres > var->yres_virtual)
+                var->yres_virtual = var->yres;
+
+        /* Round up xres_virtual to have proper alignment of lines */
+        step = arkfb_formats[rv].xresstep - 1;
+        var->xres_virtual = (var->xres_virtual+step) & ~step;
+
+
+        /* Check whether have enough memory */
+        mem = ((var->bits_per_pixel * var->xres_virtual) >> 3) * var->yres_virtual;
+        if (mem > info->screen_size)
+        {
+                printk(KERN_ERR "fb%d: not enough framebuffer memory (%d kB requested , %d kB available)\n", info->node, mem >> 10, (unsigned int) (info->screen_size >> 10));
+                return -EINVAL;
+        }
+
+        rv = svga_check_timings (&ark_timing_regs, var, info->node);
+        if (rv < 0)
+        {
+                printk(KERN_ERR "fb%d: invalid timings requested\n", info->node);
+                return rv;
+        }
+
+        /* Interlaced mode is broken */
+        if (var->vmode & FB_VMODE_INTERLACED)
+                return -EINVAL;
+
+        return 0;
+}
+
+/* Set video mode from par */
+
+static int arkfb_set_par(struct fb_info *info)
+{
+        struct arkfb_info *par = info->par;
+        u32 value, mode, hmul, hdiv, offset_value, screen_size;
+        u32 bpp = info->var.bits_per_pixel;
+        u8 regval;
+
+        if (bpp != 0) {
+                info->fix.ypanstep = 1;
+                info->fix.line_length = (info->var.xres_virtual * bpp) / 8;
+
+                info->flags &= ~FBINFO_MISC_TILEBLITTING;
+                info->tileops = NULL;
+
+                /* in 4bpp supports 8p wide tiles only, any tiles otherwise */
+                info->pixmap.blit_x = (bpp == 4) ? (1 << (8 - 1)) : (~(u32)0);
+                info->pixmap.blit_y = ~(u32)0;
+
+                offset_value = (info->var.xres_virtual * bpp) / 64;
+                screen_size = info->var.yres_virtual * info->fix.line_length;
+        } else {
+                info->fix.ypanstep = 16;
+                info->fix.line_length = 0;
+
+                info->flags |= FBINFO_MISC_TILEBLITTING;
+                info->tileops = &arkfb_tile_ops;
+
+                /* supports 8x16 tiles only */
+                info->pixmap.blit_x = 1 << (8 - 1);
+                info->pixmap.blit_y = 1 << (16 - 1);
+
+                offset_value = info->var.xres_virtual / 16;
+                screen_size = (info->var.xres_virtual * info->var.yres_virtual) / 64;
+        }
+
+        info->var.xoffset = 0;
+        info->var.yoffset = 0;
+        info->var.activate = FB_ACTIVATE_NOW;
+
+        /* Unlock registers */
+        svga_wcrt_mask(0x11, 0x00, 0x80);
+
+        /* Blank screen and turn off sync */
+        svga_wseq_mask(0x01, 0x20, 0x20);
+        svga_wcrt_mask(0x17, 0x00, 0x80);
+
+        /* Set default values */
+        svga_set_default_gfx_regs();
+        svga_set_default_atc_regs();
+        svga_set_default_seq_regs();
+        svga_set_default_crt_regs();
+        svga_wcrt_multi(ark_line_compare_regs, 0xFFFFFFFF);
+        svga_wcrt_multi(ark_start_address_regs, 0);
+
+        /* ARK specific initialization */
+        svga_wseq_mask(0x10, 0x1F, 0x1F); /* enable linear framebuffer and full memory access */
+        svga_wseq_mask(0x12, 0x03, 0x03); /* 4 MB linear framebuffer size */
+
+        vga_wseq(NULL, 0x13, info->fix.smem_start >> 16);
+        vga_wseq(NULL, 0x14, info->fix.smem_start >> 24);
+        vga_wseq(NULL, 0x15, 0);
+        vga_wseq(NULL, 0x16, 0);
+
+        /* Set the FIFO threshold register */
+        /* It is fascinating way to store 5-bit value in 8-bit register */
+        regval = 0x10 | ((threshold & 0x0E) >> 1) | (threshold & 0x01) << 7 | (threshold & 0x10) << 1;
+        vga_wseq(NULL, 0x18, regval);
+
+        /* Set the offset register */
+        pr_debug("fb%d: offset register       : %d\n", info->node, offset_value);
+        svga_wcrt_multi(ark_offset_regs, offset_value);
+
+        /* fix for hi-res textmode */
+        svga_wcrt_mask(0x40, 0x08, 0x08);
+
+        if (info->var.vmode & FB_VMODE_DOUBLE)
+                svga_wcrt_mask(0x09, 0x80, 0x80);
+        else
+                svga_wcrt_mask(0x09, 0x00, 0x80);
+
+        if (info->var.vmode & FB_VMODE_INTERLACED)
+                svga_wcrt_mask(0x44, 0x04, 0x04);
+        else
+                svga_wcrt_mask(0x44, 0x00, 0x04);
+
+        hmul = 1;
+        hdiv = 1;
+        mode = svga_match_format(arkfb_formats, &(info->var), &(info->fix));
+
+        /* Set mode-specific register values */
+        switch (mode) {
+        case 0:
+                pr_debug("fb%d: text mode\n", info->node);
+                svga_set_textmode_vga_regs();
+
+                vga_wseq(NULL, 0x11, 0x10); /* basic VGA mode */
+                svga_wcrt_mask(0x46, 0x00, 0x04); /* 8bit pixel path */
+                dac_set_mode(par->dac, DAC_PSEUDO8_8);
+
+                break;
+        case 1:
+                pr_debug("fb%d: 4 bit pseudocolor\n", info->node);
+                vga_wgfx(NULL, VGA_GFX_MODE, 0x40);
+
+                vga_wseq(NULL, 0x11, 0x10); /* basic VGA mode */
+                svga_wcrt_mask(0x46, 0x00, 0x04); /* 8bit pixel path */
+                dac_set_mode(par->dac, DAC_PSEUDO8_8);
+                break;
+        case 2:
+                pr_debug("fb%d: 4 bit pseudocolor, planar\n", info->node);
+
+                vga_wseq(NULL, 0x11, 0x10); /* basic VGA mode */
+                svga_wcrt_mask(0x46, 0x00, 0x04); /* 8bit pixel path */
+                dac_set_mode(par->dac, DAC_PSEUDO8_8);
+                break;
+        case 3:
+                pr_debug("fb%d: 8 bit pseudocolor\n", info->node);
+
+                vga_wseq(NULL, 0x11, 0x16); /* 8bpp accel mode */
+
+                if (info->var.pixclock > 20000) {
+                        pr_debug("fb%d: not using multiplex\n", info->node);
+                        svga_wcrt_mask(0x46, 0x00, 0x04); /* 8bit pixel path */
+                        dac_set_mode(par->dac, DAC_PSEUDO8_8);
+                } else {
+                        pr_debug("fb%d: using multiplex\n", info->node);
+                        svga_wcrt_mask(0x46, 0x04, 0x04); /* 16bit pixel path */
+                        dac_set_mode(par->dac, DAC_PSEUDO8_16);
+                        hdiv = 2;
+                }
+                break;
+        case 4:
+                pr_debug("fb%d: 5/5/5 truecolor\n", info->node);
+
+                vga_wseq(NULL, 0x11, 0x1A); /* 16bpp accel mode */
+                svga_wcrt_mask(0x46, 0x04, 0x04); /* 16bit pixel path */
+                dac_set_mode(par->dac, DAC_RGB1555_16);
+                break;
+        case 5:
+                pr_debug("fb%d: 5/6/5 truecolor\n", info->node);
+
+                vga_wseq(NULL, 0x11, 0x1A); /* 16bpp accel mode */
+                svga_wcrt_mask(0x46, 0x04, 0x04); /* 16bit pixel path */
+                dac_set_mode(par->dac, DAC_RGB0565_16);
+                break;
+        case 6:
+                pr_debug("fb%d: 8/8/8 truecolor\n", info->node);
+
+                vga_wseq(NULL, 0x11, 0x16); /* 8bpp accel mode ??? */
+                svga_wcrt_mask(0x46, 0x04, 0x04); /* 16bit pixel path */
+                dac_set_mode(par->dac, DAC_RGB0888_16);
+                hmul = 3;
+                hdiv = 2;
+                break;
+        case 7:
+                pr_debug("fb%d: 8/8/8/8 truecolor\n", info->node);
+
+                vga_wseq(NULL, 0x11, 0x1E); /* 32bpp accel mode */
+                svga_wcrt_mask(0x46, 0x04, 0x04); /* 16bit pixel path */
+                dac_set_mode(par->dac, DAC_RGB8888_16);
+                hmul = 2;
+                break;
+        default:
+                printk(KERN_ERR "fb%d: unsupported mode - bug\n", info->node);
+                return -EINVAL;
+        }
+
+        ark_set_pixclock(info, (hdiv * info->var.pixclock) / hmul);
+        svga_set_timings(&ark_timing_regs, &(info->var), hmul, hdiv,
+                         (info->var.vmode & FB_VMODE_DOUBLE)     ? 2 : 1,
+                         (info->var.vmode & FB_VMODE_INTERLACED) ? 2 : 1,
+                          hmul, info->node);
+
+        /* Set interlaced mode start/end register */
+        value = info->var.xres + info->var.left_margin + info->var.right_margin + info->var.hsync_len;
+        value = ((value * hmul / hdiv) / 8) - 5;
+        vga_wcrt(NULL, 0x42, (value + 1) / 2);
+
+        memset_io(info->screen_base, 0x00, screen_size);
+        /* Device and screen back on */
+        svga_wcrt_mask(0x17, 0x80, 0x80);
+        svga_wseq_mask(0x01, 0x00, 0x20);
+
+        return 0;
+}
+
+/* Set a colour register */
+
+static int arkfb_setcolreg(u_int regno, u_int red, u_int green, u_int blue,
+                                u_int transp, struct fb_info *fb)
+{
+        switch (fb->var.bits_per_pixel) {
+        case 0:
+        case 4:
+                if (regno >= 16)
+                        return -EINVAL;
+
+                if ((fb->var.bits_per_pixel == 4) &&
+                    (fb->var.nonstd == 0)) {
+                        outb(0xF0, VGA_PEL_MSK);
+                        outb(regno*16, VGA_PEL_IW);
+                } else {
+                        outb(0x0F, VGA_PEL_MSK);
+                        outb(regno, VGA_PEL_IW);
+                }
+                outb(red >> 10, VGA_PEL_D);
+                outb(green >> 10, VGA_PEL_D);
+                outb(blue >> 10, VGA_PEL_D);
+                break;
+        case 8:
+                if (regno >= 256)
+                        return -EINVAL;
+
+                outb(0xFF, VGA_PEL_MSK);
+                outb(regno, VGA_PEL_IW);
+                outb(red >> 10, VGA_PEL_D);
+                outb(green >> 10, VGA_PEL_D);
+                outb(blue >> 10, VGA_PEL_D);
+                break;
+        case 16:
+                if (regno >= 16)
+                        return 0;
+
+                if (fb->var.green.length == 5)
+                        ((u32*)fb->pseudo_palette)[regno] = ((red & 0xF800) >> 1) |
+                                ((green & 0xF800) >> 6) | ((blue & 0xF800) >> 11);
+                else if (fb->var.green.length == 6)
+                        ((u32*)fb->pseudo_palette)[regno] = (red & 0xF800) |
+                                ((green & 0xFC00) >> 5) | ((blue & 0xF800) >> 11);
+                else
+                        return -EINVAL;
+                break;
+        case 24:
+        case 32:
+                if (regno >= 16)
+                        return 0;
+
+                ((u32*)fb->pseudo_palette)[regno] = ((red & 0xFF00) << 8) |
+                        (green & 0xFF00) | ((blue & 0xFF00) >> 8);
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+/* Set the display blanking state */
+
+static int arkfb_blank(int blank_mode, struct fb_info *info)
+{
+        switch (blank_mode) {
+        case FB_BLANK_UNBLANK:
+                pr_debug("fb%d: unblank\n", info->node);
+                svga_wseq_mask(0x01, 0x00, 0x20);
+                svga_wcrt_mask(0x17, 0x80, 0x80);
+                break;
+        case FB_BLANK_NORMAL:
+                pr_debug("fb%d: blank\n", info->node);
+                svga_wseq_mask(0x01, 0x20, 0x20);
+                svga_wcrt_mask(0x17, 0x80, 0x80);
+                break;
+        case FB_BLANK_POWERDOWN:
+        case FB_BLANK_HSYNC_SUSPEND:
+        case FB_BLANK_VSYNC_SUSPEND:
+                pr_debug("fb%d: sync down\n", info->node);
+                svga_wseq_mask(0x01, 0x20, 0x20);
+                svga_wcrt_mask(0x17, 0x00, 0x80);
+                break;
+        }
+        return 0;
+}
+
+
+/* Pan the display */
+
+static int arkfb_pan_display(struct fb_var_screeninfo *var, struct fb_info *info)
+{
+        unsigned int offset;
+
+        /* Calculate the offset */
+        if (var->bits_per_pixel == 0) {
+                offset = (var->yoffset / 16) * (var->xres_virtual / 2) + (var->xoffset / 2);
+                offset = offset >> 2;
+        } else {
+                offset = (var->yoffset * info->fix.line_length) +
+                         (var->xoffset * var->bits_per_pixel / 8);
+                offset = offset >> ((var->bits_per_pixel == 4) ? 2 : 3);
+        }
+
+        /* Set the offset */
+        svga_wcrt_multi(ark_start_address_regs, offset);
+
+        return 0;
+}
+
+
+/* ------------------------------------------------------------------------- */
+
+
+/* Frame buffer operations */
+
+static struct fb_ops arkfb_ops = {
+        .owner          = THIS_MODULE,
+        .fb_open        = arkfb_open,
+        .fb_release     = arkfb_release,
+        .fb_check_var   = arkfb_check_var,
+        .fb_set_par     = arkfb_set_par,
+        .fb_setcolreg   = arkfb_setcolreg,
+        .fb_blank       = arkfb_blank,
+        .fb_pan_display = arkfb_pan_display,
+        .fb_fillrect    = arkfb_fillrect,
+        .fb_copyarea    = cfb_copyarea,
+        .fb_imageblit   = arkfb_imageblit,
+        .fb_get_caps    = svga_get_caps,
+};
+
+
+/* ------------------------------------------------------------------------- */
+
+
+/* PCI probe */
+static int __devinit ark_pci_probe(struct pci_dev *dev, const struct pci_device_id *id)
+{
+        struct fb_info *info;
+        struct arkfb_info *par;
+        int rc;
+        u8 regval;
+
+        /* Ignore secondary VGA device because there is no VGA arbitration */
+        if (! svga_primary_device(dev)) {
+                dev_info(&(dev->dev), "ignoring secondary device\n");
+                return -ENODEV;
+        }
+
+        /* Allocate and fill driver data structure */
+        info = framebuffer_alloc(sizeof(struct arkfb_info), NULL);
+        if (! info) {
+                dev_err(&(dev->dev), "cannot allocate memory\n");
+                return -ENOMEM;
+        }
+
+        par = info->par;
+        mutex_init(&par->open_lock);
+
+        info->flags = FBINFO_PARTIAL_PAN_OK | FBINFO_HWACCEL_YPAN;
+        info->fbops = &arkfb_ops;
+
+        /* Prepare PCI device */
+        rc = pci_enable_device(dev);
+        if (rc < 0) {
+                dev_err(&(dev->dev), "cannot enable PCI device\n");
+                goto err_enable_device;
+        }
+
+        rc = pci_request_regions(dev, "arkfb");
+        if (rc < 0) {
+                dev_err(&(dev->dev), "cannot reserve framebuffer region\n");
+                goto err_request_regions;
+        }
+
+        par->dac = ics5342_init(ark_dac_read_regs, ark_dac_write_regs, info);
+        if (! par->dac) {
+                rc = -ENOMEM;
+                dev_err(&(dev->dev), "RAMDAC initialization failed\n");
+                goto err_dac;
+        }
+
+        info->fix.smem_start = pci_resource_start(dev, 0);
+        info->fix.smem_len = pci_resource_len(dev, 0);
+
+        /* Map physical IO memory address into kernel space */
+        info->screen_base = pci_iomap(dev, 0, 0);
+        if (! info->screen_base) {
+                rc = -ENOMEM;
+                dev_err(&(dev->dev), "iomap for framebuffer failed\n");
+                goto err_iomap;
+        }
+
+        /* FIXME get memsize */
+        regval = vga_rseq(NULL, 0x10);
+        info->screen_size = (1 << (regval >> 6)) << 20;
+        info->fix.smem_len = info->screen_size;
+
+        strcpy(info->fix.id, "ARK 2000PV");
+        info->fix.mmio_start = 0;
+        info->fix.mmio_len = 0;
+        info->fix.type = FB_TYPE_PACKED_PIXELS;
+        info->fix.visual = FB_VISUAL_PSEUDOCOLOR;
+        info->fix.ypanstep = 0;
+        info->fix.accel = FB_ACCEL_NONE;
+        info->pseudo_palette = (void*) (par->pseudo_palette);
+
+        /* Prepare startup mode */
+        rc = fb_find_mode(&(info->var), info, mode, NULL, 0, NULL, 8);
+        if (! ((rc == 1) || (rc == 2))) {
+                rc = -EINVAL;
+                dev_err(&(dev->dev), "mode %s not found\n", mode);
+                goto err_find_mode;
+        }
+
+        rc = fb_alloc_cmap(&info->cmap, 256, 0);
+        if (rc < 0) {
+                dev_err(&(dev->dev), "cannot allocate colormap\n");
+                goto err_alloc_cmap;
+        }
+
+        rc = register_framebuffer(info);
+        if (rc < 0) {
+                dev_err(&(dev->dev), "cannot register framebugger\n");
+                goto err_reg_fb;
+        }
+
+        printk(KERN_INFO "fb%d: %s on %s, %d MB RAM\n", info->node, info->fix.id,
+                 pci_name(dev), info->fix.smem_len >> 20);
+
+        /* Record a reference to the driver data */
+        pci_set_drvdata(dev, info);
+
+#ifdef CONFIG_MTRR
+        if (mtrr) {
+                par->mtrr_reg = -1;
+                par->mtrr_reg = mtrr_add(info->fix.smem_start, info->fix.smem_len, MTRR_TYPE_WRCOMB, 1);
+        }
+#endif
+
+        return 0;
+
+        /* Error handling */
+err_reg_fb:
+        fb_dealloc_cmap(&info->cmap);
+err_alloc_cmap:
+err_find_mode:
+        pci_iounmap(dev, info->screen_base);
+err_iomap:
+        dac_release(par->dac);
+err_dac:
+        pci_release_regions(dev);
+err_request_regions:
+/*      pci_disable_device(dev); */
+err_enable_device:
+        framebuffer_release(info);
+        return rc;
+}
+
+/* PCI remove */
+
+static void __devexit ark_pci_remove(struct pci_dev *dev)
+{
+        struct fb_info *info = pci_get_drvdata(dev);
+        struct arkfb_info *par = info->par;
+
+        if (info) {
+#ifdef CONFIG_MTRR
+                if (par->mtrr_reg >= 0) {
+                        mtrr_del(par->mtrr_reg, 0, 0);
+                        par->mtrr_reg = -1;
+                }
+#endif
+
+                dac_release(par->dac);
+                unregister_framebuffer(info);
+                fb_dealloc_cmap(&info->cmap);
+
+                pci_iounmap(dev, info->screen_base);
+                pci_release_regions(dev);
+/*              pci_disable_device(dev); */
+
+                pci_set_drvdata(dev, NULL);
+                framebuffer_release(info);
+        }
+}
+
+
+#ifdef CONFIG_PM
+/* PCI suspend */
+
+static int ark_pci_suspend (struct pci_dev* dev, pm_message_t state)
+{
+        struct fb_info *info = pci_get_drvdata(dev);
+        struct arkfb_info *par = info->par;
+
+        dev_info(&(dev->dev), "suspend\n");
+
+        acquire_console_sem();
+        mutex_lock(&(par->open_lock));
+
+        if ((state.event == PM_EVENT_FREEZE) || (par->ref_count == 0)) {
+                mutex_unlock(&(par->open_lock));
+                release_console_sem();
+                return 0;
+        }
+
+        fb_set_suspend(info, 1);
+
+        pci_save_state(dev);
+        pci_disable_device(dev);
+        pci_set_power_state(dev, pci_choose_state(dev, state));
+
+        mutex_unlock(&(par->open_lock));
+        release_console_sem();
+
+        return 0;
+}
+
+
+/* PCI resume */
+
+static int ark_pci_resume (struct pci_dev* dev)
+{
+        struct fb_info *info = pci_get_drvdata(dev);
+        struct arkfb_info *par = info->par;
+
+        dev_info(&(dev->dev), "resume\n");
+
+        acquire_console_sem();
+        mutex_lock(&(par->open_lock));
+
+        if (par->ref_count == 0) {
+                mutex_unlock(&(par->open_lock));
+                release_console_sem();
+                return 0;
+        }
+
+        pci_set_power_state(dev, PCI_D0);
+        pci_restore_state(dev);
+
+        if (pci_enable_device(dev))
+                goto fail;
+
+        pci_set_master(dev);
+
+        arkfb_set_par(info);
+        fb_set_suspend(info, 0);
+
+        mutex_unlock(&(par->open_lock));
+fail:
+        release_console_sem();
+        return 0;
+}
+#else
+#define ark_pci_suspend NULL
+#define ark_pci_resume NULL
+#endif /* CONFIG_PM */
+
+/* List of boards that we are trying to support */
+
+static struct pci_device_id ark_devices[] __devinitdata = {
+        {PCI_DEVICE(0xEDD8, 0xA099)},
+        {0, 0, 0, 0, 0, 0, 0}
+};
+
+
+MODULE_DEVICE_TABLE(pci, ark_devices);
+
+static struct pci_driver arkfb_pci_driver = {
+        .name           = "arkfb",
+        .id_table       = ark_devices,
+        .probe          = ark_pci_probe,
+        .remove         = __devexit_p(ark_pci_remove),
+        .suspend        = ark_pci_suspend,
+        .resume         = ark_pci_resume,
+};
+
+/* Cleanup */
+
+static void __exit arkfb_cleanup(void)
+{
+        pr_debug("arkfb: cleaning up\n");
+        pci_unregister_driver(&arkfb_pci_driver);
+}
+
+/* Driver Initialisation */
+
+static int __init arkfb_init(void)
+{
+
+#ifndef MODULE
+        char *option = NULL;
+
+        if (fb_get_options("arkfb", &option))
+                return -ENODEV;
+
+        if (option && *option)
+                mode = option;
+#endif
+
+        pr_debug("arkfb: initializing\n");
+        return pci_register_driver(&arkfb_pci_driver);
+}
+
+module_init(arkfb_init);
+module_exit(arkfb_cleanup);
diff --git a/drivers/video/aty/atyfb_base.c b/drivers/video/aty/atyfb_base.c
index ea67dd902d4e..8d3455da663a 100644
--- a/drivers/video/aty/atyfb_base.c
+++ b/drivers/video/aty/atyfb_base.c
@@ -80,8 +80,9 @@
 #include "../macmodes.h"
 #endif
 #ifdef __sparc__
-#include <asm/pbm.h>
 #include <asm/fbio.h>
+#include <asm/oplib.h>
+#include <asm/prom.h>
 #endif
 
 #ifdef CONFIG_ADB_PMU
diff --git a/drivers/video/aty/mach64_cursor.c b/drivers/video/aty/mach64_cursor.c
index 2a7f381c330f..fe2c6ad01a8d 100644
--- a/drivers/video/aty/mach64_cursor.c
+++ b/drivers/video/aty/mach64_cursor.c
@@ -11,7 +11,6 @@
 #include <asm/uaccess.h>
 
 #ifdef __sparc__
-#include <asm/pbm.h>
 #include <asm/fbio.h>
 #endif
 
diff --git a/drivers/video/console/softcursor.c b/drivers/video/console/softcursor.c
index f577bd80e020..03cfb7ac5733 100644
--- a/drivers/video/console/softcursor.c
+++ b/drivers/video/console/softcursor.c
@@ -1,5 +1,5 @@
 /*
- * linux/drivers/video/softcursor.c
+ * linux/drivers/video/console/softcursor.c
  *
  * Generic software cursor for frame buffer devices
  *
diff --git a/drivers/video/fbmem.c b/drivers/video/fbmem.c
index 08d4e11d9121..38c2e2558f5e 100644
--- a/drivers/video/fbmem.c
+++ b/drivers/video/fbmem.c
@@ -1236,6 +1236,10 @@ fb_mmap(struct file *file, struct vm_area_struct * vma)
         pgprot_val(vma->vm_page_prot) |= _PAGE_NO_CACHE;
 #elif defined(__arm__) || defined(__sh__) || defined(__m32r__)
         vma->vm_page_prot = pgprot_writecombine(vma->vm_page_prot);
+#elif defined(__avr32__)
+        vma->vm_page_prot = __pgprot((pgprot_val(vma->vm_page_prot)
+                                      & ~_PAGE_CACHABLE)
+                                     | (_PAGE_BUFFER | _PAGE_DIRTY));
 #elif defined(__ia64__)
         if (efi_range_is_wc(vma->vm_start, vma->vm_end - vma->vm_start))
                 vma->vm_page_prot = pgprot_writecombine(vma->vm_page_prot);
diff --git a/drivers/video/i810/i810_main.c b/drivers/video/i810/i810_main.c
index 7e760197cf29..1a7d7789d877 100644
--- a/drivers/video/i810/i810_main.c
+++ b/drivers/video/i810/i810_main.c
@@ -1717,7 +1717,7 @@ static int __devinit i810_alloc_agp_mem(struct fb_info *info)
  * @info: pointer to device specific info structure
  *
  * DESCRIPTION:
- * Sets the the user monitor's horizontal and vertical
+ * Sets the user monitor's horizontal and vertical
  * frequency limits
  */
 static void __devinit i810_init_monspecs(struct fb_info *info)
diff --git a/drivers/video/matrox/matroxfb_Ti3026.c b/drivers/video/matrox/matroxfb_Ti3026.c
index a5690a5f29d5..9445cdb759b1 100644
--- a/drivers/video/matrox/matroxfb_Ti3026.c
+++ b/drivers/video/matrox/matroxfb_Ti3026.c
@@ -72,7 +72,7 @@
  *     (c) 1998 Gerd Knorr <kraxel@cs.tu-berlin.de>
  *
  * (following author is not in any relation with this code, but his ideas
- *  were used when writting this driver)
+ *  were used when writing this driver)
  *
  *               FreeVBE/AF (Matrox), "Shawn Hargreaves" <shawn@talula.demon.co.uk>
  *
diff --git a/drivers/video/matrox/matroxfb_accel.c b/drivers/video/matrox/matroxfb_accel.c
index a5c825d99466..c57aaadf410c 100644
--- a/drivers/video/matrox/matroxfb_accel.c
+++ b/drivers/video/matrox/matroxfb_accel.c
@@ -70,7 +70,7 @@
  *     (c) 1998 Gerd Knorr <kraxel@cs.tu-berlin.de>
  *
  * (following author is not in any relation with this code, but his ideas
- *  were used when writting this driver)
+ *  were used when writing this driver)
  *
  *               FreeVBE/AF (Matrox), "Shawn Hargreaves" <shawn@talula.demon.co.uk>
  *
diff --git a/drivers/video/matrox/matroxfb_base.c b/drivers/video/matrox/matroxfb_base.c
index cb2aa402ddfd..c8559a756b75 100644
--- a/drivers/video/matrox/matroxfb_base.c
+++ b/drivers/video/matrox/matroxfb_base.c
@@ -93,7 +93,7 @@
  *     (c) 1998 Gerd Knorr <kraxel@cs.tu-berlin.de>
  *
  * (following author is not in any relation with this code, but his ideas
- *  were used when writting this driver)
+ *  were used when writing this driver)
  *
  *               FreeVBE/AF (Matrox), "Shawn Hargreaves" <shawn@talula.demon.co.uk>
  *
diff --git a/drivers/video/matrox/matroxfb_misc.c b/drivers/video/matrox/matroxfb_misc.c
index 18886b629cb1..5948e54b9ef9 100644
--- a/drivers/video/matrox/matroxfb_misc.c
+++ b/drivers/video/matrox/matroxfb_misc.c
@@ -78,7 +78,7 @@
  *     (c) 1998 Gerd Knorr <kraxel@cs.tu-berlin.de>
  *
  * (following author is not in any relation with this code, but his ideas
- *  were used when writting this driver)
+ *  were used when writing this driver)
  *
  *               FreeVBE/AF (Matrox), "Shawn Hargreaves" <shawn@talula.demon.co.uk>
  *
diff --git a/drivers/video/nvidia/nv_hw.c b/drivers/video/nvidia/nv_hw.c
index f297c7b14a41..c627955aa124 100644
--- a/drivers/video/nvidia/nv_hw.c
+++ b/drivers/video/nvidia/nv_hw.c
@@ -149,8 +149,7 @@ static void nvGetClocks(struct nvidia_par *par, unsigned int *MClk,
                 pll = NV_RD32(par->PMC, 0x4024);
                 M = pll & 0xFF;
                 N = (pll >> 8) & 0xFF;
-                if (((par->Chipset & 0xfff0) == 0x0290) ||
-                                ((par->Chipset & 0xfff0) == 0x0390)) {
+                if (((par->Chipset & 0xfff0) == 0x0290) || ((par->Chipset & 0xfff0) == 0x0390) || ((par->Chipset & 0xfff0) == 0x02E0)) {
                         MB = 1;
                         NB = 1;
                 } else {
@@ -963,6 +962,7 @@ void NVLoadStateExt(struct nvidia_par *par, RIVA_HW_STATE * state)
 
                 if (((par->Chipset & 0xfff0) == 0x0090) ||
                     ((par->Chipset & 0xfff0) == 0x01D0) ||
+                    ((par->Chipset & 0xfff0) == 0x02E0) ||
                     ((par->Chipset & 0xfff0) == 0x0290))
                         regions = 15;
                 for(i = 0; i < regions; i++) {
@@ -1275,6 +1275,7 @@ void NVLoadStateExt(struct nvidia_par *par, RIVA_HW_STATE * state)
                                                 0x00100000);
                                         break;
                                 case 0x0090:
+                                case 0x02E0:
                                 case 0x0290:
                                         NV_WR32(par->PRAMDAC, 0x0608,
                                                 NV_RD32(par->PRAMDAC, 0x0608) |
@@ -1352,6 +1353,7 @@ void NVLoadStateExt(struct nvidia_par *par, RIVA_HW_STATE * state)
                         } else {
                                 if (((par->Chipset & 0xfff0) == 0x0090) ||
                                     ((par->Chipset & 0xfff0) == 0x01D0) ||
+                                    ((par->Chipset & 0xfff0) == 0x02E0) ||
                                     ((par->Chipset & 0xfff0) == 0x0290)) {
                                         for (i = 0; i < 60; i++) {
                                                 NV_WR32(par->PGRAPH,
@@ -1403,6 +1405,7 @@ void NVLoadStateExt(struct nvidia_par *par, RIVA_HW_STATE * state)
                                 } else {
                                         if ((par->Chipset & 0xfff0) == 0x0090 ||
                                             (par->Chipset & 0xfff0) == 0x01D0 ||
+                                            (par->Chipset & 0xfff0) == 0x02E0 ||
                                             (par->Chipset & 0xfff0) == 0x0290) {
                                                 NV_WR32(par->PGRAPH, 0x0DF0,
                                                         NV_RD32(par->PFB, 0x0200));
diff --git a/drivers/video/nvidia/nvidia.c b/drivers/video/nvidia/nvidia.c
index 7c36b5fe582e..f85edf084da3 100644
--- a/drivers/video/nvidia/nvidia.c
+++ b/drivers/video/nvidia/nvidia.c
@@ -1243,6 +1243,7 @@ static u32 __devinit nvidia_get_arch(struct fb_info *info)
         case 0x0140:            /* GeForce 6600 */
         case 0x0160:            /* GeForce 6200 */
         case 0x01D0:            /* GeForce 7200, 7300, 7400 */
+        case 0x02E0:            /* GeForce 7300 GT */
         case 0x0090:            /* GeForce 7800 */
         case 0x0210:            /* GeForce 6800 */
         case 0x0220:            /* GeForce 6200 */
diff --git a/drivers/video/s3fb.c b/drivers/video/s3fb.c
index 756fafb41d78..d11735895a01 100644
--- a/drivers/video/s3fb.c
+++ b/drivers/video/s3fb.c
@@ -796,23 +796,6 @@ static int s3fb_pan_display(struct fb_var_screeninfo *var, struct fb_info *info)
         return 0;
 }
 
-/* Get capabilities of accelerator based on the mode */
-
-static void s3fb_get_caps(struct fb_info *info, struct fb_blit_caps *caps,
-                          struct fb_var_screeninfo *var)
-{
-        if (var->bits_per_pixel == 0) {
-                /* can only support 256 8x16 bitmap */
-                caps->x = 1 << (8 - 1);
-                caps->y = 1 << (16 - 1);
-                caps->len = 256;
-        } else {
-                caps->x = ~(u32)0;
-                caps->y = ~(u32)0;
-                caps->len = ~(u32)0;
-        }
-}
-
 /* ------------------------------------------------------------------------- */
 
 /* Frame buffer operations */
@@ -829,7 +812,7 @@ static struct fb_ops s3fb_ops = {
         .fb_fillrect    = s3fb_fillrect,
         .fb_copyarea    = cfb_copyarea,
         .fb_imageblit   = s3fb_imageblit,
-        .fb_get_caps    = s3fb_get_caps,
+        .fb_get_caps    = svga_get_caps,
 };
 
 /* ------------------------------------------------------------------------- */
diff --git a/drivers/video/skeletonfb.c b/drivers/video/skeletonfb.c
index 842b5cd054c6..836a612af977 100644
--- a/drivers/video/skeletonfb.c
+++ b/drivers/video/skeletonfb.c
@@ -14,7 +14,7 @@
  *  of it. 
  *
  *  First the roles of struct fb_info and struct display have changed. Struct
- *  display will go away. The way the the new framebuffer console code will
+ *  display will go away. The way the new framebuffer console code will
  *  work is that it will act to translate data about the tty/console in 
  *  struct vc_data to data in a device independent way in struct fb_info. Then
  *  various functions in struct fb_ops will be called to store the device 
diff --git a/drivers/video/svgalib.c b/drivers/video/svgalib.c
index 079cdc911e48..25df928d37d8 100644
--- a/drivers/video/svgalib.c
+++ b/drivers/video/svgalib.c
@@ -347,6 +347,23 @@ int svga_get_tilemax(struct fb_info *info)
         return 256;
 }
 
+/* Get capabilities of accelerator based on the mode */
+
+void svga_get_caps(struct fb_info *info, struct fb_blit_caps *caps,
+                   struct fb_var_screeninfo *var)
+{
+        if (var->bits_per_pixel == 0) {
+                /* can only support 256 8x16 bitmap */
+                caps->x = 1 << (8 - 1);
+                caps->y = 1 << (16 - 1);
+                caps->len = 256;
+        } else {
+                caps->x = (var->bits_per_pixel == 4) ? 1 << (8 - 1) : ~(u32)0;
+                caps->y = ~(u32)0;
+                caps->len = ~(u32)0;
+        }
+}
+EXPORT_SYMBOL(svga_get_caps);
 
 /* ------------------------------------------------------------------------- */
 
diff --git a/drivers/video/vt8623fb.c b/drivers/video/vt8623fb.c
new file mode 100644
index 000000000000..5e9755e464a1
--- /dev/null
+++ b/drivers/video/vt8623fb.c
@@ -0,0 +1,927 @@
+/*
+ * linux/drivers/video/vt8623fb.c - fbdev driver for
+ * integrated graphic core in VIA VT8623 [CLE266] chipset
+ *
+ * Copyright (c) 2006-2007 Ondrej Zajicek <santiago@crfreenet.org>
+ *
+ * This file is subject to the terms and conditions of the GNU General Public
+ * License.  See the file COPYING in the main directory of this archive for
+ * more details.
+ *
+ * Code is based on s3fb, some parts are from David Boucher's viafb
+ * (http://davesdomain.org.uk/viafb/)
+ */
+
+#include <linux/version.h>
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/errno.h>
+#include <linux/string.h>
+#include <linux/mm.h>
+#include <linux/tty.h>
+#include <linux/slab.h>
+#include <linux/delay.h>
+#include <linux/fb.h>
+#include <linux/svga.h>
+#include <linux/init.h>
+#include <linux/pci.h>
+#include <linux/console.h> /* Why should fb driver call console functions? because acquire_console_sem() */
+#include <video/vga.h>
+
+#ifdef CONFIG_MTRR
+#include <asm/mtrr.h>
+#endif
+
+struct vt8623fb_info {
+        char __iomem *mmio_base;
+        int mtrr_reg;
+        struct vgastate state;
+        struct mutex open_lock;
+        unsigned int ref_count;
+        u32 pseudo_palette[16];
+};
+
+
+
+/* ------------------------------------------------------------------------- */
+
+static const struct svga_fb_format vt8623fb_formats[] = {
+        { 0,  {0, 6, 0},  {0, 6, 0},  {0, 6, 0}, {0, 0, 0}, 0,
+                FB_TYPE_TEXT, FB_AUX_TEXT_SVGA_STEP8,   FB_VISUAL_PSEUDOCOLOR, 16, 16},
+        { 4,  {0, 6, 0},  {0, 6, 0},  {0, 6, 0}, {0, 0, 0}, 0,
+                FB_TYPE_PACKED_PIXELS, 0,               FB_VISUAL_PSEUDOCOLOR, 16, 16},
+        { 4,  {0, 6, 0},  {0, 6, 0},  {0, 6, 0}, {0, 0, 0}, 1,
+                FB_TYPE_INTERLEAVED_PLANES, 1,          FB_VISUAL_PSEUDOCOLOR, 16, 16},
+        { 8,  {0, 6, 0},  {0, 6, 0},  {0, 6, 0}, {0, 0, 0}, 0,
+                FB_TYPE_PACKED_PIXELS, 0,               FB_VISUAL_PSEUDOCOLOR, 8, 8},
+/*      {16,  {10, 5, 0}, {5, 5, 0},  {0, 5, 0}, {0, 0, 0}, 0,
+                FB_TYPE_PACKED_PIXELS, 0,               FB_VISUAL_TRUECOLOR, 4, 4},     */
+        {16,  {11, 5, 0}, {5, 6, 0},  {0, 5, 0}, {0, 0, 0}, 0,
+                FB_TYPE_PACKED_PIXELS, 0,               FB_VISUAL_TRUECOLOR, 4, 4},
+        {32,  {16, 8, 0}, {8, 8, 0},  {0, 8, 0}, {0, 0, 0}, 0,
+                FB_TYPE_PACKED_PIXELS, 0,               FB_VISUAL_TRUECOLOR, 2, 2},
+        SVGA_FORMAT_END
+};
+
+static const struct svga_pll vt8623_pll = {2, 127, 2, 7, 0, 3,
+        60000, 300000, 14318};
+
+/* CRT timing register sets */
+
+struct vga_regset vt8623_h_total_regs[]       = {{0x00, 0, 7}, {0x36, 3, 3}, VGA_REGSET_END};
+struct vga_regset vt8623_h_display_regs[]     = {{0x01, 0, 7}, VGA_REGSET_END};
+struct vga_regset vt8623_h_blank_start_regs[] = {{0x02, 0, 7}, VGA_REGSET_END};
+struct vga_regset vt8623_h_blank_end_regs[]   = {{0x03, 0, 4}, {0x05, 7, 7}, {0x33, 5, 5}, VGA_REGSET_END};
+struct vga_regset vt8623_h_sync_start_regs[]  = {{0x04, 0, 7}, {0x33, 4, 4}, VGA_REGSET_END};
+struct vga_regset vt8623_h_sync_end_regs[]    = {{0x05, 0, 4}, VGA_REGSET_END};
+
+struct vga_regset vt8623_v_total_regs[]       = {{0x06, 0, 7}, {0x07, 0, 0}, {0x07, 5, 5}, {0x35, 0, 0}, VGA_REGSET_END};
+struct vga_regset vt8623_v_display_regs[]     = {{0x12, 0, 7}, {0x07, 1, 1}, {0x07, 6, 6}, {0x35, 2, 2}, VGA_REGSET_END};
+struct vga_regset vt8623_v_blank_start_regs[] = {{0x15, 0, 7}, {0x07, 3, 3}, {0x09, 5, 5}, {0x35, 3, 3}, VGA_REGSET_END};
+struct vga_regset vt8623_v_blank_end_regs[]   = {{0x16, 0, 7}, VGA_REGSET_END};
+struct vga_regset vt8623_v_sync_start_regs[]  = {{0x10, 0, 7}, {0x07, 2, 2}, {0x07, 7, 7}, {0x35, 1, 1}, VGA_REGSET_END};
+struct vga_regset vt8623_v_sync_end_regs[]    = {{0x11, 0, 3}, VGA_REGSET_END};
+
+struct vga_regset vt8623_offset_regs[]        = {{0x13, 0, 7}, {0x35, 5, 7}, VGA_REGSET_END};
+struct vga_regset vt8623_line_compare_regs[]  = {{0x18, 0, 7}, {0x07, 4, 4}, {0x09, 6, 6}, {0x33, 0, 2}, {0x35, 4, 4}, VGA_REGSET_END};
+struct vga_regset vt8623_fetch_count_regs[]   = {{0x1C, 0, 7}, {0x1D, 0, 1}, VGA_REGSET_END};
+struct vga_regset vt8623_start_address_regs[] = {{0x0d, 0, 7}, {0x0c, 0, 7}, {0x34, 0, 7}, {0x48, 0, 1}, VGA_REGSET_END};
+
+struct svga_timing_regs vt8623_timing_regs     = {
+        vt8623_h_total_regs, vt8623_h_display_regs, vt8623_h_blank_start_regs,
+        vt8623_h_blank_end_regs, vt8623_h_sync_start_regs, vt8623_h_sync_end_regs,
+        vt8623_v_total_regs, vt8623_v_display_regs, vt8623_v_blank_start_regs,
+        vt8623_v_blank_end_regs, vt8623_v_sync_start_regs, vt8623_v_sync_end_regs,
+};
+
+
+/* ------------------------------------------------------------------------- */
+
+
+/* Module parameters */
+
+static char *mode = "640x480-8@60";
+
+#ifdef CONFIG_MTRR
+static int mtrr = 1;
+#endif
+
+MODULE_AUTHOR("(c) 2006 Ondrej Zajicek <santiago@crfreenet.org>");
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("fbdev driver for integrated graphics core in VIA VT8623 [CLE266]");
+
+module_param(mode, charp, 0644);
+MODULE_PARM_DESC(mode, "Default video mode ('640x480-8@60', etc)");
+
+#ifdef CONFIG_MTRR
+module_param(mtrr, int, 0444);
+MODULE_PARM_DESC(mtrr, "Enable write-combining with MTRR (1=enable, 0=disable, default=1)");
+#endif
+
+
+/* ------------------------------------------------------------------------- */
+
+
+static struct fb_tile_ops vt8623fb_tile_ops = {
+        .fb_settile     = svga_settile,
+        .fb_tilecopy    = svga_tilecopy,
+        .fb_tilefill    = svga_tilefill,
+        .fb_tileblit    = svga_tileblit,
+        .fb_tilecursor  = svga_tilecursor,
+        .fb_get_tilemax = svga_get_tilemax,
+};
+
+
+/* ------------------------------------------------------------------------- */
+
+
+/* image data is MSB-first, fb structure is MSB-first too */
+static inline u32 expand_color(u32 c)
+{
+        return ((c & 1) | ((c & 2) << 7) | ((c & 4) << 14) | ((c & 8) << 21)) * 0xFF;
+}
+
+/* vt8623fb_iplan_imageblit silently assumes that almost everything is 8-pixel aligned */
+static void vt8623fb_iplan_imageblit(struct fb_info *info, const struct fb_image *image)
+{
+        u32 fg = expand_color(image->fg_color);
+        u32 bg = expand_color(image->bg_color);
+        const u8 *src1, *src;
+        u8 __iomem *dst1;
+        u32 __iomem *dst;
+        u32 val;
+        int x, y;
+
+        src1 = image->data;
+        dst1 = info->screen_base + (image->dy * info->fix.line_length)
+                 + ((image->dx / 8) * 4);
+
+        for (y = 0; y < image->height; y++) {
+                src = src1;
+                dst = (u32 __iomem *) dst1;
+                for (x = 0; x < image->width; x += 8) {
+                        val = *(src++) * 0x01010101;
+                        val = (val & fg) | (~val & bg);
+                        fb_writel(val, dst++);
+                }
+                src1 += image->width / 8;
+                dst1 += info->fix.line_length;
+        }
+}
+
+/* vt8623fb_iplan_fillrect silently assumes that almost everything is 8-pixel aligned */
+static void vt8623fb_iplan_fillrect(struct fb_info *info, const struct fb_fillrect *rect)
+{
+        u32 fg = expand_color(rect->color);
+        u8 __iomem *dst1;
+        u32 __iomem *dst;
+        int x, y;
+
+        dst1 = info->screen_base + (rect->dy * info->fix.line_length)
+                 + ((rect->dx / 8) * 4);
+
+        for (y = 0; y < rect->height; y++) {
+                dst = (u32 __iomem *) dst1;
+                for (x = 0; x < rect->width; x += 8) {
+                        fb_writel(fg, dst++);
+                }
+                dst1 += info->fix.line_length;
+        }
+}
+
+
+/* image data is MSB-first, fb structure is high-nibble-in-low-byte-first */
+static inline u32 expand_pixel(u32 c)
+{
+        return (((c &  1) << 24) | ((c &  2) << 27) | ((c &  4) << 14) | ((c &   8) << 17) |
+                ((c & 16) <<  4) | ((c & 32) <<  7) | ((c & 64) >>  6) | ((c & 128) >>  3)) * 0xF;
+}
+
+/* vt8623fb_cfb4_imageblit silently assumes that almost everything is 8-pixel aligned */
+static void vt8623fb_cfb4_imageblit(struct fb_info *info, const struct fb_image *image)
+{
+        u32 fg = image->fg_color * 0x11111111;
+        u32 bg = image->bg_color * 0x11111111;
+        const u8 *src1, *src;
+        u8 __iomem *dst1;
+        u32 __iomem *dst;
+        u32 val;
+        int x, y;
+
+        src1 = image->data;
+        dst1 = info->screen_base + (image->dy * info->fix.line_length)
+                 + ((image->dx / 8) * 4);
+
+        for (y = 0; y < image->height; y++) {
+                src = src1;
+                dst = (u32 __iomem *) dst1;
+                for (x = 0; x < image->width; x += 8) {
+                        val = expand_pixel(*(src++));
+                        val = (val & fg) | (~val & bg);
+                        fb_writel(val, dst++);
+                }
+                src1 += image->width / 8;
+                dst1 += info->fix.line_length;
+        }
+}
+
+static void vt8623fb_imageblit(struct fb_info *info, const struct fb_image *image)
+{
+        if ((info->var.bits_per_pixel == 4) && (image->depth == 1)
+            && ((image->width % 8) == 0) && ((image->dx % 8) == 0)) {
+                if (info->fix.type == FB_TYPE_INTERLEAVED_PLANES)
+                        vt8623fb_iplan_imageblit(info, image);
+                else
+                        vt8623fb_cfb4_imageblit(info, image);
+        } else
+                cfb_imageblit(info, image);
+}
+
+static void vt8623fb_fillrect(struct fb_info *info, const struct fb_fillrect *rect)
+{
+        if ((info->var.bits_per_pixel == 4)
+            && ((rect->width % 8) == 0) && ((rect->dx % 8) == 0)
+            && (info->fix.type == FB_TYPE_INTERLEAVED_PLANES))
+                vt8623fb_iplan_fillrect(info, rect);
+         else
+                cfb_fillrect(info, rect);
+}
+
+
+/* ------------------------------------------------------------------------- */
+
+
+static void vt8623_set_pixclock(struct fb_info *info, u32 pixclock)
+{
+        u16 m, n, r;
+        u8 regval;
+        int rv;
+
+        rv = svga_compute_pll(&vt8623_pll, 1000000000 / pixclock, &m, &n, &r, info->node);
+        if (rv < 0) {
+                printk(KERN_ERR "fb%d: cannot set requested pixclock, keeping old value\n", info->node);
+                return;
+        }
+
+        /* Set VGA misc register  */
+        regval = vga_r(NULL, VGA_MIS_R);
+        vga_w(NULL, VGA_MIS_W, regval | VGA_MIS_ENB_PLL_LOAD);
+
+        /* Set clock registers */
+        vga_wseq(NULL, 0x46, (n  | (r << 6)));
+        vga_wseq(NULL, 0x47, m);
+
+        udelay(1000);
+
+        /* PLL reset */
+        svga_wseq_mask(0x40, 0x02, 0x02);
+        svga_wseq_mask(0x40, 0x00, 0x02);
+}
+
+
+static int vt8623fb_open(struct fb_info *info, int user)
+{
+        struct vt8623fb_info *par = info->par;
+
+        mutex_lock(&(par->open_lock));
+        if (par->ref_count == 0) {
+                memset(&(par->state), 0, sizeof(struct vgastate));
+                par->state.flags = VGA_SAVE_MODE | VGA_SAVE_FONTS | VGA_SAVE_CMAP;
+                par->state.num_crtc = 0xA2;
+                par->state.num_seq = 0x50;
+                save_vga(&(par->state));
+        }
+
+        par->ref_count++;
+        mutex_unlock(&(par->open_lock));
+
+        return 0;
+}
+
+static int vt8623fb_release(struct fb_info *info, int user)
+{
+        struct vt8623fb_info *par = info->par;
+
+        mutex_lock(&(par->open_lock));
+        if (par->ref_count == 0) {
+                mutex_unlock(&(par->open_lock));
+                return -EINVAL;
+        }
+
+        if (par->ref_count == 1)
+                restore_vga(&(par->state));
+
+        par->ref_count--;
+        mutex_unlock(&(par->open_lock));
+
+        return 0;
+}
+
+static int vt8623fb_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
+{
+        int rv, mem, step;
+
+        /* Find appropriate format */
+        rv = svga_match_format (vt8623fb_formats, var, NULL);
+        if (rv < 0)
+        {
+                printk(KERN_ERR "fb%d: unsupported mode requested\n", info->node);
+                return rv;
+        }
+
+        /* Do not allow to have real resoulution larger than virtual */
+        if (var->xres > var->xres_virtual)
+                var->xres_virtual = var->xres;
+
+        if (var->yres > var->yres_virtual)
+                var->yres_virtual = var->yres;
+
+        /* Round up xres_virtual to have proper alignment of lines */
+        step = vt8623fb_formats[rv].xresstep - 1;
+        var->xres_virtual = (var->xres_virtual+step) & ~step;
+
+        /* Check whether have enough memory */
+        mem = ((var->bits_per_pixel * var->xres_virtual) >> 3) * var->yres_virtual;
+        if (mem > info->screen_size)
+        {
+                printk(KERN_ERR "fb%d: not enough framebuffer memory (%d kB requested , %d kB available)\n", info->node, mem >> 10, (unsigned int) (info->screen_size >> 10));
+                return -EINVAL;
+        }
+
+        /* Text mode is limited to 256 kB of memory */
+        if ((var->bits_per_pixel == 0) && (mem > (256*1024)))
+        {
+                printk(KERN_ERR "fb%d: text framebuffer size too large (%d kB requested, 256 kB possible)\n", info->node, mem >> 10);
+                return -EINVAL;
+        }
+
+        rv = svga_check_timings (&vt8623_timing_regs, var, info->node);
+        if (rv < 0)
+        {
+                printk(KERN_ERR "fb%d: invalid timings requested\n", info->node);
+                return rv;
+        }
+
+        /* Interlaced mode not supported */
+        if (var->vmode & FB_VMODE_INTERLACED)
+                return -EINVAL;
+
+        return 0;
+}
+
+
+static int vt8623fb_set_par(struct fb_info *info)
+{
+        u32 mode, offset_value, fetch_value, screen_size;
+        u32 bpp = info->var.bits_per_pixel;
+
+        if (bpp != 0) {
+                info->fix.ypanstep = 1;
+                info->fix.line_length = (info->var.xres_virtual * bpp) / 8;
+
+                info->flags &= ~FBINFO_MISC_TILEBLITTING;
+                info->tileops = NULL;
+
+                /* in 4bpp supports 8p wide tiles only, any tiles otherwise */
+                info->pixmap.blit_x = (bpp == 4) ? (1 << (8 - 1)) : (~(u32)0);
+                info->pixmap.blit_y = ~(u32)0;
+
+                offset_value = (info->var.xres_virtual * bpp) / 64;
+                fetch_value  = ((info->var.xres * bpp) / 128) + 4;
+
+                if (bpp == 4)
+                        fetch_value  = (info->var.xres / 8) + 8; /* + 0 is OK */
+
+                screen_size  = info->var.yres_virtual * info->fix.line_length;
+        } else {
+                info->fix.ypanstep = 16;
+                info->fix.line_length = 0;
+
+                info->flags |= FBINFO_MISC_TILEBLITTING;
+                info->tileops = &vt8623fb_tile_ops;
+
+                /* supports 8x16 tiles only */
+                info->pixmap.blit_x = 1 << (8 - 1);
+                info->pixmap.blit_y = 1 << (16 - 1);
+
+                offset_value = info->var.xres_virtual / 16;
+                fetch_value  = (info->var.xres / 8) + 8;
+                screen_size  = (info->var.xres_virtual * info->var.yres_virtual) / 64;
+        }
+
+        info->var.xoffset = 0;
+        info->var.yoffset = 0;
+        info->var.activate = FB_ACTIVATE_NOW;
+
+        /* Unlock registers */
+        svga_wseq_mask(0x10, 0x01, 0x01);
+        svga_wcrt_mask(0x11, 0x00, 0x80);
+        svga_wcrt_mask(0x47, 0x00, 0x01);
+
+        /* Device, screen and sync off */
+        svga_wseq_mask(0x01, 0x20, 0x20);
+        svga_wcrt_mask(0x36, 0x30, 0x30);
+        svga_wcrt_mask(0x17, 0x00, 0x80);
+
+        /* Set default values */
+        svga_set_default_gfx_regs();
+        svga_set_default_atc_regs();
+        svga_set_default_seq_regs();
+        svga_set_default_crt_regs();
+        svga_wcrt_multi(vt8623_line_compare_regs, 0xFFFFFFFF);
+        svga_wcrt_multi(vt8623_start_address_regs, 0);
+
+        svga_wcrt_multi(vt8623_offset_regs, offset_value);
+        svga_wseq_multi(vt8623_fetch_count_regs, fetch_value);
+
+        if (info->var.vmode & FB_VMODE_DOUBLE)
+                svga_wcrt_mask(0x09, 0x80, 0x80);
+        else
+                svga_wcrt_mask(0x09, 0x00, 0x80);
+
+        svga_wseq_mask(0x1E, 0xF0, 0xF0); // DI/DVP bus
+        svga_wseq_mask(0x2A, 0x0F, 0x0F); // DI/DVP bus
+        svga_wseq_mask(0x16, 0x08, 0xBF); // FIFO read treshold
+        vga_wseq(NULL, 0x17, 0x1F);       // FIFO depth
+        vga_wseq(NULL, 0x18, 0x4E);
+        svga_wseq_mask(0x1A, 0x08, 0x08); // enable MMIO ?
+
+        vga_wcrt(NULL, 0x32, 0x00);
+        vga_wcrt(NULL, 0x34, 0x00);
+        vga_wcrt(NULL, 0x6A, 0x80);
+        vga_wcrt(NULL, 0x6A, 0xC0);
+
+        vga_wgfx(NULL, 0x20, 0x00);
+        vga_wgfx(NULL, 0x21, 0x00);
+        vga_wgfx(NULL, 0x22, 0x00);
+
+        /* Set SR15 according to number of bits per pixel */
+        mode = svga_match_format(vt8623fb_formats, &(info->var), &(info->fix));
+        switch (mode) {
+        case 0:
+                pr_debug("fb%d: text mode\n", info->node);
+                svga_set_textmode_vga_regs();
+                svga_wseq_mask(0x15, 0x00, 0xFE);
+                svga_wcrt_mask(0x11, 0x60, 0x70);
+                break;
+        case 1:
+                pr_debug("fb%d: 4 bit pseudocolor\n", info->node);
+                vga_wgfx(NULL, VGA_GFX_MODE, 0x40);
+                svga_wseq_mask(0x15, 0x20, 0xFE);
+                svga_wcrt_mask(0x11, 0x00, 0x70);
+                break;
+        case 2:
+                pr_debug("fb%d: 4 bit pseudocolor, planar\n", info->node);
+                svga_wseq_mask(0x15, 0x00, 0xFE);
+                svga_wcrt_mask(0x11, 0x00, 0x70);
+                break;
+        case 3:
+                pr_debug("fb%d: 8 bit pseudocolor\n", info->node);
+                svga_wseq_mask(0x15, 0x22, 0xFE);
+                break;
+        case 4:
+                pr_debug("fb%d: 5/6/5 truecolor\n", info->node);
+                svga_wseq_mask(0x15, 0xB6, 0xFE);
+                break;
+        case 5:
+                pr_debug("fb%d: 8/8/8 truecolor\n", info->node);
+                svga_wseq_mask(0x15, 0xAE, 0xFE);
+                break;
+        default:
+                printk(KERN_ERR "vt8623fb: unsupported mode - bug\n");
+                return (-EINVAL);
+        }
+
+        vt8623_set_pixclock(info, info->var.pixclock);
+        svga_set_timings(&vt8623_timing_regs, &(info->var), 1, 1,
+                         (info->var.vmode & FB_VMODE_DOUBLE) ? 2 : 1, 1,
+                         1, info->node);
+
+        memset_io(info->screen_base, 0x00, screen_size);
+
+        /* Device and screen back on */
+        svga_wcrt_mask(0x17, 0x80, 0x80);
+        svga_wcrt_mask(0x36, 0x00, 0x30);
+        svga_wseq_mask(0x01, 0x00, 0x20);
+
+        return 0;
+}
+
+
+static int vt8623fb_setcolreg(u_int regno, u_int red, u_int green, u_int blue,
+                                u_int transp, struct fb_info *fb)
+{
+        switch (fb->var.bits_per_pixel) {
+        case 0:
+        case 4:
+                if (regno >= 16)
+                        return -EINVAL;
+
+                outb(0x0F, VGA_PEL_MSK);
+                outb(regno, VGA_PEL_IW);
+                outb(red >> 10, VGA_PEL_D);
+                outb(green >> 10, VGA_PEL_D);
+                outb(blue >> 10, VGA_PEL_D);
+                break;
+        case 8:
+                if (regno >= 256)
+                        return -EINVAL;
+
+                outb(0xFF, VGA_PEL_MSK);
+                outb(regno, VGA_PEL_IW);
+                outb(red >> 10, VGA_PEL_D);
+                outb(green >> 10, VGA_PEL_D);
+                outb(blue >> 10, VGA_PEL_D);
+                break;
+        case 16:
+                if (regno >= 16)
+                        return 0;
+
+                if (fb->var.green.length == 5)
+                        ((u32*)fb->pseudo_palette)[regno] = ((red & 0xF800) >> 1) |
+                                ((green & 0xF800) >> 6) | ((blue & 0xF800) >> 11);
+                else if (fb->var.green.length == 6)
+                        ((u32*)fb->pseudo_palette)[regno] = (red & 0xF800) |
+                                ((green & 0xFC00) >> 5) | ((blue & 0xF800) >> 11);
+                else
+                        return -EINVAL;
+                break;
+        case 24:
+        case 32:
+                if (regno >= 16)
+                        return 0;
+
+                /* ((transp & 0xFF00) << 16) */
+                ((u32*)fb->pseudo_palette)[regno] = ((red & 0xFF00) << 8) |
+                        (green & 0xFF00) | ((blue & 0xFF00) >> 8);
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+
+static int vt8623fb_blank(int blank_mode, struct fb_info *info)
+{
+        switch (blank_mode) {
+        case FB_BLANK_UNBLANK:
+                pr_debug("fb%d: unblank\n", info->node);
+                svga_wcrt_mask(0x36, 0x00, 0x30);
+                svga_wseq_mask(0x01, 0x00, 0x20);
+                break;
+        case FB_BLANK_NORMAL:
+                pr_debug("fb%d: blank\n", info->node);
+                svga_wcrt_mask(0x36, 0x00, 0x30);
+                svga_wseq_mask(0x01, 0x20, 0x20);
+                break;
+        case FB_BLANK_HSYNC_SUSPEND:
+                pr_debug("fb%d: DPMS standby (hsync off)\n", info->node);
+                svga_wcrt_mask(0x36, 0x10, 0x30);
+                svga_wseq_mask(0x01, 0x20, 0x20);
+                break;
+        case FB_BLANK_VSYNC_SUSPEND:
+                pr_debug("fb%d: DPMS suspend (vsync off)\n", info->node);
+                svga_wcrt_mask(0x36, 0x20, 0x30);
+                svga_wseq_mask(0x01, 0x20, 0x20);
+                break;
+        case FB_BLANK_POWERDOWN:
+                pr_debug("fb%d: DPMS off (no sync)\n", info->node);
+                svga_wcrt_mask(0x36, 0x30, 0x30);
+                svga_wseq_mask(0x01, 0x20, 0x20);
+                break;
+        }
+
+        return 0;
+}
+
+
+static int vt8623fb_pan_display(struct fb_var_screeninfo *var, struct fb_info *info)
+{
+        unsigned int offset;
+
+        /* Calculate the offset */
+        if (var->bits_per_pixel == 0) {
+                offset = (var->yoffset / 16) * var->xres_virtual + var->xoffset;
+                offset = offset >> 3;
+        } else {
+                offset = (var->yoffset * info->fix.line_length) +
+                         (var->xoffset * var->bits_per_pixel / 8);
+                offset = offset >> ((var->bits_per_pixel == 4) ? 2 : 1);
+        }
+
+        /* Set the offset */
+        svga_wcrt_multi(vt8623_start_address_regs, offset);
+
+        return 0;
+}
+
+
+/* ------------------------------------------------------------------------- */
+
+
+/* Frame buffer operations */
+
+static struct fb_ops vt8623fb_ops = {
+        .owner          = THIS_MODULE,
+        .fb_open        = vt8623fb_open,
+        .fb_release     = vt8623fb_release,
+        .fb_check_var   = vt8623fb_check_var,
+        .fb_set_par     = vt8623fb_set_par,
+        .fb_setcolreg   = vt8623fb_setcolreg,
+        .fb_blank       = vt8623fb_blank,
+        .fb_pan_display = vt8623fb_pan_display,
+        .fb_fillrect    = vt8623fb_fillrect,
+        .fb_copyarea    = cfb_copyarea,
+        .fb_imageblit   = vt8623fb_imageblit,
+        .fb_get_caps    = svga_get_caps,
+};
+
+
+/* PCI probe */
+
+static int __devinit vt8623_pci_probe(struct pci_dev *dev, const struct pci_device_id *id)
+{
+        struct fb_info *info;
+        struct vt8623fb_info *par;
+        unsigned int memsize1, memsize2;
+        int rc;
+
+        /* Ignore secondary VGA device because there is no VGA arbitration */
+        if (! svga_primary_device(dev)) {
+                dev_info(&(dev->dev), "ignoring secondary device\n");
+                return -ENODEV;
+        }
+
+        /* Allocate and fill driver data structure */
+        info = framebuffer_alloc(sizeof(struct vt8623fb_info), NULL);
+        if (! info) {
+                dev_err(&(dev->dev), "cannot allocate memory\n");
+                return -ENOMEM;
+        }
+
+        par = info->par;
+        mutex_init(&par->open_lock);
+
+        info->flags = FBINFO_PARTIAL_PAN_OK | FBINFO_HWACCEL_YPAN;
+        info->fbops = &vt8623fb_ops;
+
+        /* Prepare PCI device */
+
+        rc = pci_enable_device(dev);
+        if (rc < 0) {
+                dev_err(&(dev->dev), "cannot enable PCI device\n");
+                goto err_enable_device;
+        }
+
+        rc = pci_request_regions(dev, "vt8623fb");
+        if (rc < 0) {
+                dev_err(&(dev->dev), "cannot reserve framebuffer region\n");
+                goto err_request_regions;
+        }
+
+        info->fix.smem_start = pci_resource_start(dev, 0);
+        info->fix.smem_len = pci_resource_len(dev, 0);
+        info->fix.mmio_start = pci_resource_start(dev, 1);
+        info->fix.mmio_len = pci_resource_len(dev, 1);
+
+        /* Map physical IO memory address into kernel space */
+        info->screen_base = pci_iomap(dev, 0, 0);
+        if (! info->screen_base) {
+                rc = -ENOMEM;
+                dev_err(&(dev->dev), "iomap for framebuffer failed\n");
+                goto err_iomap_1;
+        }
+
+        par->mmio_base = pci_iomap(dev, 1, 0);
+        if (! par->mmio_base) {
+                rc = -ENOMEM;
+                dev_err(&(dev->dev), "iomap for MMIO failed\n");
+                goto err_iomap_2;
+        }
+
+        /* Find how many physical memory there is on card */
+        memsize1 = (vga_rseq(NULL, 0x34) + 1) >> 1;
+        memsize2 = vga_rseq(NULL, 0x39) << 2;
+
+        if ((16 <= memsize1) && (memsize1 <= 64) && (memsize1 == memsize2))
+                info->screen_size = memsize1 << 20;
+        else {
+                dev_err(&(dev->dev), "memory size detection failed (%x %x), suppose 16 MB\n", memsize1, memsize2);
+                info->screen_size = 16 << 20;
+        }
+
+        info->fix.smem_len = info->screen_size;
+        strcpy(info->fix.id, "VIA VT8623");
+        info->fix.type = FB_TYPE_PACKED_PIXELS;
+        info->fix.visual = FB_VISUAL_PSEUDOCOLOR;
+        info->fix.ypanstep = 0;
+        info->fix.accel = FB_ACCEL_NONE;
+        info->pseudo_palette = (void*)par->pseudo_palette;
+
+        /* Prepare startup mode */
+
+        rc = fb_find_mode(&(info->var), info, mode, NULL, 0, NULL, 8);
+        if (! ((rc == 1) || (rc == 2))) {
+                rc = -EINVAL;
+                dev_err(&(dev->dev), "mode %s not found\n", mode);
+                goto err_find_mode;
+        }
+
+        rc = fb_alloc_cmap(&info->cmap, 256, 0);
+        if (rc < 0) {
+                dev_err(&(dev->dev), "cannot allocate colormap\n");
+                goto err_alloc_cmap;
+        }
+
+        rc = register_framebuffer(info);
+        if (rc < 0) {
+                dev_err(&(dev->dev), "cannot register framebugger\n");
+                goto err_reg_fb;
+        }
+
+        printk(KERN_INFO "fb%d: %s on %s, %d MB RAM\n", info->node, info->fix.id,
+                 pci_name(dev), info->fix.smem_len >> 20);
+
+        /* Record a reference to the driver data */
+        pci_set_drvdata(dev, info);
+
+#ifdef CONFIG_MTRR
+        if (mtrr) {
+                par->mtrr_reg = -1;
+                par->mtrr_reg = mtrr_add(info->fix.smem_start, info->fix.smem_len, MTRR_TYPE_WRCOMB, 1);
+        }
+#endif
+
+        return 0;
+
+        /* Error handling */
+err_reg_fb:
+        fb_dealloc_cmap(&info->cmap);
+err_alloc_cmap:
+err_find_mode:
+        pci_iounmap(dev, par->mmio_base);
+err_iomap_2:
+        pci_iounmap(dev, info->screen_base);
+err_iomap_1:
+        pci_release_regions(dev);
+err_request_regions:
+/*      pci_disable_device(dev); */
+err_enable_device:
+        framebuffer_release(info);
+        return rc;
+}
+
+/* PCI remove */
+
+static void __devexit vt8623_pci_remove(struct pci_dev *dev)
+{
+        struct fb_info *info = pci_get_drvdata(dev);
+        struct vt8623fb_info *par = info->par;
+
+        if (info) {
+#ifdef CONFIG_MTRR
+                if (par->mtrr_reg >= 0) {
+                        mtrr_del(par->mtrr_reg, 0, 0);
+                        par->mtrr_reg = -1;
+                }
+#endif
+
+                unregister_framebuffer(info);
+                fb_dealloc_cmap(&info->cmap);
+
+                pci_iounmap(dev, info->screen_base);
+                pci_iounmap(dev, par->mmio_base);
+                pci_release_regions(dev);
+/*              pci_disable_device(dev); */
+
+                pci_set_drvdata(dev, NULL);
+                framebuffer_release(info);
+        }
+}
+
+
+#ifdef CONFIG_PM
+/* PCI suspend */
+
+static int vt8623_pci_suspend(struct pci_dev* dev, pm_message_t state)
+{
+        struct fb_info *info = pci_get_drvdata(dev);
+        struct vt8623fb_info *par = info->par;
+
+        dev_info(&(dev->dev), "suspend\n");
+
+        acquire_console_sem();
+        mutex_lock(&(par->open_lock));
+
+        if ((state.event == PM_EVENT_FREEZE) || (par->ref_count == 0)) {
+                mutex_unlock(&(par->open_lock));
+                release_console_sem();
+                return 0;
+        }
+
+        fb_set_suspend(info, 1);
+
+        pci_save_state(dev);
+        pci_disable_device(dev);
+        pci_set_power_state(dev, pci_choose_state(dev, state));
+
+        mutex_unlock(&(par->open_lock));
+        release_console_sem();
+
+        return 0;
+}
+
+
+/* PCI resume */
+
+static int vt8623_pci_resume(struct pci_dev* dev)
+{
+        struct fb_info *info = pci_get_drvdata(dev);
+        struct vt8623fb_info *par = info->par;
+
+        dev_info(&(dev->dev), "resume\n");
+
+        acquire_console_sem();
+        mutex_lock(&(par->open_lock));
+
+        if (par->ref_count == 0) {
+                mutex_unlock(&(par->open_lock));
+                release_console_sem();
+                return 0;
+        }
+
+        pci_set_power_state(dev, PCI_D0);
+        pci_restore_state(dev);
+
+        if (pci_enable_device(dev))
+                goto fail;
+
+        pci_set_master(dev);
+
+        vt8623fb_set_par(info);
+        fb_set_suspend(info, 0);
+
+        mutex_unlock(&(par->open_lock));
+fail:
+        release_console_sem();
+
+        return 0;
+}
+#else
+#define vt8623_pci_suspend NULL
+#define vt8623_pci_resume NULL
+#endif /* CONFIG_PM */
+
+/* List of boards that we are trying to support */
+
+static struct pci_device_id vt8623_devices[] __devinitdata = {
+        {PCI_DEVICE(PCI_VENDOR_ID_VIA, 0x3122)},
+        {0, 0, 0, 0, 0, 0, 0}
+};
+
+MODULE_DEVICE_TABLE(pci, vt8623_devices);
+
+static struct pci_driver vt8623fb_pci_driver = {
+        .name           = "vt8623fb",
+        .id_table       = vt8623_devices,
+        .probe          = vt8623_pci_probe,
+        .remove         = __devexit_p(vt8623_pci_remove),
+        .suspend        = vt8623_pci_suspend,
+        .resume         = vt8623_pci_resume,
+};
+
+/* Cleanup */
+
+static void __exit vt8623fb_cleanup(void)
+{
+        pr_debug("vt8623fb: cleaning up\n");
+        pci_unregister_driver(&vt8623fb_pci_driver);
+}
+
+/* Driver Initialisation */
+
+int __init vt8623fb_init(void)
+{
+
+#ifndef MODULE
+        char *option = NULL;
+
+        if (fb_get_options("vt8623fb", &option))
+                return -ENODEV;
+
+        if (option && *option)
+                mode = option;
+#endif
+
+        pr_debug("vt8623fb: initializing\n");
+        return pci_register_driver(&vt8623fb_pci_driver);
+}
+
+/* ------------------------------------------------------------------------- */
+
+/* Modularization */
+
+module_init(vt8623fb_init);
+module_exit(vt8623fb_cleanup);