291 files changed, 13461 insertions, 4252 deletions

diff --git a/drivers/Kconfig b/drivers/Kconfig
index 48f446d3c671..283c089537bc 100644
--- a/drivers/Kconfig
+++ b/drivers/Kconfig
@@ -44,6 +44,8 @@ source "drivers/char/Kconfig"
 
 source "drivers/i2c/Kconfig"
 
+source "drivers/spi/Kconfig"
+
 source "drivers/w1/Kconfig"
 
 source "drivers/hwmon/Kconfig"
diff --git a/drivers/Makefile b/drivers/Makefile
index 7fc3f0f08b29..7c45050ecd03 100644
--- a/drivers/Makefile
+++ b/drivers/Makefile
@@ -41,6 +41,7 @@ obj-$(CONFIG_FUSION)		+= message/
 obj-$(CONFIG_IEEE1394)          += ieee1394/
 obj-y                           += cdrom/
 obj-$(CONFIG_MTD)               += mtd/
+obj-$(CONFIG_SPI)               += spi/
 obj-$(CONFIG_PCCARD)            += pcmcia/
 obj-$(CONFIG_DIO)               += dio/
 obj-$(CONFIG_SBUS)              += sbus/
diff --git a/drivers/acpi/ec.c b/drivers/acpi/ec.c
index 7e1a445955bc..3758b558d2b5 100644
--- a/drivers/acpi/ec.c
+++ b/drivers/acpi/ec.c
@@ -153,7 +153,7 @@ static int acpi_ec_polling_mode = EC_POLLING;
                              Transaction Management
    -------------------------------------------------------------------------- */
 
-static inline u32 acpi_ec_read_status(union acpi_ec *ec)
+static u32 acpi_ec_read_status(union acpi_ec *ec)
 {
         u32 status = 0;
 
diff --git a/drivers/base/dd.c b/drivers/base/dd.c
index 2b905016664d..730a9ce0a14a 100644
--- a/drivers/base/dd.c
+++ b/drivers/base/dd.c
@@ -78,7 +78,13 @@ int driver_probe_device(struct device_driver * drv, struct device * dev)
         pr_debug("%s: Matched Device %s with Driver %s\n",
                  drv->bus->name, dev->bus_id, drv->name);
         dev->driver = drv;
-        if (drv->probe) {
+        if (dev->bus->probe) {
+                ret = dev->bus->probe(dev);
+                if (ret) {
+                        dev->driver = NULL;
+                        goto ProbeFailed;
+                }
+        } else if (drv->probe) {
                 ret = drv->probe(dev);
                 if (ret) {
                         dev->driver = NULL;
@@ -203,7 +209,9 @@ static void __device_release_driver(struct device * dev)
                 sysfs_remove_link(&dev->kobj, "driver");
                 klist_remove(&dev->knode_driver);
 
-                if (drv->remove)
+                if (dev->bus->remove)
+                        dev->bus->remove(dev);
+                else if (drv->remove)
                         drv->remove(dev);
                 dev->driver = NULL;
                 put_driver(drv);
diff --git a/drivers/base/driver.c b/drivers/base/driver.c
index 161f3a390d90..b400314e1c62 100644
--- a/drivers/base/driver.c
+++ b/drivers/base/driver.c
@@ -171,6 +171,11 @@ static void klist_devices_put(struct klist_node *n)
  */
 int driver_register(struct device_driver * drv)
 {
+        if ((drv->bus->probe && drv->probe) ||
+            (drv->bus->remove && drv->remove) ||
+            (drv->bus->shutdown && drv->shutdown)) {
+                printk(KERN_WARNING "Driver '%s' needs updating - please use bus_type methods\n", drv->name);
+        }
         klist_init(&drv->klist_devices, klist_devices_get, klist_devices_put);
         init_completion(&drv->unloaded);
         return bus_add_driver(drv);
diff --git a/drivers/base/firmware_class.c b/drivers/base/firmware_class.c
index 3d384e3d34de..e97e911ebf7a 100644
--- a/drivers/base/firmware_class.c
+++ b/drivers/base/firmware_class.c
@@ -48,7 +48,7 @@ struct firmware_priv {
         struct timer_list timeout;
 };
 
-static inline void
+static void
 fw_load_abort(struct firmware_priv *fw_priv)
 {
         set_bit(FW_STATUS_ABORT, &fw_priv->status);
diff --git a/drivers/base/platform.c b/drivers/base/platform.c
index 0f81731bdfa8..461554a02517 100644
--- a/drivers/base/platform.c
+++ b/drivers/base/platform.c
@@ -327,7 +327,7 @@ EXPORT_SYMBOL_GPL(platform_device_register);
  *      @pdev:  platform device we're unregistering
  *
  *      Unregistration is done in 2 steps. Fisrt we release all resources
- *      and remove it from the sybsystem, then we drop reference count by
+ *      and remove it from the subsystem, then we drop reference count by
  *      calling platform_device_put().
  */
 void platform_device_unregister(struct platform_device * pdev)
diff --git a/drivers/base/power/shutdown.c b/drivers/base/power/shutdown.c
index f50a08be424b..c2475f3134ea 100644
--- a/drivers/base/power/shutdown.c
+++ b/drivers/base/power/shutdown.c
@@ -35,12 +35,15 @@ extern int sysdev_shutdown(void);
  */
 void device_shutdown(void)
 {
-        struct device * dev;
+        struct device * dev, *devn;
 
         down_write(&devices_subsys.rwsem);
-        list_for_each_entry_reverse(dev, &devices_subsys.kset.list,
+        list_for_each_entry_safe_reverse(dev, devn, &devices_subsys.kset.list,
                                 kobj.entry) {
-                if (dev->driver && dev->driver->shutdown) {
+                if (dev->bus && dev->bus->shutdown) {
+                        dev_dbg(dev, "shutdown\n");
+                        dev->bus->shutdown(dev);
+                } else if (dev->driver && dev->driver->shutdown) {
                         dev_dbg(dev, "shutdown\n");
                         dev->driver->shutdown(dev);
                 }
diff --git a/drivers/block/loop.c b/drivers/block/loop.c
index 864729046e22..5f6d1a5cce11 100644
--- a/drivers/block/loop.c
+++ b/drivers/block/loop.c
@@ -294,7 +294,7 @@ fail:
  * This helper just factors out common code between do_lo_send_direct_write()
  * and do_lo_send_write().
  */
-static inline int __do_lo_send_write(struct file *file,
+static int __do_lo_send_write(struct file *file,
                 u8 __user *buf, const int len, loff_t pos)
 {
         ssize_t bw;
diff --git a/drivers/block/pktcdvd.c b/drivers/block/pktcdvd.c
index 51b7a5c5b77a..93affeeef7bd 100644
--- a/drivers/block/pktcdvd.c
+++ b/drivers/block/pktcdvd.c
@@ -247,7 +247,7 @@ static inline struct pkt_rb_node *pkt_rbtree_next(struct pkt_rb_node *node)
         return rb_entry(n, struct pkt_rb_node, rb_node);
 }
 
-static inline void pkt_rbtree_erase(struct pktcdvd_device *pd, struct pkt_rb_node *node)
+static void pkt_rbtree_erase(struct pktcdvd_device *pd, struct pkt_rb_node *node)
 {
         rb_erase(&node->rb_node, &pd->bio_queue);
         mempool_free(node, pd->rb_pool);
@@ -315,7 +315,7 @@ static void pkt_rbtree_insert(struct pktcdvd_device *pd, struct pkt_rb_node *nod
 /*
  * Add a bio to a single linked list defined by its head and tail pointers.
  */
-static inline void pkt_add_list_last(struct bio *bio, struct bio **list_head, struct bio **list_tail)
+static void pkt_add_list_last(struct bio *bio, struct bio **list_head, struct bio **list_tail)
 {
         bio->bi_next = NULL;
         if (*list_tail) {
diff --git a/drivers/bluetooth/hci_bcsp.c b/drivers/bluetooth/hci_bcsp.c
index 8fddfdfd0fbd..7bd4ef904115 100644
--- a/drivers/bluetooth/hci_bcsp.c
+++ b/drivers/bluetooth/hci_bcsp.c
@@ -494,7 +494,7 @@ static inline void bcsp_unslip_one_byte(struct bcsp_struct *bcsp, unsigned char
         }
 }
 
-static inline void bcsp_complete_rx_pkt(struct hci_uart *hu)
+static void bcsp_complete_rx_pkt(struct hci_uart *hu)
 {
         struct bcsp_struct *bcsp = hu->priv;
         int pass_up;
diff --git a/drivers/char/amiserial.c b/drivers/char/amiserial.c
index 667a21c72edb..7ac365b5d9ec 100644
--- a/drivers/char/amiserial.c
+++ b/drivers/char/amiserial.c
@@ -129,7 +129,6 @@ static struct serial_state rs_table[1];
  * memory if large numbers of serial ports are open.
  */
 static unsigned char *tmp_buf;
-static DECLARE_MUTEX(tmp_buf_sem);
 
 #include <asm/uaccess.h>
 
diff --git a/drivers/char/drm/r128_state.c b/drivers/char/drm/r128_state.c
index caeecc2c36da..a080cdd6081e 100644
--- a/drivers/char/drm/r128_state.c
+++ b/drivers/char/drm/r128_state.c
@@ -220,7 +220,7 @@ static __inline__ void r128_emit_tex1(drm_r128_private_t * dev_priv)
         ADVANCE_RING();
 }
 
-static __inline__ void r128_emit_state(drm_r128_private_t * dev_priv)
+static void r128_emit_state(drm_r128_private_t * dev_priv)
 {
         drm_r128_sarea_t *sarea_priv = dev_priv->sarea_priv;
         unsigned int dirty = sarea_priv->dirty;
diff --git a/drivers/char/esp.c b/drivers/char/esp.c
index e469f641c728..dd5dc8fa490d 100644
--- a/drivers/char/esp.c
+++ b/drivers/char/esp.c
@@ -160,7 +160,6 @@ static void rs_wait_until_sent(struct tty_struct *, int);
  * memory if large numbers of serial ports are open.
  */
 static unsigned char *tmp_buf;
-static DECLARE_MUTEX(tmp_buf_sem);
 
 static inline int serial_paranoia_check(struct esp_struct *info,
                                         char *name, const char *routine)
diff --git a/drivers/char/generic_serial.c b/drivers/char/generic_serial.c
index 204a7302a4a9..e38a5f0e07bb 100644
--- a/drivers/char/generic_serial.c
+++ b/drivers/char/generic_serial.c
@@ -34,7 +34,6 @@
 #define DEBUG 
 
 static char *                  tmp_buf; 
-static DECLARE_MUTEX(tmp_buf_sem);
 
 static int gs_debug;
 
diff --git a/drivers/char/riscom8.c b/drivers/char/riscom8.c
index 050e70ee5920..119e629656b7 100644
--- a/drivers/char/riscom8.c
+++ b/drivers/char/riscom8.c
@@ -82,7 +82,6 @@
 static struct riscom_board * IRQ_to_board[16];
 static struct tty_driver *riscom_driver;
 static unsigned char * tmp_buf;
-static DECLARE_MUTEX(tmp_buf_sem);
 
 static unsigned long baud_table[] =  {
         0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800,
diff --git a/drivers/char/serial167.c b/drivers/char/serial167.c
index f36342ae8e7e..037c940ac71b 100644
--- a/drivers/char/serial167.c
+++ b/drivers/char/serial167.c
@@ -129,7 +129,6 @@ struct cyclades_port cy_port[] = {
  * memory if large numbers of serial ports are open.
  */
 static unsigned char *tmp_buf = 0;
-DECLARE_MUTEX(tmp_buf_sem);
 
 /*
  * This is used to look up the divisor speeds and the timeouts
diff --git a/drivers/char/specialix.c b/drivers/char/specialix.c
index 0a574bdbce36..5343e9fc6ab7 100644
--- a/drivers/char/specialix.c
+++ b/drivers/char/specialix.c
@@ -184,7 +184,6 @@ static int sx_poll = HZ;
 
 static struct tty_driver *specialix_driver;
 static unsigned char * tmp_buf;
-static DECLARE_MUTEX(tmp_buf_sem);
 
 static unsigned long baud_table[] =  {
         0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800,
@@ -2556,8 +2555,6 @@ static int __init specialix_init_module(void)
 
         func_enter();
 
-        init_MUTEX(&tmp_buf_sem); /* Init de the semaphore - pvdl */
-
         if (iobase[0] || iobase[1] || iobase[2] || iobase[3]) {
                 for(i = 0; i < SX_NBOARD; i++) {
                         sx_board[i].base = iobase[i];
diff --git a/drivers/char/synclink.c b/drivers/char/synclink.c
index 9f1b466c4f84..ede688a4e141 100644
--- a/drivers/char/synclink.c
+++ b/drivers/char/synclink.c
@@ -951,7 +951,6 @@ static void* mgsl_get_text_ptr(void)
  * memory if large numbers of serial ports are open.
  */
 static unsigned char *tmp_buf;
-static DECLARE_MUTEX(tmp_buf_sem);
 
 static inline int mgsl_paranoia_check(struct mgsl_struct *info,
                                         char *name, const char *routine)
diff --git a/drivers/char/watchdog/Kconfig b/drivers/char/watchdog/Kconfig
index a6544790af60..c0dfcf273f0a 100644
--- a/drivers/char/watchdog/Kconfig
+++ b/drivers/char/watchdog/Kconfig
@@ -395,12 +395,38 @@ config MACHZ_WDT
           To compile this driver as a module, choose M here: the
           module will be called machzwd.
 
+config SBC_EPX_C3_WATCHDOG
+        tristate "Winsystems SBC EPX-C3 watchdog"
+        depends on WATCHDOG && X86
+        ---help---
+          This is the driver for the built-in watchdog timer on the EPX-C3
+          Single-board computer made by Winsystems, Inc.
+
+          *Note*: This hardware watchdog is not probeable and thus there
+          is no way to know if writing to its IO address will corrupt
+          your system or have any real effect.  The only way to be sure
+          that this driver does what you want is to make sure you
+          are runnning it on an EPX-C3 from Winsystems with the watchdog
+          timer at IO address 0x1ee and 0x1ef.  It will write to both those
+          IO ports.  Basically, the assumption is made that if you compile
+          this driver into your kernel and/or load it as a module, that you
+          know what you are doing and that you are in fact running on an
+          EPX-C3 board!
+
+          To compile this driver as a module, choose M here: the
+          module will be called sbc_epx_c3.
+
+
 # PowerPC Architecture
 
 config 8xx_WDT
         tristate "MPC8xx Watchdog Timer"
         depends on WATCHDOG && 8xx
 
+config 83xx_WDT
+        tristate "MPC83xx Watchdog Timer"
+        depends on WATCHDOG && PPC_83xx
+
 config MV64X60_WDT
         tristate "MV64X60 (Marvell Discovery) Watchdog Timer"
         depends on WATCHDOG && MV64X60
diff --git a/drivers/char/watchdog/Makefile b/drivers/char/watchdog/Makefile
index cfd0a3987710..36c0b282b8ba 100644
--- a/drivers/char/watchdog/Makefile
+++ b/drivers/char/watchdog/Makefile
@@ -52,9 +52,11 @@ obj-$(CONFIG_W83627HF_WDT) += w83627hf_wdt.o
 obj-$(CONFIG_W83877F_WDT) += w83877f_wdt.o
 obj-$(CONFIG_W83977F_WDT) += w83977f_wdt.o
 obj-$(CONFIG_MACHZ_WDT) += machzwd.o
+obj-$(CONFIG_SBC_EPX_C3_WATCHDOG) += sbc_epx_c3.o
 
 # PowerPC Architecture
 obj-$(CONFIG_8xx_WDT) += mpc8xx_wdt.o
+obj-$(CONFIG_83xx_WDT) += mpc83xx_wdt.o
 obj-$(CONFIG_MV64X60_WDT) += mv64x60_wdt.o
 obj-$(CONFIG_BOOKE_WDT) += booke_wdt.o
 
diff --git a/drivers/char/watchdog/mpc83xx_wdt.c b/drivers/char/watchdog/mpc83xx_wdt.c
new file mode 100644
index 000000000000..5d6f5061603a
--- /dev/null
+++ b/drivers/char/watchdog/mpc83xx_wdt.c
@@ -0,0 +1,229 @@
+/*
+ * mpc83xx_wdt.c - MPC83xx watchdog userspace interface
+ *
+ * Authors: Dave Updegraff <dave@cray.org>
+ *          Kumar Gala <galak@kernel.crashing.org>
+ *              Attribution: from 83xx_wst: Florian Schirmer <jolt@tuxbox.org>
+ *                              ..and from sc520_wdt
+ *
+ * Note: it appears that you can only actually ENABLE or DISABLE the thing
+ * once after POR. Once enabled, you cannot disable, and vice versa.
+ *
+ * This program is free software; you can redistribute  it and/or modify it
+ * under  the terms of  the GNU General  Public License as published by the
+ * Free Software Foundation;  either version 2 of the  License, or (at your
+ * option) any later version.
+ */
+
+#include <linux/config.h>
+#include <linux/fs.h>
+#include <linux/init.h>
+#include <linux/kernel.h>
+#include <linux/miscdevice.h>
+#include <linux/platform_device.h>
+#include <linux/module.h>
+#include <linux/watchdog.h>
+#include <asm/io.h>
+#include <asm/uaccess.h>
+
+struct mpc83xx_wdt {
+        __be32 res0;
+        __be32 swcrr; /* System watchdog control register */
+#define SWCRR_SWTC 0xFFFF0000 /* Software Watchdog Time Count. */
+#define SWCRR_SWEN 0x00000004 /* Watchdog Enable bit. */
+#define SWCRR_SWRI 0x00000002 /* Software Watchdog Reset/Interrupt Select bit.*/
+#define SWCRR_SWPR 0x00000001 /* Software Watchdog Counter Prescale bit. */
+        __be32 swcnr; /* System watchdog count register */
+        u8 res1[2];
+        __be16 swsrr; /* System watchdog service register */
+        u8 res2[0xF0];
+};
+
+static struct mpc83xx_wdt __iomem *wd_base;
+
+static u16 timeout = 0xffff;
+module_param(timeout, ushort, 0);
+MODULE_PARM_DESC(timeout, "Watchdog timeout in ticks. (0<timeout<65536, default=65535");
+
+static int reset = 1;
+module_param(reset, bool, 0);
+MODULE_PARM_DESC(reset, "Watchdog Interrupt/Reset Mode. 0 = interrupt, 1 = reset");
+
+/*
+ * We always prescale, but if someone really doesn't want to they can set this
+ * to 0
+ */
+static int prescale = 1;
+static unsigned int timeout_sec;
+
+static unsigned long wdt_is_open;
+static spinlock_t wdt_spinlock;
+
+static void mpc83xx_wdt_keepalive(void)
+{
+        /* Ping the WDT */
+        spin_lock(&wdt_spinlock);
+        out_be16(&wd_base->swsrr, 0x556c);
+        out_be16(&wd_base->swsrr, 0xaa39);
+        spin_unlock(&wdt_spinlock);
+}
+
+static ssize_t mpc83xx_wdt_write(struct file *file, const char __user *buf,
+                                 size_t count, loff_t *ppos)
+{
+        if (count)
+                mpc83xx_wdt_keepalive();
+        return count;
+}
+
+static int mpc83xx_wdt_open(struct inode *inode, struct file *file)
+{
+        u32 tmp = SWCRR_SWEN;
+        if (test_and_set_bit(0, &wdt_is_open))
+                return -EBUSY;
+
+        /* Once we start the watchdog we can't stop it */
+        __module_get(THIS_MODULE);
+
+        /* Good, fire up the show */
+        if (prescale)
+                tmp |= SWCRR_SWPR;
+        if (reset)
+                tmp |= SWCRR_SWRI;
+
+        tmp |= timeout << 16;
+
+        out_be32(&wd_base->swcrr, tmp);
+
+        return nonseekable_open(inode, file);
+}
+
+static int mpc83xx_wdt_release(struct inode *inode, struct file *file)
+{
+        printk(KERN_CRIT "Unexpected close, not stopping watchdog!\n");
+        mpc83xx_wdt_keepalive();
+        clear_bit(0, &wdt_is_open);
+        return 0;
+}
+
+static int mpc83xx_wdt_ioctl(struct inode *inode, struct file *file,
+                                unsigned int cmd, unsigned long arg)
+{
+        void __user *argp = (void __user *)arg;
+        int __user *p = argp;
+        static struct watchdog_info ident = {
+                .options = WDIOF_KEEPALIVEPING,
+                .firmware_version = 1,
+                .identity = "MPC83xx",
+        };
+
+        switch (cmd) {
+        case WDIOC_GETSUPPORT:
+                return copy_to_user(argp, &ident, sizeof(ident)) ? -EFAULT : 0;
+        case WDIOC_KEEPALIVE:
+                mpc83xx_wdt_keepalive();
+                return 0;
+        case WDIOC_GETTIMEOUT:
+                return put_user(timeout_sec, p);
+        default:
+                return -ENOIOCTLCMD;
+        }
+}
+
+static struct file_operations mpc83xx_wdt_fops = {
+        .owner          = THIS_MODULE,
+        .llseek         = no_llseek,
+        .write          = mpc83xx_wdt_write,
+        .ioctl          = mpc83xx_wdt_ioctl,
+        .open           = mpc83xx_wdt_open,
+        .release        = mpc83xx_wdt_release,
+};
+
+static struct miscdevice mpc83xx_wdt_miscdev = {
+        .minor  = WATCHDOG_MINOR,
+        .name   = "watchdog",
+        .fops   = &mpc83xx_wdt_fops,
+};
+
+static int __devinit mpc83xx_wdt_probe(struct platform_device *dev)
+{
+        struct resource *r;
+        int ret;
+        unsigned int *freq = dev->dev.platform_data;
+
+        /* get a pointer to the register memory */
+        r = platform_get_resource(dev, IORESOURCE_MEM, 0);
+
+        if (!r) {
+                ret = -ENODEV;
+                goto err_out;
+        }
+
+        wd_base = ioremap(r->start, sizeof (struct mpc83xx_wdt));
+
+        if (wd_base == NULL) {
+                ret = -ENOMEM;
+                goto err_out;
+        }
+
+        ret = misc_register(&mpc83xx_wdt_miscdev);
+        if (ret) {
+                printk(KERN_ERR "cannot register miscdev on minor=%d "
+                                "(err=%d)\n",
+                                WATCHDOG_MINOR, ret);
+                goto err_unmap;
+        }
+
+        /* Calculate the timeout in seconds */
+        if (prescale)
+                timeout_sec = (timeout * 0x10000) / (*freq);
+        else
+                timeout_sec = timeout / (*freq);
+
+        printk(KERN_INFO "WDT driver for MPC83xx initialized. "
+                "mode:%s timeout=%d (%d seconds)\n",
+                reset ? "reset":"interrupt", timeout, timeout_sec);
+
+        spin_lock_init(&wdt_spinlock);
+
+        return 0;
+
+err_unmap:
+        iounmap(wd_base);
+err_out:
+        return ret;
+}
+
+static int __devexit mpc83xx_wdt_remove(struct platform_device *dev)
+{
+        misc_deregister(&mpc83xx_wdt_miscdev);
+        iounmap(wd_base);
+
+        return 0;
+}
+
+static struct platform_driver mpc83xx_wdt_driver = {
+        .probe          = mpc83xx_wdt_probe,
+        .remove         = __devexit_p(mpc83xx_wdt_remove),
+        .driver         = {
+                .name   = "mpc83xx_wdt",
+        },
+};
+
+static int __init mpc83xx_wdt_init(void)
+{
+        return platform_driver_register(&mpc83xx_wdt_driver);
+}
+
+static void __exit mpc83xx_wdt_exit(void)
+{
+        platform_driver_unregister(&mpc83xx_wdt_driver);
+}
+
+module_init(mpc83xx_wdt_init);
+module_exit(mpc83xx_wdt_exit);
+
+MODULE_AUTHOR("Dave Updegraff, Kumar Gala");
+MODULE_DESCRIPTION("Driver for watchdog timer in MPC83xx uProcessor");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
diff --git a/drivers/char/watchdog/sbc_epx_c3.c b/drivers/char/watchdog/sbc_epx_c3.c
new file mode 100644
index 000000000000..951764614ebf
--- /dev/null
+++ b/drivers/char/watchdog/sbc_epx_c3.c
@@ -0,0 +1,216 @@
+/*
+ *      SBC EPX C3 0.1  A Hardware Watchdog Device for the Winsystems EPX-C3
+ *      single board computer
+ *
+ *      (c) Copyright 2006 Calin A. Culianu <calin@ajvar.org>, All Rights
+ *      Reserved.
+ *
+ *      This program is free software; you can redistribute it and/or
+ *      modify it under the terms of the GNU General Public License
+ *      as published by the Free Software Foundation; either version
+ *      2 of the License, or (at your option) any later version.
+ *
+ *      based on softdog.c by Alan Cox <alan@redhat.com>
+ */
+
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/config.h>
+#include <linux/types.h>
+#include <linux/kernel.h>
+#include <linux/fs.h>
+#include <linux/mm.h>
+#include <linux/miscdevice.h>
+#include <linux/watchdog.h>
+#include <linux/notifier.h>
+#include <linux/reboot.h>
+#include <linux/init.h>
+#include <asm/uaccess.h>
+#include <asm/io.h>
+
+#define PFX "epx_c3: "
+static int epx_c3_alive;
+
+#define WATCHDOG_TIMEOUT 1              /* 1 sec default timeout */
+
+static int nowayout = WATCHDOG_NOWAYOUT;
+module_param(nowayout, int, 0);
+MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default=CONFIG_WATCHDOG_NOWAYOUT)");
+
+#define EPXC3_WATCHDOG_CTL_REG 0x1ee /* write 1 to enable, 0 to disable */
+#define EPXC3_WATCHDOG_PET_REG 0x1ef /* write anything to pet once enabled */
+
+static void epx_c3_start(void)
+{
+        outb(1, EPXC3_WATCHDOG_CTL_REG);
+}
+
+static void epx_c3_stop(void)
+{
+
+        outb(0, EPXC3_WATCHDOG_CTL_REG);
+
+        printk(KERN_INFO PFX "Stopped watchdog timer.\n");
+}
+
+static void epx_c3_pet(void)
+{
+        outb(1, EPXC3_WATCHDOG_PET_REG);
+}
+
+/*
+ *      Allow only one person to hold it open
+ */
+static int epx_c3_open(struct inode *inode, struct file *file)
+{
+        if (epx_c3_alive)
+                return -EBUSY;
+
+        if (nowayout)
+                __module_get(THIS_MODULE);
+
+        /* Activate timer */
+        epx_c3_start();
+        epx_c3_pet();
+
+        epx_c3_alive = 1;
+        printk(KERN_INFO "Started watchdog timer.\n");
+
+        return nonseekable_open(inode, file);
+}
+
+static int epx_c3_release(struct inode *inode, struct file *file)
+{
+        /* Shut off the timer.
+         * Lock it in if it's a module and we defined ...NOWAYOUT */
+        if (!nowayout)
+                epx_c3_stop();          /* Turn the WDT off */
+
+        epx_c3_alive = 0;
+
+        return 0;
+}
+
+static ssize_t epx_c3_write(struct file *file, const char *data,
+                        size_t len, loff_t *ppos)
+{
+        /* Refresh the timer. */
+        if (len)
+                epx_c3_pet();
+        return len;
+}
+
+static int epx_c3_ioctl(struct inode *inode, struct file *file,
+                        unsigned int cmd, unsigned long arg)
+{
+        int options, retval = -EINVAL;
+        static struct watchdog_info ident = {
+                .options                = WDIOF_KEEPALIVEPING |
+                                          WDIOF_MAGICCLOSE,
+                .firmware_version       = 0,
+                .identity               = "Winsystems EPX-C3 H/W Watchdog",
+        };
+
+        switch (cmd) {
+        case WDIOC_GETSUPPORT:
+                if (copy_to_user((struct watchdog_info *)arg,
+                                 &ident, sizeof(ident)))
+                        return -EFAULT;
+                return 0;
+        case WDIOC_GETSTATUS:
+        case WDIOC_GETBOOTSTATUS:
+                return put_user(0,(int *)arg);
+        case WDIOC_KEEPALIVE:
+                epx_c3_pet();
+                return 0;
+        case WDIOC_GETTIMEOUT:
+                return put_user(WATCHDOG_TIMEOUT,(int *)arg);
+        case WDIOC_SETOPTIONS: {
+                if (get_user(options, (int *)arg))
+                        return -EFAULT;
+
+                if (options & WDIOS_DISABLECARD) {
+                        epx_c3_stop();
+                        retval = 0;
+                }
+
+                if (options & WDIOS_ENABLECARD) {
+                        epx_c3_start();
+                        retval = 0;
+                }
+
+                return retval;
+        }
+        default:
+                return -ENOIOCTLCMD;
+        }
+}
+
+static int epx_c3_notify_sys(struct notifier_block *this, unsigned long code,
+                                void *unused)
+{
+        if (code == SYS_DOWN || code == SYS_HALT)
+                epx_c3_stop();          /* Turn the WDT off */
+
+        return NOTIFY_DONE;
+}
+
+static struct file_operations epx_c3_fops = {
+        .owner          = THIS_MODULE,
+        .llseek         = no_llseek,
+        .write          = epx_c3_write,
+        .ioctl          = epx_c3_ioctl,
+        .open           = epx_c3_open,
+        .release        = epx_c3_release,
+};
+
+static struct miscdevice epx_c3_miscdev = {
+        .minor          = WATCHDOG_MINOR,
+        .name           = "watchdog",
+        .fops           = &epx_c3_fops,
+};
+
+static struct notifier_block epx_c3_notifier = {
+        .notifier_call = epx_c3_notify_sys,
+};
+
+static const char banner[] __initdata =
+    KERN_INFO PFX "Hardware Watchdog Timer for Winsystems EPX-C3 SBC: 0.1\n";
+
+static int __init watchdog_init(void)
+{
+        int ret;
+
+        ret = register_reboot_notifier(&epx_c3_notifier);
+        if (ret) {
+                printk(KERN_ERR PFX "cannot register reboot notifier "
+                        "(err=%d)\n", ret);
+                return ret;
+        }
+
+        ret = misc_register(&epx_c3_miscdev);
+        if (ret) {
+                printk(KERN_ERR PFX "cannot register miscdev on minor=%d "
+                        "(err=%d)\n", WATCHDOG_MINOR, ret);
+                unregister_reboot_notifier(&epx_c3_notifier);
+                return ret;
+        }
+
+        printk(banner);
+
+        return 0;
+}
+
+static void __exit watchdog_exit(void)
+{
+        misc_deregister(&epx_c3_miscdev);
+        unregister_reboot_notifier(&epx_c3_notifier);
+}
+
+module_init(watchdog_init);
+module_exit(watchdog_exit);
+
+MODULE_AUTHOR("Calin A. Culianu <calin@ajvar.org>");
+MODULE_DESCRIPTION("Hardware Watchdog Device for Winsystems EPX-C3 SBC.  Note that there is no way to probe for this device -- so only use it if you are *sure* you are runnning on this specific SBC system from Winsystems!  It writes to IO ports 0x1ee and 0x1ef!");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
diff --git a/drivers/cpufreq/cpufreq.c b/drivers/cpufreq/cpufreq.c
index a9163d02983a..277a843a87a6 100644
--- a/drivers/cpufreq/cpufreq.c
+++ b/drivers/cpufreq/cpufreq.c
@@ -41,7 +41,6 @@ static DEFINE_SPINLOCK(cpufreq_driver_lock);
 /* internal prototypes */
 static int __cpufreq_governor(struct cpufreq_policy *policy, unsigned int event);
 static void handle_update(void *data);
-static inline void adjust_jiffies(unsigned long val, struct cpufreq_freqs *ci);
 
 /**
  * Two notifier lists: the "policy" list is involved in the 
@@ -127,7 +126,7 @@ static unsigned int debug_ratelimit = 1;
 static unsigned int disable_ratelimit = 1;
 static DEFINE_SPINLOCK(disable_ratelimit_lock);
 
-static inline void cpufreq_debug_enable_ratelimit(void)
+static void cpufreq_debug_enable_ratelimit(void)
 {
         unsigned long flags;
 
@@ -137,7 +136,7 @@ static inline void cpufreq_debug_enable_ratelimit(void)
         spin_unlock_irqrestore(&disable_ratelimit_lock, flags);
 }
 
-static inline void cpufreq_debug_disable_ratelimit(void)
+static void cpufreq_debug_disable_ratelimit(void)
 {
         unsigned long flags;
 
@@ -206,7 +205,7 @@ static inline void cpufreq_debug_disable_ratelimit(void) { return; }
 static unsigned long l_p_j_ref;
 static unsigned int  l_p_j_ref_freq;
 
-static inline void adjust_jiffies(unsigned long val, struct cpufreq_freqs *ci)
+static void adjust_jiffies(unsigned long val, struct cpufreq_freqs *ci)
 {
         if (ci->flags & CPUFREQ_CONST_LOOPS)
                 return;
diff --git a/drivers/dio/dio-driver.c b/drivers/dio/dio-driver.c
index ffe6f44ac76f..ca8e69d2f64d 100644
--- a/drivers/dio/dio-driver.c
+++ b/drivers/dio/dio-driver.c
@@ -83,7 +83,6 @@ int dio_register_driver(struct dio_driver *drv)
         /* initialize common driver fields */
         drv->driver.name = drv->name;
         drv->driver.bus = &dio_bus_type;
-        drv->driver.probe = dio_device_probe;
 
         /* register with core */
         count = driver_register(&drv->driver);
@@ -145,7 +144,8 @@ static int dio_bus_match(struct device *dev, struct device_driver *drv)
 
 struct bus_type dio_bus_type = {
         .name   = "dio",
-        .match  = dio_bus_match
+        .match  = dio_bus_match,
+        .probe  = dio_device_probe,
 };
 
 
diff --git a/drivers/firmware/dell_rbu.c b/drivers/firmware/dell_rbu.c
index dfedb777d8c9..fdb8b042e64d 100644
--- a/drivers/firmware/dell_rbu.c
+++ b/drivers/firmware/dell_rbu.c
@@ -49,7 +49,7 @@
 MODULE_AUTHOR("Abhay Salunke <abhay_salunke@dell.com>");
 MODULE_DESCRIPTION("Driver for updating BIOS image on DELL systems");
 MODULE_LICENSE("GPL");
-MODULE_VERSION("3.1");
+MODULE_VERSION("3.2");
 
 #define BIOS_SCAN_LIMIT 0xffffffff
 #define MAX_IMAGE_LENGTH 16
@@ -564,12 +564,10 @@ static ssize_t read_rbu_data(struct kobject *kobj, char *buffer,
 
 static void callbackfn_rbu(const struct firmware *fw, void *context)
 {
-        int rc = 0;
+        rbu_data.entry_created = 0;
 
-        if (!fw || !fw->size) {
-                rbu_data.entry_created = 0;
+        if (!fw || !fw->size)
                 return;
-        }
 
         spin_lock(&rbu_data.lock);
         if (!strcmp(image_type, "mono")) {
@@ -592,15 +590,6 @@ static void callbackfn_rbu(const struct firmware *fw, void *context)
         } else
                 pr_debug("invalid image type specified.\n");
         spin_unlock(&rbu_data.lock);
-
-        rc = request_firmware_nowait(THIS_MODULE, FW_ACTION_NOHOTPLUG,
-                "dell_rbu", &rbu_device->dev, &context, callbackfn_rbu);
-        if (rc)
-                printk(KERN_ERR
-                        "dell_rbu:%s request_firmware_nowait failed"
-                        " %d\n", __FUNCTION__, rc);
-        else
-                rbu_data.entry_created = 1;
 }
 
 static ssize_t read_rbu_image_type(struct kobject *kobj, char *buffer,
@@ -735,14 +724,7 @@ static int __init dcdrbu_init(void)
         sysfs_create_bin_file(&rbu_device->dev.kobj,
                 &rbu_packet_size_attr);
 
-        rc = request_firmware_nowait(THIS_MODULE, FW_ACTION_NOHOTPLUG,
-                "dell_rbu", &rbu_device->dev, &context, callbackfn_rbu);
-        if (rc)
-                printk(KERN_ERR "dell_rbu:%s:request_firmware_nowait"
-                        " failed %d\n", __FUNCTION__, rc);
-        else
-                rbu_data.entry_created = 1;
-
+        rbu_data.entry_created = 0;
         return rc;
 
 }
diff --git a/drivers/i2c/i2c-core.c b/drivers/i2c/i2c-core.c
index 52b77477df57..0ce58b506046 100644
--- a/drivers/i2c/i2c-core.c
+++ b/drivers/i2c/i2c-core.c
@@ -63,13 +63,6 @@ static int i2c_bus_resume(struct device * dev)
         return rc;
 }
 
-struct bus_type i2c_bus_type = {
-        .name =         "i2c",
-        .match =        i2c_device_match,
-        .suspend =      i2c_bus_suspend,
-        .resume =       i2c_bus_resume,
-};
-
 static int i2c_device_probe(struct device *dev)
 {
         return -ENODEV;
@@ -80,6 +73,15 @@ static int i2c_device_remove(struct device *dev)
         return 0;
 }
 
+struct bus_type i2c_bus_type = {
+        .name =         "i2c",
+        .match =        i2c_device_match,
+        .probe =        i2c_device_probe,
+        .remove =       i2c_device_remove,
+        .suspend =      i2c_bus_suspend,
+        .resume =       i2c_bus_resume,
+};
+
 void i2c_adapter_dev_release(struct device *dev)
 {
         struct i2c_adapter *adap = dev_to_i2c_adapter(dev);
@@ -90,8 +92,6 @@ struct device_driver i2c_adapter_driver = {
         .owner = THIS_MODULE,
         .name = "i2c_adapter",
         .bus = &i2c_bus_type,
-        .probe = i2c_device_probe,
-        .remove = i2c_device_remove,
 };
 
 static void i2c_adapter_class_dev_release(struct class_device *dev)
@@ -294,8 +294,6 @@ int i2c_register_driver(struct module *owner, struct i2c_driver *driver)
         /* add the driver to the list of i2c drivers in the driver core */
         driver->driver.owner = owner;
         driver->driver.bus = &i2c_bus_type;
-        driver->driver.probe = i2c_device_probe;
-        driver->driver.remove = i2c_device_remove;
 
         res = driver_register(&driver->driver);
         if (res)
diff --git a/drivers/ide/ide-cd.c b/drivers/ide/ide-cd.c
index 9b2ebd219ad0..3325660f7248 100644
--- a/drivers/ide/ide-cd.c
+++ b/drivers/ide/ide-cd.c
@@ -980,7 +980,7 @@ static void cdrom_buffer_sectors (ide_drive_t *drive, unsigned long sector,
  * and attempt to recover if there are problems.  Returns  0 if everything's
  * ok; nonzero if the request has been terminated.
  */
-static inline
+static
 int cdrom_read_check_ireason (ide_drive_t *drive, int len, int ireason)
 {
         if (ireason == 2)
@@ -1539,7 +1539,7 @@ int cdrom_queue_packet_command(ide_drive_t *drive, struct request *rq)
 /*
  * Write handling
  */
-static inline int cdrom_write_check_ireason(ide_drive_t *drive, int len, int ireason)
+static int cdrom_write_check_ireason(ide_drive_t *drive, int len, int ireason)
 {
         /* Two notes about IDE interrupt reason here - 0 means that
          * the drive wants to receive data from us, 2 means that
@@ -3256,9 +3256,8 @@ sector_t ide_cdrom_capacity (ide_drive_t *drive)
 }
 #endif
 
-static int ide_cd_remove(struct device *dev)
+static void ide_cd_remove(ide_drive_t *drive)
 {
-        ide_drive_t *drive = to_ide_device(dev);
         struct cdrom_info *info = drive->driver_data;
 
         ide_unregister_subdriver(drive, info->driver);
@@ -3266,8 +3265,6 @@ static int ide_cd_remove(struct device *dev)
         del_gendisk(info->disk);
 
         ide_cd_put(info);
-
-        return 0;
 }
 
 static void ide_cd_release(struct kref *kref)
@@ -3291,7 +3288,7 @@ static void ide_cd_release(struct kref *kref)
         kfree(info);
 }
 
-static int ide_cd_probe(struct device *);
+static int ide_cd_probe(ide_drive_t *);
 
 #ifdef CONFIG_PROC_FS
 static int proc_idecd_read_capacity
@@ -3317,9 +3314,9 @@ static ide_driver_t ide_cdrom_driver = {
                 .owner          = THIS_MODULE,
                 .name           = "ide-cdrom",
                 .bus            = &ide_bus_type,
-                .probe          = ide_cd_probe,
-                .remove         = ide_cd_remove,
         },
+        .probe                  = ide_cd_probe,
+        .remove                 = ide_cd_remove,
         .version                = IDECD_VERSION,
         .media                  = ide_cdrom,
         .supports_dsc_overlap   = 1,
@@ -3413,9 +3410,8 @@ static char *ignore = NULL;
 module_param(ignore, charp, 0400);
 MODULE_DESCRIPTION("ATAPI CD-ROM Driver");
 
-static int ide_cd_probe(struct device *dev)
+static int ide_cd_probe(ide_drive_t *drive)
 {
-        ide_drive_t *drive = to_ide_device(dev);
         struct cdrom_info *info;
         struct gendisk *g;
         struct request_sense sense;
diff --git a/drivers/ide/ide-disk.c b/drivers/ide/ide-disk.c
index cab362ea0336..ca25f9e3d0f4 100644
--- a/drivers/ide/ide-disk.c
+++ b/drivers/ide/ide-disk.c
@@ -477,7 +477,7 @@ static inline int idedisk_supports_lba48(const struct hd_driveid *id)
                && id->lba_capacity_2;
 }
 
-static inline void idedisk_check_hpa(ide_drive_t *drive)
+static void idedisk_check_hpa(ide_drive_t *drive)
 {
         unsigned long long capacity, set_max;
         int lba48 = idedisk_supports_lba48(drive->id);
@@ -997,9 +997,8 @@ static void ide_cacheflush_p(ide_drive_t *drive)
                 printk(KERN_INFO "%s: wcache flush failed!\n", drive->name);
 }
 
-static int ide_disk_remove(struct device *dev)
+static void ide_disk_remove(ide_drive_t *drive)
 {
-        ide_drive_t *drive = to_ide_device(dev);
         struct ide_disk_obj *idkp = drive->driver_data;
         struct gendisk *g = idkp->disk;
 
@@ -1010,8 +1009,6 @@ static int ide_disk_remove(struct device *dev)
         ide_cacheflush_p(drive);
 
         ide_disk_put(idkp);
-
-        return 0;
 }
 
 static void ide_disk_release(struct kref *kref)
@@ -1027,12 +1024,10 @@ static void ide_disk_release(struct kref *kref)
         kfree(idkp);
 }
 
-static int ide_disk_probe(struct device *dev);
+static int ide_disk_probe(ide_drive_t *drive);
 
-static void ide_device_shutdown(struct device *dev)
+static void ide_device_shutdown(ide_drive_t *drive)
 {
-        ide_drive_t *drive = container_of(dev, ide_drive_t, gendev);
-
 #ifdef  CONFIG_ALPHA
         /* On Alpha, halt(8) doesn't actually turn the machine off,
            it puts you into the sort of firmware monitor. Typically,
@@ -1054,7 +1049,7 @@ static void ide_device_shutdown(struct device *dev)
         }
 
         printk("Shutdown: %s\n", drive->name);
-        dev->bus->suspend(dev, PMSG_SUSPEND);
+        drive->gendev.bus->suspend(&drive->gendev, PMSG_SUSPEND);
 }
 
 static ide_driver_t idedisk_driver = {
@@ -1062,10 +1057,10 @@ static ide_driver_t idedisk_driver = {
                 .owner          = THIS_MODULE,
                 .name           = "ide-disk",
                 .bus            = &ide_bus_type,
-                .probe          = ide_disk_probe,
-                .remove         = ide_disk_remove,
-                .shutdown       = ide_device_shutdown,
         },
+        .probe                  = ide_disk_probe,
+        .remove                 = ide_disk_remove,
+        .shutdown               = ide_device_shutdown,
         .version                = IDEDISK_VERSION,
         .media                  = ide_disk,
         .supports_dsc_overlap   = 0,
@@ -1182,9 +1177,8 @@ static struct block_device_operations idedisk_ops = {
 
 MODULE_DESCRIPTION("ATA DISK Driver");
 
-static int ide_disk_probe(struct device *dev)
+static int ide_disk_probe(ide_drive_t *drive)
 {
-        ide_drive_t *drive = to_ide_device(dev);
         struct ide_disk_obj *idkp;
         struct gendisk *g;
 
diff --git a/drivers/ide/ide-floppy.c b/drivers/ide/ide-floppy.c
index 5945f551aaaa..1f8db9ac05d1 100644
--- a/drivers/ide/ide-floppy.c
+++ b/drivers/ide/ide-floppy.c
@@ -1871,9 +1871,8 @@ static void idefloppy_setup (ide_drive_t *drive, idefloppy_floppy_t *floppy)
         idefloppy_add_settings(drive);
 }
 
-static int ide_floppy_remove(struct device *dev)
+static void ide_floppy_remove(ide_drive_t *drive)
 {
-        ide_drive_t *drive = to_ide_device(dev);
         idefloppy_floppy_t *floppy = drive->driver_data;
         struct gendisk *g = floppy->disk;
 
@@ -1882,8 +1881,6 @@ static int ide_floppy_remove(struct device *dev)
         del_gendisk(g);
 
         ide_floppy_put(floppy);
-
-        return 0;
 }
 
 static void ide_floppy_release(struct kref *kref)
@@ -1922,16 +1919,16 @@ static ide_proc_entry_t idefloppy_proc[] = {
 
 #endif  /* CONFIG_PROC_FS */
 
-static int ide_floppy_probe(struct device *);
+static int ide_floppy_probe(ide_drive_t *);
 
 static ide_driver_t idefloppy_driver = {
         .gen_driver = {
                 .owner          = THIS_MODULE,
                 .name           = "ide-floppy",
                 .bus            = &ide_bus_type,
-                .probe          = ide_floppy_probe,
-                .remove         = ide_floppy_remove,
         },
+        .probe                  = ide_floppy_probe,
+        .remove                 = ide_floppy_remove,
         .version                = IDEFLOPPY_VERSION,
         .media                  = ide_floppy,
         .supports_dsc_overlap   = 0,
@@ -2136,9 +2133,8 @@ static struct block_device_operations idefloppy_ops = {
         .revalidate_disk= idefloppy_revalidate_disk
 };
 
-static int ide_floppy_probe(struct device *dev)
+static int ide_floppy_probe(ide_drive_t *drive)
 {
-        ide_drive_t *drive = to_ide_device(dev);
         idefloppy_floppy_t *floppy;
         struct gendisk *g;
 
diff --git a/drivers/ide/ide-tape.c b/drivers/ide/ide-tape.c
index fab9b2b02504..0101d0def7c5 100644
--- a/drivers/ide/ide-tape.c
+++ b/drivers/ide/ide-tape.c
@@ -4682,9 +4682,8 @@ static void idetape_setup (ide_drive_t *drive, idetape_tape_t *tape, int minor)
         idetape_add_settings(drive);
 }
 
-static int ide_tape_remove(struct device *dev)
+static void ide_tape_remove(ide_drive_t *drive)
 {
-        ide_drive_t *drive = to_ide_device(dev);
         idetape_tape_t *tape = drive->driver_data;
 
         ide_unregister_subdriver(drive, tape->driver);
@@ -4692,8 +4691,6 @@ static int ide_tape_remove(struct device *dev)
         ide_unregister_region(tape->disk);
 
         ide_tape_put(tape);
-
-        return 0;
 }
 
 static void ide_tape_release(struct kref *kref)
@@ -4745,16 +4742,16 @@ static ide_proc_entry_t idetape_proc[] = {
 
 #endif
 
-static int ide_tape_probe(struct device *);
+static int ide_tape_probe(ide_drive_t *);
 
 static ide_driver_t idetape_driver = {
         .gen_driver = {
                 .owner          = THIS_MODULE,
                 .name           = "ide-tape",
                 .bus            = &ide_bus_type,
-                .probe          = ide_tape_probe,
-                .remove         = ide_tape_remove,
         },
+        .probe                  = ide_tape_probe,
+        .remove                 = ide_tape_remove,
         .version                = IDETAPE_VERSION,
         .media                  = ide_tape,
         .supports_dsc_overlap   = 1,
@@ -4825,9 +4822,8 @@ static struct block_device_operations idetape_block_ops = {
         .ioctl          = idetape_ioctl,
 };
 
-static int ide_tape_probe(struct device *dev)
+static int ide_tape_probe(ide_drive_t *drive)
 {
-        ide_drive_t *drive = to_ide_device(dev);
         idetape_tape_t *tape;
         struct gendisk *g;
         int minor;
@@ -4883,9 +4879,9 @@ static int ide_tape_probe(struct device *dev)
         idetape_setup(drive, tape, minor);
 
         class_device_create(idetape_sysfs_class, NULL,
-                        MKDEV(IDETAPE_MAJOR, minor), dev, "%s", tape->name);
+                        MKDEV(IDETAPE_MAJOR, minor), &drive->gendev, "%s", tape->name);
         class_device_create(idetape_sysfs_class, NULL,
-                        MKDEV(IDETAPE_MAJOR, minor + 128), dev, "n%s", tape->name);
+                        MKDEV(IDETAPE_MAJOR, minor + 128), &drive->gendev, "n%s", tape->name);
 
         devfs_mk_cdev(MKDEV(HWIF(drive)->major, minor),
                         S_IFCHR | S_IRUGO | S_IWUGO,
diff --git a/drivers/ide/ide-taskfile.c b/drivers/ide/ide-taskfile.c
index 62ebefd6394a..9834dce4e20f 100644
--- a/drivers/ide/ide-taskfile.c
+++ b/drivers/ide/ide-taskfile.c
@@ -308,7 +308,7 @@ static void ide_pio_multi(ide_drive_t *drive, unsigned int write)
                 ide_pio_sector(drive, write);
 }
 
-static inline void ide_pio_datablock(ide_drive_t *drive, struct request *rq,
+static void ide_pio_datablock(ide_drive_t *drive, struct request *rq,
                                      unsigned int write)
 {
         if (rq->bio)    /* fs request */
diff --git a/drivers/ide/ide.c b/drivers/ide/ide.c
index ec5a4cb173b0..afeb02bbb722 100644
--- a/drivers/ide/ide.c
+++ b/drivers/ide/ide.c
@@ -1949,10 +1949,41 @@ static int ide_uevent(struct device *dev, char **envp, int num_envp,
         return 0;
 }
 
+static int generic_ide_probe(struct device *dev)
+{
+        ide_drive_t *drive = to_ide_device(dev);
+        ide_driver_t *drv = to_ide_driver(dev->driver);
+
+        return drv->probe ? drv->probe(drive) : -ENODEV;
+}
+
+static int generic_ide_remove(struct device *dev)
+{
+        ide_drive_t *drive = to_ide_device(dev);
+        ide_driver_t *drv = to_ide_driver(dev->driver);
+
+        if (drv->remove)
+                drv->remove(drive);
+
+        return 0;
+}
+
+static void generic_ide_shutdown(struct device *dev)
+{
+        ide_drive_t *drive = to_ide_device(dev);
+        ide_driver_t *drv = to_ide_driver(dev->driver);
+
+        if (dev->driver && drv->shutdown)
+                drv->shutdown(drive);
+}
+
 struct bus_type ide_bus_type = {
         .name           = "ide",
         .match          = ide_bus_match,
         .uevent         = ide_uevent,
+        .probe          = generic_ide_probe,
+        .remove         = generic_ide_remove,
+        .shutdown       = generic_ide_shutdown,
         .dev_attrs      = ide_dev_attrs,
         .suspend        = generic_ide_suspend,
         .resume         = generic_ide_resume,
diff --git a/drivers/infiniband/core/cm.c b/drivers/infiniband/core/cm.c
index 3a611fe5497e..2514de3480d8 100644
--- a/drivers/infiniband/core/cm.c
+++ b/drivers/infiniband/core/cm.c
@@ -856,7 +856,7 @@ static void cm_format_req(struct cm_req_msg *req_msg,
                        param->private_data_len);
 }
 
-static inline int cm_validate_req_param(struct ib_cm_req_param *param)
+static int cm_validate_req_param(struct ib_cm_req_param *param)
 {
         /* peer-to-peer not supported */
         if (param->peer_to_peer)
@@ -1005,7 +1005,7 @@ static inline int cm_is_active_peer(__be64 local_ca_guid, __be64 remote_ca_guid,
                  (be32_to_cpu(local_qpn) > be32_to_cpu(remote_qpn))));
 }
 
-static inline void cm_format_paths_from_req(struct cm_req_msg *req_msg,
+static void cm_format_paths_from_req(struct cm_req_msg *req_msg,
                                             struct ib_sa_path_rec *primary_path,
                                             struct ib_sa_path_rec *alt_path)
 {
@@ -3163,22 +3163,6 @@ int ib_cm_init_qp_attr(struct ib_cm_id *cm_id,
 }
 EXPORT_SYMBOL(ib_cm_init_qp_attr);
 
-static __be64 cm_get_ca_guid(struct ib_device *device)
-{
-        struct ib_device_attr *device_attr;
-        __be64 guid;
-        int ret;
-
-        device_attr = kmalloc(sizeof *device_attr, GFP_KERNEL);
-        if (!device_attr)
-                return 0;
-
-        ret = ib_query_device(device, device_attr);
-        guid = ret ? 0 : device_attr->node_guid;
-        kfree(device_attr);
-        return guid;
-}
-
 static void cm_add_one(struct ib_device *device)
 {
         struct cm_device *cm_dev;
@@ -3200,9 +3184,7 @@ static void cm_add_one(struct ib_device *device)
                 return;
 
         cm_dev->device = device;
-        cm_dev->ca_guid = cm_get_ca_guid(device);
-        if (!cm_dev->ca_guid)
-                goto error1;
+        cm_dev->ca_guid = device->node_guid;
 
         set_bit(IB_MGMT_METHOD_SEND, reg_req.method_mask);
         for (i = 1; i <= device->phys_port_cnt; i++) {
@@ -3217,11 +3199,11 @@ static void cm_add_one(struct ib_device *device)
                                                         cm_recv_handler,
                                                         port);
                 if (IS_ERR(port->mad_agent))
-                        goto error2;
+                        goto error1;
 
                 ret = ib_modify_port(device, i, 0, &port_modify);
                 if (ret)
-                        goto error3;
+                        goto error2;
         }
         ib_set_client_data(device, &cm_client, cm_dev);
 
@@ -3230,9 +3212,9 @@ static void cm_add_one(struct ib_device *device)
         write_unlock_irqrestore(&cm.device_lock, flags);
         return;
 
-error3:
-        ib_unregister_mad_agent(port->mad_agent);
 error2:
+        ib_unregister_mad_agent(port->mad_agent);
+error1:
         port_modify.set_port_cap_mask = 0;
         port_modify.clr_port_cap_mask = IB_PORT_CM_SUP;
         while (--i) {
@@ -3240,7 +3222,6 @@ error2:
                 ib_modify_port(device, port->port_num, 0, &port_modify);
                 ib_unregister_mad_agent(port->mad_agent);
         }
-error1:
         kfree(cm_dev);
 }
 
diff --git a/drivers/infiniband/core/device.c b/drivers/infiniband/core/device.c
index e169e798354b..b2f3cb91d9bc 100644
--- a/drivers/infiniband/core/device.c
+++ b/drivers/infiniband/core/device.c
@@ -38,8 +38,7 @@
 #include <linux/errno.h>
 #include <linux/slab.h>
 #include <linux/init.h>
-
-#include <asm/semaphore.h>
+#include <linux/mutex.h>
 
 #include "core_priv.h"
 
@@ -57,13 +56,13 @@ static LIST_HEAD(device_list);
 static LIST_HEAD(client_list);
 
 /*
- * device_sem protects access to both device_list and client_list.
+ * device_mutex protects access to both device_list and client_list.
  * There's no real point to using multiple locks or something fancier
  * like an rwsem: we always access both lists, and we're always
  * modifying one list or the other list.  In any case this is not a
  * hot path so there's no point in trying to optimize.
  */
-static DECLARE_MUTEX(device_sem);
+static DEFINE_MUTEX(device_mutex);
 
 static int ib_device_check_mandatory(struct ib_device *device)
 {
@@ -221,7 +220,7 @@ int ib_register_device(struct ib_device *device)
 {
         int ret;
 
-        down(&device_sem);
+        mutex_lock(&device_mutex);
 
         if (strchr(device->name, '%')) {
                 ret = alloc_name(device->name);
@@ -259,7 +258,7 @@ int ib_register_device(struct ib_device *device)
         }
 
  out:
-        up(&device_sem);
+        mutex_unlock(&device_mutex);
         return ret;
 }
 EXPORT_SYMBOL(ib_register_device);
@@ -276,7 +275,7 @@ void ib_unregister_device(struct ib_device *device)
         struct ib_client_data *context, *tmp;
         unsigned long flags;
 
-        down(&device_sem);
+        mutex_lock(&device_mutex);
 
         list_for_each_entry_reverse(client, &client_list, list)
                 if (client->remove)
@@ -284,7 +283,7 @@ void ib_unregister_device(struct ib_device *device)
 
         list_del(&device->core_list);
 
-        up(&device_sem);
+        mutex_unlock(&device_mutex);
 
         spin_lock_irqsave(&device->client_data_lock, flags);
         list_for_each_entry_safe(context, tmp, &device->client_data_list, list)
@@ -312,14 +311,14 @@ int ib_register_client(struct ib_client *client)
 {
         struct ib_device *device;
 
-        down(&device_sem);
+        mutex_lock(&device_mutex);
 
         list_add_tail(&client->list, &client_list);
         list_for_each_entry(device, &device_list, core_list)
                 if (client->add && !add_client_context(device, client))
                         client->add(device);
 
-        up(&device_sem);
+        mutex_unlock(&device_mutex);
 
         return 0;
 }
@@ -339,7 +338,7 @@ void ib_unregister_client(struct ib_client *client)
         struct ib_device *device;
         unsigned long flags;
 
-        down(&device_sem);
+        mutex_lock(&device_mutex);
 
         list_for_each_entry(device, &device_list, core_list) {
                 if (client->remove)
@@ -355,7 +354,7 @@ void ib_unregister_client(struct ib_client *client)
         }
         list_del(&client->list);
 
-        up(&device_sem);
+        mutex_unlock(&device_mutex);
 }
 EXPORT_SYMBOL(ib_unregister_client);
 
diff --git a/drivers/infiniband/core/sysfs.c b/drivers/infiniband/core/sysfs.c
index 1f1743c5c9a3..5982d687a000 100644
--- a/drivers/infiniband/core/sysfs.c
+++ b/drivers/infiniband/core/sysfs.c
@@ -445,13 +445,7 @@ static int ib_device_uevent(struct class_device *cdev, char **envp,
                 return -ENOMEM;
 
         /*
-         * It might be nice to pass the node GUID with the event, but
-         * right now the only way to get it is to query the device
-         * provider, and this can crash during device removal because
-         * we are will be running after driver removal has started.
-         * We could add a node_guid field to struct ib_device, or we
-         * could just let userspace read the node GUID from sysfs when
-         * devices are added.
+         * It would be nice to pass the node GUID with the event...
          */
 
         envp[i] = NULL;
@@ -623,21 +617,15 @@ static ssize_t show_sys_image_guid(struct class_device *cdev, char *buf)
 static ssize_t show_node_guid(struct class_device *cdev, char *buf)
 {
         struct ib_device *dev = container_of(cdev, struct ib_device, class_dev);
-        struct ib_device_attr attr;
-        ssize_t ret;
 
         if (!ibdev_is_alive(dev))
                 return -ENODEV;
 
-        ret = ib_query_device(dev, &attr);
-        if (ret)
-                return ret;
-
         return sprintf(buf, "%04x:%04x:%04x:%04x\n",
-                       be16_to_cpu(((__be16 *) &attr.node_guid)[0]),
-                       be16_to_cpu(((__be16 *) &attr.node_guid)[1]),
-                       be16_to_cpu(((__be16 *) &attr.node_guid)[2]),
-                       be16_to_cpu(((__be16 *) &attr.node_guid)[3]));
+                       be16_to_cpu(((__be16 *) &dev->node_guid)[0]),
+                       be16_to_cpu(((__be16 *) &dev->node_guid)[1]),
+                       be16_to_cpu(((__be16 *) &dev->node_guid)[2]),
+                       be16_to_cpu(((__be16 *) &dev->node_guid)[3]));
 }
 
 static CLASS_DEVICE_ATTR(node_type, S_IRUGO, show_node_type, NULL);
diff --git a/drivers/infiniband/core/ucm.c b/drivers/infiniband/core/ucm.c
index 6e15787d1de1..e95c4293a496 100644
--- a/drivers/infiniband/core/ucm.c
+++ b/drivers/infiniband/core/ucm.c
@@ -42,6 +42,7 @@
 #include <linux/mount.h>
 #include <linux/cdev.h>
 #include <linux/idr.h>
+#include <linux/mutex.h>
 
 #include <asm/uaccess.h>
 
@@ -113,7 +114,7 @@ static struct ib_client ucm_client = {
         .remove = ib_ucm_remove_one
 };
 
-static DECLARE_MUTEX(ctx_id_mutex);
+static DEFINE_MUTEX(ctx_id_mutex);
 static DEFINE_IDR(ctx_id_table);
 static DECLARE_BITMAP(dev_map, IB_UCM_MAX_DEVICES);
 
@@ -121,7 +122,7 @@ static struct ib_ucm_context *ib_ucm_ctx_get(struct ib_ucm_file *file, int id)
 {
         struct ib_ucm_context *ctx;
 
-        down(&ctx_id_mutex);
+        mutex_lock(&ctx_id_mutex);
         ctx = idr_find(&ctx_id_table, id);
         if (!ctx)
                 ctx = ERR_PTR(-ENOENT);
@@ -129,7 +130,7 @@ static struct ib_ucm_context *ib_ucm_ctx_get(struct ib_ucm_file *file, int id)
                 ctx = ERR_PTR(-EINVAL);
         else
                 atomic_inc(&ctx->ref);
-        up(&ctx_id_mutex);
+        mutex_unlock(&ctx_id_mutex);
 
         return ctx;
 }
@@ -186,9 +187,9 @@ static struct ib_ucm_context *ib_ucm_ctx_alloc(struct ib_ucm_file *file)
                 if (!result)
                         goto error;
 
-                down(&ctx_id_mutex);
+                mutex_lock(&ctx_id_mutex);
                 result = idr_get_new(&ctx_id_table, ctx, &ctx->id);
-                up(&ctx_id_mutex);
+                mutex_unlock(&ctx_id_mutex);
         } while (result == -EAGAIN);
 
         if (result)
@@ -550,9 +551,9 @@ static ssize_t ib_ucm_create_id(struct ib_ucm_file *file,
 err2:
         ib_destroy_cm_id(ctx->cm_id);
 err1:
-        down(&ctx_id_mutex);
+        mutex_lock(&ctx_id_mutex);
         idr_remove(&ctx_id_table, ctx->id);
-        up(&ctx_id_mutex);
+        mutex_unlock(&ctx_id_mutex);
         kfree(ctx);
         return result;
 }
@@ -572,7 +573,7 @@ static ssize_t ib_ucm_destroy_id(struct ib_ucm_file *file,
         if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
                 return -EFAULT;
 
-        down(&ctx_id_mutex);
+        mutex_lock(&ctx_id_mutex);
         ctx = idr_find(&ctx_id_table, cmd.id);
         if (!ctx)
                 ctx = ERR_PTR(-ENOENT);
@@ -580,7 +581,7 @@ static ssize_t ib_ucm_destroy_id(struct ib_ucm_file *file,
                 ctx = ERR_PTR(-EINVAL);
         else
                 idr_remove(&ctx_id_table, ctx->id);
-        up(&ctx_id_mutex);
+        mutex_unlock(&ctx_id_mutex);
 
         if (IS_ERR(ctx))
                 return PTR_ERR(ctx);
@@ -1280,9 +1281,9 @@ static int ib_ucm_close(struct inode *inode, struct file *filp)
                                  struct ib_ucm_context, file_list);
                 up(&file->mutex);
 
-                down(&ctx_id_mutex);
+                mutex_lock(&ctx_id_mutex);
                 idr_remove(&ctx_id_table, ctx->id);
-                up(&ctx_id_mutex);
+                mutex_unlock(&ctx_id_mutex);
 
                 ib_destroy_cm_id(ctx->cm_id);
                 ib_ucm_cleanup_events(ctx);
diff --git a/drivers/infiniband/core/uverbs.h b/drivers/infiniband/core/uverbs.h
index 7114e3fbab00..f7eecbc6af6c 100644
--- a/drivers/infiniband/core/uverbs.h
+++ b/drivers/infiniband/core/uverbs.h
@@ -41,6 +41,7 @@
 
 #include <linux/kref.h>
 #include <linux/idr.h>
+#include <linux/mutex.h>
 
 #include <rdma/ib_verbs.h>
 #include <rdma/ib_user_verbs.h>
@@ -88,7 +89,7 @@ struct ib_uverbs_event_file {
 
 struct ib_uverbs_file {
         struct kref                             ref;
-        struct semaphore                        mutex;
+        struct mutex                            mutex;
         struct ib_uverbs_device                *device;
         struct ib_ucontext                     *ucontext;
         struct ib_event_handler                 event_handler;
@@ -131,7 +132,7 @@ struct ib_ucq_object {
         u32                     async_events_reported;
 };
 
-extern struct semaphore ib_uverbs_idr_mutex;
+extern struct mutex ib_uverbs_idr_mutex;
 extern struct idr ib_uverbs_pd_idr;
 extern struct idr ib_uverbs_mr_idr;
 extern struct idr ib_uverbs_mw_idr;
diff --git a/drivers/infiniband/core/uverbs_cmd.c b/drivers/infiniband/core/uverbs_cmd.c
index a02c5a05c984..407b6284d7d5 100644
--- a/drivers/infiniband/core/uverbs_cmd.c
+++ b/drivers/infiniband/core/uverbs_cmd.c
@@ -67,7 +67,7 @@ ssize_t ib_uverbs_get_context(struct ib_uverbs_file *file,
         if (copy_from_user(&cmd, buf, sizeof cmd))
                 return -EFAULT;
 
-        down(&file->mutex);
+        mutex_lock(&file->mutex);
 
         if (file->ucontext) {
                 ret = -EINVAL;
@@ -119,7 +119,7 @@ ssize_t ib_uverbs_get_context(struct ib_uverbs_file *file,
 
         fd_install(resp.async_fd, filp);
 
-        up(&file->mutex);
+        mutex_unlock(&file->mutex);
 
         return in_len;
 
@@ -131,7 +131,7 @@ err_free:
         ibdev->dealloc_ucontext(ucontext);
 
 err:
-        up(&file->mutex);
+        mutex_unlock(&file->mutex);
         return ret;
 }
 
@@ -157,7 +157,7 @@ ssize_t ib_uverbs_query_device(struct ib_uverbs_file *file,
         memset(&resp, 0, sizeof resp);
 
         resp.fw_ver                    = attr.fw_ver;
-        resp.node_guid                 = attr.node_guid;
+        resp.node_guid                 = file->device->ib_dev->node_guid;
         resp.sys_image_guid            = attr.sys_image_guid;
         resp.max_mr_size               = attr.max_mr_size;
         resp.page_size_cap             = attr.page_size_cap;
@@ -290,7 +290,7 @@ ssize_t ib_uverbs_alloc_pd(struct ib_uverbs_file *file,
         pd->uobject = uobj;
         atomic_set(&pd->usecnt, 0);
 
-        down(&ib_uverbs_idr_mutex);
+        mutex_lock(&ib_uverbs_idr_mutex);
 
 retry:
         if (!idr_pre_get(&ib_uverbs_pd_idr, GFP_KERNEL)) {
@@ -314,11 +314,11 @@ retry:
                 goto err_idr;
         }
 
-        down(&file->mutex);
+        mutex_lock(&file->mutex);
         list_add_tail(&uobj->list, &file->ucontext->pd_list);
-        up(&file->mutex);
+        mutex_unlock(&file->mutex);
 
-        up(&ib_uverbs_idr_mutex);
+        mutex_unlock(&ib_uverbs_idr_mutex);
 
         return in_len;
 
@@ -326,7 +326,7 @@ err_idr:
         idr_remove(&ib_uverbs_pd_idr, uobj->id);
 
 err_up:
-        up(&ib_uverbs_idr_mutex);
+        mutex_unlock(&ib_uverbs_idr_mutex);
         ib_dealloc_pd(pd);
 
 err:
@@ -346,7 +346,7 @@ ssize_t ib_uverbs_dealloc_pd(struct ib_uverbs_file *file,
         if (copy_from_user(&cmd, buf, sizeof cmd))
                 return -EFAULT;
 
-        down(&ib_uverbs_idr_mutex);
+        mutex_lock(&ib_uverbs_idr_mutex);
 
         pd = idr_find(&ib_uverbs_pd_idr, cmd.pd_handle);
         if (!pd || pd->uobject->context != file->ucontext)
@@ -360,14 +360,14 @@ ssize_t ib_uverbs_dealloc_pd(struct ib_uverbs_file *file,
 
         idr_remove(&ib_uverbs_pd_idr, cmd.pd_handle);
 
-        down(&file->mutex);
+        mutex_lock(&file->mutex);
         list_del(&uobj->list);
-        up(&file->mutex);
+        mutex_unlock(&file->mutex);
 
         kfree(uobj);
 
 out:
-        up(&ib_uverbs_idr_mutex);
+        mutex_unlock(&ib_uverbs_idr_mutex);
 
         return ret ? ret : in_len;
 }
@@ -426,7 +426,7 @@ ssize_t ib_uverbs_reg_mr(struct ib_uverbs_file *file,
 
         obj->umem.virt_base = cmd.hca_va;
 
-        down(&ib_uverbs_idr_mutex);
+        mutex_lock(&ib_uverbs_idr_mutex);
 
         pd = idr_find(&ib_uverbs_pd_idr, cmd.pd_handle);
         if (!pd || pd->uobject->context != file->ucontext) {
@@ -476,11 +476,11 @@ retry:
                 goto err_idr;
         }
 
-        down(&file->mutex);
+        mutex_lock(&file->mutex);
         list_add_tail(&obj->uobject.list, &file->ucontext->mr_list);
-        up(&file->mutex);
+        mutex_unlock(&file->mutex);
 
-        up(&ib_uverbs_idr_mutex);
+        mutex_unlock(&ib_uverbs_idr_mutex);
 
         return in_len;
 
@@ -492,7 +492,7 @@ err_unreg:
         atomic_dec(&pd->usecnt);
 
 err_up:
-        up(&ib_uverbs_idr_mutex);
+        mutex_unlock(&ib_uverbs_idr_mutex);
 
         ib_umem_release(file->device->ib_dev, &obj->umem);
 
@@ -513,7 +513,7 @@ ssize_t ib_uverbs_dereg_mr(struct ib_uverbs_file *file,
         if (copy_from_user(&cmd, buf, sizeof cmd))
                 return -EFAULT;
 
-        down(&ib_uverbs_idr_mutex);
+        mutex_lock(&ib_uverbs_idr_mutex);
 
         mr = idr_find(&ib_uverbs_mr_idr, cmd.mr_handle);
         if (!mr || mr->uobject->context != file->ucontext)
@@ -527,15 +527,15 @@ ssize_t ib_uverbs_dereg_mr(struct ib_uverbs_file *file,
 
         idr_remove(&ib_uverbs_mr_idr, cmd.mr_handle);
 
-        down(&file->mutex);
+        mutex_lock(&file->mutex);
         list_del(&memobj->uobject.list);
-        up(&file->mutex);
+        mutex_unlock(&file->mutex);
 
         ib_umem_release(file->device->ib_dev, &memobj->umem);
         kfree(memobj);
 
 out:
-        up(&ib_uverbs_idr_mutex);
+        mutex_unlock(&ib_uverbs_idr_mutex);
 
         return ret ? ret : in_len;
 }
@@ -628,7 +628,7 @@ ssize_t ib_uverbs_create_cq(struct ib_uverbs_file *file,
         cq->cq_context    = ev_file;
         atomic_set(&cq->usecnt, 0);
 
-        down(&ib_uverbs_idr_mutex);
+        mutex_lock(&ib_uverbs_idr_mutex);
 
 retry:
         if (!idr_pre_get(&ib_uverbs_cq_idr, GFP_KERNEL)) {
@@ -653,11 +653,11 @@ retry:
                 goto err_idr;
         }
 
-        down(&file->mutex);
+        mutex_lock(&file->mutex);
         list_add_tail(&uobj->uobject.list, &file->ucontext->cq_list);
-        up(&file->mutex);
+        mutex_unlock(&file->mutex);
 
-        up(&ib_uverbs_idr_mutex);
+        mutex_unlock(&ib_uverbs_idr_mutex);
 
         return in_len;
 
@@ -665,7 +665,7 @@ err_idr:
         idr_remove(&ib_uverbs_cq_idr, uobj->uobject.id);
 
 err_up:
-        up(&ib_uverbs_idr_mutex);
+        mutex_unlock(&ib_uverbs_idr_mutex);
         ib_destroy_cq(cq);
 
 err:
@@ -701,7 +701,7 @@ ssize_t ib_uverbs_poll_cq(struct ib_uverbs_file *file,
                 goto out_wc;
         }
 
-        down(&ib_uverbs_idr_mutex);
+        mutex_lock(&ib_uverbs_idr_mutex);
         cq = idr_find(&ib_uverbs_cq_idr, cmd.cq_handle);
         if (!cq || cq->uobject->context != file->ucontext) {
                 ret = -EINVAL;
@@ -731,7 +731,7 @@ ssize_t ib_uverbs_poll_cq(struct ib_uverbs_file *file,
                 ret = -EFAULT;
 
 out:
-        up(&ib_uverbs_idr_mutex);
+        mutex_unlock(&ib_uverbs_idr_mutex);
         kfree(resp);
 
 out_wc:
@@ -750,14 +750,14 @@ ssize_t ib_uverbs_req_notify_cq(struct ib_uverbs_file *file,
         if (copy_from_user(&cmd, buf, sizeof cmd))
                 return -EFAULT;
 
-        down(&ib_uverbs_idr_mutex);
+        mutex_lock(&ib_uverbs_idr_mutex);
         cq = idr_find(&ib_uverbs_cq_idr, cmd.cq_handle);
         if (cq && cq->uobject->context == file->ucontext) {
                 ib_req_notify_cq(cq, cmd.solicited_only ?
                                         IB_CQ_SOLICITED : IB_CQ_NEXT_COMP);
                 ret = in_len;
         }
-        up(&ib_uverbs_idr_mutex);
+        mutex_unlock(&ib_uverbs_idr_mutex);
 
         return ret;
 }
@@ -779,7 +779,7 @@ ssize_t ib_uverbs_destroy_cq(struct ib_uverbs_file *file,
 
         memset(&resp, 0, sizeof resp);
 
-        down(&ib_uverbs_idr_mutex);
+        mutex_lock(&ib_uverbs_idr_mutex);
 
         cq = idr_find(&ib_uverbs_cq_idr, cmd.cq_handle);
         if (!cq || cq->uobject->context != file->ucontext)
@@ -795,9 +795,9 @@ ssize_t ib_uverbs_destroy_cq(struct ib_uverbs_file *file,
 
         idr_remove(&ib_uverbs_cq_idr, cmd.cq_handle);
 
-        down(&file->mutex);
+        mutex_lock(&file->mutex);
         list_del(&uobj->uobject.list);
-        up(&file->mutex);
+        mutex_unlock(&file->mutex);
 
         ib_uverbs_release_ucq(file, ev_file, uobj);
 
@@ -811,7 +811,7 @@ ssize_t ib_uverbs_destroy_cq(struct ib_uverbs_file *file,
                 ret = -EFAULT;
 
 out:
-        up(&ib_uverbs_idr_mutex);
+        mutex_unlock(&ib_uverbs_idr_mutex);
 
         return ret ? ret : in_len;
 }
@@ -845,7 +845,7 @@ ssize_t ib_uverbs_create_qp(struct ib_uverbs_file *file,
         if (!uobj)
                 return -ENOMEM;
 
-        down(&ib_uverbs_idr_mutex);
+        mutex_lock(&ib_uverbs_idr_mutex);
 
         pd  = idr_find(&ib_uverbs_pd_idr, cmd.pd_handle);
         scq = idr_find(&ib_uverbs_cq_idr, cmd.send_cq_handle);
@@ -930,11 +930,11 @@ retry:
                 goto err_idr;
         }
 
-        down(&file->mutex);
+        mutex_lock(&file->mutex);
         list_add_tail(&uobj->uevent.uobject.list, &file->ucontext->qp_list);
-        up(&file->mutex);
+        mutex_unlock(&file->mutex);
 
-        up(&ib_uverbs_idr_mutex);
+        mutex_unlock(&ib_uverbs_idr_mutex);
 
         return in_len;
 
@@ -950,7 +950,7 @@ err_destroy:
                 atomic_dec(&attr.srq->usecnt);
 
 err_up:
-        up(&ib_uverbs_idr_mutex);
+        mutex_unlock(&ib_uverbs_idr_mutex);
 
         kfree(uobj);
         return ret;
@@ -972,7 +972,7 @@ ssize_t ib_uverbs_modify_qp(struct ib_uverbs_file *file,
         if (!attr)
                 return -ENOMEM;
 
-        down(&ib_uverbs_idr_mutex);
+        mutex_lock(&ib_uverbs_idr_mutex);
 
         qp = idr_find(&ib_uverbs_qp_idr, cmd.qp_handle);
         if (!qp || qp->uobject->context != file->ucontext) {
@@ -1033,7 +1033,7 @@ ssize_t ib_uverbs_modify_qp(struct ib_uverbs_file *file,
         ret = in_len;
 
 out:
-        up(&ib_uverbs_idr_mutex);
+        mutex_unlock(&ib_uverbs_idr_mutex);
         kfree(attr);
 
         return ret;
@@ -1054,7 +1054,7 @@ ssize_t ib_uverbs_destroy_qp(struct ib_uverbs_file *file,
 
         memset(&resp, 0, sizeof resp);
 
-        down(&ib_uverbs_idr_mutex);
+        mutex_lock(&ib_uverbs_idr_mutex);
 
         qp = idr_find(&ib_uverbs_qp_idr, cmd.qp_handle);
         if (!qp || qp->uobject->context != file->ucontext)
@@ -1073,9 +1073,9 @@ ssize_t ib_uverbs_destroy_qp(struct ib_uverbs_file *file,
 
         idr_remove(&ib_uverbs_qp_idr, cmd.qp_handle);
 
-        down(&file->mutex);
+        mutex_lock(&file->mutex);
         list_del(&uobj->uevent.uobject.list);
-        up(&file->mutex);
+        mutex_unlock(&file->mutex);
 
         ib_uverbs_release_uevent(file, &uobj->uevent);
 
@@ -1088,7 +1088,7 @@ ssize_t ib_uverbs_destroy_qp(struct ib_uverbs_file *file,
                 ret = -EFAULT;
 
 out:
-        up(&ib_uverbs_idr_mutex);
+        mutex_unlock(&ib_uverbs_idr_mutex);
 
         return ret ? ret : in_len;
 }
@@ -1119,7 +1119,7 @@ ssize_t ib_uverbs_post_send(struct ib_uverbs_file *file,
         if (!user_wr)
                 return -ENOMEM;
 
-        down(&ib_uverbs_idr_mutex);
+        mutex_lock(&ib_uverbs_idr_mutex);
 
         qp = idr_find(&ib_uverbs_qp_idr, cmd.qp_handle);
         if (!qp || qp->uobject->context != file->ucontext)
@@ -1224,7 +1224,7 @@ ssize_t ib_uverbs_post_send(struct ib_uverbs_file *file,
                 ret = -EFAULT;
 
 out:
-        up(&ib_uverbs_idr_mutex);
+        mutex_unlock(&ib_uverbs_idr_mutex);
 
         while (wr) {
                 next = wr->next;
@@ -1341,7 +1341,7 @@ ssize_t ib_uverbs_post_recv(struct ib_uverbs_file *file,
         if (IS_ERR(wr))
                 return PTR_ERR(wr);
 
-        down(&ib_uverbs_idr_mutex);
+        mutex_lock(&ib_uverbs_idr_mutex);
 
         qp = idr_find(&ib_uverbs_qp_idr, cmd.qp_handle);
         if (!qp || qp->uobject->context != file->ucontext)
@@ -1362,7 +1362,7 @@ ssize_t ib_uverbs_post_recv(struct ib_uverbs_file *file,
                 ret = -EFAULT;
 
 out:
-        up(&ib_uverbs_idr_mutex);
+        mutex_unlock(&ib_uverbs_idr_mutex);
 
         while (wr) {
                 next = wr->next;
@@ -1392,7 +1392,7 @@ ssize_t ib_uverbs_post_srq_recv(struct ib_uverbs_file *file,
         if (IS_ERR(wr))
                 return PTR_ERR(wr);
 
-        down(&ib_uverbs_idr_mutex);
+        mutex_lock(&ib_uverbs_idr_mutex);
 
         srq = idr_find(&ib_uverbs_srq_idr, cmd.srq_handle);
         if (!srq || srq->uobject->context != file->ucontext)
@@ -1413,7 +1413,7 @@ ssize_t ib_uverbs_post_srq_recv(struct ib_uverbs_file *file,
                 ret = -EFAULT;
 
 out:
-        up(&ib_uverbs_idr_mutex);
+        mutex_unlock(&ib_uverbs_idr_mutex);
 
         while (wr) {
                 next = wr->next;
@@ -1446,7 +1446,7 @@ ssize_t ib_uverbs_create_ah(struct ib_uverbs_file *file,
         if (!uobj)
                 return -ENOMEM;
 
-        down(&ib_uverbs_idr_mutex);
+        mutex_lock(&ib_uverbs_idr_mutex);
 
         pd = idr_find(&ib_uverbs_pd_idr, cmd.pd_handle);
         if (!pd || pd->uobject->context != file->ucontext) {
@@ -1498,11 +1498,11 @@ retry:
                 goto err_idr;
         }
 
-        down(&file->mutex);
+        mutex_lock(&file->mutex);
         list_add_tail(&uobj->list, &file->ucontext->ah_list);
-        up(&file->mutex);
+        mutex_unlock(&file->mutex);
 
-        up(&ib_uverbs_idr_mutex);
+        mutex_unlock(&ib_uverbs_idr_mutex);
 
         return in_len;
 
@@ -1513,7 +1513,7 @@ err_destroy:
         ib_destroy_ah(ah);
 
 err_up:
-        up(&ib_uverbs_idr_mutex);
+        mutex_unlock(&ib_uverbs_idr_mutex);
 
         kfree(uobj);
         return ret;
@@ -1530,7 +1530,7 @@ ssize_t ib_uverbs_destroy_ah(struct ib_uverbs_file *file,
         if (copy_from_user(&cmd, buf, sizeof cmd))
                 return -EFAULT;
 
-        down(&ib_uverbs_idr_mutex);
+        mutex_lock(&ib_uverbs_idr_mutex);
 
         ah = idr_find(&ib_uverbs_ah_idr, cmd.ah_handle);
         if (!ah || ah->uobject->context != file->ucontext)
@@ -1544,14 +1544,14 @@ ssize_t ib_uverbs_destroy_ah(struct ib_uverbs_file *file,
 
         idr_remove(&ib_uverbs_ah_idr, cmd.ah_handle);
 
-        down(&file->mutex);
+        mutex_lock(&file->mutex);
         list_del(&uobj->list);
-        up(&file->mutex);
+        mutex_unlock(&file->mutex);
 
         kfree(uobj);
 
 out:
-        up(&ib_uverbs_idr_mutex);
+        mutex_unlock(&ib_uverbs_idr_mutex);
 
         return ret ? ret : in_len;
 }
@@ -1569,7 +1569,7 @@ ssize_t ib_uverbs_attach_mcast(struct ib_uverbs_file *file,
         if (copy_from_user(&cmd, buf, sizeof cmd))
                 return -EFAULT;
 
-        down(&ib_uverbs_idr_mutex);
+        mutex_lock(&ib_uverbs_idr_mutex);
 
         qp = idr_find(&ib_uverbs_qp_idr, cmd.qp_handle);
         if (!qp || qp->uobject->context != file->ucontext)
@@ -1602,7 +1602,7 @@ ssize_t ib_uverbs_attach_mcast(struct ib_uverbs_file *file,
                 kfree(mcast);
 
 out:
-        up(&ib_uverbs_idr_mutex);
+        mutex_unlock(&ib_uverbs_idr_mutex);
 
         return ret ? ret : in_len;
 }
@@ -1620,7 +1620,7 @@ ssize_t ib_uverbs_detach_mcast(struct ib_uverbs_file *file,
         if (copy_from_user(&cmd, buf, sizeof cmd))
                 return -EFAULT;
 
-        down(&ib_uverbs_idr_mutex);
+        mutex_lock(&ib_uverbs_idr_mutex);
 
         qp = idr_find(&ib_uverbs_qp_idr, cmd.qp_handle);
         if (!qp || qp->uobject->context != file->ucontext)
@@ -1641,7 +1641,7 @@ ssize_t ib_uverbs_detach_mcast(struct ib_uverbs_file *file,
                 }
 
 out:
-        up(&ib_uverbs_idr_mutex);
+        mutex_unlock(&ib_uverbs_idr_mutex);
 
         return ret ? ret : in_len;
 }
@@ -1673,7 +1673,7 @@ ssize_t ib_uverbs_create_srq(struct ib_uverbs_file *file,
         if (!uobj)
                 return -ENOMEM;
 
-        down(&ib_uverbs_idr_mutex);
+        mutex_lock(&ib_uverbs_idr_mutex);
 
         pd  = idr_find(&ib_uverbs_pd_idr, cmd.pd_handle);
 
@@ -1730,11 +1730,11 @@ retry:
                 goto err_idr;
         }
 
-        down(&file->mutex);
+        mutex_lock(&file->mutex);
         list_add_tail(&uobj->uobject.list, &file->ucontext->srq_list);
-        up(&file->mutex);
+        mutex_unlock(&file->mutex);
 
-        up(&ib_uverbs_idr_mutex);
+        mutex_unlock(&ib_uverbs_idr_mutex);
 
         return in_len;
 
@@ -1746,7 +1746,7 @@ err_destroy:
         atomic_dec(&pd->usecnt);
 
 err_up:
-        up(&ib_uverbs_idr_mutex);
+        mutex_unlock(&ib_uverbs_idr_mutex);
 
         kfree(uobj);
         return ret;
@@ -1764,7 +1764,7 @@ ssize_t ib_uverbs_modify_srq(struct ib_uverbs_file *file,
         if (copy_from_user(&cmd, buf, sizeof cmd))
                 return -EFAULT;
 
-        down(&ib_uverbs_idr_mutex);
+        mutex_lock(&ib_uverbs_idr_mutex);
 
         srq = idr_find(&ib_uverbs_srq_idr, cmd.srq_handle);
         if (!srq || srq->uobject->context != file->ucontext) {
@@ -1778,7 +1778,7 @@ ssize_t ib_uverbs_modify_srq(struct ib_uverbs_file *file,
         ret = ib_modify_srq(srq, &attr, cmd.attr_mask);
 
 out:
-        up(&ib_uverbs_idr_mutex);
+        mutex_unlock(&ib_uverbs_idr_mutex);
 
         return ret ? ret : in_len;
 }
@@ -1796,7 +1796,7 @@ ssize_t ib_uverbs_destroy_srq(struct ib_uverbs_file *file,
         if (copy_from_user(&cmd, buf, sizeof cmd))
                 return -EFAULT;
 
-        down(&ib_uverbs_idr_mutex);
+        mutex_lock(&ib_uverbs_idr_mutex);
 
         memset(&resp, 0, sizeof resp);
 
@@ -1812,9 +1812,9 @@ ssize_t ib_uverbs_destroy_srq(struct ib_uverbs_file *file,
 
         idr_remove(&ib_uverbs_srq_idr, cmd.srq_handle);
 
-        down(&file->mutex);
+        mutex_lock(&file->mutex);
         list_del(&uobj->uobject.list);
-        up(&file->mutex);
+        mutex_unlock(&file->mutex);
 
         ib_uverbs_release_uevent(file, uobj);
 
@@ -1827,7 +1827,7 @@ ssize_t ib_uverbs_destroy_srq(struct ib_uverbs_file *file,
                 ret = -EFAULT;
 
 out:
-        up(&ib_uverbs_idr_mutex);
+        mutex_unlock(&ib_uverbs_idr_mutex);
 
         return ret ? ret : in_len;
 }
diff --git a/drivers/infiniband/core/uverbs_main.c b/drivers/infiniband/core/uverbs_main.c
index 81737bd6faea..96ea79b63df7 100644
--- a/drivers/infiniband/core/uverbs_main.c
+++ b/drivers/infiniband/core/uverbs_main.c
@@ -66,7 +66,7 @@ enum {
 
 static struct class *uverbs_class;
 
-DECLARE_MUTEX(ib_uverbs_idr_mutex);
+DEFINE_MUTEX(ib_uverbs_idr_mutex);
 DEFINE_IDR(ib_uverbs_pd_idr);
 DEFINE_IDR(ib_uverbs_mr_idr);
 DEFINE_IDR(ib_uverbs_mw_idr);
@@ -180,7 +180,7 @@ static int ib_uverbs_cleanup_ucontext(struct ib_uverbs_file *file,
         if (!context)
                 return 0;
 
-        down(&ib_uverbs_idr_mutex);
+        mutex_lock(&ib_uverbs_idr_mutex);
 
         list_for_each_entry_safe(uobj, tmp, &context->ah_list, list) {
                 struct ib_ah *ah = idr_find(&ib_uverbs_ah_idr, uobj->id);
@@ -250,7 +250,7 @@ static int ib_uverbs_cleanup_ucontext(struct ib_uverbs_file *file,
                 kfree(uobj);
         }
 
-        up(&ib_uverbs_idr_mutex);
+        mutex_unlock(&ib_uverbs_idr_mutex);
 
         return context->device->dealloc_ucontext(context);
 }
@@ -653,7 +653,7 @@ static int ib_uverbs_open(struct inode *inode, struct file *filp)
         file->ucontext   = NULL;
         file->async_file = NULL;
         kref_init(&file->ref);
-        init_MUTEX(&file->mutex);
+        mutex_init(&file->mutex);
 
         filp->private_data = file;
 
diff --git a/drivers/infiniband/hw/mthca/mthca_av.c b/drivers/infiniband/hw/mthca/mthca_av.c
index 22fdc446f25c..a14eed08a0fc 100644
--- a/drivers/infiniband/hw/mthca/mthca_av.c
+++ b/drivers/infiniband/hw/mthca/mthca_av.c
@@ -163,6 +163,11 @@ int mthca_destroy_ah(struct mthca_dev *dev, struct mthca_ah *ah)
         return 0;
 }
 
+int mthca_ah_grh_present(struct mthca_ah *ah)
+{
+        return !!(ah->av->g_slid & 0x80);
+}
+
 int mthca_read_ah(struct mthca_dev *dev, struct mthca_ah *ah,
                   struct ib_ud_header *header)
 {
@@ -172,8 +177,7 @@ int mthca_read_ah(struct mthca_dev *dev, struct mthca_ah *ah,
         header->lrh.service_level   = be32_to_cpu(ah->av->sl_tclass_flowlabel) >> 28;
         header->lrh.destination_lid = ah->av->dlid;
         header->lrh.source_lid      = cpu_to_be16(ah->av->g_slid & 0x7f);
-        if (ah->av->g_slid & 0x80) {
-                header->grh_present = 1;
+        if (mthca_ah_grh_present(ah)) {
                 header->grh.traffic_class =
                         (be32_to_cpu(ah->av->sl_tclass_flowlabel) >> 20) & 0xff;
                 header->grh.flow_label    =
@@ -184,8 +188,6 @@ int mthca_read_ah(struct mthca_dev *dev, struct mthca_ah *ah,
                                   &header->grh.source_gid);
                 memcpy(header->grh.destination_gid.raw,
                        ah->av->dgid, 16);
-        } else {
-                header->grh_present = 0;
         }
 
         return 0;
diff --git a/drivers/infiniband/hw/mthca/mthca_cmd.c b/drivers/infiniband/hw/mthca/mthca_cmd.c
index 22ac72bc20c3..be1791be627b 100644
--- a/drivers/infiniband/hw/mthca/mthca_cmd.c
+++ b/drivers/infiniband/hw/mthca/mthca_cmd.c
@@ -606,7 +606,7 @@ static int mthca_map_cmd(struct mthca_dev *dev, u16 op, struct mthca_icm *icm,
                         err = -EINVAL;
                         goto out;
                 }
-                for (i = 0; i < mthca_icm_size(&iter) / (1 << lg); ++i) {
+                for (i = 0; i < mthca_icm_size(&iter) >> lg; ++i) {
                         if (virt != -1) {
                                 pages[nent * 2] = cpu_to_be64(virt);
                                 virt += 1 << lg;
@@ -727,8 +727,8 @@ int mthca_QUERY_FW(struct mthca_dev *dev, u8 *status)
                  * system pages needed.
                  */
                 dev->fw.arbel.fw_pages =
-                        (dev->fw.arbel.fw_pages + (1 << (PAGE_SHIFT - 12)) - 1) >>
-                        (PAGE_SHIFT - 12);
+                        ALIGN(dev->fw.arbel.fw_pages, PAGE_SIZE >> 12) >>
+                                (PAGE_SHIFT - 12);
 
                 mthca_dbg(dev, "Clear int @ %llx, EQ arm @ %llx, EQ set CI @ %llx\n",
                           (unsigned long long) dev->fw.arbel.clr_int_base,
@@ -1445,6 +1445,7 @@ int mthca_SET_ICM_SIZE(struct mthca_dev *dev, u64 icm_size, u64 *aux_pages,
          * pages needed.
          */
         *aux_pages = (*aux_pages + (1 << (PAGE_SHIFT - 12)) - 1) >> (PAGE_SHIFT - 12);
+        *aux_pages = ALIGN(*aux_pages, PAGE_SIZE >> 12) >> (PAGE_SHIFT - 12);
 
         return 0;
 }
diff --git a/drivers/infiniband/hw/mthca/mthca_dev.h b/drivers/infiniband/hw/mthca/mthca_dev.h
index 795b379260bf..a104ab041ea3 100644
--- a/drivers/infiniband/hw/mthca/mthca_dev.h
+++ b/drivers/infiniband/hw/mthca/mthca_dev.h
@@ -520,6 +520,7 @@ int mthca_create_ah(struct mthca_dev *dev,
 int mthca_destroy_ah(struct mthca_dev *dev, struct mthca_ah *ah);
 int mthca_read_ah(struct mthca_dev *dev, struct mthca_ah *ah,
                   struct ib_ud_header *header);
+int mthca_ah_grh_present(struct mthca_ah *ah);
 
 int mthca_multicast_attach(struct ib_qp *ibqp, union ib_gid *gid, u16 lid);
 int mthca_multicast_detach(struct ib_qp *ibqp, union ib_gid *gid, u16 lid);
diff --git a/drivers/infiniband/hw/mthca/mthca_eq.c b/drivers/infiniband/hw/mthca/mthca_eq.c
index e8a948f087c0..2eabb27804cd 100644
--- a/drivers/infiniband/hw/mthca/mthca_eq.c
+++ b/drivers/infiniband/hw/mthca/mthca_eq.c
@@ -45,6 +45,7 @@
 enum {
         MTHCA_NUM_ASYNC_EQE = 0x80,
         MTHCA_NUM_CMD_EQE   = 0x80,
+        MTHCA_NUM_SPARE_EQE = 0x80,
         MTHCA_EQ_ENTRY_SIZE = 0x20
 };
 
@@ -277,11 +278,10 @@ static int mthca_eq_int(struct mthca_dev *dev, struct mthca_eq *eq)
 {
         struct mthca_eqe *eqe;
         int disarm_cqn;
-        int  eqes_found = 0;
+        int eqes_found = 0;
+        int set_ci = 0;
 
         while ((eqe = next_eqe_sw(eq))) {
-                int set_ci = 0;
-
                 /*
                  * Make sure we read EQ entry contents after we've
                  * checked the ownership bit.
@@ -345,12 +345,6 @@ static int mthca_eq_int(struct mthca_dev *dev, struct mthca_eq *eq)
                                         be16_to_cpu(eqe->event.cmd.token),
                                         eqe->event.cmd.status,
                                         be64_to_cpu(eqe->event.cmd.out_param));
-                        /*
-                         * cmd_event() may add more commands.
-                         * The card will think the queue has overflowed if
-                         * we don't tell it we've been processing events.
-                         */
-                        set_ci = 1;
                         break;
 
                 case MTHCA_EVENT_TYPE_PORT_CHANGE:
@@ -385,8 +379,16 @@ static int mthca_eq_int(struct mthca_dev *dev, struct mthca_eq *eq)
                 set_eqe_hw(eqe);
                 ++eq->cons_index;
                 eqes_found = 1;
+                ++set_ci;
 
-                if (unlikely(set_ci)) {
+                /*
+                 * The HCA will think the queue has overflowed if we
+                 * don't tell it we've been processing events.  We
+                 * create our EQs with MTHCA_NUM_SPARE_EQE extra
+                 * entries, so we must update our consumer index at
+                 * least that often.
+                 */
+                if (unlikely(set_ci >= MTHCA_NUM_SPARE_EQE)) {
                         /*
                          * Conditional on hca_type is OK here because
                          * this is a rare case, not the fast path.
@@ -862,19 +864,19 @@ int __devinit mthca_init_eq_table(struct mthca_dev *dev)
         intr = (dev->mthca_flags & MTHCA_FLAG_MSI) ?
                 128 : dev->eq_table.inta_pin;
 
-        err = mthca_create_eq(dev, dev->limits.num_cqs,
+        err = mthca_create_eq(dev, dev->limits.num_cqs + MTHCA_NUM_SPARE_EQE,
                               (dev->mthca_flags & MTHCA_FLAG_MSI_X) ? 128 : intr,
                               &dev->eq_table.eq[MTHCA_EQ_COMP]);
         if (err)
                 goto err_out_unmap;
 
-        err = mthca_create_eq(dev, MTHCA_NUM_ASYNC_EQE,
+        err = mthca_create_eq(dev, MTHCA_NUM_ASYNC_EQE + MTHCA_NUM_SPARE_EQE,
                               (dev->mthca_flags & MTHCA_FLAG_MSI_X) ? 129 : intr,
                               &dev->eq_table.eq[MTHCA_EQ_ASYNC]);
         if (err)
                 goto err_out_comp;
 
-        err = mthca_create_eq(dev, MTHCA_NUM_CMD_EQE,
+        err = mthca_create_eq(dev, MTHCA_NUM_CMD_EQE + MTHCA_NUM_SPARE_EQE,
                               (dev->mthca_flags & MTHCA_FLAG_MSI_X) ? 130 : intr,
                               &dev->eq_table.eq[MTHCA_EQ_CMD]);
         if (err)
diff --git a/drivers/infiniband/hw/mthca/mthca_provider.c b/drivers/infiniband/hw/mthca/mthca_provider.c
index 4cc7e2846df1..484a7e6b7f8c 100644
--- a/drivers/infiniband/hw/mthca/mthca_provider.c
+++ b/drivers/infiniband/hw/mthca/mthca_provider.c
@@ -33,7 +33,7 @@
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  *
- * $Id: mthca_provider.c 1397 2004-12-28 05:09:00Z roland $
+ * $Id: mthca_provider.c 4859 2006-01-09 21:55:10Z roland $
  */
 
 #include <rdma/ib_smi.h>
@@ -45,6 +45,14 @@
 #include "mthca_user.h"
 #include "mthca_memfree.h"
 
+static void init_query_mad(struct ib_smp *mad)
+{
+        mad->base_version  = 1;
+        mad->mgmt_class    = IB_MGMT_CLASS_SUBN_LID_ROUTED;
+        mad->class_version = 1;
+        mad->method        = IB_MGMT_METHOD_GET;
+}
+
 static int mthca_query_device(struct ib_device *ibdev,
                               struct ib_device_attr *props)
 {
@@ -55,7 +63,7 @@ static int mthca_query_device(struct ib_device *ibdev,
 
         u8 status;
 
-        in_mad  = kmalloc(sizeof *in_mad, GFP_KERNEL);
+        in_mad  = kzalloc(sizeof *in_mad, GFP_KERNEL);
         out_mad = kmalloc(sizeof *out_mad, GFP_KERNEL);
         if (!in_mad || !out_mad)
                 goto out;
@@ -64,12 +72,8 @@ static int mthca_query_device(struct ib_device *ibdev,
 
         props->fw_ver              = mdev->fw_ver;
 
-        memset(in_mad, 0, sizeof *in_mad);
-        in_mad->base_version       = 1;
-        in_mad->mgmt_class         = IB_MGMT_CLASS_SUBN_LID_ROUTED;
-        in_mad->class_version      = 1;
-        in_mad->method             = IB_MGMT_METHOD_GET;
-        in_mad->attr_id            = IB_SMP_ATTR_NODE_INFO;
+        init_query_mad(in_mad);
+        in_mad->attr_id = IB_SMP_ATTR_NODE_INFO;
 
         err = mthca_MAD_IFC(mdev, 1, 1,
                             1, NULL, NULL, in_mad, out_mad,
@@ -87,7 +91,6 @@ static int mthca_query_device(struct ib_device *ibdev,
         props->vendor_part_id      = be16_to_cpup((__be16 *) (out_mad->data + 30));
         props->hw_ver              = be32_to_cpup((__be32 *) (out_mad->data + 32));
         memcpy(&props->sys_image_guid, out_mad->data +  4, 8);
-        memcpy(&props->node_guid,      out_mad->data + 12, 8);
 
         props->max_mr_size         = ~0ull;
         props->page_size_cap       = mdev->limits.page_size_cap;
@@ -128,20 +131,16 @@ static int mthca_query_port(struct ib_device *ibdev,
         int err = -ENOMEM;
         u8 status;
 
-        in_mad  = kmalloc(sizeof *in_mad, GFP_KERNEL);
+        in_mad  = kzalloc(sizeof *in_mad, GFP_KERNEL);
         out_mad = kmalloc(sizeof *out_mad, GFP_KERNEL);
         if (!in_mad || !out_mad)
                 goto out;
 
         memset(props, 0, sizeof *props);
 
-        memset(in_mad, 0, sizeof *in_mad);
-        in_mad->base_version       = 1;
-        in_mad->mgmt_class         = IB_MGMT_CLASS_SUBN_LID_ROUTED;
-        in_mad->class_version      = 1;
-        in_mad->method             = IB_MGMT_METHOD_GET;
-        in_mad->attr_id            = IB_SMP_ATTR_PORT_INFO;
-        in_mad->attr_mod           = cpu_to_be32(port);
+        init_query_mad(in_mad);
+        in_mad->attr_id  = IB_SMP_ATTR_PORT_INFO;
+        in_mad->attr_mod = cpu_to_be32(port);
 
         err = mthca_MAD_IFC(to_mdev(ibdev), 1, 1,
                             port, NULL, NULL, in_mad, out_mad,
@@ -220,18 +219,14 @@ static int mthca_query_pkey(struct ib_device *ibdev,
         int err = -ENOMEM;
         u8 status;
 
-        in_mad  = kmalloc(sizeof *in_mad, GFP_KERNEL);
+        in_mad  = kzalloc(sizeof *in_mad, GFP_KERNEL);
         out_mad = kmalloc(sizeof *out_mad, GFP_KERNEL);
         if (!in_mad || !out_mad)
                 goto out;
 
-        memset(in_mad, 0, sizeof *in_mad);
-        in_mad->base_version       = 1;
-        in_mad->mgmt_class         = IB_MGMT_CLASS_SUBN_LID_ROUTED;
-        in_mad->class_version      = 1;
-        in_mad->method             = IB_MGMT_METHOD_GET;
-        in_mad->attr_id            = IB_SMP_ATTR_PKEY_TABLE;
-        in_mad->attr_mod           = cpu_to_be32(index / 32);
+        init_query_mad(in_mad);
+        in_mad->attr_id  = IB_SMP_ATTR_PKEY_TABLE;
+        in_mad->attr_mod = cpu_to_be32(index / 32);
 
         err = mthca_MAD_IFC(to_mdev(ibdev), 1, 1,
                             port, NULL, NULL, in_mad, out_mad,
@@ -259,18 +254,14 @@ static int mthca_query_gid(struct ib_device *ibdev, u8 port,
         int err = -ENOMEM;
         u8 status;
 
-        in_mad  = kmalloc(sizeof *in_mad, GFP_KERNEL);
+        in_mad  = kzalloc(sizeof *in_mad, GFP_KERNEL);
         out_mad = kmalloc(sizeof *out_mad, GFP_KERNEL);
         if (!in_mad || !out_mad)
                 goto out;
 
-        memset(in_mad, 0, sizeof *in_mad);
-        in_mad->base_version       = 1;
-        in_mad->mgmt_class         = IB_MGMT_CLASS_SUBN_LID_ROUTED;
-        in_mad->class_version      = 1;
-        in_mad->method             = IB_MGMT_METHOD_GET;
-        in_mad->attr_id            = IB_SMP_ATTR_PORT_INFO;
-        in_mad->attr_mod           = cpu_to_be32(port);
+        init_query_mad(in_mad);
+        in_mad->attr_id  = IB_SMP_ATTR_PORT_INFO;
+        in_mad->attr_mod = cpu_to_be32(port);
 
         err = mthca_MAD_IFC(to_mdev(ibdev), 1, 1,
                             port, NULL, NULL, in_mad, out_mad,
@@ -284,13 +275,9 @@ static int mthca_query_gid(struct ib_device *ibdev, u8 port,
 
         memcpy(gid->raw, out_mad->data + 8, 8);
 
-        memset(in_mad, 0, sizeof *in_mad);
-        in_mad->base_version       = 1;
-        in_mad->mgmt_class         = IB_MGMT_CLASS_SUBN_LID_ROUTED;
-        in_mad->class_version      = 1;
-        in_mad->method             = IB_MGMT_METHOD_GET;
-        in_mad->attr_id            = IB_SMP_ATTR_GUID_INFO;
-        in_mad->attr_mod           = cpu_to_be32(index / 8);
+        init_query_mad(in_mad);
+        in_mad->attr_id  = IB_SMP_ATTR_GUID_INFO;
+        in_mad->attr_mod = cpu_to_be32(index / 8);
 
         err = mthca_MAD_IFC(to_mdev(ibdev), 1, 1,
                             port, NULL, NULL, in_mad, out_mad,
@@ -458,8 +445,10 @@ static struct ib_srq *mthca_create_srq(struct ib_pd *pd,
         if (pd->uobject) {
                 context = to_mucontext(pd->uobject->context);
 
-                if (ib_copy_from_udata(&ucmd, udata, sizeof ucmd))
-                        return ERR_PTR(-EFAULT);
+                if (ib_copy_from_udata(&ucmd, udata, sizeof ucmd)) {
+                        err = -EFAULT;
+                        goto err_free;
+                }
 
                 err = mthca_map_user_db(to_mdev(pd->device), &context->uar,
                                         context->db_tab, ucmd.db_index,
@@ -535,8 +524,10 @@ static struct ib_qp *mthca_create_qp(struct ib_pd *pd,
                 if (pd->uobject) {
                         context = to_mucontext(pd->uobject->context);
 
-                        if (ib_copy_from_udata(&ucmd, udata, sizeof ucmd))
+                        if (ib_copy_from_udata(&ucmd, udata, sizeof ucmd)) {
+                                kfree(qp);
                                 return ERR_PTR(-EFAULT);
+                        }
 
                         err = mthca_map_user_db(to_mdev(pd->device), &context->uar,
                                                 context->db_tab,
@@ -783,24 +774,20 @@ static struct ib_mr *mthca_reg_phys_mr(struct ib_pd       *pd,
         if ((*iova_start & ~PAGE_MASK) != (buffer_list[0].addr & ~PAGE_MASK))
                 return ERR_PTR(-EINVAL);
 
-        if (num_phys_buf > 1 &&
-            ((buffer_list[0].addr + buffer_list[0].size) & ~PAGE_MASK))
-                return ERR_PTR(-EINVAL);
-
         mask = 0;
         total_size = 0;
         for (i = 0; i < num_phys_buf; ++i) {
-                if (i != 0 && buffer_list[i].addr & ~PAGE_MASK)
-                        return ERR_PTR(-EINVAL);
-                if (i != 0 && i != num_phys_buf - 1 &&
-                    (buffer_list[i].size & ~PAGE_MASK))
-                        return ERR_PTR(-EINVAL);
+                if (i != 0)
+                        mask |= buffer_list[i].addr;
+                if (i != num_phys_buf - 1)
+                        mask |= buffer_list[i].addr + buffer_list[i].size;
 
                 total_size += buffer_list[i].size;
-                if (i > 0)
-                        mask |= buffer_list[i].addr;
         }
 
+        if (mask & ~PAGE_MASK)
+                return ERR_PTR(-EINVAL);
+
         /* Find largest page shift we can use to cover buffers */
         for (shift = PAGE_SHIFT; shift < 31; ++shift)
                 if (num_phys_buf > 1) {
@@ -1070,11 +1057,48 @@ static struct class_device_attribute *mthca_class_attributes[] = {
         &class_device_attr_board_id
 };
 
+static int mthca_init_node_data(struct mthca_dev *dev)
+{
+        struct ib_smp *in_mad  = NULL;
+        struct ib_smp *out_mad = NULL;
+        int err = -ENOMEM;
+        u8 status;
+
+        in_mad  = kzalloc(sizeof *in_mad, GFP_KERNEL);
+        out_mad = kmalloc(sizeof *out_mad, GFP_KERNEL);
+        if (!in_mad || !out_mad)
+                goto out;
+
+        init_query_mad(in_mad);
+        in_mad->attr_id = IB_SMP_ATTR_NODE_INFO;
+
+        err = mthca_MAD_IFC(dev, 1, 1,
+                            1, NULL, NULL, in_mad, out_mad,
+                            &status);
+        if (err)
+                goto out;
+        if (status) {
+                err = -EINVAL;
+                goto out;
+        }
+
+        memcpy(&dev->ib_dev.node_guid, out_mad->data + 12, 8);
+
+out:
+        kfree(in_mad);
+        kfree(out_mad);
+        return err;
+}
+
 int mthca_register_device(struct mthca_dev *dev)
 {
         int ret;
         int i;
 
+        ret = mthca_init_node_data(dev);
+        if (ret)
+                return ret;
+
         strlcpy(dev->ib_dev.name, "mthca%d", IB_DEVICE_NAME_MAX);
         dev->ib_dev.owner                = THIS_MODULE;
 
diff --git a/drivers/infiniband/hw/mthca/mthca_qp.c b/drivers/infiniband/hw/mthca/mthca_qp.c
index 564b6d51c394..fba608ed7df2 100644
--- a/drivers/infiniband/hw/mthca/mthca_qp.c
+++ b/drivers/infiniband/hw/mthca/mthca_qp.c
@@ -1434,7 +1434,7 @@ static int build_mlx_header(struct mthca_dev *dev, struct mthca_sqp *sqp,
         u16 pkey;
 
         ib_ud_header_init(256, /* assume a MAD */
-                          sqp->ud_header.grh_present,
+                          mthca_ah_grh_present(to_mah(wr->wr.ud.ah)),
                           &sqp->ud_header);
 
         err = mthca_read_ah(dev, to_mah(wr->wr.ud.ah), &sqp->ud_header);
diff --git a/drivers/infiniband/ulp/ipoib/ipoib.h b/drivers/infiniband/ulp/ipoib/ipoib.h
index 9923a15a9996..e0a5412b7e68 100644
--- a/drivers/infiniband/ulp/ipoib/ipoib.h
+++ b/drivers/infiniband/ulp/ipoib/ipoib.h
@@ -45,11 +45,11 @@
 #include <linux/config.h>
 #include <linux/kref.h>
 #include <linux/if_infiniband.h>
+#include <linux/mutex.h>
 
 #include <net/neighbour.h>
 
 #include <asm/atomic.h>
-#include <asm/semaphore.h>
 
 #include <rdma/ib_verbs.h>
 #include <rdma/ib_pack.h>
@@ -123,8 +123,8 @@ struct ipoib_dev_priv {
 
         unsigned long flags;
 
-        struct semaphore mcast_mutex;
-        struct semaphore vlan_mutex;
+        struct mutex mcast_mutex;
+        struct mutex vlan_mutex;
 
         struct rb_root  path_tree;
         struct list_head path_list;
diff --git a/drivers/infiniband/ulp/ipoib/ipoib_ib.c b/drivers/infiniband/ulp/ipoib/ipoib_ib.c
index 23885801b6d2..86bcdd72a107 100644
--- a/drivers/infiniband/ulp/ipoib/ipoib_ib.c
+++ b/drivers/infiniband/ulp/ipoib/ipoib_ib.c
@@ -52,7 +52,7 @@ MODULE_PARM_DESC(data_debug_level,
 
 #define IPOIB_OP_RECV   (1ul << 31)
 
-static DECLARE_MUTEX(pkey_sem);
+static DEFINE_MUTEX(pkey_mutex);
 
 struct ipoib_ah *ipoib_create_ah(struct net_device *dev,
                                  struct ib_pd *pd, struct ib_ah_attr *attr)
@@ -445,25 +445,16 @@ int ipoib_ib_dev_down(struct net_device *dev)
 
         /* Shutdown the P_Key thread if still active */
         if (!test_bit(IPOIB_PKEY_ASSIGNED, &priv->flags)) {
-                down(&pkey_sem);
+                mutex_lock(&pkey_mutex);
                 set_bit(IPOIB_PKEY_STOP, &priv->flags);
                 cancel_delayed_work(&priv->pkey_task);
-                up(&pkey_sem);
+                mutex_unlock(&pkey_mutex);
                 flush_workqueue(ipoib_workqueue);
         }
 
         ipoib_mcast_stop_thread(dev, 1);
-
-        /*
-         * Flush the multicast groups first so we stop any multicast joins. The
-         * completion thread may have already died and we may deadlock waiting
-         * for the completion thread to finish some multicast joins.
-         */
         ipoib_mcast_dev_flush(dev);
 
-        /* Delete broadcast and local addresses since they will be recreated */
-        ipoib_mcast_dev_down(dev);
-
         ipoib_flush_paths(dev);
 
         return 0;
@@ -608,13 +599,13 @@ void ipoib_ib_dev_flush(void *_dev)
         if (test_bit(IPOIB_FLAG_ADMIN_UP, &priv->flags))
                 ipoib_ib_dev_up(dev);
 
-        down(&priv->vlan_mutex);
+        mutex_lock(&priv->vlan_mutex);
 
         /* Flush any child interfaces too */
         list_for_each_entry(cpriv, &priv->child_intfs, list)
                 ipoib_ib_dev_flush(&cpriv->dev);
 
-        up(&priv->vlan_mutex);
+        mutex_unlock(&priv->vlan_mutex);
 }
 
 void ipoib_ib_dev_cleanup(struct net_device *dev)
@@ -624,9 +615,7 @@ void ipoib_ib_dev_cleanup(struct net_device *dev)
         ipoib_dbg(priv, "cleaning up ib_dev\n");
 
         ipoib_mcast_stop_thread(dev, 1);
-
-        /* Delete the broadcast address and the local address */
-        ipoib_mcast_dev_down(dev);
+        ipoib_mcast_dev_flush(dev);
 
         ipoib_transport_dev_cleanup(dev);
 }
@@ -662,12 +651,12 @@ void ipoib_pkey_poll(void *dev_ptr)
         if (test_bit(IPOIB_PKEY_ASSIGNED, &priv->flags))
                 ipoib_open(dev);
         else {
-                down(&pkey_sem);
+                mutex_lock(&pkey_mutex);
                 if (!test_bit(IPOIB_PKEY_STOP, &priv->flags))
                         queue_delayed_work(ipoib_workqueue,
                                            &priv->pkey_task,
                                            HZ);
-                up(&pkey_sem);
+                mutex_unlock(&pkey_mutex);
         }
 }
 
@@ -681,12 +670,12 @@ int ipoib_pkey_dev_delay_open(struct net_device *dev)
 
         /* P_Key value not assigned yet - start polling */
         if (!test_bit(IPOIB_PKEY_ASSIGNED, &priv->flags)) {
-                down(&pkey_sem);
+                mutex_lock(&pkey_mutex);
                 clear_bit(IPOIB_PKEY_STOP, &priv->flags);
                 queue_delayed_work(ipoib_workqueue,
                                    &priv->pkey_task,
                                    HZ);
-                up(&pkey_sem);
+                mutex_unlock(&pkey_mutex);
                 return 1;
         }
 
diff --git a/drivers/infiniband/ulp/ipoib/ipoib_main.c b/drivers/infiniband/ulp/ipoib/ipoib_main.c
index 780009c7eaa6..fd3f5c862a5d 100644
--- a/drivers/infiniband/ulp/ipoib/ipoib_main.c
+++ b/drivers/infiniband/ulp/ipoib/ipoib_main.c
@@ -105,7 +105,7 @@ int ipoib_open(struct net_device *dev)
                 struct ipoib_dev_priv *cpriv;
 
                 /* Bring up any child interfaces too */
-                down(&priv->vlan_mutex);
+                mutex_lock(&priv->vlan_mutex);
                 list_for_each_entry(cpriv, &priv->child_intfs, list) {
                         int flags;
 
@@ -115,7 +115,7 @@ int ipoib_open(struct net_device *dev)
 
                         dev_change_flags(cpriv->dev, flags | IFF_UP);
                 }
-                up(&priv->vlan_mutex);
+                mutex_unlock(&priv->vlan_mutex);
         }
 
         netif_start_queue(dev);
@@ -140,7 +140,7 @@ static int ipoib_stop(struct net_device *dev)
                 struct ipoib_dev_priv *cpriv;
 
                 /* Bring down any child interfaces too */
-                down(&priv->vlan_mutex);
+                mutex_lock(&priv->vlan_mutex);
                 list_for_each_entry(cpriv, &priv->child_intfs, list) {
                         int flags;
 
@@ -150,7 +150,7 @@ static int ipoib_stop(struct net_device *dev)
 
                         dev_change_flags(cpriv->dev, flags & ~IFF_UP);
                 }
-                up(&priv->vlan_mutex);
+                mutex_unlock(&priv->vlan_mutex);
         }
 
         return 0;
@@ -892,8 +892,8 @@ static void ipoib_setup(struct net_device *dev)
         spin_lock_init(&priv->lock);
         spin_lock_init(&priv->tx_lock);
 
-        init_MUTEX(&priv->mcast_mutex);
-        init_MUTEX(&priv->vlan_mutex);
+        mutex_init(&priv->mcast_mutex);
+        mutex_init(&priv->vlan_mutex);
 
         INIT_LIST_HEAD(&priv->path_list);
         INIT_LIST_HEAD(&priv->child_intfs);
diff --git a/drivers/infiniband/ulp/ipoib/ipoib_multicast.c b/drivers/infiniband/ulp/ipoib/ipoib_multicast.c
index ed0c2ead8bc1..98039da0caf0 100644
--- a/drivers/infiniband/ulp/ipoib/ipoib_multicast.c
+++ b/drivers/infiniband/ulp/ipoib/ipoib_multicast.c
@@ -55,7 +55,7 @@ MODULE_PARM_DESC(mcast_debug_level,
                  "Enable multicast debug tracing if > 0");
 #endif
 
-static DECLARE_MUTEX(mcast_mutex);
+static DEFINE_MUTEX(mcast_mutex);
 
 /* Used for all multicast joins (broadcast, IPv4 mcast and IPv6 mcast) */
 struct ipoib_mcast {
@@ -97,8 +97,6 @@ static void ipoib_mcast_free(struct ipoib_mcast *mcast)
         struct ipoib_dev_priv *priv = netdev_priv(dev);
         struct ipoib_neigh *neigh, *tmp;
         unsigned long flags;
-        LIST_HEAD(ah_list);
-        struct ipoib_ah *ah, *tah;
 
         ipoib_dbg_mcast(netdev_priv(dev),
                         "deleting multicast group " IPOIB_GID_FMT "\n",
@@ -107,8 +105,14 @@ static void ipoib_mcast_free(struct ipoib_mcast *mcast)
         spin_lock_irqsave(&priv->lock, flags);
 
         list_for_each_entry_safe(neigh, tmp, &mcast->neigh_list, list) {
+                /*
+                 * It's safe to call ipoib_put_ah() inside priv->lock
+                 * here, because we know that mcast->ah will always
+                 * hold one more reference, so ipoib_put_ah() will
+                 * never do more than decrement the ref count.
+                 */
                 if (neigh->ah)
-                        list_add_tail(&neigh->ah->list, &ah_list);
+                        ipoib_put_ah(neigh->ah);
                 *to_ipoib_neigh(neigh->neighbour) = NULL;
                 neigh->neighbour->ops->destructor = NULL;
                 kfree(neigh);
@@ -116,9 +120,6 @@ static void ipoib_mcast_free(struct ipoib_mcast *mcast)
 
         spin_unlock_irqrestore(&priv->lock, flags);
 
-        list_for_each_entry_safe(ah, tah, &ah_list, list)
-                ipoib_put_ah(ah);
-
         if (mcast->ah)
                 ipoib_put_ah(mcast->ah);
 
@@ -384,10 +385,10 @@ static void ipoib_mcast_join_complete(int status,
 
         if (!status && !ipoib_mcast_join_finish(mcast, mcmember)) {
                 mcast->backoff = 1;
-                down(&mcast_mutex);
+                mutex_lock(&mcast_mutex);
                 if (test_bit(IPOIB_MCAST_RUN, &priv->flags))
                         queue_work(ipoib_workqueue, &priv->mcast_task);
-                up(&mcast_mutex);
+                mutex_unlock(&mcast_mutex);
                 complete(&mcast->done);
                 return;
         }
@@ -417,7 +418,7 @@ static void ipoib_mcast_join_complete(int status,
 
         mcast->query = NULL;
 
-        down(&mcast_mutex);
+        mutex_lock(&mcast_mutex);
         if (test_bit(IPOIB_MCAST_RUN, &priv->flags)) {
                 if (status == -ETIMEDOUT)
                         queue_work(ipoib_workqueue, &priv->mcast_task);
@@ -426,7 +427,7 @@ static void ipoib_mcast_join_complete(int status,
                                            mcast->backoff * HZ);
         } else
                 complete(&mcast->done);
-        up(&mcast_mutex);
+        mutex_unlock(&mcast_mutex);
 
         return;
 }
@@ -481,12 +482,12 @@ static void ipoib_mcast_join(struct net_device *dev, struct ipoib_mcast *mcast,
                 if (mcast->backoff > IPOIB_MAX_BACKOFF_SECONDS)
                         mcast->backoff = IPOIB_MAX_BACKOFF_SECONDS;
 
-                down(&mcast_mutex);
+                mutex_lock(&mcast_mutex);
                 if (test_bit(IPOIB_MCAST_RUN, &priv->flags))
                         queue_delayed_work(ipoib_workqueue,
                                            &priv->mcast_task,
                                            mcast->backoff * HZ);
-                up(&mcast_mutex);
+                mutex_unlock(&mcast_mutex);
         } else
                 mcast->query_id = ret;
 }
@@ -519,11 +520,11 @@ void ipoib_mcast_join_task(void *dev_ptr)
                 priv->broadcast = ipoib_mcast_alloc(dev, 1);
                 if (!priv->broadcast) {
                         ipoib_warn(priv, "failed to allocate broadcast group\n");
-                        down(&mcast_mutex);
+                        mutex_lock(&mcast_mutex);
                         if (test_bit(IPOIB_MCAST_RUN, &priv->flags))
                                 queue_delayed_work(ipoib_workqueue,
                                                    &priv->mcast_task, HZ);
-                        up(&mcast_mutex);
+                        mutex_unlock(&mcast_mutex);
                         return;
                 }
 
@@ -579,10 +580,10 @@ int ipoib_mcast_start_thread(struct net_device *dev)
 
         ipoib_dbg_mcast(priv, "starting multicast thread\n");
 
-        down(&mcast_mutex);
+        mutex_lock(&mcast_mutex);
         if (!test_and_set_bit(IPOIB_MCAST_RUN, &priv->flags))
                 queue_work(ipoib_workqueue, &priv->mcast_task);
-        up(&mcast_mutex);
+        mutex_unlock(&mcast_mutex);
 
         return 0;
 }
@@ -594,10 +595,10 @@ int ipoib_mcast_stop_thread(struct net_device *dev, int flush)
 
         ipoib_dbg_mcast(priv, "stopping multicast thread\n");
 
-        down(&mcast_mutex);
+        mutex_lock(&mcast_mutex);
         clear_bit(IPOIB_MCAST_RUN, &priv->flags);
         cancel_delayed_work(&priv->mcast_task);
-        up(&mcast_mutex);
+        mutex_unlock(&mcast_mutex);
 
         if (flush)
                 flush_workqueue(ipoib_workqueue);
@@ -741,48 +742,23 @@ void ipoib_mcast_dev_flush(struct net_device *dev)
 {
         struct ipoib_dev_priv *priv = netdev_priv(dev);
         LIST_HEAD(remove_list);
-        struct ipoib_mcast *mcast, *tmcast, *nmcast;
+        struct ipoib_mcast *mcast, *tmcast;
         unsigned long flags;
 
         ipoib_dbg_mcast(priv, "flushing multicast list\n");
 
         spin_lock_irqsave(&priv->lock, flags);
-        list_for_each_entry_safe(mcast, tmcast, &priv->multicast_list, list) {
-                nmcast = ipoib_mcast_alloc(dev, 0);
-                if (nmcast) {
-                        nmcast->flags =
-                                mcast->flags & (1 << IPOIB_MCAST_FLAG_SENDONLY);
 
-                        nmcast->mcmember.mgid = mcast->mcmember.mgid;
-
-                        /* Add the new group in before the to-be-destroyed group */
-                        list_add_tail(&nmcast->list, &mcast->list);
-                        list_del_init(&mcast->list);
-
-                        rb_replace_node(&mcast->rb_node, &nmcast->rb_node,
-                                        &priv->multicast_tree);
-
-                        list_add_tail(&mcast->list, &remove_list);
-                } else {
-                        ipoib_warn(priv, "could not reallocate multicast group "
-                                   IPOIB_GID_FMT "\n",
-                                   IPOIB_GID_ARG(mcast->mcmember.mgid));
-                }
+        list_for_each_entry_safe(mcast, tmcast, &priv->multicast_list, list) {
+                list_del(&mcast->list);
+                rb_erase(&mcast->rb_node, &priv->multicast_tree);
+                list_add_tail(&mcast->list, &remove_list);
         }
 
         if (priv->broadcast) {
-                nmcast = ipoib_mcast_alloc(dev, 0);
-                if (nmcast) {
-                        nmcast->mcmember.mgid = priv->broadcast->mcmember.mgid;
-
-                        rb_replace_node(&priv->broadcast->rb_node,
-                                        &nmcast->rb_node,
-                                        &priv->multicast_tree);
-
-                        list_add_tail(&priv->broadcast->list, &remove_list);
-                }
-
-                priv->broadcast = nmcast;
+                rb_erase(&priv->broadcast->rb_node, &priv->multicast_tree);
+                list_add_tail(&priv->broadcast->list, &remove_list);
+                priv->broadcast = NULL;
         }
 
         spin_unlock_irqrestore(&priv->lock, flags);
@@ -793,24 +769,6 @@ void ipoib_mcast_dev_flush(struct net_device *dev)
         }
 }
 
-void ipoib_mcast_dev_down(struct net_device *dev)
-{
-        struct ipoib_dev_priv *priv = netdev_priv(dev);
-        unsigned long flags;
-
-        /* Delete broadcast since it will be recreated */
-        if (priv->broadcast) {
-                ipoib_dbg_mcast(priv, "deleting broadcast group\n");
-
-                spin_lock_irqsave(&priv->lock, flags);
-                rb_erase(&priv->broadcast->rb_node, &priv->multicast_tree);
-                spin_unlock_irqrestore(&priv->lock, flags);
-                ipoib_mcast_leave(dev, priv->broadcast);
-                ipoib_mcast_free(priv->broadcast);
-                priv->broadcast = NULL;
-        }
-}
-
 void ipoib_mcast_restart_task(void *dev_ptr)
 {
         struct net_device *dev = dev_ptr;
@@ -824,7 +782,8 @@ void ipoib_mcast_restart_task(void *dev_ptr)
 
         ipoib_mcast_stop_thread(dev, 0);
 
-        spin_lock_irqsave(&priv->lock, flags);
+        spin_lock_irqsave(&dev->xmit_lock, flags);
+        spin_lock(&priv->lock);
 
         /*
          * Unfortunately, the networking core only gives us a list of all of
@@ -896,7 +855,9 @@ void ipoib_mcast_restart_task(void *dev_ptr)
                         list_add_tail(&mcast->list, &remove_list);
                 }
         }
-        spin_unlock_irqrestore(&priv->lock, flags);
+
+        spin_unlock(&priv->lock);
+        spin_unlock_irqrestore(&dev->xmit_lock, flags);
 
         /* We have to cancel outside of the spinlock */
         list_for_each_entry_safe(mcast, tmcast, &remove_list, list) {
diff --git a/drivers/infiniband/ulp/ipoib/ipoib_verbs.c b/drivers/infiniband/ulp/ipoib/ipoib_verbs.c
index e829e10400e3..faaf10e5fc7b 100644
--- a/drivers/infiniband/ulp/ipoib/ipoib_verbs.c
+++ b/drivers/infiniband/ulp/ipoib/ipoib_verbs.c
@@ -65,9 +65,9 @@ int ipoib_mcast_attach(struct net_device *dev, u16 mlid, union ib_gid *mgid)
         }
 
         /* attach QP to multicast group */
-        down(&priv->mcast_mutex);
+        mutex_lock(&priv->mcast_mutex);
         ret = ib_attach_mcast(priv->qp, mgid, mlid);
-        up(&priv->mcast_mutex);
+        mutex_unlock(&priv->mcast_mutex);
         if (ret)
                 ipoib_warn(priv, "failed to attach to multicast group, ret = %d\n", ret);
 
@@ -81,9 +81,9 @@ int ipoib_mcast_detach(struct net_device *dev, u16 mlid, union ib_gid *mgid)
         struct ipoib_dev_priv *priv = netdev_priv(dev);
         int ret;
 
-        down(&priv->mcast_mutex);
+        mutex_lock(&priv->mcast_mutex);
         ret = ib_detach_mcast(priv->qp, mgid, mlid);
-        up(&priv->mcast_mutex);
+        mutex_unlock(&priv->mcast_mutex);
         if (ret)
                 ipoib_warn(priv, "ib_detach_mcast failed (result = %d)\n", ret);
 
diff --git a/drivers/infiniband/ulp/ipoib/ipoib_vlan.c b/drivers/infiniband/ulp/ipoib/ipoib_vlan.c
index d280b341a37f..4ca175553f9f 100644
--- a/drivers/infiniband/ulp/ipoib/ipoib_vlan.c
+++ b/drivers/infiniband/ulp/ipoib/ipoib_vlan.c
@@ -63,7 +63,7 @@ int ipoib_vlan_add(struct net_device *pdev, unsigned short pkey)
 
         ppriv = netdev_priv(pdev);
 
-        down(&ppriv->vlan_mutex);
+        mutex_lock(&ppriv->vlan_mutex);
 
         /*
          * First ensure this isn't a duplicate. We check the parent device and
@@ -124,7 +124,7 @@ int ipoib_vlan_add(struct net_device *pdev, unsigned short pkey)
 
         list_add_tail(&priv->list, &ppriv->child_intfs);
 
-        up(&ppriv->vlan_mutex);
+        mutex_unlock(&ppriv->vlan_mutex);
 
         return 0;
 
@@ -139,7 +139,7 @@ device_init_failed:
         free_netdev(priv->dev);
 
 err:
-        up(&ppriv->vlan_mutex);
+        mutex_unlock(&ppriv->vlan_mutex);
         return result;
 }
 
@@ -153,7 +153,7 @@ int ipoib_vlan_delete(struct net_device *pdev, unsigned short pkey)
 
         ppriv = netdev_priv(pdev);
 
-        down(&ppriv->vlan_mutex);
+        mutex_lock(&ppriv->vlan_mutex);
         list_for_each_entry_safe(priv, tpriv, &ppriv->child_intfs, list) {
                 if (priv->pkey == pkey) {
                         unregister_netdev(priv->dev);
@@ -167,7 +167,7 @@ int ipoib_vlan_delete(struct net_device *pdev, unsigned short pkey)
                         break;
                 }
         }
-        up(&ppriv->vlan_mutex);
+        mutex_unlock(&ppriv->vlan_mutex);
 
         return ret;
 }
diff --git a/drivers/infiniband/ulp/srp/ib_srp.c b/drivers/infiniband/ulp/srp/ib_srp.c
index dd488d3cffa9..31207e664148 100644
--- a/drivers/infiniband/ulp/srp/ib_srp.c
+++ b/drivers/infiniband/ulp/srp/ib_srp.c
@@ -1516,8 +1516,7 @@ static ssize_t show_port(struct class_device *class_dev, char *buf)
 
 static CLASS_DEVICE_ATTR(port, S_IRUGO, show_port, NULL);
 
-static struct srp_host *srp_add_port(struct ib_device *device,
-                                     __be64 node_guid, u8 port)
+static struct srp_host *srp_add_port(struct ib_device *device, u8 port)
 {
         struct srp_host *host;
 
@@ -1532,7 +1531,7 @@ static struct srp_host *srp_add_port(struct ib_device *device,
         host->port = port;
 
         host->initiator_port_id[7] = port;
-        memcpy(host->initiator_port_id + 8, &node_guid, 8);
+        memcpy(host->initiator_port_id + 8, &device->node_guid, 8);
 
         host->pd   = ib_alloc_pd(device);
         if (IS_ERR(host->pd))
@@ -1580,22 +1579,11 @@ static void srp_add_one(struct ib_device *device)
 {
         struct list_head *dev_list;
         struct srp_host *host;
-        struct ib_device_attr *dev_attr;
         int s, e, p;
 
-        dev_attr = kmalloc(sizeof *dev_attr, GFP_KERNEL);
-        if (!dev_attr)
-                return;
-
-        if (ib_query_device(device, dev_attr)) {
-                printk(KERN_WARNING PFX "Couldn't query node GUID for %s.\n",
-                       device->name);
-                goto out;
-        }
-
         dev_list = kmalloc(sizeof *dev_list, GFP_KERNEL);
         if (!dev_list)
-                goto out;
+                return;
 
         INIT_LIST_HEAD(dev_list);
 
@@ -1608,15 +1596,12 @@ static void srp_add_one(struct ib_device *device)
         }
 
         for (p = s; p <= e; ++p) {
-                host = srp_add_port(device, dev_attr->node_guid, p);
+                host = srp_add_port(device, p);
                 if (host)
                         list_add_tail(&host->list, dev_list);
         }
 
         ib_set_client_data(device, &srp_client, dev_list);
-
-out:
-        kfree(dev_attr);
 }
 
 static void srp_remove_one(struct ib_device *device)
diff --git a/drivers/input/gameport/gameport.c b/drivers/input/gameport/gameport.c
index caac6d63d46f..b765a155c008 100644
--- a/drivers/input/gameport/gameport.c
+++ b/drivers/input/gameport/gameport.c
@@ -50,9 +50,7 @@ static DECLARE_MUTEX(gameport_sem);
 
 static LIST_HEAD(gameport_list);
 
-static struct bus_type gameport_bus = {
-        .name = "gameport",
-};
+static struct bus_type gameport_bus;
 
 static void gameport_add_port(struct gameport *gameport);
 static void gameport_destroy_port(struct gameport *gameport);
@@ -703,11 +701,15 @@ static int gameport_driver_remove(struct device *dev)
         return 0;
 }
 
+static struct bus_type gameport_bus = {
+        .name = "gameport",
+        .probe = gameport_driver_probe,
+        .remove = gameport_driver_remove,
+};
+
 void __gameport_register_driver(struct gameport_driver *drv, struct module *owner)
 {
         drv->driver.bus = &gameport_bus;
-        drv->driver.probe = gameport_driver_probe;
-        drv->driver.remove = gameport_driver_remove;
         gameport_queue_event(drv, owner, GAMEPORT_REGISTER_DRIVER);
 }
 
diff --git a/drivers/input/input.c b/drivers/input/input.c
index fe33ff334e27..4fe3da3c667a 100644
--- a/drivers/input/input.c
+++ b/drivers/input/input.c
@@ -528,40 +528,56 @@ INPUT_DEV_STRING_ATTR_SHOW(name);
 INPUT_DEV_STRING_ATTR_SHOW(phys);
 INPUT_DEV_STRING_ATTR_SHOW(uniq);
 
-static int print_modalias_bits(char *buf, char prefix, unsigned long *arr,
+static int print_modalias_bits(char *buf, int size, char prefix, unsigned long *arr,
                                unsigned int min, unsigned int max)
 {
         int len, i;
 
-        len = sprintf(buf, "%c", prefix);
+        len = snprintf(buf, size, "%c", prefix);
         for (i = min; i < max; i++)
                 if (arr[LONG(i)] & BIT(i))
-                        len += sprintf(buf+len, "%X,", i);
+                        len += snprintf(buf + len, size - len, "%X,", i);
         return len;
 }
 
-static ssize_t input_dev_show_modalias(struct class_device *dev, char *buf)
+static int print_modalias(char *buf, int size, struct input_dev *id)
 {
-        struct input_dev *id = to_input_dev(dev);
-        ssize_t len = 0;
+        int len;
 
-        len += sprintf(buf+len, "input:b%04Xv%04Xp%04Xe%04X-",
+        len = snprintf(buf, size, "input:b%04Xv%04Xp%04Xe%04X-",
                        id->id.bustype,
                        id->id.vendor,
                        id->id.product,
                        id->id.version);
 
-        len += print_modalias_bits(buf+len, 'e', id->evbit, 0, EV_MAX);
-        len += print_modalias_bits(buf+len, 'k', id->keybit,
+        len += print_modalias_bits(buf + len, size - len, 'e', id->evbit,
+                                   0, EV_MAX);
+        len += print_modalias_bits(buf + len, size - len, 'k', id->keybit,
                                    KEY_MIN_INTERESTING, KEY_MAX);
-        len += print_modalias_bits(buf+len, 'r', id->relbit, 0, REL_MAX);
-        len += print_modalias_bits(buf+len, 'a', id->absbit, 0, ABS_MAX);
-        len += print_modalias_bits(buf+len, 'm', id->mscbit, 0, MSC_MAX);
-        len += print_modalias_bits(buf+len, 'l', id->ledbit, 0, LED_MAX);
-        len += print_modalias_bits(buf+len, 's', id->sndbit, 0, SND_MAX);
-        len += print_modalias_bits(buf+len, 'f', id->ffbit, 0, FF_MAX);
-        len += print_modalias_bits(buf+len, 'w', id->swbit, 0, SW_MAX);
-        len += sprintf(buf+len, "\n");
+        len += print_modalias_bits(buf + len, size - len, 'r', id->relbit,
+                                   0, REL_MAX);
+        len += print_modalias_bits(buf + len, size - len, 'a', id->absbit,
+                                   0, ABS_MAX);
+        len += print_modalias_bits(buf + len, size - len, 'm', id->mscbit,
+                                   0, MSC_MAX);
+        len += print_modalias_bits(buf + len, size - len, 'l', id->ledbit,
+                                   0, LED_MAX);
+        len += print_modalias_bits(buf + len, size - len, 's', id->sndbit,
+                                   0, SND_MAX);
+        len += print_modalias_bits(buf + len, size - len, 'f', id->ffbit,
+                                   0, FF_MAX);
+        len += print_modalias_bits(buf + len, size - len, 'w', id->swbit,
+                                   0, SW_MAX);
+        return len;
+}
+
+static ssize_t input_dev_show_modalias(struct class_device *dev, char *buf)
+{
+        struct input_dev *id = to_input_dev(dev);
+        ssize_t len;
+
+        len = print_modalias(buf, PAGE_SIZE, id);
+        len += snprintf(buf + len, PAGE_SIZE-len, "\n");
         return len;
 }
 static CLASS_DEVICE_ATTR(modalias, S_IRUGO, input_dev_show_modalias, NULL);
@@ -728,8 +744,11 @@ static int input_dev_uevent(struct class_device *cdev, char **envp,
         if (test_bit(EV_SW, dev->evbit))
                 INPUT_ADD_HOTPLUG_BM_VAR("SW=", dev->swbit, SW_MAX);
 
-        envp[i] = NULL;
+        envp[i++] = buffer + len;
+        len += snprintf(buffer + len, buffer_size - len, "MODALIAS=");
+        len += print_modalias(buffer + len, buffer_size - len, dev) + 1;
 
+        envp[i] = NULL;
         return 0;
 }
 
diff --git a/drivers/input/mouse/alps.c b/drivers/input/mouse/alps.c
index 24474335dfd1..2141501e9f2e 100644
--- a/drivers/input/mouse/alps.c
+++ b/drivers/input/mouse/alps.c
@@ -348,6 +348,40 @@ static int alps_tap_mode(struct psmouse *psmouse, int enable)
         return 0;
 }
 
+/*
+ * alps_poll() - poll the touchpad for current motion packet.
+ * Used in resync.
+ */
+static int alps_poll(struct psmouse *psmouse)
+{
+        struct alps_data *priv = psmouse->private;
+        unsigned char buf[6];
+        int poll_failed;
+
+        if (priv->i->flags & ALPS_PASS)
+                alps_passthrough_mode(psmouse, 1);
+
+        poll_failed = ps2_command(&psmouse->ps2dev, buf,
+                                  PSMOUSE_CMD_POLL | (psmouse->pktsize << 8)) < 0;
+
+        if (priv->i->flags & ALPS_PASS)
+                alps_passthrough_mode(psmouse, 0);
+
+        if (poll_failed || (buf[0] & priv->i->mask0) != priv->i->byte0)
+                return -1;
+
+        if ((psmouse->badbyte & 0xc8) == 0x08) {
+/*
+ * Poll the track stick ...
+ */
+                if (ps2_command(&psmouse->ps2dev, buf, PSMOUSE_CMD_POLL | (3 << 8)))
+                        return -1;
+        }
+
+        memcpy(psmouse->packet, buf, sizeof(buf));
+        return 0;
+}
+
 static int alps_reconnect(struct psmouse *psmouse)
 {
         struct alps_data *priv = psmouse->private;
@@ -451,10 +485,14 @@ int alps_init(struct psmouse *psmouse)
         input_register_device(priv->dev2);
 
         psmouse->protocol_handler = alps_process_byte;
+        psmouse->poll = alps_poll;
         psmouse->disconnect = alps_disconnect;
         psmouse->reconnect = alps_reconnect;
         psmouse->pktsize = 6;
 
+        /* We are having trouble resyncing ALPS touchpads so disable it for now */
+        psmouse->resync_time = 0;
+
         return 0;
 
 init_fail:
diff --git a/drivers/input/mouse/logips2pp.c b/drivers/input/mouse/logips2pp.c
index 025a71de5404..c88520d3d13c 100644
--- a/drivers/input/mouse/logips2pp.c
+++ b/drivers/input/mouse/logips2pp.c
@@ -117,7 +117,7 @@ static int ps2pp_cmd(struct psmouse *psmouse, unsigned char *param, unsigned cha
         if (psmouse_sliced_command(psmouse, command))
                 return -1;
 
-        if (ps2_command(&psmouse->ps2dev, param, PSMOUSE_CMD_POLL))
+        if (ps2_command(&psmouse->ps2dev, param, PSMOUSE_CMD_POLL | 0x0300))
                 return -1;
 
         return 0;
diff --git a/drivers/input/mouse/psmouse-base.c b/drivers/input/mouse/psmouse-base.c
index 4d5ecc04c5b6..7665fd9ce559 100644
--- a/drivers/input/mouse/psmouse-base.c
+++ b/drivers/input/mouse/psmouse-base.c
@@ -54,10 +54,14 @@ static unsigned int psmouse_smartscroll = 1;
 module_param_named(smartscroll, psmouse_smartscroll, bool, 0644);
 MODULE_PARM_DESC(smartscroll, "Logitech Smartscroll autorepeat, 1 = enabled (default), 0 = disabled.");
 
-static unsigned int psmouse_resetafter;
+static unsigned int psmouse_resetafter = 5;
 module_param_named(resetafter, psmouse_resetafter, uint, 0644);
 MODULE_PARM_DESC(resetafter, "Reset device after so many bad packets (0 = never).");
 
+static unsigned int psmouse_resync_time = 5;
+module_param_named(resync_time, psmouse_resync_time, uint, 0644);
+MODULE_PARM_DESC(resync_time, "How long can mouse stay idle before forcing resync (in seconds, 0 = never).");
+
 PSMOUSE_DEFINE_ATTR(protocol, S_IWUSR | S_IRUGO,
                         NULL,
                         psmouse_attr_show_protocol, psmouse_attr_set_protocol);
@@ -70,12 +74,16 @@ PSMOUSE_DEFINE_ATTR(resolution, S_IWUSR | S_IRUGO,
 PSMOUSE_DEFINE_ATTR(resetafter, S_IWUSR | S_IRUGO,
                         (void *) offsetof(struct psmouse, resetafter),
                         psmouse_show_int_attr, psmouse_set_int_attr);
+PSMOUSE_DEFINE_ATTR(resync_time, S_IWUSR | S_IRUGO,
+                        (void *) offsetof(struct psmouse, resync_time),
+                        psmouse_show_int_attr, psmouse_set_int_attr);
 
 static struct attribute *psmouse_attributes[] = {
         &psmouse_attr_protocol.dattr.attr,
         &psmouse_attr_rate.dattr.attr,
         &psmouse_attr_resolution.dattr.attr,
         &psmouse_attr_resetafter.dattr.attr,
+        &psmouse_attr_resync_time.dattr.attr,
         NULL
 };
 
@@ -98,6 +106,8 @@ __obsolete_setup("psmouse_rate=");
  */
 static DECLARE_MUTEX(psmouse_sem);
 
+static struct workqueue_struct *kpsmoused_wq;
+
 struct psmouse_protocol {
         enum psmouse_type type;
         char *name;
@@ -178,15 +188,79 @@ static psmouse_ret_t psmouse_process_byte(struct psmouse *psmouse, struct pt_reg
 }
 
 /*
- * psmouse_interrupt() handles incoming characters, either gathering them into
- * packets or passing them to the command routine as command output.
+ * __psmouse_set_state() sets new psmouse state and resets all flags.
+ */
+
+static inline void __psmouse_set_state(struct psmouse *psmouse, enum psmouse_state new_state)
+{
+        psmouse->state = new_state;
+        psmouse->pktcnt = psmouse->out_of_sync = 0;
+        psmouse->ps2dev.flags = 0;
+        psmouse->last = jiffies;
+}
+
+
+/*
+ * psmouse_set_state() sets new psmouse state and resets all flags and
+ * counters while holding serio lock so fighting with interrupt handler
+ * is not a concern.
+ */
+
+static void psmouse_set_state(struct psmouse *psmouse, enum psmouse_state new_state)
+{
+        serio_pause_rx(psmouse->ps2dev.serio);
+        __psmouse_set_state(psmouse, new_state);
+        serio_continue_rx(psmouse->ps2dev.serio);
+}
+
+/*
+ * psmouse_handle_byte() processes one byte of the input data stream
+ * by calling corresponding protocol handler.
+ */
+
+static int psmouse_handle_byte(struct psmouse *psmouse, struct pt_regs *regs)
+{
+        psmouse_ret_t rc = psmouse->protocol_handler(psmouse, regs);
+
+        switch (rc) {
+                case PSMOUSE_BAD_DATA:
+                        if (psmouse->state == PSMOUSE_ACTIVATED) {
+                                printk(KERN_WARNING "psmouse.c: %s at %s lost sync at byte %d\n",
+                                        psmouse->name, psmouse->phys, psmouse->pktcnt);
+                                if (++psmouse->out_of_sync == psmouse->resetafter) {
+                                        __psmouse_set_state(psmouse, PSMOUSE_IGNORE);
+                                        printk(KERN_NOTICE "psmouse.c: issuing reconnect request\n");
+                                        serio_reconnect(psmouse->ps2dev.serio);
+                                        return -1;
+                                }
+                        }
+                        psmouse->pktcnt = 0;
+                        break;
+
+                case PSMOUSE_FULL_PACKET:
+                        psmouse->pktcnt = 0;
+                        if (psmouse->out_of_sync) {
+                                psmouse->out_of_sync = 0;
+                                printk(KERN_NOTICE "psmouse.c: %s at %s - driver resynched.\n",
+                                        psmouse->name, psmouse->phys);
+                        }
+                        break;
+
+                case PSMOUSE_GOOD_DATA:
+                        break;
+        }
+        return 0;
+}
+
+/*
+ * psmouse_interrupt() handles incoming characters, either passing them
+ * for normal processing or gathering them as command response.
  */
 
 static irqreturn_t psmouse_interrupt(struct serio *serio,
                 unsigned char data, unsigned int flags, struct pt_regs *regs)
 {
         struct psmouse *psmouse = serio_get_drvdata(serio);
-        psmouse_ret_t rc;
 
         if (psmouse->state == PSMOUSE_IGNORE)
                 goto out;
@@ -208,67 +282,58 @@ static irqreturn_t psmouse_interrupt(struct serio *serio,
                 if  (ps2_handle_response(&psmouse->ps2dev, data))
                         goto out;
 
-        if (psmouse->state == PSMOUSE_INITIALIZING)
+        if (psmouse->state <= PSMOUSE_RESYNCING)
                 goto out;
 
         if (psmouse->state == PSMOUSE_ACTIVATED &&
             psmouse->pktcnt && time_after(jiffies, psmouse->last + HZ/2)) {
-                printk(KERN_WARNING "psmouse.c: %s at %s lost synchronization, throwing %d bytes away.\n",
+                printk(KERN_INFO "psmouse.c: %s at %s lost synchronization, throwing %d bytes away.\n",
                        psmouse->name, psmouse->phys, psmouse->pktcnt);
-                psmouse->pktcnt = 0;
+                psmouse->badbyte = psmouse->packet[0];
+                __psmouse_set_state(psmouse, PSMOUSE_RESYNCING);
+                queue_work(kpsmoused_wq, &psmouse->resync_work);
+                goto out;
         }
 
-        psmouse->last = jiffies;
         psmouse->packet[psmouse->pktcnt++] = data;
-
-        if (psmouse->packet[0] == PSMOUSE_RET_BAT) {
+/*
+ * Check if this is a new device announcement (0xAA 0x00)
+ */
+        if (unlikely(psmouse->packet[0] == PSMOUSE_RET_BAT && psmouse->pktcnt <= 2)) {
                 if (psmouse->pktcnt == 1)
                         goto out;
 
-                if (psmouse->pktcnt == 2) {
-                        if (psmouse->packet[1] == PSMOUSE_RET_ID) {
-                                psmouse->state = PSMOUSE_IGNORE;
-                                serio_reconnect(serio);
-                                goto out;
-                        }
-                        if (psmouse->type == PSMOUSE_SYNAPTICS) {
-                                /* neither 0xAA nor 0x00 are valid first bytes
-                                 * for a packet in absolute mode
-                                 */
-                                psmouse->pktcnt = 0;
-                                goto out;
-                        }
+                if (psmouse->packet[1] == PSMOUSE_RET_ID) {
+                        __psmouse_set_state(psmouse, PSMOUSE_IGNORE);
+                        serio_reconnect(serio);
+                        goto out;
                 }
-        }
-
-        rc = psmouse->protocol_handler(psmouse, regs);
+/*
+ * Not a new device, try processing first byte normally
+ */
+                psmouse->pktcnt = 1;
+                if (psmouse_handle_byte(psmouse, regs))
+                        goto out;
 
-        switch (rc) {
-                case PSMOUSE_BAD_DATA:
-                        printk(KERN_WARNING "psmouse.c: %s at %s lost sync at byte %d\n",
-                                psmouse->name, psmouse->phys, psmouse->pktcnt);
-                        psmouse->pktcnt = 0;
+                psmouse->packet[psmouse->pktcnt++] = data;
+        }
 
-                        if (++psmouse->out_of_sync == psmouse->resetafter) {
-                                psmouse->state = PSMOUSE_IGNORE;
-                                printk(KERN_NOTICE "psmouse.c: issuing reconnect request\n");
-                                serio_reconnect(psmouse->ps2dev.serio);
-                        }
-                        break;
+/*
+ * See if we need to force resync because mouse was idle for too long
+ */
+        if (psmouse->state == PSMOUSE_ACTIVATED &&
+            psmouse->pktcnt == 1 && psmouse->resync_time &&
+            time_after(jiffies, psmouse->last + psmouse->resync_time * HZ)) {
+                psmouse->badbyte = psmouse->packet[0];
+                __psmouse_set_state(psmouse, PSMOUSE_RESYNCING);
+                queue_work(kpsmoused_wq, &psmouse->resync_work);
+                goto out;
+        }
 
-                case PSMOUSE_FULL_PACKET:
-                        psmouse->pktcnt = 0;
-                        if (psmouse->out_of_sync) {
-                                psmouse->out_of_sync = 0;
-                                printk(KERN_NOTICE "psmouse.c: %s at %s - driver resynched.\n",
-                                        psmouse->name, psmouse->phys);
-                        }
-                        break;
+        psmouse->last = jiffies;
+        psmouse_handle_byte(psmouse, regs);
 
-                case PSMOUSE_GOOD_DATA:
-                        break;
-        }
-out:
+ out:
         return IRQ_HANDLED;
 }
 
@@ -752,21 +817,6 @@ static void psmouse_initialize(struct psmouse *psmouse)
 }
 
 /*
- * psmouse_set_state() sets new psmouse state and resets all flags and
- * counters while holding serio lock so fighting with interrupt handler
- * is not a concern.
- */
-
-static void psmouse_set_state(struct psmouse *psmouse, enum psmouse_state new_state)
-{
-        serio_pause_rx(psmouse->ps2dev.serio);
-        psmouse->state = new_state;
-        psmouse->pktcnt = psmouse->out_of_sync = 0;
-        psmouse->ps2dev.flags = 0;
-        serio_continue_rx(psmouse->ps2dev.serio);
-}
-
-/*
  * psmouse_activate() enables the mouse so that we get motion reports from it.
  */
 
@@ -794,6 +844,111 @@ static void psmouse_deactivate(struct psmouse *psmouse)
         psmouse_set_state(psmouse, PSMOUSE_CMD_MODE);
 }
 
+/*
+ * psmouse_poll() - default poll hanlder. Everyone except for ALPS uses it.
+ */
+
+static int psmouse_poll(struct psmouse *psmouse)
+{
+        return ps2_command(&psmouse->ps2dev, psmouse->packet,
+                           PSMOUSE_CMD_POLL | (psmouse->pktsize << 8));
+}
+
+
+/*
+ * psmouse_resync() attempts to re-validate current protocol.
+ */
+
+static void psmouse_resync(void *p)
+{
+        struct psmouse *psmouse = p, *parent = NULL;
+        struct serio *serio = psmouse->ps2dev.serio;
+        psmouse_ret_t rc = PSMOUSE_GOOD_DATA;
+        int failed = 0, enabled = 0;
+        int i;
+
+        down(&psmouse_sem);
+
+        if (psmouse->state != PSMOUSE_RESYNCING)
+                goto out;
+
+        if (serio->parent && serio->id.type == SERIO_PS_PSTHRU) {
+                parent = serio_get_drvdata(serio->parent);
+                psmouse_deactivate(parent);
+        }
+
+/*
+ * Some mice don't ACK commands sent while they are in the middle of
+ * transmitting motion packet. To avoid delay we use ps2_sendbyte()
+ * instead of ps2_command() which would wait for 200ms for an ACK
+ * that may never come.
+ * As an additional quirk ALPS touchpads may not only forget to ACK
+ * disable command but will stop reporting taps, so if we see that
+ * mouse at least once ACKs disable we will do full reconnect if ACK
+ * is missing.
+ */
+        psmouse->num_resyncs++;
+
+        if (ps2_sendbyte(&psmouse->ps2dev, PSMOUSE_CMD_DISABLE, 20)) {
+                if (psmouse->num_resyncs < 3 || psmouse->acks_disable_command)
+                        failed = 1;
+        } else
+                psmouse->acks_disable_command = 1;
+
+/*
+ * Poll the mouse. If it was reset the packet will be shorter than
+ * psmouse->pktsize and ps2_command will fail. We do not expect and
+ * do not handle scenario when mouse "upgrades" its protocol while
+ * disconnected since it would require additional delay. If we ever
+ * see a mouse that does it we'll adjust the code.
+ */
+        if (!failed) {
+                if (psmouse->poll(psmouse))
+                        failed = 1;
+                else {
+                        psmouse_set_state(psmouse, PSMOUSE_CMD_MODE);
+                        for (i = 0; i < psmouse->pktsize; i++) {
+                                psmouse->pktcnt++;
+                                rc = psmouse->protocol_handler(psmouse, NULL);
+                                if (rc != PSMOUSE_GOOD_DATA)
+                                        break;
+                        }
+                        if (rc != PSMOUSE_FULL_PACKET)
+                                failed = 1;
+                        psmouse_set_state(psmouse, PSMOUSE_RESYNCING);
+                }
+        }
+/*
+ * Now try to enable mouse. We try to do that even if poll failed and also
+ * repeat our attempts 5 times, otherwise we may be left out with disabled
+ * mouse.
+ */
+        for (i = 0; i < 5; i++) {
+                if (!ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_ENABLE)) {
+                        enabled = 1;
+                        break;
+                }
+                msleep(200);
+        }
+
+        if (!enabled) {
+                printk(KERN_WARNING "psmouse.c: failed to re-enable mouse on %s\n",
+                        psmouse->ps2dev.serio->phys);
+                failed = 1;
+        }
+
+        if (failed) {
+                psmouse_set_state(psmouse, PSMOUSE_IGNORE);
+                printk(KERN_INFO "psmouse.c: resync failed, issuing reconnect request\n");
+                serio_reconnect(serio);
+        } else
+                psmouse_set_state(psmouse, PSMOUSE_ACTIVATED);
+
+        if (parent)
+                psmouse_activate(parent);
+ out:
+        up(&psmouse_sem);
+}
 
 /*
  * psmouse_cleanup() resets the mouse into power-on state.
@@ -822,6 +977,11 @@ static void psmouse_disconnect(struct serio *serio)
 
         psmouse_set_state(psmouse, PSMOUSE_CMD_MODE);
 
+        /* make sure we don't have a resync in progress */
+        up(&psmouse_sem);
+        flush_workqueue(kpsmoused_wq);
+        down(&psmouse_sem);
+
         if (serio->parent && serio->id.type == SERIO_PS_PSTHRU) {
                 parent = serio_get_drvdata(serio->parent);
                 psmouse_deactivate(parent);
@@ -859,6 +1019,7 @@ static int psmouse_switch_protocol(struct psmouse *psmouse, struct psmouse_proto
 
         psmouse->set_rate = psmouse_set_rate;
         psmouse->set_resolution = psmouse_set_resolution;
+        psmouse->poll = psmouse_poll;
         psmouse->protocol_handler = psmouse_process_byte;
         psmouse->pktsize = 3;
 
@@ -874,6 +1035,23 @@ static int psmouse_switch_protocol(struct psmouse *psmouse, struct psmouse_proto
         else
                 psmouse->type = psmouse_extensions(psmouse, psmouse_max_proto, 1);
 
+        /*
+         * If mouse's packet size is 3 there is no point in polling the
+         * device in hopes to detect protocol reset - we won't get less
+         * than 3 bytes response anyhow.
+         */
+        if (psmouse->pktsize == 3)
+                psmouse->resync_time = 0;
+
+        /*
+         * Some smart KVMs fake response to POLL command returning just
+         * 3 bytes and messing up our resync logic, so if initial poll
+         * fails we won't try polling the device anymore. Hopefully
+         * such KVM will maintain initially selected protocol.
+         */
+        if (psmouse->resync_time && psmouse->poll(psmouse))
+                psmouse->resync_time = 0;
+
         sprintf(psmouse->devname, "%s %s %s",
                 psmouse_protocol_by_type(psmouse->type)->name, psmouse->vendor, psmouse->name);
 
@@ -914,6 +1092,7 @@ static int psmouse_connect(struct serio *serio, struct serio_driver *drv)
                 goto out;
 
         ps2_init(&psmouse->ps2dev, serio);
+        INIT_WORK(&psmouse->resync_work, psmouse_resync, psmouse);
         psmouse->dev = input_dev;
         sprintf(psmouse->phys, "%s/input0", serio->phys);
 
@@ -934,6 +1113,7 @@ static int psmouse_connect(struct serio *serio, struct serio_driver *drv)
         psmouse->rate = psmouse_rate;
         psmouse->resolution = psmouse_resolution;
         psmouse->resetafter = psmouse_resetafter;
+        psmouse->resync_time = parent ? 0 : psmouse_resync_time;
         psmouse->smartscroll = psmouse_smartscroll;
 
         psmouse_switch_protocol(psmouse, NULL);
@@ -1278,13 +1458,21 @@ static int psmouse_get_maxproto(char *buffer, struct kernel_param *kp)
 
 static int __init psmouse_init(void)
 {
+        kpsmoused_wq = create_singlethread_workqueue("kpsmoused");
+        if (!kpsmoused_wq) {
+                printk(KERN_ERR "psmouse: failed to create kpsmoused workqueue\n");
+                return -ENOMEM;
+        }
+
         serio_register_driver(&psmouse_drv);
+
         return 0;
 }
 
 static void __exit psmouse_exit(void)
 {
         serio_unregister_driver(&psmouse_drv);
+        destroy_workqueue(kpsmoused_wq);
 }
 
 module_init(psmouse_init);
diff --git a/drivers/input/mouse/psmouse.h b/drivers/input/mouse/psmouse.h
index 7c4192bd1279..4d9107fba6a1 100644
--- a/drivers/input/mouse/psmouse.h
+++ b/drivers/input/mouse/psmouse.h
@@ -7,7 +7,7 @@
 #define PSMOUSE_CMD_GETINFO     0x03e9
 #define PSMOUSE_CMD_SETSTREAM   0x00ea
 #define PSMOUSE_CMD_SETPOLL     0x00f0
-#define PSMOUSE_CMD_POLL        0x03eb
+#define PSMOUSE_CMD_POLL        0x00eb  /* caller sets number of bytes to receive */
 #define PSMOUSE_CMD_GETID       0x02f2
 #define PSMOUSE_CMD_SETRATE     0x10f3
 #define PSMOUSE_CMD_ENABLE      0x00f4
@@ -23,6 +23,7 @@
 enum psmouse_state {
         PSMOUSE_IGNORE,
         PSMOUSE_INITIALIZING,
+        PSMOUSE_RESYNCING,
         PSMOUSE_CMD_MODE,
         PSMOUSE_ACTIVATED,
 };
@@ -38,15 +39,19 @@ struct psmouse {
         void *private;
         struct input_dev *dev;
         struct ps2dev ps2dev;
+        struct work_struct resync_work;
         char *vendor;
         char *name;
         unsigned char packet[8];
+        unsigned char badbyte;
         unsigned char pktcnt;
         unsigned char pktsize;
         unsigned char type;
+        unsigned char acks_disable_command;
         unsigned int model;
         unsigned long last;
         unsigned long out_of_sync;
+        unsigned long num_resyncs;
         enum psmouse_state state;
         char devname[64];
         char phys[32];
@@ -54,6 +59,7 @@ struct psmouse {
         unsigned int rate;
         unsigned int resolution;
         unsigned int resetafter;
+        unsigned int resync_time;
         unsigned int smartscroll;       /* Logitech only */
 
         psmouse_ret_t (*protocol_handler)(struct psmouse *psmouse, struct pt_regs *regs);
@@ -62,6 +68,7 @@ struct psmouse {
 
         int (*reconnect)(struct psmouse *psmouse);
         void (*disconnect)(struct psmouse *psmouse);
+        int (*poll)(struct psmouse *psmouse);
 
         void (*pt_activate)(struct psmouse *psmouse);
         void (*pt_deactivate)(struct psmouse *psmouse);
diff --git a/drivers/input/mouse/synaptics.c b/drivers/input/mouse/synaptics.c
index 97cdfd6acaca..2051bec2c394 100644
--- a/drivers/input/mouse/synaptics.c
+++ b/drivers/input/mouse/synaptics.c
@@ -652,6 +652,8 @@ int synaptics_init(struct psmouse *psmouse)
         psmouse->disconnect = synaptics_disconnect;
         psmouse->reconnect = synaptics_reconnect;
         psmouse->pktsize = 6;
+        /* Synaptics can usually stay in sync without extra help */
+        psmouse->resync_time = 0;
 
         if (SYN_CAP_PASS_THROUGH(priv->capabilities))
                 synaptics_pt_create(psmouse);
diff --git a/drivers/input/serio/i8042-x86ia64io.h b/drivers/input/serio/i8042-x86ia64io.h
index 2d2f9fb3aded..a4c6f3522723 100644
--- a/drivers/input/serio/i8042-x86ia64io.h
+++ b/drivers/input/serio/i8042-x86ia64io.h
@@ -173,6 +173,13 @@ static struct dmi_system_id __initdata i8042_dmi_nomux_table[] = {
                         DMI_MATCH(DMI_PRODUCT_NAME, "PC-MM20 Series"),
                 },
         },
+        {
+                .ident = "Sony Vaio FS-115b",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "VGN-FS115B"),
+                },
+        },
         { }
 };
 
diff --git a/drivers/input/serio/serio.c b/drivers/input/serio/serio.c
index 8e530cc970e1..2f76813c3a64 100644
--- a/drivers/input/serio/serio.c
+++ b/drivers/input/serio/serio.c
@@ -59,9 +59,7 @@ static DECLARE_MUTEX(serio_sem);
 
 static LIST_HEAD(serio_list);
 
-static struct bus_type serio_bus = {
-        .name = "serio",
-};
+static struct bus_type serio_bus;
 
 static void serio_add_port(struct serio *serio);
 static void serio_destroy_port(struct serio *serio);
@@ -750,11 +748,15 @@ static int serio_driver_remove(struct device *dev)
         return 0;
 }
 
+static struct bus_type serio_bus = {
+        .name = "serio",
+        .probe = serio_driver_probe,
+        .remove = serio_driver_remove,
+};
+
 void __serio_register_driver(struct serio_driver *drv, struct module *owner)
 {
         drv->driver.bus = &serio_bus;
-        drv->driver.probe = serio_driver_probe;
-        drv->driver.remove = serio_driver_remove;
 
         serio_queue_event(drv, owner, SERIO_REGISTER_DRIVER);
 }
diff --git a/drivers/input/touchscreen/Kconfig b/drivers/input/touchscreen/Kconfig
index 21d55ed4b88a..2c674023a6ac 100644
--- a/drivers/input/touchscreen/Kconfig
+++ b/drivers/input/touchscreen/Kconfig
@@ -11,6 +11,19 @@ menuconfig INPUT_TOUCHSCREEN
 
 if INPUT_TOUCHSCREEN
 
+config TOUCHSCREEN_ADS7846
+        tristate "ADS 7846 based touchscreens"
+        depends on SPI_MASTER
+        help
+          Say Y here if you have a touchscreen interface using the
+          ADS7846 controller, and your board-specific initialization
+          code includes that in its table of SPI devices.
+
+          If unsure, say N (but it's safe to say "Y").
+
+          To compile this driver as a module, choose M here: the
+          module will be called ads7846.
+
 config TOUCHSCREEN_BITSY
         tristate "Compaq iPAQ H3600 (Bitsy) touchscreen"
         depends on SA1100_BITSY
diff --git a/drivers/input/touchscreen/Makefile b/drivers/input/touchscreen/Makefile
index 6842869c9a26..5e5557c43121 100644
--- a/drivers/input/touchscreen/Makefile
+++ b/drivers/input/touchscreen/Makefile
@@ -4,6 +4,7 @@
 
 # Each configuration option enables a list of files.
 
+obj-$(CONFIG_TOUCHSCREEN_ADS7846)       += ads7846.o
 obj-$(CONFIG_TOUCHSCREEN_BITSY) += h3600_ts_input.o
 obj-$(CONFIG_TOUCHSCREEN_CORGI) += corgi_ts.o
 obj-$(CONFIG_TOUCHSCREEN_GUNZE) += gunze.o
diff --git a/drivers/input/touchscreen/ads7846.c b/drivers/input/touchscreen/ads7846.c
new file mode 100644
index 000000000000..dd8c6a9ffc76
--- /dev/null
+++ b/drivers/input/touchscreen/ads7846.c
@@ -0,0 +1,625 @@
+/*
+ * ADS7846 based touchscreen and sensor driver
+ *
+ * Copyright (c) 2005 David Brownell
+ *
+ * Using code from:
+ *  - corgi_ts.c
+ *      Copyright (C) 2004-2005 Richard Purdie
+ *  - omap_ts.[hc], ads7846.h, ts_osk.c
+ *      Copyright (C) 2002 MontaVista Software
+ *      Copyright (C) 2004 Texas Instruments
+ *      Copyright (C) 2005 Dirk Behme
+ *
+ *  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.
+ */
+#include <linux/device.h>
+#include <linux/init.h>
+#include <linux/delay.h>
+#include <linux/input.h>
+#include <linux/interrupt.h>
+#include <linux/slab.h>
+#include <linux/spi/spi.h>
+#include <linux/spi/ads7846.h>
+
+#ifdef  CONFIG_ARM
+#include <asm/mach-types.h>
+#ifdef  CONFIG_ARCH_OMAP
+#include <asm/arch/gpio.h>
+#endif
+
+#else
+#define set_irq_type(irq,type)  do{}while(0)
+#endif
+
+
+/*
+ * This code has been lightly tested on an ads7846.
+ * Support for ads7843 and ads7845 has only been stubbed in.
+ *
+ * Not yet done:  investigate the values reported.  Are x/y/pressure
+ * event values sane enough for X11?  How accurate are the temperature
+ * and voltage readings?  (System-specific calibration should support
+ * accuracy of 0.3 degrees C; otherwise it's 2.0 degrees.)
+ *
+ * app note sbaa036 talks in more detail about accurate sampling...
+ * that ought to help in situations like LCDs inducing noise (which
+ * can also be helped by using synch signals) and more generally.
+ */
+
+#define TS_POLL_PERIOD  msecs_to_jiffies(10)
+
+struct ts_event {
+        /* For portability, we can't read 12 bit values using SPI (which
+         * would make the controller deliver them as native byteorder u16
+         * with msbs zeroed).  Instead, we read them as two 8-byte values,
+         * which need byteswapping then range adjustment.
+         */
+        __be16 x;
+        __be16 y;
+        __be16 z1, z2;
+};
+
+struct ads7846 {
+        struct input_dev        input;
+        char                    phys[32];
+
+        struct spi_device       *spi;
+        u16                     model;
+        u16                     vref_delay_usecs;
+        u16                     x_plate_ohms;
+
+        struct ts_event         tc;
+
+        struct spi_transfer     xfer[8];
+        struct spi_message      msg;
+
+        spinlock_t              lock;
+        struct timer_list       timer;          /* P: lock */
+        unsigned                pendown:1;      /* P: lock */
+        unsigned                pending:1;      /* P: lock */
+// FIXME remove "irq_disabled"
+        unsigned                irq_disabled:1; /* P: lock */
+};
+
+/* leave chip selected when we're done, for quicker re-select? */
+#if     0
+#define CS_CHANGE(xfer) ((xfer).cs_change = 1)
+#else
+#define CS_CHANGE(xfer) ((xfer).cs_change = 0)
+#endif
+
+/*--------------------------------------------------------------------------*/
+
+/* The ADS7846 has touchscreen and other sensors.
+ * Earlier ads784x chips are somewhat compatible.
+ */
+#define ADS_START               (1 << 7)
+#define ADS_A2A1A0_d_y          (1 << 4)        /* differential */
+#define ADS_A2A1A0_d_z1         (3 << 4)        /* differential */
+#define ADS_A2A1A0_d_z2         (4 << 4)        /* differential */
+#define ADS_A2A1A0_d_x          (5 << 4)        /* differential */
+#define ADS_A2A1A0_temp0        (0 << 4)        /* non-differential */
+#define ADS_A2A1A0_vbatt        (2 << 4)        /* non-differential */
+#define ADS_A2A1A0_vaux         (6 << 4)        /* non-differential */
+#define ADS_A2A1A0_temp1        (7 << 4)        /* non-differential */
+#define ADS_8_BIT               (1 << 3)
+#define ADS_12_BIT              (0 << 3)
+#define ADS_SER                 (1 << 2)        /* non-differential */
+#define ADS_DFR                 (0 << 2)        /* differential */
+#define ADS_PD10_PDOWN          (0 << 0)        /* lowpower mode + penirq */
+#define ADS_PD10_ADC_ON         (1 << 0)        /* ADC on */
+#define ADS_PD10_REF_ON         (2 << 0)        /* vREF on + penirq */
+#define ADS_PD10_ALL_ON         (3 << 0)        /* ADC + vREF on */
+
+#define MAX_12BIT       ((1<<12)-1)
+
+/* leave ADC powered up (disables penirq) between differential samples */
+#define READ_12BIT_DFR(x) (ADS_START | ADS_A2A1A0_d_ ## x \
+        | ADS_12_BIT | ADS_DFR)
+
+static const u8 read_y  = READ_12BIT_DFR(y)  | ADS_PD10_ADC_ON;
+static const u8 read_z1 = READ_12BIT_DFR(z1) | ADS_PD10_ADC_ON;
+static const u8 read_z2 = READ_12BIT_DFR(z2) | ADS_PD10_ADC_ON;
+static const u8 read_x  = READ_12BIT_DFR(x)  | ADS_PD10_PDOWN;  /* LAST */
+
+/* single-ended samples need to first power up reference voltage;
+ * we leave both ADC and VREF powered
+ */
+#define READ_12BIT_SER(x) (ADS_START | ADS_A2A1A0_ ## x \
+        | ADS_12_BIT | ADS_SER)
+
+static const u8 ref_on = READ_12BIT_DFR(x) | ADS_PD10_ALL_ON;
+static const u8 ref_off = READ_12BIT_DFR(y) | ADS_PD10_PDOWN;
+
+/*--------------------------------------------------------------------------*/
+
+/*
+ * Non-touchscreen sensors only use single-ended conversions.
+ */
+
+struct ser_req {
+        u8                      command;
+        u16                     scratch;
+        __be16                  sample;
+        struct spi_message      msg;
+        struct spi_transfer     xfer[6];
+};
+
+static int ads7846_read12_ser(struct device *dev, unsigned command)
+{
+        struct spi_device       *spi = to_spi_device(dev);
+        struct ads7846          *ts = dev_get_drvdata(dev);
+        struct ser_req          *req = kzalloc(sizeof *req, SLAB_KERNEL);
+        int                     status;
+        int                     sample;
+        int                     i;
+
+        if (!req)
+                return -ENOMEM;
+
+        INIT_LIST_HEAD(&req->msg.transfers);
+
+        /* activate reference, so it has time to settle; */
+        req->xfer[0].tx_buf = &ref_on;
+        req->xfer[0].len = 1;
+        req->xfer[1].rx_buf = &req->scratch;
+        req->xfer[1].len = 2;
+
+        /*
+         * for external VREF, 0 usec (and assume it's always on);
+         * for 1uF, use 800 usec;
+         * no cap, 100 usec.
+         */
+        req->xfer[1].delay_usecs = ts->vref_delay_usecs;
+
+        /* take sample */
+        req->command = (u8) command;
+        req->xfer[2].tx_buf = &req->command;
+        req->xfer[2].len = 1;
+        req->xfer[3].rx_buf = &req->sample;
+        req->xfer[3].len = 2;
+
+        /* REVISIT:  take a few more samples, and compare ... */
+
+        /* turn off reference */
+        req->xfer[4].tx_buf = &ref_off;
+        req->xfer[4].len = 1;
+        req->xfer[5].rx_buf = &req->scratch;
+        req->xfer[5].len = 2;
+
+        CS_CHANGE(req->xfer[5]);
+
+        /* group all the transfers together, so we can't interfere with
+         * reading touchscreen state; disable penirq while sampling
+         */
+        for (i = 0; i < 6; i++)
+                spi_message_add_tail(&req->xfer[i], &req->msg);
+
+        disable_irq(spi->irq);
+        status = spi_sync(spi, &req->msg);
+        enable_irq(spi->irq);
+
+        if (req->msg.status)
+                status = req->msg.status;
+        sample = be16_to_cpu(req->sample);
+        sample = sample >> 4;
+        kfree(req);
+
+        return status ? status : sample;
+}
+
+#define SHOW(name) static ssize_t \
+name ## _show(struct device *dev, struct device_attribute *attr, char *buf) \
+{ \
+        ssize_t v = ads7846_read12_ser(dev, \
+                        READ_12BIT_SER(name) | ADS_PD10_ALL_ON); \
+        if (v < 0) \
+                return v; \
+        return sprintf(buf, "%u\n", (unsigned) v); \
+} \
+static DEVICE_ATTR(name, S_IRUGO, name ## _show, NULL);
+
+SHOW(temp0)
+SHOW(temp1)
+SHOW(vaux)
+SHOW(vbatt)
+
+/*--------------------------------------------------------------------------*/
+
+/*
+ * PENIRQ only kicks the timer.  The timer only reissues the SPI transfer,
+ * to retrieve touchscreen status.
+ *
+ * The SPI transfer completion callback does the real work.  It reports
+ * touchscreen events and reactivates the timer (or IRQ) as appropriate.
+ */
+
+static void ads7846_rx(void *ads)
+{
+        struct ads7846  *ts = ads;
+        unsigned        Rt;
+        unsigned        sync = 0;
+        u16             x, y, z1, z2;
+        unsigned long   flags;
+
+        /* adjust:  12 bit samples (left aligned), built from
+         * two 8 bit values writen msb-first.
+         */
+        x = be16_to_cpu(ts->tc.x) >> 4;
+        y = be16_to_cpu(ts->tc.y) >> 4;
+        z1 = be16_to_cpu(ts->tc.z1) >> 4;
+        z2 = be16_to_cpu(ts->tc.z2) >> 4;
+
+        /* range filtering */
+        if (x == MAX_12BIT)
+                x = 0;
+
+        if (x && z1 && ts->spi->dev.power.power_state.event == PM_EVENT_ON) {
+                /* compute touch pressure resistance using equation #2 */
+                Rt = z2;
+                Rt -= z1;
+                Rt *= x;
+                Rt *= ts->x_plate_ohms;
+                Rt /= z1;
+                Rt = (Rt + 2047) >> 12;
+        } else
+                Rt = 0;
+
+        /* NOTE:  "pendown" is inferred from pressure; we don't rely on
+         * being able to check nPENIRQ status, or "friendly" trigger modes
+         * (both-edges is much better than just-falling or low-level).
+         *
+         * REVISIT:  some boards may require reading nPENIRQ; it's
+         * needed on 7843.  and 7845 reads pressure differently...
+         *
+         * REVISIT:  the touchscreen might not be connected; this code
+         * won't notice that, even if nPENIRQ never fires ...
+         */
+        if (!ts->pendown && Rt != 0) {
+                input_report_key(&ts->input, BTN_TOUCH, 1);
+                sync = 1;
+        } else if (ts->pendown && Rt == 0) {
+                input_report_key(&ts->input, BTN_TOUCH, 0);
+                sync = 1;
+        }
+
+        if (Rt) {
+                input_report_abs(&ts->input, ABS_X, x);
+                input_report_abs(&ts->input, ABS_Y, y);
+                input_report_abs(&ts->input, ABS_PRESSURE, Rt);
+                sync = 1;
+        }
+        if (sync)
+                input_sync(&ts->input);
+
+#ifdef  VERBOSE
+        if (Rt || ts->pendown)
+                pr_debug("%s: %d/%d/%d%s\n", ts->spi->dev.bus_id,
+                        x, y, Rt, Rt ? "" : " UP");
+#endif
+
+        /* don't retrigger while we're suspended */
+        spin_lock_irqsave(&ts->lock, flags);
+
+        ts->pendown = (Rt != 0);
+        ts->pending = 0;
+
+        if (ts->spi->dev.power.power_state.event == PM_EVENT_ON) {
+                if (ts->pendown)
+                        mod_timer(&ts->timer, jiffies + TS_POLL_PERIOD);
+                else if (ts->irq_disabled) {
+                        ts->irq_disabled = 0;
+                        enable_irq(ts->spi->irq);
+                }
+        }
+
+        spin_unlock_irqrestore(&ts->lock, flags);
+}
+
+static void ads7846_timer(unsigned long handle)
+{
+        struct ads7846  *ts = (void *)handle;
+        int             status = 0;
+        unsigned long   flags;
+
+        spin_lock_irqsave(&ts->lock, flags);
+        if (!ts->pending) {
+                ts->pending = 1;
+                if (!ts->irq_disabled) {
+                        ts->irq_disabled = 1;
+                        disable_irq(ts->spi->irq);
+                }
+                status = spi_async(ts->spi, &ts->msg);
+                if (status)
+                        dev_err(&ts->spi->dev, "spi_async --> %d\n",
+                                        status);
+        }
+        spin_unlock_irqrestore(&ts->lock, flags);
+}
+
+static irqreturn_t ads7846_irq(int irq, void *handle, struct pt_regs *regs)
+{
+        ads7846_timer((unsigned long) handle);
+        return IRQ_HANDLED;
+}
+
+/*--------------------------------------------------------------------------*/
+
+static int
+ads7846_suspend(struct spi_device *spi, pm_message_t message)
+{
+        struct ads7846 *ts = dev_get_drvdata(&spi->dev);
+        unsigned long   flags;
+
+        spin_lock_irqsave(&ts->lock, flags);
+
+        spi->dev.power.power_state = message;
+
+        /* are we waiting for IRQ, or polling? */
+        if (!ts->pendown) {
+                if (!ts->irq_disabled) {
+                        ts->irq_disabled = 1;
+                        disable_irq(ts->spi->irq);
+                }
+        } else {
+                /* polling; force a final SPI completion;
+                 * that will clean things up neatly
+                 */
+                if (!ts->pending)
+                        mod_timer(&ts->timer, jiffies);
+
+                while (ts->pendown || ts->pending) {
+                        spin_unlock_irqrestore(&ts->lock, flags);
+                        udelay(10);
+                        spin_lock_irqsave(&ts->lock, flags);
+                }
+        }
+
+        /* we know the chip's in lowpower mode since we always
+         * leave it that way after every request
+         */
+
+        spin_unlock_irqrestore(&ts->lock, flags);
+        return 0;
+}
+
+static int ads7846_resume(struct spi_device *spi)
+{
+        struct ads7846 *ts = dev_get_drvdata(&spi->dev);
+
+        ts->irq_disabled = 0;
+        enable_irq(ts->spi->irq);
+        spi->dev.power.power_state = PMSG_ON;
+        return 0;
+}
+
+static int __devinit ads7846_probe(struct spi_device *spi)
+{
+        struct ads7846                  *ts;
+        struct ads7846_platform_data    *pdata = spi->dev.platform_data;
+        struct spi_transfer             *x;
+        int                             i;
+
+        if (!spi->irq) {
+                dev_dbg(&spi->dev, "no IRQ?\n");
+                return -ENODEV;
+        }
+
+        if (!pdata) {
+                dev_dbg(&spi->dev, "no platform data?\n");
+                return -ENODEV;
+        }
+
+        /* don't exceed max specified sample rate */
+        if (spi->max_speed_hz > (125000 * 16)) {
+                dev_dbg(&spi->dev, "f(sample) %d KHz?\n",
+                                (spi->max_speed_hz/16)/1000);
+                return -EINVAL;
+        }
+
+        /* We'd set the wordsize to 12 bits ... except that some controllers
+         * will then treat the 8 bit command words as 12 bits (and drop the
+         * four MSBs of the 12 bit result).  Result: inputs must be shifted
+         * to discard the four garbage LSBs.
+         */
+
+        if (!(ts = kzalloc(sizeof(struct ads7846), GFP_KERNEL)))
+                return -ENOMEM;
+
+        dev_set_drvdata(&spi->dev, ts);
+
+        ts->spi = spi;
+        spi->dev.power.power_state = PMSG_ON;
+
+        init_timer(&ts->timer);
+        ts->timer.data = (unsigned long) ts;
+        ts->timer.function = ads7846_timer;
+
+        ts->model = pdata->model ? : 7846;
+        ts->vref_delay_usecs = pdata->vref_delay_usecs ? : 100;
+        ts->x_plate_ohms = pdata->x_plate_ohms ? : 400;
+
+        init_input_dev(&ts->input);
+
+        ts->input.dev = &spi->dev;
+        ts->input.name = "ADS784x Touchscreen";
+        snprintf(ts->phys, sizeof ts->phys, "%s/input0", spi->dev.bus_id);
+        ts->input.phys = ts->phys;
+
+        ts->input.evbit[0] = BIT(EV_KEY) | BIT(EV_ABS);
+        ts->input.keybit[LONG(BTN_TOUCH)] = BIT(BTN_TOUCH);
+        input_set_abs_params(&ts->input, ABS_X,
+                        pdata->x_min ? : 0,
+                        pdata->x_max ? : MAX_12BIT,
+                        0, 0);
+        input_set_abs_params(&ts->input, ABS_Y,
+                        pdata->y_min ? : 0,
+                        pdata->y_max ? : MAX_12BIT,
+                        0, 0);
+        input_set_abs_params(&ts->input, ABS_PRESSURE,
+                        pdata->pressure_min, pdata->pressure_max, 0, 0);
+
+        input_register_device(&ts->input);
+
+        /* set up the transfers to read touchscreen state; this assumes we
+         * use formula #2 for pressure, not #3.
+         */
+        x = ts->xfer;
+
+        /* y- still on; turn on only y+ (and ADC) */
+        x->tx_buf = &read_y;
+        x->len = 1;
+        x++;
+        x->rx_buf = &ts->tc.y;
+        x->len = 2;
+        x++;
+
+        /* turn y+ off, x- on; we'll use formula #2 */
+        if (ts->model == 7846) {
+                x->tx_buf = &read_z1;
+                x->len = 1;
+                x++;
+                x->rx_buf = &ts->tc.z1;
+                x->len = 2;
+                x++;
+
+                x->tx_buf = &read_z2;
+                x->len = 1;
+                x++;
+                x->rx_buf = &ts->tc.z2;
+                x->len = 2;
+                x++;
+        }
+
+        /* turn y- off, x+ on, then leave in lowpower */
+        x->tx_buf = &read_x;
+        x->len = 1;
+        x++;
+        x->rx_buf = &ts->tc.x;
+        x->len = 2;
+        x++;
+
+        CS_CHANGE(x[-1]);
+
+        for (i = 0; i < x - ts->xfer; i++)
+                spi_message_add_tail(&ts->xfer[i], &ts->msg);
+        ts->msg.complete = ads7846_rx;
+        ts->msg.context = ts;
+
+        if (request_irq(spi->irq, ads7846_irq, SA_SAMPLE_RANDOM,
+                                spi->dev.bus_id, ts)) {
+                dev_dbg(&spi->dev, "irq %d busy?\n", spi->irq);
+                input_unregister_device(&ts->input);
+                kfree(ts);
+                return -EBUSY;
+        }
+        set_irq_type(spi->irq, IRQT_FALLING);
+
+        dev_info(&spi->dev, "touchscreen, irq %d\n", spi->irq);
+
+        /* take a first sample, leaving nPENIRQ active; avoid
+         * the touchscreen, in case it's not connected.
+         */
+        (void) ads7846_read12_ser(&spi->dev,
+                          READ_12BIT_SER(vaux) | ADS_PD10_ALL_ON);
+
+        /* ads7843/7845 don't have temperature sensors, and
+         * use the other sensors a bit differently too
+         */
+        if (ts->model == 7846) {
+                device_create_file(&spi->dev, &dev_attr_temp0);
+                device_create_file(&spi->dev, &dev_attr_temp1);
+        }
+        if (ts->model != 7845)
+                device_create_file(&spi->dev, &dev_attr_vbatt);
+        device_create_file(&spi->dev, &dev_attr_vaux);
+
+        return 0;
+}
+
+static int __devexit ads7846_remove(struct spi_device *spi)
+{
+        struct ads7846          *ts = dev_get_drvdata(&spi->dev);
+
+        ads7846_suspend(spi, PMSG_SUSPEND);
+        free_irq(ts->spi->irq, ts);
+        if (ts->irq_disabled)
+                enable_irq(ts->spi->irq);
+
+        if (ts->model == 7846) {
+                device_remove_file(&spi->dev, &dev_attr_temp0);
+                device_remove_file(&spi->dev, &dev_attr_temp1);
+        }
+        if (ts->model != 7845)
+                device_remove_file(&spi->dev, &dev_attr_vbatt);
+        device_remove_file(&spi->dev, &dev_attr_vaux);
+
+        input_unregister_device(&ts->input);
+        kfree(ts);
+
+        dev_dbg(&spi->dev, "unregistered touchscreen\n");
+        return 0;
+}
+
+static struct spi_driver ads7846_driver = {
+        .driver = {
+                .name   = "ads7846",
+                .bus    = &spi_bus_type,
+                .owner  = THIS_MODULE,
+        },
+        .probe          = ads7846_probe,
+        .remove         = __devexit_p(ads7846_remove),
+        .suspend        = ads7846_suspend,
+        .resume         = ads7846_resume,
+};
+
+static int __init ads7846_init(void)
+{
+        /* grr, board-specific init should stay out of drivers!! */
+
+#ifdef  CONFIG_ARCH_OMAP
+        if (machine_is_omap_osk()) {
+                /* GPIO4 = PENIRQ; GPIO6 = BUSY */
+                omap_request_gpio(4);
+                omap_set_gpio_direction(4, 1);
+                omap_request_gpio(6);
+                omap_set_gpio_direction(6, 1);
+        }
+        // also TI 1510 Innovator, bitbanging through FPGA
+        // also Nokia 770
+        // also Palm Tungsten T2
+#endif
+
+        // PXA:
+        // also Dell Axim X50
+        // also HP iPaq H191x/H192x/H415x/H435x
+        // also Intel Lubbock (additional to UCB1400; as temperature sensor)
+        // also Sharp Zaurus C7xx, C8xx (corgi/sheperd/husky)
+
+        // Atmel at91sam9261-EK uses ads7843
+
+        // also various AMD Au1x00 devel boards
+
+        return spi_register_driver(&ads7846_driver);
+}
+module_init(ads7846_init);
+
+static void __exit ads7846_exit(void)
+{
+        spi_unregister_driver(&ads7846_driver);
+
+#ifdef  CONFIG_ARCH_OMAP
+        if (machine_is_omap_osk()) {
+                omap_free_gpio(4);
+                omap_free_gpio(6);
+        }
+#endif
+
+}
+module_exit(ads7846_exit);
+
+MODULE_DESCRIPTION("ADS7846 TouchScreen Driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/isdn/hisax/avm_pci.c b/drivers/isdn/hisax/avm_pci.c
index 5d8ee7368f7b..4abe5ff10e72 100644
--- a/drivers/isdn/hisax/avm_pci.c
+++ b/drivers/isdn/hisax/avm_pci.c
@@ -358,7 +358,7 @@ hdlc_fill_fifo(struct BCState *bcs)
         }
 }
 
-static inline void
+static void
 HDLC_irq(struct BCState *bcs, u_int stat) {
         int len;
         struct sk_buff *skb;
diff --git a/drivers/isdn/hisax/diva.c b/drivers/isdn/hisax/diva.c
index b62d6b30b72b..b0ff1cc97d7c 100644
--- a/drivers/isdn/hisax/diva.c
+++ b/drivers/isdn/hisax/diva.c
@@ -476,7 +476,7 @@ Memhscx_fill_fifo(struct BCState *bcs)
         }
 }
 
-static inline void
+static void
 Memhscx_interrupt(struct IsdnCardState *cs, u_char val, u_char hscx)
 {
         u_char r;
diff --git a/drivers/isdn/hisax/hscx_irq.c b/drivers/isdn/hisax/hscx_irq.c
index 5fe9d42d03a3..7b1ad5e4ecda 100644
--- a/drivers/isdn/hisax/hscx_irq.c
+++ b/drivers/isdn/hisax/hscx_irq.c
@@ -119,7 +119,7 @@ hscx_fill_fifo(struct BCState *bcs)
         }
 }
 
-static inline void
+static void
 hscx_interrupt(struct IsdnCardState *cs, u_char val, u_char hscx)
 {
         u_char r;
@@ -221,7 +221,7 @@ hscx_interrupt(struct IsdnCardState *cs, u_char val, u_char hscx)
         }
 }
 
-static inline void
+static void
 hscx_int_main(struct IsdnCardState *cs, u_char val)
 {
 
diff --git a/drivers/isdn/hisax/jade_irq.c b/drivers/isdn/hisax/jade_irq.c
index 08563400e4fd..1f201af15a0f 100644
--- a/drivers/isdn/hisax/jade_irq.c
+++ b/drivers/isdn/hisax/jade_irq.c
@@ -110,7 +110,7 @@ jade_fill_fifo(struct BCState *bcs)
 }
 
 
-static inline void
+static void
 jade_interrupt(struct IsdnCardState *cs, u_char val, u_char jade)
 {
         u_char r;
diff --git a/drivers/macintosh/macio-adb.c b/drivers/macintosh/macio-adb.c
index cf6a6f2248ac..314fc0830d90 100644
--- a/drivers/macintosh/macio-adb.c
+++ b/drivers/macintosh/macio-adb.c
@@ -17,6 +17,7 @@
 #include <asm/irq.h>
 #include <asm/system.h>
 #include <linux/init.h>
+#include <linux/ioport.h>
 
 struct preg {
         unsigned char r;
@@ -88,24 +89,26 @@ int macio_probe(void)
 int macio_init(void)
 {
         struct device_node *adbs;
+        struct resource r;
 
         adbs = find_compatible_devices("adb", "chrp,adb0");
         if (adbs == 0)
                 return -ENXIO;
 
 #if 0
-        { int i;
+        { int i = 0;
 
         printk("macio_adb_init: node = %p, addrs =", adbs->node);
-        for (i = 0; i < adbs->n_addrs; ++i)
-                printk(" %x(%x)", adbs->addrs[i].address, adbs->addrs[i].size);
+        while(!of_address_to_resource(adbs, i, &r))
+                printk(" %x(%x)", r.start, r.end - r.start);
         printk(", intrs =");
         for (i = 0; i < adbs->n_intrs; ++i)
                 printk(" %x", adbs->intrs[i].line);
         printk("\n"); }
 #endif
-        
-        adb = ioremap(adbs->addrs->address, sizeof(struct adb_regs));
+        if (of_address_to_resource(adbs, 0, &r))
+                return -ENXIO;
+        adb = ioremap(r.start, sizeof(struct adb_regs));
 
         out_8(&adb->ctrl.r, 0);
         out_8(&adb->intr.r, 0);
diff --git a/drivers/macintosh/macio_asic.c b/drivers/macintosh/macio_asic.c
index 2a545ceb523b..ed6d3174d660 100644
--- a/drivers/macintosh/macio_asic.c
+++ b/drivers/macintosh/macio_asic.c
@@ -211,6 +211,9 @@ struct bus_type macio_bus_type = {
        .name    = "macio",
        .match   = macio_bus_match,
        .uevent = macio_uevent,
+       .probe   = macio_device_probe,
+       .remove  = macio_device_remove,
+       .shutdown = macio_device_shutdown,
        .suspend = macio_device_suspend,
        .resume  = macio_device_resume,
        .dev_attrs = macio_dev_attrs,
@@ -528,9 +531,6 @@ int macio_register_driver(struct macio_driver *drv)
         /* initialize common driver fields */
         drv->driver.name = drv->name;
         drv->driver.bus = &macio_bus_type;
-        drv->driver.probe = macio_device_probe;
-        drv->driver.remove = macio_device_remove;
-        drv->driver.shutdown = macio_device_shutdown;
 
         /* register with core */
         count = driver_register(&drv->driver);
diff --git a/drivers/md/bitmap.c b/drivers/md/bitmap.c
index 76a189ceb529..eae4473eadde 100644
--- a/drivers/md/bitmap.c
+++ b/drivers/md/bitmap.c
@@ -200,7 +200,7 @@ out:
 /* if page is completely empty, put it back on the free list, or dealloc it */
 /* if page was hijacked, unmark the flag so it might get alloced next time */
 /* Note: lock should be held when calling this */
-static inline void bitmap_checkfree(struct bitmap *bitmap, unsigned long page)
+static void bitmap_checkfree(struct bitmap *bitmap, unsigned long page)
 {
         char *ptr;
 
diff --git a/drivers/md/dm-crypt.c b/drivers/md/dm-crypt.c
index a601a427885c..e7a650f9ca07 100644
--- a/drivers/md/dm-crypt.c
+++ b/drivers/md/dm-crypt.c
@@ -228,7 +228,7 @@ static struct crypt_iv_operations crypt_iv_essiv_ops = {
 };
 
 
-static inline int
+static int
 crypt_convert_scatterlist(struct crypt_config *cc, struct scatterlist *out,
                           struct scatterlist *in, unsigned int length,
                           int write, sector_t sector)
diff --git a/drivers/md/dm-ioctl.c b/drivers/md/dm-ioctl.c
index 561bda5011e0..1235135b384b 100644
--- a/drivers/md/dm-ioctl.c
+++ b/drivers/md/dm-ioctl.c
@@ -598,7 +598,7 @@ static int dev_create(struct dm_ioctl *param, size_t param_size)
 /*
  * Always use UUID for lookups if it's present, otherwise use name or dev.
  */
-static inline struct hash_cell *__find_device_hash_cell(struct dm_ioctl *param)
+static struct hash_cell *__find_device_hash_cell(struct dm_ioctl *param)
 {
         if (*param->uuid)
                 return __get_uuid_cell(param->uuid);
@@ -608,7 +608,7 @@ static inline struct hash_cell *__find_device_hash_cell(struct dm_ioctl *param)
                 return dm_get_mdptr(huge_decode_dev(param->dev));
 }
 
-static inline struct mapped_device *find_device(struct dm_ioctl *param)
+static struct mapped_device *find_device(struct dm_ioctl *param)
 {
         struct hash_cell *hc;
         struct mapped_device *md = NULL;
diff --git a/drivers/md/dm-snap.c b/drivers/md/dm-snap.c
index 4b9dd8fb1e5c..87727d84dbba 100644
--- a/drivers/md/dm-snap.c
+++ b/drivers/md/dm-snap.c
@@ -691,7 +691,7 @@ static void copy_callback(int read_err, unsigned int write_err, void *context)
 /*
  * Dispatches the copy operation to kcopyd.
  */
-static inline void start_copy(struct pending_exception *pe)
+static void start_copy(struct pending_exception *pe)
 {
         struct dm_snapshot *s = pe->snap;
         struct io_region src, dest;
diff --git a/drivers/md/dm.c b/drivers/md/dm.c
index 097d1e540090..8c16359f8b01 100644
--- a/drivers/md/dm.c
+++ b/drivers/md/dm.c
@@ -293,7 +293,7 @@ struct dm_table *dm_get_table(struct mapped_device *md)
  * Decrements the number of outstanding ios that a bio has been
  * cloned into, completing the original io if necc.
  */
-static inline void dec_pending(struct dm_io *io, int error)
+static void dec_pending(struct dm_io *io, int error)
 {
         if (error)
                 io->error = error;
diff --git a/drivers/md/raid1.c b/drivers/md/raid1.c
index a06ff91f27e2..d39f584cd8b3 100644
--- a/drivers/md/raid1.c
+++ b/drivers/md/raid1.c
@@ -176,7 +176,7 @@ static void put_all_bios(conf_t *conf, r1bio_t *r1_bio)
         }
 }
 
-static inline void free_r1bio(r1bio_t *r1_bio)
+static void free_r1bio(r1bio_t *r1_bio)
 {
         conf_t *conf = mddev_to_conf(r1_bio->mddev);
 
@@ -190,7 +190,7 @@ static inline void free_r1bio(r1bio_t *r1_bio)
         mempool_free(r1_bio, conf->r1bio_pool);
 }
 
-static inline void put_buf(r1bio_t *r1_bio)
+static void put_buf(r1bio_t *r1_bio)
 {
         conf_t *conf = mddev_to_conf(r1_bio->mddev);
         int i;
diff --git a/drivers/md/raid10.c b/drivers/md/raid10.c
index 9e658e519a27..9130d051b474 100644
--- a/drivers/md/raid10.c
+++ b/drivers/md/raid10.c
@@ -176,7 +176,7 @@ static void put_all_bios(conf_t *conf, r10bio_t *r10_bio)
         }
 }
 
-static inline void free_r10bio(r10bio_t *r10_bio)
+static void free_r10bio(r10bio_t *r10_bio)
 {
         conf_t *conf = mddev_to_conf(r10_bio->mddev);
 
@@ -190,7 +190,7 @@ static inline void free_r10bio(r10bio_t *r10_bio)
         mempool_free(r10_bio, conf->r10bio_pool);
 }
 
-static inline void put_buf(r10bio_t *r10_bio)
+static void put_buf(r10bio_t *r10_bio)
 {
         conf_t *conf = mddev_to_conf(r10_bio->mddev);
 
diff --git a/drivers/md/raid5.c b/drivers/md/raid5.c
index 54f4a9847e38..25976bfb6f9c 100644
--- a/drivers/md/raid5.c
+++ b/drivers/md/raid5.c
@@ -69,7 +69,7 @@
 
 static void print_raid5_conf (raid5_conf_t *conf);
 
-static inline void __release_stripe(raid5_conf_t *conf, struct stripe_head *sh)
+static void __release_stripe(raid5_conf_t *conf, struct stripe_head *sh)
 {
         if (atomic_dec_and_test(&sh->count)) {
                 if (!list_empty(&sh->lru))
@@ -118,7 +118,7 @@ static inline void remove_hash(struct stripe_head *sh)
         hlist_del_init(&sh->hash);
 }
 
-static inline void insert_hash(raid5_conf_t *conf, struct stripe_head *sh)
+static void insert_hash(raid5_conf_t *conf, struct stripe_head *sh)
 {
         struct hlist_head *hp = stripe_hash(conf, sh->sector);
 
@@ -178,7 +178,7 @@ static int grow_buffers(struct stripe_head *sh, int num)
 
 static void raid5_build_block (struct stripe_head *sh, int i);
 
-static inline void init_stripe(struct stripe_head *sh, sector_t sector, int pd_idx)
+static void init_stripe(struct stripe_head *sh, sector_t sector, int pd_idx)
 {
         raid5_conf_t *conf = sh->raid_conf;
         int disks = conf->raid_disks, i;
@@ -1415,7 +1415,7 @@ static void handle_stripe(struct stripe_head *sh)
         }
 }
 
-static inline void raid5_activate_delayed(raid5_conf_t *conf)
+static void raid5_activate_delayed(raid5_conf_t *conf)
 {
         if (atomic_read(&conf->preread_active_stripes) < IO_THRESHOLD) {
                 while (!list_empty(&conf->delayed_list)) {
@@ -1431,7 +1431,7 @@ static inline void raid5_activate_delayed(raid5_conf_t *conf)
         }
 }
 
-static inline void activate_bit_delay(raid5_conf_t *conf)
+static void activate_bit_delay(raid5_conf_t *conf)
 {
         /* device_lock is held */
         struct list_head head;
diff --git a/drivers/md/raid6main.c b/drivers/md/raid6main.c
index 8c823d686a60..f618a53b98be 100644
--- a/drivers/md/raid6main.c
+++ b/drivers/md/raid6main.c
@@ -88,7 +88,7 @@ static inline int raid6_next_disk(int disk, int raid_disks)
 
 static void print_raid6_conf (raid6_conf_t *conf);
 
-static inline void __release_stripe(raid6_conf_t *conf, struct stripe_head *sh)
+static void __release_stripe(raid6_conf_t *conf, struct stripe_head *sh)
 {
         if (atomic_dec_and_test(&sh->count)) {
                 if (!list_empty(&sh->lru))
@@ -197,7 +197,7 @@ static int grow_buffers(struct stripe_head *sh, int num)
 
 static void raid6_build_block (struct stripe_head *sh, int i);
 
-static inline void init_stripe(struct stripe_head *sh, sector_t sector, int pd_idx)
+static void init_stripe(struct stripe_head *sh, sector_t sector, int pd_idx)
 {
         raid6_conf_t *conf = sh->raid_conf;
         int disks = conf->raid_disks, i;
@@ -1577,7 +1577,7 @@ static void handle_stripe(struct stripe_head *sh, struct page *tmp_page)
         }
 }
 
-static inline void raid6_activate_delayed(raid6_conf_t *conf)
+static void raid6_activate_delayed(raid6_conf_t *conf)
 {
         if (atomic_read(&conf->preread_active_stripes) < IO_THRESHOLD) {
                 while (!list_empty(&conf->delayed_list)) {
@@ -1593,7 +1593,7 @@ static inline void raid6_activate_delayed(raid6_conf_t *conf)
         }
 }
 
-static inline void activate_bit_delay(raid6_conf_t *conf)
+static void activate_bit_delay(raid6_conf_t *conf)
 {
         /* device_lock is held */
         struct list_head head;
diff --git a/drivers/media/dvb/bt8xx/dvb-bt8xx.c b/drivers/media/dvb/bt8xx/dvb-bt8xx.c
index f65f64b00ff3..44fcbe77c8f9 100644
--- a/drivers/media/dvb/bt8xx/dvb-bt8xx.c
+++ b/drivers/media/dvb/bt8xx/dvb-bt8xx.c
@@ -779,9 +779,8 @@ static int __init dvb_bt8xx_load_card(struct dvb_bt8xx_card *card, u32 type)
         return 0;
 }
 
-static int dvb_bt8xx_probe(struct device *dev)
+static int dvb_bt8xx_probe(struct bttv_sub_device *sub)
 {
-        struct bttv_sub_device *sub = to_bttv_sub_dev(dev);
         struct dvb_bt8xx_card *card;
         struct pci_dev* bttv_pci_dev;
         int ret;
@@ -890,13 +889,13 @@ static int dvb_bt8xx_probe(struct device *dev)
                 return ret;
         }
 
-        dev_set_drvdata(dev, card);
+        dev_set_drvdata(&sub->dev, card);
         return 0;
 }
 
-static int dvb_bt8xx_remove(struct device *dev)
+static int dvb_bt8xx_remove(struct bttv_sub_device *sub)
 {
-        struct dvb_bt8xx_card *card = dev_get_drvdata(dev);
+        struct dvb_bt8xx_card *card = dev_get_drvdata(&sub->dev);
 
         dprintk("dvb_bt8xx: unloading card%d\n", card->bttv_nr);
 
@@ -919,14 +918,14 @@ static int dvb_bt8xx_remove(struct device *dev)
 static struct bttv_sub_driver driver = {
         .drv = {
                 .name           = "dvb-bt8xx",
-                .probe          = dvb_bt8xx_probe,
-                .remove         = dvb_bt8xx_remove,
-                /* FIXME:
-                 * .shutdown    = dvb_bt8xx_shutdown,
-                 * .suspend     = dvb_bt8xx_suspend,
-                 * .resume      = dvb_bt8xx_resume,
-                 */
         },
+        .probe          = dvb_bt8xx_probe,
+        .remove         = dvb_bt8xx_remove,
+        /* FIXME:
+         * .shutdown    = dvb_bt8xx_shutdown,
+         * .suspend     = dvb_bt8xx_suspend,
+         * .resume      = dvb_bt8xx_resume,
+         */
 };
 
 static int __init dvb_bt8xx_init(void)
diff --git a/drivers/media/video/bttv-gpio.c b/drivers/media/video/bttv-gpio.c
index d64accc17b0e..c4d5e2b70c28 100644
--- a/drivers/media/video/bttv-gpio.c
+++ b/drivers/media/video/bttv-gpio.c
@@ -47,9 +47,29 @@ static int bttv_sub_bus_match(struct device *dev, struct device_driver *drv)
         return 0;
 }
 
+static int bttv_sub_probe(struct device *dev)
+{
+        struct bttv_sub_device *sdev = to_bttv_sub_dev(dev);
+        struct bttv_sub_driver *sub = to_bttv_sub_drv(dev->driver);
+
+        return sub->probe ? sub->probe(sdev) : -ENODEV;
+}
+
+static int bttv_sub_remove(struct device *dev)
+{
+        struct bttv_sub_device *sdev = to_bttv_sub_dev(dev);
+        struct bttv_sub_driver *sub = to_bttv_sub_drv(dev->driver);
+
+        if (sub->remove)
+                sub->remove(sdev);
+        return 0;
+}
+
 struct bus_type bttv_sub_bus_type = {
-        .name  = "bttv-sub",
-        .match = &bttv_sub_bus_match,
+        .name   = "bttv-sub",
+        .match  = &bttv_sub_bus_match,
+        .probe  = bttv_sub_probe,
+        .remove = bttv_sub_remove,
 };
 EXPORT_SYMBOL(bttv_sub_bus_type);
 
diff --git a/drivers/media/video/bttv.h b/drivers/media/video/bttv.h
index e370d74f2a1b..9908c8e0c951 100644
--- a/drivers/media/video/bttv.h
+++ b/drivers/media/video/bttv.h
@@ -365,6 +365,8 @@ struct bttv_sub_device {
 struct bttv_sub_driver {
         struct device_driver   drv;
         char                   wanted[BUS_ID_SIZE];
+        int                    (*probe)(struct bttv_sub_device *sub);
+        void                   (*remove)(struct bttv_sub_device *sub);
         void                   (*gpio_irq)(struct bttv_sub_device *sub);
 };
 #define to_bttv_sub_drv(x) container_of((x), struct bttv_sub_driver, drv)
diff --git a/drivers/media/video/tvp5150.c b/drivers/media/video/tvp5150.c
index e86b522938fd..9094fa9f2ecb 100644
--- a/drivers/media/video/tvp5150.c
+++ b/drivers/media/video/tvp5150.c
@@ -93,7 +93,7 @@ struct tvp5150 {
         int sat;
 };
 
-static inline int tvp5150_read(struct i2c_client *c, unsigned char addr)
+static int tvp5150_read(struct i2c_client *c, unsigned char addr)
 {
         unsigned char buffer[1];
         int rc;
diff --git a/drivers/message/fusion/Kconfig b/drivers/message/fusion/Kconfig
index 1883d22cffeb..e67cf15e9c39 100644
--- a/drivers/message/fusion/Kconfig
+++ b/drivers/message/fusion/Kconfig
@@ -23,6 +23,7 @@ config FUSION_FC
         tristate "Fusion MPT ScsiHost drivers for FC"
         depends on PCI && SCSI
         select FUSION
+        select SCSI_FC_ATTRS
         ---help---
           SCSI HOST support for a Fiber Channel host adapters.
 
diff --git a/drivers/message/fusion/lsi/mpi.h b/drivers/message/fusion/lsi/mpi.h
index b61e3d175070..02cdc840a06b 100644
--- a/drivers/message/fusion/lsi/mpi.h
+++ b/drivers/message/fusion/lsi/mpi.h
@@ -6,7 +6,7 @@
  *          Title:  MPI Message independent structures and definitions
  *  Creation Date:  July 27, 2000
  *
- *    mpi.h Version:  01.05.08
+ *    mpi.h Version:  01.05.10
  *
  *  Version History
  *  ---------------
@@ -74,6 +74,8 @@
  *  06-24-05  01.05.08  Added function codes for SCSI IO 32 and
  *                      TargetAssistExtended requests.
  *                      Added EEDP IOCStatus codes.
+ *  08-03-05  01.05.09  Bumped MPI_HEADER_VERSION_UNIT.
+ *  08-30-05  01.05.10  Added 2 new IOCStatus codes for Target.
  *  --------------------------------------------------------------------------
  */
 
@@ -104,7 +106,7 @@
 /* Note: The major versions of 0xe0 through 0xff are reserved */
 
 /* versioning for this MPI header set */
-#define MPI_HEADER_VERSION_UNIT             (0x0A)
+#define MPI_HEADER_VERSION_UNIT             (0x0C)
 #define MPI_HEADER_VERSION_DEV              (0x00)
 #define MPI_HEADER_VERSION_UNIT_MASK        (0xFF00)
 #define MPI_HEADER_VERSION_UNIT_SHIFT       (8)
@@ -711,6 +713,8 @@ typedef struct _MSG_DEFAULT_REPLY
 #define MPI_IOCSTATUS_TARGET_DATA_OFFSET_ERROR   (0x006D)
 #define MPI_IOCSTATUS_TARGET_TOO_MUCH_WRITE_DATA (0x006E)
 #define MPI_IOCSTATUS_TARGET_IU_TOO_SHORT        (0x006F)
+#define MPI_IOCSTATUS_TARGET_ACK_NAK_TIMEOUT     (0x0070)
+#define MPI_IOCSTATUS_TARGET_NAK_RECEIVED        (0x0071)
 
 /****************************************************************************/
 /*  Additional FCP target values (obsolete)                                 */
@@ -745,7 +749,7 @@ typedef struct _MSG_DEFAULT_REPLY
 #define MPI_IOCSTATUS_LAN_CANCELED              (0x0087)
 
 /****************************************************************************/
-/*  Serial Attached SCSI values                                                              */
+/*  Serial Attached SCSI values                                             */
 /****************************************************************************/
 
 #define MPI_IOCSTATUS_SAS_SMP_REQUEST_FAILED    (0x0090)
diff --git a/drivers/message/fusion/lsi/mpi_cnfg.h b/drivers/message/fusion/lsi/mpi_cnfg.h
index d8339896f734..b1becec27e1b 100644
--- a/drivers/message/fusion/lsi/mpi_cnfg.h
+++ b/drivers/message/fusion/lsi/mpi_cnfg.h
@@ -6,7 +6,7 @@
  *          Title:  MPI Config message, structures, and Pages
  *  Creation Date:  July 27, 2000
  *
- *    mpi_cnfg.h Version:  01.05.09
+ *    mpi_cnfg.h Version:  01.05.11
  *
  *  Version History
  *  ---------------
@@ -249,6 +249,23 @@
  *                      Added OwnerDevHandle and Flags field to SAS PHY Page 0.
  *                      Added IOC GPIO Flags define to SAS Enclosure Page 0.
  *                      Fixed the value for MPI_SAS_IOUNIT1_CONTROL_DEV_SATA_SUPPORT.
+ *  08-03-05  01.05.10  Removed ISDataScrubRate and ISResyncRate from
+ *                      Manufacturing Page 4.
+ *                      Added MPI_IOUNITPAGE1_SATA_WRITE_CACHE_DISABLE bit.
+ *                      Added NumDevsPerEnclosure field to SAS IO Unit page 2.
+ *                      Added MPI_SAS_IOUNIT2_FLAGS_HOST_ASSIGNED_PHYS_MAP
+ *                      define.
+ *                      Added EnclosureHandle field to SAS Expander page 0.
+ *                      Removed redundant NumTableEntriesProg field from SAS
+ *                      Expander Page 1.
+ *  08-30-05  01.05.11  Added DeviceID for FC949E and changed the DeviceID for
+ *                      SAS1078.
+ *                      Added more defines for Manufacturing Page 4 Flags field.
+ *                      Added more defines for IOCSettings and added
+ *                      ExpanderSpinup field to Bios Page 1.
+ *                      Added postpone SATA Init bit to SAS IO Unit Page 1
+ *                      ControlFlags.
+ *                      Changed LogEntry format for Log Page 0.
  *  --------------------------------------------------------------------------
  */
 
@@ -494,7 +511,7 @@ typedef struct _MSG_CONFIG_REPLY
 #define MPI_MANUFACTPAGE_DEVICEID_FC929X            (0x0626)
 #define MPI_MANUFACTPAGE_DEVICEID_FC939X            (0x0642)
 #define MPI_MANUFACTPAGE_DEVICEID_FC949X            (0x0640)
-#define MPI_MANUFACTPAGE_DEVICEID_FC949ES           (0x0646)
+#define MPI_MANUFACTPAGE_DEVICEID_FC949E            (0x0646)
 /* SCSI */
 #define MPI_MANUFACTPAGE_DEVID_53C1030              (0x0030)
 #define MPI_MANUFACTPAGE_DEVID_53C1030ZC            (0x0031)
@@ -510,7 +527,7 @@ typedef struct _MSG_CONFIG_REPLY
 #define MPI_MANUFACTPAGE_DEVID_SAS1066E             (0x005A)
 #define MPI_MANUFACTPAGE_DEVID_SAS1068              (0x0054)
 #define MPI_MANUFACTPAGE_DEVID_SAS1068E             (0x0058)
-#define MPI_MANUFACTPAGE_DEVID_SAS1078              (0x0060)
+#define MPI_MANUFACTPAGE_DEVID_SAS1078              (0x0062)
 
 
 typedef struct _CONFIG_PAGE_MANUFACTURING_0
@@ -602,9 +619,7 @@ typedef struct _CONFIG_PAGE_MANUFACTURING_4
     U32                             IMVolumeSettings;   /* 50h */
     U32                             Reserved3;          /* 54h */
     U32                             Reserved4;          /* 58h */
-    U8                              ISDataScrubRate;    /* 5Ch */
-    U8                              ISResyncRate;       /* 5Dh */
-    U16                             Reserved5;          /* 5Eh */
+    U32                             Reserved5;          /* 5Ch */
     U8                              IMEDataScrubRate;   /* 60h */
     U8                              IMEResyncRate;      /* 61h */
     U16                             Reserved6;          /* 62h */
@@ -616,9 +631,14 @@ typedef struct _CONFIG_PAGE_MANUFACTURING_4
 } CONFIG_PAGE_MANUFACTURING_4, MPI_POINTER PTR_CONFIG_PAGE_MANUFACTURING_4,
   ManufacturingPage4_t, MPI_POINTER pManufacturingPage4_t;
 
-#define MPI_MANUFACTURING4_PAGEVERSION                  (0x02)
+#define MPI_MANUFACTURING4_PAGEVERSION                  (0x03)
 
 /* defines for the Flags field */
+#define MPI_MANPAGE4_IME_DISABLE                        (0x20)
+#define MPI_MANPAGE4_IM_DISABLE                         (0x10)
+#define MPI_MANPAGE4_IS_DISABLE                         (0x08)
+#define MPI_MANPAGE4_IR_MODEPAGE8_DISABLE               (0x04)
+#define MPI_MANPAGE4_IM_RESYNC_CACHE_ENABLE             (0x02)
 #define MPI_MANPAGE4_IR_NO_MIX_SAS_SATA                 (0x01)
 
 
@@ -669,7 +689,7 @@ typedef struct _CONFIG_PAGE_IO_UNIT_1
 } CONFIG_PAGE_IO_UNIT_1, MPI_POINTER PTR_CONFIG_PAGE_IO_UNIT_1,
   IOUnitPage1_t, MPI_POINTER pIOUnitPage1_t;
 
-#define MPI_IOUNITPAGE1_PAGEVERSION                     (0x01)
+#define MPI_IOUNITPAGE1_PAGEVERSION                     (0x02)
 
 /* IO Unit Page 1 Flags defines */
 #define MPI_IOUNITPAGE1_MULTI_FUNCTION                  (0x00000000)
@@ -681,7 +701,7 @@ typedef struct _CONFIG_PAGE_IO_UNIT_1
 #define MPI_IOUNITPAGE1_DISABLE_IR                      (0x00000040)
 #define MPI_IOUNITPAGE1_FORCE_32                        (0x00000080)
 #define MPI_IOUNITPAGE1_NATIVE_COMMAND_Q_DISABLE        (0x00000100)
-
+#define MPI_IOUNITPAGE1_SATA_WRITE_CACHE_DISABLE        (0x00000200)
 
 typedef struct _MPI_ADAPTER_INFO
 {
@@ -968,7 +988,8 @@ typedef struct _CONFIG_PAGE_BIOS_1
     U32                     Reserved1;                  /* 0Ch */
     U32                     DeviceSettings;             /* 10h */
     U16                     NumberOfDevices;            /* 14h */
-    U16                     Reserved2;                  /* 16h */
+    U8                      ExpanderSpinup;             /* 16h */
+    U8                      Reserved2;                  /* 17h */
     U16                     IOTimeoutBlockDevicesNonRM; /* 18h */
     U16                     IOTimeoutSequential;        /* 1Ah */
     U16                     IOTimeoutOther;             /* 1Ch */
@@ -976,7 +997,7 @@ typedef struct _CONFIG_PAGE_BIOS_1
 } CONFIG_PAGE_BIOS_1, MPI_POINTER PTR_CONFIG_PAGE_BIOS_1,
   BIOSPage1_t, MPI_POINTER pBIOSPage1_t;
 
-#define MPI_BIOSPAGE1_PAGEVERSION                       (0x02)
+#define MPI_BIOSPAGE1_PAGEVERSION                       (0x03)
 
 /* values for the BiosOptions field */
 #define MPI_BIOSPAGE1_OPTIONS_SPI_ENABLE                (0x00000400)
@@ -985,8 +1006,15 @@ typedef struct _CONFIG_PAGE_BIOS_1
 #define MPI_BIOSPAGE1_OPTIONS_DISABLE_BIOS              (0x00000001)
 
 /* values for the IOCSettings field */
+#define MPI_BIOSPAGE1_IOCSET_MASK_INITIAL_SPINUP_DELAY  (0x0F000000)
+#define MPI_BIOSPAGE1_IOCSET_SHIFT_INITIAL_SPINUP_DELAY (24)
+
 #define MPI_BIOSPAGE1_IOCSET_MASK_PORT_ENABLE_DELAY     (0x00F00000)
 #define MPI_BIOSPAGE1_IOCSET_SHIFT_PORT_ENABLE_DELAY    (20)
+
+#define MPI_BIOSPAGE1_IOCSET_AUTO_PORT_ENABLE           (0x00080000)
+#define MPI_BIOSPAGE1_IOCSET_DIRECT_ATTACH_SPINUP_MODE  (0x00040000)
+
 #define MPI_BIOSPAGE1_IOCSET_MASK_BOOT_PREFERENCE       (0x00030000)
 #define MPI_BIOSPAGE1_IOCSET_ENCLOSURE_SLOT_BOOT        (0x00000000)
 #define MPI_BIOSPAGE1_IOCSET_SAS_ADDRESS_BOOT           (0x00010000)
@@ -1016,6 +1044,11 @@ typedef struct _CONFIG_PAGE_BIOS_1
 #define MPI_BIOSPAGE1_DEVSET_DISABLE_NON_RM_LUN         (0x00000002)
 #define MPI_BIOSPAGE1_DEVSET_DISABLE_OTHER_LUN          (0x00000001)
 
+/* defines for the ExpanderSpinup field */
+#define MPI_BIOSPAGE1_EXPSPINUP_MASK_MAX_TARGET         (0xF0)
+#define MPI_BIOSPAGE1_EXPSPINUP_SHIFT_MAX_TARGET        (4)
+#define MPI_BIOSPAGE1_EXPSPINUP_MASK_DELAY              (0x0F)
+
 typedef struct _MPI_BOOT_DEVICE_ADAPTER_ORDER
 {
     U32         Reserved1;                              /* 00h */
@@ -1233,13 +1266,13 @@ typedef struct _CONFIG_PAGE_SCSI_PORT_0
 
 #define MPI_SCSIPORTPAGE0_CAP_SHIFT_MIN_SYNC_PERIOD     (8)
 #define MPI_SCSIPORTPAGE0_CAP_GET_MIN_SYNC_PERIOD(Cap)      \
-    (  ((Cap) & MPI_SCSIPORTPAGE0_CAP_MASK_MIN_SYNC_PERIOD) \
+    (  ((Cap) & MPI_SCSIPORTPAGE0_CAP_MIN_SYNC_PERIOD_MASK) \
     >> MPI_SCSIPORTPAGE0_CAP_SHIFT_MIN_SYNC_PERIOD          \
     )
 #define MPI_SCSIPORTPAGE0_CAP_MAX_SYNC_OFFSET_MASK      (0x00FF0000)
 #define MPI_SCSIPORTPAGE0_CAP_SHIFT_MAX_SYNC_OFFSET     (16)
 #define MPI_SCSIPORTPAGE0_CAP_GET_MAX_SYNC_OFFSET(Cap)      \
-    (  ((Cap) & MPI_SCSIPORTPAGE0_CAP_MASK_MAX_SYNC_OFFSET) \
+    (  ((Cap) & MPI_SCSIPORTPAGE0_CAP_MAX_SYNC_OFFSET_MASK) \
     >> MPI_SCSIPORTPAGE0_CAP_SHIFT_MAX_SYNC_OFFSET          \
     )
 #define MPI_SCSIPORTPAGE0_CAP_IDP                       (0x08000000)
@@ -2370,47 +2403,48 @@ typedef struct _CONFIG_PAGE_SAS_IO_UNIT_1
 } CONFIG_PAGE_SAS_IO_UNIT_1, MPI_POINTER PTR_CONFIG_PAGE_SAS_IO_UNIT_1,
   SasIOUnitPage1_t, MPI_POINTER pSasIOUnitPage1_t;
 
-#define MPI_SASIOUNITPAGE1_PAGEVERSION      (0x04)
+#define MPI_SASIOUNITPAGE1_PAGEVERSION      (0x05)
 
 /* values for SAS IO Unit Page 1 ControlFlags */
-#define MPI_SAS_IOUNIT1_CONTROL_DEVICE_SELF_TEST        (0x8000)
-#define MPI_SAS_IOUNIT1_CONTROL_SATA_3_0_MAX            (0x4000)
-#define MPI_SAS_IOUNIT1_CONTROL_SATA_1_5_MAX            (0x2000)
-#define MPI_SAS_IOUNIT1_CONTROL_SATA_SW_PRESERVE        (0x1000)
-#define MPI_SAS_IOUNIT1_CONTROL_DISABLE_SAS_HASH        (0x0800)
-
-#define MPI_SAS_IOUNIT1_CONTROL_MASK_DEV_SUPPORT        (0x0600)
-#define MPI_SAS_IOUNIT1_CONTROL_SHIFT_DEV_SUPPORT       (9)
-#define MPI_SAS_IOUNIT1_CONTROL_DEV_SUPPORT_BOTH        (0x00)
-#define MPI_SAS_IOUNIT1_CONTROL_DEV_SAS_SUPPORT         (0x01)
-#define MPI_SAS_IOUNIT1_CONTROL_DEV_SATA_SUPPORT        (0x02)
-
-#define MPI_SAS_IOUNIT1_CONTROL_SATA_48BIT_LBA_REQUIRED (0x0080)
-#define MPI_SAS_IOUNIT1_CONTROL_SATA_SMART_REQUIRED     (0x0040)
-#define MPI_SAS_IOUNIT1_CONTROL_SATA_NCQ_REQUIRED       (0x0020)
-#define MPI_SAS_IOUNIT1_CONTROL_SATA_FUA_REQUIRED       (0x0010)
-#define MPI_SAS_IOUNIT1_CONTROL_PHY_ENABLE_ORDER_HIGH   (0x0008)
-#define MPI_SAS_IOUNIT1_CONTROL_SUBTRACTIVE_ILLEGAL     (0x0004)
-#define MPI_SAS_IOUNIT1_CONTROL_FIRST_LVL_DISC_ONLY     (0x0002)
-#define MPI_SAS_IOUNIT1_CONTROL_CLEAR_AFFILIATION       (0x0001)
+#define MPI_SAS_IOUNIT1_CONTROL_DEVICE_SELF_TEST            (0x8000)
+#define MPI_SAS_IOUNIT1_CONTROL_SATA_3_0_MAX                (0x4000)
+#define MPI_SAS_IOUNIT1_CONTROL_SATA_1_5_MAX                (0x2000)
+#define MPI_SAS_IOUNIT1_CONTROL_SATA_SW_PRESERVE            (0x1000)
+#define MPI_SAS_IOUNIT1_CONTROL_DISABLE_SAS_HASH            (0x0800)
+
+#define MPI_SAS_IOUNIT1_CONTROL_MASK_DEV_SUPPORT            (0x0600)
+#define MPI_SAS_IOUNIT1_CONTROL_SHIFT_DEV_SUPPORT           (9)
+#define MPI_SAS_IOUNIT1_CONTROL_DEV_SUPPORT_BOTH            (0x00)
+#define MPI_SAS_IOUNIT1_CONTROL_DEV_SAS_SUPPORT             (0x01)
+#define MPI_SAS_IOUNIT1_CONTROL_DEV_SATA_SUPPORT            (0x02)
+
+#define MPI_SAS_IOUNIT1_CONTROL_POSTPONE_SATA_INIT          (0x0100)
+#define MPI_SAS_IOUNIT1_CONTROL_SATA_48BIT_LBA_REQUIRED     (0x0080)
+#define MPI_SAS_IOUNIT1_CONTROL_SATA_SMART_REQUIRED         (0x0040)
+#define MPI_SAS_IOUNIT1_CONTROL_SATA_NCQ_REQUIRED           (0x0020)
+#define MPI_SAS_IOUNIT1_CONTROL_SATA_FUA_REQUIRED           (0x0010)
+#define MPI_SAS_IOUNIT1_CONTROL_PHY_ENABLE_ORDER_HIGH       (0x0008)
+#define MPI_SAS_IOUNIT1_CONTROL_SUBTRACTIVE_ILLEGAL         (0x0004)
+#define MPI_SAS_IOUNIT1_CONTROL_FIRST_LVL_DISC_ONLY         (0x0002)
+#define MPI_SAS_IOUNIT1_CONTROL_CLEAR_AFFILIATION           (0x0001)
 
 /* values for SAS IO Unit Page 1 PortFlags */
-#define MPI_SAS_IOUNIT1_PORT_FLAGS_0_TARGET_IOC_NUM     (0x00)
-#define MPI_SAS_IOUNIT1_PORT_FLAGS_1_TARGET_IOC_NUM     (0x04)
-#define MPI_SAS_IOUNIT1_PORT_FLAGS_AUTO_PORT_CONFIG     (0x01)
+#define MPI_SAS_IOUNIT1_PORT_FLAGS_0_TARGET_IOC_NUM         (0x00)
+#define MPI_SAS_IOUNIT1_PORT_FLAGS_1_TARGET_IOC_NUM         (0x04)
+#define MPI_SAS_IOUNIT1_PORT_FLAGS_AUTO_PORT_CONFIG         (0x01)
 
 /* values for SAS IO Unit Page 0 PhyFlags */
-#define MPI_SAS_IOUNIT1_PHY_FLAGS_PHY_DISABLE           (0x04)
-#define MPI_SAS_IOUNIT1_PHY_FLAGS_TX_INVERT             (0x02)
-#define MPI_SAS_IOUNIT1_PHY_FLAGS_RX_INVERT             (0x01)
+#define MPI_SAS_IOUNIT1_PHY_FLAGS_PHY_DISABLE               (0x04)
+#define MPI_SAS_IOUNIT1_PHY_FLAGS_TX_INVERT                 (0x02)
+#define MPI_SAS_IOUNIT1_PHY_FLAGS_RX_INVERT                 (0x01)
 
 /* values for SAS IO Unit Page 0 MaxMinLinkRate */
-#define MPI_SAS_IOUNIT1_MAX_RATE_MASK                   (0xF0)
-#define MPI_SAS_IOUNIT1_MAX_RATE_1_5                    (0x80)
-#define MPI_SAS_IOUNIT1_MAX_RATE_3_0                    (0x90)
-#define MPI_SAS_IOUNIT1_MIN_RATE_MASK                   (0x0F)
-#define MPI_SAS_IOUNIT1_MIN_RATE_1_5                    (0x08)
-#define MPI_SAS_IOUNIT1_MIN_RATE_3_0                    (0x09)
+#define MPI_SAS_IOUNIT1_MAX_RATE_MASK                       (0xF0)
+#define MPI_SAS_IOUNIT1_MAX_RATE_1_5                        (0x80)
+#define MPI_SAS_IOUNIT1_MAX_RATE_3_0                        (0x90)
+#define MPI_SAS_IOUNIT1_MIN_RATE_MASK                       (0x0F)
+#define MPI_SAS_IOUNIT1_MIN_RATE_1_5                        (0x08)
+#define MPI_SAS_IOUNIT1_MIN_RATE_3_0                        (0x09)
 
 /* see mpi_sas.h for values for SAS IO Unit Page 1 ControllerPhyDeviceInfo values */
 
@@ -2418,16 +2452,18 @@ typedef struct _CONFIG_PAGE_SAS_IO_UNIT_1
 typedef struct _CONFIG_PAGE_SAS_IO_UNIT_2
 {
     CONFIG_EXTENDED_PAGE_HEADER         Header;                 /* 00h */
-    U32                                 Reserved1;              /* 08h */
+    U8                                  NumDevsPerEnclosure;    /* 08h */
+    U8                                  Reserved1;              /* 09h */
+    U16                                 Reserved2;              /* 0Ah */
     U16                                 MaxPersistentIDs;       /* 0Ch */
     U16                                 NumPersistentIDsUsed;   /* 0Eh */
     U8                                  Status;                 /* 10h */
     U8                                  Flags;                  /* 11h */
-    U16                                 MaxNumPhysicalMappedIDs;/* 12h */              /* 12h */
+    U16                                 MaxNumPhysicalMappedIDs;/* 12h */
 } CONFIG_PAGE_SAS_IO_UNIT_2, MPI_POINTER PTR_CONFIG_PAGE_SAS_IO_UNIT_2,
   SasIOUnitPage2_t, MPI_POINTER pSasIOUnitPage2_t;
 
-#define MPI_SASIOUNITPAGE2_PAGEVERSION      (0x04)
+#define MPI_SASIOUNITPAGE2_PAGEVERSION      (0x05)
 
 /* values for SAS IO Unit Page 2 Status field */
 #define MPI_SAS_IOUNIT2_STATUS_DISABLED_PERSISTENT_MAPPINGS (0x02)
@@ -2441,6 +2477,7 @@ typedef struct _CONFIG_PAGE_SAS_IO_UNIT_2
 #define MPI_SAS_IOUNIT2_FLAGS_NO_PHYS_MAP                   (0x00)
 #define MPI_SAS_IOUNIT2_FLAGS_DIRECT_ATTACH_PHYS_MAP        (0x01)
 #define MPI_SAS_IOUNIT2_FLAGS_ENCLOSURE_SLOT_PHYS_MAP       (0x02)
+#define MPI_SAS_IOUNIT2_FLAGS_HOST_ASSIGNED_PHYS_MAP        (0x07)
 
 #define MPI_SAS_IOUNIT2_FLAGS_RESERVE_ID_0_FOR_BOOT         (0x10)
 #define MPI_SAS_IOUNIT2_FLAGS_DA_STARTING_SLOT              (0x20)
@@ -2473,7 +2510,7 @@ typedef struct _CONFIG_PAGE_SAS_EXPANDER_0
     CONFIG_EXTENDED_PAGE_HEADER         Header;                 /* 00h */
     U8                                  PhysicalPort;           /* 08h */
     U8                                  Reserved1;              /* 09h */
-    U16                                 Reserved2;              /* 0Ah */
+    U16                                 EnclosureHandle;        /* 0Ah */
     U64                                 SASAddress;             /* 0Ch */
     U32                                 DiscoveryStatus;        /* 14h */
     U16                                 DevHandle;              /* 18h */
@@ -2487,7 +2524,7 @@ typedef struct _CONFIG_PAGE_SAS_EXPANDER_0
 } CONFIG_PAGE_SAS_EXPANDER_0, MPI_POINTER PTR_CONFIG_PAGE_SAS_EXPANDER_0,
   SasExpanderPage0_t, MPI_POINTER pSasExpanderPage0_t;
 
-#define MPI_SASEXPANDER0_PAGEVERSION        (0x02)
+#define MPI_SASEXPANDER0_PAGEVERSION        (0x03)
 
 /* values for SAS Expander Page 0 DiscoveryStatus field */
 #define MPI_SAS_EXPANDER0_DS_LOOP_DETECTED              (0x00000001)
@@ -2527,9 +2564,9 @@ typedef struct _CONFIG_PAGE_SAS_EXPANDER_1
     U8                          NegotiatedLinkRate;     /* 1Fh */
     U8                          PhyIdentifier;          /* 20h */
     U8                          AttachedPhyIdentifier;  /* 21h */
-    U8                          NumTableEntriesProg;    /* 22h */
+    U8                          Reserved3;              /* 22h */
     U8                          DiscoveryInfo;          /* 23h */
-    U32                         Reserved3;              /* 24h */
+    U32                         Reserved4;              /* 24h */
 } CONFIG_PAGE_SAS_EXPANDER_1, MPI_POINTER PTR_CONFIG_PAGE_SAS_EXPANDER_1,
   SasExpanderPage1_t, MPI_POINTER pSasExpanderPage1_t;
 
@@ -2766,16 +2803,15 @@ typedef struct _CONFIG_PAGE_SAS_ENCLOSURE_0
 #define MPI_LOG_0_NUM_LOG_ENTRIES        (1)
 #endif
 
-#define MPI_LOG_0_LOG_DATA_LENGTH        (20)
+#define MPI_LOG_0_LOG_DATA_LENGTH        (0x1C)
 
 typedef struct _MPI_LOG_0_ENTRY
 {
-    U64         WWID;                               /* 00h */
-    U32         TimeStamp;                          /* 08h */
-    U32         Reserved1;                          /* 0Ch */
-    U16         LogSequence;                        /* 10h */
-    U16         LogEntryQualifier;                  /* 12h */
-    U8          LogData[MPI_LOG_0_LOG_DATA_LENGTH]; /* 14h */
+    U32         TimeStamp;                          /* 00h */
+    U32         Reserved1;                          /* 04h */
+    U16         LogSequence;                        /* 08h */
+    U16         LogEntryQualifier;                  /* 0Ah */
+    U8          LogData[MPI_LOG_0_LOG_DATA_LENGTH]; /* 0Ch */
 } MPI_LOG_0_ENTRY, MPI_POINTER PTR_MPI_LOG_0_ENTRY,
   MpiLog0Entry_t, MPI_POINTER pMpiLog0Entry_t;
 
@@ -2794,7 +2830,7 @@ typedef struct _CONFIG_PAGE_LOG_0
 } CONFIG_PAGE_LOG_0, MPI_POINTER PTR_CONFIG_PAGE_LOG_0,
   LogPage0_t, MPI_POINTER pLogPage0_t;
 
-#define MPI_LOG_0_PAGEVERSION               (0x00)
+#define MPI_LOG_0_PAGEVERSION               (0x01)
 
 
 #endif
diff --git a/drivers/message/fusion/lsi/mpi_history.txt b/drivers/message/fusion/lsi/mpi_history.txt
index 1a30ef16adb4..4a5f8dd1d766 100644
--- a/drivers/message/fusion/lsi/mpi_history.txt
+++ b/drivers/message/fusion/lsi/mpi_history.txt
@@ -6,25 +6,25 @@
  Copyright (c) 2000-2005 LSI Logic Corporation.
 
  ---------------------------------------
- Header Set Release Version:    01.05.10
- Header Set Release Date:       03-11-05
+ Header Set Release Version:    01.05.12
+ Header Set Release Date:       08-30-05
  ---------------------------------------
 
  Filename               Current version     Prior version
  ----------             ---------------     -------------
- mpi.h                  01.05.08            01.05.07
- mpi_ioc.h              01.05.09            01.05.08
- mpi_cnfg.h             01.05.09            01.05.08
- mpi_init.h             01.05.05            01.05.04
- mpi_targ.h             01.05.05            01.05.04
+ mpi.h                  01.05.10            01.05.09
+ mpi_ioc.h              01.05.10            01.05.09
+ mpi_cnfg.h             01.05.11            01.05.10
+ mpi_init.h             01.05.06            01.05.06
+ mpi_targ.h             01.05.05            01.05.05
  mpi_fc.h               01.05.01            01.05.01
  mpi_lan.h              01.05.01            01.05.01
  mpi_raid.h             01.05.02            01.05.02
  mpi_tool.h             01.05.03            01.05.03
  mpi_inb.h              01.05.01            01.05.01
- mpi_sas.h              01.05.01            01.05.01
- mpi_type.h             01.05.01            01.05.01
- mpi_history.txt        01.05.09            01.05.09
+ mpi_sas.h              01.05.02            01.05.01
+ mpi_type.h             01.05.02            01.05.01
+ mpi_history.txt        01.05.12            01.05.11
 
 
  *  Date      Version   Description
@@ -91,6 +91,8 @@ mpi.h
  *  06-24-05  01.05.08  Added function codes for SCSI IO 32 and
  *                      TargetAssistExtended requests.
  *                      Added EEDP IOCStatus codes.
+ *  08-03-05  01.05.09  Bumped MPI_HEADER_VERSION_UNIT.
+ *  08-30-05  01.05.10  Added 2 new IOCStatus codes for Target.
  *  --------------------------------------------------------------------------
 
 mpi_ioc.h
@@ -164,6 +166,10 @@ mpi_ioc.h
  *                      Removed IOCFacts Reply EEDP Capability bit.
  *  06-24-05  01.05.09  Added 5 new IOCFacts Reply IOCCapabilities bits.
  *                      Added Max SATA Targets to SAS Discovery Error event.
+ *  08-30-05  01.05.10  Added 4 new events and their event data structures.
+ *                      Added new ReasonCode value for SAS Device Status Change
+ *                      event.
+ *                      Added new family code for FC949E.
  *  --------------------------------------------------------------------------
 
 mpi_cnfg.h
@@ -402,6 +408,23 @@ mpi_cnfg.h
  *                      Added OwnerDevHandle and Flags field to SAS PHY Page 0.
  *                      Added IOC GPIO Flags define to SAS Enclosure Page 0.
  *                      Fixed the value for MPI_SAS_IOUNIT1_CONTROL_DEV_SATA_SUPPORT.
+ *  08-03-05  01.05.10  Removed ISDataScrubRate and ISResyncRate from
+ *                      Manufacturing Page 4.
+ *                      Added MPI_IOUNITPAGE1_SATA_WRITE_CACHE_DISABLE bit.
+ *                      Added NumDevsPerEnclosure field to SAS IO Unit page 2.
+ *                      Added MPI_SAS_IOUNIT2_FLAGS_HOST_ASSIGNED_PHYS_MAP
+ *                      define.
+ *                      Added EnclosureHandle field to SAS Expander page 0.
+ *                      Removed redundant NumTableEntriesProg field from SAS
+ *                      Expander Page 1.
+ *  08-30-05  01.05.11  Added DeviceID for FC949E and changed the DeviceID for
+ *                      SAS1078.
+ *                      Added more defines for Manufacturing Page 4 Flags field.
+ *                      Added more defines for IOCSettings and added
+ *                      ExpanderSpinup field to Bios Page 1.
+ *                      Added postpone SATA Init bit to SAS IO Unit Page 1
+ *                      ControlFlags.
+ *                      Changed LogEntry format for Log Page 0.
  *  --------------------------------------------------------------------------
 
 mpi_init.h
@@ -442,6 +465,8 @@ mpi_init.h
  *                      addressing.
  *  06-24-05  01.05.05  Added SCSI IO 32 structures and defines.
  *                      Added four new defines for SEP SlotStatus.
+ *  08-03-05  01.05.06  Fixed some MPI_SCSIIO32_MSGFLGS_ defines to make them
+ *                      unique in the first 32 characters.
  *  --------------------------------------------------------------------------
 
 mpi_targ.h
@@ -582,6 +607,9 @@ mpi_inb.h
 
 mpi_sas.h
  *  08-19-04  01.05.01  Original release.
+ *  08-30-05  01.05.02  Added DeviceInfo bit for SEP.
+ *                      Added PrimFlags and Primitive field to SAS IO Unit
+ *                      Control request, and added a new operation code.
  *  --------------------------------------------------------------------------
 
 mpi_type.h
@@ -592,24 +620,25 @@ mpi_type.h
  *  08-08-01  01.02.01  Original release for v1.2 work.
  *  05-11-04  01.03.01  Original release for MPI v1.3.
  *  08-19-04  01.05.01  Original release for MPI v1.5.
+ *  08-30-05  01.05.02  Added PowerPC option to #ifdef's.
  *  --------------------------------------------------------------------------
 
 mpi_history.txt         Parts list history
 
-Filename    01.05.10  01.05.09
-----------  --------  --------
-mpi.h       01.05.08  01.05.07
-mpi_ioc.h   01.05.09  01.05.08
-mpi_cnfg.h  01.05.09  01.05.08
-mpi_init.h  01.05.05  01.05.04
-mpi_targ.h  01.05.05  01.05.04
-mpi_fc.h    01.05.01  01.05.01
-mpi_lan.h   01.05.01  01.05.01
-mpi_raid.h  01.05.02  01.05.02
-mpi_tool.h  01.05.03  01.05.03
-mpi_inb.h   01.05.01  01.05.01
-mpi_sas.h   01.05.01  01.05.01
-mpi_type.h  01.05.01  01.05.01
+Filename    01.05.12  01.05.11  01.05.10  01.05.09
+----------  --------  --------  --------  --------
+mpi.h       01.05.10  01.05.09  01.05.08  01.05.07
+mpi_ioc.h   01.05.10  01.05.09  01.05.09  01.05.08
+mpi_cnfg.h  01.05.11  01.05.10  01.05.09  01.05.08
+mpi_init.h  01.05.06  01.05.06  01.05.05  01.05.04
+mpi_targ.h  01.05.05  01.05.05  01.05.05  01.05.04
+mpi_fc.h    01.05.01  01.05.01  01.05.01  01.05.01
+mpi_lan.h   01.05.01  01.05.01  01.05.01  01.05.01
+mpi_raid.h  01.05.02  01.05.02  01.05.02  01.05.02
+mpi_tool.h  01.05.03  01.05.03  01.05.03  01.05.03
+mpi_inb.h   01.05.01  01.05.01  01.05.01  01.05.01
+mpi_sas.h   01.05.02  01.05.01  01.05.01  01.05.01
+mpi_type.h  01.05.02  01.05.01  01.05.01  01.05.01
 
 Filename    01.05.08   01.05.07   01.05.06   01.05.05   01.05.04   01.05.03
 ----------  --------   --------   --------   --------   --------   --------
diff --git a/drivers/message/fusion/lsi/mpi_init.h b/drivers/message/fusion/lsi/mpi_init.h
index d5af75afbd94..68941f459ca3 100644
--- a/drivers/message/fusion/lsi/mpi_init.h
+++ b/drivers/message/fusion/lsi/mpi_init.h
@@ -6,7 +6,7 @@
  *          Title:  MPI initiator mode messages and structures
  *  Creation Date:  June 8, 2000
  *
- *    mpi_init.h Version:  01.05.05
+ *    mpi_init.h Version:  01.05.06
  *
  *  Version History
  *  ---------------
@@ -50,6 +50,8 @@
  *                      addressing.
  *  06-24-05  01.05.05  Added SCSI IO 32 structures and defines.
  *                      Added four new defines for SEP SlotStatus.
+ *  08-03-05  01.05.06  Fixed some MPI_SCSIIO32_MSGFLGS_ defines to make them
+ *                      unique in the first 32 characters.
  *  --------------------------------------------------------------------------
  */
 
@@ -290,8 +292,8 @@ typedef struct _MSG_SCSI_IO32_REQUEST
 
 /* SCSI IO 32 MsgFlags bits */
 #define MPI_SCSIIO32_MSGFLGS_SENSE_WIDTH                (0x01)
-#define MPI_SCSIIO32_MSGFLGS_SENSE_WIDTH_32             (0x00)
-#define MPI_SCSIIO32_MSGFLGS_SENSE_WIDTH_64             (0x01)
+#define MPI_SCSIIO32_MSGFLGS_32_SENSE_WIDTH             (0x00)
+#define MPI_SCSIIO32_MSGFLGS_64_SENSE_WIDTH             (0x01)
 
 #define MPI_SCSIIO32_MSGFLGS_SENSE_LOCATION             (0x02)
 #define MPI_SCSIIO32_MSGFLGS_SENSE_LOC_HOST             (0x00)
diff --git a/drivers/message/fusion/lsi/mpi_ioc.h b/drivers/message/fusion/lsi/mpi_ioc.h
index 93b70e2b4266..2c5f43fa7c73 100644
--- a/drivers/message/fusion/lsi/mpi_ioc.h
+++ b/drivers/message/fusion/lsi/mpi_ioc.h
@@ -6,7 +6,7 @@
  *          Title:  MPI IOC, Port, Event, FW Download, and FW Upload messages
  *  Creation Date:  August 11, 2000
  *
- *    mpi_ioc.h Version:  01.05.09
+ *    mpi_ioc.h Version:  01.05.10
  *
  *  Version History
  *  ---------------
@@ -83,6 +83,10 @@
  *                      Removed IOCFacts Reply EEDP Capability bit.
  *  06-24-05  01.05.09  Added 5 new IOCFacts Reply IOCCapabilities bits.
  *                      Added Max SATA Targets to SAS Discovery Error event.
+ *  08-30-05  01.05.10  Added 4 new events and their event data structures.
+ *                      Added new ReasonCode value for SAS Device Status Change
+ *                      event.
+ *                      Added new family code for FC949E.
  *  --------------------------------------------------------------------------
  */
 
@@ -464,6 +468,10 @@ typedef struct _MSG_EVENT_ACK_REPLY
 #define MPI_EVENT_PERSISTENT_TABLE_FULL     (0x00000011)
 #define MPI_EVENT_SAS_PHY_LINK_STATUS       (0x00000012)
 #define MPI_EVENT_SAS_DISCOVERY_ERROR       (0x00000013)
+#define MPI_EVENT_IR_RESYNC_UPDATE          (0x00000014)
+#define MPI_EVENT_IR2                       (0x00000015)
+#define MPI_EVENT_SAS_DISCOVERY             (0x00000016)
+#define MPI_EVENT_LOG_ENTRY_ADDED           (0x00000021)
 
 /* AckRequired field values */
 
@@ -480,6 +488,29 @@ typedef struct _EVENT_DATA_EVENT_CHANGE
 } EVENT_DATA_EVENT_CHANGE, MPI_POINTER PTR_EVENT_DATA_EVENT_CHANGE,
   EventDataEventChange_t, MPI_POINTER pEventDataEventChange_t;
 
+/* LogEntryAdded Event data */
+
+/* this structure matches MPI_LOG_0_ENTRY in mpi_cnfg.h */
+#define MPI_EVENT_DATA_LOG_ENTRY_DATA_LENGTH    (0x1C)
+typedef struct _EVENT_DATA_LOG_ENTRY
+{
+    U32         TimeStamp;                          /* 00h */
+    U32         Reserved1;                          /* 04h */
+    U16         LogSequence;                        /* 08h */
+    U16         LogEntryQualifier;                  /* 0Ah */
+    U8          LogData[MPI_EVENT_DATA_LOG_ENTRY_DATA_LENGTH]; /* 0Ch */
+} EVENT_DATA_LOG_ENTRY, MPI_POINTER PTR_EVENT_DATA_LOG_ENTRY,
+  MpiEventDataLogEntry_t, MPI_POINTER pMpiEventDataLogEntry_t;
+
+typedef struct _EVENT_DATA_LOG_ENTRY_ADDED
+{
+    U16                     LogSequence;            /* 00h */
+    U16                     Reserved1;              /* 02h */
+    U32                     Reserved2;              /* 04h */
+    EVENT_DATA_LOG_ENTRY    LogEntry;               /* 08h */
+} EVENT_DATA_LOG_ENTRY_ADDED, MPI_POINTER PTR_EVENT_DATA_LOG_ENTRY_ADDED,
+  MpiEventDataLogEntryAdded_t, MPI_POINTER pMpiEventDataLogEntryAdded_t;
+
 /* SCSI Event data for Port, Bus and Device forms */
 
 typedef struct _EVENT_DATA_SCSI
@@ -538,6 +569,7 @@ typedef struct _EVENT_DATA_SAS_DEVICE_STATUS_CHANGE
 #define MPI_EVENT_SAS_DEV_STAT_RC_SMART_DATA            (0x05)
 #define MPI_EVENT_SAS_DEV_STAT_RC_NO_PERSIST_ADDED      (0x06)
 #define MPI_EVENT_SAS_DEV_STAT_RC_UNSUPPORTED           (0x07)
+#define MPI_EVENT_SAS_DEV_STAT_RC_INTERNAL_DEVICE_RESET (0x08)
 
 
 /* SCSI Event data for Queue Full event */
@@ -579,6 +611,79 @@ typedef struct _EVENT_DATA_RAID
 #define MPI_EVENT_RAID_RC_SMART_DATA                    (0x0A)
 #define MPI_EVENT_RAID_RC_REPLACE_ACTION_STARTED        (0x0B)
 
+
+/* MPI Integrated RAID Resync Update Event data */
+
+typedef struct _MPI_EVENT_DATA_IR_RESYNC_UPDATE
+{
+    U8                      VolumeID;                   /* 00h */
+    U8                      VolumeBus;                  /* 01h */
+    U8                      ResyncComplete;             /* 02h */
+    U8                      Reserved1;                  /* 03h */
+    U32                     Reserved2;                  /* 04h */
+} MPI_EVENT_DATA_IR_RESYNC_UPDATE,
+  MPI_POINTER PTR_MPI_EVENT_DATA_IR_RESYNC_UPDATE,
+  MpiEventDataIrResyncUpdate_t, MPI_POINTER pMpiEventDataIrResyncUpdate_t;
+
+/* MPI IR2 Event data */
+
+/* MPI_LD_STATE or MPI_PD_STATE */
+typedef struct _IR2_STATE_CHANGED
+{
+    U16                 PreviousState;  /* 00h */
+    U16                 NewState;       /* 02h */
+} IR2_STATE_CHANGED, MPI_POINTER PTR_IR2_STATE_CHANGED;
+
+typedef struct _IR2_PD_INFO
+{
+    U16                 DeviceHandle;           /* 00h */
+    U8                  TruncEnclosureHandle;   /* 02h */
+    U8                  TruncatedSlot;          /* 03h */
+} IR2_PD_INFO, MPI_POINTER PTR_IR2_PD_INFO;
+
+typedef union _MPI_IR2_RC_EVENT_DATA
+{
+    IR2_STATE_CHANGED   StateChanged;
+    U32                 Lba;
+    IR2_PD_INFO         PdInfo;
+} MPI_IR2_RC_EVENT_DATA, MPI_POINTER PTR_MPI_IR2_RC_EVENT_DATA;
+
+typedef struct _MPI_EVENT_DATA_IR2
+{
+    U8                      TargetID;             /* 00h */
+    U8                      Bus;                  /* 01h */
+    U8                      ReasonCode;           /* 02h */
+    U8                      PhysDiskNum;          /* 03h */
+    MPI_IR2_RC_EVENT_DATA   IR2EventData;         /* 04h */
+} MPI_EVENT_DATA_IR2, MPI_POINTER PTR_MPI_EVENT_DATA_IR2,
+  MpiEventDataIR2_t, MPI_POINTER pMpiEventDataIR2_t;
+
+/* MPI IR2 Event data ReasonCode values */
+#define MPI_EVENT_IR2_RC_LD_STATE_CHANGED           (0x01)
+#define MPI_EVENT_IR2_RC_PD_STATE_CHANGED           (0x02)
+#define MPI_EVENT_IR2_RC_BAD_BLOCK_TABLE_FULL       (0x03)
+#define MPI_EVENT_IR2_RC_PD_INSERTED                (0x04)
+#define MPI_EVENT_IR2_RC_PD_REMOVED                 (0x05)
+#define MPI_EVENT_IR2_RC_FOREIGN_CFG_DETECTED       (0x06)
+#define MPI_EVENT_IR2_RC_REBUILD_MEDIUM_ERROR       (0x07)
+
+/* defines for logical disk states */
+#define MPI_LD_STATE_OPTIMAL                        (0x00)
+#define MPI_LD_STATE_DEGRADED                       (0x01)
+#define MPI_LD_STATE_FAILED                         (0x02)
+#define MPI_LD_STATE_MISSING                        (0x03)
+#define MPI_LD_STATE_OFFLINE                        (0x04)
+
+/* defines for physical disk states */
+#define MPI_PD_STATE_ONLINE                         (0x00)
+#define MPI_PD_STATE_MISSING                        (0x01)
+#define MPI_PD_STATE_NOT_COMPATIBLE                 (0x02)
+#define MPI_PD_STATE_FAILED                         (0x03)
+#define MPI_PD_STATE_INITIALIZING                   (0x04)
+#define MPI_PD_STATE_OFFLINE_AT_HOST_REQUEST        (0x05)
+#define MPI_PD_STATE_FAILED_AT_HOST_REQUEST         (0x06)
+#define MPI_PD_STATE_OFFLINE_FOR_ANOTHER_REASON     (0xFF)
+
 /* MPI Link Status Change Event data */
 
 typedef struct _EVENT_DATA_LINK_STATUS
@@ -660,6 +765,20 @@ typedef struct _EVENT_DATA_SAS_PHY_LINK_STATUS
 #define MPI_EVENT_SAS_PLS_LR_RATE_1_5                       (0x08)
 #define MPI_EVENT_SAS_PLS_LR_RATE_3_0                       (0x09)
 
+/* SAS Discovery Event data */
+
+typedef struct _EVENT_DATA_SAS_DISCOVERY
+{
+    U32                     DiscoveryStatus;            /* 00h */
+    U32                     Reserved1;                  /* 04h */
+} EVENT_DATA_SAS_DISCOVERY, MPI_POINTER PTR_EVENT_DATA_SAS_DISCOVERY,
+  EventDataSasDiscovery_t, MPI_POINTER pEventDataSasDiscovery_t;
+
+#define MPI_EVENT_SAS_DSCVRY_COMPLETE                       (0x00000000)
+#define MPI_EVENT_SAS_DSCVRY_IN_PROGRESS                    (0x00000001)
+#define MPI_EVENT_SAS_DSCVRY_PHY_BITS_MASK                  (0xFFFF0000)
+#define MPI_EVENT_SAS_DSCVRY_PHY_BITS_SHIFT                 (16)
+
 /* SAS Discovery Errror Event data */
 
 typedef struct _EVENT_DATA_DISCOVERY_ERROR
@@ -869,6 +988,7 @@ typedef struct _MPI_FW_HEADER
 #define MPI_FW_HEADER_PID_FAMILY_919XL_FC       (0x0003) /* 919XL and 929XL */
 #define MPI_FW_HEADER_PID_FAMILY_939X_FC        (0x0004) /* 939X and 949X   */
 #define MPI_FW_HEADER_PID_FAMILY_959_FC         (0x0005)
+#define MPI_FW_HEADER_PID_FAMILY_949E_FC        (0x0006)
 /* SAS */
 #define MPI_FW_HEADER_PID_FAMILY_1064_SAS       (0x0001)
 #define MPI_FW_HEADER_PID_FAMILY_1068_SAS       (0x0002)
diff --git a/drivers/message/fusion/lsi/mpi_log_fc.h b/drivers/message/fusion/lsi/mpi_log_fc.h
new file mode 100644
index 000000000000..dc98d46f9071
--- /dev/null
+++ b/drivers/message/fusion/lsi/mpi_log_fc.h
@@ -0,0 +1,89 @@
+/*
+ *  Copyright (c) 2000-2001 LSI Logic Corporation. All rights reserved.
+ *
+ *  NAME:           fc_log.h
+ *  SUMMARY:        MPI IocLogInfo definitions for the SYMFC9xx chips
+ *  DESCRIPTION:    Contains the enumerated list of values that may be returned
+ *                  in the IOCLogInfo field of a MPI Default Reply Message.
+ *
+ *  CREATION DATE:  6/02/2000
+ *  ID:             $Id: fc_log.h,v 4.6 2001/07/26 14:41:33 sschremm Exp $
+ */
+
+
+/*
+ * MpiIocLogInfo_t enum
+ *
+ * These 32 bit values are used in the IOCLogInfo field of the MPI reply
+ * messages.
+ * The value is 0xabcccccc where
+ *          a = The type of log info as per the MPI spec. Since these codes are
+ *              all for Fibre Channel this value will always be 2.
+ *          b = Specifies a subclass of the firmware where
+ *                  0 = FCP Initiator
+ *                  1 = FCP Target
+ *                  2 = LAN
+ *                  3 = MPI Message Layer
+ *                  4 = FC Link
+ *                  5 = Context Manager
+ *                  6 = Invalid Field Offset
+ *                  7 = State Change Info
+ *                  all others are reserved for future use
+ *          c = A specific value within the subclass.
+ *
+ * NOTE: Any new values should be added to the end of each subclass so that the
+ *       codes remain consistent across firmware releases.
+ */
+typedef enum _MpiIocLogInfoFc
+{
+    MPI_IOCLOGINFO_FC_INIT_BASE                     = 0x20000000,
+    MPI_IOCLOGINFO_FC_INIT_ERROR_OUT_OF_ORDER_FRAME = 0x20000001, /* received an out of order frame - unsupported */
+    MPI_IOCLOGINFO_FC_INIT_ERROR_BAD_START_OF_FRAME = 0x20000002, /* Bad Rx Frame, bad start of frame primative */
+    MPI_IOCLOGINFO_FC_INIT_ERROR_BAD_END_OF_FRAME   = 0x20000003, /* Bad Rx Frame, bad end of frame primative */
+    MPI_IOCLOGINFO_FC_INIT_ERROR_OVER_RUN           = 0x20000004, /* Bad Rx Frame, overrun */
+    MPI_IOCLOGINFO_FC_INIT_ERROR_RX_OTHER           = 0x20000005, /* Other errors caught by IOC which require retries */
+    MPI_IOCLOGINFO_FC_INIT_ERROR_SUBPROC_DEAD       = 0x20000006, /* Main processor could not initialize sub-processor */
+    MPI_IOCLOGINFO_FC_INIT_ERROR_RX_OVERRUN         = 0x20000007, /* Scatter Gather overrun  */
+    MPI_IOCLOGINFO_FC_INIT_ERROR_RX_BAD_STATUS      = 0x20000008, /* Receiver detected context mismatch via invalid header */
+    MPI_IOCLOGINFO_FC_INIT_ERROR_RX_UNEXPECTED_FRAME= 0x20000009, /* CtxMgr detected unsupported frame type  */
+    MPI_IOCLOGINFO_FC_INIT_ERROR_LINK_FAILURE       = 0x2000000A, /* Link failure occurred  */
+    MPI_IOCLOGINFO_FC_INIT_ERROR_TX_TIMEOUT         = 0x2000000B, /* Transmitter timeout error */
+
+    MPI_IOCLOGINFO_FC_TARGET_BASE                   = 0x21000000,
+    MPI_IOCLOGINFO_FC_TARGET_NO_PDISC               = 0x21000001, /* not sent because we are waiting for a PDISC from the initiator */
+    MPI_IOCLOGINFO_FC_TARGET_NO_LOGIN               = 0x21000002, /* not sent because we are not logged in to the remote node */
+    MPI_IOCLOGINFO_FC_TARGET_DOAR_KILLED_BY_LIP     = 0x21000003, /* Data Out, Auto Response, not sent due to a LIP */
+    MPI_IOCLOGINFO_FC_TARGET_DIAR_KILLED_BY_LIP     = 0x21000004, /* Data In, Auto Response, not sent due to a LIP */
+    MPI_IOCLOGINFO_FC_TARGET_DIAR_MISSING_DATA      = 0x21000005, /* Data In, Auto Response, missing data frames */
+    MPI_IOCLOGINFO_FC_TARGET_DONR_KILLED_BY_LIP     = 0x21000006, /* Data Out, No Response, not sent due to a LIP */
+    MPI_IOCLOGINFO_FC_TARGET_WRSP_KILLED_BY_LIP     = 0x21000007, /* Auto-response after a write not sent due to a LIP */
+    MPI_IOCLOGINFO_FC_TARGET_DINR_KILLED_BY_LIP     = 0x21000008, /* Data In, No Response, not completed due to a LIP */
+    MPI_IOCLOGINFO_FC_TARGET_DINR_MISSING_DATA      = 0x21000009, /* Data In, No Response, missing data frames */
+    MPI_IOCLOGINFO_FC_TARGET_MRSP_KILLED_BY_LIP     = 0x2100000a, /* Manual Response not sent due to a LIP */
+    MPI_IOCLOGINFO_FC_TARGET_NO_CLASS_3             = 0x2100000b, /* not sent because remote node does not support Class 3 */
+    MPI_IOCLOGINFO_FC_TARGET_LOGIN_NOT_VALID        = 0x2100000c, /* not sent because login to remote node not validated */
+    MPI_IOCLOGINFO_FC_TARGET_FROM_OUTBOUND          = 0x2100000e, /* cleared from the outbound queue after a logout */
+    MPI_IOCLOGINFO_FC_TARGET_WAITING_FOR_DATA_IN    = 0x2100000f, /* cleared waiting for data after a logout */
+
+    MPI_IOCLOGINFO_FC_LAN_BASE                      = 0x22000000,
+    MPI_IOCLOGINFO_FC_LAN_TRANS_SGL_MISSING         = 0x22000001, /* Transaction Context Sgl Missing */
+    MPI_IOCLOGINFO_FC_LAN_TRANS_WRONG_PLACE         = 0x22000002, /* Transaction Context found before an EOB */
+    MPI_IOCLOGINFO_FC_LAN_TRANS_RES_BITS_SET        = 0x22000003, /* Transaction Context value has reserved bits set */
+    MPI_IOCLOGINFO_FC_LAN_WRONG_SGL_FLAG            = 0x22000004, /* Invalid SGL Flags */
+
+    MPI_IOCLOGINFO_FC_MSG_BASE                      = 0x23000000,
+
+    MPI_IOCLOGINFO_FC_LINK_BASE                     = 0x24000000,
+    MPI_IOCLOGINFO_FC_LINK_LOOP_INIT_TIMEOUT        = 0x24000001, /* Loop initialization timed out */
+    MPI_IOCLOGINFO_FC_LINK_ALREADY_INITIALIZED      = 0x24000002, /* Another system controller already initialized the loop */
+    MPI_IOCLOGINFO_FC_LINK_LINK_NOT_ESTABLISHED     = 0x24000003, /* Not synchronized to signal or still negotiating (possible cable problem) */
+    MPI_IOCLOGINFO_FC_LINK_CRC_ERROR                = 0x24000004, /* CRC check detected error on received frame */
+
+    MPI_IOCLOGINFO_FC_CTX_BASE                      = 0x25000000,
+
+    MPI_IOCLOGINFO_FC_INVALID_FIELD_BYTE_OFFSET     = 0x26000000, /* The lower 24 bits give the byte offset of the field in the request message that is invalid */
+    MPI_IOCLOGINFO_FC_INVALID_FIELD_MAX_OFFSET      = 0x26ffffff,
+
+    MPI_IOCLOGINFO_FC_STATE_CHANGE                  = 0x27000000  /* The lower 24 bits give additional information concerning state change */
+
+} MpiIocLogInfoFc_t;
diff --git a/drivers/message/fusion/lsi/mpi_log_sas.h b/drivers/message/fusion/lsi/mpi_log_sas.h
new file mode 100644
index 000000000000..9259d1ad6e6e
--- /dev/null
+++ b/drivers/message/fusion/lsi/mpi_log_sas.h
@@ -0,0 +1,162 @@
+
+/***************************************************************************
+ *                                                                         *
+ *  Copyright 2003 LSI Logic Corporation.  All rights reserved.            *
+ *                                                                         *
+ *  This file is confidential and a trade secret of LSI Logic.  The        *
+ *  receipt of or possession of this file does not convey any rights to    *
+ *  reproduce or disclose its contents or to manufacture, use, or sell     *
+ *  anything it may describe, in whole, or in part, without the specific   *
+ *  written consent of LSI Logic Corporation.                              *
+ *                                                                         *
+ ***************************************************************************
+ *
+ *           Name:  iopiIocLogInfo.h
+ *          Title:  SAS Firmware IOP Interface IOC Log Info Definitions
+ *     Programmer:  Guy Kendall
+ *  Creation Date:  September 24, 2003
+ *
+ *  Version History
+ *  ---------------
+ *
+ *  Last Updated
+ *  -------------
+ *  Version         %version: 22 %
+ *  Date Updated    %date_modified: %
+ *  Programmer      %created_by: nperucca %
+ *
+ *  Date      Who   Description
+ *  --------  ---   -------------------------------------------------------
+ *  09/24/03  GWK   Initial version
+ *
+ *
+ * Description
+ * ------------
+ * This include file contains SAS firmware interface IOC Log Info codes
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#ifndef IOPI_IOCLOGINFO_H_INCLUDED
+#define IOPI_IOCLOGINFO_H_INCLUDED
+
+
+/****************************************************************************/
+/*  IOC LOGINFO defines, 0x00000000 - 0x0FFFFFFF                            */
+/*  Format:                                                                 */
+/*      Bits 31-28: MPI_IOCLOGINFO_TYPE_SAS (3)                             */
+/*      Bits 27-24: IOC_LOGINFO_ORIGINATOR: 0=IOP, 1=PL, 2=IR               */
+/*      Bits 23-16: LOGINFO_CODE                                            */
+/*      Bits 15-0:  LOGINFO_CODE Specific                                   */
+/****************************************************************************/
+
+/****************************************************************************/
+/* IOC_LOGINFO_ORIGINATOR defines                                           */
+/****************************************************************************/
+#define IOC_LOGINFO_ORIGINATOR_IOP                      (0x00000000)
+#define IOC_LOGINFO_ORIGINATOR_PL                       (0x01000000)
+#define IOC_LOGINFO_ORIGINATOR_IR                       (0x02000000)
+
+/****************************************************************************/
+/* LOGINFO_CODE defines                                                     */
+/****************************************************************************/
+#define IOC_LOGINFO_CODE_MASK                           (0x00FF0000)
+#define IOC_LOGINFO_CODE_SHIFT                          (16)
+
+/****************************************************************************/
+/* IOP LOGINFO_CODE defines, valid if IOC_LOGINFO_ORIGINATOR = IOP          */
+/****************************************************************************/
+#define IOP_LOGINFO_CODE_INVALID_SAS_ADDRESS            (0x00010000)
+#define IOP_LOGINFO_CODE_UNUSED2                        (0x00020000)
+#define IOP_LOGINFO_CODE_CONFIG_INVALID_PAGE            (0x00030000)
+#define IOP_LOGINFO_CODE_CONFIG_INVALID_PAGE_RT         (0x00030100) /* Route Table Entry not found */
+#define IOP_LOGINFO_CODE_CONFIG_INVALID_PAGE_PN         (0x00030200) /* Invalid Page Number */
+#define IOP_LOGINFO_CODE_CONFIG_INVALID_PAGE_FORM       (0x00030300) /* Invalid FORM */
+#define IOP_LOGINFO_CODE_CONFIG_INVALID_PAGE_PT         (0x00030400) /* Invalid Page Type */
+#define IOP_LOGINFO_CODE_CONFIG_INVALID_PAGE_DNM        (0x00030500) /* Device Not Mapped */
+#define IOP_LOGINFO_CODE_CONFIG_INVALID_PAGE_PERSIST    (0x00030600) /* Persistent Page not found */
+#define IOP_LOGINFO_CODE_CONFIG_INVALID_PAGE_DEFAULT    (0x00030700) /* Default Page not found */
+#define IOP_LOGINFO_CODE_TASK_TERMINATED                (0x00050000)
+
+
+/****************************************************************************/
+/* PL LOGINFO_CODE defines, valid if IOC_LOGINFO_ORIGINATOR = PL            */
+/****************************************************************************/
+#define PL_LOGINFO_CODE_OPEN_FAILURE                        (0x00010000)
+#define PL_LOGINFO_CODE_INVALID_SGL                         (0x00020000)
+#define PL_LOGINFO_CODE_WRONG_REL_OFF_OR_FRAME_LENGTH       (0x00030000)
+#define PL_LOGINFO_CODE_FRAME_XFER_ERROR                    (0x00040000)
+#define PL_LOGINFO_CODE_TX_FM_CONNECTED_LOW                 (0x00050000)
+#define PL_LOGINFO_CODE_SATA_NON_NCQ_RW_ERR_BIT_SET         (0x00060000)
+#define PL_LOGINFO_CODE_SATA_READ_LOG_RECEIVE_DATA_ERR      (0x00070000)
+#define PL_LOGINFO_CODE_SATA_NCQ_FAIL_ALL_CMDS_AFTR_ERR     (0x00080000)
+#define PL_LOGINFO_CODE_SATA_ERR_IN_RCV_SET_DEV_BIT_FIS     (0x00090000)
+#define PL_LOGINFO_CODE_RX_FM_INVALID_MESSAGE               (0x000A0000)
+#define PL_LOGINFO_CODE_RX_CTX_MESSAGE_VALID_ERROR          (0x000B0000)
+#define PL_LOGINFO_CODE_RX_FM_CURRENT_FRAME_ERROR           (0x000C0000)
+#define PL_LOGINFO_CODE_SATA_LINK_DOWN                      (0x000D0000)
+#define PL_LOGINFO_CODE_DISCOVERY_SATA_INIT_W_IOS           (0x000E0000)
+#define PL_LOGINFO_CODE_CONFIG_INVALID_PAGE                 (0x000F0000)
+#define PL_LOGINFO_CODE_CONFIG_INVALID_PAGE_PT              (0x000F0100) /* Invalid Page Type */
+#define PL_LOGINFO_CODE_CONFIG_INVALID_PAGE_NUM_PHYS        (0x000F0200) /* Invalid Number of Phys */
+#define PL_LOGINFO_CODE_CONFIG_INVALID_PAGE_NOT_IMP         (0x000F0300) /* Case Not Handled */
+#define PL_LOGINFO_CODE_CONFIG_INVALID_PAGE_NO_DEV          (0x000F0400) /* No Device Found */
+#define PL_LOGINFO_CODE_CONFIG_INVALID_PAGE_FORM            (0x000F0500) /* Invalid FORM */
+#define PL_LOGINFO_CODE_CONFIG_INVALID_PAGE_PHY             (0x000F0600) /* Invalid Phy */
+#define PL_LOGINFO_CODE_CONFIG_INVALID_PAGE_NO_OWNER        (0x000F0700) /* No Owner Found */
+#define PL_LOGINFO_CODE_DSCVRY_SATA_INIT_TIMEOUT            (0x00100000)
+#define PL_LOGINFO_CODE_RESET                               (0x00110000)
+#define PL_LOGINFO_CODE_ABORT                               (0x00120000)
+#define PL_LOGINFO_CODE_IO_NOT_YET_EXECUTED                 (0x00130000)
+#define PL_LOGINFO_CODE_IO_EXECUTED                         (0x00140000)
+#define PL_LOGINFO_SUB_CODE_OPEN_FAILURE                    (0x00000100)
+#define PL_LOGINFO_SUB_CODE_INVALID_SGL                     (0x00000200)
+#define PL_LOGINFO_SUB_CODE_WRONG_REL_OFF_OR_FRAME_LENGTH   (0x00000300)
+#define PL_LOGINFO_SUB_CODE_FRAME_XFER_ERROR                (0x00000400)
+#define PL_LOGINFO_SUB_CODE_TX_FM_CONNECTED_LOW             (0x00000500)
+#define PL_LOGINFO_SUB_CODE_SATA_NON_NCQ_RW_ERR_BIT_SET     (0x00000600)
+#define PL_LOGINFO_SUB_CODE_SATA_READ_LOG_RECEIVE_DATA_ERR  (0x00000700)
+#define PL_LOGINFO_SUB_CODE_SATA_NCQ_FAIL_ALL_CMDS_AFTR_ERR (0x00000800)
+#define PL_LOGINFO_SUB_CODE_SATA_ERR_IN_RCV_SET_DEV_BIT_FIS (0x00000900)
+#define PL_LOGINFO_SUB_CODE_RX_FM_INVALID_MESSAGE           (0x00000A00)
+#define PL_LOGINFO_SUB_CODE_RX_CTX_MESSAGE_VALID_ERROR      (0x00000B00)
+#define PL_LOGINFO_SUB_CODE_RX_FM_CURRENT_FRAME_ERROR       (0x00000C00)
+#define PL_LOGINFO_SUB_CODE_SATA_LINK_DOWN                  (0x00000D00)
+#define PL_LOGINFO_SUB_CODE_DISCOVERY_SATA_INIT_W_IOS       (0x00000E00)
+#define PL_LOGINFO_SUB_CODE_DSCVRY_SATA_INIT_TIMEOUT        (0x00001000)
+
+
+#define PL_LOGINFO_CODE_ENCL_MGMT_SMP_FRAME_FAILURE         (0x00200000) /* Can't get SMP Frame */
+#define PL_LOGINFO_CODE_ENCL_MGMT_SMP_READ_ERROR            (0x00200001) /* Error occured on SMP Read */
+#define PL_LOGINFO_CODE_ENCL_MGMT_SMP_WRITE_ERROR           (0x00200002) /* Error occured on SMP Write */
+#define PL_LOGINFO_CODE_ENCL_MGMT_NOT_SUPPORTED_ON_ENCL     (0x00200004) /* Encl Mgmt services not available for this WWID */
+#define PL_LOGINFO_CODE_ENCL_MGMT_ADDR_MODE_NOT_SUPPORTED   (0x00200005) /* Address Mode not suppored */
+#define PL_LOGINFO_CODE_ENCL_MGMT_BAD_SLOT_NUM              (0x00200006) /* Invalid Slot Number in SEP Msg */
+#define PL_LOGINFO_CODE_ENCL_MGMT_SGPIO_NOT_PRESENT         (0x00200007) /* SGPIO not present/enabled */
+
+#define PL_LOGINFO_DA_SEP_NOT_PRESENT                       (0x00200100) /* SEP not present when msg received */
+#define PL_LOGINFO_DA_SEP_SINGLE_THREAD_ERROR               (0x00200101) /* Can only accept 1 msg at a time */
+#define PL_LOGINFO_DA_SEP_ISTWI_INTR_IN_IDLE_STATE          (0x00200102) /* ISTWI interrupt recvd. while IDLE */
+#define PL_LOGINFO_DA_SEP_RECEIVED_NACK_FROM_SLAVE          (0x00200103) /* SEP NACK'd, it is busy */
+#define PL_LOGINFO_DA_SEP_BAD_STATUS_HDR_CHKSUM             (0x00200104) /* SEP stopped or sent bad chksum in Hdr */
+#define PL_LOGINFO_DA_SEP_UNSUPPORTED_SCSI_STATUS_1         (0x00200105) /* SEP returned unknown scsi status */
+#define PL_LOGINFO_DA_SEP_UNSUPPORTED_SCSI_STATUS_2         (0x00200106) /* SEP returned unknown scsi status */
+#define PL_LOGINFO_DA_SEP_CHKSUM_ERROR_AFTER_STOP           (0x00200107) /* SEP returned bad chksum after STOP */
+#define PL_LOGINFO_DA_SEP_CHKSUM_ERROR_AFTER_STOP_GETDATA   (0x00200108) /* SEP returned bad chksum after STOP while gettin data*/
+
+
+/****************************************************************************/
+/* IR LOGINFO_CODE defines, valid if IOC_LOGINFO_ORIGINATOR = IR            */
+/****************************************************************************/
+#define IR_LOGINFO_CODE_UNUSED1                         (0x00010000)
+#define IR_LOGINFO_CODE_UNUSED2                         (0x00020000)
+
+/****************************************************************************/
+/* Defines for convienence                                                  */
+/****************************************************************************/
+#define IOC_LOGINFO_PREFIX_IOP                          ((MPI_IOCLOGINFO_TYPE_SAS << MPI_IOCLOGINFO_TYPE_SHIFT) | IOC_LOGINFO_ORIGINATOR_IOP)
+#define IOC_LOGINFO_PREFIX_PL                           ((MPI_IOCLOGINFO_TYPE_SAS << MPI_IOCLOGINFO_TYPE_SHIFT) | IOC_LOGINFO_ORIGINATOR_PL)
+#define IOC_LOGINFO_PREFIX_IR                           ((MPI_IOCLOGINFO_TYPE_SAS << MPI_IOCLOGINFO_TYPE_SHIFT) | IOC_LOGINFO_ORIGINATOR_IR)
+
+#endif /* end of file */
+
diff --git a/drivers/message/fusion/lsi/mpi_sas.h b/drivers/message/fusion/lsi/mpi_sas.h
index 230fa69b5353..70514867bddf 100644
--- a/drivers/message/fusion/lsi/mpi_sas.h
+++ b/drivers/message/fusion/lsi/mpi_sas.h
@@ -6,7 +6,7 @@
  *          Title:  MPI Serial Attached SCSI structures and definitions
  *  Creation Date:  August 19, 2004
  *
- *    mpi_sas.h Version:  01.05.01
+ *    mpi_sas.h Version:  01.05.02
  *
  *  Version History
  *  ---------------
@@ -14,6 +14,9 @@
  *  Date      Version   Description
  *  --------  --------  ------------------------------------------------------
  *  08-19-04  01.05.01  Original release.
+ *  08-30-05  01.05.02  Added DeviceInfo bit for SEP.
+ *                      Added PrimFlags and Primitive field to SAS IO Unit
+ *                      Control request, and added a new operation code.
  *  --------------------------------------------------------------------------
  */
 
@@ -51,6 +54,7 @@
  * Values for the SAS DeviceInfo field used in SAS Device Status Change Event
  * data and SAS IO Unit Configuration pages.
  */
+#define MPI_SAS_DEVICE_INFO_SEP                 (0x00004000)
 #define MPI_SAS_DEVICE_INFO_ATAPI_DEVICE        (0x00002000)
 #define MPI_SAS_DEVICE_INFO_LSI_DEVICE          (0x00001000)
 #define MPI_SAS_DEVICE_INFO_DIRECT_ATTACH       (0x00000800)
@@ -212,20 +216,26 @@ typedef struct _MSG_SAS_IOUNIT_CONTROL_REQUEST
     U8                      TargetID;           /* 0Ch */
     U8                      Bus;                /* 0Dh */
     U8                      PhyNum;             /* 0Eh */
-    U8                      Reserved4;          /* 0Fh */
-    U32                     Reserved5;          /* 10h */
+    U8                      PrimFlags;          /* 0Fh */
+    U32                     Primitive;          /* 10h */
     U64                     SASAddress;         /* 14h */
-    U32                     Reserved6;          /* 1Ch */
+    U32                     Reserved4;          /* 1Ch */
 } MSG_SAS_IOUNIT_CONTROL_REQUEST, MPI_POINTER PTR_MSG_SAS_IOUNIT_CONTROL_REQUEST,
   SasIoUnitControlRequest_t, MPI_POINTER pSasIoUnitControlRequest_t;
 
 /* values for the Operation field */
-#define MPI_SAS_OP_CLEAR_NOT_PRESENT             (0x01)
-#define MPI_SAS_OP_CLEAR_ALL_PERSISTENT          (0x02)
-#define MPI_SAS_OP_PHY_LINK_RESET                (0x06)
-#define MPI_SAS_OP_PHY_HARD_RESET                (0x07)
-#define MPI_SAS_OP_PHY_CLEAR_ERROR_LOG           (0x08)
-#define MPI_SAS_OP_MAP_CURRENT                   (0x09)
+#define MPI_SAS_OP_CLEAR_NOT_PRESENT            (0x01)
+#define MPI_SAS_OP_CLEAR_ALL_PERSISTENT         (0x02)
+#define MPI_SAS_OP_PHY_LINK_RESET               (0x06)
+#define MPI_SAS_OP_PHY_HARD_RESET               (0x07)
+#define MPI_SAS_OP_PHY_CLEAR_ERROR_LOG          (0x08)
+#define MPI_SAS_OP_MAP_CURRENT                  (0x09)
+#define MPI_SAS_OP_SEND_PRIMITIVE               (0x0A)
+
+/* values for the PrimFlags field */
+#define MPI_SAS_PRIMFLAGS_SINGLE                (0x08)
+#define MPI_SAS_PRIMFLAGS_TRIPLE                (0x02)
+#define MPI_SAS_PRIMFLAGS_REDUNDANT             (0x01)
 
 
 /* SAS IO Unit Control Reply */
diff --git a/drivers/message/fusion/mptbase.c b/drivers/message/fusion/mptbase.c
index 537836068c49..d890b2b8a93e 100644
--- a/drivers/message/fusion/mptbase.c
+++ b/drivers/message/fusion/mptbase.c
@@ -148,7 +148,6 @@ static int	WaitForDoorbellAck(MPT_ADAPTER *ioc, int howlong, int sleepFlag);
 static int      WaitForDoorbellInt(MPT_ADAPTER *ioc, int howlong, int sleepFlag);
 static int      WaitForDoorbellReply(MPT_ADAPTER *ioc, int howlong, int sleepFlag);
 static int      GetLanConfigPages(MPT_ADAPTER *ioc);
-static int      GetFcPortPage0(MPT_ADAPTER *ioc, int portnum);
 static int      GetIoUnitPage2(MPT_ADAPTER *ioc);
 int             mptbase_sas_persist_operation(MPT_ADAPTER *ioc, u8 persist_opcode);
 static int      mpt_GetScsiPortSettings(MPT_ADAPTER *ioc, int portnum);
@@ -1232,12 +1231,11 @@ mpt_attach(struct pci_dev *pdev, const struct pci_device_id *id)
                 dprintk((KERN_INFO MYNAM
                         ": Not using 64 bit consistent mask\n"));
 
-        ioc = kmalloc(sizeof(MPT_ADAPTER), GFP_ATOMIC);
+        ioc = kzalloc(sizeof(MPT_ADAPTER), GFP_ATOMIC);
         if (ioc == NULL) {
                 printk(KERN_ERR MYNAM ": ERROR - Insufficient memory to add adapter!\n");
                 return -ENOMEM;
         }
-        memset(ioc, 0, sizeof(MPT_ADAPTER));
         ioc->alloc_total = sizeof(MPT_ADAPTER);
         ioc->req_sz = MPT_DEFAULT_FRAME_SIZE;           /* avoid div by zero! */
         ioc->reply_sz = MPT_REPLY_FRAME_SIZE;
@@ -1245,6 +1243,8 @@ mpt_attach(struct pci_dev *pdev, const struct pci_device_id *id)
         ioc->pcidev = pdev;
         ioc->diagPending = 0;
         spin_lock_init(&ioc->diagLock);
+        spin_lock_init(&ioc->fc_rescan_work_lock);
+        spin_lock_init(&ioc->fc_rport_lock);
         spin_lock_init(&ioc->initializing_hba_lock);
 
         /* Initialize the event logging.
@@ -1268,6 +1268,10 @@ mpt_attach(struct pci_dev *pdev, const struct pci_device_id *id)
          */
         INIT_LIST_HEAD(&ioc->configQ);
 
+        /* Initialize the fc rport list head.
+         */
+        INIT_LIST_HEAD(&ioc->fc_rports);
+
         /* Find lookup slot. */
         INIT_LIST_HEAD(&ioc->list);
         ioc->id = mpt_ids++;
@@ -1374,6 +1378,10 @@ mpt_attach(struct pci_dev *pdev, const struct pci_device_id *id)
                 ioc->bus_type = FC;
                 ioc->errata_flag_1064 = 1;
         }
+        else if (pdev->device == MPI_MANUFACTPAGE_DEVICEID_FC949E) {
+                ioc->prod_name = "LSIFC949E";
+                ioc->bus_type = FC;
+        }
         else if (pdev->device == MPI_MANUFACTPAGE_DEVID_53C1030) {
                 ioc->prod_name = "LSI53C1030";
                 ioc->bus_type = SPI;
@@ -1622,7 +1630,7 @@ mpt_resume(struct pci_dev *pdev)
         pci_enable_device(pdev);
 
         /* enable interrupts */
-        CHIPREG_WRITE32(&ioc->chip->IntMask, ~(MPI_HIM_RIM));
+        CHIPREG_WRITE32(&ioc->chip->IntMask, MPI_HIM_DIM);
         ioc->active = 1;
 
         /* F/W not running */
@@ -1715,7 +1723,7 @@ mpt_do_ioc_recovery(MPT_ADAPTER *ioc, u32 reason, int sleepFlag)
                                 /* (re)Enable alt-IOC! (reply interrupt, FreeQ) */
                                 dprintk((KERN_INFO MYNAM ": alt-%s reply irq re-enabled\n",
                                                 ioc->alt_ioc->name));
-                                CHIPREG_WRITE32(&ioc->alt_ioc->chip->IntMask, ~(MPI_HIM_RIM));
+                                CHIPREG_WRITE32(&ioc->alt_ioc->chip->IntMask, MPI_HIM_DIM);
                                 ioc->alt_ioc->active = 1;
                         }
 
@@ -1831,7 +1839,7 @@ mpt_do_ioc_recovery(MPT_ADAPTER *ioc, u32 reason, int sleepFlag)
 
         if (ret == 0) {
                 /* Enable! (reply interrupt) */
-                CHIPREG_WRITE32(&ioc->chip->IntMask, ~(MPI_HIM_RIM));
+                CHIPREG_WRITE32(&ioc->chip->IntMask, MPI_HIM_DIM);
                 ioc->active = 1;
         }
 
@@ -1839,7 +1847,7 @@ mpt_do_ioc_recovery(MPT_ADAPTER *ioc, u32 reason, int sleepFlag)
                 /* (re)Enable alt-IOC! (reply interrupt) */
                 dinitprintk((KERN_INFO MYNAM ": alt-%s reply irq re-enabled\n",
                                 ioc->alt_ioc->name));
-                CHIPREG_WRITE32(&ioc->alt_ioc->chip->IntMask, ~(MPI_HIM_RIM));
+                CHIPREG_WRITE32(&ioc->alt_ioc->chip->IntMask, MPI_HIM_DIM);
                 ioc->alt_ioc->active = 1;
         }
 
@@ -1880,7 +1888,7 @@ mpt_do_ioc_recovery(MPT_ADAPTER *ioc, u32 reason, int sleepFlag)
                          *  (FCPortPage0_t stuff)
                          */
                         for (ii=0; ii < ioc->facts.NumberOfPorts; ii++) {
-                                (void) GetFcPortPage0(ioc, ii);
+                                (void) mptbase_GetFcPortPage0(ioc, ii);
                         }
 
                         if ((ioc->pfacts[0].ProtocolFlags & MPI_PORTFACTS_PROTOCOL_LAN) &&
@@ -4199,7 +4207,7 @@ GetLanConfigPages(MPT_ADAPTER *ioc)
 
 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
 /*
- *      GetFcPortPage0 - Fetch FCPort config Page0.
+ *      mptbase_GetFcPortPage0 - Fetch FCPort config Page0.
  *      @ioc: Pointer to MPT_ADAPTER structure
  *      @portnum: IOC Port number
  *
@@ -4209,8 +4217,8 @@ GetLanConfigPages(MPT_ADAPTER *ioc)
  *              -EAGAIN if no msg frames currently available
  *              -EFAULT for non-successful reply or no reply (timeout)
  */
-static int
-GetFcPortPage0(MPT_ADAPTER *ioc, int portnum)
+int
+mptbase_GetFcPortPage0(MPT_ADAPTER *ioc, int portnum)
 {
         ConfigPageHeader_t       hdr;
         CONFIGPARMS              cfg;
@@ -4220,6 +4228,8 @@ GetFcPortPage0(MPT_ADAPTER *ioc, int portnum)
         int                      data_sz;
         int                      copy_sz;
         int                      rc;
+        int                      count = 400;
+
 
         /* Get FCPort Page 0 header */
         hdr.PageVersion = 0;
@@ -4243,6 +4253,8 @@ GetFcPortPage0(MPT_ADAPTER *ioc, int portnum)
         rc = -ENOMEM;
         ppage0_alloc = (FCPortPage0_t *) pci_alloc_consistent(ioc->pcidev, data_sz, &page0_dma);
         if (ppage0_alloc) {
+
+ try_again:
                 memset((u8 *)ppage0_alloc, 0, data_sz);
                 cfg.physAddr = page0_dma;
                 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
@@ -4274,6 +4286,19 @@ GetFcPortPage0(MPT_ADAPTER *ioc, int portnum)
                         pp0dest->DiscoveredPortsCount = le32_to_cpu(pp0dest->DiscoveredPortsCount);
                         pp0dest->MaxInitiators = le32_to_cpu(pp0dest->MaxInitiators);
 
+                        /*
+                         * if still doing discovery,
+                         * hang loose a while until finished
+                         */
+                        if (pp0dest->PortState == MPI_FCPORTPAGE0_PORTSTATE_UNKNOWN) {
+                                if (count-- > 0) {
+                                        msleep_interruptible(100);
+                                        goto try_again;
+                                }
+                                printk(MYIOC_s_INFO_FMT "Firmware discovery not"
+                                                        " complete.\n",
+                                                ioc->name);
+                        }
                 }
 
                 pci_free_consistent(ioc->pcidev, data_sz, (u8 *) ppage0_alloc, page0_dma);
@@ -6358,6 +6383,7 @@ EXPORT_SYMBOL(mpt_alloc_fw_memory);
 EXPORT_SYMBOL(mpt_free_fw_memory);
 EXPORT_SYMBOL(mptbase_sas_persist_operation);
 EXPORT_SYMBOL(mpt_alt_ioc_wait);
+EXPORT_SYMBOL(mptbase_GetFcPortPage0);
 
 
 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
diff --git a/drivers/message/fusion/mptbase.h b/drivers/message/fusion/mptbase.h
index 6c48d1f54ac9..47053ac65068 100644
--- a/drivers/message/fusion/mptbase.h
+++ b/drivers/message/fusion/mptbase.h
@@ -76,8 +76,8 @@
 #define COPYRIGHT       "Copyright (c) 1999-2005 " MODULEAUTHOR
 #endif
 
-#define MPT_LINUX_VERSION_COMMON        "3.03.05"
-#define MPT_LINUX_PACKAGE_NAME          "@(#)mptlinux-3.03.05"
+#define MPT_LINUX_VERSION_COMMON        "3.03.06"
+#define MPT_LINUX_PACKAGE_NAME          "@(#)mptlinux-3.03.06"
 #define WHAT_MAGIC_STRING               "@" "(" "#" ")"
 
 #define show_mptmod_ver(s,ver)  \
@@ -413,7 +413,7 @@ typedef struct _MPT_IOCTL {
         u8                       status;        /* current command status */
         u8                       reset;         /* 1 if bus reset allowed */
         u8                       target;        /* target for reset */
-        struct semaphore         sem_ioc;
+        struct mutex             ioctl_mutex;
 } MPT_IOCTL;
 
 #define MPT_SAS_MGMT_STATUS_RF_VALID    0x02    /* The Reply Frame is VALID */
@@ -421,7 +421,7 @@ typedef struct _MPT_IOCTL {
 #define MPT_SAS_MGMT_STATUS_TM_FAILED   0x40    /* User TM request failed */
 
 typedef struct _MPT_SAS_MGMT {
-        struct semaphore         mutex;
+        struct mutex             mutex;
         struct completion        done;
         u8                       reply[MPT_DEFAULT_FRAME_SIZE]; /* reply frame data */
         u8                       status;        /* current command status */
@@ -499,6 +499,22 @@ typedef	struct _RaidCfgData {
         int              isRaid;                /* bit field, 1 if RAID */
 }RaidCfgData;
 
+#define MPT_RPORT_INFO_FLAGS_REGISTERED 0x01    /* rport registered */
+#define MPT_RPORT_INFO_FLAGS_MISSING    0x02    /* missing from DevPage0 scan */
+#define MPT_RPORT_INFO_FLAGS_MAPPED_VDEV 0x04   /* target mapped in vdev */
+
+/*
+ * data allocated for each fc rport device
+ */
+struct mptfc_rport_info
+{
+        struct list_head list;
+        struct fc_rport *rport;
+        VirtDevice      *vdev;
+        FCDevicePage0_t pg0;
+        u8              flags;
+};
+
 /*
  *  Adapter Structure - pci_dev specific. Maximum: MPT_MAX_ADAPTERS
  */
@@ -612,7 +628,16 @@ typedef struct _MPT_ADAPTER
         struct list_head         list;
         struct net_device       *netdev;
         struct list_head         sas_topology;
+        struct mutex             sas_topology_mutex;
         MPT_SAS_MGMT             sas_mgmt;
+        int                      num_ports;
+
+        struct list_head         fc_rports;
+        spinlock_t               fc_rport_lock; /* list and ri flags */
+        spinlock_t               fc_rescan_work_lock;
+        int                      fc_rescan_work_count;
+        struct work_struct       fc_rescan_work;
+
 } MPT_ADAPTER;
 
 /*
@@ -999,6 +1024,7 @@ extern void	 mpt_free_fw_memory(MPT_ADAPTER *ioc);
 extern int       mpt_findImVolumes(MPT_ADAPTER *ioc);
 extern int       mpt_read_ioc_pg_3(MPT_ADAPTER *ioc);
 extern int       mptbase_sas_persist_operation(MPT_ADAPTER *ioc, u8 persist_opcode);
+extern int       mptbase_GetFcPortPage0(MPT_ADAPTER *ioc, int portnum);
 extern int       mpt_alt_ioc_wait(MPT_ADAPTER *ioc);
 
 /*
diff --git a/drivers/message/fusion/mptctl.c b/drivers/message/fusion/mptctl.c
index 7c340240a50e..bdf709987982 100644
--- a/drivers/message/fusion/mptctl.c
+++ b/drivers/message/fusion/mptctl.c
@@ -177,10 +177,10 @@ mptctl_syscall_down(MPT_ADAPTER *ioc, int nonblock)
         dctlprintk((KERN_INFO MYNAM "::mptctl_syscall_down(%p,%d) called\n", ioc, nonblock));
 
         if (nonblock) {
-                if (down_trylock(&ioc->ioctl->sem_ioc))
+                if (!mutex_trylock(&ioc->ioctl->ioctl_mutex))
                         rc = -EAGAIN;
         } else {
-                if (down_interruptible(&ioc->ioctl->sem_ioc))
+                if (mutex_lock_interruptible(&ioc->ioctl->ioctl_mutex))
                         rc = -ERESTARTSYS;
         }
         dctlprintk((KERN_INFO MYNAM "::mptctl_syscall_down return %d\n", rc));
@@ -557,7 +557,7 @@ __mptctl_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
         else
                 ret = -EINVAL;
 
-        up(&iocp->ioctl->sem_ioc);
+        mutex_unlock(&iocp->ioctl->ioctl_mutex);
 
         return ret;
 }
@@ -2619,7 +2619,7 @@ compat_mptfwxfer_ioctl(struct file *filp, unsigned int cmd,
 
         ret = mptctl_do_fw_download(kfw.iocnum, kfw.bufp, kfw.fwlen);
 
-        up(&iocp->ioctl->sem_ioc);
+        mutex_unlock(&iocp->ioctl->ioctl_mutex);
 
         return ret;
 }
@@ -2673,7 +2673,7 @@ compat_mpt_command(struct file *filp, unsigned int cmd,
          */
         ret = mptctl_do_mpt_command (karg, &uarg->MF);
 
-        up(&iocp->ioctl->sem_ioc);
+        mutex_unlock(&iocp->ioctl->ioctl_mutex);
 
         return ret;
 }
@@ -2743,7 +2743,7 @@ mptctl_probe(struct pci_dev *pdev, const struct pci_device_id *id)
         memset(mem, 0, sz);
         ioc->ioctl = (MPT_IOCTL *) mem;
         ioc->ioctl->ioc = ioc;
-        sema_init(&ioc->ioctl->sem_ioc, 1);
+        mutex_init(&ioc->ioctl->ioctl_mutex);
         return 0;
 
 out_fail:
diff --git a/drivers/message/fusion/mptfc.c b/drivers/message/fusion/mptfc.c
index ba61e1828858..b102c7666d0e 100644
--- a/drivers/message/fusion/mptfc.c
+++ b/drivers/message/fusion/mptfc.c
@@ -55,12 +55,14 @@
 #include <linux/reboot.h>       /* notifier code */
 #include <linux/sched.h>
 #include <linux/workqueue.h>
+#include <linux/sort.h>
 
 #include <scsi/scsi.h>
 #include <scsi/scsi_cmnd.h>
 #include <scsi/scsi_device.h>
 #include <scsi/scsi_host.h>
 #include <scsi/scsi_tcq.h>
+#include <scsi/scsi_transport_fc.h>
 
 #include "mptbase.h"
 #include "mptscsih.h"
@@ -79,19 +81,34 @@ static int mpt_pq_filter = 0;
 module_param(mpt_pq_filter, int, 0);
 MODULE_PARM_DESC(mpt_pq_filter, " Enable peripheral qualifier filter: enable=1  (default=0)");
 
+#define MPTFC_DEV_LOSS_TMO (60)
+static int mptfc_dev_loss_tmo = MPTFC_DEV_LOSS_TMO;     /* reasonable default */
+module_param(mptfc_dev_loss_tmo, int, 0);
+MODULE_PARM_DESC(mptfc_dev_loss_tmo, " Initial time the driver programs the "
+                                     " transport to wait for an rport to "
+                                     " return following a device loss event."
+                                     "  Default=60.");
+
 static int      mptfcDoneCtx = -1;
 static int      mptfcTaskCtx = -1;
 static int      mptfcInternalCtx = -1; /* Used only for internal commands */
 
+int mptfc_slave_alloc(struct scsi_device *device);
+static int mptfc_qcmd(struct scsi_cmnd *SCpnt,
+    void (*done)(struct scsi_cmnd *));
+
+static void mptfc_set_rport_loss_tmo(struct fc_rport *rport, uint32_t timeout);
+static void __devexit mptfc_remove(struct pci_dev *pdev);
+
 static struct scsi_host_template mptfc_driver_template = {
         .module                         = THIS_MODULE,
         .proc_name                      = "mptfc",
         .proc_info                      = mptscsih_proc_info,
         .name                           = "MPT FC Host",
         .info                           = mptscsih_info,
-        .queuecommand                   = mptscsih_qcmd,
+        .queuecommand                   = mptfc_qcmd,
         .target_alloc                   = mptscsih_target_alloc,
-        .slave_alloc                    = mptscsih_slave_alloc,
+        .slave_alloc                    = mptfc_slave_alloc,
         .slave_configure                = mptscsih_slave_configure,
         .target_destroy                 = mptscsih_target_destroy,
         .slave_destroy                  = mptscsih_slave_destroy,
@@ -128,19 +145,478 @@ static struct pci_device_id mptfc_pci_table[] = {
                 PCI_ANY_ID, PCI_ANY_ID },
         { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_FC949X,
                 PCI_ANY_ID, PCI_ANY_ID },
+        { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_FC949ES,
+                PCI_ANY_ID, PCI_ANY_ID },
         {0}     /* Terminating entry */
 };
 MODULE_DEVICE_TABLE(pci, mptfc_pci_table);
 
-/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
-/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+static struct scsi_transport_template *mptfc_transport_template = NULL;
+
+struct fc_function_template mptfc_transport_functions = {
+        .dd_fcrport_size = 8,
+        .show_host_node_name = 1,
+        .show_host_port_name = 1,
+        .show_host_supported_classes = 1,
+        .show_host_port_id = 1,
+        .show_rport_supported_classes = 1,
+        .show_starget_node_name = 1,
+        .show_starget_port_name = 1,
+        .show_starget_port_id = 1,
+        .set_rport_dev_loss_tmo = mptfc_set_rport_loss_tmo,
+        .show_rport_dev_loss_tmo = 1,
+
+};
+
+/* FIXME! values controlling firmware RESCAN event
+ * need to be set low to allow dev_loss_tmo to
+ * work as expected.  Currently, firmware doesn't
+ * notify driver of RESCAN event until some number
+ * of seconds elapse.  This value can be set via
+ * lsiutil.
+ */
+static void
+mptfc_set_rport_loss_tmo(struct fc_rport *rport, uint32_t timeout)
+{
+        if (timeout > 0)
+                rport->dev_loss_tmo = timeout;
+        else
+                rport->dev_loss_tmo = mptfc_dev_loss_tmo;
+}
+
+static int
+mptfc_FcDevPage0_cmp_func(const void *a, const void *b)
+{
+        FCDevicePage0_t **aa = (FCDevicePage0_t **)a;
+        FCDevicePage0_t **bb = (FCDevicePage0_t **)b;
+
+        if ((*aa)->CurrentBus == (*bb)->CurrentBus) {
+                if ((*aa)->CurrentTargetID == (*bb)->CurrentTargetID)
+                        return 0;
+                if ((*aa)->CurrentTargetID < (*bb)->CurrentTargetID)
+                        return -1;
+                return 1;
+        }
+        if ((*aa)->CurrentBus < (*bb)->CurrentBus)
+                return -1;
+        return 1;
+}
+
+static int
+mptfc_GetFcDevPage0(MPT_ADAPTER *ioc, int ioc_port,
+        void(*func)(MPT_ADAPTER *ioc,int channel, FCDevicePage0_t *arg))
+{
+        ConfigPageHeader_t       hdr;
+        CONFIGPARMS              cfg;
+        FCDevicePage0_t         *ppage0_alloc, *fc;
+        dma_addr_t               page0_dma;
+        int                      data_sz;
+        int                      ii;
+
+        FCDevicePage0_t         *p0_array=NULL, *p_p0;
+        FCDevicePage0_t         **pp0_array=NULL, **p_pp0;
+
+        int                      rc = -ENOMEM;
+        U32                      port_id = 0xffffff;
+        int                      num_targ = 0;
+        int                      max_bus = ioc->facts.MaxBuses;
+        int                      max_targ = ioc->facts.MaxDevices;
+
+        if (max_bus == 0 || max_targ == 0)
+                goto out;
+
+        data_sz = sizeof(FCDevicePage0_t) * max_bus * max_targ;
+        p_p0 = p0_array =  kzalloc(data_sz, GFP_KERNEL);
+        if (!p0_array)
+                goto out;
+
+        data_sz = sizeof(FCDevicePage0_t *) * max_bus * max_targ;
+        p_pp0 = pp0_array = kzalloc(data_sz, GFP_KERNEL);
+        if (!pp0_array)
+                goto out;
+
+        do {
+                /* Get FC Device Page 0 header */
+                hdr.PageVersion = 0;
+                hdr.PageLength = 0;
+                hdr.PageNumber = 0;
+                hdr.PageType = MPI_CONFIG_PAGETYPE_FC_DEVICE;
+                cfg.cfghdr.hdr = &hdr;
+                cfg.physAddr = -1;
+                cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
+                cfg.dir = 0;
+                cfg.pageAddr = port_id;
+                cfg.timeout = 0;
+
+                if ((rc = mpt_config(ioc, &cfg)) != 0)
+                        break;
+
+                if (hdr.PageLength <= 0)
+                        break;
+
+                data_sz = hdr.PageLength * 4;
+                ppage0_alloc = pci_alloc_consistent(ioc->pcidev, data_sz,
+                                                        &page0_dma);
+                rc = -ENOMEM;
+                if (!ppage0_alloc)
+                        break;
+
+                cfg.physAddr = page0_dma;
+                cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
+
+                if ((rc = mpt_config(ioc, &cfg)) == 0) {
+                        ppage0_alloc->PortIdentifier =
+                                le32_to_cpu(ppage0_alloc->PortIdentifier);
+
+                        ppage0_alloc->WWNN.Low =
+                                le32_to_cpu(ppage0_alloc->WWNN.Low);
+
+                        ppage0_alloc->WWNN.High =
+                                le32_to_cpu(ppage0_alloc->WWNN.High);
+
+                        ppage0_alloc->WWPN.Low =
+                                le32_to_cpu(ppage0_alloc->WWPN.Low);
+
+                        ppage0_alloc->WWPN.High =
+                                le32_to_cpu(ppage0_alloc->WWPN.High);
+
+                        ppage0_alloc->BBCredit =
+                                le16_to_cpu(ppage0_alloc->BBCredit);
+
+                        ppage0_alloc->MaxRxFrameSize =
+                                le16_to_cpu(ppage0_alloc->MaxRxFrameSize);
+
+                        port_id = ppage0_alloc->PortIdentifier;
+                        num_targ++;
+                        *p_p0 = *ppage0_alloc;  /* save data */
+                        *p_pp0++ = p_p0++;      /* save addr */
+                }
+                pci_free_consistent(ioc->pcidev, data_sz,
+                                        (u8 *) ppage0_alloc, page0_dma);
+                if (rc != 0)
+                        break;
+
+        } while (port_id <= 0xff0000);
+
+        if (num_targ) {
+                /* sort array */
+                if (num_targ > 1)
+                        sort (pp0_array, num_targ, sizeof(FCDevicePage0_t *),
+                                mptfc_FcDevPage0_cmp_func, NULL);
+                /* call caller's func for each targ */
+                for (ii = 0; ii < num_targ;  ii++) {
+                        fc = *(pp0_array+ii);
+                        func(ioc, ioc_port, fc);
+                }
+        }
+
+ out:
+        if (pp0_array)
+                kfree(pp0_array);
+        if (p0_array)
+                kfree(p0_array);
+        return rc;
+}
+
+static int
+mptfc_generate_rport_ids(FCDevicePage0_t *pg0, struct fc_rport_identifiers *rid)
+{
+        /* not currently usable */
+        if (pg0->Flags & (MPI_FC_DEVICE_PAGE0_FLAGS_PLOGI_INVALID |
+                          MPI_FC_DEVICE_PAGE0_FLAGS_PRLI_INVALID))
+                return -1;
+
+        if (!(pg0->Flags & MPI_FC_DEVICE_PAGE0_FLAGS_TARGETID_BUS_VALID))
+                return -1;
+
+        if (!(pg0->Protocol & MPI_FC_DEVICE_PAGE0_PROT_FCP_TARGET))
+                return -1;
+
+        /*
+         * board data structure already normalized to platform endianness
+         * shifted to avoid unaligned access on 64 bit architecture
+         */
+        rid->node_name = ((u64)pg0->WWNN.High) << 32 | (u64)pg0->WWNN.Low;
+        rid->port_name = ((u64)pg0->WWPN.High) << 32 | (u64)pg0->WWPN.Low;
+        rid->port_id =   pg0->PortIdentifier;
+        rid->roles = FC_RPORT_ROLE_UNKNOWN;
+        rid->roles |= FC_RPORT_ROLE_FCP_TARGET;
+        if (pg0->Protocol & MPI_FC_DEVICE_PAGE0_PROT_FCP_INITIATOR)
+                rid->roles |= FC_RPORT_ROLE_FCP_INITIATOR;
+
+        return 0;
+}
+
+static void
+mptfc_register_dev(MPT_ADAPTER *ioc, int channel, FCDevicePage0_t *pg0)
+{
+        struct fc_rport_identifiers rport_ids;
+        struct fc_rport         *rport;
+        struct mptfc_rport_info *ri;
+        int                     match = 0;
+        u64                     port_name;
+        unsigned long           flags;
+
+        if (mptfc_generate_rport_ids(pg0, &rport_ids) < 0)
+                return;
+
+        /* scan list looking for a match */
+        spin_lock_irqsave(&ioc->fc_rport_lock, flags);
+        list_for_each_entry(ri, &ioc->fc_rports, list) {
+                port_name = (u64)ri->pg0.WWPN.High << 32 | (u64)ri->pg0.WWPN.Low;
+                if (port_name == rport_ids.port_name) { /* match */
+                        list_move_tail(&ri->list, &ioc->fc_rports);
+                        match = 1;
+                        break;
+                }
+        }
+        if (!match) {   /* allocate one */
+                spin_unlock_irqrestore(&ioc->fc_rport_lock, flags);
+                ri = kzalloc(sizeof(struct mptfc_rport_info), GFP_KERNEL);
+                if (!ri)
+                        return;
+                spin_lock_irqsave(&ioc->fc_rport_lock, flags);
+                list_add_tail(&ri->list, &ioc->fc_rports);
+        }
+
+        ri->pg0 = *pg0; /* add/update pg0 data */
+        ri->flags &= ~MPT_RPORT_INFO_FLAGS_MISSING;
+
+        if (!(ri->flags & MPT_RPORT_INFO_FLAGS_REGISTERED)) {
+                ri->flags |= MPT_RPORT_INFO_FLAGS_REGISTERED;
+                spin_unlock_irqrestore(&ioc->fc_rport_lock, flags);
+                rport = fc_remote_port_add(ioc->sh,channel, &rport_ids);
+                spin_lock_irqsave(&ioc->fc_rport_lock, flags);
+                if (rport) {
+                        if (*((struct mptfc_rport_info **)rport->dd_data) != ri) {
+                                ri->flags &= ~MPT_RPORT_INFO_FLAGS_MAPPED_VDEV;
+                                ri->vdev = NULL;
+                                ri->rport = rport;
+                                *((struct mptfc_rport_info **)rport->dd_data) = ri;
+                        }
+                        rport->dev_loss_tmo = mptfc_dev_loss_tmo;
+                        /*
+                         * if already mapped, remap here.  If not mapped,
+                         * slave_alloc will allocate vdev and map
+                         */
+                        if (ri->flags & MPT_RPORT_INFO_FLAGS_MAPPED_VDEV) {
+                                ri->vdev->target_id = ri->pg0.CurrentTargetID;
+                                ri->vdev->bus_id = ri->pg0.CurrentBus;
+                                ri->vdev->vtarget->target_id = ri->vdev->target_id;
+                                ri->vdev->vtarget->bus_id = ri->vdev->bus_id;
+                        }
+                        #ifdef MPT_DEBUG
+                        printk ("mptfc_reg_dev.%d: %x, %llx / %llx, tid %d, "
+                                "rport tid %d, tmo %d\n",
+                                        ioc->sh->host_no,
+                                        pg0->PortIdentifier,
+                                        pg0->WWNN,
+                                        pg0->WWPN,
+                                        pg0->CurrentTargetID,
+                                        ri->rport->scsi_target_id,
+                                        ri->rport->dev_loss_tmo);
+                        #endif
+                } else {
+                        list_del(&ri->list);
+                        kfree(ri);
+                        ri = NULL;
+                }
+        }
+        spin_unlock_irqrestore(&ioc->fc_rport_lock,flags);
+
+}
+
 /*
- *      mptfc_probe - Installs scsi devices per bus.
- *      @pdev: Pointer to pci_dev structure
- *
- *      Returns 0 for success, non-zero for failure.
- *
+ *      OS entry point to allow host driver to alloc memory
+ *      for each scsi device. Called once per device the bus scan.
+ *      Return non-zero if allocation fails.
+ *      Init memory once per LUN.
  */
+int
+mptfc_slave_alloc(struct scsi_device *sdev)
+{
+        MPT_SCSI_HOST           *hd;
+        VirtTarget              *vtarget;
+        VirtDevice              *vdev;
+        struct scsi_target      *starget;
+        struct fc_rport         *rport;
+        struct mptfc_rport_info *ri;
+        unsigned long           flags;
+
+
+        rport = starget_to_rport(scsi_target(sdev));
+
+        if (!rport || fc_remote_port_chkready(rport))
+                return -ENXIO;
+
+        hd = (MPT_SCSI_HOST *)sdev->host->hostdata;
+
+        vdev = kmalloc(sizeof(VirtDevice), GFP_KERNEL);
+        if (!vdev) {
+                printk(MYIOC_s_ERR_FMT "slave_alloc kmalloc(%zd) FAILED!\n",
+                                hd->ioc->name, sizeof(VirtDevice));
+                return -ENOMEM;
+        }
+        memset(vdev, 0, sizeof(VirtDevice));
+
+        spin_lock_irqsave(&hd->ioc->fc_rport_lock,flags);
+
+        if (!(ri = *((struct mptfc_rport_info **)rport->dd_data))) {
+                spin_unlock_irqrestore(&hd->ioc->fc_rport_lock,flags);
+                kfree(vdev);
+                return -ENODEV;
+        }
+
+        sdev->hostdata = vdev;
+        starget = scsi_target(sdev);
+        vtarget = starget->hostdata;
+        if (vtarget->num_luns == 0) {
+                vtarget->tflags = MPT_TARGET_FLAGS_Q_YES |
+                                  MPT_TARGET_FLAGS_VALID_INQUIRY;
+                hd->Targets[sdev->id] = vtarget;
+        }
+
+        vtarget->target_id = vdev->target_id;
+        vtarget->bus_id = vdev->bus_id;
+
+        vdev->vtarget = vtarget;
+        vdev->ioc_id = hd->ioc->id;
+        vdev->lun = sdev->lun;
+        vdev->target_id = ri->pg0.CurrentTargetID;
+        vdev->bus_id = ri->pg0.CurrentBus;
+
+        ri->flags |= MPT_RPORT_INFO_FLAGS_MAPPED_VDEV;
+        ri->vdev = vdev;
+
+        spin_unlock_irqrestore(&hd->ioc->fc_rport_lock,flags);
+
+        vtarget->num_luns++;
+
+#ifdef MPT_DEBUG
+        printk ("mptfc_slv_alloc.%d: num_luns %d, sdev.id %d, "
+                "CurrentTargetID %d, %x %llx %llx\n",
+                        sdev->host->host_no,
+                        vtarget->num_luns,
+                        sdev->id, ri->pg0.CurrentTargetID,
+                        ri->pg0.PortIdentifier, ri->pg0.WWPN, ri->pg0.WWNN);
+#endif
+
+        return 0;
+}
+
+static int
+mptfc_qcmd(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *))
+{
+        struct fc_rport *rport = starget_to_rport(scsi_target(SCpnt->device));
+        int             err;
+
+        err = fc_remote_port_chkready(rport);
+        if (unlikely(err)) {
+                SCpnt->result = err;
+                done(SCpnt);
+                return 0;
+        }
+        return mptscsih_qcmd(SCpnt,done);
+}
+
+static void
+mptfc_init_host_attr(MPT_ADAPTER *ioc,int portnum)
+{
+        unsigned class = 0, cos = 0;
+
+        /* don't know what to do as only one scsi (fc) host was allocated */
+        if (portnum != 0)
+                return;
+
+        class = ioc->fc_port_page0[portnum].SupportedServiceClass;
+        if (class & MPI_FCPORTPAGE0_SUPPORT_CLASS_1)
+                cos |= FC_COS_CLASS1;
+        if (class & MPI_FCPORTPAGE0_SUPPORT_CLASS_2)
+                cos |= FC_COS_CLASS2;
+        if (class & MPI_FCPORTPAGE0_SUPPORT_CLASS_3)
+                cos |= FC_COS_CLASS3;
+
+        fc_host_node_name(ioc->sh) =
+                (u64)ioc->fc_port_page0[portnum].WWNN.High << 32
+                    | (u64)ioc->fc_port_page0[portnum].WWNN.Low;
+
+        fc_host_port_name(ioc->sh) =
+                (u64)ioc->fc_port_page0[portnum].WWPN.High << 32
+                    | (u64)ioc->fc_port_page0[portnum].WWPN.Low;
+
+        fc_host_port_id(ioc->sh) = ioc->fc_port_page0[portnum].PortIdentifier;
+
+        fc_host_supported_classes(ioc->sh) = cos;
+
+        fc_host_tgtid_bind_type(ioc->sh) = FC_TGTID_BIND_BY_WWPN;
+}
+
+static void
+mptfc_rescan_devices(void *arg)
+{
+        MPT_ADAPTER             *ioc = (MPT_ADAPTER *)arg;
+        int                     ii;
+        int                     work_to_do;
+        unsigned long           flags;
+        struct mptfc_rport_info *ri;
+
+        do {
+                /* start by tagging all ports as missing */
+                spin_lock_irqsave(&ioc->fc_rport_lock,flags);
+                list_for_each_entry(ri, &ioc->fc_rports, list) {
+                        if (ri->flags & MPT_RPORT_INFO_FLAGS_REGISTERED) {
+                                ri->flags |= MPT_RPORT_INFO_FLAGS_MISSING;
+                        }
+                }
+                spin_unlock_irqrestore(&ioc->fc_rport_lock,flags);
+
+                /*
+                 * now rescan devices known to adapter,
+                 * will reregister existing rports
+                 */
+                for (ii=0; ii < ioc->facts.NumberOfPorts; ii++) {
+                        (void) mptbase_GetFcPortPage0(ioc, ii);
+                        mptfc_init_host_attr(ioc,ii);   /* refresh */
+                        mptfc_GetFcDevPage0(ioc,ii,mptfc_register_dev);
+                }
+
+                /* delete devices still missing */
+                spin_lock_irqsave(&ioc->fc_rport_lock, flags);
+                list_for_each_entry(ri, &ioc->fc_rports, list) {
+                        /* if newly missing, delete it */
+                        if ((ri->flags & (MPT_RPORT_INFO_FLAGS_REGISTERED |
+                                          MPT_RPORT_INFO_FLAGS_MISSING))
+                          == (MPT_RPORT_INFO_FLAGS_REGISTERED |
+                              MPT_RPORT_INFO_FLAGS_MISSING)) {
+
+                                ri->flags &= ~(MPT_RPORT_INFO_FLAGS_REGISTERED|
+                                               MPT_RPORT_INFO_FLAGS_MISSING);
+                                fc_remote_port_delete(ri->rport);
+                                /*
+                                 * remote port not really deleted 'cause
+                                 * binding is by WWPN and driver only
+                                 * registers FCP_TARGETs
+                                 */
+                                #ifdef MPT_DEBUG
+                                printk ("mptfc_rescan.%d: %llx deleted\n",
+                                        ioc->sh->host_no, ri->pg0.WWPN);
+                                #endif
+                        }
+                }
+                spin_unlock_irqrestore(&ioc->fc_rport_lock,flags);
+
+                /*
+                 * allow multiple passes as target state
+                 * might have changed during scan
+                 */
+                spin_lock_irqsave(&ioc->fc_rescan_work_lock, flags);
+                if (ioc->fc_rescan_work_count > 2)      /* only need one more */
+                        ioc->fc_rescan_work_count = 2;
+                work_to_do = --ioc->fc_rescan_work_count;
+                spin_unlock_irqrestore(&ioc->fc_rescan_work_lock, flags);
+        } while (work_to_do);
+}
+
 static int
 mptfc_probe(struct pci_dev *pdev, const struct pci_device_id *id)
 {
@@ -148,17 +624,16 @@ mptfc_probe(struct pci_dev *pdev, const struct pci_device_id *id)
         MPT_SCSI_HOST           *hd;
         MPT_ADAPTER             *ioc;
         unsigned long            flags;
-        int                      sz, ii;
+        int                      ii;
         int                      numSGE = 0;
         int                      scale;
         int                      ioc_cap;
-        u8                      *mem;
         int                     error=0;
         int                     r;
-                
+
         if ((r = mpt_attach(pdev,id)) != 0)
                 return r;
-        
+
         ioc = pci_get_drvdata(pdev);
         ioc->DoneCtx = mptfcDoneCtx;
         ioc->TaskCtx = mptfcTaskCtx;
@@ -194,7 +669,7 @@ mptfc_probe(struct pci_dev *pdev, const struct pci_device_id *id)
                 printk(MYIOC_s_WARN_FMT
                         "Skipping ioc=%p because SCSI Initiator mode is NOT enabled!\n",
                         ioc->name, ioc);
-                return 0;
+                return -ENODEV;
         }
 
         sh = scsi_host_alloc(&mptfc_driver_template, sizeof(MPT_SCSI_HOST));
@@ -207,6 +682,8 @@ mptfc_probe(struct pci_dev *pdev, const struct pci_device_id *id)
                 goto out_mptfc_probe;
         }
 
+        INIT_WORK(&ioc->fc_rescan_work, mptfc_rescan_devices,(void *)ioc);
+
         spin_lock_irqsave(&ioc->FreeQlock, flags);
 
         /* Attach the SCSI Host to the IOC structure
@@ -268,36 +745,27 @@ mptfc_probe(struct pci_dev *pdev, const struct pci_device_id *id)
         /* SCSI needs scsi_cmnd lookup table!
          * (with size equal to req_depth*PtrSz!)
          */
-        sz = ioc->req_depth * sizeof(void *);
-        mem = kmalloc(sz, GFP_ATOMIC);
-        if (mem == NULL) {
+        hd->ScsiLookup = kcalloc(ioc->req_depth, sizeof(void *), GFP_ATOMIC);
+        if (!hd->ScsiLookup) {
                 error = -ENOMEM;
                 goto out_mptfc_probe;
         }
 
-        memset(mem, 0, sz);
-        hd->ScsiLookup = (struct scsi_cmnd **) mem;
-
-        dprintk((MYIOC_s_INFO_FMT "ScsiLookup @ %p, sz=%d\n",
-                 ioc->name, hd->ScsiLookup, sz));
+        dprintk((MYIOC_s_INFO_FMT "ScsiLookup @ %p\n",
+                 ioc->name, hd->ScsiLookup));
 
         /* Allocate memory for the device structures.
          * A non-Null pointer at an offset
          * indicates a device exists.
          * max_id = 1 + maximum id (hosts.h)
          */
-        sz = sh->max_id * sizeof(void *);
-        mem = kmalloc(sz, GFP_ATOMIC);
-        if (mem == NULL) {
+        hd->Targets = kcalloc(sh->max_id, sizeof(void *), GFP_ATOMIC);
+        if (!hd->Targets) {
                 error = -ENOMEM;
                 goto out_mptfc_probe;
         }
 
-        memset(mem, 0, sz);
-        hd->Targets = (VirtTarget **) mem;
-
-        dprintk((KERN_INFO
-          "  vdev @ %p, sz=%d\n", hd->Targets, sz));
+        dprintk((KERN_INFO "  vdev @ %p\n", hd->Targets));
 
         /* Clear the TM flags
          */
@@ -332,6 +800,7 @@ mptfc_probe(struct pci_dev *pdev, const struct pci_device_id *id)
         hd->scandv_wait_done = 0;
         hd->last_queue_full = 0;
 
+        sh->transportt = mptfc_transport_template;
         error = scsi_add_host (sh, &ioc->pcidev->dev);
         if(error) {
                 dprintk((KERN_ERR MYNAM
@@ -339,7 +808,11 @@ mptfc_probe(struct pci_dev *pdev, const struct pci_device_id *id)
                 goto out_mptfc_probe;
         }
 
-        scsi_scan_host(sh);
+        for (ii=0; ii < ioc->facts.NumberOfPorts; ii++) {
+                mptfc_init_host_attr(ioc,ii);
+                mptfc_GetFcDevPage0(ioc,ii,mptfc_register_dev);
+        }
+
         return 0;
 
 out_mptfc_probe:
@@ -352,7 +825,7 @@ static struct pci_driver mptfc_driver = {
         .name           = "mptfc",
         .id_table       = mptfc_pci_table,
         .probe          = mptfc_probe,
-        .remove         = __devexit_p(mptscsih_remove),
+        .remove         = __devexit_p(mptfc_remove),
         .shutdown       = mptscsih_shutdown,
 #ifdef CONFIG_PM
         .suspend        = mptscsih_suspend,
@@ -370,9 +843,20 @@ static struct pci_driver mptfc_driver = {
 static int __init
 mptfc_init(void)
 {
+        int error;
 
         show_mptmod_ver(my_NAME, my_VERSION);
 
+        /* sanity check module parameter */
+        if (mptfc_dev_loss_tmo == 0)
+                mptfc_dev_loss_tmo = MPTFC_DEV_LOSS_TMO;
+
+        mptfc_transport_template =
+                fc_attach_transport(&mptfc_transport_functions);
+
+        if (!mptfc_transport_template)
+                return -ENODEV;
+
         mptfcDoneCtx = mpt_register(mptscsih_io_done, MPTFC_DRIVER);
         mptfcTaskCtx = mpt_register(mptscsih_taskmgmt_complete, MPTFC_DRIVER);
         mptfcInternalCtx = mpt_register(mptscsih_scandv_complete, MPTFC_DRIVER);
@@ -387,7 +871,33 @@ mptfc_init(void)
                   ": Registered for IOC reset notifications\n"));
         }
 
-        return pci_register_driver(&mptfc_driver);
+        error = pci_register_driver(&mptfc_driver);
+        if (error) {
+                fc_release_transport(mptfc_transport_template);
+        }
+
+        return error;
+}
+
+/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+/**
+ *      mptfc_remove - Removed fc infrastructure for devices
+ *      @pdev: Pointer to pci_dev structure
+ *
+ */
+static void __devexit mptfc_remove(struct pci_dev *pdev)
+{
+        MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
+        struct mptfc_rport_info *p, *n;
+
+        fc_remove_host(ioc->sh);
+
+        list_for_each_entry_safe(p, n, &ioc->fc_rports, list) {
+                list_del(&p->list);
+                kfree(p);
+        }
+
+        mptscsih_remove(pdev);
 }
 
 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
@@ -400,7 +910,8 @@ static void __exit
 mptfc_exit(void)
 {
         pci_unregister_driver(&mptfc_driver);
-        
+        fc_release_transport(mptfc_transport_template);
+
         mpt_reset_deregister(mptfcDoneCtx);
         dprintk((KERN_INFO MYNAM
           ": Deregistered for IOC reset notifications\n"));
diff --git a/drivers/message/fusion/mptlan.c b/drivers/message/fusion/mptlan.c
index 014085d8ec85..73f59528212a 100644
--- a/drivers/message/fusion/mptlan.c
+++ b/drivers/message/fusion/mptlan.c
@@ -411,14 +411,12 @@ mpt_lan_open(struct net_device *dev)
                 goto out;
         priv->mpt_txfidx_tail = -1;
 
-        priv->SendCtl = kmalloc(priv->tx_max_out * sizeof(struct BufferControl),
+        priv->SendCtl = kcalloc(priv->tx_max_out, sizeof(struct BufferControl),
                                 GFP_KERNEL);
         if (priv->SendCtl == NULL)
                 goto out_mpt_txfidx;
-        for (i = 0; i < priv->tx_max_out; i++) {
-                memset(&priv->SendCtl[i], 0, sizeof(struct BufferControl));
+        for (i = 0; i < priv->tx_max_out; i++)
                 priv->mpt_txfidx[++priv->mpt_txfidx_tail] = i;
-        }
 
         dlprintk((KERN_INFO MYNAM "@lo: Finished initializing SendCtl\n"));
 
@@ -428,15 +426,13 @@ mpt_lan_open(struct net_device *dev)
                 goto out_SendCtl;
         priv->mpt_rxfidx_tail = -1;
 
-        priv->RcvCtl = kmalloc(priv->max_buckets_out *
-                                                sizeof(struct BufferControl),
+        priv->RcvCtl = kcalloc(priv->max_buckets_out,
+                               sizeof(struct BufferControl),
                                GFP_KERNEL);
         if (priv->RcvCtl == NULL)
                 goto out_mpt_rxfidx;
-        for (i = 0; i < priv->max_buckets_out; i++) {
-                memset(&priv->RcvCtl[i], 0, sizeof(struct BufferControl));
+        for (i = 0; i < priv->max_buckets_out; i++)
                 priv->mpt_rxfidx[++priv->mpt_rxfidx_tail] = i;
-        }
 
 /**/    dlprintk((KERN_INFO MYNAM "/lo: txfidx contains - "));
 /**/    for (i = 0; i < priv->tx_max_out; i++)
@@ -848,7 +844,7 @@ mpt_lan_sdu_send (struct sk_buff *skb, struct net_device *dev)
 }
 
 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
-static inline void
+static void
 mpt_lan_wake_post_buckets_task(struct net_device *dev, int priority)
 /*
  * @priority: 0 = put it on the timer queue, 1 = put it on the immediate queue
@@ -870,7 +866,7 @@ mpt_lan_wake_post_buckets_task(struct net_device *dev, int priority)
 }
 
 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
-static inline int
+static int
 mpt_lan_receive_skb(struct net_device *dev, struct sk_buff *skb)
 {
         struct mpt_lan_priv *priv = dev->priv;
diff --git a/drivers/message/fusion/mptsas.c b/drivers/message/fusion/mptsas.c
index 17e9757e728b..5a06d8d8694e 100644
--- a/drivers/message/fusion/mptsas.c
+++ b/drivers/message/fusion/mptsas.c
@@ -5,7 +5,7 @@
  *
  *  Copyright (c) 1999-2005 LSI Logic Corporation
  *  (mailto:mpt_linux_developer@lsil.com)
- *  Copyright (c) 2005 Dell
+ *  Copyright (c) 2005-2006 Dell
  */
 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
 /*
@@ -86,6 +86,24 @@ static int	mptsasInternalCtx = -1; /* Used only for internal commands */
 static int      mptsasMgmtCtx = -1;
 
 
+enum mptsas_hotplug_action {
+        MPTSAS_ADD_DEVICE,
+        MPTSAS_DEL_DEVICE,
+};
+
+struct mptsas_hotplug_event {
+        struct work_struct      work;
+        MPT_ADAPTER             *ioc;
+        enum mptsas_hotplug_action event_type;
+        u64                     sas_address;
+        u32                     channel;
+        u32                     id;
+        u32                     device_info;
+        u16                     handle;
+        u16                     parent_handle;
+        u8                      phy_id;
+};
+
 /*
  * SAS topology structures
  *
@@ -99,8 +117,8 @@ struct mptsas_devinfo {
         u8      phy_id;         /* phy number of parent device */
         u8      port_id;        /* sas physical port this device
                                    is assoc'd with */
-        u8      target;         /* logical target id of this device */
-        u8      bus;            /* logical bus number of this device */
+        u8      id;             /* logical target id of this device */
+        u8      channel;        /* logical bus number of this device */
         u64     sas_address;    /* WWN of this device,
                                    SATA is assigned by HBA,expander */
         u32     device_info;    /* bitfield detailed info about this device */
@@ -114,6 +132,7 @@ struct mptsas_phyinfo {
         u8      programmed_link_rate;   /* programmed max/min phy link rate */
         struct mptsas_devinfo identify; /* point to phy device info */
         struct mptsas_devinfo attached; /* point to attached device info */
+        struct sas_phy *phy;
         struct sas_rphy *rphy;
 };
 
@@ -239,13 +258,12 @@ mptsas_slave_alloc(struct scsi_device *sdev)
         struct scsi_target      *starget;
         int i;
 
-        vdev = kmalloc(sizeof(VirtDevice), GFP_KERNEL);
+        vdev = kzalloc(sizeof(VirtDevice), GFP_KERNEL);
         if (!vdev) {
                 printk(MYIOC_s_ERR_FMT "slave_alloc kmalloc(%zd) FAILED!\n",
                                 hd->ioc->name, sizeof(VirtDevice));
                 return -ENOMEM;
         }
-        memset(vdev, 0, sizeof(VirtDevice));
         vdev->ioc_id = hd->ioc->id;
         sdev->hostdata = vdev;
         starget = scsi_target(sdev);
@@ -256,19 +274,32 @@ mptsas_slave_alloc(struct scsi_device *sdev)
                 hd->Targets[sdev->id] = vtarget;
         }
 
+        /*
+          RAID volumes placed beyond the last expected port.
+        */
+        if (sdev->channel == hd->ioc->num_ports) {
+                vdev->target_id = sdev->id;
+                vdev->bus_id = 0;
+                vdev->lun = 0;
+                goto out;
+        }
+
         rphy = dev_to_rphy(sdev->sdev_target->dev.parent);
+        mutex_lock(&hd->ioc->sas_topology_mutex);
         list_for_each_entry(p, &hd->ioc->sas_topology, list) {
                 for (i = 0; i < p->num_phys; i++) {
                         if (p->phy_info[i].attached.sas_address ==
                                         rphy->identify.sas_address) {
                                 vdev->target_id =
-                                        p->phy_info[i].attached.target;
-                                vdev->bus_id = p->phy_info[i].attached.bus;
+                                        p->phy_info[i].attached.id;
+                                vdev->bus_id = p->phy_info[i].attached.channel;
                                 vdev->lun = sdev->lun;
+        mutex_unlock(&hd->ioc->sas_topology_mutex);
                                 goto out;
                         }
                 }
         }
+        mutex_unlock(&hd->ioc->sas_topology_mutex);
 
         printk("No matching SAS device found!!\n");
         kfree(vdev);
@@ -282,6 +313,42 @@ mptsas_slave_alloc(struct scsi_device *sdev)
         return 0;
 }
 
+static void
+mptsas_slave_destroy(struct scsi_device *sdev)
+{
+        struct Scsi_Host *host = sdev->host;
+        MPT_SCSI_HOST *hd = (MPT_SCSI_HOST *)host->hostdata;
+        struct sas_rphy *rphy;
+        struct mptsas_portinfo *p;
+        int i;
+
+        /*
+         * Handle hotplug removal case.
+         * We need to clear out attached data structure.
+         */
+        rphy = dev_to_rphy(sdev->sdev_target->dev.parent);
+
+        mutex_lock(&hd->ioc->sas_topology_mutex);
+        list_for_each_entry(p, &hd->ioc->sas_topology, list) {
+                for (i = 0; i < p->num_phys; i++) {
+                        if (p->phy_info[i].attached.sas_address ==
+                                        rphy->identify.sas_address) {
+                                memset(&p->phy_info[i].attached, 0,
+                                    sizeof(struct mptsas_devinfo));
+                                p->phy_info[i].rphy = NULL;
+                                goto out;
+                        }
+                }
+        }
+
+ out:
+        mutex_unlock(&hd->ioc->sas_topology_mutex);
+        /*
+         * TODO: Issue target reset to flush firmware outstanding commands.
+         */
+        mptscsih_slave_destroy(sdev);
+}
+
 static struct scsi_host_template mptsas_driver_template = {
         .module                         = THIS_MODULE,
         .proc_name                      = "mptsas",
@@ -293,7 +360,7 @@ static struct scsi_host_template mptsas_driver_template = {
         .slave_alloc                    = mptsas_slave_alloc,
         .slave_configure                = mptscsih_slave_configure,
         .target_destroy                 = mptscsih_target_destroy,
-        .slave_destroy                  = mptscsih_slave_destroy,
+        .slave_destroy                  = mptsas_slave_destroy,
         .change_queue_depth             = mptscsih_change_queue_depth,
         .eh_abort_handler               = mptscsih_abort,
         .eh_device_reset_handler        = mptscsih_dev_reset,
@@ -399,7 +466,7 @@ static int mptsas_phy_reset(struct sas_phy *phy, int hard_reset)
         if (phy->identify.target_port_protocols & SAS_PROTOCOL_SMP)
                 return -ENXIO;
 
-        if (down_interruptible(&ioc->sas_mgmt.mutex))
+        if (mutex_lock_interruptible(&ioc->sas_mgmt.mutex))
                 goto out;
 
         mf = mpt_get_msg_frame(mptsasMgmtCtx, ioc);
@@ -450,7 +517,7 @@ static int mptsas_phy_reset(struct sas_phy *phy, int hard_reset)
         error = 0;
 
  out_unlock:
-        up(&ioc->sas_mgmt.mutex);
+        mutex_unlock(&ioc->sas_mgmt.mutex);
  out:
         return error;
 }
@@ -649,8 +716,8 @@ mptsas_sas_device_pg0(MPT_ADAPTER *ioc, struct mptsas_devinfo *device_info,
         device_info->handle = le16_to_cpu(buffer->DevHandle);
         device_info->phy_id = buffer->PhyNum;
         device_info->port_id = buffer->PhysicalPort;
-        device_info->target = buffer->TargetID;
-        device_info->bus = buffer->Bus;
+        device_info->id = buffer->TargetID;
+        device_info->channel = buffer->Bus;
         memcpy(&sas_address, &buffer->SASAddress, sizeof(__le64));
         device_info->sas_address = le64_to_cpu(sas_address);
         device_info->device_info =
@@ -858,36 +925,36 @@ mptsas_parse_device_info(struct sas_identify *identify,
 static int mptsas_probe_one_phy(struct device *dev,
                 struct mptsas_phyinfo *phy_info, int index, int local)
 {
-        struct sas_phy *port;
+        struct sas_phy *phy;
         int error;
 
-        port = sas_phy_alloc(dev, index);
-        if (!port)
+        phy = sas_phy_alloc(dev, index);
+        if (!phy)
                 return -ENOMEM;
 
-        port->port_identifier = phy_info->port_id;
-        mptsas_parse_device_info(&port->identify, &phy_info->identify);
+        phy->port_identifier = phy_info->port_id;
+        mptsas_parse_device_info(&phy->identify, &phy_info->identify);
 
         /*
          * Set Negotiated link rate.
          */
         switch (phy_info->negotiated_link_rate) {
         case MPI_SAS_IOUNIT0_RATE_PHY_DISABLED:
-                port->negotiated_linkrate = SAS_PHY_DISABLED;
+                phy->negotiated_linkrate = SAS_PHY_DISABLED;
                 break;
         case MPI_SAS_IOUNIT0_RATE_FAILED_SPEED_NEGOTIATION:
-                port->negotiated_linkrate = SAS_LINK_RATE_FAILED;
+                phy->negotiated_linkrate = SAS_LINK_RATE_FAILED;
                 break;
         case MPI_SAS_IOUNIT0_RATE_1_5:
-                port->negotiated_linkrate = SAS_LINK_RATE_1_5_GBPS;
+                phy->negotiated_linkrate = SAS_LINK_RATE_1_5_GBPS;
                 break;
         case MPI_SAS_IOUNIT0_RATE_3_0:
-                port->negotiated_linkrate = SAS_LINK_RATE_3_0_GBPS;
+                phy->negotiated_linkrate = SAS_LINK_RATE_3_0_GBPS;
                 break;
         case MPI_SAS_IOUNIT0_RATE_SATA_OOB_COMPLETE:
         case MPI_SAS_IOUNIT0_RATE_UNKNOWN:
         default:
-                port->negotiated_linkrate = SAS_LINK_RATE_UNKNOWN;
+                phy->negotiated_linkrate = SAS_LINK_RATE_UNKNOWN;
                 break;
         }
 
@@ -896,10 +963,10 @@ static int mptsas_probe_one_phy(struct device *dev,
          */
         switch (phy_info->hw_link_rate & MPI_SAS_PHY0_PRATE_MAX_RATE_MASK) {
         case MPI_SAS_PHY0_HWRATE_MAX_RATE_1_5:
-                port->maximum_linkrate_hw = SAS_LINK_RATE_1_5_GBPS;
+                phy->maximum_linkrate_hw = SAS_LINK_RATE_1_5_GBPS;
                 break;
         case MPI_SAS_PHY0_PRATE_MAX_RATE_3_0:
-                port->maximum_linkrate_hw = SAS_LINK_RATE_3_0_GBPS;
+                phy->maximum_linkrate_hw = SAS_LINK_RATE_3_0_GBPS;
                 break;
         default:
                 break;
@@ -911,10 +978,10 @@ static int mptsas_probe_one_phy(struct device *dev,
         switch (phy_info->programmed_link_rate &
                         MPI_SAS_PHY0_PRATE_MAX_RATE_MASK) {
         case MPI_SAS_PHY0_PRATE_MAX_RATE_1_5:
-                port->maximum_linkrate = SAS_LINK_RATE_1_5_GBPS;
+                phy->maximum_linkrate = SAS_LINK_RATE_1_5_GBPS;
                 break;
         case MPI_SAS_PHY0_PRATE_MAX_RATE_3_0:
-                port->maximum_linkrate = SAS_LINK_RATE_3_0_GBPS;
+                phy->maximum_linkrate = SAS_LINK_RATE_3_0_GBPS;
                 break;
         default:
                 break;
@@ -925,10 +992,10 @@ static int mptsas_probe_one_phy(struct device *dev,
          */
         switch (phy_info->hw_link_rate & MPI_SAS_PHY0_HWRATE_MIN_RATE_MASK) {
         case MPI_SAS_PHY0_HWRATE_MIN_RATE_1_5:
-                port->minimum_linkrate_hw = SAS_LINK_RATE_1_5_GBPS;
+                phy->minimum_linkrate_hw = SAS_LINK_RATE_1_5_GBPS;
                 break;
         case MPI_SAS_PHY0_PRATE_MIN_RATE_3_0:
-                port->minimum_linkrate_hw = SAS_LINK_RATE_3_0_GBPS;
+                phy->minimum_linkrate_hw = SAS_LINK_RATE_3_0_GBPS;
                 break;
         default:
                 break;
@@ -940,28 +1007,29 @@ static int mptsas_probe_one_phy(struct device *dev,
         switch (phy_info->programmed_link_rate &
                         MPI_SAS_PHY0_PRATE_MIN_RATE_MASK) {
         case MPI_SAS_PHY0_PRATE_MIN_RATE_1_5:
-                port->minimum_linkrate = SAS_LINK_RATE_1_5_GBPS;
+                phy->minimum_linkrate = SAS_LINK_RATE_1_5_GBPS;
                 break;
         case MPI_SAS_PHY0_PRATE_MIN_RATE_3_0:
-                port->minimum_linkrate = SAS_LINK_RATE_3_0_GBPS;
+                phy->minimum_linkrate = SAS_LINK_RATE_3_0_GBPS;
                 break;
         default:
                 break;
         }
 
         if (local)
-                port->local_attached = 1;
+                phy->local_attached = 1;
 
-        error = sas_phy_add(port);
+        error = sas_phy_add(phy);
         if (error) {
-                sas_phy_free(port);
+                sas_phy_free(phy);
                 return error;
         }
+        phy_info->phy = phy;
 
         if (phy_info->attached.handle) {
                 struct sas_rphy *rphy;
 
-                rphy = sas_rphy_alloc(port);
+                rphy = sas_rphy_alloc(phy);
                 if (!rphy)
                         return 0; /* non-fatal: an rphy can be added later */
 
@@ -985,16 +1053,19 @@ mptsas_probe_hba_phys(MPT_ADAPTER *ioc, int *index)
         u32 handle = 0xFFFF;
         int error = -ENOMEM, i;
 
-        port_info = kmalloc(sizeof(*port_info), GFP_KERNEL);
+        port_info = kzalloc(sizeof(*port_info), GFP_KERNEL);
         if (!port_info)
                 goto out;
-        memset(port_info, 0, sizeof(*port_info));
 
         error = mptsas_sas_io_unit_pg0(ioc, port_info);
         if (error)
                 goto out_free_port_info;
 
+        ioc->num_ports = port_info->num_phys;
+        mutex_lock(&ioc->sas_topology_mutex);
         list_add_tail(&port_info->list, &ioc->sas_topology);
+        mutex_unlock(&ioc->sas_topology_mutex);
+
         for (i = 0; i < port_info->num_phys; i++) {
                 mptsas_sas_phy_pg0(ioc, &port_info->phy_info[i],
                         (MPI_SAS_PHY_PGAD_FORM_PHY_NUMBER <<
@@ -1034,10 +1105,9 @@ mptsas_probe_expander_phys(MPT_ADAPTER *ioc, u32 *handle, int *index)
         struct mptsas_portinfo *port_info, *p;
         int error = -ENOMEM, i, j;
 
-        port_info = kmalloc(sizeof(*port_info), GFP_KERNEL);
+        port_info = kzalloc(sizeof(*port_info), GFP_KERNEL);
         if (!port_info)
                 goto out;
-        memset(port_info, 0, sizeof(*port_info));
 
         error = mptsas_sas_expander_pg0(ioc, port_info,
                 (MPI_SAS_EXPAND_PGAD_FORM_GET_NEXT_HANDLE <<
@@ -1047,7 +1117,10 @@ mptsas_probe_expander_phys(MPT_ADAPTER *ioc, u32 *handle, int *index)
 
         *handle = port_info->handle;
 
+        mutex_lock(&ioc->sas_topology_mutex);
         list_add_tail(&port_info->list, &ioc->sas_topology);
+        mutex_unlock(&ioc->sas_topology_mutex);
+
         for (i = 0; i < port_info->num_phys; i++) {
                 struct device *parent;
 
@@ -1079,6 +1152,7 @@ mptsas_probe_expander_phys(MPT_ADAPTER *ioc, u32 *handle, int *index)
                  * HBA phys.
                  */
                 parent = &ioc->sh->shost_gendev;
+                mutex_lock(&ioc->sas_topology_mutex);
                 list_for_each_entry(p, &ioc->sas_topology, list) {
                         for (j = 0; j < p->num_phys; j++) {
                                 if (port_info->phy_info[i].identify.handle ==
@@ -1086,6 +1160,7 @@ mptsas_probe_expander_phys(MPT_ADAPTER *ioc, u32 *handle, int *index)
                                         parent = &p->phy_info[j].rphy->dev;
                         }
                 }
+                mutex_unlock(&ioc->sas_topology_mutex);
 
                 mptsas_probe_one_phy(parent, &port_info->phy_info[i],
                                      *index, 0);
@@ -1111,6 +1186,211 @@ mptsas_scan_sas_topology(MPT_ADAPTER *ioc)
                 ;
 }
 
+static struct mptsas_phyinfo *
+mptsas_find_phyinfo_by_parent(MPT_ADAPTER *ioc, u16 parent_handle, u8 phy_id)
+{
+        struct mptsas_portinfo *port_info;
+        struct mptsas_devinfo device_info;
+        struct mptsas_phyinfo *phy_info = NULL;
+        int i, error;
+
+        /*
+         * Retrieve the parent sas_address
+         */
+        error = mptsas_sas_device_pg0(ioc, &device_info,
+                (MPI_SAS_DEVICE_PGAD_FORM_HANDLE <<
+                 MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
+                parent_handle);
+        if (error) {
+                printk("mptsas: failed to retrieve device page\n");
+                return NULL;
+        }
+
+        /*
+         * The phy_info structures are never deallocated during lifetime of
+         * a host, so the code below is safe without additional refcounting.
+         */
+        mutex_lock(&ioc->sas_topology_mutex);
+        list_for_each_entry(port_info, &ioc->sas_topology, list) {
+                for (i = 0; i < port_info->num_phys; i++) {
+                        if (port_info->phy_info[i].identify.sas_address ==
+                            device_info.sas_address &&
+                            port_info->phy_info[i].phy_id == phy_id) {
+                                phy_info = &port_info->phy_info[i];
+                                break;
+                        }
+                }
+        }
+        mutex_unlock(&ioc->sas_topology_mutex);
+
+        return phy_info;
+}
+
+static struct mptsas_phyinfo *
+mptsas_find_phyinfo_by_handle(MPT_ADAPTER *ioc, u16 handle)
+{
+        struct mptsas_portinfo *port_info;
+        struct mptsas_phyinfo *phy_info = NULL;
+        int i;
+
+        /*
+         * The phy_info structures are never deallocated during lifetime of
+         * a host, so the code below is safe without additional refcounting.
+         */
+        mutex_lock(&ioc->sas_topology_mutex);
+        list_for_each_entry(port_info, &ioc->sas_topology, list) {
+                for (i = 0; i < port_info->num_phys; i++) {
+                        if (port_info->phy_info[i].attached.handle == handle) {
+                                phy_info = &port_info->phy_info[i];
+                                break;
+                        }
+                }
+        }
+        mutex_unlock(&ioc->sas_topology_mutex);
+
+        return phy_info;
+}
+
+static void
+mptsas_hotplug_work(void *arg)
+{
+        struct mptsas_hotplug_event *ev = arg;
+        MPT_ADAPTER *ioc = ev->ioc;
+        struct mptsas_phyinfo *phy_info;
+        struct sas_rphy *rphy;
+        char *ds = NULL;
+
+        if (ev->device_info & MPI_SAS_DEVICE_INFO_SSP_TARGET)
+                ds = "ssp";
+        if (ev->device_info & MPI_SAS_DEVICE_INFO_STP_TARGET)
+                ds = "stp";
+        if (ev->device_info & MPI_SAS_DEVICE_INFO_SATA_DEVICE)
+                ds = "sata";
+
+        switch (ev->event_type) {
+        case MPTSAS_DEL_DEVICE:
+                printk(MYIOC_s_INFO_FMT
+                       "removing %s device, channel %d, id %d, phy %d\n",
+                       ioc->name, ds, ev->channel, ev->id, ev->phy_id);
+
+                phy_info = mptsas_find_phyinfo_by_handle(ioc, ev->handle);
+                if (!phy_info) {
+                        printk("mptsas: remove event for non-existant PHY.\n");
+                        break;
+                }
+
+                if (phy_info->rphy) {
+                        sas_rphy_delete(phy_info->rphy);
+                        phy_info->rphy = NULL;
+                }
+                break;
+        case MPTSAS_ADD_DEVICE:
+                printk(MYIOC_s_INFO_FMT
+                       "attaching %s device, channel %d, id %d, phy %d\n",
+                       ioc->name, ds, ev->channel, ev->id, ev->phy_id);
+
+                phy_info = mptsas_find_phyinfo_by_parent(ioc,
+                                ev->parent_handle, ev->phy_id);
+                if (!phy_info) {
+                        printk("mptsas: add event for non-existant PHY.\n");
+                        break;
+                }
+
+                if (phy_info->rphy) {
+                        printk("mptsas: trying to add existing device.\n");
+                        break;
+                }
+
+                /* fill attached info */
+                phy_info->attached.handle = ev->handle;
+                phy_info->attached.phy_id = ev->phy_id;
+                phy_info->attached.port_id = phy_info->identify.port_id;
+                phy_info->attached.id = ev->id;
+                phy_info->attached.channel = ev->channel;
+                phy_info->attached.sas_address = ev->sas_address;
+                phy_info->attached.device_info = ev->device_info;
+
+                rphy = sas_rphy_alloc(phy_info->phy);
+                if (!rphy)
+                        break; /* non-fatal: an rphy can be added later */
+
+                mptsas_parse_device_info(&rphy->identify, &phy_info->attached);
+                if (sas_rphy_add(rphy)) {
+                        sas_rphy_free(rphy);
+                        break;
+                }
+
+                phy_info->rphy = rphy;
+                break;
+        }
+
+        kfree(ev);
+}
+
+static void
+mptscsih_send_sas_event(MPT_ADAPTER *ioc,
+                EVENT_DATA_SAS_DEVICE_STATUS_CHANGE *sas_event_data)
+{
+        struct mptsas_hotplug_event *ev;
+        u32 device_info = le32_to_cpu(sas_event_data->DeviceInfo);
+        __le64 sas_address;
+
+        if ((device_info &
+             (MPI_SAS_DEVICE_INFO_SSP_TARGET |
+              MPI_SAS_DEVICE_INFO_STP_TARGET |
+              MPI_SAS_DEVICE_INFO_SATA_DEVICE )) == 0)
+                return;
+
+        if ((sas_event_data->ReasonCode &
+             (MPI_EVENT_SAS_DEV_STAT_RC_ADDED |
+              MPI_EVENT_SAS_DEV_STAT_RC_NOT_RESPONDING)) == 0)
+                return;
+
+        ev = kmalloc(sizeof(*ev), GFP_ATOMIC);
+        if (!ev) {
+                printk(KERN_WARNING "mptsas: lost hotplug event\n");
+                return;
+        }
+
+
+        INIT_WORK(&ev->work, mptsas_hotplug_work, ev);
+        ev->ioc = ioc;
+        ev->handle = le16_to_cpu(sas_event_data->DevHandle);
+        ev->parent_handle = le16_to_cpu(sas_event_data->ParentDevHandle);
+        ev->channel = sas_event_data->Bus;
+        ev->id = sas_event_data->TargetID;
+        ev->phy_id = sas_event_data->PhyNum;
+        memcpy(&sas_address, &sas_event_data->SASAddress, sizeof(__le64));
+        ev->sas_address = le64_to_cpu(sas_address);
+        ev->device_info = device_info;
+
+        if (sas_event_data->ReasonCode & MPI_EVENT_SAS_DEV_STAT_RC_ADDED)
+                ev->event_type = MPTSAS_ADD_DEVICE;
+        else
+                ev->event_type = MPTSAS_DEL_DEVICE;
+
+        schedule_work(&ev->work);
+}
+
+static int
+mptsas_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *reply)
+{
+        u8 event = le32_to_cpu(reply->Event) & 0xFF;
+
+        if (!ioc->sh)
+                return 1;
+
+        switch (event) {
+        case MPI_EVENT_SAS_DEVICE_STATUS_CHANGE:
+                mptscsih_send_sas_event(ioc,
+                        (EVENT_DATA_SAS_DEVICE_STATUS_CHANGE *)reply->Data);
+                return 1;               /* currently means nothing really */
+
+        default:
+                return mptscsih_event_process(ioc, reply);
+        }
+}
+
 static int
 mptsas_probe(struct pci_dev *pdev, const struct pci_device_id *id)
 {
@@ -1118,11 +1398,10 @@ mptsas_probe(struct pci_dev *pdev, const struct pci_device_id *id)
         MPT_SCSI_HOST           *hd;
         MPT_ADAPTER             *ioc;
         unsigned long            flags;
-        int                      sz, ii;
+        int                      ii;
         int                      numSGE = 0;
         int                      scale;
         int                      ioc_cap;
-        u8                      *mem;
         int                     error=0;
         int                     r;
 
@@ -1203,7 +1482,9 @@ mptsas_probe(struct pci_dev *pdev, const struct pci_device_id *id)
         sh->unique_id = ioc->id;
 
         INIT_LIST_HEAD(&ioc->sas_topology);
-        init_MUTEX(&ioc->sas_mgmt.mutex);
+        mutex_init(&ioc->sas_topology_mutex);
+
+        mutex_init(&ioc->sas_mgmt.mutex);
         init_completion(&ioc->sas_mgmt.done);
 
         /* Verify that we won't exceed the maximum
@@ -1244,36 +1525,27 @@ mptsas_probe(struct pci_dev *pdev, const struct pci_device_id *id)
         /* SCSI needs scsi_cmnd lookup table!
          * (with size equal to req_depth*PtrSz!)
          */
-        sz = ioc->req_depth * sizeof(void *);
-        mem = kmalloc(sz, GFP_ATOMIC);
-        if (mem == NULL) {
+        hd->ScsiLookup = kcalloc(ioc->req_depth, sizeof(void *), GFP_ATOMIC);
+        if (!hd->ScsiLookup) {
                 error = -ENOMEM;
                 goto out_mptsas_probe;
         }
 
-        memset(mem, 0, sz);
-        hd->ScsiLookup = (struct scsi_cmnd **) mem;
-
-        dprintk((MYIOC_s_INFO_FMT "ScsiLookup @ %p, sz=%d\n",
-                 ioc->name, hd->ScsiLookup, sz));
+        dprintk((MYIOC_s_INFO_FMT "ScsiLookup @ %p\n",
+                 ioc->name, hd->ScsiLookup));
 
         /* Allocate memory for the device structures.
          * A non-Null pointer at an offset
          * indicates a device exists.
          * max_id = 1 + maximum id (hosts.h)
          */
-        sz = sh->max_id * sizeof(void *);
-        mem = kmalloc(sz, GFP_ATOMIC);
-        if (mem == NULL) {
+        hd->Targets = kcalloc(sh->max_id, sizeof(void *), GFP_ATOMIC);
+        if (!hd->Targets) {
                 error = -ENOMEM;
                 goto out_mptsas_probe;
         }
 
-        memset(mem, 0, sz);
-        hd->Targets = (VirtTarget **) mem;
-
-        dprintk((KERN_INFO
-          "  vtarget @ %p, sz=%d\n", hd->Targets, sz));
+        dprintk((KERN_INFO "  vtarget @ %p\n", hd->Targets));
 
         /* Clear the TM flags
          */
@@ -1324,6 +1596,20 @@ mptsas_probe(struct pci_dev *pdev, const struct pci_device_id *id)
 
         mptsas_scan_sas_topology(ioc);
 
+        /*
+          Reporting RAID volumes.
+        */
+        if (!ioc->raid_data.pIocPg2)
+                return 0;
+        if (!ioc->raid_data.pIocPg2->NumActiveVolumes)
+                return 0;
+        for (ii=0;ii<ioc->raid_data.pIocPg2->NumActiveVolumes;ii++) {
+                scsi_add_device(sh,
+                        ioc->num_ports,
+                        ioc->raid_data.pIocPg2->RaidVolume[ii].VolumeID,
+                        0);
+        }
+
         return 0;
 
 out_mptsas_probe:
@@ -1339,10 +1625,12 @@ static void __devexit mptsas_remove(struct pci_dev *pdev)
 
         sas_remove_host(ioc->sh);
 
+        mutex_lock(&ioc->sas_topology_mutex);
         list_for_each_entry_safe(p, n, &ioc->sas_topology, list) {
                 list_del(&p->list);
                 kfree(p);
         }
+        mutex_unlock(&ioc->sas_topology_mutex);
 
         mptscsih_remove(pdev);
 }
@@ -1393,7 +1681,7 @@ mptsas_init(void)
                 mpt_register(mptscsih_scandv_complete, MPTSAS_DRIVER);
         mptsasMgmtCtx = mpt_register(mptsas_mgmt_done, MPTSAS_DRIVER);
 
-        if (mpt_event_register(mptsasDoneCtx, mptscsih_event_process) == 0) {
+        if (mpt_event_register(mptsasDoneCtx, mptsas_event_process) == 0) {
                 devtprintk((KERN_INFO MYNAM
                   ": Registered for IOC event notifications\n"));
         }
diff --git a/drivers/message/fusion/mptscsih.c b/drivers/message/fusion/mptscsih.c
index 93a16fa3c4ba..cdac5578fdf2 100644
--- a/drivers/message/fusion/mptscsih.c
+++ b/drivers/message/fusion/mptscsih.c
@@ -893,6 +893,7 @@ mptscsih_flush_running_cmds(MPT_SCSI_HOST *hd)
  *              when a lun is disable by mid-layer.
  *              Do NOT access the referenced scsi_cmnd structure or
  *              members. Will cause either a paging or NULL ptr error.
+ *              (BUT, BUT, BUT, the code does reference it! - mdr)
  *      @hd: Pointer to a SCSI HOST structure
  *      @vdevice: per device private data
  *
@@ -2162,10 +2163,9 @@ mptscsih_target_alloc(struct scsi_target *starget)
 {
         VirtTarget              *vtarget;
 
-        vtarget = kmalloc(sizeof(VirtTarget), GFP_KERNEL);
+        vtarget = kzalloc(sizeof(VirtTarget), GFP_KERNEL);
         if (!vtarget)
                 return -ENOMEM;
-        memset(vtarget, 0, sizeof(VirtTarget));
         starget->hostdata = vtarget;
         return 0;
 }
@@ -2185,14 +2185,13 @@ mptscsih_slave_alloc(struct scsi_device *sdev)
         VirtDevice              *vdev;
         struct scsi_target      *starget;
 
-        vdev = kmalloc(sizeof(VirtDevice), GFP_KERNEL);
+        vdev = kzalloc(sizeof(VirtDevice), GFP_KERNEL);
         if (!vdev) {
                 printk(MYIOC_s_ERR_FMT "slave_alloc kmalloc(%zd) FAILED!\n",
                                 hd->ioc->name, sizeof(VirtDevice));
                 return -ENOMEM;
         }
 
-        memset(vdev, 0, sizeof(VirtDevice));
         vdev->ioc_id = hd->ioc->id;
         vdev->target_id = sdev->id;
         vdev->bus_id = sdev->channel;
@@ -2559,13 +2558,25 @@ mptscsih_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
                         hd->cmdPtr = NULL;
                 }
 
-                /* 7. Set flag to force DV and re-read IOC Page 3
+                /* 7. SPI: Set flag to force DV and re-read IOC Page 3
                  */
                 if (ioc->bus_type == SPI) {
                         ioc->spi_data.forceDv = MPT_SCSICFG_NEED_DV | MPT_SCSICFG_RELOAD_IOC_PG3;
                         ddvtprintk(("Set reload IOC Pg3 Flag\n"));
                 }
 
+                /* 7. FC: Rescan for blocked rports which might have returned.
+                 */
+                else if (ioc->bus_type == FC) {
+                        int work_count;
+                        unsigned long flags;
+
+                        spin_lock_irqsave(&ioc->fc_rescan_work_lock, flags);
+                        work_count = ++ioc->fc_rescan_work_count;
+                        spin_unlock_irqrestore(&ioc->fc_rescan_work_lock, flags);
+                        if (work_count == 1)
+                                schedule_work(&ioc->fc_rescan_work);
+                }
                 dtmprintk((MYIOC_s_WARN_FMT "Post-Reset complete.\n", ioc->name));
 
         }
@@ -2589,6 +2600,8 @@ mptscsih_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply)
 {
         MPT_SCSI_HOST *hd;
         u8 event = le32_to_cpu(pEvReply->Event) & 0xFF;
+        int work_count;
+        unsigned long flags;
 
         devtprintk((MYIOC_s_INFO_FMT "MPT event (=%02Xh) routed to SCSI host driver!\n",
                         ioc->name, event));
@@ -2610,11 +2623,18 @@ mptscsih_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply)
                 /* FIXME! */
                 break;
 
+        case MPI_EVENT_RESCAN:                          /* 06 */
+                spin_lock_irqsave(&ioc->fc_rescan_work_lock, flags);
+                work_count = ++ioc->fc_rescan_work_count;
+                spin_unlock_irqrestore(&ioc->fc_rescan_work_lock, flags);
+                if (work_count == 1)
+                        schedule_work(&ioc->fc_rescan_work);
+                break;
+
                 /*
                  *  CHECKME! Don't think we need to do
                  *  anything for these, but...
                  */
-        case MPI_EVENT_RESCAN:                          /* 06 */
         case MPI_EVENT_LINK_STATUS_CHANGE:              /* 07 */
         case MPI_EVENT_LOOP_STATE_CHANGE:               /* 08 */
                 /*
@@ -3954,8 +3974,6 @@ mptscsih_synchronize_cache(MPT_SCSI_HOST *hd, VirtDevice *vdevice)
 
 /* Search IOC page 3 to determine if this is hidden physical disk
  */
-/* Search IOC page 3 to determine if this is hidden physical disk
- */
 static int
 mptscsih_is_phys_disk(MPT_ADAPTER *ioc, int id)
 {
diff --git a/drivers/message/fusion/mptspi.c b/drivers/message/fusion/mptspi.c
index ce332a6085e5..7dce29277cb7 100644
--- a/drivers/message/fusion/mptspi.c
+++ b/drivers/message/fusion/mptspi.c
@@ -158,11 +158,10 @@ mptspi_probe(struct pci_dev *pdev, const struct pci_device_id *id)
         MPT_SCSI_HOST           *hd;
         MPT_ADAPTER             *ioc;
         unsigned long            flags;
-        int                      sz, ii;
+        int                      ii;
         int                      numSGE = 0;
         int                      scale;
         int                      ioc_cap;
-        u8                      *mem;
         int                     error=0;
         int                     r;
 
@@ -288,36 +287,27 @@ mptspi_probe(struct pci_dev *pdev, const struct pci_device_id *id)
         /* SCSI needs scsi_cmnd lookup table!
          * (with size equal to req_depth*PtrSz!)
          */
-        sz = ioc->req_depth * sizeof(void *);
-        mem = kmalloc(sz, GFP_ATOMIC);
-        if (mem == NULL) {
+        hd->ScsiLookup = kcalloc(ioc->req_depth, sizeof(void *), GFP_ATOMIC);
+        if (!hd->ScsiLookup) {
                 error = -ENOMEM;
                 goto out_mptspi_probe;
         }
 
-        memset(mem, 0, sz);
-        hd->ScsiLookup = (struct scsi_cmnd **) mem;
-
-        dprintk((MYIOC_s_INFO_FMT "ScsiLookup @ %p, sz=%d\n",
-                 ioc->name, hd->ScsiLookup, sz));
+        dprintk((MYIOC_s_INFO_FMT "ScsiLookup @ %p\n",
+                 ioc->name, hd->ScsiLookup));
 
         /* Allocate memory for the device structures.
          * A non-Null pointer at an offset
          * indicates a device exists.
          * max_id = 1 + maximum id (hosts.h)
          */
-        sz = sh->max_id * sizeof(void *);
-        mem = kmalloc(sz, GFP_ATOMIC);
-        if (mem == NULL) {
+        hd->Targets = kcalloc(sh->max_id, sizeof(void *), GFP_ATOMIC);
+        if (!hd->Targets) {
                 error = -ENOMEM;
                 goto out_mptspi_probe;
         }
 
-        memset(mem, 0, sz);
-        hd->Targets = (VirtTarget **) mem;
-
-        dprintk((KERN_INFO
-          "  vdev @ %p, sz=%d\n", hd->Targets, sz));
+        dprintk((KERN_INFO "  vdev @ %p\n", hd->Targets));
 
         /* Clear the TM flags
          */
diff --git a/drivers/message/i2o/pci.c b/drivers/message/i2o/pci.c
index c5b656cdea7c..d698d7709c31 100644
--- a/drivers/message/i2o/pci.c
+++ b/drivers/message/i2o/pci.c
@@ -88,11 +88,6 @@ static int __devinit i2o_pci_alloc(struct i2o_controller *c)
         struct device *dev = &pdev->dev;
         int i;
 
-        if (pci_request_regions(pdev, OSM_DESCRIPTION)) {
-                printk(KERN_ERR "%s: device already claimed\n", c->name);
-                return -ENODEV;
-        }
-
         for (i = 0; i < 6; i++) {
                 /* Skip I/O spaces */
                 if (!(pci_resource_flags(pdev, i) & IORESOURCE_IO)) {
@@ -319,6 +314,11 @@ static int __devinit i2o_pci_probe(struct pci_dev *pdev,
                 return rc;
         }
 
+        if (pci_request_regions(pdev, OSM_DESCRIPTION)) {
+                printk(KERN_ERR "i2o: device already claimed\n");
+                return -ENODEV;
+        }
+
         if (pci_set_dma_mask(pdev, DMA_32BIT_MASK)) {
                 printk(KERN_WARNING "i2o: no suitable DMA found for %s\n",
                        pci_name(pdev));
diff --git a/drivers/mfd/mcp-core.c b/drivers/mfd/mcp-core.c
index 55ba23075c90..75f401d52fda 100644
--- a/drivers/mfd/mcp-core.c
+++ b/drivers/mfd/mcp-core.c
@@ -77,6 +77,8 @@ static int mcp_bus_resume(struct device *dev)
 static struct bus_type mcp_bus_type = {
         .name           = "mcp",
         .match          = mcp_bus_match,
+        .probe          = mcp_bus_probe,
+        .remove         = mcp_bus_remove,
         .suspend        = mcp_bus_suspend,
         .resume         = mcp_bus_resume,
 };
@@ -227,8 +229,6 @@ EXPORT_SYMBOL(mcp_host_unregister);
 int mcp_driver_register(struct mcp_driver *mcpdrv)
 {
         mcpdrv->drv.bus = &mcp_bus_type;
-        mcpdrv->drv.probe = mcp_bus_probe;
-        mcpdrv->drv.remove = mcp_bus_remove;
         return driver_register(&mcpdrv->drv);
 }
 EXPORT_SYMBOL(mcp_driver_register);
diff --git a/drivers/mmc/mmc_sysfs.c b/drivers/mmc/mmc_sysfs.c
index ec701667abfc..a2a35fd946ee 100644
--- a/drivers/mmc/mmc_sysfs.c
+++ b/drivers/mmc/mmc_sysfs.c
@@ -136,17 +136,7 @@ static int mmc_bus_resume(struct device *dev)
         return ret;
 }
 
-static struct bus_type mmc_bus_type = {
-        .name           = "mmc",
-        .dev_attrs      = mmc_dev_attrs,
-        .match          = mmc_bus_match,
-        .uevent         = mmc_bus_uevent,
-        .suspend        = mmc_bus_suspend,
-        .resume         = mmc_bus_resume,
-};
-
-
-static int mmc_drv_probe(struct device *dev)
+static int mmc_bus_probe(struct device *dev)
 {
         struct mmc_driver *drv = to_mmc_driver(dev->driver);
         struct mmc_card *card = dev_to_mmc_card(dev);
@@ -154,7 +144,7 @@ static int mmc_drv_probe(struct device *dev)
         return drv->probe(card);
 }
 
-static int mmc_drv_remove(struct device *dev)
+static int mmc_bus_remove(struct device *dev)
 {
         struct mmc_driver *drv = to_mmc_driver(dev->driver);
         struct mmc_card *card = dev_to_mmc_card(dev);
@@ -164,6 +154,16 @@ static int mmc_drv_remove(struct device *dev)
         return 0;
 }
 
+static struct bus_type mmc_bus_type = {
+        .name           = "mmc",
+        .dev_attrs      = mmc_dev_attrs,
+        .match          = mmc_bus_match,
+        .uevent         = mmc_bus_uevent,
+        .probe          = mmc_bus_probe,
+        .remove         = mmc_bus_remove,
+        .suspend        = mmc_bus_suspend,
+        .resume         = mmc_bus_resume,
+};
 
 /**
  *      mmc_register_driver - register a media driver
@@ -172,8 +172,6 @@ static int mmc_drv_remove(struct device *dev)
 int mmc_register_driver(struct mmc_driver *drv)
 {
         drv->drv.bus = &mmc_bus_type;
-        drv->drv.probe = mmc_drv_probe;
-        drv->drv.remove = mmc_drv_remove;
         return driver_register(&drv->drv);
 }
 
diff --git a/drivers/mtd/devices/Kconfig b/drivers/mtd/devices/Kconfig
index 9a2aa4033c6a..5038e90ceb12 100644
--- a/drivers/mtd/devices/Kconfig
+++ b/drivers/mtd/devices/Kconfig
@@ -47,6 +47,22 @@ config MTD_MS02NV
           accelerator.  Say Y here if you have a DECstation 5000/2x0 or a
           DECsystem 5900 equipped with such a module.
 
+config MTD_DATAFLASH
+        tristate "Support for AT45xxx DataFlash"
+        depends on MTD && SPI_MASTER && EXPERIMENTAL
+        help
+          This enables access to AT45xxx DataFlash chips, using SPI.
+          Sometimes DataFlash chips are packaged inside MMC-format
+          cards; at this writing, the MMC stack won't handle those.
+
+config MTD_M25P80
+        tristate "Support for M25 SPI Flash"
+        depends on MTD && SPI_MASTER && EXPERIMENTAL
+        help
+          This enables access to ST M25P80 and similar SPI flash chips,
+          used for program and data storage.  Set up your spi devices
+          with the right board-specific platform data.
+
 config MTD_SLRAM
         tristate "Uncached system RAM"
         depends on MTD
diff --git a/drivers/mtd/devices/Makefile b/drivers/mtd/devices/Makefile
index e38db348057d..7c5ed2178380 100644
--- a/drivers/mtd/devices/Makefile
+++ b/drivers/mtd/devices/Makefile
@@ -23,3 +23,5 @@ obj-$(CONFIG_MTD_MTDRAM)	+= mtdram.o
 obj-$(CONFIG_MTD_LART)          += lart.o
 obj-$(CONFIG_MTD_BLKMTD)        += blkmtd.o
 obj-$(CONFIG_MTD_BLOCK2MTD)     += block2mtd.o
+obj-$(CONFIG_MTD_DATAFLASH)     += mtd_dataflash.o
+obj-$(CONFIG_MTD_M25P80)        += m25p80.o
diff --git a/drivers/mtd/devices/doc2000.c b/drivers/mtd/devices/doc2000.c
index be5e88b3888d..e4345cf744a2 100644
--- a/drivers/mtd/devices/doc2000.c
+++ b/drivers/mtd/devices/doc2000.c
@@ -138,7 +138,7 @@ static inline int DoC_WaitReady(struct DiskOnChip *doc)
    bypass the internal pipeline. Each of 4 delay cycles (read from the NOP register) is
    required after writing to CDSN Control register, see Software Requirement 11.4 item 3. */
 
-static inline int DoC_Command(struct DiskOnChip *doc, unsigned char command,
+static int DoC_Command(struct DiskOnChip *doc, unsigned char command,
                               unsigned char xtraflags)
 {
         void __iomem *docptr = doc->virtadr;
diff --git a/drivers/mtd/devices/doc2001.c b/drivers/mtd/devices/doc2001.c
index fcb28a6fd89f..681a9c73a2a3 100644
--- a/drivers/mtd/devices/doc2001.c
+++ b/drivers/mtd/devices/doc2001.c
@@ -103,7 +103,7 @@ static inline int DoC_WaitReady(void __iomem * docptr)
    with the internal pipeline. Each of 4 delay cycles (read from the NOP register) is
    required after writing to CDSN Control register, see Software Requirement 11.4 item 3. */
 
-static inline void DoC_Command(void __iomem * docptr, unsigned char command,
+static void DoC_Command(void __iomem * docptr, unsigned char command,
                                unsigned char xtraflags)
 {
         /* Assert the CLE (Command Latch Enable) line to the flash chip */
diff --git a/drivers/mtd/devices/doc2001plus.c b/drivers/mtd/devices/doc2001plus.c
index 0595cc7324b2..5f57f29efee4 100644
--- a/drivers/mtd/devices/doc2001plus.c
+++ b/drivers/mtd/devices/doc2001plus.c
@@ -118,7 +118,7 @@ static inline void DoC_CheckASIC(void __iomem * docptr)
 /* DoC_Command: Send a flash command to the flash chip through the Flash
  * command register. Need 2 Write Pipeline Terminates to complete send.
  */
-static inline void DoC_Command(void __iomem * docptr, unsigned char command,
+static void DoC_Command(void __iomem * docptr, unsigned char command,
                                unsigned char xtraflags)
 {
         WriteDOC(command, docptr, Mplus_FlashCmd);
diff --git a/drivers/mtd/devices/m25p80.c b/drivers/mtd/devices/m25p80.c
new file mode 100644
index 000000000000..d5f24089be71
--- /dev/null
+++ b/drivers/mtd/devices/m25p80.c
@@ -0,0 +1,582 @@
+/*
+ * MTD SPI driver for ST M25Pxx flash chips
+ *
+ * Author: Mike Lavender, mike@steroidmicros.com
+ *
+ * Copyright (c) 2005, Intec Automation Inc.
+ *
+ * Some parts are based on lart.c by Abraham Van Der Merwe
+ *
+ * Cleaned up and generalized based on mtd_dataflash.c
+ *
+ * This code 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.
+ *
+ */
+
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/device.h>
+#include <linux/interrupt.h>
+#include <linux/interrupt.h>
+#include <linux/mtd/mtd.h>
+#include <linux/mtd/partitions.h>
+#include <linux/spi/spi.h>
+#include <linux/spi/flash.h>
+
+#include <asm/semaphore.h>
+
+
+/* NOTE: AT 25F and SST 25LF series are very similar,
+ * but commands for sector erase and chip id differ...
+ */
+
+#define FLASH_PAGESIZE          256
+
+/* Flash opcodes. */
+#define OPCODE_WREN             6       /* Write enable */
+#define OPCODE_RDSR             5       /* Read status register */
+#define OPCODE_READ             3       /* Read data bytes */
+#define OPCODE_PP               2       /* Page program */
+#define OPCODE_SE               0xd8    /* Sector erase */
+#define OPCODE_RES              0xab    /* Read Electronic Signature */
+#define OPCODE_RDID             0x9f    /* Read JEDEC ID */
+
+/* Status Register bits. */
+#define SR_WIP                  1       /* Write in progress */
+#define SR_WEL                  2       /* Write enable latch */
+#define SR_BP0                  4       /* Block protect 0 */
+#define SR_BP1                  8       /* Block protect 1 */
+#define SR_BP2                  0x10    /* Block protect 2 */
+#define SR_SRWD                 0x80    /* SR write protect */
+
+/* Define max times to check status register before we give up. */
+#define MAX_READY_WAIT_COUNT    100000
+
+
+#ifdef CONFIG_MTD_PARTITIONS
+#define mtd_has_partitions()    (1)
+#else
+#define mtd_has_partitions()    (0)
+#endif
+
+/****************************************************************************/
+
+struct m25p {
+        struct spi_device       *spi;
+        struct semaphore        lock;
+        struct mtd_info         mtd;
+        unsigned                partitioned;
+        u8                      command[4];
+};
+
+static inline struct m25p *mtd_to_m25p(struct mtd_info *mtd)
+{
+        return container_of(mtd, struct m25p, mtd);
+}
+
+/****************************************************************************/
+
+/*
+ * Internal helper functions
+ */
+
+/*
+ * Read the status register, returning its value in the location
+ * Return the status register value.
+ * Returns negative if error occurred.
+ */
+static int read_sr(struct m25p *flash)
+{
+        ssize_t retval;
+        u8 code = OPCODE_RDSR;
+        u8 val;
+
+        retval = spi_write_then_read(flash->spi, &code, 1, &val, 1);
+
+        if (retval < 0) {
+                dev_err(&flash->spi->dev, "error %d reading SR\n",
+                                (int) retval);
+                return retval;
+        }
+
+        return val;
+}
+
+
+/*
+ * Set write enable latch with Write Enable command.
+ * Returns negative if error occurred.
+ */
+static inline int write_enable(struct m25p *flash)
+{
+        u8      code = OPCODE_WREN;
+
+        return spi_write_then_read(flash->spi, &code, 1, NULL, 0);
+}
+
+
+/*
+ * Service routine to read status register until ready, or timeout occurs.
+ * Returns non-zero if error.
+ */
+static int wait_till_ready(struct m25p *flash)
+{
+        int count;
+        int sr;
+
+        /* one chip guarantees max 5 msec wait here after page writes,
+         * but potentially three seconds (!) after page erase.
+         */
+        for (count = 0; count < MAX_READY_WAIT_COUNT; count++) {
+                if ((sr = read_sr(flash)) < 0)
+                        break;
+                else if (!(sr & SR_WIP))
+                        return 0;
+
+                /* REVISIT sometimes sleeping would be best */
+        }
+
+        return 1;
+}
+
+
+/*
+ * Erase one sector of flash memory at offset ``offset'' which is any
+ * address within the sector which should be erased.
+ *
+ * Returns 0 if successful, non-zero otherwise.
+ */
+static int erase_sector(struct m25p *flash, u32 offset)
+{
+        DEBUG(MTD_DEBUG_LEVEL3, "%s: %s at 0x%08x\n", flash->spi->dev.bus_id,
+                        __FUNCTION__, offset);
+
+        /* Wait until finished previous write command. */
+        if (wait_till_ready(flash))
+                return 1;
+
+        /* Send write enable, then erase commands. */
+        write_enable(flash);
+
+        /* Set up command buffer. */
+        flash->command[0] = OPCODE_SE;
+        flash->command[1] = offset >> 16;
+        flash->command[2] = offset >> 8;
+        flash->command[3] = offset;
+
+        spi_write(flash->spi, flash->command, sizeof(flash->command));
+
+        return 0;
+}
+
+/****************************************************************************/
+
+/*
+ * MTD implementation
+ */
+
+/*
+ * Erase an address range on the flash chip.  The address range may extend
+ * one or more erase sectors.  Return an error is there is a problem erasing.
+ */
+static int m25p80_erase(struct mtd_info *mtd, struct erase_info *instr)
+{
+        struct m25p *flash = mtd_to_m25p(mtd);
+        u32 addr,len;
+
+        DEBUG(MTD_DEBUG_LEVEL2, "%s: %s %s 0x%08x, len %zd\n",
+                        flash->spi->dev.bus_id, __FUNCTION__, "at",
+                        (u32)instr->addr, instr->len);
+
+        /* sanity checks */
+        if (instr->addr + instr->len > flash->mtd.size)
+                return -EINVAL;
+        if ((instr->addr % mtd->erasesize) != 0
+                        || (instr->len % mtd->erasesize) != 0) {
+                return -EINVAL;
+        }
+
+        addr = instr->addr;
+        len = instr->len;
+
+        down(&flash->lock);
+
+        /* now erase those sectors */
+        while (len) {
+                if (erase_sector(flash, addr)) {
+                        instr->state = MTD_ERASE_FAILED;
+                        up(&flash->lock);
+                        return -EIO;
+                }
+
+                addr += mtd->erasesize;
+                len -= mtd->erasesize;
+        }
+
+        up(&flash->lock);
+
+        instr->state = MTD_ERASE_DONE;
+        mtd_erase_callback(instr);
+
+        return 0;
+}
+
+/*
+ * Read an address range from the flash chip.  The address range
+ * may be any size provided it is within the physical boundaries.
+ */
+static int m25p80_read(struct mtd_info *mtd, loff_t from, size_t len,
+        size_t *retlen, u_char *buf)
+{
+        struct m25p *flash = mtd_to_m25p(mtd);
+        struct spi_transfer t[2];
+        struct spi_message m;
+
+        DEBUG(MTD_DEBUG_LEVEL2, "%s: %s %s 0x%08x, len %zd\n",
+                        flash->spi->dev.bus_id, __FUNCTION__, "from",
+                        (u32)from, len);
+
+        /* sanity checks */
+        if (!len)
+                return 0;
+
+        if (from + len > flash->mtd.size)
+                return -EINVAL;
+
+        spi_message_init(&m);
+        memset(t, 0, (sizeof t));
+
+        t[0].tx_buf = flash->command;
+        t[0].len = sizeof(flash->command);
+        spi_message_add_tail(&t[0], &m);
+
+        t[1].rx_buf = buf;
+        t[1].len = len;
+        spi_message_add_tail(&t[1], &m);
+
+        /* Byte count starts at zero. */
+        if (retlen)
+                *retlen = 0;
+
+        down(&flash->lock);
+
+        /* Wait till previous write/erase is done. */
+        if (wait_till_ready(flash)) {
+                /* REVISIT status return?? */
+                up(&flash->lock);
+                return 1;
+        }
+
+        /* NOTE:  OPCODE_FAST_READ (if available) is faster... */
+
+        /* Set up the write data buffer. */
+        flash->command[0] = OPCODE_READ;
+        flash->command[1] = from >> 16;
+        flash->command[2] = from >> 8;
+        flash->command[3] = from;
+
+        spi_sync(flash->spi, &m);
+
+        *retlen = m.actual_length - sizeof(flash->command);
+
+        up(&flash->lock);
+
+        return 0;
+}
+
+/*
+ * Write an address range to the flash chip.  Data must be written in
+ * FLASH_PAGESIZE chunks.  The address range may be any size provided
+ * it is within the physical boundaries.
+ */
+static int m25p80_write(struct mtd_info *mtd, loff_t to, size_t len,
+        size_t *retlen, const u_char *buf)
+{
+        struct m25p *flash = mtd_to_m25p(mtd);
+        u32 page_offset, page_size;
+        struct spi_transfer t[2];
+        struct spi_message m;
+
+        DEBUG(MTD_DEBUG_LEVEL2, "%s: %s %s 0x%08x, len %zd\n",
+                        flash->spi->dev.bus_id, __FUNCTION__, "to",
+                        (u32)to, len);
+
+        if (retlen)
+                *retlen = 0;
+
+        /* sanity checks */
+        if (!len)
+                return(0);
+
+        if (to + len > flash->mtd.size)
+                return -EINVAL;
+
+        spi_message_init(&m);
+        memset(t, 0, (sizeof t));
+
+        t[0].tx_buf = flash->command;
+        t[0].len = sizeof(flash->command);
+        spi_message_add_tail(&t[0], &m);
+
+        t[1].tx_buf = buf;
+        spi_message_add_tail(&t[1], &m);
+
+        down(&flash->lock);
+
+        /* Wait until finished previous write command. */
+        if (wait_till_ready(flash))
+                return 1;
+
+        write_enable(flash);
+
+        /* Set up the opcode in the write buffer. */
+        flash->command[0] = OPCODE_PP;
+        flash->command[1] = to >> 16;
+        flash->command[2] = to >> 8;
+        flash->command[3] = to;
+
+        /* what page do we start with? */
+        page_offset = to % FLASH_PAGESIZE;
+
+        /* do all the bytes fit onto one page? */
+        if (page_offset + len <= FLASH_PAGESIZE) {
+                t[1].len = len;
+
+                spi_sync(flash->spi, &m);
+
+                *retlen = m.actual_length - sizeof(flash->command);
+        } else {
+                u32 i;
+
+                /* the size of data remaining on the first page */
+                page_size = FLASH_PAGESIZE - page_offset;
+
+                t[1].len = page_size;
+                spi_sync(flash->spi, &m);
+
+                *retlen = m.actual_length - sizeof(flash->command);
+
+                /* write everything in PAGESIZE chunks */
+                for (i = page_size; i < len; i += page_size) {
+                        page_size = len - i;
+                        if (page_size > FLASH_PAGESIZE)
+                                page_size = FLASH_PAGESIZE;
+
+                        /* write the next page to flash */
+                        flash->command[1] = (to + i) >> 16;
+                        flash->command[2] = (to + i) >> 8;
+                        flash->command[3] = (to + i);
+
+                        t[1].tx_buf = buf + i;
+                        t[1].len = page_size;
+
+                        wait_till_ready(flash);
+
+                        write_enable(flash);
+
+                        spi_sync(flash->spi, &m);
+
+                        if (retlen)
+                                *retlen += m.actual_length
+                                        - sizeof(flash->command);
+                }
+        }
+
+        up(&flash->lock);
+
+        return 0;
+}
+
+
+/****************************************************************************/
+
+/*
+ * SPI device driver setup and teardown
+ */
+
+struct flash_info {
+        char            *name;
+        u8              id;
+        u16             jedec_id;
+        unsigned        sector_size;
+        unsigned        n_sectors;
+};
+
+static struct flash_info __devinitdata m25p_data [] = {
+        /* REVISIT: fill in JEDEC ids, for parts that have them */
+        { "m25p05", 0x05, 0x0000, 32 * 1024, 2 },
+        { "m25p10", 0x10, 0x0000, 32 * 1024, 4 },
+        { "m25p20", 0x11, 0x0000, 64 * 1024, 4 },
+        { "m25p40", 0x12, 0x0000, 64 * 1024, 8 },
+        { "m25p80", 0x13, 0x0000, 64 * 1024, 16 },
+        { "m25p16", 0x14, 0x0000, 64 * 1024, 32 },
+        { "m25p32", 0x15, 0x0000, 64 * 1024, 64 },
+        { "m25p64", 0x16, 0x2017, 64 * 1024, 128 },
+};
+
+/*
+ * board specific setup should have ensured the SPI clock used here
+ * matches what the READ command supports, at least until this driver
+ * understands FAST_READ (for clocks over 25 MHz).
+ */
+static int __devinit m25p_probe(struct spi_device *spi)
+{
+        struct flash_platform_data      *data;
+        struct m25p                     *flash;
+        struct flash_info               *info;
+        unsigned                        i;
+
+        /* Platform data helps sort out which chip type we have, as
+         * well as how this board partitions it.
+         */
+        data = spi->dev.platform_data;
+        if (!data || !data->type) {
+                /* FIXME some chips can identify themselves with RES
+                 * or JEDEC get-id commands.  Try them ...
+                 */
+                DEBUG(MTD_DEBUG_LEVEL1, "%s: no chip id\n",
+                                flash->spi->dev.bus_id);
+                return -ENODEV;
+        }
+
+        for (i = 0, info = m25p_data; i < ARRAY_SIZE(m25p_data); i++, info++) {
+                if (strcmp(data->type, info->name) == 0)
+                        break;
+        }
+        if (i == ARRAY_SIZE(m25p_data)) {
+                DEBUG(MTD_DEBUG_LEVEL1, "%s: unrecognized id %s\n",
+                                flash->spi->dev.bus_id, data->type);
+                return -ENODEV;
+        }
+
+        flash = kzalloc(sizeof *flash, SLAB_KERNEL);
+        if (!flash)
+                return -ENOMEM;
+
+        flash->spi = spi;
+        init_MUTEX(&flash->lock);
+        dev_set_drvdata(&spi->dev, flash);
+
+        if (data->name)
+                flash->mtd.name = data->name;
+        else
+                flash->mtd.name = spi->dev.bus_id;
+
+        flash->mtd.type = MTD_NORFLASH;
+        flash->mtd.flags = MTD_CAP_NORFLASH;
+        flash->mtd.size = info->sector_size * info->n_sectors;
+        flash->mtd.erasesize = info->sector_size;
+        flash->mtd.erase = m25p80_erase;
+        flash->mtd.read = m25p80_read;
+        flash->mtd.write = m25p80_write;
+
+        dev_info(&spi->dev, "%s (%d Kbytes)\n", info->name,
+                        flash->mtd.size / 1024);
+
+        DEBUG(MTD_DEBUG_LEVEL2,
+                "mtd .name = %s, .size = 0x%.8x (%uM) "
+                        ".erasesize = 0x%.8x (%uK) .numeraseregions = %d\n",
+                flash->mtd.name,
+                flash->mtd.size, flash->mtd.size / (1024*1024),
+                flash->mtd.erasesize, flash->mtd.erasesize / 1024,
+                flash->mtd.numeraseregions);
+
+        if (flash->mtd.numeraseregions)
+                for (i = 0; i < flash->mtd.numeraseregions; i++)
+                        DEBUG(MTD_DEBUG_LEVEL2,
+                                "mtd.eraseregions[%d] = { .offset = 0x%.8x, "
+                                ".erasesize = 0x%.8x (%uK), "
+                                ".numblocks = %d }\n",
+                                i, flash->mtd.eraseregions[i].offset,
+                                flash->mtd.eraseregions[i].erasesize,
+                                flash->mtd.eraseregions[i].erasesize / 1024,
+                                flash->mtd.eraseregions[i].numblocks);
+
+
+        /* partitions should match sector boundaries; and it may be good to
+         * use readonly partitions for writeprotected sectors (BP2..BP0).
+         */
+        if (mtd_has_partitions()) {
+                struct mtd_partition    *parts = NULL;
+                int                     nr_parts = 0;
+
+#ifdef CONFIG_MTD_CMDLINE_PARTS
+                static const char *part_probes[] = { "cmdlinepart", NULL, };
+
+                nr_parts = parse_mtd_partitions(&flash->mtd,
+                                part_probes, &parts, 0);
+#endif
+
+                if (nr_parts <= 0 && data && data->parts) {
+                        parts = data->parts;
+                        nr_parts = data->nr_parts;
+                }
+
+                if (nr_parts > 0) {
+                        for (i = 0; i < data->nr_parts; i++) {
+                                DEBUG(MTD_DEBUG_LEVEL2, "partitions[%d] = "
+                                        "{.name = %s, .offset = 0x%.8x, "
+                                                ".size = 0x%.8x (%uK) }\n",
+                                        i, data->parts[i].name,
+                                        data->parts[i].offset,
+                                        data->parts[i].size,
+                                        data->parts[i].size / 1024);
+                        }
+                        flash->partitioned = 1;
+                        return add_mtd_partitions(&flash->mtd, parts, nr_parts);
+                }
+        } else if (data->nr_parts)
+                dev_warn(&spi->dev, "ignoring %d default partitions on %s\n",
+                                data->nr_parts, data->name);
+
+        return add_mtd_device(&flash->mtd) == 1 ? -ENODEV : 0;
+}
+
+
+static int __devexit m25p_remove(struct spi_device *spi)
+{
+        struct m25p     *flash = dev_get_drvdata(&spi->dev);
+        int             status;
+
+        /* Clean up MTD stuff. */
+        if (mtd_has_partitions() && flash->partitioned)
+                status = del_mtd_partitions(&flash->mtd);
+        else
+                status = del_mtd_device(&flash->mtd);
+        if (status == 0)
+                kfree(flash);
+        return 0;
+}
+
+
+static struct spi_driver m25p80_driver = {
+        .driver = {
+                .name   = "m25p80",
+                .bus    = &spi_bus_type,
+                .owner  = THIS_MODULE,
+        },
+        .probe  = m25p_probe,
+        .remove = __devexit_p(m25p_remove),
+};
+
+
+static int m25p80_init(void)
+{
+        return spi_register_driver(&m25p80_driver);
+}
+
+
+static void m25p80_exit(void)
+{
+        spi_unregister_driver(&m25p80_driver);
+}
+
+
+module_init(m25p80_init);
+module_exit(m25p80_exit);
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Mike Lavender");
+MODULE_DESCRIPTION("MTD SPI driver for ST M25Pxx flash chips");
diff --git a/drivers/mtd/devices/mtd_dataflash.c b/drivers/mtd/devices/mtd_dataflash.c
new file mode 100644
index 000000000000..155737e7483f
--- /dev/null
+++ b/drivers/mtd/devices/mtd_dataflash.c
@@ -0,0 +1,629 @@
+/*
+ * Atmel AT45xxx DataFlash MTD driver for lightweight SPI framework
+ *
+ * Largely derived from at91_dataflash.c:
+ *  Copyright (C) 2003-2005 SAN People (Pty) Ltd
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+*/
+#include <linux/config.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/delay.h>
+#include <linux/device.h>
+#include <linux/spi/spi.h>
+#include <linux/spi/flash.h>
+
+#include <linux/mtd/mtd.h>
+#include <linux/mtd/partitions.h>
+
+
+/*
+ * DataFlash is a kind of SPI flash.  Most AT45 chips have two buffers in
+ * each chip, which may be used for double buffered I/O; but this driver
+ * doesn't (yet) use these for any kind of i/o overlap or prefetching.
+ *
+ * Sometimes DataFlash is packaged in MMC-format cards, although the
+ * MMC stack can't use SPI (yet), or distinguish between MMC and DataFlash
+ * protocols during enumeration.
+ */
+
+#define CONFIG_DATAFLASH_WRITE_VERIFY
+
+/* reads can bypass the buffers */
+#define OP_READ_CONTINUOUS      0xE8
+#define OP_READ_PAGE            0xD2
+
+/* group B requests can run even while status reports "busy" */
+#define OP_READ_STATUS          0xD7    /* group B */
+
+/* move data between host and buffer */
+#define OP_READ_BUFFER1         0xD4    /* group B */
+#define OP_READ_BUFFER2         0xD6    /* group B */
+#define OP_WRITE_BUFFER1        0x84    /* group B */
+#define OP_WRITE_BUFFER2        0x87    /* group B */
+
+/* erasing flash */
+#define OP_ERASE_PAGE           0x81
+#define OP_ERASE_BLOCK          0x50
+
+/* move data between buffer and flash */
+#define OP_TRANSFER_BUF1        0x53
+#define OP_TRANSFER_BUF2        0x55
+#define OP_MREAD_BUFFER1        0xD4
+#define OP_MREAD_BUFFER2        0xD6
+#define OP_MWERASE_BUFFER1      0x83
+#define OP_MWERASE_BUFFER2      0x86
+#define OP_MWRITE_BUFFER1       0x88    /* sector must be pre-erased */
+#define OP_MWRITE_BUFFER2       0x89    /* sector must be pre-erased */
+
+/* write to buffer, then write-erase to flash */
+#define OP_PROGRAM_VIA_BUF1     0x82
+#define OP_PROGRAM_VIA_BUF2     0x85
+
+/* compare buffer to flash */
+#define OP_COMPARE_BUF1         0x60
+#define OP_COMPARE_BUF2         0x61
+
+/* read flash to buffer, then write-erase to flash */
+#define OP_REWRITE_VIA_BUF1     0x58
+#define OP_REWRITE_VIA_BUF2     0x59
+
+/* newer chips report JEDEC manufacturer and device IDs; chip
+ * serial number and OTP bits; and per-sector writeprotect.
+ */
+#define OP_READ_ID              0x9F
+#define OP_READ_SECURITY        0x77
+#define OP_WRITE_SECURITY       0x9A    /* OTP bits */
+
+
+struct dataflash {
+        u8                      command[4];
+        char                    name[24];
+
+        unsigned                partitioned:1;
+
+        unsigned short          page_offset;    /* offset in flash address */
+        unsigned int            page_size;      /* of bytes per page */
+
+        struct semaphore        lock;
+        struct spi_device       *spi;
+
+        struct mtd_info         mtd;
+};
+
+#ifdef CONFIG_MTD_PARTITIONS
+#define mtd_has_partitions()    (1)
+#else
+#define mtd_has_partitions()    (0)
+#endif
+
+/* ......................................................................... */
+
+/*
+ * Return the status of the DataFlash device.
+ */
+static inline int dataflash_status(struct spi_device *spi)
+{
+        /* NOTE:  at45db321c over 25 MHz wants to write
+         * a dummy byte after the opcode...
+         */
+        return spi_w8r8(spi, OP_READ_STATUS);
+}
+
+/*
+ * Poll the DataFlash device until it is READY.
+ * This usually takes 5-20 msec or so; more for sector erase.
+ */
+static int dataflash_waitready(struct spi_device *spi)
+{
+        int     status;
+
+        for (;;) {
+                status = dataflash_status(spi);
+                if (status < 0) {
+                        DEBUG(MTD_DEBUG_LEVEL1, "%s: status %d?\n",
+                                        spi->dev.bus_id, status);
+                        status = 0;
+                }
+
+                if (status & (1 << 7))  /* RDY/nBSY */
+                        return status;
+
+                msleep(3);
+        }
+}
+
+/* ......................................................................... */
+
+/*
+ * Erase pages of flash.
+ */
+static int dataflash_erase(struct mtd_info *mtd, struct erase_info *instr)
+{
+        struct dataflash        *priv = (struct dataflash *)mtd->priv;
+        struct spi_device       *spi = priv->spi;
+        struct spi_transfer     x = { .tx_dma = 0, };
+        struct spi_message      msg;
+        unsigned                blocksize = priv->page_size << 3;
+        u8                      *command;
+
+        DEBUG(MTD_DEBUG_LEVEL2, "%s: erase addr=0x%x len 0x%x\n",
+                        spi->dev.bus_id,
+                        instr->addr, instr->len);
+
+        /* Sanity checks */
+        if ((instr->addr + instr->len) > mtd->size
+                        || (instr->len % priv->page_size) != 0
+                        || (instr->addr % priv->page_size) != 0)
+                return -EINVAL;
+
+        spi_message_init(&msg);
+
+        x.tx_buf = command = priv->command;
+        x.len = 4;
+        spi_message_add_tail(&x, &msg);
+
+        down(&priv->lock);
+        while (instr->len > 0) {
+                unsigned int    pageaddr;
+                int             status;
+                int             do_block;
+
+                /* Calculate flash page address; use block erase (for speed) if
+                 * we're at a block boundary and need to erase the whole block.
+                 */
+                pageaddr = instr->addr / priv->page_size;
+                do_block = (pageaddr & 0x7) == 0 && instr->len <= blocksize;
+                pageaddr = pageaddr << priv->page_offset;
+
+                command[0] = do_block ? OP_ERASE_BLOCK : OP_ERASE_PAGE;
+                command[1] = (u8)(pageaddr >> 16);
+                command[2] = (u8)(pageaddr >> 8);
+                command[3] = 0;
+
+                DEBUG(MTD_DEBUG_LEVEL3, "ERASE %s: (%x) %x %x %x [%i]\n",
+                        do_block ? "block" : "page",
+                        command[0], command[1], command[2], command[3],
+                        pageaddr);
+
+                status = spi_sync(spi, &msg);
+                (void) dataflash_waitready(spi);
+
+                if (status < 0) {
+                        printk(KERN_ERR "%s: erase %x, err %d\n",
+                                spi->dev.bus_id, pageaddr, status);
+                        /* REVISIT:  can retry instr->retries times; or
+                         * giveup and instr->fail_addr = instr->addr;
+                         */
+                        continue;
+                }
+
+                if (do_block) {
+                        instr->addr += blocksize;
+                        instr->len -= blocksize;
+                } else {
+                        instr->addr += priv->page_size;
+                        instr->len -= priv->page_size;
+                }
+        }
+        up(&priv->lock);
+
+        /* Inform MTD subsystem that erase is complete */
+        instr->state = MTD_ERASE_DONE;
+        mtd_erase_callback(instr);
+
+        return 0;
+}
+
+/*
+ * Read from the DataFlash device.
+ *   from   : Start offset in flash device
+ *   len    : Amount to read
+ *   retlen : About of data actually read
+ *   buf    : Buffer containing the data
+ */
+static int dataflash_read(struct mtd_info *mtd, loff_t from, size_t len,
+                               size_t *retlen, u_char *buf)
+{
+        struct dataflash        *priv = (struct dataflash *)mtd->priv;
+        struct spi_transfer     x[2] = { { .tx_dma = 0, }, };
+        struct spi_message      msg;
+        unsigned int            addr;
+        u8                      *command;
+        int                     status;
+
+        DEBUG(MTD_DEBUG_LEVEL2, "%s: read 0x%x..0x%x\n",
+                priv->spi->dev.bus_id, (unsigned)from, (unsigned)(from + len));
+
+        *retlen = 0;
+
+        /* Sanity checks */
+        if (!len)
+                return 0;
+        if (from + len > mtd->size)
+                return -EINVAL;
+
+        /* Calculate flash page/byte address */
+        addr = (((unsigned)from / priv->page_size) << priv->page_offset)
+                + ((unsigned)from % priv->page_size);
+
+        command = priv->command;
+
+        DEBUG(MTD_DEBUG_LEVEL3, "READ: (%x) %x %x %x\n",
+                command[0], command[1], command[2], command[3]);
+
+        spi_message_init(&msg);
+
+        x[0].tx_buf = command;
+        x[0].len = 8;
+        spi_message_add_tail(&x[0], &msg);
+
+        x[1].rx_buf = buf;
+        x[1].len = len;
+        spi_message_add_tail(&x[1], &msg);
+
+        down(&priv->lock);
+
+        /* Continuous read, max clock = f(car) which may be less than
+         * the peak rate available.  Some chips support commands with
+         * fewer "don't care" bytes.  Both buffers stay unchanged.
+         */
+        command[0] = OP_READ_CONTINUOUS;
+        command[1] = (u8)(addr >> 16);
+        command[2] = (u8)(addr >> 8);
+        command[3] = (u8)(addr >> 0);
+        /* plus 4 "don't care" bytes */
+
+        status = spi_sync(priv->spi, &msg);
+        up(&priv->lock);
+
+        if (status >= 0) {
+                *retlen = msg.actual_length - 8;
+                status = 0;
+        } else
+                DEBUG(MTD_DEBUG_LEVEL1, "%s: read %x..%x --> %d\n",
+                        priv->spi->dev.bus_id,
+                        (unsigned)from, (unsigned)(from + len),
+                        status);
+        return status;
+}
+
+/*
+ * Write to the DataFlash device.
+ *   to     : Start offset in flash device
+ *   len    : Amount to write
+ *   retlen : Amount of data actually written
+ *   buf    : Buffer containing the data
+ */
+static int dataflash_write(struct mtd_info *mtd, loff_t to, size_t len,
+                                size_t * retlen, const u_char * buf)
+{
+        struct dataflash        *priv = (struct dataflash *)mtd->priv;
+        struct spi_device       *spi = priv->spi;
+        struct spi_transfer     x[2] = { { .tx_dma = 0, }, };
+        struct spi_message      msg;
+        unsigned int            pageaddr, addr, offset, writelen;
+        size_t                  remaining = len;
+        u_char                  *writebuf = (u_char *) buf;
+        int                     status = -EINVAL;
+        u8                      *command;
+
+        DEBUG(MTD_DEBUG_LEVEL2, "%s: write 0x%x..0x%x\n",
+                spi->dev.bus_id, (unsigned)to, (unsigned)(to + len));
+
+        *retlen = 0;
+
+        /* Sanity checks */
+        if (!len)
+                return 0;
+        if ((to + len) > mtd->size)
+                return -EINVAL;
+
+        spi_message_init(&msg);
+
+        x[0].tx_buf = command = priv->command;
+        x[0].len = 4;
+        spi_message_add_tail(&x[0], &msg);
+
+        pageaddr = ((unsigned)to / priv->page_size);
+        offset = ((unsigned)to % priv->page_size);
+        if (offset + len > priv->page_size)
+                writelen = priv->page_size - offset;
+        else
+                writelen = len;
+
+        down(&priv->lock);
+        while (remaining > 0) {
+                DEBUG(MTD_DEBUG_LEVEL3, "write @ %i:%i len=%i\n",
+                        pageaddr, offset, writelen);
+
+                /* REVISIT:
+                 * (a) each page in a sector must be rewritten at least
+                 *     once every 10K sibling erase/program operations.
+                 * (b) for pages that are already erased, we could
+                 *     use WRITE+MWRITE not PROGRAM for ~30% speedup.
+                 * (c) WRITE to buffer could be done while waiting for
+                 *     a previous MWRITE/MWERASE to complete ...
+                 * (d) error handling here seems to be mostly missing.
+                 *
+                 * Two persistent bits per page, plus a per-sector counter,
+                 * could support (a) and (b) ... we might consider using
+                 * the second half of sector zero, which is just one block,
+                 * to track that state.  (On AT91, that sector should also
+                 * support boot-from-DataFlash.)
+                 */
+
+                addr = pageaddr << priv->page_offset;
+
+                /* (1) Maybe transfer partial page to Buffer1 */
+                if (writelen != priv->page_size) {
+                        command[0] = OP_TRANSFER_BUF1;
+                        command[1] = (addr & 0x00FF0000) >> 16;
+                        command[2] = (addr & 0x0000FF00) >> 8;
+                        command[3] = 0;
+
+                        DEBUG(MTD_DEBUG_LEVEL3, "TRANSFER: (%x) %x %x %x\n",
+                                command[0], command[1], command[2], command[3]);
+
+                        status = spi_sync(spi, &msg);
+                        if (status < 0)
+                                DEBUG(MTD_DEBUG_LEVEL1, "%s: xfer %u -> %d \n",
+                                        spi->dev.bus_id, addr, status);
+
+                        (void) dataflash_waitready(priv->spi);
+                }
+
+                /* (2) Program full page via Buffer1 */
+                addr += offset;
+                command[0] = OP_PROGRAM_VIA_BUF1;
+                command[1] = (addr & 0x00FF0000) >> 16;
+                command[2] = (addr & 0x0000FF00) >> 8;
+                command[3] = (addr & 0x000000FF);
+
+                DEBUG(MTD_DEBUG_LEVEL3, "PROGRAM: (%x) %x %x %x\n",
+                        command[0], command[1], command[2], command[3]);
+
+                x[1].tx_buf = writebuf;
+                x[1].len = writelen;
+                spi_message_add_tail(x + 1, &msg);
+                status = spi_sync(spi, &msg);
+                spi_transfer_del(x + 1);
+                if (status < 0)
+                        DEBUG(MTD_DEBUG_LEVEL1, "%s: pgm %u/%u -> %d \n",
+                                spi->dev.bus_id, addr, writelen, status);
+
+                (void) dataflash_waitready(priv->spi);
+
+
+#ifdef  CONFIG_DATAFLASH_WRITE_VERIFY
+
+                /* (3) Compare to Buffer1 */
+                addr = pageaddr << priv->page_offset;
+                command[0] = OP_COMPARE_BUF1;
+                command[1] = (addr & 0x00FF0000) >> 16;
+                command[2] = (addr & 0x0000FF00) >> 8;
+                command[3] = 0;
+
+                DEBUG(MTD_DEBUG_LEVEL3, "COMPARE: (%x) %x %x %x\n",
+                        command[0], command[1], command[2], command[3]);
+
+                status = spi_sync(spi, &msg);
+                if (status < 0)
+                        DEBUG(MTD_DEBUG_LEVEL1, "%s: compare %u -> %d \n",
+                                spi->dev.bus_id, addr, status);
+
+                status = dataflash_waitready(priv->spi);
+
+                /* Check result of the compare operation */
+                if ((status & (1 << 6)) == 1) {
+                        printk(KERN_ERR "%s: compare page %u, err %d\n",
+                                spi->dev.bus_id, pageaddr, status);
+                        remaining = 0;
+                        status = -EIO;
+                        break;
+                } else
+                        status = 0;
+
+#endif  /* CONFIG_DATAFLASH_WRITE_VERIFY */
+
+                remaining = remaining - writelen;
+                pageaddr++;
+                offset = 0;
+                writebuf += writelen;
+                *retlen += writelen;
+
+                if (remaining > priv->page_size)
+                        writelen = priv->page_size;
+                else
+                        writelen = remaining;
+        }
+        up(&priv->lock);
+
+        return status;
+}
+
+/* ......................................................................... */
+
+/*
+ * Register DataFlash device with MTD subsystem.
+ */
+static int __devinit
+add_dataflash(struct spi_device *spi, char *name,
+                int nr_pages, int pagesize, int pageoffset)
+{
+        struct dataflash                *priv;
+        struct mtd_info                 *device;
+        struct flash_platform_data      *pdata = spi->dev.platform_data;
+
+        priv = (struct dataflash *) kzalloc(sizeof *priv, GFP_KERNEL);
+        if (!priv)
+                return -ENOMEM;
+
+        init_MUTEX(&priv->lock);
+        priv->spi = spi;
+        priv->page_size = pagesize;
+        priv->page_offset = pageoffset;
+
+        /* name must be usable with cmdlinepart */
+        sprintf(priv->name, "spi%d.%d-%s",
+                        spi->master->bus_num, spi->chip_select,
+                        name);
+
+        device = &priv->mtd;
+        device->name = (pdata && pdata->name) ? pdata->name : priv->name;
+        device->size = nr_pages * pagesize;
+        device->erasesize = pagesize;
+        device->owner = THIS_MODULE;
+        device->type = MTD_DATAFLASH;
+        device->flags = MTD_CAP_NORFLASH;
+        device->erase = dataflash_erase;
+        device->read = dataflash_read;
+        device->write = dataflash_write;
+        device->priv = priv;
+
+        dev_info(&spi->dev, "%s (%d KBytes)\n", name, device->size/1024);
+        dev_set_drvdata(&spi->dev, priv);
+
+        if (mtd_has_partitions()) {
+                struct mtd_partition    *parts;
+                int                     nr_parts = 0;
+
+#ifdef CONFIG_MTD_CMDLINE_PARTS
+                static const char *part_probes[] = { "cmdlinepart", NULL, };
+
+                nr_parts = parse_mtd_partitions(device, part_probes, &parts, 0);
+#endif
+
+                if (nr_parts <= 0 && pdata && pdata->parts) {
+                        parts = pdata->parts;
+                        nr_parts = pdata->nr_parts;
+                }
+
+                if (nr_parts > 0) {
+                        priv->partitioned = 1;
+                        return add_mtd_partitions(device, parts, nr_parts);
+                }
+        } else if (pdata && pdata->nr_parts)
+                dev_warn(&spi->dev, "ignoring %d default partitions on %s\n",
+                                pdata->nr_parts, device->name);
+
+        return add_mtd_device(device) == 1 ? -ENODEV : 0;
+}
+
+/*
+ * Detect and initialize DataFlash device:
+ *
+ *   Device      Density         ID code          #Pages PageSize  Offset
+ *   AT45DB011B  1Mbit   (128K)  xx0011xx (0x0c)    512    264      9
+ *   AT45DB021B  2Mbit   (256K)  xx0101xx (0x14)   1025    264      9
+ *   AT45DB041B  4Mbit   (512K)  xx0111xx (0x1c)   2048    264      9
+ *   AT45DB081B  8Mbit   (1M)    xx1001xx (0x24)   4096    264      9
+ *   AT45DB0161B 16Mbit  (2M)    xx1011xx (0x2c)   4096    528     10
+ *   AT45DB0321B 32Mbit  (4M)    xx1101xx (0x34)   8192    528     10
+ *   AT45DB0642  64Mbit  (8M)    xx111xxx (0x3c)   8192   1056     11
+ *   AT45DB1282  128Mbit (16M)   xx0100xx (0x10)  16384   1056     11
+ */
+static int __devinit dataflash_probe(struct spi_device *spi)
+{
+        int status;
+
+        status = dataflash_status(spi);
+        if (status <= 0 || status == 0xff) {
+                DEBUG(MTD_DEBUG_LEVEL1, "%s: status error %d\n",
+                                spi->dev.bus_id, status);
+                if (status == 0xff)
+                        status = -ENODEV;
+                return status;
+        }
+
+        /* if there's a device there, assume it's dataflash.
+         * board setup should have set spi->max_speed_max to
+         * match f(car) for continuous reads, mode 0 or 3.
+         */
+        switch (status & 0x3c) {
+        case 0x0c:      /* 0 0 1 1 x x */
+                status = add_dataflash(spi, "AT45DB011B", 512, 264, 9);
+                break;
+        case 0x14:      /* 0 1 0 1 x x */
+                status = add_dataflash(spi, "AT45DB021B", 1025, 264, 9);
+                break;
+        case 0x1c:      /* 0 1 1 1 x x */
+                status = add_dataflash(spi, "AT45DB041x", 2048, 264, 9);
+                break;
+        case 0x24:      /* 1 0 0 1 x x */
+                status = add_dataflash(spi, "AT45DB081B", 4096, 264, 9);
+                break;
+        case 0x2c:      /* 1 0 1 1 x x */
+                status = add_dataflash(spi, "AT45DB161x", 4096, 528, 10);
+                break;
+        case 0x34:      /* 1 1 0 1 x x */
+                status = add_dataflash(spi, "AT45DB321x", 8192, 528, 10);
+                break;
+        case 0x38:      /* 1 1 1 x x x */
+        case 0x3c:
+                status = add_dataflash(spi, "AT45DB642x", 8192, 1056, 11);
+                break;
+        /* obsolete AT45DB1282 not (yet?) supported */
+        default:
+                DEBUG(MTD_DEBUG_LEVEL1, "%s: unsupported device (%x)\n",
+                                spi->dev.bus_id, status & 0x3c);
+                status = -ENODEV;
+        }
+
+        if (status < 0)
+                DEBUG(MTD_DEBUG_LEVEL1, "%s: add_dataflash --> %d\n",
+                                spi->dev.bus_id, status);
+
+        return status;
+}
+
+static int __devexit dataflash_remove(struct spi_device *spi)
+{
+        struct dataflash        *flash = dev_get_drvdata(&spi->dev);
+        int                     status;
+
+        DEBUG(MTD_DEBUG_LEVEL1, "%s: remove\n", spi->dev.bus_id);
+
+        if (mtd_has_partitions() && flash->partitioned)
+                status = del_mtd_partitions(&flash->mtd);
+        else
+                status = del_mtd_device(&flash->mtd);
+        if (status == 0)
+                kfree(flash);
+        return status;
+}
+
+static struct spi_driver dataflash_driver = {
+        .driver = {
+                .name           = "mtd_dataflash",
+                .bus            = &spi_bus_type,
+                .owner          = THIS_MODULE,
+        },
+
+        .probe          = dataflash_probe,
+        .remove         = __devexit_p(dataflash_remove),
+
+        /* FIXME:  investigate suspend and resume... */
+};
+
+static int __init dataflash_init(void)
+{
+        return spi_register_driver(&dataflash_driver);
+}
+module_init(dataflash_init);
+
+static void __exit dataflash_exit(void)
+{
+        spi_unregister_driver(&dataflash_driver);
+}
+module_exit(dataflash_exit);
+
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Andrew Victor, David Brownell");
+MODULE_DESCRIPTION("MTD DataFlash driver");
diff --git a/drivers/mtd/nand/diskonchip.c b/drivers/mtd/nand/diskonchip.c
index 21d4e8f4b7af..ec5e45e4e4ef 100644
--- a/drivers/mtd/nand/diskonchip.c
+++ b/drivers/mtd/nand/diskonchip.c
@@ -1506,7 +1506,7 @@ static inline int __init doc2001plus_init(struct mtd_info *mtd)
         return 1;
 }
 
-static inline int __init doc_probe(unsigned long physadr)
+static int __init doc_probe(unsigned long physadr)
 {
         unsigned char ChipID;
         struct mtd_info *mtd;
diff --git a/drivers/net/Kconfig b/drivers/net/Kconfig
index 5c15f3e9ea07..171999e67eec 100644
--- a/drivers/net/Kconfig
+++ b/drivers/net/Kconfig
@@ -1387,7 +1387,7 @@ config FORCEDETH
 
 config CS89x0
         tristate "CS89x0 support"
-        depends on NET_PCI && (ISA || ARCH_IXDP2X01 || ARCH_PNX010X)
+        depends on NET_PCI && (ISA || MACH_IXDP2351 || ARCH_IXDP2X01 || ARCH_PNX010X)
         ---help---
           Support for CS89x0 chipset based Ethernet cards. If you have a
           network (Ethernet) card of this type, say Y and read the
diff --git a/drivers/net/cs89x0.c b/drivers/net/cs89x0.c
index e2cfde7e31ec..fab6586d87e9 100644
--- a/drivers/net/cs89x0.c
+++ b/drivers/net/cs89x0.c
@@ -87,6 +87,12 @@
   Deepak Saxena     : dsaxena@plexity.net
                     : Intel IXDP2x01 (XScale ixp2x00 NPU) platform support
 
+  Dmitry Pervushin  : dpervushin@ru.mvista.com
+                    : PNX010X platform support
+
+  Deepak Saxena     : dsaxena@plexity.net
+                    : Intel IXDP2351 platform support
+
 */
 
 /* Always include 'config.h' first in case the user wants to turn on
@@ -171,6 +177,10 @@ static unsigned int cs8900_irq_map[] = {12,0,0,0};
 static unsigned int netcard_portlist[] __initdata =
    { 0x0300, 0};
 static unsigned int cs8900_irq_map[] = {1,0,0,0};
+#elif defined(CONFIG_MACH_IXDP2351)
+static unsigned int netcard_portlist[] __initdata = {IXDP2351_VIRT_CS8900_BASE, 0};
+static unsigned int cs8900_irq_map[] = {IRQ_IXDP2351_CS8900, 0, 0, 0};
+#include <asm/irq.h>
 #elif defined(CONFIG_ARCH_IXDP2X01)
 #include <asm/irq.h>
 static unsigned int netcard_portlist[] __initdata = {IXDP2X01_CS8900_VIRT_BASE, 0};
@@ -338,45 +348,55 @@ out:
 }
 #endif
 
-#if defined(CONFIG_ARCH_IXDP2X01)
-static int
+#if defined(CONFIG_MACH_IXDP2351)
+static u16
 readword(unsigned long base_addr, int portno)
 {
-        return (u16)__raw_readl(base_addr + (portno << 1));
+        return __raw_readw(base_addr + (portno << 1));
 }
 
 static void
-writeword(unsigned long base_addr, int portno, int value)
+writeword(unsigned long base_addr, int portno, u16 value)
 {
-        __raw_writel((u16)value, base_addr + (portno << 1));
+        __raw_writew(value, base_addr + (portno << 1));
 }
-#else
-#if defined(CONFIG_ARCH_PNX010X)
-static int
+#elif defined(CONFIG_ARCH_IXDP2X01)
+static u16
+readword(unsigned long base_addr, int portno)
+{
+        return __raw_readl(base_addr + (portno << 1));
+}
+
+static void
+writeword(unsigned long base_addr, int portno, u16 value)
+{
+        __raw_writel(value, base_addr + (portno << 1));
+}
+#elif defined(CONFIG_ARCH_PNX010X)
+static u16
 readword(unsigned long base_addr, int portno)
 {
         return inw(base_addr + (portno << 1));
 }
 
 static void
-writeword(unsigned long base_addr, int portno, int value)
+writeword(unsigned long base_addr, int portno, u16 value)
 {
         outw(value, base_addr + (portno << 1));
 }
 #else
-static int
+static u16
 readword(unsigned long base_addr, int portno)
 {
         return inw(base_addr + portno);
 }
 
 static void
-writeword(unsigned long base_addr, int portno, int value)
+writeword(unsigned long base_addr, int portno, u16 value)
 {
         outw(value, base_addr + portno);
 }
 #endif
-#endif
 
 static void
 readwords(unsigned long base_addr, int portno, void *buf, int length)
@@ -384,11 +404,11 @@ readwords(unsigned long base_addr, int portno, void *buf, int length)
         u8 *buf8 = (u8 *)buf;
 
         do {
-                u32 tmp32;
+                u16 tmp16;
 
-                tmp32 = readword(base_addr, portno);
-                *buf8++ = (u8)tmp32;
-                *buf8++ = (u8)(tmp32 >> 8);
+                tmp16 = readword(base_addr, portno);
+                *buf8++ = (u8)tmp16;
+                *buf8++ = (u8)(tmp16 >> 8);
         } while (--length);
 }
 
@@ -398,23 +418,23 @@ writewords(unsigned long base_addr, int portno, void *buf, int length)
         u8 *buf8 = (u8 *)buf;
 
         do {
-                u32 tmp32;
+                u16 tmp16;
 
-                tmp32 = *buf8++;
-                tmp32 |= (*buf8++) << 8;
-                writeword(base_addr, portno, tmp32);
+                tmp16 = *buf8++;
+                tmp16 |= (*buf8++) << 8;
+                writeword(base_addr, portno, tmp16);
         } while (--length);
 }
 
-static int
-readreg(struct net_device *dev, int regno)
+static u16
+readreg(struct net_device *dev, u16 regno)
 {
         writeword(dev->base_addr, ADD_PORT, regno);
         return readword(dev->base_addr, DATA_PORT);
 }
 
 static void
-writereg(struct net_device *dev, int regno, int value)
+writereg(struct net_device *dev, u16 regno, u16 value)
 {
         writeword(dev->base_addr, ADD_PORT, regno);
         writeword(dev->base_addr, DATA_PORT, value);
@@ -780,7 +800,7 @@ cs89x0_probe1(struct net_device *dev, int ioaddr, int modular)
         } else {
                 i = lp->isa_config & INT_NO_MASK;
                 if (lp->chip_type == CS8900) {
-#if defined(CONFIG_ARCH_IXDP2X01) || defined(CONFIG_ARCH_PNX010X)
+#if defined(CONFIG_MACH_IXDP2351) || defined(CONFIG_ARCH_IXDP2X01) || defined(CONFIG_ARCH_PNX010X)
                         i = cs8900_irq_map[0];
 #else
                         /* Translate the IRQ using the IRQ mapping table. */
@@ -1012,7 +1032,7 @@ skip_this_frame:
 
 void  __init reset_chip(struct net_device *dev)
 {
-#ifndef CONFIG_ARCH_IXDP2X01
+#if !defined(CONFIG_MACH_IXDP2351) && !defined(CONFIG_ARCH_IXDP2X01)
         struct net_local *lp = netdev_priv(dev);
         int ioaddr = dev->base_addr;
 #endif
@@ -1023,7 +1043,7 @@ void  __init reset_chip(struct net_device *dev)
         /* wait 30 ms */
         msleep(30);
 
-#ifndef CONFIG_ARCH_IXDP2X01
+#if !defined(CONFIG_MACH_IXDP2351) && !defined(CONFIG_ARCH_IXDP2X01)
         if (lp->chip_type != CS8900) {
                 /* Hardware problem requires PNP registers to be reconfigured after a reset */
                 writeword(ioaddr, ADD_PORT, PP_CS8920_ISAINT);
@@ -1287,7 +1307,7 @@ net_open(struct net_device *dev)
         else
 #endif
         {
-#if !defined(CONFIG_ARCH_IXDP2X01) && !defined(CONFIG_ARCH_PNX010X)
+#if !defined(CONFIG_MACH_IXDP2351) && !defined(CONFIG_ARCH_IXDP2X01) && !defined(CONFIG_ARCH_PNX010X)
                 if (((1 << dev->irq) & lp->irq_map) == 0) {
                         printk(KERN_ERR "%s: IRQ %d is not in our map of allowable IRQs, which is %x\n",
                                dev->name, dev->irq, lp->irq_map);
diff --git a/drivers/net/e100.c b/drivers/net/e100.c
index 23de22631c64..4726722a0635 100644
--- a/drivers/net/e100.c
+++ b/drivers/net/e100.c
@@ -592,7 +592,7 @@ static inline void e100_write_flush(struct nic *nic)
         (void)readb(&nic->csr->scb.status);
 }
 
-static inline void e100_enable_irq(struct nic *nic)
+static void e100_enable_irq(struct nic *nic)
 {
         unsigned long flags;
 
@@ -602,7 +602,7 @@ static inline void e100_enable_irq(struct nic *nic)
         e100_write_flush(nic);
 }
 
-static inline void e100_disable_irq(struct nic *nic)
+static void e100_disable_irq(struct nic *nic)
 {
         unsigned long flags;
 
@@ -791,7 +791,7 @@ static int e100_eeprom_save(struct nic *nic, u16 start, u16 count)
 
 #define E100_WAIT_SCB_TIMEOUT 20000 /* we might have to wait 100ms!!! */
 #define E100_WAIT_SCB_FAST 20       /* delay like the old code */
-static inline int e100_exec_cmd(struct nic *nic, u8 cmd, dma_addr_t dma_addr)
+static int e100_exec_cmd(struct nic *nic, u8 cmd, dma_addr_t dma_addr)
 {
         unsigned long flags;
         unsigned int i;
@@ -822,7 +822,7 @@ err_unlock:
         return err;
 }
 
-static inline int e100_exec_cb(struct nic *nic, struct sk_buff *skb,
+static int e100_exec_cb(struct nic *nic, struct sk_buff *skb,
         void (*cb_prepare)(struct nic *, struct cb *, struct sk_buff *))
 {
         struct cb *cb;
@@ -1567,7 +1567,7 @@ static void e100_watchdog(unsigned long data)
         mod_timer(&nic->watchdog, jiffies + E100_WATCHDOG_PERIOD);
 }
 
-static inline void e100_xmit_prepare(struct nic *nic, struct cb *cb,
+static void e100_xmit_prepare(struct nic *nic, struct cb *cb,
         struct sk_buff *skb)
 {
         cb->command = nic->tx_command;
@@ -1617,7 +1617,7 @@ static int e100_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
         return 0;
 }
 
-static inline int e100_tx_clean(struct nic *nic)
+static int e100_tx_clean(struct nic *nic)
 {
         struct cb *cb;
         int tx_cleaned = 0;
@@ -1728,7 +1728,7 @@ static inline void e100_start_receiver(struct nic *nic, struct rx *rx)
 }
 
 #define RFD_BUF_LEN (sizeof(struct rfd) + VLAN_ETH_FRAME_LEN)
-static inline int e100_rx_alloc_skb(struct nic *nic, struct rx *rx)
+static int e100_rx_alloc_skb(struct nic *nic, struct rx *rx)
 {
         if(!(rx->skb = dev_alloc_skb(RFD_BUF_LEN + NET_IP_ALIGN)))
                 return -ENOMEM;
@@ -1762,7 +1762,7 @@ static inline int e100_rx_alloc_skb(struct nic *nic, struct rx *rx)
         return 0;
 }
 
-static inline int e100_rx_indicate(struct nic *nic, struct rx *rx,
+static int e100_rx_indicate(struct nic *nic, struct rx *rx,
         unsigned int *work_done, unsigned int work_to_do)
 {
         struct sk_buff *skb = rx->skb;
@@ -1822,7 +1822,7 @@ static inline int e100_rx_indicate(struct nic *nic, struct rx *rx,
         return 0;
 }
 
-static inline void e100_rx_clean(struct nic *nic, unsigned int *work_done,
+static void e100_rx_clean(struct nic *nic, unsigned int *work_done,
         unsigned int work_to_do)
 {
         struct rx *rx;
diff --git a/drivers/net/sb1000.c b/drivers/net/sb1000.c
index d6388e1533f0..76139478c3df 100644
--- a/drivers/net/sb1000.c
+++ b/drivers/net/sb1000.c
@@ -94,7 +94,7 @@ static inline int card_wait_for_busy_clear(const int ioaddr[],
         const char* name);
 static inline int card_wait_for_ready(const int ioaddr[], const char* name,
         unsigned char in[]);
-static inline int card_send_command(const int ioaddr[], const char* name,
+static int card_send_command(const int ioaddr[], const char* name,
         const unsigned char out[], unsigned char in[]);
 
 /* SB1000 hardware routines to be used during frame rx interrupt */
@@ -309,7 +309,7 @@ card_wait_for_ready(const int ioaddr[], const char* name, unsigned char in[])
 }
 
 /* Card Send Command (cannot be used during an interrupt) */
-static inline int
+static int
 card_send_command(const int ioaddr[], const char* name,
         const unsigned char out[], unsigned char in[])
 {
diff --git a/drivers/net/wireless/hostap/hostap_80211_rx.c b/drivers/net/wireless/hostap/hostap_80211_rx.c
index ffac50899454..4b13b76425c1 100644
--- a/drivers/net/wireless/hostap/hostap_80211_rx.c
+++ b/drivers/net/wireless/hostap/hostap_80211_rx.c
@@ -435,7 +435,7 @@ static void hostap_rx_sta_beacon(local_info_t *local, struct sk_buff *skb,
 }
 
 
-static inline int
+static int
 hostap_rx_frame_mgmt(local_info_t *local, struct sk_buff *skb,
                      struct hostap_80211_rx_status *rx_stats, u16 type,
                      u16 stype)
@@ -499,7 +499,7 @@ hostap_rx_frame_mgmt(local_info_t *local, struct sk_buff *skb,
 
 
 /* Called only as a tasklet (software IRQ) */
-static inline struct net_device *prism2_rx_get_wds(local_info_t *local,
+static struct net_device *prism2_rx_get_wds(local_info_t *local,
                                                    u8 *addr)
 {
         struct hostap_interface *iface = NULL;
@@ -519,7 +519,7 @@ static inline struct net_device *prism2_rx_get_wds(local_info_t *local,
 }
 
 
-static inline int
+static int
 hostap_rx_frame_wds(local_info_t *local, struct ieee80211_hdr_4addr *hdr,
                     u16 fc, struct net_device **wds)
 {
@@ -615,7 +615,7 @@ static int hostap_is_eapol_frame(local_info_t *local, struct sk_buff *skb)
 
 
 /* Called only as a tasklet (software IRQ) */
-static inline int
+static int
 hostap_rx_frame_decrypt(local_info_t *local, struct sk_buff *skb,
                         struct ieee80211_crypt_data *crypt)
 {
@@ -654,7 +654,7 @@ hostap_rx_frame_decrypt(local_info_t *local, struct sk_buff *skb,
 
 
 /* Called only as a tasklet (software IRQ) */
-static inline int
+static int
 hostap_rx_frame_decrypt_msdu(local_info_t *local, struct sk_buff *skb,
                              int keyidx, struct ieee80211_crypt_data *crypt)
 {
diff --git a/drivers/net/wireless/hostap/hostap_hw.c b/drivers/net/wireless/hostap/hostap_hw.c
index abfae7fedebc..b1f142d9e232 100644
--- a/drivers/net/wireless/hostap/hostap_hw.c
+++ b/drivers/net/wireless/hostap/hostap_hw.c
@@ -253,7 +253,7 @@ static void prism2_clear_cmd_queue(local_info_t *local)
  * @dev: pointer to net_device
  * @entry: Prism2 command queue entry to be issued
  */
-static inline int hfa384x_cmd_issue(struct net_device *dev,
+static int hfa384x_cmd_issue(struct net_device *dev,
                                     struct hostap_cmd_queue *entry)
 {
         struct hostap_interface *iface;
@@ -743,7 +743,7 @@ static void prism2_cmd_ev(struct net_device *dev)
 }
 
 
-static inline int hfa384x_wait_offset(struct net_device *dev, u16 o_off)
+static int hfa384x_wait_offset(struct net_device *dev, u16 o_off)
 {
         int tries = HFA384X_BAP_BUSY_TIMEOUT;
         int res = HFA384X_INW(o_off) & HFA384X_OFFSET_BUSY;
@@ -1904,7 +1904,7 @@ fail:
  * and will try to get the correct fid eventually. */
 #define EXTRA_FID_READ_TESTS
 
-static inline u16 prism2_read_fid_reg(struct net_device *dev, u16 reg)
+static u16 prism2_read_fid_reg(struct net_device *dev, u16 reg)
 {
 #ifdef EXTRA_FID_READ_TESTS
         u16 val, val2, val3;
@@ -2581,7 +2581,7 @@ static void prism2_ev_tick(struct net_device *dev)
 
 
 /* Called only from hardware IRQ */
-static inline void prism2_check_magic(local_info_t *local)
+static void prism2_check_magic(local_info_t *local)
 {
         /* at least PCI Prism2.5 with bus mastering seems to sometimes
          * return 0x0000 in SWSUPPORT0 for unknown reason, but re-reading the
diff --git a/drivers/net/wireless/ipw2100.c b/drivers/net/wireless/ipw2100.c
index cf05661fb1bd..7518384f34d9 100644
--- a/drivers/net/wireless/ipw2100.c
+++ b/drivers/net/wireless/ipw2100.c
@@ -411,7 +411,7 @@ static inline void write_nic_dword_auto_inc(struct net_device *dev, u32 val)
         write_register(dev, IPW_REG_AUTOINCREMENT_DATA, val);
 }
 
-static inline void write_nic_memory(struct net_device *dev, u32 addr, u32 len,
+static void write_nic_memory(struct net_device *dev, u32 addr, u32 len,
                                     const u8 * buf)
 {
         u32 aligned_addr;
@@ -449,7 +449,7 @@ static inline void write_nic_memory(struct net_device *dev, u32 addr, u32 len,
                                     *buf);
 }
 
-static inline void read_nic_memory(struct net_device *dev, u32 addr, u32 len,
+static void read_nic_memory(struct net_device *dev, u32 addr, u32 len,
                                    u8 * buf)
 {
         u32 aligned_addr;
@@ -657,7 +657,7 @@ static void printk_buf(int level, const u8 * data, u32 len)
 
 #define MAX_RESET_BACKOFF 10
 
-static inline void schedule_reset(struct ipw2100_priv *priv)
+static void schedule_reset(struct ipw2100_priv *priv)
 {
         unsigned long now = get_seconds();
 
@@ -1130,7 +1130,7 @@ static inline void ipw2100_hw_set_gpio(struct ipw2100_priv *priv)
         write_register(priv->net_dev, IPW_REG_GPIO, reg);
 }
 
-static inline int rf_kill_active(struct ipw2100_priv *priv)
+static int rf_kill_active(struct ipw2100_priv *priv)
 {
 #define MAX_RF_KILL_CHECKS 5
 #define RF_KILL_CHECK_DELAY 40
@@ -2177,7 +2177,7 @@ static const char *frame_types[] = {
 };
 #endif
 
-static inline int ipw2100_alloc_skb(struct ipw2100_priv *priv,
+static int ipw2100_alloc_skb(struct ipw2100_priv *priv,
                                     struct ipw2100_rx_packet *packet)
 {
         packet->skb = dev_alloc_skb(sizeof(struct ipw2100_rx));
@@ -2201,7 +2201,7 @@ static inline int ipw2100_alloc_skb(struct ipw2100_priv *priv,
 #define SEARCH_SNAPSHOT 1
 
 #define SNAPSHOT_ADDR(ofs) (priv->snapshot[((ofs) >> 12) & 0xff] + ((ofs) & 0xfff))
-static inline int ipw2100_snapshot_alloc(struct ipw2100_priv *priv)
+static int ipw2100_snapshot_alloc(struct ipw2100_priv *priv)
 {
         int i;
         if (priv->snapshot[0])
@@ -2221,7 +2221,7 @@ static inline int ipw2100_snapshot_alloc(struct ipw2100_priv *priv)
         return 1;
 }
 
-static inline void ipw2100_snapshot_free(struct ipw2100_priv *priv)
+static void ipw2100_snapshot_free(struct ipw2100_priv *priv)
 {
         int i;
         if (!priv->snapshot[0])
@@ -2231,7 +2231,7 @@ static inline void ipw2100_snapshot_free(struct ipw2100_priv *priv)
         priv->snapshot[0] = NULL;
 }
 
-static inline u32 ipw2100_match_buf(struct ipw2100_priv *priv, u8 * in_buf,
+static u32 ipw2100_match_buf(struct ipw2100_priv *priv, u8 * in_buf,
                                     size_t len, int mode)
 {
         u32 i, j;
@@ -2288,7 +2288,7 @@ static inline u32 ipw2100_match_buf(struct ipw2100_priv *priv, u8 * in_buf,
 static u8 packet_data[IPW_RX_NIC_BUFFER_LENGTH];
 #endif
 
-static inline void ipw2100_corruption_detected(struct ipw2100_priv *priv, int i)
+static void ipw2100_corruption_detected(struct ipw2100_priv *priv, int i)
 {
 #ifdef CONFIG_IPW2100_DEBUG_C3
         struct ipw2100_status *status = &priv->status_queue.drv[i];
@@ -2346,7 +2346,7 @@ static inline void ipw2100_corruption_detected(struct ipw2100_priv *priv, int i)
         schedule_reset(priv);
 }
 
-static inline void isr_rx(struct ipw2100_priv *priv, int i,
+static void isr_rx(struct ipw2100_priv *priv, int i,
                           struct ieee80211_rx_stats *stats)
 {
         struct ipw2100_status *status = &priv->status_queue.drv[i];
@@ -2425,7 +2425,7 @@ static inline void isr_rx(struct ipw2100_priv *priv, int i,
         priv->rx_queue.drv[i].host_addr = packet->dma_addr;
 }
 
-static inline int ipw2100_corruption_check(struct ipw2100_priv *priv, int i)
+static int ipw2100_corruption_check(struct ipw2100_priv *priv, int i)
 {
         struct ipw2100_status *status = &priv->status_queue.drv[i];
         struct ipw2100_rx *u = priv->rx_buffers[i].rxp;
@@ -2481,7 +2481,7 @@ static inline int ipw2100_corruption_check(struct ipw2100_priv *priv, int i)
  * The WRITE index is cached in the variable 'priv->rx_queue.next'.
  *
  */
-static inline void __ipw2100_rx_process(struct ipw2100_priv *priv)
+static void __ipw2100_rx_process(struct ipw2100_priv *priv)
 {
         struct ipw2100_bd_queue *rxq = &priv->rx_queue;
         struct ipw2100_status_queue *sq = &priv->status_queue;
@@ -2634,7 +2634,7 @@ static inline void __ipw2100_rx_process(struct ipw2100_priv *priv)
  * for use by future command and data packets.
  *
  */
-static inline int __ipw2100_tx_process(struct ipw2100_priv *priv)
+static int __ipw2100_tx_process(struct ipw2100_priv *priv)
 {
         struct ipw2100_bd_queue *txq = &priv->tx_queue;
         struct ipw2100_bd *tbd;
diff --git a/drivers/net/wireless/ipw2200.c b/drivers/net/wireless/ipw2200.c
index cdfe50207757..819be2b6b7df 100644
--- a/drivers/net/wireless/ipw2200.c
+++ b/drivers/net/wireless/ipw2200.c
@@ -813,7 +813,7 @@ static void ipw_bg_led_link_off(void *data)
         up(&priv->sem);
 }
 
-static inline void __ipw_led_activity_on(struct ipw_priv *priv)
+static void __ipw_led_activity_on(struct ipw_priv *priv)
 {
         u32 led;
 
@@ -1508,7 +1508,7 @@ static ssize_t store_direct_dword(struct device *d,
 static DEVICE_ATTR(direct_dword, S_IWUSR | S_IRUGO,
                    show_direct_dword, store_direct_dword);
 
-static inline int rf_kill_active(struct ipw_priv *priv)
+static int rf_kill_active(struct ipw_priv *priv)
 {
         if (0 == (ipw_read32(priv, 0x30) & 0x10000))
                 priv->status |= STATUS_RF_KILL_HW;
@@ -2359,7 +2359,7 @@ static inline void eeprom_write_reg(struct ipw_priv *p, u32 data)
 }
 
 /* perform a chip select operation */
-static inline void eeprom_cs(struct ipw_priv *priv)
+static void eeprom_cs(struct ipw_priv *priv)
 {
         eeprom_write_reg(priv, 0);
         eeprom_write_reg(priv, EEPROM_BIT_CS);
@@ -2368,7 +2368,7 @@ static inline void eeprom_cs(struct ipw_priv *priv)
 }
 
 /* perform a chip select operation */
-static inline void eeprom_disable_cs(struct ipw_priv *priv)
+static void eeprom_disable_cs(struct ipw_priv *priv)
 {
         eeprom_write_reg(priv, EEPROM_BIT_CS);
         eeprom_write_reg(priv, 0);
@@ -2475,7 +2475,7 @@ static void ipw_eeprom_init_sram(struct ipw_priv *priv)
         IPW_DEBUG_TRACE("<<\n");
 }
 
-static inline void ipw_zero_memory(struct ipw_priv *priv, u32 start, u32 count)
+static void ipw_zero_memory(struct ipw_priv *priv, u32 start, u32 count)
 {
         count >>= 2;
         if (!count)
@@ -2772,7 +2772,7 @@ static inline int ipw_alive(struct ipw_priv *priv)
         return ipw_read32(priv, 0x90) == 0xd55555d5;
 }
 
-static inline int ipw_poll_bit(struct ipw_priv *priv, u32 addr, u32 mask,
+static int ipw_poll_bit(struct ipw_priv *priv, u32 addr, u32 mask,
                                int timeout)
 {
         int i = 0;
@@ -3150,7 +3150,7 @@ static int ipw_get_fw(struct ipw_priv *priv,
 
 #define IPW_RX_BUF_SIZE (3000)
 
-static inline void ipw_rx_queue_reset(struct ipw_priv *priv,
+static void ipw_rx_queue_reset(struct ipw_priv *priv,
                                       struct ipw_rx_queue *rxq)
 {
         unsigned long flags;
@@ -3608,7 +3608,7 @@ static void ipw_tx_queue_free(struct ipw_priv *priv)
         ipw_queue_tx_free(priv, &priv->txq[3]);
 }
 
-static inline void ipw_create_bssid(struct ipw_priv *priv, u8 * bssid)
+static void ipw_create_bssid(struct ipw_priv *priv, u8 * bssid)
 {
         /* First 3 bytes are manufacturer */
         bssid[0] = priv->mac_addr[0];
@@ -3622,7 +3622,7 @@ static inline void ipw_create_bssid(struct ipw_priv *priv, u8 * bssid)
         bssid[0] |= 0x02;       /* set local assignment bit (IEEE802) */
 }
 
-static inline u8 ipw_add_station(struct ipw_priv *priv, u8 * bssid)
+static u8 ipw_add_station(struct ipw_priv *priv, u8 * bssid)
 {
         struct ipw_station_entry entry;
         int i;
@@ -3655,7 +3655,7 @@ static inline u8 ipw_add_station(struct ipw_priv *priv, u8 * bssid)
         return i;
 }
 
-static inline u8 ipw_find_station(struct ipw_priv *priv, u8 * bssid)
+static u8 ipw_find_station(struct ipw_priv *priv, u8 * bssid)
 {
         int i;
 
@@ -3794,7 +3794,7 @@ static void inline average_init(struct average *avg)
         memset(avg, 0, sizeof(*avg));
 }
 
-static void inline average_add(struct average *avg, s16 val)
+static void average_add(struct average *avg, s16 val)
 {
         avg->sum -= avg->entries[avg->pos];
         avg->sum += val;
@@ -3805,7 +3805,7 @@ static void inline average_add(struct average *avg, s16 val)
         }
 }
 
-static s16 inline average_value(struct average *avg)
+static s16 average_value(struct average *avg)
 {
         if (!unlikely(avg->init)) {
                 if (avg->pos)
@@ -3847,7 +3847,7 @@ static void ipw_reset_stats(struct ipw_priv *priv)
 
 }
 
-static inline u32 ipw_get_max_rate(struct ipw_priv *priv)
+static u32 ipw_get_max_rate(struct ipw_priv *priv)
 {
         u32 i = 0x80000000;
         u32 mask = priv->rates_mask;
@@ -4087,7 +4087,7 @@ static void ipw_bg_gather_stats(void *data)
  * roaming_threshold -> disassociate_threshold, scan and roam for better signal.
  * Above disassociate threshold, give up and stop scanning.
  * Roaming is disabled if disassociate_threshold <= roaming_threshold  */
-static inline void ipw_handle_missed_beacon(struct ipw_priv *priv,
+static void ipw_handle_missed_beacon(struct ipw_priv *priv,
                                             int missed_count)
 {
         priv->notif_missed_beacons = missed_count;
@@ -4157,7 +4157,7 @@ static inline void ipw_handle_missed_beacon(struct ipw_priv *priv,
  * Handle host notification packet.
  * Called from interrupt routine
  */
-static inline void ipw_rx_notification(struct ipw_priv *priv,
+static void ipw_rx_notification(struct ipw_priv *priv,
                                        struct ipw_rx_notification *notif)
 {
         notif->size = le16_to_cpu(notif->size);
@@ -5095,7 +5095,7 @@ static int ipw_compatible_rates(struct ipw_priv *priv,
         return 1;
 }
 
-static inline void ipw_copy_rates(struct ipw_supported_rates *dest,
+static void ipw_copy_rates(struct ipw_supported_rates *dest,
                                   const struct ipw_supported_rates *src)
 {
         u8 i;
@@ -5856,7 +5856,7 @@ static void ipw_debug_config(struct ipw_priv *priv)
 #define ipw_debug_config(x) do {} while (0)
 #endif
 
-static inline void ipw_set_fixed_rate(struct ipw_priv *priv, int mode)
+static void ipw_set_fixed_rate(struct ipw_priv *priv, int mode)
 {
         /* TODO: Verify that this works... */
         struct ipw_fixed_rate fr = {
@@ -7634,7 +7634,7 @@ static void ipw_handle_data_packet_monitor(struct ipw_priv *priv,
 }
 #endif
 
-static inline int is_network_packet(struct ipw_priv *priv,
+static int is_network_packet(struct ipw_priv *priv,
                                     struct ieee80211_hdr_4addr *header)
 {
         /* Filter incoming packets to determine if they are targetted toward
@@ -7672,7 +7672,7 @@ static inline int is_network_packet(struct ipw_priv *priv,
 
 #define IPW_PACKET_RETRY_TIME HZ
 
-static inline int is_duplicate_packet(struct ipw_priv *priv,
+static  int is_duplicate_packet(struct ipw_priv *priv,
                                       struct ieee80211_hdr_4addr *header)
 {
         u16 sc = le16_to_cpu(header->seq_ctl);
@@ -9581,7 +9581,7 @@ static struct iw_statistics *ipw_get_wireless_stats(struct net_device *dev)
 
 /* net device stuff */
 
-static inline void init_sys_config(struct ipw_sys_config *sys_config)
+static  void init_sys_config(struct ipw_sys_config *sys_config)
 {
         memset(sys_config, 0, sizeof(struct ipw_sys_config));
         sys_config->bt_coexistence = 1; /* We may need to look into prvStaBtConfig */
@@ -9627,7 +9627,7 @@ modify to send one tfd per fragment instead of using chunking.  otherwise
 we need to heavily modify the ieee80211_skb_to_txb.
 */
 
-static inline int ipw_tx_skb(struct ipw_priv *priv, struct ieee80211_txb *txb,
+static int ipw_tx_skb(struct ipw_priv *priv, struct ieee80211_txb *txb,
                              int pri)
 {
         struct ieee80211_hdr_3addr *hdr = (struct ieee80211_hdr_3addr *)
diff --git a/drivers/net/wireless/wavelan.c b/drivers/net/wireless/wavelan.c
index b0d8b5b03152..ff192e96268a 100644
--- a/drivers/net/wireless/wavelan.c
+++ b/drivers/net/wireless/wavelan.c
@@ -102,7 +102,7 @@ static inline void hacr_write(unsigned long ioaddr, u16 hacr)
  * Write to card's Host Adapter Command Register. Include a delay for
  * those times when it is needed.
  */
-static inline void hacr_write_slow(unsigned long ioaddr, u16 hacr)
+static void hacr_write_slow(unsigned long ioaddr, u16 hacr)
 {
         hacr_write(ioaddr, hacr);
         /* delay might only be needed sometimes */
@@ -242,7 +242,7 @@ static void psa_write(unsigned long ioaddr, u16 hacr, int o,	/* Offset in PSA */
  * The Windows drivers don't use the CRC, but the AP and the PtP tool
  * depend on it.
  */
-static inline u16 psa_crc(u8 * psa,     /* The PSA */
+static u16 psa_crc(u8 * psa,    /* The PSA */
                               int size)
 {                               /* Number of short for CRC */
         int byte_cnt;           /* Loop on the PSA */
@@ -310,7 +310,7 @@ static void update_psa_checksum(struct net_device * dev, unsigned long ioaddr, u
 /*
  * Write 1 byte to the MMC.
  */
-static inline void mmc_out(unsigned long ioaddr, u16 o, u8 d)
+static void mmc_out(unsigned long ioaddr, u16 o, u8 d)
 {
         int count = 0;
 
@@ -326,7 +326,7 @@ static inline void mmc_out(unsigned long ioaddr, u16 o, u8 d)
  * Routine to write bytes to the Modem Management Controller.
  * We start at the end because it is the way it should be!
  */
-static inline void mmc_write(unsigned long ioaddr, u8 o, u8 * b, int n)
+static void mmc_write(unsigned long ioaddr, u8 o, u8 * b, int n)
 {
         o += n;
         b += n;
@@ -340,7 +340,7 @@ static inline void mmc_write(unsigned long ioaddr, u8 o, u8 * b, int n)
  * Read a byte from the MMC.
  * Optimised version for 1 byte, avoid using memory.
  */
-static inline u8 mmc_in(unsigned long ioaddr, u16 o)
+static u8 mmc_in(unsigned long ioaddr, u16 o)
 {
         int count = 0;
 
@@ -587,7 +587,7 @@ static void wv_ack(struct net_device * dev)
  * Set channel attention bit and busy wait until command has
  * completed, then acknowledge completion of the command.
  */
-static inline int wv_synchronous_cmd(struct net_device * dev, const char *str)
+static int wv_synchronous_cmd(struct net_device * dev, const char *str)
 {
         net_local *lp = (net_local *) dev->priv;
         unsigned long ioaddr = dev->base_addr;
@@ -633,7 +633,7 @@ static inline int wv_synchronous_cmd(struct net_device * dev, const char *str)
  * Configuration commands completion interrupt.
  * Check if done, and if OK.
  */
-static inline int
+static int
 wv_config_complete(struct net_device * dev, unsigned long ioaddr, net_local * lp)
 {
         unsigned short mcs_addr;
@@ -843,7 +843,7 @@ if (lp->tx_n_in_use > 0)
  * wavelan_interrupt is not an option), so you may experience
  * delays sometimes.
  */
-static inline void wv_82586_reconfig(struct net_device * dev)
+static void wv_82586_reconfig(struct net_device * dev)
 {
         net_local *lp = (net_local *) dev->priv;
         unsigned long flags;
@@ -1281,7 +1281,7 @@ static inline void wv_packet_info(u8 * p,	/* Packet to dump */
  * This is the information which is displayed by the driver at startup.
  * There are lots of flags for configuring it to your liking.
  */
-static inline void wv_init_info(struct net_device * dev)
+static void wv_init_info(struct net_device * dev)
 {
         short ioaddr = dev->base_addr;
         net_local *lp = (net_local *) dev->priv;
@@ -1502,7 +1502,7 @@ static int wavelan_set_mac_address(struct net_device * dev, void *addr)
  * It's a bit complicated and you don't really want to look into it.
  * (called in wavelan_ioctl)
  */
-static inline int wv_set_frequency(unsigned long ioaddr,        /* I/O port of the card */
+static int wv_set_frequency(unsigned long ioaddr,       /* I/O port of the card */
                                    iw_freq * frequency)
 {
         const int BAND_NUM = 10;        /* Number of bands */
@@ -1677,7 +1677,7 @@ static inline int wv_set_frequency(unsigned long ioaddr,	/* I/O port of the card
 /*
  * Give the list of available frequencies.
  */
-static inline int wv_frequency_list(unsigned long ioaddr,       /* I/O port of the card */
+static int wv_frequency_list(unsigned long ioaddr,      /* I/O port of the card */
                                     iw_freq * list,     /* List of frequencies to fill */
                                     int max)
 {                               /* Maximum number of frequencies */
@@ -2489,7 +2489,7 @@ static iw_stats *wavelan_get_wireless_stats(struct net_device * dev)
  * Note: if any errors occur, the packet is "dropped on the floor".
  * (called by wv_packet_rcv())
  */
-static inline void
+static void
 wv_packet_read(struct net_device * dev, u16 buf_off, int sksize)
 {
         net_local *lp = (net_local *) dev->priv;
@@ -2585,7 +2585,7 @@ wv_packet_read(struct net_device * dev, u16 buf_off, int sksize)
  * (called in wavelan_interrupt()).
  * Note : the spinlock is already grabbed for us.
  */
-static inline void wv_receive(struct net_device * dev)
+static void wv_receive(struct net_device * dev)
 {
         unsigned long ioaddr = dev->base_addr;
         net_local *lp = (net_local *) dev->priv;
@@ -2768,7 +2768,7 @@ static inline void wv_receive(struct net_device * dev)
  *
  * (called in wavelan_packet_xmit())
  */
-static inline int wv_packet_write(struct net_device * dev, void *buf, short length)
+static int wv_packet_write(struct net_device * dev, void *buf, short length)
 {
         net_local *lp = (net_local *) dev->priv;
         unsigned long ioaddr = dev->base_addr;
@@ -2964,7 +2964,7 @@ static int wavelan_packet_xmit(struct sk_buff *skb, struct net_device * dev)
  * Routine to initialize the Modem Management Controller.
  * (called by wv_hw_reset())
  */
-static inline int wv_mmc_init(struct net_device * dev)
+static int wv_mmc_init(struct net_device * dev)
 {
         unsigned long ioaddr = dev->base_addr;
         net_local *lp = (net_local *) dev->priv;
@@ -3136,7 +3136,7 @@ static inline int wv_mmc_init(struct net_device * dev)
  * Start the receive unit.
  * (called by wv_hw_reset())
  */
-static inline int wv_ru_start(struct net_device * dev)
+static int wv_ru_start(struct net_device * dev)
 {
         net_local *lp = (net_local *) dev->priv;
         unsigned long ioaddr = dev->base_addr;
@@ -3228,7 +3228,7 @@ static inline int wv_ru_start(struct net_device * dev)
  *
  * (called by wv_hw_reset())
  */
-static inline int wv_cu_start(struct net_device * dev)
+static int wv_cu_start(struct net_device * dev)
 {
         net_local *lp = (net_local *) dev->priv;
         unsigned long ioaddr = dev->base_addr;
@@ -3329,7 +3329,7 @@ static inline int wv_cu_start(struct net_device * dev)
  *
  * (called by wv_hw_reset())
  */
-static inline int wv_82586_start(struct net_device * dev)
+static int wv_82586_start(struct net_device * dev)
 {
         net_local *lp = (net_local *) dev->priv;
         unsigned long ioaddr = dev->base_addr;
@@ -3641,7 +3641,7 @@ static void wv_82586_config(struct net_device * dev)
  * WaveLAN controller (i82586).
  * (called by wavelan_close())
  */
-static inline void wv_82586_stop(struct net_device * dev)
+static void wv_82586_stop(struct net_device * dev)
 {
         net_local *lp = (net_local *) dev->priv;
         unsigned long ioaddr = dev->base_addr;
diff --git a/drivers/pci/pci-driver.c b/drivers/pci/pci-driver.c
index 7146b69b812c..0aa14c92b570 100644
--- a/drivers/pci/pci-driver.c
+++ b/drivers/pci/pci-driver.c
@@ -380,8 +380,6 @@ int __pci_register_driver(struct pci_driver *drv, struct module *owner)
         /* initialize common driver fields */
         drv->driver.name = drv->name;
         drv->driver.bus = &pci_bus_type;
-        drv->driver.probe = pci_device_probe;
-        drv->driver.remove = pci_device_remove;
         /* FIXME, once all of the existing PCI drivers have been fixed to set
          * the pci shutdown function, this test can go away. */
         if (!drv->driver.shutdown)
@@ -513,6 +511,8 @@ struct bus_type pci_bus_type = {
         .name           = "pci",
         .match          = pci_bus_match,
         .uevent         = pci_uevent,
+        .probe          = pci_device_probe,
+        .remove         = pci_device_remove,
         .suspend        = pci_device_suspend,
         .resume         = pci_device_resume,
         .dev_attrs      = pci_dev_attrs,
diff --git a/drivers/pcmcia/ds.c b/drivers/pcmcia/ds.c
index 621ec459d27a..0a424a4e8187 100644
--- a/drivers/pcmcia/ds.c
+++ b/drivers/pcmcia/ds.c
@@ -311,8 +311,6 @@ int pcmcia_register_driver(struct pcmcia_driver *driver)
         /* initialize common fields */
         driver->drv.bus = &pcmcia_bus_type;
         driver->drv.owner = driver->owner;
-        driver->drv.probe = pcmcia_device_probe;
-        driver->drv.remove = pcmcia_device_remove;
 
         return driver_register(&driver->drv);
 }
@@ -1200,6 +1198,8 @@ struct bus_type pcmcia_bus_type = {
         .uevent = pcmcia_bus_uevent,
         .match = pcmcia_bus_match,
         .dev_attrs = pcmcia_dev_attrs,
+        .probe = pcmcia_device_probe,
+        .remove = pcmcia_device_remove,
         .suspend = pcmcia_dev_suspend,
         .resume = pcmcia_dev_resume,
 };
diff --git a/drivers/pnp/driver.c b/drivers/pnp/driver.c
index 15fb758a9e52..7cafacdd12b0 100644
--- a/drivers/pnp/driver.c
+++ b/drivers/pnp/driver.c
@@ -195,6 +195,8 @@ static int pnp_bus_resume(struct device *dev)
 struct bus_type pnp_bus_type = {
         .name   = "pnp",
         .match  = pnp_bus_match,
+        .probe  = pnp_device_probe,
+        .remove = pnp_device_remove,
         .suspend = pnp_bus_suspend,
         .resume = pnp_bus_resume,
 };
@@ -215,8 +217,6 @@ int pnp_register_driver(struct pnp_driver *drv)
 
         drv->driver.name = drv->name;
         drv->driver.bus = &pnp_bus_type;
-        drv->driver.probe = pnp_device_probe;
-        drv->driver.remove = pnp_device_remove;
 
         count = driver_register(&drv->driver);
 
diff --git a/drivers/rapidio/rio-driver.c b/drivers/rapidio/rio-driver.c
index dc749609699a..5480119ff9d3 100644
--- a/drivers/rapidio/rio-driver.c
+++ b/drivers/rapidio/rio-driver.c
@@ -147,8 +147,6 @@ int rio_register_driver(struct rio_driver *rdrv)
         /* initialize common driver fields */
         rdrv->driver.name = rdrv->name;
         rdrv->driver.bus = &rio_bus_type;
-        rdrv->driver.probe = rio_device_probe;
-        rdrv->driver.remove = rio_device_remove;
 
         /* register with core */
         return driver_register(&rdrv->driver);
@@ -204,7 +202,9 @@ static struct device rio_bus = {
 struct bus_type rio_bus_type = {
         .name = "rapidio",
         .match = rio_match_bus,
-        .dev_attrs = rio_dev_attrs
+        .dev_attrs = rio_dev_attrs,
+        .probe = rio_device_probe,
+        .remove = rio_device_remove,
 };
 
 /**
diff --git a/drivers/s390/block/dasd.c b/drivers/s390/block/dasd.c
index 9c25654b1e75..ef4c687e7c01 100644
--- a/drivers/s390/block/dasd.c
+++ b/drivers/s390/block/dasd.c
@@ -1635,7 +1635,7 @@ dasd_setup_queue(struct dasd_device * device)
         blk_queue_max_hw_segments(device->request_queue, -1L);
         blk_queue_max_segment_size(device->request_queue, -1L);
         blk_queue_segment_boundary(device->request_queue, -1L);
-        blk_queue_ordered(device->request_queue, 1);
+        blk_queue_ordered(device->request_queue, QUEUE_ORDERED_TAG, NULL);
 }
 
 /*
diff --git a/drivers/s390/cio/airq.c b/drivers/s390/cio/airq.c
index 83e6a060668e..cd2cc28e16a7 100644
--- a/drivers/s390/cio/airq.c
+++ b/drivers/s390/cio/airq.c
@@ -2,12 +2,12 @@
  *  drivers/s390/cio/airq.c
  *   S/390 common I/O routines -- support for adapter interruptions
  *
- *   $Revision: 1.12 $
+ *   $Revision: 1.15 $
  *
  *    Copyright (C) 1999-2002 IBM Deutschland Entwicklung GmbH,
  *                            IBM Corporation
  *    Author(s): Ingo Adlung (adlung@de.ibm.com)
- *               Cornelia Huck (cohuck@de.ibm.com)
+ *               Cornelia Huck (cornelia.huck@de.ibm.com)
  *               Arnd Bergmann (arndb@de.ibm.com)
  */
 
diff --git a/drivers/s390/cio/blacklist.c b/drivers/s390/cio/blacklist.c
index daf21e03b21d..72f27c151c09 100644
--- a/drivers/s390/cio/blacklist.c
+++ b/drivers/s390/cio/blacklist.c
@@ -1,12 +1,12 @@
 /*
  *  drivers/s390/cio/blacklist.c
  *   S/390 common I/O routines -- blacklisting of specific devices
- *   $Revision: 1.39 $
+ *   $Revision: 1.42 $
  *
  *    Copyright (C) 1999-2002 IBM Deutschland Entwicklung GmbH,
  *                            IBM Corporation
  *    Author(s): Ingo Adlung (adlung@de.ibm.com)
- *               Cornelia Huck (cohuck@de.ibm.com)
+ *               Cornelia Huck (cornelia.huck@de.ibm.com)
  *               Arnd Bergmann (arndb@de.ibm.com)
  */
 
diff --git a/drivers/s390/cio/ccwgroup.c b/drivers/s390/cio/ccwgroup.c
index e849289d4f3c..6c077ad71edc 100644
--- a/drivers/s390/cio/ccwgroup.c
+++ b/drivers/s390/cio/ccwgroup.c
@@ -1,12 +1,12 @@
 /*
  *  drivers/s390/cio/ccwgroup.c
  *  bus driver for ccwgroup
- *   $Revision: 1.33 $
+ *   $Revision: 1.35 $
  *
  *    Copyright (C) 2002 IBM Deutschland Entwicklung GmbH,
  *                       IBM Corporation
  *    Author(s): Arnd Bergmann (arndb@de.ibm.com)
- *               Cornelia Huck (cohuck@de.ibm.com)
+ *               Cornelia Huck (cornelia.huck@de.ibm.com)
  */
 #include <linux/module.h>
 #include <linux/errno.h>
@@ -52,11 +52,7 @@ ccwgroup_uevent (struct device *dev, char **envp, int num_envp, char *buffer,
         return 0;
 }
 
-static struct bus_type ccwgroup_bus_type = {
-        .name    = "ccwgroup",
-        .match   = ccwgroup_bus_match,
-        .uevent = ccwgroup_uevent,
-};
+static struct bus_type ccwgroup_bus_type;
 
 static inline void
 __ccwgroup_remove_symlinks(struct ccwgroup_device *gdev)
@@ -389,6 +385,14 @@ ccwgroup_remove (struct device *dev)
         return 0;
 }
 
+static struct bus_type ccwgroup_bus_type = {
+        .name   = "ccwgroup",
+        .match  = ccwgroup_bus_match,
+        .uevent = ccwgroup_uevent,
+        .probe  = ccwgroup_probe,
+        .remove = ccwgroup_remove,
+};
+
 int
 ccwgroup_driver_register (struct ccwgroup_driver *cdriver)
 {
@@ -396,8 +400,6 @@ ccwgroup_driver_register (struct ccwgroup_driver *cdriver)
         cdriver->driver = (struct device_driver) {
                 .bus = &ccwgroup_bus_type,
                 .name = cdriver->name,
-                .probe = ccwgroup_probe,
-                .remove = ccwgroup_remove,
         };
 
         return driver_register(&cdriver->driver);
diff --git a/drivers/s390/cio/chsc.c b/drivers/s390/cio/chsc.c
index 7270808c02d1..2cbb724791a8 100644
--- a/drivers/s390/cio/chsc.c
+++ b/drivers/s390/cio/chsc.c
@@ -1,12 +1,12 @@
 /*
  *  drivers/s390/cio/chsc.c
  *   S/390 common I/O routines -- channel subsystem call
- *   $Revision: 1.126 $
+ *   $Revision: 1.128 $
  *
  *    Copyright (C) 1999-2002 IBM Deutschland Entwicklung GmbH,
  *                            IBM Corporation
  *    Author(s): Ingo Adlung (adlung@de.ibm.com)
- *               Cornelia Huck (cohuck@de.ibm.com)
+ *               Cornelia Huck (cornelia.huck@de.ibm.com)
  *               Arnd Bergmann (arndb@de.ibm.com)
  */
 
diff --git a/drivers/s390/cio/cio.c b/drivers/s390/cio/cio.c
index 7376bc87206d..6223b06d27d5 100644
--- a/drivers/s390/cio/cio.c
+++ b/drivers/s390/cio/cio.c
@@ -1,12 +1,12 @@
 /*
  *  drivers/s390/cio/cio.c
  *   S/390 common I/O routines -- low level i/o calls
- *   $Revision: 1.138 $
+ *   $Revision: 1.140 $
  *
  *    Copyright (C) 1999-2002 IBM Deutschland Entwicklung GmbH,
  *                            IBM Corporation
  *    Author(s): Ingo Adlung (adlung@de.ibm.com)
- *               Cornelia Huck (cohuck@de.ibm.com)
+ *               Cornelia Huck (cornelia.huck@de.ibm.com)
  *               Arnd Bergmann (arndb@de.ibm.com)
  *               Martin Schwidefsky (schwidefsky@de.ibm.com)
  */
diff --git a/drivers/s390/cio/css.c b/drivers/s390/cio/css.c
index e565193650c7..516108779f60 100644
--- a/drivers/s390/cio/css.c
+++ b/drivers/s390/cio/css.c
@@ -1,12 +1,12 @@
 /*
  *  drivers/s390/cio/css.c
  *  driver for channel subsystem
- *   $Revision: 1.93 $
+ *   $Revision: 1.96 $
  *
  *    Copyright (C) 2002 IBM Deutschland Entwicklung GmbH,
  *                       IBM Corporation
  *    Author(s): Arnd Bergmann (arndb@de.ibm.com)
- *               Cornelia Huck (cohuck@de.ibm.com)
+ *               Cornelia Huck (cornelia.huck@de.ibm.com)
  */
 #include <linux/module.h>
 #include <linux/init.h>
@@ -542,9 +542,41 @@ css_bus_match (struct device *dev, struct device_driver *drv)
         return 0;
 }
 
+static int
+css_probe (struct device *dev)
+{
+        struct subchannel *sch;
+
+        sch = to_subchannel(dev);
+        sch->driver = container_of (dev->driver, struct css_driver, drv);
+        return (sch->driver->probe ? sch->driver->probe(sch) : 0);
+}
+
+static int
+css_remove (struct device *dev)
+{
+        struct subchannel *sch;
+
+        sch = to_subchannel(dev);
+        return (sch->driver->remove ? sch->driver->remove(sch) : 0);
+}
+
+static void
+css_shutdown (struct device *dev)
+{
+        struct subchannel *sch;
+
+        sch = to_subchannel(dev);
+        if (sch->driver->shutdown)
+                sch->driver->shutdown(sch);
+}
+
 struct bus_type css_bus_type = {
-        .name  = "css",
-        .match = &css_bus_match,
+        .name     = "css",
+        .match    = css_bus_match,
+        .probe    = css_probe,
+        .remove   = css_remove,
+        .shutdown = css_shutdown,
 };
 
 subsys_initcall(init_channel_subsystem);
diff --git a/drivers/s390/cio/css.h b/drivers/s390/cio/css.h
index 251ebd7a7d3a..b6375861cb37 100644
--- a/drivers/s390/cio/css.h
+++ b/drivers/s390/cio/css.h
@@ -115,6 +115,7 @@ struct ccw_device_private {
  * Currently, we only care about I/O subchannels (type 0), these
  * have a ccw_device connected to them.
  */
+struct subchannel;
 struct css_driver {
         unsigned int subchannel_type;
         struct device_driver drv;
@@ -122,6 +123,9 @@ struct css_driver {
         int (*notify)(struct device *, int);
         void (*verify)(struct device *);
         void (*termination)(struct device *);
+        int (*probe)(struct subchannel *);
+        int (*remove)(struct subchannel *);
+        void (*shutdown)(struct subchannel *);
 };
 
 /*
@@ -143,7 +147,7 @@ extern int for_each_subchannel(int(*fn)(struct subchannel_id, void *), void *);
 struct channel_subsystem {
         u8 cssid;
         int valid;
-        struct channel_path *chps[__MAX_CHPID];
+        struct channel_path *chps[__MAX_CHPID + 1];
         struct device device;
         struct pgid global_pgid;
 };
diff --git a/drivers/s390/cio/device.c b/drivers/s390/cio/device.c
index fa3e4c0a2536..a67e7e60e330 100644
--- a/drivers/s390/cio/device.c
+++ b/drivers/s390/cio/device.c
@@ -1,12 +1,12 @@
 /*
  *  drivers/s390/cio/device.c
  *  bus driver for ccw devices
- *   $Revision: 1.137 $
+ *   $Revision: 1.140 $
  *
  *    Copyright (C) 2002 IBM Deutschland Entwicklung GmbH,
  *                       IBM Corporation
  *    Author(s): Arnd Bergmann (arndb@de.ibm.com)
- *               Cornelia Huck (cohuck@de.ibm.com)
+ *               Cornelia Huck (cornelia.huck@de.ibm.com)
  *               Martin Schwidefsky (schwidefsky@de.ibm.com)
  */
 #include <linux/config.h>
@@ -107,33 +107,29 @@ ccw_uevent (struct device *dev, char **envp, int num_envp,
         return 0;
 }
 
-struct bus_type ccw_bus_type = {
-        .name  = "ccw",
-        .match = &ccw_bus_match,
-        .uevent = &ccw_uevent,
-};
+struct bus_type ccw_bus_type;
 
-static int io_subchannel_probe (struct device *);
-static int io_subchannel_remove (struct device *);
+static int io_subchannel_probe (struct subchannel *);
+static int io_subchannel_remove (struct subchannel *);
 void io_subchannel_irq (struct device *);
 static int io_subchannel_notify(struct device *, int);
 static void io_subchannel_verify(struct device *);
 static void io_subchannel_ioterm(struct device *);
-static void io_subchannel_shutdown(struct device *);
+static void io_subchannel_shutdown(struct subchannel *);
 
 struct css_driver io_subchannel_driver = {
         .subchannel_type = SUBCHANNEL_TYPE_IO,
         .drv = {
                 .name = "io_subchannel",
                 .bus  = &css_bus_type,
-                .probe = &io_subchannel_probe,
-                .remove = &io_subchannel_remove,
-                .shutdown = &io_subchannel_shutdown,
         },
         .irq = io_subchannel_irq,
         .notify = io_subchannel_notify,
         .verify = io_subchannel_verify,
         .termination = io_subchannel_ioterm,
+        .probe = io_subchannel_probe,
+        .remove = io_subchannel_remove,
+        .shutdown = io_subchannel_shutdown,
 };
 
 struct workqueue_struct *ccw_device_work;
@@ -803,14 +799,12 @@ io_subchannel_recog(struct ccw_device *cdev, struct subchannel *sch)
 }
 
 static int
-io_subchannel_probe (struct device *pdev)
+io_subchannel_probe (struct subchannel *sch)
 {
-        struct subchannel *sch;
         struct ccw_device *cdev;
         int rc;
         unsigned long flags;
 
-        sch = to_subchannel(pdev);
         if (sch->dev.driver_data) {
                 /*
                  * This subchannel already has an associated ccw_device.
@@ -846,7 +840,7 @@ io_subchannel_probe (struct device *pdev)
         memset(cdev->private, 0, sizeof(struct ccw_device_private));
         atomic_set(&cdev->private->onoff, 0);
         cdev->dev = (struct device) {
-                .parent = pdev,
+                .parent = &sch->dev,
                 .release = ccw_device_release,
         };
         INIT_LIST_HEAD(&cdev->private->kick_work.entry);
@@ -859,7 +853,7 @@ io_subchannel_probe (struct device *pdev)
                 return -ENODEV;
         }
 
-        rc = io_subchannel_recog(cdev, to_subchannel(pdev));
+        rc = io_subchannel_recog(cdev, sch);
         if (rc) {
                 spin_lock_irqsave(&sch->lock, flags);
                 sch->dev.driver_data = NULL;
@@ -883,17 +877,17 @@ ccw_device_unregister(void *data)
 }
 
 static int
-io_subchannel_remove (struct device *dev)
+io_subchannel_remove (struct subchannel *sch)
 {
         struct ccw_device *cdev;
         unsigned long flags;
 
-        if (!dev->driver_data)
+        if (!sch->dev.driver_data)
                 return 0;
-        cdev = dev->driver_data;
+        cdev = sch->dev.driver_data;
         /* Set ccw device to not operational and drop reference. */
         spin_lock_irqsave(cdev->ccwlock, flags);
-        dev->driver_data = NULL;
+        sch->dev.driver_data = NULL;
         cdev->private->state = DEV_STATE_NOT_OPER;
         spin_unlock_irqrestore(cdev->ccwlock, flags);
         /*
@@ -948,14 +942,12 @@ io_subchannel_ioterm(struct device *dev)
 }
 
 static void
-io_subchannel_shutdown(struct device *dev)
+io_subchannel_shutdown(struct subchannel *sch)
 {
-        struct subchannel *sch;
         struct ccw_device *cdev;
         int ret;
 
-        sch = to_subchannel(dev);
-        cdev = dev->driver_data;
+        cdev = sch->dev.driver_data;
 
         if (cio_is_console(sch->schid))
                 return;
@@ -1129,6 +1121,14 @@ ccw_device_remove (struct device *dev)
         return 0;
 }
 
+struct bus_type ccw_bus_type = {
+        .name   = "ccw",
+        .match  = ccw_bus_match,
+        .uevent = ccw_uevent,
+        .probe  = ccw_device_probe,
+        .remove = ccw_device_remove,
+};
+
 int
 ccw_driver_register (struct ccw_driver *cdriver)
 {
@@ -1136,8 +1136,6 @@ ccw_driver_register (struct ccw_driver *cdriver)
 
         drv->bus = &ccw_bus_type;
         drv->name = cdriver->name;
-        drv->probe = ccw_device_probe;
-        drv->remove = ccw_device_remove;
 
         return driver_register(drv);
 }
diff --git a/drivers/s390/cio/device_fsm.c b/drivers/s390/cio/device_fsm.c
index 23d12b65e5fa..b302779e7cff 100644
--- a/drivers/s390/cio/device_fsm.c
+++ b/drivers/s390/cio/device_fsm.c
@@ -4,7 +4,7 @@
  *
  *    Copyright (C) 2002 IBM Deutschland Entwicklung GmbH,
  *                       IBM Corporation
- *    Author(s): Cornelia Huck(cohuck@de.ibm.com)
+ *    Author(s): Cornelia Huck (cornelia.huck@de.ibm.com)
  *               Martin Schwidefsky (schwidefsky@de.ibm.com)
  */
 
diff --git a/drivers/s390/cio/device_id.c b/drivers/s390/cio/device_id.c
index 04ceba343db8..e60b2d8103b8 100644
--- a/drivers/s390/cio/device_id.c
+++ b/drivers/s390/cio/device_id.c
@@ -3,7 +3,7 @@
  *
  *    Copyright (C) 2002 IBM Deutschland Entwicklung GmbH,
  *                       IBM Corporation
- *    Author(s): Cornelia Huck(cohuck@de.ibm.com)
+ *    Author(s): Cornelia Huck (cornelia.huck@de.ibm.com)
  *               Martin Schwidefsky (schwidefsky@de.ibm.com)
  *
  * Sense ID functions.
diff --git a/drivers/s390/cio/device_ops.c b/drivers/s390/cio/device_ops.c
index 143b6c25a4e6..8b0218949b62 100644
--- a/drivers/s390/cio/device_ops.c
+++ b/drivers/s390/cio/device_ops.c
@@ -1,12 +1,12 @@
 /*
  *  drivers/s390/cio/device_ops.c
  *
- *   $Revision: 1.58 $
+ *   $Revision: 1.61 $
  *
  *    Copyright (C) 2002 IBM Deutschland Entwicklung GmbH,
  *                       IBM Corporation
  *    Author(s): Martin Schwidefsky (schwidefsky@de.ibm.com)
- *               Cornelia Huck (cohuck@de.ibm.com)
+ *               Cornelia Huck (cornelia.huck@de.ibm.com)
  */
 #include <linux/config.h>
 #include <linux/module.h>
diff --git a/drivers/s390/cio/device_pgid.c b/drivers/s390/cio/device_pgid.c
index 052832d03d38..d2a5b04d7cba 100644
--- a/drivers/s390/cio/device_pgid.c
+++ b/drivers/s390/cio/device_pgid.c
@@ -3,7 +3,7 @@
  *
  *    Copyright (C) 2002 IBM Deutschland Entwicklung GmbH,
  *                       IBM Corporation
- *    Author(s): Cornelia Huck(cohuck@de.ibm.com)
+ *    Author(s): Cornelia Huck (cornelia.huck@de.ibm.com)
  *               Martin Schwidefsky (schwidefsky@de.ibm.com)
  *
  * Path Group ID functions.
diff --git a/drivers/s390/cio/device_status.c b/drivers/s390/cio/device_status.c
index db09c209098b..dad4dd9887c9 100644
--- a/drivers/s390/cio/device_status.c
+++ b/drivers/s390/cio/device_status.c
@@ -3,7 +3,7 @@
  *
  *    Copyright (C) 2002 IBM Deutschland Entwicklung GmbH,
  *                       IBM Corporation
- *    Author(s): Cornelia Huck(cohuck@de.ibm.com)
+ *    Author(s): Cornelia Huck (cornelia.huck@de.ibm.com)
  *               Martin Schwidefsky (schwidefsky@de.ibm.com)
  *
  * Status accumulation and basic sense functions.
diff --git a/drivers/s390/cio/qdio.c b/drivers/s390/cio/qdio.c
index 30a836ffc31f..77be2c39bfe4 100644
--- a/drivers/s390/cio/qdio.c
+++ b/drivers/s390/cio/qdio.c
@@ -7,7 +7,7 @@
  *
  * Copyright 2000,2002 IBM Corporation
  * Author(s):             Utz Bacher <utz.bacher@de.ibm.com>
- * 2.6 cio integration by Cornelia Huck <cohuck@de.ibm.com>
+ * 2.6 cio integration by Cornelia Huck <cornelia.huck@de.ibm.com>
  *
  * Restriction: only 63 iqdio subchannels would have its own indicator,
  * after that, subsequent subchannels share one indicator
@@ -56,7 +56,7 @@
 #include "ioasm.h"
 #include "chsc.h"
 
-#define VERSION_QDIO_C "$Revision: 1.114 $"
+#define VERSION_QDIO_C "$Revision: 1.117 $"
 
 /****************** MODULE PARAMETER VARIABLES ********************/
 MODULE_AUTHOR("Utz Bacher <utz.bacher@de.ibm.com>");
diff --git a/drivers/s390/net/ctcmain.c b/drivers/s390/net/ctcmain.c
index 0db4f57a6a95..1901feef07d9 100644
--- a/drivers/s390/net/ctcmain.c
+++ b/drivers/s390/net/ctcmain.c
@@ -1,5 +1,5 @@
 /*
- * $Id: ctcmain.c,v 1.78 2005/09/07 12:18:02 pavlic Exp $
+ * $Id: ctcmain.c,v 1.79 2006/01/11 11:32:18 cohuck Exp $
  *
  * CTC / ESCON network driver
  *
@@ -8,7 +8,7 @@
  * Fixes by : Jochen Röhrig (roehrig@de.ibm.com)
  *            Arnaldo Carvalho de Melo <acme@conectiva.com.br>
               Peter Tiedemann (ptiedem@de.ibm.com)
- * Driver Model stuff by : Cornelia Huck <cohuck@de.ibm.com>
+ * Driver Model stuff by : Cornelia Huck <huckc@de.ibm.com>
  *
  * Documentation used:
  *  - Principles of Operation (IBM doc#: SA22-7201-06)
@@ -37,7 +37,7 @@
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  *
- * RELEASE-TAG: CTC/ESCON network driver $Revision: 1.78 $
+ * RELEASE-TAG: CTC/ESCON network driver $Revision: 1.79 $
  *
  */
 #undef DEBUG
@@ -248,7 +248,7 @@ static void
 print_banner(void)
 {
         static int printed = 0;
-        char vbuf[] = "$Revision: 1.78 $";
+        char vbuf[] = "$Revision: 1.79 $";
         char *version = vbuf;
 
         if (printed)
diff --git a/drivers/s390/net/cu3088.c b/drivers/s390/net/cu3088.c
index 77dacb465732..2014fb7a4881 100644
--- a/drivers/s390/net/cu3088.c
+++ b/drivers/s390/net/cu3088.c
@@ -1,11 +1,11 @@
 /*
- * $Id: cu3088.c,v 1.36 2005/10/25 14:37:17 cohuck Exp $
+ * $Id: cu3088.c,v 1.38 2006/01/12 14:33:09 cohuck Exp $
  *
  * CTC / LCS ccw_device driver
  *
  * Copyright (C) 2002 IBM Deutschland Entwicklung GmbH, IBM Corporation
  * Author(s): Arnd Bergmann <arndb@de.ibm.com>
- *            Cornelia Huck <cohuck@de.ibm.com>
+ *            Cornelia Huck <cornelia.huck@de.ibm.com>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
diff --git a/drivers/s390/net/netiucv.c b/drivers/s390/net/netiucv.c
index 69425a7a6e98..ac4c4b83fe17 100644
--- a/drivers/s390/net/netiucv.c
+++ b/drivers/s390/net/netiucv.c
@@ -1,12 +1,13 @@
 /*
- * $Id: netiucv.c,v 1.66 2005/05/11 08:10:17 holzheu Exp $
+ * $Id: netiucv.c,v 1.69 2006/01/12 14:33:09 cohuck Exp $
  *
  * IUCV network driver
  *
  * Copyright (C) 2001 IBM Deutschland Entwicklung GmbH, IBM Corporation
  * Author(s): Fritz Elfert (elfert@de.ibm.com, felfert@millenux.com)
  *
- * Driverfs integration and all bugs therein by Cornelia Huck(cohuck@de.ibm.com)
+ * Sysfs integration and all bugs therein by Cornelia Huck
+ * (cornelia.huck@de.ibm.com)
  *
  * Documentation used:
  *  the source of the original IUCV driver by:
@@ -30,7 +31,7 @@
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  *
- * RELEASE-TAG: IUCV network driver $Revision: 1.66 $
+ * RELEASE-TAG: IUCV network driver $Revision: 1.69 $
  *
  */
 
@@ -2076,7 +2077,7 @@ DRIVER_ATTR(remove, 0200, NULL, remove_write);
 static void
 netiucv_banner(void)
 {
-        char vbuf[] = "$Revision: 1.66 $";
+        char vbuf[] = "$Revision: 1.69 $";
         char *version = vbuf;
 
         if ((version = strchr(version, ':'))) {
diff --git a/drivers/s390/s390_rdev.c b/drivers/s390/s390_rdev.c
index 566cc3d185b6..206518c7d332 100644
--- a/drivers/s390/s390_rdev.c
+++ b/drivers/s390/s390_rdev.c
@@ -1,11 +1,11 @@
 /*
  *  drivers/s390/s390_rdev.c
  *  s390 root device
- *   $Revision: 1.2 $
+ *   $Revision: 1.4 $
  *
  *    Copyright (C) 2002, 2005 IBM Deutschland Entwicklung GmbH,
  *                       IBM Corporation
- *    Author(s): Cornelia Huck (cohuck@de.ibm.com)
+ *    Author(s): Cornelia Huck (cornelia.huck@de.ibm.com)
  *                Carsten Otte  (cotte@de.ibm.com)
  */
 
diff --git a/drivers/s390/scsi/zfcp_aux.c b/drivers/s390/scsi/zfcp_aux.c
index 5e84c5aa7779..167fef39d8a7 100644
--- a/drivers/s390/scsi/zfcp_aux.c
+++ b/drivers/s390/scsi/zfcp_aux.c
@@ -1125,6 +1125,8 @@ zfcp_adapter_dequeue(struct zfcp_adapter *adapter)
         zfcp_free_low_mem_buffers(adapter);
         /* free memory of adapter data structure and queues */
         zfcp_qdio_free_queues(adapter);
+        kfree(adapter->fc_stats);
+        kfree(adapter->stats_reset_data);
         ZFCP_LOG_TRACE("freeing adapter structure\n");
         kfree(adapter);
  out:
diff --git a/drivers/s390/scsi/zfcp_def.h b/drivers/s390/scsi/zfcp_def.h
index d81b737d68cc..9bb511083a26 100644
--- a/drivers/s390/scsi/zfcp_def.h
+++ b/drivers/s390/scsi/zfcp_def.h
@@ -921,7 +921,6 @@ struct zfcp_adapter {
         u32                     physical_s_id;     /* local FC port ID */
         struct ccw_device       *ccw_device;       /* S/390 ccw device */
         u8                      fc_service_class;
-        u32                     fc_topology;       /* FC topology */
         u32                     hydra_version;     /* Hydra version */
         u32                     fsf_lic_version;
         u32                     adapter_features;  /* FCP channel features */
@@ -978,6 +977,9 @@ struct zfcp_adapter {
         struct zfcp_adapter_mempool     pool;      /* Adapter memory pools */
         struct qdio_initialize  qdio_init_data;    /* for qdio_establish */
         struct device           generic_services;  /* directory for WKA ports */
+        struct fc_host_statistics *fc_stats;
+        struct fsf_qtcb_bottom_port *stats_reset_data;
+        unsigned long           stats_reset;
 };
 
 /*
diff --git a/drivers/s390/scsi/zfcp_erp.c b/drivers/s390/scsi/zfcp_erp.c
index ee7314d8c2da..7bdb00b5aeb2 100644
--- a/drivers/s390/scsi/zfcp_erp.c
+++ b/drivers/s390/scsi/zfcp_erp.c
@@ -2613,7 +2613,7 @@ zfcp_erp_port_strategy_open_common(struct zfcp_erp_action *erp_action)
         case ZFCP_ERP_STEP_UNINITIALIZED:
         case ZFCP_ERP_STEP_PHYS_PORT_CLOSING:
         case ZFCP_ERP_STEP_PORT_CLOSING:
-                if (adapter->fc_topology == FSF_TOPO_P2P) {
+                if (fc_host_port_type(adapter->scsi_host) == FC_PORTTYPE_PTP) {
                         if (port->wwpn != adapter->peer_wwpn) {
                                 ZFCP_LOG_NORMAL("Failed to open port 0x%016Lx "
                                                 "on adapter %s.\nPeer WWPN "
diff --git a/drivers/s390/scsi/zfcp_fsf.c b/drivers/s390/scsi/zfcp_fsf.c
index 59587951c847..cbfab09899c8 100644
--- a/drivers/s390/scsi/zfcp_fsf.c
+++ b/drivers/s390/scsi/zfcp_fsf.c
@@ -964,6 +964,40 @@ zfcp_fsf_status_read_handler(struct zfcp_fsf_req *fsf_req)
                                         | ZFCP_STATUS_COMMON_ERP_FAILED);
                 break;
 
+        case FSF_STATUS_READ_NOTIFICATION_LOST:
+                ZFCP_LOG_NORMAL("Unsolicited status notification(s) lost: "
+                                "adapter %s%s%s%s%s%s%s%s%s\n",
+                                zfcp_get_busid_by_adapter(adapter),
+                                (status_buffer->status_subtype &
+                                        FSF_STATUS_READ_SUB_INCOMING_ELS) ?
+                                        ", incoming ELS" : "",
+                                (status_buffer->status_subtype &
+                                        FSF_STATUS_READ_SUB_SENSE_DATA) ?
+                                        ", sense data" : "",
+                                (status_buffer->status_subtype &
+                                        FSF_STATUS_READ_SUB_LINK_STATUS) ?
+                                        ", link status change" : "",
+                                (status_buffer->status_subtype &
+                                        FSF_STATUS_READ_SUB_PORT_CLOSED) ?
+                                        ", port close" : "",
+                                (status_buffer->status_subtype &
+                                        FSF_STATUS_READ_SUB_BIT_ERROR_THRESHOLD) ?
+                                        ", bit error exception" : "",
+                                (status_buffer->status_subtype &
+                                        FSF_STATUS_READ_SUB_ACT_UPDATED) ?
+                                        ", ACT update" : "",
+                                (status_buffer->status_subtype &
+                                        FSF_STATUS_READ_SUB_ACT_HARDENED) ?
+                                        ", ACT hardening" : "",
+                                (status_buffer->status_subtype &
+                                        FSF_STATUS_READ_SUB_FEATURE_UPDATE_ALERT) ?
+                                        ", adapter feature change" : "");
+
+                if (status_buffer->status_subtype &
+                    FSF_STATUS_READ_SUB_ACT_UPDATED)
+                        zfcp_erp_adapter_access_changed(adapter);
+                break;
+
         case FSF_STATUS_READ_CFDC_UPDATED:
                 ZFCP_LOG_NORMAL("CFDC has been updated on the adapter %s\n",
                               zfcp_get_busid_by_adapter(adapter));
@@ -1954,6 +1988,7 @@ zfcp_fsf_exchange_config_data(struct zfcp_erp_action *erp_action)
         erp_action->fsf_req->qtcb->bottom.config.feature_selection =
                         FSF_FEATURE_CFDC |
                         FSF_FEATURE_LUN_SHARING |
+                        FSF_FEATURE_NOTIFICATION_LOST |
                         FSF_FEATURE_UPDATE_ALERT;
 
         /* start QDIO request for this FSF request */
@@ -2008,27 +2043,30 @@ zfcp_fsf_exchange_config_evaluate(struct zfcp_fsf_req *fsf_req, int xchg_ok)
                 fc_host_port_id(shost) = bottom->s_id & ZFCP_DID_MASK;
                 fc_host_speed(shost) = bottom->fc_link_speed;
                 fc_host_supported_classes(shost) = FC_COS_CLASS2 | FC_COS_CLASS3;
-                adapter->fc_topology = bottom->fc_topology;
                 adapter->hydra_version = bottom->adapter_type;
-                if (adapter->physical_wwpn == 0)
-                        adapter->physical_wwpn = fc_host_port_name(shost);
-                if (adapter->physical_s_id == 0)
-                        adapter->physical_s_id = fc_host_port_id(shost);
+                if (fc_host_permanent_port_name(shost) == -1)
+                        fc_host_permanent_port_name(shost) =
+                                fc_host_port_name(shost);
+                if (bottom->fc_topology == FSF_TOPO_P2P) {
+                        adapter->peer_d_id = bottom->peer_d_id & ZFCP_DID_MASK;
+                        adapter->peer_wwpn = bottom->plogi_payload.wwpn;
+                        adapter->peer_wwnn = bottom->plogi_payload.wwnn;
+                        fc_host_port_type(shost) = FC_PORTTYPE_PTP;
+                } else if (bottom->fc_topology == FSF_TOPO_FABRIC)
+                        fc_host_port_type(shost) = FC_PORTTYPE_NPORT;
+                else if (bottom->fc_topology == FSF_TOPO_AL)
+                        fc_host_port_type(shost) = FC_PORTTYPE_NLPORT;
+                else
+                        fc_host_port_type(shost) = FC_PORTTYPE_UNKNOWN;
         } else {
                 fc_host_node_name(shost) = 0;
                 fc_host_port_name(shost) = 0;
                 fc_host_port_id(shost) = 0;
                 fc_host_speed(shost) = FC_PORTSPEED_UNKNOWN;
-                adapter->fc_topology = 0;
+                fc_host_port_type(shost) = FC_PORTTYPE_UNKNOWN;
                 adapter->hydra_version = 0;
         }
 
-        if (adapter->fc_topology == FSF_TOPO_P2P) {
-                adapter->peer_d_id = bottom->peer_d_id & ZFCP_DID_MASK;
-                adapter->peer_wwpn = bottom->plogi_payload.wwpn;
-                adapter->peer_wwnn = bottom->plogi_payload.wwnn;
-        }
-
         if (adapter->adapter_features & FSF_FEATURE_HBAAPI_MANAGEMENT) {
                 adapter->hardware_version = bottom->hardware_version;
                 memcpy(fc_host_serial_number(shost), bottom->serial_number,
@@ -2097,8 +2135,8 @@ zfcp_fsf_exchange_config_data_handler(struct zfcp_fsf_req *fsf_req)
                 if (zfcp_fsf_exchange_config_evaluate(fsf_req, 1))
                         return -EIO;
 
-                switch (adapter->fc_topology) {
-                case FSF_TOPO_P2P:
+                switch (fc_host_port_type(adapter->scsi_host)) {
+                case FC_PORTTYPE_PTP:
                         ZFCP_LOG_NORMAL("Point-to-Point fibrechannel "
                                         "configuration detected at adapter %s\n"
                                         "Peer WWNN 0x%016llx, "
@@ -2111,7 +2149,7 @@ zfcp_fsf_exchange_config_data_handler(struct zfcp_fsf_req *fsf_req)
                         debug_text_event(fsf_req->adapter->erp_dbf, 0,
                                          "top-p-to-p");
                         break;
-                case FSF_TOPO_AL:
+                case FC_PORTTYPE_NLPORT:
                         ZFCP_LOG_NORMAL("error: Arbitrated loop fibrechannel "
                                         "topology detected at adapter %s "
                                         "unsupported, shutting down adapter\n",
@@ -2120,7 +2158,7 @@ zfcp_fsf_exchange_config_data_handler(struct zfcp_fsf_req *fsf_req)
                                          "top-al");
                         zfcp_erp_adapter_shutdown(adapter, 0);
                         return -EIO;
-                case FSF_TOPO_FABRIC:
+                case FC_PORTTYPE_NPORT:
                         ZFCP_LOG_NORMAL("Switched fabric fibrechannel "
                                       "network detected at adapter %s.\n",
                                       zfcp_get_busid_by_adapter(adapter));
@@ -2133,7 +2171,6 @@ zfcp_fsf_exchange_config_data_handler(struct zfcp_fsf_req *fsf_req)
                                         "of a type known to the zfcp "
                                         "driver, shutting down adapter\n",
                                         zfcp_get_busid_by_adapter(adapter));
-                        adapter->fc_topology = FSF_TOPO_ERROR;
                         debug_text_exception(fsf_req->adapter->erp_dbf, 0,
                                              "unknown-topo");
                         zfcp_erp_adapter_shutdown(adapter, 0);
@@ -2293,14 +2330,13 @@ zfcp_fsf_exchange_port_data_handler(struct zfcp_fsf_req *fsf_req)
                 data = (struct fsf_qtcb_bottom_port*) fsf_req->data;
                 if (data)
                         memcpy(data, bottom, sizeof(struct fsf_qtcb_bottom_port));
-                if (adapter->connection_features & FSF_FEATURE_NPIV_MODE) {
-                        adapter->physical_wwpn = bottom->wwpn;
-                        adapter->physical_s_id = bottom->fc_port_id;
-                } else {
-                        adapter->physical_wwpn = fc_host_port_name(shost);
-                        adapter->physical_s_id = fc_host_port_id(shost);
-                }
+                if (adapter->connection_features & FSF_FEATURE_NPIV_MODE)
+                        fc_host_permanent_port_name(shost) = bottom->wwpn;
+                else
+                        fc_host_permanent_port_name(shost) =
+                                fc_host_port_name(shost);
                 fc_host_maxframe_size(shost) = bottom->maximum_frame_size;
+                fc_host_supported_speeds(shost) = bottom->supported_speed;
                 break;
 
         case FSF_EXCHANGE_CONFIG_DATA_INCOMPLETE:
diff --git a/drivers/s390/scsi/zfcp_fsf.h b/drivers/s390/scsi/zfcp_fsf.h
index 48719f055952..e734415cae6d 100644
--- a/drivers/s390/scsi/zfcp_fsf.h
+++ b/drivers/s390/scsi/zfcp_fsf.h
@@ -166,6 +166,7 @@
 #define FSF_STATUS_READ_BIT_ERROR_THRESHOLD     0x00000004
 #define FSF_STATUS_READ_LINK_DOWN               0x00000005
 #define FSF_STATUS_READ_LINK_UP                 0x00000006
+#define FSF_STATUS_READ_NOTIFICATION_LOST       0x00000009
 #define FSF_STATUS_READ_CFDC_UPDATED            0x0000000A
 #define FSF_STATUS_READ_CFDC_HARDENED           0x0000000B
 #define FSF_STATUS_READ_FEATURE_UPDATE_ALERT    0x0000000C
@@ -179,6 +180,16 @@
 #define FSF_STATUS_READ_SUB_FDISC_FAILED        0x00000001
 #define FSF_STATUS_READ_SUB_FIRMWARE_UPDATE     0x00000002
 
+/* status subtypes for unsolicited status notification lost */
+#define FSF_STATUS_READ_SUB_INCOMING_ELS        0x00000001
+#define FSF_STATUS_READ_SUB_SENSE_DATA          0x00000002
+#define FSF_STATUS_READ_SUB_LINK_STATUS         0x00000004
+#define FSF_STATUS_READ_SUB_PORT_CLOSED         0x00000008
+#define FSF_STATUS_READ_SUB_BIT_ERROR_THRESHOLD 0x00000010
+#define FSF_STATUS_READ_SUB_ACT_UPDATED         0x00000020
+#define FSF_STATUS_READ_SUB_ACT_HARDENED        0x00000040
+#define FSF_STATUS_READ_SUB_FEATURE_UPDATE_ALERT 0x00000080
+
 /* status subtypes for CFDC */
 #define FSF_STATUS_READ_SUB_CFDC_HARDENED_ON_SE 0x00000002
 #define FSF_STATUS_READ_SUB_CFDC_HARDENED_ON_SE2 0x0000000F
@@ -188,7 +199,6 @@
 #define FSF_TOPO_P2P                            0x00000001
 #define FSF_TOPO_FABRIC                         0x00000002
 #define FSF_TOPO_AL                             0x00000003
-#define FSF_TOPO_FABRIC_VIRT                    0x00000004
 
 /* data direction for FCP commands */
 #define FSF_DATADIR_WRITE                       0x00000001
@@ -211,6 +221,7 @@
 /* channel features */
 #define FSF_FEATURE_CFDC                        0x00000002
 #define FSF_FEATURE_LUN_SHARING                 0x00000004
+#define FSF_FEATURE_NOTIFICATION_LOST           0x00000008
 #define FSF_FEATURE_HBAAPI_MANAGEMENT           0x00000010
 #define FSF_FEATURE_ELS_CT_CHAINED_SBALS        0x00000020
 #define FSF_FEATURE_UPDATE_ALERT                0x00000100
diff --git a/drivers/s390/scsi/zfcp_scsi.c b/drivers/s390/scsi/zfcp_scsi.c
index 66608d13a634..3c2cbcccbf54 100644
--- a/drivers/s390/scsi/zfcp_scsi.c
+++ b/drivers/s390/scsi/zfcp_scsi.c
@@ -49,8 +49,6 @@ static int zfcp_task_management_function(struct zfcp_unit *, u8,
 
 static struct zfcp_unit *zfcp_unit_lookup(struct zfcp_adapter *, int, scsi_id_t,
                                           scsi_lun_t);
-static struct zfcp_port *zfcp_port_lookup(struct zfcp_adapter *, int,
-                                          scsi_id_t);
 
 static struct device_attribute *zfcp_sysfs_sdev_attrs[];
 
@@ -406,18 +404,6 @@ zfcp_unit_lookup(struct zfcp_adapter *adapter, int channel, scsi_id_t id,
         return retval;
 }
 
-static struct zfcp_port *
-zfcp_port_lookup(struct zfcp_adapter *adapter, int channel, scsi_id_t id)
-{
-        struct zfcp_port *port;
-
-        list_for_each_entry(port, &adapter->port_list_head, list) {
-                if (port->rport && (id == port->rport->scsi_target_id))
-                        return port;
-        }
-        return (struct zfcp_port *) NULL;
-}
-
 /**
  * zfcp_scsi_eh_abort_handler - abort the specified SCSI command
  * @scpnt: pointer to scsi_cmnd to be aborted 
@@ -731,70 +717,164 @@ zfcp_fsf_start_scsi_er_timer(struct zfcp_adapter *adapter)
 /*
  * Support functions for FC transport class
  */
-static void
-zfcp_get_port_id(struct scsi_target *starget)
+static struct fc_host_statistics*
+zfcp_init_fc_host_stats(struct zfcp_adapter *adapter)
 {
-        struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
-        struct zfcp_adapter *adapter = (struct zfcp_adapter *)shost->hostdata[0];
-        struct zfcp_port *port;
-        unsigned long flags;
+        struct fc_host_statistics *fc_stats;
 
-        read_lock_irqsave(&zfcp_data.config_lock, flags);
-        port = zfcp_port_lookup(adapter, starget->channel, starget->id);
-        if (port)
-                fc_starget_port_id(starget) = port->d_id;
-        else
-                fc_starget_port_id(starget) = -1;
-        read_unlock_irqrestore(&zfcp_data.config_lock, flags);
+        if (!adapter->fc_stats) {
+                fc_stats = kmalloc(sizeof(*fc_stats), GFP_KERNEL);
+                if (!fc_stats)
+                        return NULL;
+                adapter->fc_stats = fc_stats; /* freed in adater_dequeue */
+        }
+        memset(adapter->fc_stats, 0, sizeof(*adapter->fc_stats));
+        return adapter->fc_stats;
 }
 
 static void
-zfcp_get_port_name(struct scsi_target *starget)
+zfcp_adjust_fc_host_stats(struct fc_host_statistics *fc_stats,
+                          struct fsf_qtcb_bottom_port *data,
+                          struct fsf_qtcb_bottom_port *old)
 {
-        struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
-        struct zfcp_adapter *adapter = (struct zfcp_adapter *)shost->hostdata[0];
-        struct zfcp_port *port;
-        unsigned long flags;
+        fc_stats->seconds_since_last_reset = data->seconds_since_last_reset -
+                old->seconds_since_last_reset;
+        fc_stats->tx_frames = data->tx_frames - old->tx_frames;
+        fc_stats->tx_words = data->tx_words - old->tx_words;
+        fc_stats->rx_frames = data->rx_frames - old->rx_frames;
+        fc_stats->rx_words = data->rx_words - old->rx_words;
+        fc_stats->lip_count = data->lip - old->lip;
+        fc_stats->nos_count = data->nos - old->nos;
+        fc_stats->error_frames = data->error_frames - old->error_frames;
+        fc_stats->dumped_frames = data->dumped_frames - old->dumped_frames;
+        fc_stats->link_failure_count = data->link_failure - old->link_failure;
+        fc_stats->loss_of_sync_count = data->loss_of_sync - old->loss_of_sync;
+        fc_stats->loss_of_signal_count = data->loss_of_signal -
+                old->loss_of_signal;
+        fc_stats->prim_seq_protocol_err_count = data->psp_error_counts -
+                old->psp_error_counts;
+        fc_stats->invalid_tx_word_count = data->invalid_tx_words -
+                old->invalid_tx_words;
+        fc_stats->invalid_crc_count = data->invalid_crcs - old->invalid_crcs;
+        fc_stats->fcp_input_requests = data->input_requests -
+                old->input_requests;
+        fc_stats->fcp_output_requests = data->output_requests -
+                old->output_requests;
+        fc_stats->fcp_control_requests = data->control_requests -
+                old->control_requests;
+        fc_stats->fcp_input_megabytes = data->input_mb - old->input_mb;
+        fc_stats->fcp_output_megabytes = data->output_mb - old->output_mb;
+}
 
-        read_lock_irqsave(&zfcp_data.config_lock, flags);
-        port = zfcp_port_lookup(adapter, starget->channel, starget->id);
-        if (port)
-                fc_starget_port_name(starget) = port->wwpn;
-        else
-                fc_starget_port_name(starget) = -1;
-        read_unlock_irqrestore(&zfcp_data.config_lock, flags);
+static void
+zfcp_set_fc_host_stats(struct fc_host_statistics *fc_stats,
+                       struct fsf_qtcb_bottom_port *data)
+{
+        fc_stats->seconds_since_last_reset = data->seconds_since_last_reset;
+        fc_stats->tx_frames = data->tx_frames;
+        fc_stats->tx_words = data->tx_words;
+        fc_stats->rx_frames = data->rx_frames;
+        fc_stats->rx_words = data->rx_words;
+        fc_stats->lip_count = data->lip;
+        fc_stats->nos_count = data->nos;
+        fc_stats->error_frames = data->error_frames;
+        fc_stats->dumped_frames = data->dumped_frames;
+        fc_stats->link_failure_count = data->link_failure;
+        fc_stats->loss_of_sync_count = data->loss_of_sync;
+        fc_stats->loss_of_signal_count = data->loss_of_signal;
+        fc_stats->prim_seq_protocol_err_count = data->psp_error_counts;
+        fc_stats->invalid_tx_word_count = data->invalid_tx_words;
+        fc_stats->invalid_crc_count = data->invalid_crcs;
+        fc_stats->fcp_input_requests = data->input_requests;
+        fc_stats->fcp_output_requests = data->output_requests;
+        fc_stats->fcp_control_requests = data->control_requests;
+        fc_stats->fcp_input_megabytes = data->input_mb;
+        fc_stats->fcp_output_megabytes = data->output_mb;
+}
+
+/**
+ * zfcp_get_fc_host_stats - provide fc_host_statistics for scsi_transport_fc
+ *
+ * assumption: scsi_transport_fc synchronizes calls of
+ *             get_fc_host_stats and reset_fc_host_stats
+ *             (XXX to be checked otherwise introduce locking)
+ */
+static struct fc_host_statistics *
+zfcp_get_fc_host_stats(struct Scsi_Host *shost)
+{
+        struct zfcp_adapter *adapter;
+        struct fc_host_statistics *fc_stats;
+        struct fsf_qtcb_bottom_port *data;
+        int ret;
+
+        adapter = (struct zfcp_adapter *)shost->hostdata[0];
+        fc_stats = zfcp_init_fc_host_stats(adapter);
+        if (!fc_stats)
+                return NULL;
+
+        data = kmalloc(sizeof(*data), GFP_KERNEL);
+        if (!data)
+                return NULL;
+        memset(data, 0, sizeof(*data));
+
+        ret = zfcp_fsf_exchange_port_data(NULL, adapter, data);
+        if (ret) {
+                kfree(data);
+                return NULL; /* XXX return zeroed fc_stats? */
+        }
+
+        if (adapter->stats_reset &&
+            ((jiffies/HZ - adapter->stats_reset) <
+             data->seconds_since_last_reset)) {
+                zfcp_adjust_fc_host_stats(fc_stats, data,
+                                          adapter->stats_reset_data);
+        } else
+                zfcp_set_fc_host_stats(fc_stats, data);
+
+        kfree(data);
+        return fc_stats;
 }
 
 static void
-zfcp_get_node_name(struct scsi_target *starget)
+zfcp_reset_fc_host_stats(struct Scsi_Host *shost)
 {
-        struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
-        struct zfcp_adapter *adapter = (struct zfcp_adapter *)shost->hostdata[0];
-        struct zfcp_port *port;
-        unsigned long flags;
+        struct zfcp_adapter *adapter;
+        struct fsf_qtcb_bottom_port *data, *old_data;
+        int ret;
 
-        read_lock_irqsave(&zfcp_data.config_lock, flags);
-        port = zfcp_port_lookup(adapter, starget->channel, starget->id);
-        if (port)
-                fc_starget_node_name(starget) = port->wwnn;
-        else
-                fc_starget_node_name(starget) = -1;
-        read_unlock_irqrestore(&zfcp_data.config_lock, flags);
+        adapter = (struct zfcp_adapter *)shost->hostdata[0];
+        data = kmalloc(sizeof(*data), GFP_KERNEL);
+        if (!data)
+                return;
+        memset(data, 0, sizeof(*data));
+
+        ret = zfcp_fsf_exchange_port_data(NULL, adapter, data);
+        if (ret == 0) {
+                adapter->stats_reset = jiffies/HZ;
+                old_data = adapter->stats_reset_data;
+                adapter->stats_reset_data = data; /* finally freed in
+                                                     adater_dequeue */
+                kfree(old_data);
+        }
 }
 
 struct fc_function_template zfcp_transport_functions = {
-        .get_starget_port_id = zfcp_get_port_id,
-        .get_starget_port_name = zfcp_get_port_name,
-        .get_starget_node_name = zfcp_get_node_name,
         .show_starget_port_id = 1,
         .show_starget_port_name = 1,
         .show_starget_node_name = 1,
         .show_rport_supported_classes = 1,
         .show_host_node_name = 1,
         .show_host_port_name = 1,
+        .show_host_permanent_port_name = 1,
         .show_host_supported_classes = 1,
+        .show_host_supported_speeds = 1,
         .show_host_maxframe_size = 1,
         .show_host_serial_number = 1,
+        .get_fc_host_stats = zfcp_get_fc_host_stats,
+        .reset_fc_host_stats = zfcp_reset_fc_host_stats,
+        /* no functions registered for following dynamic attributes but
+           directly set by LLDD */
+        .show_host_port_type = 1,
         .show_host_speed = 1,
         .show_host_port_id = 1,
 };
diff --git a/drivers/s390/scsi/zfcp_sysfs_adapter.c b/drivers/s390/scsi/zfcp_sysfs_adapter.c
index 0cd435280e7d..9f262250043a 100644
--- a/drivers/s390/scsi/zfcp_sysfs_adapter.c
+++ b/drivers/s390/scsi/zfcp_sysfs_adapter.c
@@ -33,14 +33,6 @@
 
 #define ZFCP_LOG_AREA                   ZFCP_LOG_AREA_CONFIG
 
-static const char fc_topologies[5][25] = {
-        "<error>",
-        "point-to-point",
-        "fabric",
-        "arbitrated loop",
-        "fabric (virt. adapter)"
-};
-
 /**
  * ZFCP_DEFINE_ADAPTER_ATTR
  * @_name:   name of show attribute
@@ -69,12 +61,8 @@ ZFCP_DEFINE_ADAPTER_ATTR(physical_wwpn, "0x%016llx\n", adapter->physical_wwpn);
 ZFCP_DEFINE_ADAPTER_ATTR(physical_s_id, "0x%06x\n", adapter->physical_s_id);
 ZFCP_DEFINE_ADAPTER_ATTR(card_version, "0x%04x\n", adapter->hydra_version);
 ZFCP_DEFINE_ADAPTER_ATTR(lic_version, "0x%08x\n", adapter->fsf_lic_version);
-ZFCP_DEFINE_ADAPTER_ATTR(fc_service_class, "%d\n", adapter->fc_service_class);
-ZFCP_DEFINE_ADAPTER_ATTR(fc_topology, "%s\n",
-                         fc_topologies[adapter->fc_topology]);
 ZFCP_DEFINE_ADAPTER_ATTR(hardware_version, "0x%08x\n",
                          adapter->hardware_version);
-ZFCP_DEFINE_ADAPTER_ATTR(scsi_host_no, "0x%x\n", adapter->scsi_host_no);
 ZFCP_DEFINE_ADAPTER_ATTR(in_recovery, "%d\n", atomic_test_mask
                          (ZFCP_STATUS_COMMON_ERP_INUSE, &adapter->status));
 
@@ -259,9 +247,6 @@ static struct attribute *zfcp_adapter_attrs[] = {
         &dev_attr_physical_s_id.attr,
         &dev_attr_card_version.attr,
         &dev_attr_lic_version.attr,
-        &dev_attr_fc_service_class.attr,
-        &dev_attr_fc_topology.attr,
-        &dev_attr_scsi_host_no.attr,
         &dev_attr_status.attr,
         &dev_attr_hardware_version.attr,
         NULL
diff --git a/drivers/s390/scsi/zfcp_sysfs_port.c b/drivers/s390/scsi/zfcp_sysfs_port.c
index c55e82d91deb..3924eb38805c 100644
--- a/drivers/s390/scsi/zfcp_sysfs_port.c
+++ b/drivers/s390/scsi/zfcp_sysfs_port.c
@@ -65,8 +65,6 @@ static ssize_t zfcp_sysfs_port_##_name##_show(struct device *dev, struct device_
 static DEVICE_ATTR(_name, S_IRUGO, zfcp_sysfs_port_##_name##_show, NULL);
 
 ZFCP_DEFINE_PORT_ATTR(status, "0x%08x\n", atomic_read(&port->status));
-ZFCP_DEFINE_PORT_ATTR(wwnn, "0x%016llx\n", port->wwnn);
-ZFCP_DEFINE_PORT_ATTR(d_id, "0x%06x\n", port->d_id);
 ZFCP_DEFINE_PORT_ATTR(in_recovery, "%d\n", atomic_test_mask
                       (ZFCP_STATUS_COMMON_ERP_INUSE, &port->status));
 ZFCP_DEFINE_PORT_ATTR(access_denied, "%d\n", atomic_test_mask
@@ -245,8 +243,6 @@ static struct attribute *zfcp_port_common_attrs[] = {
         &dev_attr_failed.attr,
         &dev_attr_in_recovery.attr,
         &dev_attr_status.attr,
-        &dev_attr_wwnn.attr,
-        &dev_attr_d_id.attr,
         &dev_attr_access_denied.attr,
         NULL
 };
diff --git a/drivers/s390/scsi/zfcp_sysfs_unit.c b/drivers/s390/scsi/zfcp_sysfs_unit.c
index 0556642c9e1d..2f50815f65c7 100644
--- a/drivers/s390/scsi/zfcp_sysfs_unit.c
+++ b/drivers/s390/scsi/zfcp_sysfs_unit.c
@@ -65,7 +65,6 @@ static ssize_t zfcp_sysfs_unit_##_name##_show(struct device *dev, struct device_
 static DEVICE_ATTR(_name, S_IRUGO, zfcp_sysfs_unit_##_name##_show, NULL);
 
 ZFCP_DEFINE_UNIT_ATTR(status, "0x%08x\n", atomic_read(&unit->status));
-ZFCP_DEFINE_UNIT_ATTR(scsi_lun, "0x%x\n", unit->scsi_lun);
 ZFCP_DEFINE_UNIT_ATTR(in_recovery, "%d\n", atomic_test_mask
                       (ZFCP_STATUS_COMMON_ERP_INUSE, &unit->status));
 ZFCP_DEFINE_UNIT_ATTR(access_denied, "%d\n", atomic_test_mask
@@ -138,7 +137,6 @@ static DEVICE_ATTR(failed, S_IWUSR | S_IRUGO, zfcp_sysfs_unit_failed_show,
                    zfcp_sysfs_unit_failed_store);
 
 static struct attribute *zfcp_unit_attrs[] = {
-        &dev_attr_scsi_lun.attr,
         &dev_attr_failed.attr,
         &dev_attr_in_recovery.attr,
         &dev_attr_status.attr,
diff --git a/drivers/sbus/char/aurora.c b/drivers/sbus/char/aurora.c
index 92e6c5639dd3..015db40ad8a4 100644
--- a/drivers/sbus/char/aurora.c
+++ b/drivers/sbus/char/aurora.c
@@ -92,7 +92,6 @@ static struct Aurora_port aurora_port[AURORA_TNPORTS] =  {
 
 /* no longer used. static struct Aurora_board * IRQ_to_board[16] = { NULL, } ;*/
 static unsigned char * tmp_buf = NULL;
-static DECLARE_MUTEX(tmp_buf_sem);
 
 DECLARE_TASK_QUEUE(tq_aurora);
 
diff --git a/drivers/scsi/3w-9xxx.c b/drivers/scsi/3w-9xxx.c
index 3ff74f472249..31c497542272 100644
--- a/drivers/scsi/3w-9xxx.c
+++ b/drivers/scsi/3w-9xxx.c
@@ -73,6 +73,7 @@
 #include <linux/delay.h>
 #include <linux/pci.h>
 #include <linux/time.h>
+#include <linux/mutex.h>
 #include <asm/io.h>
 #include <asm/irq.h>
 #include <asm/uaccess.h>
@@ -615,7 +616,7 @@ static int twa_chrdev_ioctl(struct inode *inode, struct file *file, unsigned int
         void __user *argp = (void __user *)arg;
 
         /* Only let one of these through at a time */
-        if (down_interruptible(&tw_dev->ioctl_sem)) {
+        if (mutex_lock_interruptible(&tw_dev->ioctl_lock)) {
                 retval = TW_IOCTL_ERROR_OS_EINTR;
                 goto out;
         }
@@ -852,7 +853,7 @@ out3:
         /* Now free ioctl buf memory */
         dma_free_coherent(&tw_dev->tw_pci_dev->dev, data_buffer_length_adjusted+sizeof(TW_Ioctl_Buf_Apache) - 1, cpu_addr, dma_handle);
 out2:
-        up(&tw_dev->ioctl_sem);
+        mutex_unlock(&tw_dev->ioctl_lock);
 out:
         return retval;
 } /* End twa_chrdev_ioctl() */
@@ -1182,7 +1183,7 @@ static int twa_initialize_device_extension(TW_Device_Extension *tw_dev)
         tw_dev->error_sequence_id = 1;
         tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE;
 
-        init_MUTEX(&tw_dev->ioctl_sem);
+        mutex_init(&tw_dev->ioctl_lock);
         init_waitqueue_head(&tw_dev->ioctl_wqueue);
 
         retval = 0;
diff --git a/drivers/scsi/3w-9xxx.h b/drivers/scsi/3w-9xxx.h
index 46f22cdc8298..1b16d57f0314 100644
--- a/drivers/scsi/3w-9xxx.h
+++ b/drivers/scsi/3w-9xxx.h
@@ -672,7 +672,7 @@ typedef struct TAG_TW_Device_Extension {
         u32                     ioctl_msec;
         int                     chrdev_request_id;
         wait_queue_head_t       ioctl_wqueue;
-        struct semaphore        ioctl_sem;
+        struct mutex            ioctl_lock;
         char                    aen_clobber;
         unsigned short          working_srl;
         unsigned short          working_branch;
diff --git a/drivers/scsi/3w-xxxx.c b/drivers/scsi/3w-xxxx.c
index 283f6d25892b..25f678d0780b 100644
--- a/drivers/scsi/3w-xxxx.c
+++ b/drivers/scsi/3w-xxxx.c
@@ -203,6 +203,7 @@
 #include <linux/delay.h>
 #include <linux/pci.h>
 #include <linux/time.h>
+#include <linux/mutex.h>
 #include <asm/io.h>
 #include <asm/irq.h>
 #include <asm/uaccess.h>
@@ -888,7 +889,7 @@ static int tw_chrdev_ioctl(struct inode *inode, struct file *file, unsigned int
         dprintk(KERN_WARNING "3w-xxxx: tw_chrdev_ioctl()\n");
 
         /* Only let one of these through at a time */
-        if (down_interruptible(&tw_dev->ioctl_sem))
+        if (mutex_lock_interruptible(&tw_dev->ioctl_lock))
                 return -EINTR;
 
         /* First copy down the buffer length */
@@ -1029,7 +1030,7 @@ out2:
         /* Now free ioctl buf memory */
         dma_free_coherent(&tw_dev->tw_pci_dev->dev, data_buffer_length_adjusted+sizeof(TW_New_Ioctl) - 1, cpu_addr, dma_handle);
 out:
-        up(&tw_dev->ioctl_sem);
+        mutex_unlock(&tw_dev->ioctl_lock);
         return retval;
 } /* End tw_chrdev_ioctl() */
 
@@ -1270,7 +1271,7 @@ static int tw_initialize_device_extension(TW_Device_Extension *tw_dev)
         tw_dev->pending_tail = TW_Q_START;
         tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE;
 
-        init_MUTEX(&tw_dev->ioctl_sem);
+        mutex_init(&tw_dev->ioctl_lock);
         init_waitqueue_head(&tw_dev->ioctl_wqueue);
 
         return 0;
diff --git a/drivers/scsi/3w-xxxx.h b/drivers/scsi/3w-xxxx.h
index 4f81fc39ec57..31fe5ea15920 100644
--- a/drivers/scsi/3w-xxxx.h
+++ b/drivers/scsi/3w-xxxx.h
@@ -420,7 +420,7 @@ typedef struct TAG_TW_Device_Extension {
         u32                     max_sector_count;
         u32                     aen_count;
         struct Scsi_Host        *host;
-        struct semaphore        ioctl_sem;
+        struct mutex            ioctl_lock;
         unsigned short          aen_queue[TW_Q_LENGTH];
         unsigned char           aen_head;
         unsigned char           aen_tail;
diff --git a/drivers/scsi/BusLogic.c b/drivers/scsi/BusLogic.c
index 9d6040bfa064..1c459343292b 100644
--- a/drivers/scsi/BusLogic.c
+++ b/drivers/scsi/BusLogic.c
@@ -2216,6 +2216,7 @@ static int __init BusLogic_init(void)
                 HostAdapter->PCI_Address = ProbeInfo->PCI_Address;
                 HostAdapter->Bus = ProbeInfo->Bus;
                 HostAdapter->Device = ProbeInfo->Device;
+                HostAdapter->PCI_Device = ProbeInfo->PCI_Device;
                 HostAdapter->IRQ_Channel = ProbeInfo->IRQ_Channel;
                 HostAdapter->AddressCount = BusLogic_HostAdapterAddressCount[HostAdapter->HostAdapterType];
                 /*
@@ -2296,7 +2297,7 @@ static int __init BusLogic_init(void)
                                 scsi_host_put(Host);
                         } else {
                                 BusLogic_InitializeHostStructure(HostAdapter, Host);
-                                scsi_add_host(Host, NULL);
+                                scsi_add_host(Host, HostAdapter->PCI_Device ? &HostAdapter->PCI_Device->dev : NULL);
                                 scsi_scan_host(Host);
                                 BusLogicHostAdapterCount++;
                         }
diff --git a/drivers/scsi/Makefile b/drivers/scsi/Makefile
index 6e0c059df6a5..320e765fa0cd 100644
--- a/drivers/scsi/Makefile
+++ b/drivers/scsi/Makefile
@@ -80,7 +80,7 @@ obj-$(CONFIG_SCSI_QLOGIC_FAS)	+= qlogicfas408.o	qlogicfas.o
 obj-$(CONFIG_PCMCIA_QLOGIC)     += qlogicfas408.o
 obj-$(CONFIG_SCSI_QLOGIC_FC)    += qlogicfc.o 
 obj-$(CONFIG_SCSI_QLOGIC_1280)  += qla1280.o 
-obj-$(CONFIG_SCSI_QLA2XXX)      += qla2xxx/
+obj-$(CONFIG_SCSI_QLA_FC)       += qla2xxx/
 obj-$(CONFIG_SCSI_LPFC)         += lpfc/
 obj-$(CONFIG_SCSI_PAS16)        += pas16.o
 obj-$(CONFIG_SCSI_SEAGATE)      += seagate.o
diff --git a/drivers/scsi/aacraid/README b/drivers/scsi/aacraid/README
deleted file mode 100644
index 4193865d419c..000000000000
--- a/drivers/scsi/aacraid/README
+++ /dev/null
@@ -1,74 +0,0 @@
-AACRAID Driver for Linux (take two)
-
-Introduction
--------------------------
-The aacraid driver adds support for Adaptec (http://www.adaptec.com)
-RAID controllers. This is a major rewrite from the original 
-Adaptec supplied driver. It has signficantly cleaned up both the code
-and the running binary size (the module is less than half the size of
-the original).
-
-Supported Cards/Chipsets
--------------------------
-        Adaptec 2020S
-        Adaptec 2025S
-        Adaptec 2120S
-        Adaptec 2130S
-        Adaptec 2200S
-        Adaptec 2230S
-        Adaptec 2240S
-        Adaptec 2410SA
-        Adaptec 2610SA
-        Adaptec 2810SA
-        Adaptec 21610SA
-        Adaptec 3230S
-        Adaptec 3240S
-        Adaptec 4000SAS
-        Adaptec 4005SAS
-        Adaptec 4800SAS
-        Adaptec 4805SAS
-        Adaptec 5400S
-        Dell PERC 2 Quad Channel
-        Dell PERC 2/Si
-        Dell PERC 3/Si
-        Dell PERC 3/Di
-        Dell CERC 2
-        HP NetRAID-4M
-        Legend S220
-        Legend S230
-        IBM ServeRAID 8i
-        ICP 9014R0
-        ICP 9024R0
-        ICP 9047MA
-        ICP 9087MA
-        ICP 9085LI
-        ICP 5085AU
-
-People
--------------------------
-Alan Cox <alan@redhat.com>
-Christoph Hellwig <hch@infradead.org>   (updates for new-style PCI probing and SCSI host registration,
-                                         small cleanups/fixes)
-Matt Domsch <matt_domsch@dell.com>      (revision ioctl, adapter messages)
-Deanna Bonds                            (non-DASD support, PAE fibs and 64 bit, added new adaptec controllers
-                                         added new ioctls, changed scsi interface to use new error handler,
-                                         increased the number of fibs and outstanding commands to a container)
-
-                                        (fixed 64bit and 64G memory model, changed confusing naming convention
-                                         where fibs that go to the hardware are consistently called hw_fibs and
-                                         not just fibs like the name of the driver tracking structure)
-Mark Salyzyn <Mark_Salyzyn@adaptec.com> Fixed panic issues and added some new product ids for upcoming hbas. Performance tuning, card failover and bug mitigations.
-
-Original Driver
--------------------------
-Adaptec Unix OEM Product Group
-
-Mailing List
--------------------------
-linux-scsi@vger.kernel.org (Interested parties troll here)
-Also note this is very different to Brian's original driver
-so don't expect him to support it.
-Adaptec does support this driver.  Contact either tech support or Mark Salyzyn.
-
-Original by Brian Boerner February 2001
-Rewritten by Alan Cox, November 2001
diff --git a/drivers/scsi/aacraid/aacraid.h b/drivers/scsi/aacraid/aacraid.h
index 30fd8d6e3f31..66dbb6d2c506 100644
--- a/drivers/scsi/aacraid/aacraid.h
+++ b/drivers/scsi/aacraid/aacraid.h
@@ -532,6 +532,13 @@ struct aac_driver_ident
 #define AAC_QUIRK_MASTER 0x0008
 
 /*
+ * Some adapter firmware perform poorly when it must split up scatter gathers
+ * in order to deal with the limits of the underlying CHIM. This limit in this
+ * class of adapters is 17 scatter gather elements.
+ */
+#define AAC_QUIRK_17SG  0x0010
+
+/*
  *      The adapter interface specs all queues to be located in the same
  *      physically contigous block. The host structure that defines the
  *      commuication queues will assume they are each a separate physically
diff --git a/drivers/scsi/aacraid/commctrl.c b/drivers/scsi/aacraid/commctrl.c
index ef623bd965f5..4fe79cd7c957 100644
--- a/drivers/scsi/aacraid/commctrl.c
+++ b/drivers/scsi/aacraid/commctrl.c
@@ -85,6 +85,10 @@ static int ioctl_send_fib(struct aac_dev * dev, void __user *arg)
         if (size < le16_to_cpu(kfib->header.SenderSize))
                 size = le16_to_cpu(kfib->header.SenderSize);
         if (size > dev->max_fib_size) {
+                if (size > 2048) {
+                        retval = -EINVAL;
+                        goto cleanup;
+                }
                 /* Highjack the hw_fib */
                 hw_fib = fibptr->hw_fib;
                 hw_fib_pa = fibptr->hw_fib_pa;
diff --git a/drivers/scsi/aacraid/linit.c b/drivers/scsi/aacraid/linit.c
index 9b9062f02462..0bf5f9a943e8 100644
--- a/drivers/scsi/aacraid/linit.c
+++ b/drivers/scsi/aacraid/linit.c
@@ -200,10 +200,10 @@ static struct aac_driver_ident aac_drivers[] = {
         { aac_rkt_init, "aacraid",  "ADAPTEC ", "Callisto        ", 2, AAC_QUIRK_MASTER }, /* Jupiter Platform */
         { aac_rx_init, "aacraid",  "ADAPTEC ", "ASR-2020SA       ", 1 }, /* ASR-2020SA SATA PCI-X ZCR (Skyhawk) */
         { aac_rx_init, "aacraid",  "ADAPTEC ", "ASR-2025SA       ", 1 }, /* ASR-2025SA SATA SO-DIMM PCI-X ZCR (Terminator) */
-        { aac_rx_init, "aacraid",  "ADAPTEC ", "AAR-2410SA SATA ", 1 }, /* AAR-2410SA PCI SATA 4ch (Jaguar II) */
-        { aac_rx_init, "aacraid",  "DELL    ", "CERC SR2        ", 1 }, /* CERC SATA RAID 2 PCI SATA 6ch (DellCorsair) */
-        { aac_rx_init, "aacraid",  "ADAPTEC ", "AAR-2810SA SATA ", 1 }, /* AAR-2810SA PCI SATA 8ch (Corsair-8) */
-        { aac_rx_init, "aacraid",  "ADAPTEC ", "AAR-21610SA SATA", 1 }, /* AAR-21610SA PCI SATA 16ch (Corsair-16) */
+        { aac_rx_init, "aacraid",  "ADAPTEC ", "AAR-2410SA SATA ", 1, AAC_QUIRK_17SG }, /* AAR-2410SA PCI SATA 4ch (Jaguar II) */
+        { aac_rx_init, "aacraid",  "DELL    ", "CERC SR2        ", 1, AAC_QUIRK_17SG }, /* CERC SATA RAID 2 PCI SATA 6ch (DellCorsair) */
+        { aac_rx_init, "aacraid",  "ADAPTEC ", "AAR-2810SA SATA ", 1, AAC_QUIRK_17SG }, /* AAR-2810SA PCI SATA 8ch (Corsair-8) */
+        { aac_rx_init, "aacraid",  "ADAPTEC ", "AAR-21610SA SATA", 1, AAC_QUIRK_17SG }, /* AAR-21610SA PCI SATA 16ch (Corsair-16) */
         { aac_rx_init, "aacraid",  "ADAPTEC ", "ASR-2026ZCR     ", 1 }, /* ESD SO-DIMM PCI-X SATA ZCR (Prowler) */
         { aac_rx_init, "aacraid",  "ADAPTEC ", "AAR-2610SA      ", 1 }, /* SATA 6Ch (Bearcat) */
         { aac_rx_init, "aacraid",  "ADAPTEC ", "ASR-2240S       ", 1 }, /* ASR-2240S (SabreExpress) */
@@ -574,7 +574,15 @@ static ssize_t aac_show_model(struct class_device *class_dev,
         struct aac_dev *dev = (struct aac_dev*)class_to_shost(class_dev)->hostdata;
         int len;
 
-        len = snprintf(buf, PAGE_SIZE, "%s\n",
+        if (dev->supplement_adapter_info.AdapterTypeText[0]) {
+                char * cp = dev->supplement_adapter_info.AdapterTypeText;
+                while (*cp && *cp != ' ')
+                        ++cp;
+                while (*cp == ' ')
+                        ++cp;
+                len = snprintf(buf, PAGE_SIZE, "%s\n", cp);
+        } else
+                len = snprintf(buf, PAGE_SIZE, "%s\n",
                   aac_drivers[dev->cardtype].model);
         return len;
 }
@@ -585,7 +593,15 @@ static ssize_t aac_show_vendor(struct class_device *class_dev,
         struct aac_dev *dev = (struct aac_dev*)class_to_shost(class_dev)->hostdata;
         int len;
 
-        len = snprintf(buf, PAGE_SIZE, "%s\n",
+        if (dev->supplement_adapter_info.AdapterTypeText[0]) {
+                char * cp = dev->supplement_adapter_info.AdapterTypeText;
+                while (*cp && *cp != ' ')
+                        ++cp;
+                len = snprintf(buf, PAGE_SIZE, "%.*s\n",
+                  (int)(cp - (char *)dev->supplement_adapter_info.AdapterTypeText),
+                  dev->supplement_adapter_info.AdapterTypeText);
+        } else
+                len = snprintf(buf, PAGE_SIZE, "%s\n",
                   aac_drivers[dev->cardtype].vname);
         return len;
 }
@@ -837,6 +853,13 @@ static int __devinit aac_probe_one(struct pci_dev *pdev,
                   = (aac->scsi_host_ptr->sg_tablesize * 8) + 112;
         }
 
+        if ((aac_drivers[index].quirks & AAC_QUIRK_17SG) &&
+                        (aac->scsi_host_ptr->sg_tablesize > 17)) {
+                aac->scsi_host_ptr->sg_tablesize = 17;
+                aac->scsi_host_ptr->max_sectors
+                  = (aac->scsi_host_ptr->sg_tablesize * 8) + 112;
+        }
+
         /*
          * Firware printf works only with older firmware.
          */
diff --git a/drivers/scsi/aic7xxx/Kconfig.aic7xxx b/drivers/scsi/aic7xxx/Kconfig.aic7xxx
index ac8de03c9fa2..6c2c395554ff 100644
--- a/drivers/scsi/aic7xxx/Kconfig.aic7xxx
+++ b/drivers/scsi/aic7xxx/Kconfig.aic7xxx
@@ -42,13 +42,13 @@ config AIC7XXX_CMDS_PER_DEVICE
 config AIC7XXX_RESET_DELAY_MS
         int "Initial bus reset delay in milli-seconds"
         depends on SCSI_AIC7XXX
-        default "15000"
+        default "5000"
         ---help---
         The number of milliseconds to delay after an initial bus reset.
         The bus settle delay following all error recovery actions is
         dictated by the SCSI layer and is not affected by this value.
 
-        Default: 15000 (15 seconds)
+        Default: 5000 (5 seconds)
 
 config AIC7XXX_PROBE_EISA_VL
         bool "Probe for EISA and VL AIC7XXX Adapters"
diff --git a/drivers/scsi/aic7xxx/aic79xx.h b/drivers/scsi/aic7xxx/aic79xx.h
index 653fb0b42aea..2cfdbef447db 100644
--- a/drivers/scsi/aic7xxx/aic79xx.h
+++ b/drivers/scsi/aic7xxx/aic79xx.h
@@ -37,7 +37,7 @@
  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGES.
  *
- * $Id: //depot/aic7xxx/aic7xxx/aic79xx.h#95 $
+ * $Id: //depot/aic7xxx/aic7xxx/aic79xx.h#108 $
  *
  * $FreeBSD$
  */
@@ -75,8 +75,7 @@ struct scb_platform_data;
 #define INITIATOR_WILDCARD      (~0)
 #define SCB_LIST_NULL           0xFF00
 #define SCB_LIST_NULL_LE        (ahd_htole16(SCB_LIST_NULL))
-#define QOUTFIFO_ENTRY_VALID 0x8000
-#define QOUTFIFO_ENTRY_VALID_LE (ahd_htole16(0x8000))
+#define QOUTFIFO_ENTRY_VALID 0x80
 #define SCBID_IS_NULL(scbid) (((scbid) & 0xFF00 ) == SCB_LIST_NULL)
 
 #define SCSIID_TARGET(ahd, scsiid)      \
@@ -1053,6 +1052,13 @@ typedef uint8_t ahd_mode_state;
 
 typedef void ahd_callback_t (void *);
 
+struct ahd_completion
+{
+        uint16_t        tag;
+        uint8_t         sg_status;
+        uint8_t         valid_tag;
+};
+
 struct ahd_softc {
         bus_space_tag_t           tags[2];
         bus_space_handle_t        bshs[2];
@@ -1062,6 +1068,7 @@ struct ahd_softc {
         struct scb_data           scb_data;
 
         struct hardware_scb      *next_queued_hscb;
+        struct map_node          *next_queued_hscb_map;
 
         /*
          * SCBs that have been sent to the controller
@@ -1140,16 +1147,23 @@ struct ahd_softc {
         ahd_flag                  flags;
         struct seeprom_config    *seep_config;
 
-        /* Values to store in the SEQCTL register for pause and unpause */
-        uint8_t                   unpause;
-        uint8_t                   pause;
-
         /* Command Queues */
+        struct ahd_completion     *qoutfifo;
         uint16_t                  qoutfifonext;
         uint16_t                  qoutfifonext_valid_tag;
         uint16_t                  qinfifonext;
         uint16_t                  qinfifo[AHD_SCB_MAX];
-        uint16_t                 *qoutfifo;
+
+        /*
+         * Our qfreeze count.  The sequencer compares
+         * this value with its own counter to determine
+         * whether to allow selections to occur.
+         */
+        uint16_t                  qfreeze_cnt;
+
+        /* Values to store in the SEQCTL register for pause and unpause */
+        uint8_t                   unpause;
+        uint8_t                   pause;
 
         /* Critical Section Data */
         struct cs                *critical_sections;
@@ -1197,8 +1211,7 @@ struct ahd_softc {
          */
         bus_dma_tag_t             parent_dmat;
         bus_dma_tag_t             shared_data_dmat;
-        bus_dmamap_t              shared_data_dmamap;
-        dma_addr_t                shared_data_busaddr;
+        struct map_node           shared_data_map;
 
         /* Information saved through suspend/resume cycles */
         struct ahd_suspend_state  suspend_state;
@@ -1296,9 +1309,9 @@ struct ahd_devinfo {
 };
 
 /****************************** PCI Structures ********************************/
-#define AHD_PCI_IOADDR0 PCIR_MAPS       /* I/O BAR*/
-#define AHD_PCI_MEMADDR (PCIR_MAPS + 4) /* Memory BAR */
-#define AHD_PCI_IOADDR1 (PCIR_MAPS + 12)/* Second I/O BAR */
+#define AHD_PCI_IOADDR0 PCIR_BAR(0)     /* I/O BAR*/
+#define AHD_PCI_MEMADDR PCIR_BAR(1)     /* Memory BAR */
+#define AHD_PCI_IOADDR1 PCIR_BAR(3)     /* Second I/O BAR */
 
 typedef int (ahd_device_setup_t)(struct ahd_softc *);
 
diff --git a/drivers/scsi/aic7xxx/aic79xx.reg b/drivers/scsi/aic7xxx/aic79xx.reg
index cca58edc8648..3a3204703b15 100644
--- a/drivers/scsi/aic7xxx/aic79xx.reg
+++ b/drivers/scsi/aic7xxx/aic79xx.reg
@@ -39,7 +39,7 @@
  *
  * $FreeBSD$
  */
-VERSION = "$Id: //depot/aic7xxx/aic7xxx/aic79xx.reg#70 $"
+VERSION = "$Id: //depot/aic7xxx/aic7xxx/aic79xx.reg#76 $"
 
 /*
  * This file is processed by the aic7xxx_asm utility for use in assembling
@@ -65,13 +65,6 @@ VERSION = "$Id: //depot/aic7xxx/aic7xxx/aic79xx.reg#70 $"
                 mvi     MODE_PTR, MK_MODE(src, dst);                    \
         }
 
-#define TOGGLE_DFF_MODE                                                 \
-        if ((ahd->bugs & AHD_SET_MODE_BUG) != 0) {                      \
-                call    toggle_dff_mode_work_around;                    \
-        } else {                                                        \
-                xor     MODE_PTR, MK_MODE(M_DFF1, M_DFF1);              \
-        }
-        
 #define RESTORE_MODE(mode)                                              \
         if ((ahd->bugs & AHD_SET_MODE_BUG) != 0) {                      \
                 mov     mode call set_mode_work_around;                 \
@@ -1199,7 +1192,7 @@ register TARGPCISTAT {
 
 /*
  * LQ Packet In
- * The last LQ Packet received
+ * The last LQ Packet recieved
  */
 register LQIN {
         address                 0x020
@@ -3542,10 +3535,34 @@ scratch_ram {
         COMPLETE_DMA_SCB_HEAD {
                 size            2
         }
-        /* Counting semaphore to prevent new select-outs */
+        /*
+         * tail of list of SCBs that have
+         * completed but need to be uploaded
+         * to the host prior to being completed.
+         */
+        COMPLETE_DMA_SCB_TAIL {
+                size            2
+        }
+        /*
+         * head of list of SCBs that have
+         * been uploaded to the host, but cannot
+         * be completed until the QFREEZE is in
+         * full effect (i.e. no selections pending).
+         */
+        COMPLETE_ON_QFREEZE_HEAD {
+                size            2
+        }
+        /*
+         * Counting semaphore to prevent new select-outs
+         * The queue is frozen so long as the sequencer
+         * and kernel freeze counts differ.
+         */
         QFREEZE_COUNT {
                 size            2
         }
+        KERNEL_QFREEZE_COUNT {
+                size            2
+        }
         /*
          * Mode to restore on legacy idle loop exit.
          */
@@ -3625,6 +3642,17 @@ scratch_ram {
                 size            1
         }
         /*
+         * Kernel and sequencer offsets into the queue of
+         * incoming target mode command descriptors.  The
+         * queue is full when the KERNEL_TQINPOS == TQINPOS.
+         */
+        KERNEL_TQINPOS {
+                size            1
+        }
+        TQINPOS {                
+                size            1
+        }
+        /*
          * Base address of our shared data with the kernel driver in host
          * memory.  This includes the qoutfifo and target mode
          * incoming command queue.
@@ -3639,17 +3667,6 @@ scratch_ram {
         QOUTFIFO_NEXT_ADDR {
                 size            4
         }
-        /*
-         * Kernel and sequencer offsets into the queue of
-         * incoming target mode command descriptors.  The
-         * queue is full when the KERNEL_TQINPOS == TQINPOS.
-         */
-        KERNEL_TQINPOS {
-                size            1
-        }
-        TQINPOS {                
-                size            1
-        }
         ARG_1 {
                 size            1
                 mask    SEND_MSG                0x80
@@ -3951,6 +3968,7 @@ const SG_PREFETCH_ADDR_MASK download
 const SG_SIZEOF download
 const PKT_OVERRUN_BUFOFFSET download
 const SCB_TRANSFER_SIZE download
+const CACHELINE_MASK download
 
 /*
  * BIOS SCB offsets
diff --git a/drivers/scsi/aic7xxx/aic79xx.seq b/drivers/scsi/aic7xxx/aic79xx.seq
index 65339bc1ca99..bef1f9d369b6 100644
--- a/drivers/scsi/aic7xxx/aic79xx.seq
+++ b/drivers/scsi/aic7xxx/aic79xx.seq
@@ -40,7 +40,7 @@
  * $FreeBSD$
  */
 
-VERSION = "$Id: //depot/aic7xxx/aic7xxx/aic79xx.seq#99 $"
+VERSION = "$Id: //depot/aic7xxx/aic7xxx/aic79xx.seq#119 $"
 PATCH_ARG_LIST = "struct ahd_softc *ahd"
 PREFIX = "ahd_"
 
@@ -68,13 +68,47 @@ no_error_set:
         }
         SET_MODE(M_SCSI, M_SCSI)
         test    SCSISEQ0, ENSELO|ENARBO jnz idle_loop_checkbus;
-        test    SEQ_FLAGS2, SELECTOUT_QFROZEN jnz idle_loop_checkbus;
+        test    SEQ_FLAGS2, SELECTOUT_QFROZEN jz check_waiting_list;
+        /*
+         * If the kernel has caught up with us, thaw the queue.
+         */
+        mov     A, KERNEL_QFREEZE_COUNT;
+        cmp     QFREEZE_COUNT, A jne check_frozen_completions;
+        mov     A, KERNEL_QFREEZE_COUNT[1];
+        cmp     QFREEZE_COUNT[1], A jne check_frozen_completions;
+        and     SEQ_FLAGS2, ~SELECTOUT_QFROZEN;
+        jmp     check_waiting_list;
+check_frozen_completions:
+        test    SSTAT0, SELDO|SELINGO jnz idle_loop_checkbus;
+BEGIN_CRITICAL;
+        /*
+         * If we have completions stalled waiting for the qfreeze
+         * to take effect, move them over to the complete_scb list
+         * now that no selections are pending.
+         */
+        cmp     COMPLETE_ON_QFREEZE_HEAD[1],SCB_LIST_NULL je idle_loop_checkbus;
+        /*
+         * Find the end of the qfreeze list.  The first element has
+         * to be treated specially.
+         */
+        bmov    SCBPTR, COMPLETE_ON_QFREEZE_HEAD, 2;
+        cmp     SCB_NEXT_COMPLETE[1], SCB_LIST_NULL je join_lists;
+        /*
+         * Now the normal loop.
+         */
+        bmov    SCBPTR, SCB_NEXT_COMPLETE, 2;
+        cmp     SCB_NEXT_COMPLETE[1], SCB_LIST_NULL jne . - 1;
+join_lists:
+        bmov    SCB_NEXT_COMPLETE, COMPLETE_SCB_HEAD, 2;
+        bmov    COMPLETE_SCB_HEAD, COMPLETE_ON_QFREEZE_HEAD, 2;
+        mvi     COMPLETE_ON_QFREEZE_HEAD[1], SCB_LIST_NULL;
+        jmp     idle_loop_checkbus;
+check_waiting_list:
         cmp     WAITING_TID_HEAD[1], SCB_LIST_NULL je idle_loop_checkbus;
         /*
          * ENSELO is cleared by a SELDO, so we must test for SELDO
          * one last time.
          */
-BEGIN_CRITICAL;
         test    SSTAT0, SELDO jnz select_out;
 END_CRITICAL;
         call    start_selection;
@@ -90,6 +124,13 @@ idle_loop_check_nonpackreq:
         test    SSTAT2, NONPACKREQ jz . + 2;
         call    unexpected_nonpkt_phase_find_ctxt;
         if ((ahd->bugs & AHD_FAINT_LED_BUG) != 0) {
+                /*
+                 * On Rev A. hardware, the busy LED is only
+                 * turned on automaically during selections
+                 * and re-selections.  Make the LED status
+                 * more useful by forcing it to be on so
+                 * long as one of our data FIFOs is active.
+                 */
                 and     A, FIFO0FREE|FIFO1FREE, DFFSTAT;
                 cmp     A, FIFO0FREE|FIFO1FREE jne . + 3;
                 and     SBLKCTL, ~DIAGLEDEN|DIAGLEDON;
@@ -101,9 +142,9 @@ idle_loop_check_nonpackreq:
         call    idle_loop_cchan;
         jmp     idle_loop;
 
-BEGIN_CRITICAL;
 idle_loop_gsfifo:
         SET_MODE(M_SCSI, M_SCSI)
+BEGIN_CRITICAL;
 idle_loop_gsfifo_in_scsi_mode:
         test    LQISTAT2, LQIGSAVAIL jz return;
         /*
@@ -152,11 +193,15 @@ END_CRITICAL;
 
 idle_loop_service_fifos:
         SET_MODE(M_DFF0, M_DFF0)
+BEGIN_CRITICAL;
         test    LONGJMP_ADDR[1], INVALID_ADDR jnz idle_loop_next_fifo;
         call    longjmp;
+END_CRITICAL;
 idle_loop_next_fifo:
         SET_MODE(M_DFF1, M_DFF1)
+BEGIN_CRITICAL;
         test    LONGJMP_ADDR[1], INVALID_ADDR jz longjmp;
+END_CRITICAL;
 return:
         ret;
 
@@ -170,7 +215,6 @@ BEGIN_CRITICAL;
         test    CCSCBCTL, CCARREN|CCSCBEN jz scbdma_idle;
         test    CCSCBCTL, CCSCBDIR jnz fetch_new_scb_inprog;
         test    CCSCBCTL, CCSCBDONE jz return;
-END_CRITICAL;
         /* FALLTHROUGH */
 scbdma_tohost_done:
         test    CCSCBCTL, CCARREN jz fill_qoutfifo_dmadone;
@@ -180,26 +224,18 @@ scbdma_tohost_done:
          * bad SCSI status (currently only for underruns), we
          * queue the SCB for normal completion.  Otherwise, we
          * wait until any select-out activity has halted, and
-         * then notify the host so that the transaction can be
-         * dealt with.
+         * then queue the completion.
          */
-        test    SCB_SCSI_STATUS, 0xff jnz scbdma_notify_host;
         and     CCSCBCTL, ~(CCARREN|CCSCBEN);
         bmov    COMPLETE_DMA_SCB_HEAD, SCB_NEXT_COMPLETE, 2;
+        cmp     SCB_NEXT_COMPLETE[1], SCB_LIST_NULL jne . + 2;
+        mvi     COMPLETE_DMA_SCB_TAIL[1], SCB_LIST_NULL;
+        test    SCB_SCSI_STATUS, 0xff jz scbdma_queue_completion;
+        bmov    SCB_NEXT_COMPLETE, COMPLETE_ON_QFREEZE_HEAD, 2;
+        bmov    COMPLETE_ON_QFREEZE_HEAD, SCBPTR, 2 ret;
+scbdma_queue_completion:
         bmov    SCB_NEXT_COMPLETE, COMPLETE_SCB_HEAD, 2;
         bmov    COMPLETE_SCB_HEAD, SCBPTR, 2 ret;
-scbdma_notify_host:
-        SET_MODE(M_SCSI, M_SCSI)
-        test    SCSISEQ0, ENSELO jnz return;
-        test    SSTAT0, (SELDO|SELINGO) jnz return;
-        SET_MODE(M_CCHAN, M_CCHAN)
-        /*
-         * Remove SCB and notify host.
-         */
-        and     CCSCBCTL, ~(CCARREN|CCSCBEN);
-        bmov    COMPLETE_DMA_SCB_HEAD, SCB_NEXT_COMPLETE, 2;
-        SET_SEQINTCODE(BAD_SCB_STATUS)
-        ret;
 fill_qoutfifo_dmadone:
         and     CCSCBCTL, ~(CCARREN|CCSCBEN);
         call    qoutfifo_updated;
@@ -208,6 +244,7 @@ fill_qoutfifo_dmadone:
         test    QOFF_CTLSTA, SDSCB_ROLLOVR jz return;
         bmov    QOUTFIFO_NEXT_ADDR, SHARED_DATA_ADDR, 4;
         xor     QOUTFIFO_ENTRY_VALID_TAG, QOUTFIFO_ENTRY_VALID_TOGGLE ret;
+END_CRITICAL;
 
 qoutfifo_updated:
         /*
@@ -324,14 +361,15 @@ fill_qoutfifo:
          * Keep track of the SCBs we are dmaing just
          * in case the DMA fails or is aborted.
          */
-        mov     A, QOUTFIFO_ENTRY_VALID_TAG;
         bmov    COMPLETE_SCB_DMAINPROG_HEAD, COMPLETE_SCB_HEAD, 2;
         mvi     CCSCBCTL, CCSCBRESET;
         bmov    SCBHADDR, QOUTFIFO_NEXT_ADDR, 4;
+        mov     A, QOUTFIFO_NEXT_ADDR;
         bmov    SCBPTR, COMPLETE_SCB_HEAD, 2;
 fill_qoutfifo_loop:
-        mov     CCSCBRAM, SCBPTR;
-        or      CCSCBRAM, A, SCBPTR[1];
+        bmov    CCSCBRAM, SCBPTR, 2;
+        mov     CCSCBRAM, SCB_SGPTR[0];
+        mov     CCSCBRAM, QOUTFIFO_ENTRY_VALID_TAG;
         mov     NONE, SDSCB_QOFF;
         inc     INT_COALESCING_CMDCOUNT;
         add     CMDS_PENDING, -1;
@@ -339,6 +377,18 @@ fill_qoutfifo_loop:
         cmp     SCB_NEXT_COMPLETE[1], SCB_LIST_NULL je fill_qoutfifo_done;
         cmp     CCSCBADDR, CCSCBADDR_MAX je fill_qoutfifo_done;
         test    QOFF_CTLSTA, SDSCB_ROLLOVR jnz fill_qoutfifo_done;
+        /*
+         * Don't cross an ADB or Cachline boundary when DMA'ing
+         * completion entries.  In PCI mode, at least in 32/33
+         * configurations, the SCB DMA engine may lose its place
+         * in the data-stream should the target force a retry on
+         * something other than an 8byte aligned boundary. In
+         * PCI-X mode, we do this to avoid split transactions since
+         * many chipsets seem to be unable to format proper split
+         * completions to continue the data transfer.
+         */
+        add     SINDEX, A, CCSCBADDR;
+        test    SINDEX, CACHELINE_MASK jz fill_qoutfifo_done;
         bmov    SCBPTR, SCB_NEXT_COMPLETE, 2;
         jmp     fill_qoutfifo_loop;
 fill_qoutfifo_done:
@@ -354,7 +404,6 @@ dma_complete_scb:
         bmov    SCBPTR, COMPLETE_DMA_SCB_HEAD, 2;
         bmov    SCBHADDR, SCB_BUSADDR, 4;
         mvi     CCARREN|CCSCBEN|CCSCBRESET jmp dma_scb;
-END_CRITICAL;
 
 /*
  * Either post or fetch an SCB from host memory.  The caller
@@ -371,9 +420,19 @@ dma_scb:
         mvi     SCBHCNT, SCB_TRANSFER_SIZE;
         mov     CCSCBCTL, SINDEX ret;
 
-BEGIN_CRITICAL;
 setjmp:
-        bmov    LONGJMP_ADDR, STACK, 2 ret;
+        /*
+         * At least on the A, a return in the same
+         * instruction as the bmov results in a return
+         * to the caller, not to the new address at the
+         * top of the stack.  Since we want the latter
+         * (we use setjmp to register a handler from an
+         * interrupt context but not invoke that handler
+         * until we return to our idle loop), use a
+         * separate ret instruction.
+         */
+        bmov    LONGJMP_ADDR, STACK, 2;
+        ret;
 setjmp_inline:
         bmov    LONGJMP_ADDR, STACK, 2;
 longjmp:
@@ -392,11 +451,6 @@ set_mode_work_around:
         mvi     SEQINTCTL, INTVEC1DSL;
         mov     MODE_PTR, SINDEX;
         clr     SEQINTCTL ret;
-
-toggle_dff_mode_work_around:
-        mvi     SEQINTCTL, INTVEC1DSL;
-        xor     MODE_PTR, MK_MODE(M_DFF1, M_DFF1);
-        clr     SEQINTCTL ret;
 }
 
 
@@ -490,6 +544,21 @@ allocate_fifo1:
 SET_SRC_MODE    M_SCSI;
 SET_DST_MODE    M_SCSI;
 select_in:
+        if ((ahd->bugs & AHD_FAINT_LED_BUG) != 0) {
+                /*
+                 * On Rev A. hardware, the busy LED is only
+                 * turned on automaically during selections
+                 * and re-selections.  Make the LED status
+                 * more useful by forcing it to be on from
+                 * the point of selection until our idle
+                 * loop determines that neither of our FIFOs
+                 * are busy.  This handles the non-packetized
+                 * case nicely as we will not return to the
+                 * idle loop until the busfree at the end of
+                 * each transaction.
+                 */
+                or      SBLKCTL, DIAGLEDEN|DIAGLEDON;
+        }
         if ((ahd->bugs & AHD_BUSFREEREV_BUG) != 0) {
                 /*
                  * Test to ensure that the bus has not
@@ -528,6 +597,21 @@ SET_SRC_MODE	M_SCSI;
 SET_DST_MODE    M_SCSI;
 select_out:
 BEGIN_CRITICAL;
+        if ((ahd->bugs & AHD_FAINT_LED_BUG) != 0) {
+                /*
+                 * On Rev A. hardware, the busy LED is only
+                 * turned on automaically during selections
+                 * and re-selections.  Make the LED status
+                 * more useful by forcing it to be on from
+                 * the point of re-selection until our idle
+                 * loop determines that neither of our FIFOs
+                 * are busy.  This handles the non-packetized
+                 * case nicely as we will not return to the
+                 * idle loop until the busfree at the end of
+                 * each transaction.
+                 */
+                or      SBLKCTL, DIAGLEDEN|DIAGLEDON;
+        }
         /* Clear out all SCBs that have been successfully sent. */
         if ((ahd->bugs & AHD_SENT_SCB_UPDATE_BUG) != 0) {
                 /*
@@ -1000,15 +1084,9 @@ not_found_ITloop:
 /*
  * We received a "command complete" message.  Put the SCB on the complete
  * queue and trigger a completion interrupt via the idle loop.  Before doing
- * so, check to see if there
- * is a residual or the status byte is something other than STATUS_GOOD (0).
- * In either of these conditions, we upload the SCB back to the host so it can
- * process this information.  In the case of a non zero status byte, we 
- * additionally interrupt the kernel driver synchronously, allowing it to
- * decide if sense should be retrieved.  If the kernel driver wishes to request
- * sense, it will fill the kernel SCB with a request sense command, requeue
- * it to the QINFIFO and tell us not to post to the QOUTFIFO by setting 
- * RETURN_1 to SEND_SENSE.
+ * so, check to see if there is a residual or the status byte is something
+ * other than STATUS_GOOD (0).  In either of these conditions, we upload the
+ * SCB back to the host so it can process this information.
  */
 mesgin_complete:
 
@@ -1053,6 +1131,7 @@ complete_nomsg:
         call    queue_scb_completion;
         jmp     await_busfree;
 
+BEGIN_CRITICAL;
 freeze_queue:
         /* Cancel any pending select-out. */
         test    SSTAT0, SELDO|SELINGO jnz . + 2;
@@ -1063,6 +1142,7 @@ freeze_queue:
         adc     QFREEZE_COUNT[1], A;
         or      SEQ_FLAGS2, SELECTOUT_QFROZEN;
         mov     A, ACCUM_SAVE ret;
+END_CRITICAL;
 
 /*
  * Complete the current FIFO's SCB if data for this same
@@ -1085,8 +1165,10 @@ queue_scb_completion:
         test    SCB_SGPTR, SG_FULL_RESID jnz upload_scb;/* Never xfered */
         test    SCB_RESIDUAL_SGPTR, SG_LIST_NULL jz upload_scb;
 complete:
+BEGIN_CRITICAL;
         bmov    SCB_NEXT_COMPLETE, COMPLETE_SCB_HEAD, 2;
         bmov    COMPLETE_SCB_HEAD, SCBPTR, 2 ret;
+END_CRITICAL;
 bad_status:
         cmp     SCB_SCSI_STATUS, STATUS_PKT_SENSE je upload_scb;
         call    freeze_queue;
@@ -1097,9 +1179,18 @@ upload_scb:
          * it on the host.
          */
         bmov    SCB_TAG, SCBPTR, 2;
-        bmov    SCB_NEXT_COMPLETE, COMPLETE_DMA_SCB_HEAD, 2;
+BEGIN_CRITICAL;
+        or      SCB_SGPTR, SG_STATUS_VALID;
+        mvi     SCB_NEXT_COMPLETE[1], SCB_LIST_NULL;
+        cmp     COMPLETE_DMA_SCB_HEAD[1], SCB_LIST_NULL jne add_dma_scb_tail;
         bmov    COMPLETE_DMA_SCB_HEAD, SCBPTR, 2;
-        or      SCB_SGPTR, SG_STATUS_VALID ret;
+        bmov    COMPLETE_DMA_SCB_TAIL, SCBPTR, 2 ret;
+add_dma_scb_tail:
+        bmov    REG0, SCBPTR, 2;
+        bmov    SCBPTR, COMPLETE_DMA_SCB_TAIL, 2;
+        bmov    SCB_NEXT_COMPLETE, REG0, 2;
+        bmov    COMPLETE_DMA_SCB_TAIL, REG0, 2 ret;
+END_CRITICAL;
 
 /*
  * Is it a disconnect message?  Set a flag in the SCB to remind us
@@ -1146,8 +1237,18 @@ SET_DST_MODE	M_DFF1;
 await_busfree_clrchn:
         mvi     DFFSXFRCTL, CLRCHN;
 await_busfree_not_m_dff:
-        call    clear_target_state;
+        /* clear target specific flags */
+        mvi     SEQ_FLAGS, NOT_IDENTIFIED|NO_CDB_SENT;
         test    SSTAT1,REQINIT|BUSFREE  jz .;
+        /*
+         * We only set BUSFREE status once either a new
+         * phase has been detected or we are really
+         * BUSFREE.  This allows the driver to know
+         * that we are active on the bus even though
+         * no identified transaction exists should a
+         * timeout occur while awaiting busfree.
+         */
+        mvi     LASTPHASE, P_BUSFREE;
         test    SSTAT1, BUSFREE jnz idle_loop;
         SET_SEQINTCODE(MISSED_BUSFREE)
 
@@ -1202,11 +1303,6 @@ msgin_rdptrs_get_fifo:
         call    allocate_fifo;
         jmp     mesgin_done;
 
-clear_target_state:
-        mvi     LASTPHASE, P_BUSFREE;
-        /* clear target specific flags */
-        mvi     SEQ_FLAGS, NOT_IDENTIFIED|NO_CDB_SENT ret;
-
 phase_lock:     
         if ((ahd->bugs & AHD_EARLY_REQ_BUG) != 0) {
                 /*
@@ -1298,6 +1394,47 @@ service_fifo:
         test    CCSGCTL, CCSGENACK jnz return;
 
         /*
+         * Should the other FIFO get the S/G cache first?  If
+         * both FIFOs have been allocated since we last checked
+         * any FIFO, it is important that we service a FIFO
+         * that is not actively on the bus first.  This guarantees
+         * that a FIFO will be freed to handle snapshot requests for
+         * any FIFO that is still on the bus.  Chips with RTI do not
+         * perform snapshots, so don't bother with this test there.
+         */
+        if ((ahd->features & AHD_RTI) == 0) {
+                /*
+                 * If we're not still receiving SCSI data,
+                 * it is safe to allocate the S/G cache to
+                 * this FIFO.
+                 */
+                test    DFCNTRL, SCSIEN jz idle_sgfetch_start;
+
+                /*
+                 * Switch to the other FIFO.  Non-RTI chips
+                 * also have the "set mode" bug, so we must
+                 * disable interrupts during the switch.
+                 */
+                mvi     SEQINTCTL, INTVEC1DSL;
+                xor     MODE_PTR, MK_MODE(M_DFF1, M_DFF1);
+
+                /*
+                 * If the other FIFO needs loading, then it
+                 * must not have claimed the S/G cache yet
+                 * (SG_CACHE_AVAIL would have been cleared in
+                 * the orginal FIFO mode and we test this above).
+                 * Return to the idle loop so we can process the
+                 * FIFO not currently on the bus first.
+                 */
+                test    SG_STATE, LOADING_NEEDED jz idle_sgfetch_okay;
+                clr     SEQINTCTL ret;
+idle_sgfetch_okay:
+                xor     MODE_PTR, MK_MODE(M_DFF1, M_DFF1);
+                clr     SEQINTCTL;
+        }
+
+idle_sgfetch_start:
+        /*
          * We fetch a "cacheline aligned" and sized amount of data
          * so we don't end up referencing a non-existant page.
          * Cacheline aligned is in quotes because the kernel will
@@ -1308,7 +1445,7 @@ service_fifo:
         mvi     SGHCNT, SG_PREFETCH_CNT;
         if ((ahd->bugs & AHD_REG_SLOW_SETTLE_BUG) != 0) {
                 /*
-                 * Need two instruction between "touches" of SGHADDR.
+                 * Need two instructions between "touches" of SGHADDR.
                  */
                 nop;
         }
@@ -1658,7 +1795,7 @@ export seq_isr:
                  * savepointer in the current FIFO.  We do this so that
                  * a pending CTXTDONE or SAVEPTR is visible in the active
                  * FIFO.  This status is the only way we can detect if we
-                 * have lost the race (e.g. host paused us) and our attepts
+                 * have lost the race (e.g. host paused us) and our attempts
                  * to disable the channel occurred after all REQs were
                  * already seen and acked (REQINIT never comes true).
                  */
@@ -1667,7 +1804,7 @@ export seq_isr:
                 test    DFCNTRL, DIRECTION jz interrupt_return;
                 and     DFCNTRL, ~SCSIEN;
 snapshot_wait_data_valid:
-                test    SEQINTSRC, (CTXTDONE|SAVEPTRS) jnz snapshot_data_valid;
+                test    SEQINTSRC, (CTXTDONE|SAVEPTRS) jnz interrupt_return;
                 test    SSTAT1, REQINIT jz snapshot_wait_data_valid;
 snapshot_data_valid:
                 or      DFCNTRL, SCSIEN;
@@ -1834,7 +1971,6 @@ pkt_saveptrs_check_status:
         dec     SCB_FIFO_USE_COUNT;
         test    SCB_CONTROL, STATUS_RCVD jnz pkt_complete_scb_if_fifos_idle;
         mvi     DFFSXFRCTL, CLRCHN ret;
-END_CRITICAL;
 
 /*
  * LAST_SEG_DONE status has been seen in the current FIFO.
@@ -1843,7 +1979,6 @@ END_CRITICAL;
  * Check for overrun and see if we can complete this command.
  */
 pkt_last_seg_done:
-BEGIN_CRITICAL;
         /*
          * Mark transfer as completed.
          */
diff --git a/drivers/scsi/aic7xxx/aic79xx_core.c b/drivers/scsi/aic7xxx/aic79xx_core.c
index 4e8f00df978d..db8f5ce99ee3 100644
--- a/drivers/scsi/aic7xxx/aic79xx_core.c
+++ b/drivers/scsi/aic7xxx/aic79xx_core.c
@@ -37,9 +37,7 @@
  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGES.
  *
- * $Id: //depot/aic7xxx/aic7xxx/aic79xx.c#202 $
- *
- * $FreeBSD$
+ * $Id: //depot/aic7xxx/aic7xxx/aic79xx.c#247 $
  */
 
 #ifdef __linux__
@@ -332,6 +330,14 @@ ahd_restart(struct ahd_softc *ahd)
         ahd_outb(ahd, SCSISEQ1,
                  ahd_inb(ahd, SCSISEQ_TEMPLATE) & (ENSELI|ENRSELI|ENAUTOATNP));
         ahd_set_modes(ahd, AHD_MODE_CCHAN, AHD_MODE_CCHAN);
+
+        /*
+         * Clear any pending sequencer interrupt.  It is no
+         * longer relevant since we're resetting the Program
+         * Counter.
+         */
+        ahd_outb(ahd, CLRINT, CLRSEQINT);
+
         ahd_outb(ahd, SEQCTL0, FASTMODE|SEQRESET);
         ahd_unpause(ahd);
 }
@@ -373,13 +379,7 @@ ahd_flush_qoutfifo(struct ahd_softc *ahd)
         saved_modes = ahd_save_modes(ahd);
 
         /*
-         * Complete any SCBs that just finished being
-         * DMA'ed into the qoutfifo.
-         */
-        ahd_run_qoutfifo(ahd);
-
-        /*
-         * Flush the good status FIFO for compelted packetized commands.
+         * Flush the good status FIFO for completed packetized commands.
          */
         ahd_set_modes(ahd, AHD_MODE_SCSI, AHD_MODE_SCSI);
         saved_scbptr = ahd_get_scbptr(ahd);
@@ -387,8 +387,7 @@ ahd_flush_qoutfifo(struct ahd_softc *ahd)
                 u_int fifo_mode;
                 u_int i;
                 
-                scbid = (ahd_inb(ahd, GSFIFO+1) << 8)
-                      | ahd_inb(ahd, GSFIFO);
+                scbid = ahd_inw(ahd, GSFIFO);
                 scb = ahd_lookup_scb(ahd, scbid);
                 if (scb == NULL) {
                         printf("%s: Warning - GSFIFO SCB %d invalid\n",
@@ -401,22 +400,33 @@ ahd_flush_qoutfifo(struct ahd_softc *ahd)
                  * the host before completing the  command.
                  */
                 fifo_mode = 0;
+rescan_fifos:
                 for (i = 0; i < 2; i++) {
                         /* Toggle to the other mode. */
                         fifo_mode ^= 1;
                         ahd_set_modes(ahd, fifo_mode, fifo_mode);
+
                         if (ahd_scb_active_in_fifo(ahd, scb) == 0)
                                 continue;
 
                         ahd_run_data_fifo(ahd, scb);
 
                         /*
-                         * Clearing this transaction in this FIFO may
-                         * cause a CFG4DATA for this same transaction
-                         * to assert in the other FIFO.  Make sure we
-                         * loop one more time and check the other FIFO.
+                         * Running this FIFO may cause a CFG4DATA for
+                         * this same transaction to assert in the other
+                         * FIFO or a new snapshot SAVEPTRS interrupt
+                         * in this FIFO.  Even running a FIFO may not
+                         * clear the transaction if we are still waiting
+                         * for data to drain to the host. We must loop
+                         * until the transaction is not active in either
+                         * FIFO just to be sure.  Reset our loop counter
+                         * so we will visit both FIFOs again before
+                         * declaring this transaction finished.  We
+                         * also delay a bit so that status has a chance
+                         * to change before we look at this FIFO again.
                          */
-                        i = 0;
+                        ahd_delay(200);
+                        goto rescan_fifos;
                 }
                 ahd_set_modes(ahd, AHD_MODE_SCSI, AHD_MODE_SCSI);
                 ahd_set_scbptr(ahd, scbid);
@@ -429,19 +439,28 @@ ahd_flush_qoutfifo(struct ahd_softc *ahd)
                         /*
                          * The transfer completed with a residual.
                          * Place this SCB on the complete DMA list
-                         * so that we Update our in-core copy of the
+                         * so that we update our in-core copy of the
                          * SCB before completing the command.
                          */
                         ahd_outb(ahd, SCB_SCSI_STATUS, 0);
                         ahd_outb(ahd, SCB_SGPTR,
                                  ahd_inb_scbram(ahd, SCB_SGPTR)
                                  | SG_STATUS_VALID);
-                        ahd_outw(ahd, SCB_TAG, SCB_GET_TAG(scb));
+                        ahd_outw(ahd, SCB_TAG, scbid);
+                        ahd_outw(ahd, SCB_NEXT_COMPLETE, SCB_LIST_NULL);
                         comp_head = ahd_inw(ahd, COMPLETE_DMA_SCB_HEAD);
-                        ahd_outw(ahd, SCB_NEXT_COMPLETE, comp_head);
-                        if (SCBID_IS_NULL(comp_head))
-                                ahd_outw(ahd, COMPLETE_DMA_SCB_HEAD,
-                                         SCB_GET_TAG(scb));
+                        if (SCBID_IS_NULL(comp_head)) {
+                                ahd_outw(ahd, COMPLETE_DMA_SCB_HEAD, scbid);
+                                ahd_outw(ahd, COMPLETE_DMA_SCB_TAIL, scbid);
+                        } else {
+                                u_int tail;
+
+                                tail = ahd_inw(ahd, COMPLETE_DMA_SCB_TAIL);
+                                ahd_set_scbptr(ahd, tail);
+                                ahd_outw(ahd, SCB_NEXT_COMPLETE, scbid);
+                                ahd_outw(ahd, COMPLETE_DMA_SCB_TAIL, scbid);
+                                ahd_set_scbptr(ahd, scbid);
+                        }
                 } else
                         ahd_complete_scb(ahd, scb);
         }
@@ -465,9 +484,22 @@ ahd_flush_qoutfifo(struct ahd_softc *ahd)
                         break;
                 ahd_delay(200);
         }
-        if ((ccscbctl & CCSCBDIR) != 0)
+        /*
+         * We leave the sequencer to cleanup in the case of DMA's to
+         * update the qoutfifo.  In all other cases (DMA's to the
+         * chip or a push of an SCB from the COMPLETE_DMA_SCB list),
+         * we disable the DMA engine so that the sequencer will not
+         * attempt to handle the DMA completion.
+         */
+        if ((ccscbctl & CCSCBDIR) != 0 || (ccscbctl & ARRDONE) != 0)
                 ahd_outb(ahd, CCSCBCTL, ccscbctl & ~(CCARREN|CCSCBEN));
 
+        /*
+         * Complete any SCBs that just finished
+         * being DMA'ed into the qoutfifo.
+         */
+        ahd_run_qoutfifo(ahd);
+
         saved_scbptr = ahd_get_scbptr(ahd);
         /*
          * Manually update/complete any completed SCBs that are waiting to be
@@ -494,6 +526,24 @@ ahd_flush_qoutfifo(struct ahd_softc *ahd)
                 scbid = next_scbid;
         }
         ahd_outw(ahd, COMPLETE_DMA_SCB_HEAD, SCB_LIST_NULL);
+        ahd_outw(ahd, COMPLETE_DMA_SCB_TAIL, SCB_LIST_NULL);
+
+        scbid = ahd_inw(ahd, COMPLETE_ON_QFREEZE_HEAD);
+        while (!SCBID_IS_NULL(scbid)) {
+
+                ahd_set_scbptr(ahd, scbid);
+                next_scbid = ahd_inw_scbram(ahd, SCB_NEXT_COMPLETE);
+                scb = ahd_lookup_scb(ahd, scbid);
+                if (scb == NULL) {
+                        printf("%s: Warning - Complete Qfrz SCB %d invalid\n",
+                               ahd_name(ahd), scbid);
+                        continue;
+                }
+
+                ahd_complete_scb(ahd, scb);
+                scbid = next_scbid;
+        }
+        ahd_outw(ahd, COMPLETE_ON_QFREEZE_HEAD, SCB_LIST_NULL);
 
         scbid = ahd_inw(ahd, COMPLETE_SCB_HEAD);
         while (!SCBID_IS_NULL(scbid)) {
@@ -558,150 +608,146 @@ ahd_run_data_fifo(struct ahd_softc *ahd, struct scb *scb)
 {
         u_int seqintsrc;
 
-        while (1) {
-                seqintsrc = ahd_inb(ahd, SEQINTSRC);
-                if ((seqintsrc & CFG4DATA) != 0) {
-                        uint32_t datacnt;
-                        uint32_t sgptr;
-
-                        /*
-                         * Clear full residual flag.
-                         */
-                        sgptr = ahd_inl_scbram(ahd, SCB_SGPTR) & ~SG_FULL_RESID;
-                        ahd_outb(ahd, SCB_SGPTR, sgptr);
+        seqintsrc = ahd_inb(ahd, SEQINTSRC);
+        if ((seqintsrc & CFG4DATA) != 0) {
+                uint32_t datacnt;
+                uint32_t sgptr;
 
-                        /*
-                         * Load datacnt and address.
-                         */
-                        datacnt = ahd_inl_scbram(ahd, SCB_DATACNT);
-                        if ((datacnt & AHD_DMA_LAST_SEG) != 0) {
-                                sgptr |= LAST_SEG;
-                                ahd_outb(ahd, SG_STATE, 0);
-                        } else
-                                ahd_outb(ahd, SG_STATE, LOADING_NEEDED);
-                        ahd_outq(ahd, HADDR, ahd_inq_scbram(ahd, SCB_DATAPTR));
-                        ahd_outl(ahd, HCNT, datacnt & AHD_SG_LEN_MASK);
-                        ahd_outb(ahd, SG_CACHE_PRE, sgptr);
-                        ahd_outb(ahd, DFCNTRL, PRELOADEN|SCSIEN|HDMAEN);
+                /*
+                 * Clear full residual flag.
+                 */
+                sgptr = ahd_inl_scbram(ahd, SCB_SGPTR) & ~SG_FULL_RESID;
+                ahd_outb(ahd, SCB_SGPTR, sgptr);
 
-                        /*
-                         * Initialize Residual Fields.
-                         */
-                        ahd_outb(ahd, SCB_RESIDUAL_DATACNT+3, datacnt >> 24);
-                        ahd_outl(ahd, SCB_RESIDUAL_SGPTR, sgptr & SG_PTR_MASK);
+                /*
+                 * Load datacnt and address.
+                 */
+                datacnt = ahd_inl_scbram(ahd, SCB_DATACNT);
+                if ((datacnt & AHD_DMA_LAST_SEG) != 0) {
+                        sgptr |= LAST_SEG;
+                        ahd_outb(ahd, SG_STATE, 0);
+                } else
+                        ahd_outb(ahd, SG_STATE, LOADING_NEEDED);
+                ahd_outq(ahd, HADDR, ahd_inq_scbram(ahd, SCB_DATAPTR));
+                ahd_outl(ahd, HCNT, datacnt & AHD_SG_LEN_MASK);
+                ahd_outb(ahd, SG_CACHE_PRE, sgptr);
+                ahd_outb(ahd, DFCNTRL, PRELOADEN|SCSIEN|HDMAEN);
 
-                        /*
-                         * Mark the SCB as having a FIFO in use.
-                         */
-                        ahd_outb(ahd, SCB_FIFO_USE_COUNT,
-                                 ahd_inb_scbram(ahd, SCB_FIFO_USE_COUNT) + 1);
+                /*
+                 * Initialize Residual Fields.
+                 */
+                ahd_outb(ahd, SCB_RESIDUAL_DATACNT+3, datacnt >> 24);
+                ahd_outl(ahd, SCB_RESIDUAL_SGPTR, sgptr & SG_PTR_MASK);
 
-                        /*
-                         * Install a "fake" handler for this FIFO.
-                         */
-                        ahd_outw(ahd, LONGJMP_ADDR, 0);
+                /*
+                 * Mark the SCB as having a FIFO in use.
+                 */
+                ahd_outb(ahd, SCB_FIFO_USE_COUNT,
+                         ahd_inb_scbram(ahd, SCB_FIFO_USE_COUNT) + 1);
 
-                        /*
-                         * Notify the hardware that we have satisfied
-                         * this sequencer interrupt.
-                         */
-                        ahd_outb(ahd, CLRSEQINTSRC, CLRCFG4DATA);
-                } else if ((seqintsrc & SAVEPTRS) != 0) {
-                        uint32_t sgptr;
-                        uint32_t resid;
+                /*
+                 * Install a "fake" handler for this FIFO.
+                 */
+                ahd_outw(ahd, LONGJMP_ADDR, 0);
 
-                        if ((ahd_inb(ahd, LONGJMP_ADDR+1)&INVALID_ADDR) != 0) {
-                                /*
-                                 * Snapshot Save Pointers.  Clear
-                                 * the snapshot and continue.
-                                 */
-                                ahd_outb(ahd, DFFSXFRCTL, CLRCHN);
-                                continue;
-                        }
+                /*
+                 * Notify the hardware that we have satisfied
+                 * this sequencer interrupt.
+                 */
+                ahd_outb(ahd, CLRSEQINTSRC, CLRCFG4DATA);
+        } else if ((seqintsrc & SAVEPTRS) != 0) {
+                uint32_t sgptr;
+                uint32_t resid;
 
+                if ((ahd_inb(ahd, LONGJMP_ADDR+1)&INVALID_ADDR) != 0) {
                         /*
-                         * Disable S/G fetch so the DMA engine
-                         * is available to future users.
+                         * Snapshot Save Pointers.  All that
+                         * is necessary to clear the snapshot
+                         * is a CLRCHN.
                          */
-                        if ((ahd_inb(ahd, SG_STATE) & FETCH_INPROG) != 0)
-                                ahd_outb(ahd, CCSGCTL, 0);
-                        ahd_outb(ahd, SG_STATE, 0);
+                        goto clrchn;
+                }
 
-                        /*
-                         * Flush the data FIFO.  Strickly only
-                         * necessary for Rev A parts.
-                         */
-                        ahd_outb(ahd, DFCNTRL,
-                                 ahd_inb(ahd, DFCNTRL) | FIFOFLUSH);
+                /*
+                 * Disable S/G fetch so the DMA engine
+                 * is available to future users.
+                 */
+                if ((ahd_inb(ahd, SG_STATE) & FETCH_INPROG) != 0)
+                        ahd_outb(ahd, CCSGCTL, 0);
+                ahd_outb(ahd, SG_STATE, 0);
 
-                        /*
-                         * Calculate residual.
-                         */
-                        sgptr = ahd_inl_scbram(ahd, SCB_RESIDUAL_SGPTR);
-                        resid = ahd_inl(ahd, SHCNT);
-                        resid |=
-                            ahd_inb_scbram(ahd, SCB_RESIDUAL_DATACNT+3) << 24;
-                        ahd_outl(ahd, SCB_RESIDUAL_DATACNT, resid);
-                        if ((ahd_inb(ahd, SG_CACHE_SHADOW) & LAST_SEG) == 0) {
-                                /*
-                                 * Must back up to the correct S/G element.
-                                 * Typically this just means resetting our
-                                 * low byte to the offset in the SG_CACHE,
-                                 * but if we wrapped, we have to correct
-                                 * the other bytes of the sgptr too.
-                                 */
-                                if ((ahd_inb(ahd, SG_CACHE_SHADOW) & 0x80) != 0
-                                 && (sgptr & 0x80) == 0)
-                                        sgptr -= 0x100;
-                                sgptr &= ~0xFF;
-                                sgptr |= ahd_inb(ahd, SG_CACHE_SHADOW)
-                                       & SG_ADDR_MASK;
-                                ahd_outl(ahd, SCB_RESIDUAL_SGPTR, sgptr);
-                                ahd_outb(ahd, SCB_RESIDUAL_DATACNT + 3, 0);
-                        } else if ((resid & AHD_SG_LEN_MASK) == 0) {
-                                ahd_outb(ahd, SCB_RESIDUAL_SGPTR,
-                                         sgptr | SG_LIST_NULL);
-                        }
-                        /*
-                         * Save Pointers.
-                         */
-                        ahd_outq(ahd, SCB_DATAPTR, ahd_inq(ahd, SHADDR));
-                        ahd_outl(ahd, SCB_DATACNT, resid);
-                        ahd_outl(ahd, SCB_SGPTR, sgptr);
-                        ahd_outb(ahd, CLRSEQINTSRC, CLRSAVEPTRS);
-                        ahd_outb(ahd, SEQIMODE,
-                                 ahd_inb(ahd, SEQIMODE) | ENSAVEPTRS);
-                        /*
-                         * If the data is to the SCSI bus, we are
-                         * done, otherwise wait for FIFOEMP.
-                         */
-                        if ((ahd_inb(ahd, DFCNTRL) & DIRECTION) != 0)
-                                break;
-                } else if ((ahd_inb(ahd, SG_STATE) & LOADING_NEEDED) != 0) {
-                        uint32_t sgptr;
-                        uint64_t data_addr;
-                        uint32_t data_len;
-                        u_int    dfcntrl;
+                /*
+                 * Flush the data FIFO.  Strickly only
+                 * necessary for Rev A parts.
+                 */
+                ahd_outb(ahd, DFCNTRL, ahd_inb(ahd, DFCNTRL) | FIFOFLUSH);
 
+                /*
+                 * Calculate residual.
+                 */
+                sgptr = ahd_inl_scbram(ahd, SCB_RESIDUAL_SGPTR);
+                resid = ahd_inl(ahd, SHCNT);
+                resid |= ahd_inb_scbram(ahd, SCB_RESIDUAL_DATACNT+3) << 24;
+                ahd_outl(ahd, SCB_RESIDUAL_DATACNT, resid);
+                if ((ahd_inb(ahd, SG_CACHE_SHADOW) & LAST_SEG) == 0) {
                         /*
-                         * Disable S/G fetch so the DMA engine
-                         * is available to future users.
+                         * Must back up to the correct S/G element.
+                         * Typically this just means resetting our
+                         * low byte to the offset in the SG_CACHE,
+                         * but if we wrapped, we have to correct
+                         * the other bytes of the sgptr too.
                          */
-                        if ((ahd_inb(ahd, SG_STATE) & FETCH_INPROG) != 0) {
-                                ahd_outb(ahd, CCSGCTL, 0);
-                                ahd_outb(ahd, SG_STATE, LOADING_NEEDED);
-                        }
+                        if ((ahd_inb(ahd, SG_CACHE_SHADOW) & 0x80) != 0
+                         && (sgptr & 0x80) == 0)
+                                sgptr -= 0x100;
+                        sgptr &= ~0xFF;
+                        sgptr |= ahd_inb(ahd, SG_CACHE_SHADOW)
+                               & SG_ADDR_MASK;
+                        ahd_outl(ahd, SCB_RESIDUAL_SGPTR, sgptr);
+                        ahd_outb(ahd, SCB_RESIDUAL_DATACNT + 3, 0);
+                } else if ((resid & AHD_SG_LEN_MASK) == 0) {
+                        ahd_outb(ahd, SCB_RESIDUAL_SGPTR,
+                                 sgptr | SG_LIST_NULL);
+                }
+                /*
+                 * Save Pointers.
+                 */
+                ahd_outq(ahd, SCB_DATAPTR, ahd_inq(ahd, SHADDR));
+                ahd_outl(ahd, SCB_DATACNT, resid);
+                ahd_outl(ahd, SCB_SGPTR, sgptr);
+                ahd_outb(ahd, CLRSEQINTSRC, CLRSAVEPTRS);
+                ahd_outb(ahd, SEQIMODE,
+                         ahd_inb(ahd, SEQIMODE) | ENSAVEPTRS);
+                /*
+                 * If the data is to the SCSI bus, we are
+                 * done, otherwise wait for FIFOEMP.
+                 */
+                if ((ahd_inb(ahd, DFCNTRL) & DIRECTION) != 0)
+                        goto clrchn;
+        } else if ((ahd_inb(ahd, SG_STATE) & LOADING_NEEDED) != 0) {
+                uint32_t sgptr;
+                uint64_t data_addr;
+                uint32_t data_len;
+                u_int    dfcntrl;
 
-                        /*
-                         * Wait for the DMA engine to notice that the
-                         * host transfer is enabled and that there is
-                         * space in the S/G FIFO for new segments before
-                         * loading more segments.
-                         */
-                        if ((ahd_inb(ahd, DFSTATUS) & PRELOAD_AVAIL) == 0)
-                                continue;
-                        if ((ahd_inb(ahd, DFCNTRL) & HDMAENACK) == 0)
-                                continue;
+                /*
+                 * Disable S/G fetch so the DMA engine
+                 * is available to future users.  We won't
+                 * be using the DMA engine to load segments.
+                 */
+                if ((ahd_inb(ahd, SG_STATE) & FETCH_INPROG) != 0) {
+                        ahd_outb(ahd, CCSGCTL, 0);
+                        ahd_outb(ahd, SG_STATE, LOADING_NEEDED);
+                }
+
+                /*
+                 * Wait for the DMA engine to notice that the
+                 * host transfer is enabled and that there is
+                 * space in the S/G FIFO for new segments before
+                 * loading more segments.
+                 */
+                if ((ahd_inb(ahd, DFSTATUS) & PRELOAD_AVAIL) != 0
+                 && (ahd_inb(ahd, DFCNTRL) & HDMAENACK) != 0) {
 
                         /*
                          * Determine the offset of the next S/G
@@ -748,7 +794,7 @@ ahd_run_data_fifo(struct ahd_softc *ahd, struct scb *scb)
                          * Advertise the segment to the hardware.
                          */
                         dfcntrl = ahd_inb(ahd, DFCNTRL)|PRELOADEN|HDMAEN;
-                        if ((ahd->features & AHD_NEW_DFCNTRL_OPTS)!=0) {
+                        if ((ahd->features & AHD_NEW_DFCNTRL_OPTS) != 0) {
                                 /*
                                  * Use SCSIENWRDIS so that SCSIEN
                                  * is never modified by this
@@ -757,35 +803,44 @@ ahd_run_data_fifo(struct ahd_softc *ahd, struct scb *scb)
                                 dfcntrl |= SCSIENWRDIS;
                         }
                         ahd_outb(ahd, DFCNTRL, dfcntrl);
-                } else if ((ahd_inb(ahd, SG_CACHE_SHADOW)
-                         & LAST_SEG_DONE) != 0) {
-
-                        /*
-                         * Transfer completed to the end of SG list
-                         * and has flushed to the host.
-                         */
-                        ahd_outb(ahd, SCB_SGPTR,
-                                 ahd_inb_scbram(ahd, SCB_SGPTR) | SG_LIST_NULL);
-                        break;
-                } else if ((ahd_inb(ahd, DFSTATUS) & FIFOEMP) != 0) {
-                        break;
                 }
-                ahd_delay(200);
+        } else if ((ahd_inb(ahd, SG_CACHE_SHADOW) & LAST_SEG_DONE) != 0) {
+
+                /*
+                 * Transfer completed to the end of SG list
+                 * and has flushed to the host.
+                 */
+                ahd_outb(ahd, SCB_SGPTR,
+                         ahd_inb_scbram(ahd, SCB_SGPTR) | SG_LIST_NULL);
+                goto clrchn;
+        } else if ((ahd_inb(ahd, DFSTATUS) & FIFOEMP) != 0) {
+clrchn:
+                /*
+                 * Clear any handler for this FIFO, decrement
+                 * the FIFO use count for the SCB, and release
+                 * the FIFO.
+                 */
+                ahd_outb(ahd, LONGJMP_ADDR + 1, INVALID_ADDR);
+                ahd_outb(ahd, SCB_FIFO_USE_COUNT,
+                         ahd_inb_scbram(ahd, SCB_FIFO_USE_COUNT) - 1);
+                ahd_outb(ahd, DFFSXFRCTL, CLRCHN);
         }
-        /*
-         * Clear any handler for this FIFO, decrement
-         * the FIFO use count for the SCB, and release
-         * the FIFO.
-         */
-        ahd_outb(ahd, LONGJMP_ADDR + 1, INVALID_ADDR);
-        ahd_outb(ahd, SCB_FIFO_USE_COUNT,
-                 ahd_inb_scbram(ahd, SCB_FIFO_USE_COUNT) - 1);
-        ahd_outb(ahd, DFFSXFRCTL, CLRCHN);
 }
 
+/*
+ * Look for entries in the QoutFIFO that have completed.
+ * The valid_tag completion field indicates the validity
+ * of the entry - the valid value toggles each time through
+ * the queue. We use the sg_status field in the completion
+ * entry to avoid referencing the hscb if the completion
+ * occurred with no errors and no residual.  sg_status is
+ * a copy of the first byte (little endian) of the sgptr
+ * hscb field.
+ */
 void
 ahd_run_qoutfifo(struct ahd_softc *ahd)
 {
+        struct ahd_completion *completion;
         struct scb *scb;
         u_int  scb_index;
 
@@ -793,11 +848,13 @@ ahd_run_qoutfifo(struct ahd_softc *ahd)
                 panic("ahd_run_qoutfifo recursion");
         ahd->flags |= AHD_RUNNING_QOUTFIFO;
         ahd_sync_qoutfifo(ahd, BUS_DMASYNC_POSTREAD);
-        while ((ahd->qoutfifo[ahd->qoutfifonext]
-             & QOUTFIFO_ENTRY_VALID_LE) == ahd->qoutfifonext_valid_tag) {
+        for (;;) {
+                completion = &ahd->qoutfifo[ahd->qoutfifonext];
 
-                scb_index = ahd_le16toh(ahd->qoutfifo[ahd->qoutfifonext]
-                                      & ~QOUTFIFO_ENTRY_VALID_LE);
+                if (completion->valid_tag != ahd->qoutfifonext_valid_tag)
+                        break;
+
+                scb_index = ahd_le16toh(completion->tag);
                 scb = ahd_lookup_scb(ahd, scb_index);
                 if (scb == NULL) {
                         printf("%s: WARNING no command for scb %d "
@@ -805,12 +862,15 @@ ahd_run_qoutfifo(struct ahd_softc *ahd)
                                ahd_name(ahd), scb_index,
                                ahd->qoutfifonext);
                         ahd_dump_card_state(ahd);
-                } else
-                        ahd_complete_scb(ahd, scb);
+                } else if ((completion->sg_status & SG_STATUS_VALID) != 0) {
+                        ahd_handle_scb_status(ahd, scb);
+                } else {
+                        ahd_done(ahd, scb);
+                }
 
                 ahd->qoutfifonext = (ahd->qoutfifonext+1) & (AHD_QOUT_SIZE-1);
                 if (ahd->qoutfifonext == 0)
-                        ahd->qoutfifonext_valid_tag ^= QOUTFIFO_ENTRY_VALID_LE;
+                        ahd->qoutfifonext_valid_tag ^= QOUTFIFO_ENTRY_VALID;
         }
         ahd->flags &= ~AHD_RUNNING_QOUTFIFO;
 }
@@ -876,26 +936,6 @@ ahd_handle_seqint(struct ahd_softc *ahd, u_int intstat)
                        ahd_name(ahd), seqintcode);
 #endif
         switch (seqintcode) {
-        case BAD_SCB_STATUS:
-        {
-                struct  scb *scb;
-                u_int   scbid;
-                int     cmds_pending;
-
-                scbid = ahd_get_scbptr(ahd);
-                scb = ahd_lookup_scb(ahd, scbid);
-                if (scb != NULL) {
-                        ahd_complete_scb(ahd, scb);
-                } else {
-                        printf("%s: WARNING no command for scb %d "
-                               "(bad status)\n", ahd_name(ahd), scbid);
-                        ahd_dump_card_state(ahd);
-                }
-                cmds_pending = ahd_inw(ahd, CMDS_PENDING);
-                if (cmds_pending > 0)
-                        ahd_outw(ahd, CMDS_PENDING, cmds_pending - 1);
-                break;
-        }
         case ENTERING_NONPACK:
         {
                 struct  scb *scb;
@@ -1060,7 +1100,7 @@ ahd_handle_seqint(struct ahd_softc *ahd, u_int intstat)
                         ahd_outb(ahd, SAVED_LUN, 0);
                         ahd_outb(ahd, SEQ_FLAGS, 0);
                         ahd_assert_atn(ahd);
-                        scb->flags &= ~(SCB_PACKETIZED);
+                        scb->flags &= ~SCB_PACKETIZED;
                         scb->flags |= SCB_ABORT|SCB_CMDPHASE_ABORT;
                         ahd_freeze_devq(ahd, scb);
                         ahd_set_transaction_status(scb, CAM_REQUEUE_REQ);
@@ -1503,9 +1543,6 @@ ahd_handle_scsiint(struct ahd_softc *ahd, u_int intstat)
          && (ahd_inb(ahd, SEQ_FLAGS) & NOT_IDENTIFIED) != 0)
                 scb = NULL;
 
-        /* Make sure the sequencer is in a safe location. */
-        ahd_clear_critical_section(ahd);
-
         if ((status0 & IOERR) != 0) {
                 u_int now_lvd;
 
@@ -1521,26 +1558,35 @@ ahd_handle_scsiint(struct ahd_softc *ahd, u_int intstat)
                 ahd_setup_iocell_workaround(ahd);
                 ahd_unpause(ahd);
         } else if ((status0 & OVERRUN) != 0) {
+
                 printf("%s: SCSI offset overrun detected.  Resetting bus.\n",
                        ahd_name(ahd));
                 ahd_reset_channel(ahd, 'A', /*Initiate Reset*/TRUE);
         } else if ((status & SCSIRSTI) != 0) {
+
                 printf("%s: Someone reset channel A\n", ahd_name(ahd));
                 ahd_reset_channel(ahd, 'A', /*Initiate Reset*/FALSE);
         } else if ((status & SCSIPERR) != 0) {
+
+                /* Make sure the sequencer is in a safe location. */
+                ahd_clear_critical_section(ahd);
+
                 ahd_handle_transmission_error(ahd);
         } else if (lqostat0 != 0) {
+
                 printf("%s: lqostat0 == 0x%x!\n", ahd_name(ahd), lqostat0);
                 ahd_outb(ahd, CLRLQOINT0, lqostat0);
-                if ((ahd->bugs & AHD_CLRLQO_AUTOCLR_BUG) != 0) {
+                if ((ahd->bugs & AHD_CLRLQO_AUTOCLR_BUG) != 0)
                         ahd_outb(ahd, CLRLQOINT1, 0);
-                }
         } else if ((status & SELTO) != 0) {
                 u_int  scbid;
 
                 /* Stop the selection */
                 ahd_outb(ahd, SCSISEQ0, 0);
 
+                /* Make sure the sequencer is in a safe location. */
+                ahd_clear_critical_section(ahd);
+
                 /* No more pending messages */
                 ahd_clear_msg_state(ahd);
 
@@ -1573,24 +1619,27 @@ ahd_handle_scsiint(struct ahd_softc *ahd, u_int intstat)
                                        scbid);
                         }
 #endif
-                        /*
-                         * Force a renegotiation with this target just in
-                         * case the cable was pulled and will later be
-                         * re-attached.  The target may forget its negotiation
-                         * settings with us should it attempt to reselect
-                         * during the interruption.  The target will not issue
-                         * a unit attention in this case, so we must always
-                         * renegotiate.
-                         */
                         ahd_scb_devinfo(ahd, &devinfo, scb);
-                        ahd_force_renegotiation(ahd, &devinfo);
                         ahd_set_transaction_status(scb, CAM_SEL_TIMEOUT);
                         ahd_freeze_devq(ahd, scb);
+
+                        /*
+                         * Cancel any pending transactions on the device
+                         * now that it seems to be missing.  This will
+                         * also revert us to async/narrow transfers until
+                         * we can renegotiate with the device.
+                         */
+                        ahd_handle_devreset(ahd, &devinfo,
+                                            CAM_LUN_WILDCARD,
+                                            CAM_SEL_TIMEOUT,
+                                            "Selection Timeout",
+                                            /*verbose_level*/1);
                 }
                 ahd_outb(ahd, CLRINT, CLRSCSIINT);
                 ahd_iocell_first_selection(ahd);
                 ahd_unpause(ahd);
         } else if ((status0 & (SELDI|SELDO)) != 0) {
+
                 ahd_iocell_first_selection(ahd);
                 ahd_unpause(ahd);
         } else if (status3 != 0) {
@@ -1598,6 +1647,10 @@ ahd_handle_scsiint(struct ahd_softc *ahd, u_int intstat)
                        ahd_name(ahd), status3);
                 ahd_outb(ahd, CLRSINT3, status3);
         } else if ((lqistat1 & (LQIPHASE_LQ|LQIPHASE_NLQ)) != 0) {
+
+                /* Make sure the sequencer is in a safe location. */
+                ahd_clear_critical_section(ahd);
+
                 ahd_handle_lqiphase_error(ahd, lqistat1);
         } else if ((lqistat1 & LQICRCI_NLQ) != 0) {
                 /*
@@ -1622,6 +1675,9 @@ ahd_handle_scsiint(struct ahd_softc *ahd, u_int intstat)
                  */
                 ahd_outb(ahd, SCSISEQ0, 0);
 
+                /* Make sure the sequencer is in a safe location. */
+                ahd_clear_critical_section(ahd);
+
                 /*
                  * Determine what we were up to at the time of
                  * the busfree.
@@ -1659,7 +1715,16 @@ ahd_handle_scsiint(struct ahd_softc *ahd, u_int intstat)
                         clear_fifo = 0;
                         packetized =  (lqostat1 & LQOBUSFREE) != 0;
                         if (!packetized
-                         && ahd_inb(ahd, LASTPHASE) == P_BUSFREE)
+                         && ahd_inb(ahd, LASTPHASE) == P_BUSFREE
+                         && (ahd_inb(ahd, SSTAT0) & SELDI) == 0
+                         && ((ahd_inb(ahd, SSTAT0) & SELDO) == 0
+                          || (ahd_inb(ahd, SCSISEQ0) & ENSELO) == 0))
+                                /*
+                                 * Assume packetized if we are not
+                                 * on the bus in a non-packetized
+                                 * capacity and any pending selection
+                                 * was a packetized selection.
+                                 */
                                 packetized = 1;
                         break;
                 }
@@ -2310,8 +2375,7 @@ ahd_handle_nonpkt_busfree(struct ahd_softc *ahd)
                        "PRGMCNT == 0x%x\n",
                        ahd_lookup_phase_entry(lastphase)->phasemsg,
                        aborted,
-                       ahd_inb(ahd, PRGMCNT)
-                        | (ahd_inb(ahd, PRGMCNT+1) << 8));
+                       ahd_inw(ahd, PRGMCNT));
                 ahd_dump_card_state(ahd);
         }
         /* Always restart the sequencer. */
@@ -2474,8 +2538,7 @@ ahd_clear_critical_section(struct ahd_softc *ahd)
                 u_int   i;
 
                 ahd_set_modes(ahd, AHD_MODE_SCSI, AHD_MODE_SCSI);
-                seqaddr = ahd_inb(ahd, CURADDR)
-                        | (ahd_inb(ahd, CURADDR+1) << 8);
+                seqaddr = ahd_inw(ahd, CURADDR);
 
                 cs = ahd->critical_sections;
                 for (i = 0; i < ahd->num_critical_sections; i++, cs++) {
@@ -3196,14 +3259,25 @@ ahd_update_neg_table(struct ahd_softc *ahd, struct ahd_devinfo *devinfo,
                 iocell_opts[AHD_PRECOMP_SLEW_INDEX] &= ~AHD_PRECOMP_MASK;
 
                 if ((ahd->features & AHD_NEW_IOCELL_OPTS) != 0
-                 && (ppr_opts & MSG_EXT_PPR_DT_REQ) != 0) {
+                 && (ppr_opts & MSG_EXT_PPR_DT_REQ) != 0
+                 && (ppr_opts & MSG_EXT_PPR_IU_REQ) == 0) {
                         /*
                          * Slow down our CRC interval to be
-                         * compatible with devices that can't
-                         * handle a CRC at full speed.
+                         * compatible with non-packetized
+                         * U160 devices that can't handle a
+                         * CRC at full speed.
                          */
                         con_opts |= ENSLOWCRC;
                 }
+
+                if ((ahd->bugs & AHD_PACED_NEGTABLE_BUG) != 0) {
+                        /*
+                         * On H2A4, revert to a slower slewrate
+                         * on non-paced transfers.
+                         */
+                        iocell_opts[AHD_PRECOMP_SLEW_INDEX] &=
+                            ~AHD_SLEWRATE_MASK;
+                }
         }
 
         ahd_outb(ahd, ANNEXCOL, AHD_ANNEXCOL_PRECOMP_SLEW);
@@ -3292,11 +3366,15 @@ ahd_update_pending_scbs(struct ahd_softc *ahd)
          * Force the sequencer to reinitialize the selection for
          * the command at the head of the execution queue if it
          * has already been setup.  The negotiation changes may
-         * effect whether we select-out with ATN.
+         * effect whether we select-out with ATN.  It is only
+         * safe to clear ENSELO when the bus is not free and no
+         * selection is in progres or completed.
          */
         saved_modes = ahd_save_modes(ahd);
         ahd_set_modes(ahd, AHD_MODE_SCSI, AHD_MODE_SCSI);
-        ahd_outb(ahd, SCSISEQ0, ahd_inb(ahd, SCSISEQ0) & ~ENSELO);
+        if ((ahd_inb(ahd, SCSISIGI) & BSYI) != 0
+         && (ahd_inb(ahd, SSTAT0) & (SELDO|SELINGO)) == 0)
+                ahd_outb(ahd, SCSISEQ0, ahd_inb(ahd, SCSISEQ0) & ~ENSELO);
         saved_scbptr = ahd_get_scbptr(ahd);
         /* Ensure that the hscbs down on the card match the new information */
         for (scb_tag = 0; scb_tag < ahd->scb_data.maxhscbs; scb_tag++) {
@@ -4909,10 +4987,7 @@ ahd_reinitialize_dataptrs(struct ahd_softc *ahd)
          * Determine initial values for data_addr and data_cnt
          * for resuming the data phase.
          */
-        sgptr = (ahd_inb_scbram(ahd, SCB_RESIDUAL_SGPTR + 3) << 24)
-              | (ahd_inb_scbram(ahd, SCB_RESIDUAL_SGPTR + 2) << 16)
-              | (ahd_inb_scbram(ahd, SCB_RESIDUAL_SGPTR + 1) << 8)
-              | ahd_inb_scbram(ahd, SCB_RESIDUAL_SGPTR);
+        sgptr = ahd_inl_scbram(ahd, SCB_RESIDUAL_SGPTR);
         sgptr &= SG_PTR_MASK;
 
         resid = (ahd_inb_scbram(ahd, SCB_RESIDUAL_DATACNT + 2) << 16)
@@ -4930,10 +5005,7 @@ ahd_reinitialize_dataptrs(struct ahd_softc *ahd)
                 dataptr = ahd_le64toh(sg->addr)
                         + (ahd_le32toh(sg->len) & AHD_SG_LEN_MASK)
                         - resid;
-                ahd_outb(ahd, HADDR + 7, dataptr >> 56);
-                ahd_outb(ahd, HADDR + 6, dataptr >> 48);
-                ahd_outb(ahd, HADDR + 5, dataptr >> 40);
-                ahd_outb(ahd, HADDR + 4, dataptr >> 32);
+                ahd_outl(ahd, HADDR + 4, dataptr >> 32);
         } else {
                 struct   ahd_dma_seg *sg;
 
@@ -4948,10 +5020,7 @@ ahd_reinitialize_dataptrs(struct ahd_softc *ahd)
                 ahd_outb(ahd, HADDR + 4,
                          (ahd_le32toh(sg->len) & ~AHD_SG_LEN_MASK) >> 24);
         }
-        ahd_outb(ahd, HADDR + 3, dataptr >> 24);
-        ahd_outb(ahd, HADDR + 2, dataptr >> 16);
-        ahd_outb(ahd, HADDR + 1, dataptr >> 8);
-        ahd_outb(ahd, HADDR, dataptr);
+        ahd_outl(ahd, HADDR, dataptr);
         ahd_outb(ahd, HCNT + 2, resid >> 16);
         ahd_outb(ahd, HCNT + 1, resid >> 8);
         ahd_outb(ahd, HCNT, resid);
@@ -5011,13 +5080,14 @@ ahd_handle_devreset(struct ahd_softc *ahd, struct ahd_devinfo *devinfo,
         ahd_set_width(ahd, devinfo, MSG_EXT_WDTR_BUS_8_BIT,
                       AHD_TRANS_CUR, /*paused*/TRUE);
         ahd_set_syncrate(ahd, devinfo, /*period*/0, /*offset*/0,
-                         /*ppr_options*/0, AHD_TRANS_CUR, /*paused*/TRUE);
+                         /*ppr_options*/0, AHD_TRANS_CUR,
+                         /*paused*/TRUE);
         
-        ahd_send_async(ahd, devinfo->channel, devinfo->target,
-                       lun, AC_SENT_BDR, NULL);
+        if (status != CAM_SEL_TIMEOUT)
+                ahd_send_async(ahd, devinfo->channel, devinfo->target,
+                               CAM_LUN_WILDCARD, AC_SENT_BDR, NULL);
 
-        if (message != NULL
-         && (verbose_level <= bootverbose))
+        if (message != NULL && bootverbose)
                 printf("%s: %s on %c:%d. %d SCBs aborted\n", ahd_name(ahd),
                        message, devinfo->channel, devinfo->target, found);
 }
@@ -5203,13 +5273,13 @@ ahd_free(struct ahd_softc *ahd)
                 /* FALLTHROUGH */
         case 4:
                 ahd_dmamap_unload(ahd, ahd->shared_data_dmat,
-                                  ahd->shared_data_dmamap);
+                                  ahd->shared_data_map.dmamap);
                 /* FALLTHROUGH */
         case 3:
                 ahd_dmamem_free(ahd, ahd->shared_data_dmat, ahd->qoutfifo,
-                                ahd->shared_data_dmamap);
+                                ahd->shared_data_map.dmamap);
                 ahd_dmamap_destroy(ahd, ahd->shared_data_dmat,
-                                   ahd->shared_data_dmamap);
+                                   ahd->shared_data_map.dmamap);
                 /* FALLTHROUGH */
         case 2:
                 ahd_dma_tag_destroy(ahd, ahd->shared_data_dmat);
@@ -5975,16 +6045,13 @@ ahd_alloc_scbs(struct ahd_softc *ahd)
         newcount = MIN(scb_data->sense_left, scb_data->scbs_left);
         newcount = MIN(newcount, scb_data->sgs_left);
         newcount = MIN(newcount, (AHD_SCB_MAX_ALLOC - scb_data->numscbs));
-        scb_data->sense_left -= newcount;
-        scb_data->scbs_left -= newcount;
-        scb_data->sgs_left -= newcount;
         for (i = 0; i < newcount; i++) {
-                u_int col_tag;
-
                 struct scb_platform_data *pdata;
+                u_int col_tag;
 #ifndef __linux__
                 int error;
 #endif
+
                 next_scb = (struct scb *)malloc(sizeof(*next_scb),
                                                 M_DEVBUF, M_NOWAIT);
                 if (next_scb == NULL)
@@ -6041,6 +6108,9 @@ ahd_alloc_scbs(struct ahd_softc *ahd)
                 sense_data += AHD_SENSE_BUFSIZE;
                 sense_busaddr += AHD_SENSE_BUFSIZE;
                 scb_data->numscbs++;
+                scb_data->sense_left--;
+                scb_data->scbs_left--;
+                scb_data->sgs_left--;
         }
 }
 
@@ -6088,7 +6158,6 @@ static const char *termstat_strings[] = {
 int
 ahd_init(struct ahd_softc *ahd)
 {
-        uint8_t         *base_vaddr;
         uint8_t         *next_vaddr;
         dma_addr_t       next_baddr;
         size_t           driver_data_size;
@@ -6156,7 +6225,7 @@ ahd_init(struct ahd_softc *ahd)
          * for the target mode role, we must additionally provide space for
          * the incoming target command fifo.
          */
-        driver_data_size = AHD_SCB_MAX * sizeof(uint16_t)
+        driver_data_size = AHD_SCB_MAX * sizeof(*ahd->qoutfifo)
                          + sizeof(struct hardware_scb);
         if ((ahd->features & AHD_TARGETMODE) != 0)
                 driver_data_size += AHD_TMODE_CMDS * sizeof(struct target_cmd);
@@ -6178,20 +6247,23 @@ ahd_init(struct ahd_softc *ahd)
 
         /* Allocation of driver data */
         if (ahd_dmamem_alloc(ahd, ahd->shared_data_dmat,
-                             (void **)&base_vaddr,
-                             BUS_DMA_NOWAIT, &ahd->shared_data_dmamap) != 0) {
+                             (void **)&ahd->shared_data_map.vaddr,
+                             BUS_DMA_NOWAIT,
+                             &ahd->shared_data_map.dmamap) != 0) {
                 return (ENOMEM);
         }
 
         ahd->init_level++;
 
         /* And permanently map it in */
-        ahd_dmamap_load(ahd, ahd->shared_data_dmat, ahd->shared_data_dmamap,
-                        base_vaddr, driver_data_size, ahd_dmamap_cb,
-                        &ahd->shared_data_busaddr, /*flags*/0);
-        ahd->qoutfifo = (uint16_t *)base_vaddr;
+        ahd_dmamap_load(ahd, ahd->shared_data_dmat, ahd->shared_data_map.dmamap,
+                        ahd->shared_data_map.vaddr, driver_data_size,
+                        ahd_dmamap_cb, &ahd->shared_data_map.physaddr,
+                        /*flags*/0);
+        ahd->qoutfifo = (struct ahd_completion *)ahd->shared_data_map.vaddr;
         next_vaddr = (uint8_t *)&ahd->qoutfifo[AHD_QOUT_SIZE];
-        next_baddr = ahd->shared_data_busaddr + AHD_QOUT_SIZE*sizeof(uint16_t);
+        next_baddr = ahd->shared_data_map.physaddr
+                   + AHD_QOUT_SIZE*sizeof(struct ahd_completion);
         if ((ahd->features & AHD_TARGETMODE) != 0) {
                 ahd->targetcmds = (struct target_cmd *)next_vaddr;
                 next_vaddr += AHD_TMODE_CMDS * sizeof(struct target_cmd);
@@ -6212,6 +6284,7 @@ ahd_init(struct ahd_softc *ahd)
          * specially from the DMA safe memory chunk used for the QOUTFIFO.
          */
         ahd->next_queued_hscb = (struct hardware_scb *)next_vaddr;
+        ahd->next_queued_hscb_map = &ahd->shared_data_map;
         ahd->next_queued_hscb->hscb_busaddr = ahd_htole32(next_baddr);
 
         ahd->init_level++;
@@ -6517,10 +6590,10 @@ ahd_chip_init(struct ahd_softc *ahd)
 
         /* All of our queues are empty */
         ahd->qoutfifonext = 0;
-        ahd->qoutfifonext_valid_tag = QOUTFIFO_ENTRY_VALID_LE;
-        ahd_outb(ahd, QOUTFIFO_ENTRY_VALID_TAG, QOUTFIFO_ENTRY_VALID >> 8);
+        ahd->qoutfifonext_valid_tag = QOUTFIFO_ENTRY_VALID;
+        ahd_outb(ahd, QOUTFIFO_ENTRY_VALID_TAG, QOUTFIFO_ENTRY_VALID);
         for (i = 0; i < AHD_QOUT_SIZE; i++)
-                ahd->qoutfifo[i] = 0;
+                ahd->qoutfifo[i].valid_tag = 0;
         ahd_sync_qoutfifo(ahd, BUS_DMASYNC_PREREAD);
 
         ahd->qinfifonext = 0;
@@ -6553,24 +6626,22 @@ ahd_chip_init(struct ahd_softc *ahd)
         ahd_outw(ahd, COMPLETE_SCB_HEAD, SCB_LIST_NULL);
         ahd_outw(ahd, COMPLETE_SCB_DMAINPROG_HEAD, SCB_LIST_NULL);
         ahd_outw(ahd, COMPLETE_DMA_SCB_HEAD, SCB_LIST_NULL);
+        ahd_outw(ahd, COMPLETE_DMA_SCB_TAIL, SCB_LIST_NULL);
+        ahd_outw(ahd, COMPLETE_ON_QFREEZE_HEAD, SCB_LIST_NULL);
 
         /*
          * The Freeze Count is 0.
          */
+        ahd->qfreeze_cnt = 0;
         ahd_outw(ahd, QFREEZE_COUNT, 0);
+        ahd_outw(ahd, KERNEL_QFREEZE_COUNT, 0);
 
         /*
          * Tell the sequencer where it can find our arrays in memory.
          */
-        busaddr = ahd->shared_data_busaddr;
-        ahd_outb(ahd, SHARED_DATA_ADDR, busaddr & 0xFF);
-        ahd_outb(ahd, SHARED_DATA_ADDR + 1, (busaddr >> 8) & 0xFF);
-        ahd_outb(ahd, SHARED_DATA_ADDR + 2, (busaddr >> 16) & 0xFF);
-        ahd_outb(ahd, SHARED_DATA_ADDR + 3, (busaddr >> 24) & 0xFF);
-        ahd_outb(ahd, QOUTFIFO_NEXT_ADDR, busaddr & 0xFF);
-        ahd_outb(ahd, QOUTFIFO_NEXT_ADDR + 1, (busaddr >> 8) & 0xFF);
-        ahd_outb(ahd, QOUTFIFO_NEXT_ADDR + 2, (busaddr >> 16) & 0xFF);
-        ahd_outb(ahd, QOUTFIFO_NEXT_ADDR + 3, (busaddr >> 24) & 0xFF);
+        busaddr = ahd->shared_data_map.physaddr;
+        ahd_outl(ahd, SHARED_DATA_ADDR, busaddr);
+        ahd_outl(ahd, QOUTFIFO_NEXT_ADDR, busaddr);
 
         /*
          * Setup the allowed SCSI Sequences based on operational mode.
@@ -6619,10 +6690,7 @@ ahd_chip_init(struct ahd_softc *ahd)
          * Tell the sequencer which SCB will be the next one it receives.
          */
         busaddr = ahd_le32toh(ahd->next_queued_hscb->hscb_busaddr);
-        ahd_outb(ahd, NEXT_QUEUED_SCB_ADDR + 0, busaddr & 0xFF);
-        ahd_outb(ahd, NEXT_QUEUED_SCB_ADDR + 1, (busaddr >> 8) & 0xFF);
-        ahd_outb(ahd, NEXT_QUEUED_SCB_ADDR + 2, (busaddr >> 16) & 0xFF);
-        ahd_outb(ahd, NEXT_QUEUED_SCB_ADDR + 3, (busaddr >> 24) & 0xFF);
+        ahd_outl(ahd, NEXT_QUEUED_SCB_ADDR, busaddr);
 
         /*
          * Default to coalescing disabled.
@@ -6926,43 +6994,34 @@ ahd_pause_and_flushwork(struct ahd_softc *ahd)
 {
         u_int intstat;
         u_int maxloops;
-        u_int qfreeze_cnt;
 
         maxloops = 1000;
         ahd->flags |= AHD_ALL_INTERRUPTS;
         ahd_pause(ahd);
         /*
-         * Increment the QFreeze Count so that the sequencer
-         * will not start new selections.  We do this only
+         * Freeze the outgoing selections.  We do this only
          * until we are safely paused without further selections
          * pending.
          */
-        ahd_outw(ahd, QFREEZE_COUNT, ahd_inw(ahd, QFREEZE_COUNT) + 1);
+        ahd->qfreeze_cnt--;
+        ahd_outw(ahd, KERNEL_QFREEZE_COUNT, ahd->qfreeze_cnt);
         ahd_outb(ahd, SEQ_FLAGS2, ahd_inb(ahd, SEQ_FLAGS2) | SELECTOUT_QFROZEN);
         do {
-                struct scb *waiting_scb;
 
                 ahd_unpause(ahd);
+                /*
+                 * Give the sequencer some time to service
+                 * any active selections.
+                 */
+                ahd_delay(500);
+
                 ahd_intr(ahd);
                 ahd_pause(ahd);
-                ahd_clear_critical_section(ahd);
                 intstat = ahd_inb(ahd, INTSTAT);
-                ahd_set_modes(ahd, AHD_MODE_SCSI, AHD_MODE_SCSI);
-                if ((ahd_inb(ahd, SSTAT0) & (SELDO|SELINGO)) == 0)
-                        ahd_outb(ahd, SCSISEQ0,
-                                 ahd_inb(ahd, SCSISEQ0) & ~ENSELO);
-                /*
-                 * In the non-packetized case, the sequencer (for Rev A),
-                 * relies on ENSELO remaining set after SELDO.  The hardware
-                 * auto-clears ENSELO in the packetized case.
-                 */
-                waiting_scb = ahd_lookup_scb(ahd,
-                                             ahd_inw(ahd, WAITING_TID_HEAD));
-                if (waiting_scb != NULL
-                 && (waiting_scb->flags & SCB_PACKETIZED) == 0
-                 && (ahd_inb(ahd, SSTAT0) & (SELDO|SELINGO)) != 0)
-                        ahd_outb(ahd, SCSISEQ0,
-                                 ahd_inb(ahd, SCSISEQ0) | ENSELO);
+                if ((intstat & INT_PEND) == 0) {
+                        ahd_clear_critical_section(ahd);
+                        intstat = ahd_inb(ahd, INTSTAT);
+                }
         } while (--maxloops
               && (intstat != 0xFF || (ahd->features & AHD_REMOVABLE) == 0)
               && ((intstat & INT_PEND) != 0
@@ -6973,17 +7032,8 @@ ahd_pause_and_flushwork(struct ahd_softc *ahd)
                 printf("Infinite interrupt loop, INTSTAT = %x",
                       ahd_inb(ahd, INTSTAT));
         }
-        qfreeze_cnt = ahd_inw(ahd, QFREEZE_COUNT);
-        if (qfreeze_cnt == 0) {
-                printf("%s: ahd_pause_and_flushwork with 0 qfreeze count!\n",
-                       ahd_name(ahd));
-        } else {
-                qfreeze_cnt--;
-        }
-        ahd_outw(ahd, QFREEZE_COUNT, qfreeze_cnt);
-        if (qfreeze_cnt == 0)
-                ahd_outb(ahd, SEQ_FLAGS2,
-                         ahd_inb(ahd, SEQ_FLAGS2) & ~SELECTOUT_QFROZEN);
+        ahd->qfreeze_cnt++;
+        ahd_outw(ahd, KERNEL_QFREEZE_COUNT, ahd->qfreeze_cnt);
 
         ahd_flush_qoutfifo(ahd);
 
@@ -7155,10 +7205,7 @@ ahd_qinfifo_requeue(struct ahd_softc *ahd, struct scb *prev_scb,
                 uint32_t busaddr;
 
                 busaddr = ahd_le32toh(scb->hscb->hscb_busaddr);
-                ahd_outb(ahd, NEXT_QUEUED_SCB_ADDR + 0, busaddr & 0xFF);
-                ahd_outb(ahd, NEXT_QUEUED_SCB_ADDR + 1, (busaddr >> 8) & 0xFF);
-                ahd_outb(ahd, NEXT_QUEUED_SCB_ADDR + 2, (busaddr >> 16) & 0xFF);
-                ahd_outb(ahd, NEXT_QUEUED_SCB_ADDR + 3, (busaddr >> 24) & 0xFF);
+                ahd_outl(ahd, NEXT_QUEUED_SCB_ADDR, busaddr);
         } else {
                 prev_scb->hscb->next_hscb_busaddr = scb->hscb->hscb_busaddr;
                 ahd_sync_scb(ahd, prev_scb, 
@@ -7265,10 +7312,7 @@ ahd_search_qinfifo(struct ahd_softc *ahd, int target, char channel,
          */
         ahd->qinfifonext = qinstart;
         busaddr = ahd_le32toh(ahd->next_queued_hscb->hscb_busaddr);
-        ahd_outb(ahd, NEXT_QUEUED_SCB_ADDR + 0, busaddr & 0xFF);
-        ahd_outb(ahd, NEXT_QUEUED_SCB_ADDR + 1, (busaddr >> 8) & 0xFF);
-        ahd_outb(ahd, NEXT_QUEUED_SCB_ADDR + 2, (busaddr >> 16) & 0xFF);
-        ahd_outb(ahd, NEXT_QUEUED_SCB_ADDR + 3, (busaddr >> 24) & 0xFF);
+        ahd_outl(ahd, NEXT_QUEUED_SCB_ADDR, busaddr);
 
         while (qinpos != qintail) {
                 scb = ahd_lookup_scb(ahd, ahd->qinfifo[qinpos]);
@@ -7330,6 +7374,7 @@ ahd_search_qinfifo(struct ahd_softc *ahd, int target, char channel,
          * appropriate, traverse the SCBs of each "their id"
          * looking for matches.
          */
+        ahd_set_modes(ahd, AHD_MODE_SCSI, AHD_MODE_SCSI);
         savedscbptr = ahd_get_scbptr(ahd);
         tid_next = ahd_inw(ahd, WAITING_TID_HEAD);
         tid_prev = SCB_LIST_NULL;
@@ -7399,7 +7444,7 @@ ahd_search_scb_list(struct ahd_softc *ahd, int target, char channel,
         u_int   prev;
         int     found;
 
-        AHD_ASSERT_MODES(ahd, AHD_MODE_CCHAN_MSK, AHD_MODE_CCHAN_MSK);
+        AHD_ASSERT_MODES(ahd, AHD_MODE_SCSI_MSK, AHD_MODE_SCSI_MSK);
         found = 0;
         prev = SCB_LIST_NULL;
         next = *list_head;
@@ -7466,7 +7511,7 @@ static void
 ahd_stitch_tid_list(struct ahd_softc *ahd, u_int tid_prev,
                     u_int tid_cur, u_int tid_next)
 {
-        AHD_ASSERT_MODES(ahd, AHD_MODE_CCHAN_MSK, AHD_MODE_CCHAN_MSK);
+        AHD_ASSERT_MODES(ahd, AHD_MODE_SCSI_MSK, AHD_MODE_SCSI_MSK);
 
         if (SCBID_IS_NULL(tid_cur)) {
 
@@ -7506,7 +7551,7 @@ ahd_rem_wscb(struct ahd_softc *ahd, u_int scbid,
 {
         u_int tail_offset;
 
-        AHD_ASSERT_MODES(ahd, AHD_MODE_CCHAN_MSK, AHD_MODE_CCHAN_MSK);
+        AHD_ASSERT_MODES(ahd, AHD_MODE_SCSI_MSK, AHD_MODE_SCSI_MSK);
         if (!SCBID_IS_NULL(prev)) {
                 ahd_set_scbptr(ahd, prev);
                 ahd_outw(ahd, SCB_NEXT, next);
@@ -7739,7 +7784,7 @@ ahd_reset_channel(struct ahd_softc *ahd, char channel, int initiate_reset)
          */
         ahd_clear_msg_state(ahd);
         ahd_outb(ahd, SIMODE1,
-                 ahd_inb(ahd, SIMODE1) & ~(ENBUSFREE|ENSCSIRST|ENBUSFREE));
+                 ahd_inb(ahd, SIMODE1) & ~(ENBUSFREE|ENSCSIRST));
 
         if (initiate_reset)
                 ahd_reset_current_bus(ahd);
@@ -7910,30 +7955,35 @@ ahd_handle_scb_status(struct ahd_softc *ahd, struct scb *scb)
 void
 ahd_handle_scsi_status(struct ahd_softc *ahd, struct scb *scb)
 {
-        struct hardware_scb *hscb;
-        u_int  qfreeze_cnt;
+        struct  hardware_scb *hscb;
+        int     paused;
 
         /*
          * The sequencer freezes its select-out queue
          * anytime a SCSI status error occurs.  We must
-         * handle the error and decrement the QFREEZE count
-         * to allow the sequencer to continue.
+         * handle the error and increment our qfreeze count
+         * to allow the sequencer to continue.  We don't
+         * bother clearing critical sections here since all
+         * operations are on data structures that the sequencer
+         * is not touching once the queue is frozen.
          */
         hscb = scb->hscb; 
 
+        if (ahd_is_paused(ahd)) {
+                paused = 1;
+        } else {
+                paused = 0;
+                ahd_pause(ahd);
+        }
+
         /* Freeze the queue until the client sees the error. */
         ahd_freeze_devq(ahd, scb);
         ahd_freeze_scb(scb);
-        qfreeze_cnt = ahd_inw(ahd, QFREEZE_COUNT);
-        if (qfreeze_cnt == 0) {
-                printf("%s: Bad status with 0 qfreeze count!\n", ahd_name(ahd));
-        } else {
-                qfreeze_cnt--;
-                ahd_outw(ahd, QFREEZE_COUNT, qfreeze_cnt);
-        }
-        if (qfreeze_cnt == 0)
-                ahd_outb(ahd, SEQ_FLAGS2,
-                         ahd_inb(ahd, SEQ_FLAGS2) & ~SELECTOUT_QFROZEN);
+        ahd->qfreeze_cnt++;
+        ahd_outw(ahd, KERNEL_QFREEZE_COUNT, ahd->qfreeze_cnt);
+
+        if (paused == 0)
+                ahd_unpause(ahd);
 
         /* Don't want to clobber the original sense code */
         if ((scb->flags & SCB_SENSE) != 0) {
@@ -8317,8 +8367,7 @@ ahd_dumpseq(struct ahd_softc* ahd)
         max_prog = 2048;
 
         ahd_outb(ahd, SEQCTL0, PERRORDIS|FAILDIS|FASTMODE|LOADRAM);
-        ahd_outb(ahd, PRGMCNT, 0);
-        ahd_outb(ahd, PRGMCNT+1, 0);
+        ahd_outw(ahd, PRGMCNT, 0);
         for (i = 0; i < max_prog; i++) {
                 uint8_t ins_bytes[4];
 
@@ -8347,13 +8396,14 @@ ahd_loadseq(struct ahd_softc *ahd)
         u_int   sg_prefetch_cnt_limit;
         u_int   sg_prefetch_align;
         u_int   sg_size;
+        u_int   cacheline_mask;
         uint8_t download_consts[DOWNLOAD_CONST_COUNT];
 
         if (bootverbose)
                 printf("%s: Downloading Sequencer Program...",
                        ahd_name(ahd));
 
-#if DOWNLOAD_CONST_COUNT != 7
+#if DOWNLOAD_CONST_COUNT != 8
 #error "Download Const Mismatch"
 #endif
         /*
@@ -8389,6 +8439,9 @@ ahd_loadseq(struct ahd_softc *ahd)
         /* Round down to the nearest power of 2. */
         while (powerof2(sg_prefetch_align) == 0)
                 sg_prefetch_align--;
+
+        cacheline_mask = sg_prefetch_align - 1;
+
         /*
          * If the cacheline boundary is greater than half our prefetch RAM
          * we risk not being able to fetch even a single complete S/G
@@ -8429,12 +8482,12 @@ ahd_loadseq(struct ahd_softc *ahd)
         download_consts[PKT_OVERRUN_BUFOFFSET] =
                 (ahd->overrun_buf - (uint8_t *)ahd->qoutfifo) / 256;
         download_consts[SCB_TRANSFER_SIZE] = SCB_TRANSFER_SIZE_1BYTE_LUN;
+        download_consts[CACHELINE_MASK] = cacheline_mask;
         cur_patch = patches;
         downloaded = 0;
         skip_addr = 0;
         ahd_outb(ahd, SEQCTL0, PERRORDIS|FAILDIS|FASTMODE|LOADRAM);
-        ahd_outb(ahd, PRGMCNT, 0);
-        ahd_outb(ahd, PRGMCNT+1, 0);
+        ahd_outw(ahd, PRGMCNT, 0);
 
         for (i = 0; i < sizeof(seqprog)/4; i++) {
                 if (ahd_check_patch(ahd, &cur_patch, i, &skip_addr) == 0) {
@@ -8727,7 +8780,7 @@ ahd_dump_card_state(struct ahd_softc *ahd)
         printf(">>>>>>>>>>>>>>>>>> Dump Card State Begins <<<<<<<<<<<<<<<<<\n"
                "%s: Dumping Card State at program address 0x%x Mode 0x%x\n",
                ahd_name(ahd), 
-               ahd_inb(ahd, CURADDR) | (ahd_inb(ahd, CURADDR+1) << 8),
+               ahd_inw(ahd, CURADDR),
                ahd_build_mode_state(ahd, ahd->saved_src_mode,
                                     ahd->saved_dst_mode));
         if (paused)
@@ -8843,6 +8896,15 @@ ahd_dump_card_state(struct ahd_softc *ahd)
                 scb_index = ahd_inw_scbram(ahd, SCB_NEXT_COMPLETE);
         }
         printf("\n");
+        printf("Sequencer On QFreeze and Complete list: ");
+        scb_index = ahd_inw(ahd, COMPLETE_ON_QFREEZE_HEAD);
+        i = 0;
+        while (!SCBID_IS_NULL(scb_index) && i++ < AHD_SCB_MAX) {
+                ahd_set_scbptr(ahd, scb_index);
+                printf("%d ", scb_index);
+                scb_index = ahd_inw_scbram(ahd, SCB_NEXT_COMPLETE);
+        }
+        printf("\n");
         ahd_set_scbptr(ahd, saved_scb_index);
         dffstat = ahd_inb(ahd, DFFSTAT);
         for (i = 0; i < 2; i++) {
@@ -9077,7 +9139,7 @@ ahd_wait_seeprom(struct ahd_softc *ahd)
 {
         int cnt;
 
-        cnt = 20;
+        cnt = 5000;
         while ((ahd_inb(ahd, SEESTAT) & (SEEARBACK|SEEBUSY)) != 0 && --cnt)
                 ahd_delay(5);
 
@@ -9423,13 +9485,9 @@ ahd_handle_en_lun(struct ahd_softc *ahd, struct cam_sim *sim, union ccb *ccb)
                         if ((ahd->features & AHD_MULTI_TID) != 0) {
                                 u_int targid_mask;
 
-                                targid_mask = ahd_inb(ahd, TARGID)
-                                            | (ahd_inb(ahd, TARGID + 1) << 8);
-
+                                targid_mask = ahd_inw(ahd, TARGID);
                                 targid_mask |= target_mask;
-                                ahd_outb(ahd, TARGID, targid_mask);
-                                ahd_outb(ahd, TARGID+1, (targid_mask >> 8));
-                                
+                                ahd_outw(ahd, TARGID, targid_mask);
                                 ahd_update_scsiid(ahd, targid_mask);
                         } else {
                                 u_int our_id;
@@ -9543,14 +9601,9 @@ ahd_handle_en_lun(struct ahd_softc *ahd, struct cam_sim *sim, union ccb *ccb)
                                 if (ahd->features & AHD_MULTI_TID) {
                                         u_int targid_mask;
 
-                                        targid_mask = ahd_inb(ahd, TARGID)
-                                                    | (ahd_inb(ahd, TARGID + 1)
-                                                       << 8);
-
+                                        targid_mask = ahd_inw(ahd, TARGID);
                                         targid_mask &= ~target_mask;
-                                        ahd_outb(ahd, TARGID, targid_mask);
-                                        ahd_outb(ahd, TARGID+1,
-                                                 (targid_mask >> 8));
+                                        ahd_outw(ahd, TARGID, targid_mask);
                                         ahd_update_scsiid(ahd, targid_mask);
                                 }
                         }
@@ -9651,7 +9704,7 @@ ahd_run_tqinfifo(struct ahd_softc *ahd, int paused)
 
                 cmd->cmd_valid = 0;
                 ahd_dmamap_sync(ahd, ahd->shared_data_dmat,
-                                ahd->shared_data_dmamap,
+                                ahd->shared_data_map.dmamap,
                                 ahd_targetcmd_offset(ahd, ahd->tqinfifonext),
                                 sizeof(struct target_cmd),
                                 BUS_DMASYNC_PREREAD);
diff --git a/drivers/scsi/aic7xxx/aic79xx_inline.h b/drivers/scsi/aic7xxx/aic79xx_inline.h
index d80bc5161fb1..91c4f7f484b1 100644
--- a/drivers/scsi/aic7xxx/aic79xx_inline.h
+++ b/drivers/scsi/aic7xxx/aic79xx_inline.h
@@ -37,7 +37,7 @@
  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGES.
  *
- * $Id: //depot/aic7xxx/aic7xxx/aic79xx_inline.h#51 $
+ * $Id: //depot/aic7xxx/aic7xxx/aic79xx_inline.h#58 $
  *
  * $FreeBSD$
  */
@@ -522,12 +522,21 @@ do {								\
 static __inline uint16_t
 ahd_inw(struct ahd_softc *ahd, u_int port)
 {
+        /*
+         * Read high byte first as some registers increment
+         * or have other side effects when the low byte is
+         * read.
+         */
         return ((ahd_inb(ahd, port+1) << 8) | ahd_inb(ahd, port));
 }
 
 static __inline void
 ahd_outw(struct ahd_softc *ahd, u_int port, u_int value)
 {
+        /*
+         * Write low byte first to accomodate registers
+         * such as PRGMCNT where the order maters.
+         */
         ahd_outb(ahd, port, value & 0xFF);
         ahd_outb(ahd, port+1, (value >> 8) & 0xFF);
 }
@@ -684,7 +693,7 @@ ahd_inb_scbram(struct ahd_softc *ahd, u_int offset)
          * Razor #528
          */
         value = ahd_inb(ahd, offset);
-        if ((ahd->flags & AHD_PCIX_SCBRAM_RD_BUG) != 0)
+        if ((ahd->bugs & AHD_PCIX_SCBRAM_RD_BUG) != 0)
                 ahd_inb(ahd, MODE_PTR);
         return (value);
 }
@@ -727,7 +736,8 @@ ahd_lookup_scb(struct ahd_softc *ahd, u_int tag)
 static __inline void
 ahd_swap_with_next_hscb(struct ahd_softc *ahd, struct scb *scb)
 {
-        struct hardware_scb *q_hscb;
+        struct   hardware_scb *q_hscb;
+        struct   map_node *q_hscb_map;
         uint32_t saved_hscb_busaddr;
 
         /*
@@ -743,6 +753,7 @@ ahd_swap_with_next_hscb(struct ahd_softc *ahd, struct scb *scb)
          * locate the correct SCB by SCB_TAG.
          */
         q_hscb = ahd->next_queued_hscb;
+        q_hscb_map = ahd->next_queued_hscb_map;
         saved_hscb_busaddr = q_hscb->hscb_busaddr;
         memcpy(q_hscb, scb->hscb, sizeof(*scb->hscb));
         q_hscb->hscb_busaddr = saved_hscb_busaddr;
@@ -750,7 +761,9 @@ ahd_swap_with_next_hscb(struct ahd_softc *ahd, struct scb *scb)
 
         /* Now swap HSCB pointers. */
         ahd->next_queued_hscb = scb->hscb;
+        ahd->next_queued_hscb_map = scb->hscb_map;
         scb->hscb = q_hscb;
+        scb->hscb_map = q_hscb_map;
 
         /* Now define the mapping from tag to SCB in the scbindex */
         ahd->scb_data.scbindex[SCB_GET_TAG(scb)] = scb;
@@ -824,8 +837,9 @@ static __inline int	ahd_intr(struct ahd_softc *ahd);
 static __inline void
 ahd_sync_qoutfifo(struct ahd_softc *ahd, int op)
 {
-        ahd_dmamap_sync(ahd, ahd->shared_data_dmat, ahd->shared_data_dmamap,
-                        /*offset*/0, /*len*/AHC_SCB_MAX * sizeof(uint16_t), op);
+        ahd_dmamap_sync(ahd, ahd->shared_data_dmat, ahd->shared_data_map.dmamap,
+                        /*offset*/0,
+                        /*len*/AHD_SCB_MAX * sizeof(struct ahd_completion), op);
 }
 
 static __inline void
@@ -834,7 +848,7 @@ ahd_sync_tqinfifo(struct ahd_softc *ahd, int op)
 #ifdef AHD_TARGET_MODE
         if ((ahd->flags & AHD_TARGETROLE) != 0) {
                 ahd_dmamap_sync(ahd, ahd->shared_data_dmat,
-                                ahd->shared_data_dmamap,
+                                ahd->shared_data_map.dmamap,
                                 ahd_targetcmd_offset(ahd, 0),
                                 sizeof(struct target_cmd) * AHD_TMODE_CMDS,
                                 op);
@@ -854,17 +868,17 @@ ahd_check_cmdcmpltqueues(struct ahd_softc *ahd)
         u_int retval;
 
         retval = 0;
-        ahd_dmamap_sync(ahd, ahd->shared_data_dmat, ahd->shared_data_dmamap,
-                        /*offset*/ahd->qoutfifonext, /*len*/2,
-                        BUS_DMASYNC_POSTREAD);
-        if ((ahd->qoutfifo[ahd->qoutfifonext]
-             & QOUTFIFO_ENTRY_VALID_LE) == ahd->qoutfifonext_valid_tag)
+        ahd_dmamap_sync(ahd, ahd->shared_data_dmat, ahd->shared_data_map.dmamap,
+                        /*offset*/ahd->qoutfifonext * sizeof(*ahd->qoutfifo),
+                        /*len*/sizeof(*ahd->qoutfifo), BUS_DMASYNC_POSTREAD);
+        if (ahd->qoutfifo[ahd->qoutfifonext].valid_tag
+          == ahd->qoutfifonext_valid_tag)
                 retval |= AHD_RUN_QOUTFIFO;
 #ifdef AHD_TARGET_MODE
         if ((ahd->flags & AHD_TARGETROLE) != 0
          && (ahd->flags & AHD_TQINFIFO_BLOCKED) == 0) {
                 ahd_dmamap_sync(ahd, ahd->shared_data_dmat,
-                                ahd->shared_data_dmamap,
+                                ahd->shared_data_map.dmamap,
                                 ahd_targetcmd_offset(ahd, ahd->tqinfifofnext),
                                 /*len*/sizeof(struct target_cmd),
                                 BUS_DMASYNC_POSTREAD);
diff --git a/drivers/scsi/aic7xxx/aic79xx_osm.c b/drivers/scsi/aic7xxx/aic79xx_osm.c
index 1c8f872e2dd4..2567e29960bd 100644
--- a/drivers/scsi/aic7xxx/aic79xx_osm.c
+++ b/drivers/scsi/aic7xxx/aic79xx_osm.c
@@ -1468,6 +1468,30 @@ ahd_linux_run_command(struct ahd_softc *ahd, struct ahd_linux_device *dev,
         if ((tstate->auto_negotiate & mask) != 0) {
                 scb->flags |= SCB_AUTO_NEGOTIATE;
                 scb->hscb->control |= MK_MESSAGE;
+                } else if (cmd->cmnd[0] == INQUIRY
+                        && (tinfo->curr.offset != 0
+                         || tinfo->curr.width != MSG_EXT_WDTR_BUS_8_BIT
+                         || tinfo->curr.ppr_options != 0)
+                        && (tinfo->curr.ppr_options & MSG_EXT_PPR_IU_REQ)==0) {
+                        /*
+                         * The SCSI spec requires inquiry
+                         * commands to complete without
+                         * reporting unit attention conditions.
+                         * Because of this, an inquiry command
+                         * that occurs just after a device is
+                         * reset will result in a data phase
+                         * with mismatched negotiated rates.
+                         * The core already forces a renegotiation
+                         * for reset events that are visible to
+                         * our controller or that we initiate,
+                         * but a third party device reset or a
+                         * hot-plug insertion can still cause this
+                         * issue.  Therefore, we force a re-negotiation
+                         * for every inquiry command unless we
+                         * are async.
+                         */
+                        scb->flags |= SCB_NEGOTIATE;
+                        scb->hscb->control |= MK_MESSAGE;
         }
 
         if ((dev->flags & (AHD_DEV_Q_TAGGED|AHD_DEV_Q_BASIC)) != 0) {
@@ -2058,6 +2082,7 @@ ahd_linux_queue_recovery_cmd(struct scsi_cmnd *cmd, scb_flag flag)
         int    paused;
         int    wait;
         int    disconnected;
+        int    found;
         ahd_mode_state saved_modes;
         unsigned long flags;
 
@@ -2176,7 +2201,8 @@ ahd_linux_queue_recovery_cmd(struct scsi_cmnd *cmd, scb_flag flag)
         last_phase = ahd_inb(ahd, LASTPHASE);
         saved_scbptr = ahd_get_scbptr(ahd);
         active_scbptr = saved_scbptr;
-        if (disconnected && (ahd_inb(ahd, SEQ_FLAGS) & NOT_IDENTIFIED) == 0) {
+        if (disconnected && ((last_phase != P_BUSFREE) || 
+                             (ahd_inb(ahd, SEQ_FLAGS) & NOT_IDENTIFIED) == 0)) {
                 struct scb *bus_scb;
 
                 bus_scb = ahd_lookup_scb(ahd, active_scbptr);
@@ -2194,28 +2220,41 @@ ahd_linux_queue_recovery_cmd(struct scsi_cmnd *cmd, scb_flag flag)
          * bus or is in the disconnected state.
          */
         saved_scsiid = ahd_inb(ahd, SAVED_SCSIID);
-        if (last_phase != P_BUSFREE
-         && (SCB_GET_TAG(pending_scb) == active_scbptr
+        if (SCB_GET_TAG(pending_scb) == active_scbptr
              || (flag == SCB_DEVICE_RESET
-                 && SCSIID_TARGET(ahd, saved_scsiid) == scmd_id(cmd)))) {
+                 && SCSIID_TARGET(ahd, saved_scsiid) == scmd_id(cmd))) {
 
                 /*
                  * We're active on the bus, so assert ATN
                  * and hope that the target responds.
                  */
                 pending_scb = ahd_lookup_scb(ahd, active_scbptr);
-                pending_scb->flags |= SCB_RECOVERY_SCB|flag;
+                pending_scb->flags |= SCB_RECOVERY_SCB|SCB_DEVICE_RESET;
                 ahd_outb(ahd, MSG_OUT, HOST_MSG);
                 ahd_outb(ahd, SCSISIGO, last_phase|ATNO);
-                scmd_printk(KERN_INFO, cmd, "Device is active, asserting ATN\n");
+                scmd_printk(KERN_INFO, cmd, "BDR message in message buffer\n");
                 wait = TRUE;
+        } else if (last_phase != P_BUSFREE
+                   && ahd_inb(ahd, SCSIPHASE) == 0) {
+                /*
+                 * SCB is not identified, there
+                 * is no pending REQ, and the sequencer
+                 * has not seen a busfree.  Looks like
+                 * a stuck connection waiting to
+                 * go busfree.  Reset the bus.
+                 */
+                found = ahd_reset_channel(ahd, cmd->device->channel + 'A',
+                                          /*Initiate Reset*/TRUE);
+                printf("%s: Issued Channel %c Bus Reset. "
+                       "%d SCBs aborted\n", ahd_name(ahd),
+                       cmd->device->channel + 'A', found);
         } else if (disconnected) {
 
                 /*
                  * Actually re-queue this SCB in an attempt
                  * to select the device before it reconnects.
                  */
-                pending_scb->flags |= SCB_RECOVERY_SCB|SCB_ABORT;
+                pending_scb->flags |= SCB_RECOVERY_SCB|flag;
                 ahd_set_scbptr(ahd, SCB_GET_TAG(pending_scb));
                 pending_scb->hscb->cdb_len = 0;
                 pending_scb->hscb->task_attribute = 0;
@@ -2296,16 +2335,17 @@ done:
                 timer.expires = jiffies + (5 * HZ);
                 timer.function = ahd_linux_sem_timeout;
                 add_timer(&timer);
-                printf("Recovery code sleeping\n");
+                printf("%s: Recovery code sleeping\n", ahd_name(ahd));
                 down(&ahd->platform_data->eh_sem);
-                printf("Recovery code awake\n");
+                printf("%s: Recovery code awake\n", ahd_name(ahd));
                 ret = del_timer_sync(&timer);
                 if (ret == 0) {
-                        printf("Timer Expired\n");
+                        printf("%s: Timer Expired (active %d)\n",
+                               ahd_name(ahd), dev->active);
                         retval = FAILED;
                 }
         }
-                ahd_unlock(ahd, &flags);
+        ahd_unlock(ahd, &flags);
         return (retval);
 }
 
diff --git a/drivers/scsi/aic7xxx/aic79xx_osm.h b/drivers/scsi/aic7xxx/aic79xx_osm.h
index bc44222d6cc3..cb74fccc8100 100644
--- a/drivers/scsi/aic7xxx/aic79xx_osm.h
+++ b/drivers/scsi/aic7xxx/aic79xx_osm.h
@@ -252,7 +252,7 @@ ahd_scb_timer_reset(struct scb *scb, u_int usec)
 /***************************** SMP support ************************************/
 #include <linux/spinlock.h>
 
-#define AIC79XX_DRIVER_VERSION "1.3.11"
+#define AIC79XX_DRIVER_VERSION "3.0"
 
 /*************************** Device Data Structures ***************************/
 /*
diff --git a/drivers/scsi/aic7xxx/aic79xx_pci.c b/drivers/scsi/aic7xxx/aic79xx_pci.c
index 2131db60018a..196a6344b037 100644
--- a/drivers/scsi/aic7xxx/aic79xx_pci.c
+++ b/drivers/scsi/aic7xxx/aic79xx_pci.c
@@ -38,9 +38,7 @@
  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGES.
  *
- * $Id: //depot/aic7xxx/aic7xxx/aic79xx_pci.c#77 $
- *
- * $FreeBSD$
+ * $Id: //depot/aic7xxx/aic7xxx/aic79xx_pci.c#89 $
  */
 
 #ifdef __linux__
@@ -114,6 +112,13 @@ struct ahd_pci_identity ahd_pci_ident_table [] =
                 "Adaptec 29320ALP Ultra320 SCSI adapter",
                 ahd_aic7901_setup
         },
+        /* aic7901A based controllers */
+        {
+                ID_AHA_29320LP,
+                ID_ALL_MASK,
+                "Adaptec 29320LP Ultra320 SCSI adapter",
+                ahd_aic7901A_setup
+        },
         /* aic7902 based controllers */ 
         {
                 ID_AHA_29320,
@@ -128,12 +133,6 @@ struct ahd_pci_identity ahd_pci_ident_table [] =
                 ahd_aic7902_setup
         },
         {
-                ID_AHA_29320LP,
-                ID_ALL_MASK,
-                "Adaptec 29320LP Ultra320 SCSI adapter",
-                ahd_aic7901A_setup
-        },
-        {
                 ID_AHA_39320,
                 ID_ALL_MASK,
                 "Adaptec 39320 Ultra320 SCSI adapter",
@@ -146,6 +145,12 @@ struct ahd_pci_identity ahd_pci_ident_table [] =
                 ahd_aic7902_setup
         },
         {
+                ID_AHA_39320_B_DELL,
+                ID_ALL_MASK,
+                "Adaptec (Dell OEM) 39320 Ultra320 SCSI adapter",
+                ahd_aic7902_setup
+        },
+        {
                 ID_AHA_39320A,
                 ID_ALL_MASK,
                 "Adaptec 39320A Ultra320 SCSI adapter",
@@ -668,6 +673,7 @@ ahd_configure_termination(struct ahd_softc *ahd, u_int adapter_control)
          * Now set the termination based on what we found.
          */
         sxfrctl1 = ahd_inb(ahd, SXFRCTL1) & ~STPWEN;
+        ahd->flags &= ~AHD_TERM_ENB_A;
         if ((termctl & FLX_TERMCTL_ENPRILOW) != 0) {
                 ahd->flags |= AHD_TERM_ENB_A;
                 sxfrctl1 |= STPWEN;
diff --git a/drivers/scsi/aic7xxx/aic79xx_pci.h b/drivers/scsi/aic7xxx/aic79xx_pci.h
index b5cfeabdfecf..da45153668c7 100644
--- a/drivers/scsi/aic7xxx/aic79xx_pci.h
+++ b/drivers/scsi/aic7xxx/aic79xx_pci.h
@@ -53,14 +53,15 @@
 #define ID_AHA_29320ALP                 0x8017900500449005ull
 
 #define ID_AIC7901A                     0x801E9005FFFF9005ull
-#define ID_AHA_29320                    0x8012900500429005ull
-#define ID_AHA_29320B                   0x8013900500439005ull
 #define ID_AHA_29320LP                  0x8014900500449005ull
 
 #define ID_AIC7902                      0x801F9005FFFF9005ull
 #define ID_AIC7902_B                    0x801D9005FFFF9005ull
 #define ID_AHA_39320                    0x8010900500409005ull
+#define ID_AHA_29320                    0x8012900500429005ull
+#define ID_AHA_29320B                   0x8013900500439005ull
 #define ID_AHA_39320_B                  0x8015900500409005ull
+#define ID_AHA_39320_B_DELL             0x8015900501681028ull
 #define ID_AHA_39320A                   0x8016900500409005ull
 #define ID_AHA_39320D                   0x8011900500419005ull
 #define ID_AHA_39320D_B                 0x801C900500419005ull
diff --git a/drivers/scsi/aic7xxx/aic79xx_reg.h_shipped b/drivers/scsi/aic7xxx/aic79xx_reg.h_shipped
index c01ac39090d9..8763b158856b 100644
--- a/drivers/scsi/aic7xxx/aic79xx_reg.h_shipped
+++ b/drivers/scsi/aic7xxx/aic79xx_reg.h_shipped
@@ -2,8 +2,8 @@
  * DO NOT EDIT - This file is automatically generated
  *               from the following source files:
  *
- * $Id: //depot/aic7xxx/aic7xxx/aic79xx.seq#94 $
- * $Id: //depot/aic7xxx/aic7xxx/aic79xx.reg#70 $
+ * $Id: //depot/aic7xxx/aic7xxx/aic79xx.seq#119 $
+ * $Id: //depot/aic7xxx/aic7xxx/aic79xx.reg#76 $
  */
 typedef int (ahd_reg_print_t)(u_int, u_int *, u_int);
 typedef struct ahd_reg_parse_entry {
@@ -83,17 +83,17 @@ ahd_reg_print_t ahd_hs_mailbox_print;
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_clrseqintstat_print;
+ahd_reg_print_t ahd_seqintstat_print;
 #else
-#define ahd_clrseqintstat_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "CLRSEQINTSTAT", 0x0c, regvalue, cur_col, wrap)
+#define ahd_seqintstat_print(regvalue, cur_col, wrap) \
+    ahd_print_register(NULL, 0, "SEQINTSTAT", 0x0c, regvalue, cur_col, wrap)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_seqintstat_print;
+ahd_reg_print_t ahd_clrseqintstat_print;
 #else
-#define ahd_seqintstat_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "SEQINTSTAT", 0x0c, regvalue, cur_col, wrap)
+#define ahd_clrseqintstat_print(regvalue, cur_col, wrap) \
+    ahd_print_register(NULL, 0, "CLRSEQINTSTAT", 0x0c, regvalue, cur_col, wrap)
 #endif
 
 #if AIC_DEBUG_REGISTERS
@@ -412,17 +412,17 @@ ahd_reg_print_t ahd_sxfrctl0_print;
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_businitid_print;
+ahd_reg_print_t ahd_dlcount_print;
 #else
-#define ahd_businitid_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "BUSINITID", 0x3c, regvalue, cur_col, wrap)
+#define ahd_dlcount_print(regvalue, cur_col, wrap) \
+    ahd_print_register(NULL, 0, "DLCOUNT", 0x3c, regvalue, cur_col, wrap)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_dlcount_print;
+ahd_reg_print_t ahd_businitid_print;
 #else
-#define ahd_dlcount_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "DLCOUNT", 0x3c, regvalue, cur_col, wrap)
+#define ahd_businitid_print(regvalue, cur_col, wrap) \
+    ahd_print_register(NULL, 0, "BUSINITID", 0x3c, regvalue, cur_col, wrap)
 #endif
 
 #if AIC_DEBUG_REGISTERS
@@ -517,13 +517,6 @@ ahd_reg_print_t ahd_selid_print;
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_sblkctl_print;
-#else
-#define ahd_sblkctl_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "SBLKCTL", 0x4a, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
 ahd_reg_print_t ahd_optionmode_print;
 #else
 #define ahd_optionmode_print(regvalue, cur_col, wrap) \
@@ -531,10 +524,10 @@ ahd_reg_print_t ahd_optionmode_print;
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_sstat0_print;
+ahd_reg_print_t ahd_sblkctl_print;
 #else
-#define ahd_sstat0_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "SSTAT0", 0x4b, regvalue, cur_col, wrap)
+#define ahd_sblkctl_print(regvalue, cur_col, wrap) \
+    ahd_print_register(NULL, 0, "SBLKCTL", 0x4a, regvalue, cur_col, wrap)
 #endif
 
 #if AIC_DEBUG_REGISTERS
@@ -545,6 +538,13 @@ ahd_reg_print_t ahd_clrsint0_print;
 #endif
 
 #if AIC_DEBUG_REGISTERS
+ahd_reg_print_t ahd_sstat0_print;
+#else
+#define ahd_sstat0_print(regvalue, cur_col, wrap) \
+    ahd_print_register(NULL, 0, "SSTAT0", 0x4b, regvalue, cur_col, wrap)
+#endif
+
+#if AIC_DEBUG_REGISTERS
 ahd_reg_print_t ahd_simode0_print;
 #else
 #define ahd_simode0_print(regvalue, cur_col, wrap) \
@@ -573,17 +573,17 @@ ahd_reg_print_t ahd_sstat2_print;
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_clrsint2_print;
+ahd_reg_print_t ahd_simode2_print;
 #else
-#define ahd_clrsint2_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "CLRSINT2", 0x4d, regvalue, cur_col, wrap)
+#define ahd_simode2_print(regvalue, cur_col, wrap) \
+    ahd_print_register(NULL, 0, "SIMODE2", 0x4d, regvalue, cur_col, wrap)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_simode2_print;
+ahd_reg_print_t ahd_clrsint2_print;
 #else
-#define ahd_simode2_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "SIMODE2", 0x4d, regvalue, cur_col, wrap)
+#define ahd_clrsint2_print(regvalue, cur_col, wrap) \
+    ahd_print_register(NULL, 0, "CLRSINT2", 0x4d, regvalue, cur_col, wrap)
 #endif
 
 #if AIC_DEBUG_REGISTERS
@@ -685,13 +685,6 @@ ahd_reg_print_t ahd_clrsint3_print;
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_lqomode0_print;
-#else
-#define ahd_lqomode0_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "LQOMODE0", 0x54, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
 ahd_reg_print_t ahd_lqostat0_print;
 #else
 #define ahd_lqostat0_print(regvalue, cur_col, wrap) \
@@ -706,6 +699,20 @@ ahd_reg_print_t ahd_clrlqoint0_print;
 #endif
 
 #if AIC_DEBUG_REGISTERS
+ahd_reg_print_t ahd_lqomode0_print;
+#else
+#define ahd_lqomode0_print(regvalue, cur_col, wrap) \
+    ahd_print_register(NULL, 0, "LQOMODE0", 0x54, regvalue, cur_col, wrap)
+#endif
+
+#if AIC_DEBUG_REGISTERS
+ahd_reg_print_t ahd_lqomode1_print;
+#else
+#define ahd_lqomode1_print(regvalue, cur_col, wrap) \
+    ahd_print_register(NULL, 0, "LQOMODE1", 0x55, regvalue, cur_col, wrap)
+#endif
+
+#if AIC_DEBUG_REGISTERS
 ahd_reg_print_t ahd_lqostat1_print;
 #else
 #define ahd_lqostat1_print(regvalue, cur_col, wrap) \
@@ -720,13 +727,6 @@ ahd_reg_print_t ahd_clrlqoint1_print;
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_lqomode1_print;
-#else
-#define ahd_lqomode1_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "LQOMODE1", 0x55, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
 ahd_reg_print_t ahd_lqostat2_print;
 #else
 #define ahd_lqostat2_print(regvalue, cur_col, wrap) \
@@ -909,17 +909,17 @@ ahd_reg_print_t ahd_annexcol_print;
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_scschkn_print;
+ahd_reg_print_t ahd_annexdat_print;
 #else
-#define ahd_scschkn_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "SCSCHKN", 0x66, regvalue, cur_col, wrap)
+#define ahd_annexdat_print(regvalue, cur_col, wrap) \
+    ahd_print_register(NULL, 0, "ANNEXDAT", 0x66, regvalue, cur_col, wrap)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_annexdat_print;
+ahd_reg_print_t ahd_scschkn_print;
 #else
-#define ahd_annexdat_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "ANNEXDAT", 0x66, regvalue, cur_col, wrap)
+#define ahd_scschkn_print(regvalue, cur_col, wrap) \
+    ahd_print_register(NULL, 0, "SCSCHKN", 0x66, regvalue, cur_col, wrap)
 #endif
 
 #if AIC_DEBUG_REGISTERS
@@ -1000,17 +1000,17 @@ ahd_reg_print_t ahd_pll400ctl1_print;
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_pll400cnt0_print;
+ahd_reg_print_t ahd_unfairness_print;
 #else
-#define ahd_pll400cnt0_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "PLL400CNT0", 0x6e, regvalue, cur_col, wrap)
+#define ahd_unfairness_print(regvalue, cur_col, wrap) \
+    ahd_print_register(NULL, 0, "UNFAIRNESS", 0x6e, regvalue, cur_col, wrap)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_unfairness_print;
+ahd_reg_print_t ahd_pll400cnt0_print;
 #else
-#define ahd_unfairness_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "UNFAIRNESS", 0x6e, regvalue, cur_col, wrap)
+#define ahd_pll400cnt0_print(regvalue, cur_col, wrap) \
+    ahd_print_register(NULL, 0, "PLL400CNT0", 0x6e, regvalue, cur_col, wrap)
 #endif
 
 #if AIC_DEBUG_REGISTERS
@@ -1056,13 +1056,6 @@ ahd_reg_print_t ahd_hodmaen_print;
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_sghaddr_print;
-#else
-#define ahd_sghaddr_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "SGHADDR", 0x7c, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
 ahd_reg_print_t ahd_scbhaddr_print;
 #else
 #define ahd_scbhaddr_print(regvalue, cur_col, wrap) \
@@ -1070,10 +1063,10 @@ ahd_reg_print_t ahd_scbhaddr_print;
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_sghcnt_print;
+ahd_reg_print_t ahd_sghaddr_print;
 #else
-#define ahd_sghcnt_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "SGHCNT", 0x84, regvalue, cur_col, wrap)
+#define ahd_sghaddr_print(regvalue, cur_col, wrap) \
+    ahd_print_register(NULL, 0, "SGHADDR", 0x7c, regvalue, cur_col, wrap)
 #endif
 
 #if AIC_DEBUG_REGISTERS
@@ -1084,6 +1077,13 @@ ahd_reg_print_t ahd_scbhcnt_print;
 #endif
 
 #if AIC_DEBUG_REGISTERS
+ahd_reg_print_t ahd_sghcnt_print;
+#else
+#define ahd_sghcnt_print(regvalue, cur_col, wrap) \
+    ahd_print_register(NULL, 0, "SGHCNT", 0x84, regvalue, cur_col, wrap)
+#endif
+
+#if AIC_DEBUG_REGISTERS
 ahd_reg_print_t ahd_dff_thrsh_print;
 #else
 #define ahd_dff_thrsh_print(regvalue, cur_col, wrap) \
@@ -1154,13 +1154,6 @@ ahd_reg_print_t ahd_nsenable_print;
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_dchrxmsg1_print;
-#else
-#define ahd_dchrxmsg1_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "DCHRXMSG1", 0x91, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
 ahd_reg_print_t ahd_cmcrxmsg1_print;
 #else
 #define ahd_cmcrxmsg1_print(regvalue, cur_col, wrap) \
@@ -1168,17 +1161,17 @@ ahd_reg_print_t ahd_cmcrxmsg1_print;
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_dchrxmsg2_print;
+ahd_reg_print_t ahd_dchrxmsg1_print;
 #else
-#define ahd_dchrxmsg2_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "DCHRXMSG2", 0x92, regvalue, cur_col, wrap)
+#define ahd_dchrxmsg1_print(regvalue, cur_col, wrap) \
+    ahd_print_register(NULL, 0, "DCHRXMSG1", 0x91, regvalue, cur_col, wrap)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_ovlyrxmsg2_print;
+ahd_reg_print_t ahd_dchrxmsg2_print;
 #else
-#define ahd_ovlyrxmsg2_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "OVLYRXMSG2", 0x92, regvalue, cur_col, wrap)
+#define ahd_dchrxmsg2_print(regvalue, cur_col, wrap) \
+    ahd_print_register(NULL, 0, "DCHRXMSG2", 0x92, regvalue, cur_col, wrap)
 #endif
 
 #if AIC_DEBUG_REGISTERS
@@ -1196,6 +1189,13 @@ ahd_reg_print_t ahd_ost_print;
 #endif
 
 #if AIC_DEBUG_REGISTERS
+ahd_reg_print_t ahd_ovlyrxmsg2_print;
+#else
+#define ahd_ovlyrxmsg2_print(regvalue, cur_col, wrap) \
+    ahd_print_register(NULL, 0, "OVLYRXMSG2", 0x92, regvalue, cur_col, wrap)
+#endif
+
+#if AIC_DEBUG_REGISTERS
 ahd_reg_print_t ahd_dchrxmsg3_print;
 #else
 #define ahd_dchrxmsg3_print(regvalue, cur_col, wrap) \
@@ -1203,6 +1203,13 @@ ahd_reg_print_t ahd_dchrxmsg3_print;
 #endif
 
 #if AIC_DEBUG_REGISTERS
+ahd_reg_print_t ahd_ovlyrxmsg3_print;
+#else
+#define ahd_ovlyrxmsg3_print(regvalue, cur_col, wrap) \
+    ahd_print_register(NULL, 0, "OVLYRXMSG3", 0x93, regvalue, cur_col, wrap)
+#endif
+
+#if AIC_DEBUG_REGISTERS
 ahd_reg_print_t ahd_cmcrxmsg3_print;
 #else
 #define ahd_cmcrxmsg3_print(regvalue, cur_col, wrap) \
@@ -1217,13 +1224,6 @@ ahd_reg_print_t ahd_pcixctl_print;
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_ovlyrxmsg3_print;
-#else
-#define ahd_ovlyrxmsg3_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "OVLYRXMSG3", 0x93, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
 ahd_reg_print_t ahd_ovlyseqbcnt_print;
 #else
 #define ahd_ovlyseqbcnt_print(regvalue, cur_col, wrap) \
@@ -1231,13 +1231,6 @@ ahd_reg_print_t ahd_ovlyseqbcnt_print;
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_cmcseqbcnt_print;
-#else
-#define ahd_cmcseqbcnt_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "CMCSEQBCNT", 0x94, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
 ahd_reg_print_t ahd_dchseqbcnt_print;
 #else
 #define ahd_dchseqbcnt_print(regvalue, cur_col, wrap) \
@@ -1245,17 +1238,17 @@ ahd_reg_print_t ahd_dchseqbcnt_print;
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_cmcspltstat0_print;
+ahd_reg_print_t ahd_cmcseqbcnt_print;
 #else
-#define ahd_cmcspltstat0_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "CMCSPLTSTAT0", 0x96, regvalue, cur_col, wrap)
+#define ahd_cmcseqbcnt_print(regvalue, cur_col, wrap) \
+    ahd_print_register(NULL, 0, "CMCSEQBCNT", 0x94, regvalue, cur_col, wrap)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_ovlyspltstat0_print;
+ahd_reg_print_t ahd_cmcspltstat0_print;
 #else
-#define ahd_ovlyspltstat0_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "OVLYSPLTSTAT0", 0x96, regvalue, cur_col, wrap)
+#define ahd_cmcspltstat0_print(regvalue, cur_col, wrap) \
+    ahd_print_register(NULL, 0, "CMCSPLTSTAT0", 0x96, regvalue, cur_col, wrap)
 #endif
 
 #if AIC_DEBUG_REGISTERS
@@ -1266,10 +1259,10 @@ ahd_reg_print_t ahd_dchspltstat0_print;
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_dchspltstat1_print;
+ahd_reg_print_t ahd_ovlyspltstat0_print;
 #else
-#define ahd_dchspltstat1_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "DCHSPLTSTAT1", 0x97, regvalue, cur_col, wrap)
+#define ahd_ovlyspltstat0_print(regvalue, cur_col, wrap) \
+    ahd_print_register(NULL, 0, "OVLYSPLTSTAT0", 0x96, regvalue, cur_col, wrap)
 #endif
 
 #if AIC_DEBUG_REGISTERS
@@ -1287,6 +1280,13 @@ ahd_reg_print_t ahd_ovlyspltstat1_print;
 #endif
 
 #if AIC_DEBUG_REGISTERS
+ahd_reg_print_t ahd_dchspltstat1_print;
+#else
+#define ahd_dchspltstat1_print(regvalue, cur_col, wrap) \
+    ahd_print_register(NULL, 0, "DCHSPLTSTAT1", 0x97, regvalue, cur_col, wrap)
+#endif
+
+#if AIC_DEBUG_REGISTERS
 ahd_reg_print_t ahd_sgrxmsg0_print;
 #else
 #define ahd_sgrxmsg0_print(regvalue, cur_col, wrap) \
@@ -1378,17 +1378,17 @@ ahd_reg_print_t ahd_sgspltstat0_print;
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_sfunct_print;
+ahd_reg_print_t ahd_sgspltstat1_print;
 #else
-#define ahd_sfunct_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "SFUNCT", 0x9f, regvalue, cur_col, wrap)
+#define ahd_sgspltstat1_print(regvalue, cur_col, wrap) \
+    ahd_print_register(NULL, 0, "SGSPLTSTAT1", 0x9f, regvalue, cur_col, wrap)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_sgspltstat1_print;
+ahd_reg_print_t ahd_sfunct_print;
 #else
-#define ahd_sgspltstat1_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "SGSPLTSTAT1", 0x9f, regvalue, cur_col, wrap)
+#define ahd_sfunct_print(regvalue, cur_col, wrap) \
+    ahd_print_register(NULL, 0, "SFUNCT", 0x9f, regvalue, cur_col, wrap)
 #endif
 
 #if AIC_DEBUG_REGISTERS
@@ -1504,17 +1504,17 @@ ahd_reg_print_t ahd_ccsgaddr_print;
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_ccscbaddr_print;
+ahd_reg_print_t ahd_ccscbadr_bk_print;
 #else
-#define ahd_ccscbaddr_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "CCSCBADDR", 0xac, regvalue, cur_col, wrap)
+#define ahd_ccscbadr_bk_print(regvalue, cur_col, wrap) \
+    ahd_print_register(NULL, 0, "CCSCBADR_BK", 0xac, regvalue, cur_col, wrap)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_ccscbadr_bk_print;
+ahd_reg_print_t ahd_ccscbaddr_print;
 #else
-#define ahd_ccscbadr_bk_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "CCSCBADR_BK", 0xac, regvalue, cur_col, wrap)
+#define ahd_ccscbaddr_print(regvalue, cur_col, wrap) \
+    ahd_print_register(NULL, 0, "CCSCBADDR", 0xac, regvalue, cur_col, wrap)
 #endif
 
 #if AIC_DEBUG_REGISTERS
@@ -1525,17 +1525,17 @@ ahd_reg_print_t ahd_cmc_rambist_print;
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_ccsgctl_print;
+ahd_reg_print_t ahd_ccscbctl_print;
 #else
-#define ahd_ccsgctl_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "CCSGCTL", 0xad, regvalue, cur_col, wrap)
+#define ahd_ccscbctl_print(regvalue, cur_col, wrap) \
+    ahd_print_register(NULL, 0, "CCSCBCTL", 0xad, regvalue, cur_col, wrap)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_ccscbctl_print;
+ahd_reg_print_t ahd_ccsgctl_print;
 #else
-#define ahd_ccscbctl_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "CCSCBCTL", 0xad, regvalue, cur_col, wrap)
+#define ahd_ccsgctl_print(regvalue, cur_col, wrap) \
+    ahd_print_register(NULL, 0, "CCSGCTL", 0xad, regvalue, cur_col, wrap)
 #endif
 
 #if AIC_DEBUG_REGISTERS
@@ -1707,13 +1707,6 @@ ahd_reg_print_t ahd_wrtbiascalc_print;
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_dfptrs_print;
-#else
-#define ahd_dfptrs_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "DFPTRS", 0xc8, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
 ahd_reg_print_t ahd_rcvrbiascalc_print;
 #else
 #define ahd_rcvrbiascalc_print(regvalue, cur_col, wrap) \
@@ -1721,10 +1714,10 @@ ahd_reg_print_t ahd_rcvrbiascalc_print;
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_dfbkptr_print;
+ahd_reg_print_t ahd_dfptrs_print;
 #else
-#define ahd_dfbkptr_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "DFBKPTR", 0xc9, regvalue, cur_col, wrap)
+#define ahd_dfptrs_print(regvalue, cur_col, wrap) \
+    ahd_print_register(NULL, 0, "DFPTRS", 0xc8, regvalue, cur_col, wrap)
 #endif
 
 #if AIC_DEBUG_REGISTERS
@@ -1735,6 +1728,13 @@ ahd_reg_print_t ahd_skewcalc_print;
 #endif
 
 #if AIC_DEBUG_REGISTERS
+ahd_reg_print_t ahd_dfbkptr_print;
+#else
+#define ahd_dfbkptr_print(regvalue, cur_col, wrap) \
+    ahd_print_register(NULL, 0, "DFBKPTR", 0xc9, regvalue, cur_col, wrap)
+#endif
+
+#if AIC_DEBUG_REGISTERS
 ahd_reg_print_t ahd_dfdbctl_print;
 #else
 #define ahd_dfdbctl_print(regvalue, cur_col, wrap) \
@@ -1826,17 +1826,17 @@ ahd_reg_print_t ahd_dindex_print;
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_brkaddr1_print;
+ahd_reg_print_t ahd_brkaddr0_print;
 #else
-#define ahd_brkaddr1_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "BRKADDR1", 0xe6, regvalue, cur_col, wrap)
+#define ahd_brkaddr0_print(regvalue, cur_col, wrap) \
+    ahd_print_register(NULL, 0, "BRKADDR0", 0xe6, regvalue, cur_col, wrap)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_brkaddr0_print;
+ahd_reg_print_t ahd_brkaddr1_print;
 #else
-#define ahd_brkaddr0_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "BRKADDR0", 0xe6, regvalue, cur_col, wrap)
+#define ahd_brkaddr1_print(regvalue, cur_col, wrap) \
+    ahd_print_register(NULL, 0, "BRKADDR1", 0xe6, regvalue, cur_col, wrap)
 #endif
 
 #if AIC_DEBUG_REGISTERS
@@ -1889,13 +1889,6 @@ ahd_reg_print_t ahd_stack_print;
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_curaddr_print;
-#else
-#define ahd_curaddr_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "CURADDR", 0xf4, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
 ahd_reg_print_t ahd_intvec1_addr_print;
 #else
 #define ahd_intvec1_addr_print(regvalue, cur_col, wrap) \
@@ -1903,10 +1896,10 @@ ahd_reg_print_t ahd_intvec1_addr_print;
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_intvec2_addr_print;
+ahd_reg_print_t ahd_curaddr_print;
 #else
-#define ahd_intvec2_addr_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "INTVEC2_ADDR", 0xf6, regvalue, cur_col, wrap)
+#define ahd_curaddr_print(regvalue, cur_col, wrap) \
+    ahd_print_register(NULL, 0, "CURADDR", 0xf4, regvalue, cur_col, wrap)
 #endif
 
 #if AIC_DEBUG_REGISTERS
@@ -1917,6 +1910,13 @@ ahd_reg_print_t ahd_lastaddr_print;
 #endif
 
 #if AIC_DEBUG_REGISTERS
+ahd_reg_print_t ahd_intvec2_addr_print;
+#else
+#define ahd_intvec2_addr_print(regvalue, cur_col, wrap) \
+    ahd_print_register(NULL, 0, "INTVEC2_ADDR", 0xf6, regvalue, cur_col, wrap)
+#endif
+
+#if AIC_DEBUG_REGISTERS
 ahd_reg_print_t ahd_longjmp_addr_print;
 #else
 #define ahd_longjmp_addr_print(regvalue, cur_col, wrap) \
@@ -1994,192 +1994,213 @@ ahd_reg_print_t ahd_complete_dma_scb_head_print;
 #endif
 
 #if AIC_DEBUG_REGISTERS
+ahd_reg_print_t ahd_complete_dma_scb_tail_print;
+#else
+#define ahd_complete_dma_scb_tail_print(regvalue, cur_col, wrap) \
+    ahd_print_register(NULL, 0, "COMPLETE_DMA_SCB_TAIL", 0x12e, regvalue, cur_col, wrap)
+#endif
+
+#if AIC_DEBUG_REGISTERS
+ahd_reg_print_t ahd_complete_on_qfreeze_head_print;
+#else
+#define ahd_complete_on_qfreeze_head_print(regvalue, cur_col, wrap) \
+    ahd_print_register(NULL, 0, "COMPLETE_ON_QFREEZE_HEAD", 0x130, regvalue, cur_col, wrap)
+#endif
+
+#if AIC_DEBUG_REGISTERS
 ahd_reg_print_t ahd_qfreeze_count_print;
 #else
 #define ahd_qfreeze_count_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "QFREEZE_COUNT", 0x12e, regvalue, cur_col, wrap)
+    ahd_print_register(NULL, 0, "QFREEZE_COUNT", 0x132, regvalue, cur_col, wrap)
+#endif
+
+#if AIC_DEBUG_REGISTERS
+ahd_reg_print_t ahd_kernel_qfreeze_count_print;
+#else
+#define ahd_kernel_qfreeze_count_print(regvalue, cur_col, wrap) \
+    ahd_print_register(NULL, 0, "KERNEL_QFREEZE_COUNT", 0x134, regvalue, cur_col, wrap)
 #endif
 
 #if AIC_DEBUG_REGISTERS
 ahd_reg_print_t ahd_saved_mode_print;
 #else
 #define ahd_saved_mode_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "SAVED_MODE", 0x130, regvalue, cur_col, wrap)
+    ahd_print_register(NULL, 0, "SAVED_MODE", 0x136, regvalue, cur_col, wrap)
 #endif
 
 #if AIC_DEBUG_REGISTERS
 ahd_reg_print_t ahd_msg_out_print;
 #else
 #define ahd_msg_out_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "MSG_OUT", 0x131, regvalue, cur_col, wrap)
+    ahd_print_register(NULL, 0, "MSG_OUT", 0x137, regvalue, cur_col, wrap)
 #endif
 
 #if AIC_DEBUG_REGISTERS
 ahd_reg_print_t ahd_dmaparams_print;
 #else
 #define ahd_dmaparams_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "DMAPARAMS", 0x132, regvalue, cur_col, wrap)
+    ahd_print_register(NULL, 0, "DMAPARAMS", 0x138, regvalue, cur_col, wrap)
 #endif
 
 #if AIC_DEBUG_REGISTERS
 ahd_reg_print_t ahd_seq_flags_print;
 #else
 #define ahd_seq_flags_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "SEQ_FLAGS", 0x133, regvalue, cur_col, wrap)
+    ahd_print_register(NULL, 0, "SEQ_FLAGS", 0x139, regvalue, cur_col, wrap)
 #endif
 
 #if AIC_DEBUG_REGISTERS
 ahd_reg_print_t ahd_saved_scsiid_print;
 #else
 #define ahd_saved_scsiid_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "SAVED_SCSIID", 0x134, regvalue, cur_col, wrap)
+    ahd_print_register(NULL, 0, "SAVED_SCSIID", 0x13a, regvalue, cur_col, wrap)
 #endif
 
 #if AIC_DEBUG_REGISTERS
 ahd_reg_print_t ahd_saved_lun_print;
 #else
 #define ahd_saved_lun_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "SAVED_LUN", 0x135, regvalue, cur_col, wrap)
+    ahd_print_register(NULL, 0, "SAVED_LUN", 0x13b, regvalue, cur_col, wrap)
 #endif
 
 #if AIC_DEBUG_REGISTERS
 ahd_reg_print_t ahd_lastphase_print;
 #else
 #define ahd_lastphase_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "LASTPHASE", 0x136, regvalue, cur_col, wrap)
+    ahd_print_register(NULL, 0, "LASTPHASE", 0x13c, regvalue, cur_col, wrap)
 #endif
 
 #if AIC_DEBUG_REGISTERS
 ahd_reg_print_t ahd_qoutfifo_entry_valid_tag_print;
 #else
 #define ahd_qoutfifo_entry_valid_tag_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "QOUTFIFO_ENTRY_VALID_TAG", 0x137, regvalue, cur_col, wrap)
+    ahd_print_register(NULL, 0, "QOUTFIFO_ENTRY_VALID_TAG", 0x13d, regvalue, cur_col, wrap)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_shared_data_addr_print;
+ahd_reg_print_t ahd_kernel_tqinpos_print;
 #else
-#define ahd_shared_data_addr_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "SHARED_DATA_ADDR", 0x138, regvalue, cur_col, wrap)
+#define ahd_kernel_tqinpos_print(regvalue, cur_col, wrap) \
+    ahd_print_register(NULL, 0, "KERNEL_TQINPOS", 0x13e, regvalue, cur_col, wrap)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_qoutfifo_next_addr_print;
+ahd_reg_print_t ahd_tqinpos_print;
 #else
-#define ahd_qoutfifo_next_addr_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "QOUTFIFO_NEXT_ADDR", 0x13c, regvalue, cur_col, wrap)
+#define ahd_tqinpos_print(regvalue, cur_col, wrap) \
+    ahd_print_register(NULL, 0, "TQINPOS", 0x13f, regvalue, cur_col, wrap)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_kernel_tqinpos_print;
+ahd_reg_print_t ahd_shared_data_addr_print;
 #else
-#define ahd_kernel_tqinpos_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "KERNEL_TQINPOS", 0x140, regvalue, cur_col, wrap)
+#define ahd_shared_data_addr_print(regvalue, cur_col, wrap) \
+    ahd_print_register(NULL, 0, "SHARED_DATA_ADDR", 0x140, regvalue, cur_col, wrap)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_tqinpos_print;
+ahd_reg_print_t ahd_qoutfifo_next_addr_print;
 #else
-#define ahd_tqinpos_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "TQINPOS", 0x141, regvalue, cur_col, wrap)
+#define ahd_qoutfifo_next_addr_print(regvalue, cur_col, wrap) \
+    ahd_print_register(NULL, 0, "QOUTFIFO_NEXT_ADDR", 0x144, regvalue, cur_col, wrap)
 #endif
 
 #if AIC_DEBUG_REGISTERS
 ahd_reg_print_t ahd_arg_1_print;
 #else
 #define ahd_arg_1_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "ARG_1", 0x142, regvalue, cur_col, wrap)
+    ahd_print_register(NULL, 0, "ARG_1", 0x148, regvalue, cur_col, wrap)
 #endif
 
 #if AIC_DEBUG_REGISTERS
 ahd_reg_print_t ahd_arg_2_print;
 #else
 #define ahd_arg_2_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "ARG_2", 0x143, regvalue, cur_col, wrap)
+    ahd_print_register(NULL, 0, "ARG_2", 0x149, regvalue, cur_col, wrap)
 #endif
 
 #if AIC_DEBUG_REGISTERS
 ahd_reg_print_t ahd_last_msg_print;
 #else
 #define ahd_last_msg_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "LAST_MSG", 0x144, regvalue, cur_col, wrap)
+    ahd_print_register(NULL, 0, "LAST_MSG", 0x14a, regvalue, cur_col, wrap)
 #endif
 
 #if AIC_DEBUG_REGISTERS
 ahd_reg_print_t ahd_scsiseq_template_print;
 #else
 #define ahd_scsiseq_template_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "SCSISEQ_TEMPLATE", 0x145, regvalue, cur_col, wrap)
+    ahd_print_register(NULL, 0, "SCSISEQ_TEMPLATE", 0x14b, regvalue, cur_col, wrap)
 #endif
 
 #if AIC_DEBUG_REGISTERS
 ahd_reg_print_t ahd_initiator_tag_print;
 #else
 #define ahd_initiator_tag_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "INITIATOR_TAG", 0x146, regvalue, cur_col, wrap)
+    ahd_print_register(NULL, 0, "INITIATOR_TAG", 0x14c, regvalue, cur_col, wrap)
 #endif
 
 #if AIC_DEBUG_REGISTERS
 ahd_reg_print_t ahd_seq_flags2_print;
 #else
 #define ahd_seq_flags2_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "SEQ_FLAGS2", 0x147, regvalue, cur_col, wrap)
+    ahd_print_register(NULL, 0, "SEQ_FLAGS2", 0x14d, regvalue, cur_col, wrap)
 #endif
 
 #if AIC_DEBUG_REGISTERS
 ahd_reg_print_t ahd_allocfifo_scbptr_print;
 #else
 #define ahd_allocfifo_scbptr_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "ALLOCFIFO_SCBPTR", 0x148, regvalue, cur_col, wrap)
+    ahd_print_register(NULL, 0, "ALLOCFIFO_SCBPTR", 0x14e, regvalue, cur_col, wrap)
 #endif
 
 #if AIC_DEBUG_REGISTERS
 ahd_reg_print_t ahd_int_coalescing_timer_print;
 #else
 #define ahd_int_coalescing_timer_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "INT_COALESCING_TIMER", 0x14a, regvalue, cur_col, wrap)
+    ahd_print_register(NULL, 0, "INT_COALESCING_TIMER", 0x150, regvalue, cur_col, wrap)
 #endif
 
 #if AIC_DEBUG_REGISTERS
 ahd_reg_print_t ahd_int_coalescing_maxcmds_print;
 #else
 #define ahd_int_coalescing_maxcmds_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "INT_COALESCING_MAXCMDS", 0x14c, regvalue, cur_col, wrap)
+    ahd_print_register(NULL, 0, "INT_COALESCING_MAXCMDS", 0x152, regvalue, cur_col, wrap)
 #endif
 
 #if AIC_DEBUG_REGISTERS
 ahd_reg_print_t ahd_int_coalescing_mincmds_print;
 #else
 #define ahd_int_coalescing_mincmds_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "INT_COALESCING_MINCMDS", 0x14d, regvalue, cur_col, wrap)
+    ahd_print_register(NULL, 0, "INT_COALESCING_MINCMDS", 0x153, regvalue, cur_col, wrap)
 #endif
 
 #if AIC_DEBUG_REGISTERS
 ahd_reg_print_t ahd_cmds_pending_print;
 #else
 #define ahd_cmds_pending_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "CMDS_PENDING", 0x14e, regvalue, cur_col, wrap)
+    ahd_print_register(NULL, 0, "CMDS_PENDING", 0x154, regvalue, cur_col, wrap)
 #endif
 
 #if AIC_DEBUG_REGISTERS
 ahd_reg_print_t ahd_int_coalescing_cmdcount_print;
 #else
 #define ahd_int_coalescing_cmdcount_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "INT_COALESCING_CMDCOUNT", 0x150, regvalue, cur_col, wrap)
+    ahd_print_register(NULL, 0, "INT_COALESCING_CMDCOUNT", 0x156, regvalue, cur_col, wrap)
 #endif
 
 #if AIC_DEBUG_REGISTERS
 ahd_reg_print_t ahd_local_hs_mailbox_print;
 #else
 #define ahd_local_hs_mailbox_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "LOCAL_HS_MAILBOX", 0x151, regvalue, cur_col, wrap)
+    ahd_print_register(NULL, 0, "LOCAL_HS_MAILBOX", 0x157, regvalue, cur_col, wrap)
 #endif
 
 #if AIC_DEBUG_REGISTERS
 ahd_reg_print_t ahd_cmdsize_table_print;
 #else
 #define ahd_cmdsize_table_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "CMDSIZE_TABLE", 0x152, regvalue, cur_col, wrap)
+    ahd_print_register(NULL, 0, "CMDSIZE_TABLE", 0x158, regvalue, cur_col, wrap)
 #endif
 
 #if AIC_DEBUG_REGISTERS
@@ -2434,13 +2455,6 @@ ahd_reg_print_t ahd_scb_disconnected_lists_print;
 #define         HOST_TQINPOS            0x80
 #define         ENINT_COALESCE          0x40
 
-#define CLRSEQINTSTAT                   0x0c
-#define         CLRSEQ_SWTMRTO          0x10
-#define         CLRSEQ_SEQINT           0x08
-#define         CLRSEQ_SCSIINT          0x04
-#define         CLRSEQ_PCIINT           0x02
-#define         CLRSEQ_SPLTINT          0x01
-
 #define SEQINTSTAT                      0x0c
 #define         SEQ_SWTMRTO             0x10
 #define         SEQ_SEQINT              0x08
@@ -2448,6 +2462,13 @@ ahd_reg_print_t ahd_scb_disconnected_lists_print;
 #define         SEQ_PCIINT              0x02
 #define         SEQ_SPLTINT             0x01
 
+#define CLRSEQINTSTAT                   0x0c
+#define         CLRSEQ_SWTMRTO          0x10
+#define         CLRSEQ_SEQINT           0x08
+#define         CLRSEQ_SCSIINT          0x04
+#define         CLRSEQ_PCIINT           0x02
+#define         CLRSEQ_SPLTINT          0x01
+
 #define SWTIMER                         0x0e
 
 #define SNSCB_QOFF                      0x10
@@ -2623,10 +2644,10 @@ ahd_reg_print_t ahd_scb_disconnected_lists_print;
 #define         BIOSCANCELEN            0x10
 #define         SPIOEN                  0x08
 
-#define BUSINITID                       0x3c
-
 #define DLCOUNT                         0x3c
 
+#define BUSINITID                       0x3c
+
 #define SXFRCTL1                        0x3d
 #define         BITBUCKET               0x80
 #define         ENSACHK                 0x40
@@ -2693,13 +2714,6 @@ ahd_reg_print_t ahd_scb_disconnected_lists_print;
 #define         SELID_MASK              0xf0
 #define         ONEBIT                  0x08
 
-#define SBLKCTL                         0x4a
-#define         DIAGLEDEN               0x80
-#define         DIAGLEDON               0x40
-#define         ENAB40                  0x08
-#define         ENAB20                  0x04
-#define         SELWIDE                 0x02
-
 #define OPTIONMODE                      0x4a
 #define         OPTIONMODE_DEFAULTS     0x02
 #define         BIOSCANCTL              0x80
@@ -2709,15 +2723,12 @@ ahd_reg_print_t ahd_scb_disconnected_lists_print;
 #define         ENDGFORMCHK             0x04
 #define         AUTO_MSGOUT_DE          0x02
 
-#define SSTAT0                          0x4b
-#define         TARGET                  0x80
-#define         SELDO                   0x40
-#define         SELDI                   0x20
-#define         SELINGO                 0x10
-#define         IOERR                   0x08
-#define         OVERRUN                 0x04
-#define         SPIORDY                 0x02
-#define         ARBDO                   0x01
+#define SBLKCTL                         0x4a
+#define         DIAGLEDEN               0x80
+#define         DIAGLEDON               0x40
+#define         ENAB40                  0x08
+#define         ENAB20                  0x04
+#define         SELWIDE                 0x02
 
 #define CLRSINT0                        0x4b
 #define         CLRSELDO                0x40
@@ -2728,6 +2739,16 @@ ahd_reg_print_t ahd_scb_disconnected_lists_print;
 #define         CLRSPIORDY              0x02
 #define         CLRARBDO                0x01
 
+#define SSTAT0                          0x4b
+#define         TARGET                  0x80
+#define         SELDO                   0x40
+#define         SELDI                   0x20
+#define         SELINGO                 0x10
+#define         IOERR                   0x08
+#define         OVERRUN                 0x04
+#define         SPIORDY                 0x02
+#define         ARBDO                   0x01
+
 #define SIMODE0                         0x4b
 #define         ENSELDO                 0x40
 #define         ENSELDI                 0x20
@@ -2768,17 +2789,17 @@ ahd_reg_print_t ahd_scb_disconnected_lists_print;
 #define         BUSFREE_DFF0            0x80
 #define         BUSFREE_LQO             0x40
 
+#define SIMODE2                         0x4d
+#define         ENWIDE_RES              0x04
+#define         ENSDONE                 0x02
+#define         ENDMADONE               0x01
+
 #define CLRSINT2                        0x4d
 #define         CLRNONPACKREQ           0x20
 #define         CLRWIDE_RES             0x04
 #define         CLRSDONE                0x02
 #define         CLRDMADONE              0x01
 
-#define SIMODE2                         0x4d
-#define         ENWIDE_RES              0x04
-#define         ENSDONE                 0x02
-#define         ENDMADONE               0x01
-
 #define PERRDIAG                        0x4e
 #define         HIZERO                  0x80
 #define         HIPERR                  0x40
@@ -2871,13 +2892,6 @@ ahd_reg_print_t ahd_scb_disconnected_lists_print;
 #define         CLRNTRAMPERR            0x02
 #define         CLROSRAMPERR            0x01
 
-#define LQOMODE0                        0x54
-#define         ENLQOTARGSCBPERR        0x10
-#define         ENLQOSTOPT2             0x08
-#define         ENLQOATNLQ              0x04
-#define         ENLQOATNPKT             0x02
-#define         ENLQOTCRC               0x01
-
 #define LQOSTAT0                        0x54
 #define         LQOTARGSCBPERR          0x10
 #define         LQOSTOPT2               0x08
@@ -2892,6 +2906,20 @@ ahd_reg_print_t ahd_scb_disconnected_lists_print;
 #define         CLRLQOATNPKT            0x02
 #define         CLRLQOTCRC              0x01
 
+#define LQOMODE0                        0x54
+#define         ENLQOTARGSCBPERR        0x10
+#define         ENLQOSTOPT2             0x08
+#define         ENLQOATNLQ              0x04
+#define         ENLQOATNPKT             0x02
+#define         ENLQOTCRC               0x01
+
+#define LQOMODE1                        0x55
+#define         ENLQOINITSCBPERR        0x10
+#define         ENLQOSTOPI2             0x08
+#define         ENLQOBADQAS             0x04
+#define         ENLQOBUSFREE            0x02
+#define         ENLQOPHACHGINPKT        0x01
+
 #define LQOSTAT1                        0x55
 #define         LQOINITSCBPERR          0x10
 #define         LQOSTOPI2               0x08
@@ -2906,13 +2934,6 @@ ahd_reg_print_t ahd_scb_disconnected_lists_print;
 #define         CLRLQOBUSFREE           0x02
 #define         CLRLQOPHACHGINPKT       0x01
 
-#define LQOMODE1                        0x55
-#define         ENLQOINITSCBPERR        0x10
-#define         ENLQOSTOPI2             0x08
-#define         ENLQOBADQAS             0x04
-#define         ENLQOBUSFREE            0x02
-#define         ENLQOPHACHGINPKT        0x01
-
 #define LQOSTAT2                        0x56
 #define         LQOPKT                  0xe0
 #define         LQOWAITFIFO             0x10
@@ -3028,6 +3049,8 @@ ahd_reg_print_t ahd_scb_disconnected_lists_print;
 
 #define ANNEXCOL                        0x65
 
+#define ANNEXDAT                        0x66
+
 #define SCSCHKN                         0x66
 #define         STSELSKIDDIS            0x40
 #define         CURRFIFODEF             0x20
@@ -3037,8 +3060,6 @@ ahd_reg_print_t ahd_scb_disconnected_lists_print;
 #define         SHVALIDSTDIS            0x02
 #define         LSTSGCLRDIS             0x01
 
-#define ANNEXDAT                        0x66
-
 #define IOWNID                          0x67
 
 #define PLL960CTL0                      0x68
@@ -3071,10 +3092,10 @@ ahd_reg_print_t ahd_scb_disconnected_lists_print;
 #define         PLL_CNTCLR              0x40
 #define         PLL_RST                 0x01
 
-#define PLL400CNT0                      0x6e
-
 #define UNFAIRNESS                      0x6e
 
+#define PLL400CNT0                      0x6e
+
 #define HADDR                           0x70
 
 #define PLLDELAY                        0x70
@@ -3088,14 +3109,14 @@ ahd_reg_print_t ahd_scb_disconnected_lists_print;
 
 #define HODMAEN                         0x7a
 
-#define SGHADDR                         0x7c
-
 #define SCBHADDR                        0x7c
 
-#define SGHCNT                          0x84
+#define SGHADDR                         0x7c
 
 #define SCBHCNT                         0x84
 
+#define SGHCNT                          0x84
+
 #define DFF_THRSH                       0x88
 #define         WR_DFTHRSH              0x70
 #define         RD_DFTHRSH              0x07
@@ -3113,8 +3134,8 @@ ahd_reg_print_t ahd_scb_disconnected_lists_print;
 #define         RD_DFTHRSH_63           0x03
 #define         RD_DFTHRSH_50           0x02
 #define         RD_DFTHRSH_25           0x01
-#define         WR_DFTHRSH_MIN          0x00
 #define         RD_DFTHRSH_MIN          0x00
+#define         WR_DFTHRSH_MIN          0x00
 
 #define ROMADDR                         0x8a
 
@@ -3150,20 +3171,22 @@ ahd_reg_print_t ahd_scb_disconnected_lists_print;
 #define         DCH1NSEN                0x02
 #define         DCH0NSEN                0x01
 
-#define DCHRXMSG1                       0x91
-
 #define CMCRXMSG1                       0x91
 
-#define DCHRXMSG2                       0x92
+#define DCHRXMSG1                       0x91
 
-#define OVLYRXMSG2                      0x92
+#define DCHRXMSG2                       0x92
 
 #define CMCRXMSG2                       0x92
 
 #define OST                             0x92
 
+#define OVLYRXMSG2                      0x92
+
 #define DCHRXMSG3                       0x93
 
+#define OVLYRXMSG3                      0x93
+
 #define CMCRXMSG3                       0x93
 
 #define PCIXCTL                         0x93
@@ -3175,26 +3198,24 @@ ahd_reg_print_t ahd_scb_disconnected_lists_print;
 #define         TSCSERREN               0x02
 #define         CMPABCDIS               0x01
 
-#define OVLYRXMSG3                      0x93
-
 #define OVLYSEQBCNT                     0x94
 
-#define CMCSEQBCNT                      0x94
-
 #define DCHSEQBCNT                      0x94
 
-#define CMCSPLTSTAT0                    0x96
+#define CMCSEQBCNT                      0x94
 
-#define OVLYSPLTSTAT0                   0x96
+#define CMCSPLTSTAT0                    0x96
 
 #define DCHSPLTSTAT0                    0x96
 
-#define DCHSPLTSTAT1                    0x97
+#define OVLYSPLTSTAT0                   0x96
 
 #define CMCSPLTSTAT1                    0x97
 
 #define OVLYSPLTSTAT1                   0x97
 
+#define DCHSPLTSTAT1                    0x97
+
 #define SGRXMSG0                        0x98
 #define         CDNUM                   0xf8
 #define         CFNUM                   0x07
@@ -3244,13 +3265,13 @@ ahd_reg_print_t ahd_scb_disconnected_lists_print;
 #define         RXSCEMSG                0x02
 #define         RXSPLTRSP               0x01
 
+#define SGSPLTSTAT1                     0x9f
+#define         RXDATABUCKET            0x01
+
 #define SFUNCT                          0x9f
 #define         TEST_GROUP              0xf0
 #define         TEST_NUM                0x0f
 
-#define SGSPLTSTAT1                     0x9f
-#define         RXDATABUCKET            0x01
-
 #define DF0PCISTAT                      0xa0
 
 #define REG0                            0xa0
@@ -3299,10 +3320,10 @@ ahd_reg_print_t ahd_scb_disconnected_lists_print;
 
 #define CCSGADDR                        0xac
 
-#define CCSCBADDR                       0xac
-
 #define CCSCBADR_BK                     0xac
 
+#define CCSCBADDR                       0xac
+
 #define CMC_RAMBIST                     0xad
 #define         SG_ELEMENT_SIZE         0x80
 #define         SCBRAMBIST_FAIL         0x40
@@ -3311,14 +3332,6 @@ ahd_reg_print_t ahd_scb_disconnected_lists_print;
 #define         CMC_BUFFER_BIST_FAIL    0x02
 #define         CMC_BUFFER_BIST_EN      0x01
 
-#define CCSGCTL                         0xad
-#define         CCSGEN                  0x0c
-#define         CCSGDONE                0x80
-#define         SG_CACHE_AVAIL          0x10
-#define         CCSGENACK               0x08
-#define         SG_FETCH_REQ            0x02
-#define         CCSGRESET               0x01
-
 #define CCSCBCTL                        0xad
 #define         CCSCBDONE               0x80
 #define         ARRDONE                 0x40
@@ -3327,6 +3340,14 @@ ahd_reg_print_t ahd_scb_disconnected_lists_print;
 #define         CCSCBDIR                0x04
 #define         CCSCBRESET              0x01
 
+#define CCSGCTL                         0xad
+#define         CCSGEN                  0x0c
+#define         CCSGDONE                0x80
+#define         SG_CACHE_AVAIL          0x10
+#define         CCSGENACK               0x08
+#define         SG_FETCH_REQ            0x02
+#define         CCSGRESET               0x01
+
 #define CCSGRAM                         0xb0
 
 #define FLEXADR                         0xb0
@@ -3356,8 +3377,8 @@ ahd_reg_print_t ahd_scb_disconnected_lists_print;
 #define SEEDAT                          0xbc
 
 #define SEECTL                          0xbe
-#define         SEEOP_EWEN              0x40
 #define         SEEOP_WALL              0x40
+#define         SEEOP_EWEN              0x40
 #define         SEEOP_EWDS              0x40
 #define         SEEOPCODE               0x70
 #define         SEERST                  0x02
@@ -3414,14 +3435,14 @@ ahd_reg_print_t ahd_scb_disconnected_lists_print;
 
 #define WRTBIASCALC                     0xc7
 
-#define DFPTRS                          0xc8
-
 #define RCVRBIASCALC                    0xc8
 
-#define DFBKPTR                         0xc9
+#define DFPTRS                          0xc8
 
 #define SKEWCALC                        0xc9
 
+#define DFBKPTR                         0xc9
+
 #define DFDBCTL                         0xcb
 #define         DFF_CIO_WR_RDY          0x20
 #define         DFF_CIO_RD_RDY          0x10
@@ -3475,11 +3496,11 @@ ahd_reg_print_t ahd_scb_disconnected_lists_print;
 
 #define DINDEX                          0xe4
 
+#define BRKADDR0                        0xe6
+
 #define BRKADDR1                        0xe6
 #define         BRKDIS                  0x80
 
-#define BRKADDR0                        0xe6
-
 #define ALLONES                         0xe8
 
 #define ALLZEROS                        0xea
@@ -3494,14 +3515,14 @@ ahd_reg_print_t ahd_scb_disconnected_lists_print;
 
 #define STACK                           0xf2
 
-#define CURADDR                         0xf4
-
 #define INTVEC1_ADDR                    0xf4
 
-#define INTVEC2_ADDR                    0xf6
+#define CURADDR                         0xf4
 
 #define LASTADDR                        0xf6
 
+#define INTVEC2_ADDR                    0xf6
+
 #define LONGJMP_ADDR                    0xf8
 
 #define ACCUM_SAVE                      0xfa
@@ -3524,25 +3545,31 @@ ahd_reg_print_t ahd_scb_disconnected_lists_print;
 
 #define COMPLETE_DMA_SCB_HEAD           0x12c
 
-#define QFREEZE_COUNT                   0x12e
+#define COMPLETE_DMA_SCB_TAIL           0x12e
+
+#define COMPLETE_ON_QFREEZE_HEAD                0x130
+
+#define QFREEZE_COUNT                   0x132
 
-#define SAVED_MODE                      0x130
+#define KERNEL_QFREEZE_COUNT            0x134
 
-#define MSG_OUT                         0x131
+#define SAVED_MODE                      0x136
 
-#define DMAPARAMS                       0x132
+#define MSG_OUT                         0x137
+
+#define DMAPARAMS                       0x138
 #define         PRELOADEN               0x80
 #define         WIDEODD                 0x40
 #define         SCSIEN                  0x20
 #define         SDMAEN                  0x10
 #define         SDMAENACK               0x10
-#define         HDMAENACK               0x08
 #define         HDMAEN                  0x08
+#define         HDMAENACK               0x08
 #define         DIRECTION               0x04
 #define         FIFOFLUSH               0x02
 #define         FIFORESET               0x01
 
-#define SEQ_FLAGS                       0x133
+#define SEQ_FLAGS                       0x139
 #define         NOT_IDENTIFIED          0x80
 #define         NO_CDB_SENT             0x40
 #define         TARGET_CMD_IS_TAGGED    0x40
@@ -3553,11 +3580,11 @@ ahd_reg_print_t ahd_scb_disconnected_lists_print;
 #define         SPHASE_PENDING          0x02
 #define         NO_DISCONNECT           0x01
 
-#define SAVED_SCSIID                    0x134
+#define SAVED_SCSIID                    0x13a
 
-#define SAVED_LUN                       0x135
+#define SAVED_LUN                       0x13b
 
-#define LASTPHASE                       0x136
+#define LASTPHASE                       0x13c
 #define         PHASE_MASK              0xe0
 #define         CDI                     0x80
 #define         IOI                     0x40
@@ -3572,18 +3599,18 @@ ahd_reg_print_t ahd_scb_disconnected_lists_print;
 #define         P_DATAOUT_DT            0x20
 #define         P_DATAOUT               0x00
 
-#define QOUTFIFO_ENTRY_VALID_TAG                0x137
+#define QOUTFIFO_ENTRY_VALID_TAG                0x13d
 
-#define SHARED_DATA_ADDR                0x138
+#define KERNEL_TQINPOS                  0x13e
 
-#define QOUTFIFO_NEXT_ADDR              0x13c
+#define TQINPOS                         0x13f
 
-#define KERNEL_TQINPOS                  0x140
+#define SHARED_DATA_ADDR                0x140
 
-#define TQINPOS                         0x141
+#define QOUTFIFO_NEXT_ADDR              0x144
 
-#define ARG_1                           0x142
-#define RETURN_1                        0x142
+#define ARG_1                           0x148
+#define RETURN_1                        0x148
 #define         SEND_MSG                0x80
 #define         SEND_SENSE              0x40
 #define         SEND_REJ                0x20
@@ -3593,12 +3620,12 @@ ahd_reg_print_t ahd_scb_disconnected_lists_print;
 #define         CONT_MSG_LOOP_READ      0x03
 #define         CONT_MSG_LOOP_TARG      0x02
 
-#define ARG_2                           0x143
-#define RETURN_2                        0x143
+#define ARG_2                           0x149
+#define RETURN_2                        0x149
 
-#define LAST_MSG                        0x144
+#define LAST_MSG                        0x14a
 
-#define SCSISEQ_TEMPLATE                0x145
+#define SCSISEQ_TEMPLATE                0x14b
 #define         MANUALCTL               0x40
 #define         ENSELI                  0x20
 #define         ENRSELI                 0x10
@@ -3606,27 +3633,27 @@ ahd_reg_print_t ahd_scb_disconnected_lists_print;
 #define         ENAUTOATNP              0x02
 #define         ALTSTIM                 0x01
 
-#define INITIATOR_TAG                   0x146
+#define INITIATOR_TAG                   0x14c
 
-#define SEQ_FLAGS2                      0x147
+#define SEQ_FLAGS2                      0x14d
 #define         SELECTOUT_QFROZEN       0x04
 #define         TARGET_MSG_PENDING      0x02
 
-#define ALLOCFIFO_SCBPTR                0x148
+#define ALLOCFIFO_SCBPTR                0x14e
 
-#define INT_COALESCING_TIMER            0x14a
+#define INT_COALESCING_TIMER            0x150
 
-#define INT_COALESCING_MAXCMDS          0x14c
+#define INT_COALESCING_MAXCMDS          0x152
 
-#define INT_COALESCING_MINCMDS          0x14d
+#define INT_COALESCING_MINCMDS          0x153
 
-#define CMDS_PENDING                    0x14e
+#define CMDS_PENDING                    0x154
 
-#define INT_COALESCING_CMDCOUNT         0x150
+#define INT_COALESCING_CMDCOUNT         0x156
 
-#define LOCAL_HS_MAILBOX                0x151
+#define LOCAL_HS_MAILBOX                0x157
 
-#define CMDSIZE_TABLE                   0x152
+#define CMDSIZE_TABLE                   0x158
 
 #define SCB_BASE                        0x180
 
@@ -3701,6 +3728,16 @@ ahd_reg_print_t ahd_scb_disconnected_lists_print;
 #define SCB_DISCONNECTED_LISTS          0x1b8
 
 
+#define AHD_TIMER_MAX_US        0x18ffe7
+#define AHD_TIMER_MAX_TICKS     0xffff
+#define AHD_SENSE_BUFSIZE       0x100
+#define BUS_8_BIT       0x00
+#define TARGET_CMD_CMPLT        0xfe
+#define SEEOP_WRAL_ADDR 0x40
+#define AHD_AMPLITUDE_DEF       0x07
+#define AHD_PRECOMP_CUTBACK_37  0x07
+#define AHD_PRECOMP_SHIFT       0x00
+#define AHD_ANNEXCOL_PRECOMP_SLEW       0x04
 #define AHD_TIMER_US_PER_TICK   0x19
 #define SCB_TRANSFER_SIZE_FULL_LUN      0x38
 #define STATUS_QUEUE_FULL       0x28
@@ -3724,28 +3761,18 @@ ahd_reg_print_t ahd_scb_disconnected_lists_print;
 #define B_CURRFIFO_0    0x02
 #define LUNLEN_SINGLE_LEVEL_LUN 0x0f
 #define NVRAM_SCB_OFFSET        0x2c
-#define AHD_TIMER_MAX_US        0x18ffe7
-#define AHD_TIMER_MAX_TICKS     0xffff
 #define STATUS_PKT_SENSE        0xff
 #define CMD_GROUP_CODE_SHIFT    0x05
-#define AHD_SENSE_BUFSIZE       0x100
 #define MAX_OFFSET_PACED_BUG    0x7f
-#define BUS_8_BIT       0x00
 #define STIMESEL_BUG_ADJ        0x08
 #define STIMESEL_MIN    0x18
 #define STIMESEL_SHIFT  0x03
 #define CCSGRAM_MAXSEGS 0x10
 #define INVALID_ADDR    0x80
-#define TARGET_CMD_CMPLT        0xfe
-#define SEEOP_WRAL_ADDR 0x40
 #define SEEOP_ERAL_ADDR 0x80
-#define AHD_AMPLITUDE_DEF       0x07
 #define AHD_SLEWRATE_DEF_REVB   0x08
-#define AHD_PRECOMP_CUTBACK_37  0x07
 #define AHD_PRECOMP_CUTBACK_17  0x04
-#define AHD_PRECOMP_SHIFT       0x00
 #define AHD_PRECOMP_MASK        0x07
-#define AHD_ANNEXCOL_PRECOMP_SLEW       0x04
 #define SRC_MODE_SHIFT  0x00
 #define PKT_OVERRUN_BUFSIZE     0x200
 #define SCB_TRANSFER_SIZE_1BYTE_LUN     0x30
@@ -3761,6 +3788,7 @@ ahd_reg_print_t ahd_scb_disconnected_lists_print;
 
 
 /* Downloaded Constant Definitions */
+#define CACHELINE_MASK  0x07
 #define SCB_TRANSFER_SIZE       0x06
 #define PKT_OVERRUN_BUFOFFSET   0x05
 #define SG_SIZEOF       0x04
@@ -3768,9 +3796,9 @@ ahd_reg_print_t ahd_scb_disconnected_lists_print;
 #define SG_PREFETCH_ALIGN_MASK  0x02
 #define SG_PREFETCH_CNT_LIMIT   0x01
 #define SG_PREFETCH_CNT 0x00
-#define DOWNLOAD_CONST_COUNT    0x07
+#define DOWNLOAD_CONST_COUNT    0x08
 
 
 /* Exported Labels */
-#define LABEL_seq_isr   0x269
-#define LABEL_timer_isr 0x265
+#define LABEL_seq_isr   0x285
+#define LABEL_timer_isr 0x281
diff --git a/drivers/scsi/aic7xxx/aic79xx_reg_print.c_shipped b/drivers/scsi/aic7xxx/aic79xx_reg_print.c_shipped
index 3098a757e3d7..a4137c985376 100644
--- a/drivers/scsi/aic7xxx/aic79xx_reg_print.c_shipped
+++ b/drivers/scsi/aic7xxx/aic79xx_reg_print.c_shipped
@@ -2,8 +2,8 @@
  * DO NOT EDIT - This file is automatically generated
  *               from the following source files:
  *
- * $Id: //depot/aic7xxx/aic7xxx/aic79xx.seq#94 $
- * $Id: //depot/aic7xxx/aic7xxx/aic79xx.reg#70 $
+ * $Id: //depot/aic7xxx/aic7xxx/aic79xx.seq#118 $
+ * $Id: //depot/aic7xxx/aic7xxx/aic79xx.reg#75 $
  */
 
 #include "aic79xx_osm.h"
@@ -172,21 +172,6 @@ ahd_hs_mailbox_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x0b, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t CLRSEQINTSTAT_parse_table[] = {
-        { "CLRSEQ_SPLTINT",     0x01, 0x01 },
-        { "CLRSEQ_PCIINT",      0x02, 0x02 },
-        { "CLRSEQ_SCSIINT",     0x04, 0x04 },
-        { "CLRSEQ_SEQINT",      0x08, 0x08 },
-        { "CLRSEQ_SWTMRTO",     0x10, 0x10 }
-};
-
-int
-ahd_clrseqintstat_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(CLRSEQINTSTAT_parse_table, 5, "CLRSEQINTSTAT",
-            0x0c, regvalue, cur_col, wrap));
-}
-
 static ahd_reg_parse_entry_t SEQINTSTAT_parse_table[] = {
         { "SEQ_SPLTINT",        0x01, 0x01 },
         { "SEQ_PCIINT",         0x02, 0x02 },
@@ -202,6 +187,21 @@ ahd_seqintstat_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x0c, regvalue, cur_col, wrap));
 }
 
+static ahd_reg_parse_entry_t CLRSEQINTSTAT_parse_table[] = {
+        { "CLRSEQ_SPLTINT",     0x01, 0x01 },
+        { "CLRSEQ_PCIINT",      0x02, 0x02 },
+        { "CLRSEQ_SCSIINT",     0x04, 0x04 },
+        { "CLRSEQ_SEQINT",      0x08, 0x08 },
+        { "CLRSEQ_SWTMRTO",     0x10, 0x10 }
+};
+
+int
+ahd_clrseqintstat_print(u_int regvalue, u_int *cur_col, u_int wrap)
+{
+        return (ahd_print_register(CLRSEQINTSTAT_parse_table, 5, "CLRSEQINTSTAT",
+            0x0c, regvalue, cur_col, wrap));
+}
+
 int
 ahd_swtimer_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
@@ -670,16 +670,16 @@ ahd_sxfrctl0_print(u_int regvalue, u_int *cur_col, u_int wrap)
 }
 
 int
-ahd_businitid_print(u_int regvalue, u_int *cur_col, u_int wrap)
+ahd_dlcount_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
-        return (ahd_print_register(NULL, 0, "BUSINITID",
+        return (ahd_print_register(NULL, 0, "DLCOUNT",
             0x3c, regvalue, cur_col, wrap));
 }
 
 int
-ahd_dlcount_print(u_int regvalue, u_int *cur_col, u_int wrap)
+ahd_businitid_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
-        return (ahd_print_register(NULL, 0, "DLCOUNT",
+        return (ahd_print_register(NULL, 0, "BUSINITID",
             0x3c, regvalue, cur_col, wrap));
 }
 
@@ -859,21 +859,6 @@ ahd_selid_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x49, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t SBLKCTL_parse_table[] = {
-        { "SELWIDE",            0x02, 0x02 },
-        { "ENAB20",             0x04, 0x04 },
-        { "ENAB40",             0x08, 0x08 },
-        { "DIAGLEDON",          0x40, 0x40 },
-        { "DIAGLEDEN",          0x80, 0x80 }
-};
-
-int
-ahd_sblkctl_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(SBLKCTL_parse_table, 5, "SBLKCTL",
-            0x4a, regvalue, cur_col, wrap));
-}
-
 static ahd_reg_parse_entry_t OPTIONMODE_parse_table[] = {
         { "AUTO_MSGOUT_DE",     0x02, 0x02 },
         { "ENDGFORMCHK",        0x04, 0x04 },
@@ -891,22 +876,19 @@ ahd_optionmode_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x4a, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t SSTAT0_parse_table[] = {
-        { "ARBDO",              0x01, 0x01 },
-        { "SPIORDY",            0x02, 0x02 },
-        { "OVERRUN",            0x04, 0x04 },
-        { "IOERR",              0x08, 0x08 },
-        { "SELINGO",            0x10, 0x10 },
-        { "SELDI",              0x20, 0x20 },
-        { "SELDO",              0x40, 0x40 },
-        { "TARGET",             0x80, 0x80 }
+static ahd_reg_parse_entry_t SBLKCTL_parse_table[] = {
+        { "SELWIDE",            0x02, 0x02 },
+        { "ENAB20",             0x04, 0x04 },
+        { "ENAB40",             0x08, 0x08 },
+        { "DIAGLEDON",          0x40, 0x40 },
+        { "DIAGLEDEN",          0x80, 0x80 }
 };
 
 int
-ahd_sstat0_print(u_int regvalue, u_int *cur_col, u_int wrap)
+ahd_sblkctl_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
-        return (ahd_print_register(SSTAT0_parse_table, 8, "SSTAT0",
-            0x4b, regvalue, cur_col, wrap));
+        return (ahd_print_register(SBLKCTL_parse_table, 5, "SBLKCTL",
+            0x4a, regvalue, cur_col, wrap));
 }
 
 static ahd_reg_parse_entry_t CLRSINT0_parse_table[] = {
@@ -926,6 +908,24 @@ ahd_clrsint0_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x4b, regvalue, cur_col, wrap));
 }
 
+static ahd_reg_parse_entry_t SSTAT0_parse_table[] = {
+        { "ARBDO",              0x01, 0x01 },
+        { "SPIORDY",            0x02, 0x02 },
+        { "OVERRUN",            0x04, 0x04 },
+        { "IOERR",              0x08, 0x08 },
+        { "SELINGO",            0x10, 0x10 },
+        { "SELDI",              0x20, 0x20 },
+        { "SELDO",              0x40, 0x40 },
+        { "TARGET",             0x80, 0x80 }
+};
+
+int
+ahd_sstat0_print(u_int regvalue, u_int *cur_col, u_int wrap)
+{
+        return (ahd_print_register(SSTAT0_parse_table, 8, "SSTAT0",
+            0x4b, regvalue, cur_col, wrap));
+}
+
 static ahd_reg_parse_entry_t SIMODE0_parse_table[] = {
         { "ENARBDO",            0x01, 0x01 },
         { "ENSPIORDY",          0x02, 0x02 },
@@ -998,30 +998,30 @@ ahd_sstat2_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x4d, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t CLRSINT2_parse_table[] = {
-        { "CLRDMADONE",         0x01, 0x01 },
-        { "CLRSDONE",           0x02, 0x02 },
-        { "CLRWIDE_RES",        0x04, 0x04 },
-        { "CLRNONPACKREQ",      0x20, 0x20 }
+static ahd_reg_parse_entry_t SIMODE2_parse_table[] = {
+        { "ENDMADONE",          0x01, 0x01 },
+        { "ENSDONE",            0x02, 0x02 },
+        { "ENWIDE_RES",         0x04, 0x04 }
 };
 
 int
-ahd_clrsint2_print(u_int regvalue, u_int *cur_col, u_int wrap)
+ahd_simode2_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
-        return (ahd_print_register(CLRSINT2_parse_table, 4, "CLRSINT2",
+        return (ahd_print_register(SIMODE2_parse_table, 3, "SIMODE2",
             0x4d, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t SIMODE2_parse_table[] = {
-        { "ENDMADONE",          0x01, 0x01 },
-        { "ENSDONE",            0x02, 0x02 },
-        { "ENWIDE_RES",         0x04, 0x04 }
+static ahd_reg_parse_entry_t CLRSINT2_parse_table[] = {
+        { "CLRDMADONE",         0x01, 0x01 },
+        { "CLRSDONE",           0x02, 0x02 },
+        { "CLRWIDE_RES",        0x04, 0x04 },
+        { "CLRNONPACKREQ",      0x20, 0x20 }
 };
 
 int
-ahd_simode2_print(u_int regvalue, u_int *cur_col, u_int wrap)
+ahd_clrsint2_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
-        return (ahd_print_register(SIMODE2_parse_table, 3, "SIMODE2",
+        return (ahd_print_register(CLRSINT2_parse_table, 4, "CLRSINT2",
             0x4d, regvalue, cur_col, wrap));
 }
 
@@ -1220,21 +1220,6 @@ ahd_clrsint3_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x53, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t LQOMODE0_parse_table[] = {
-        { "ENLQOTCRC",          0x01, 0x01 },
-        { "ENLQOATNPKT",        0x02, 0x02 },
-        { "ENLQOATNLQ",         0x04, 0x04 },
-        { "ENLQOSTOPT2",        0x08, 0x08 },
-        { "ENLQOTARGSCBPERR",   0x10, 0x10 }
-};
-
-int
-ahd_lqomode0_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(LQOMODE0_parse_table, 5, "LQOMODE0",
-            0x54, regvalue, cur_col, wrap));
-}
-
 static ahd_reg_parse_entry_t LQOSTAT0_parse_table[] = {
         { "LQOTCRC",            0x01, 0x01 },
         { "LQOATNPKT",          0x02, 0x02 },
@@ -1265,6 +1250,36 @@ ahd_clrlqoint0_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x54, regvalue, cur_col, wrap));
 }
 
+static ahd_reg_parse_entry_t LQOMODE0_parse_table[] = {
+        { "ENLQOTCRC",          0x01, 0x01 },
+        { "ENLQOATNPKT",        0x02, 0x02 },
+        { "ENLQOATNLQ",         0x04, 0x04 },
+        { "ENLQOSTOPT2",        0x08, 0x08 },
+        { "ENLQOTARGSCBPERR",   0x10, 0x10 }
+};
+
+int
+ahd_lqomode0_print(u_int regvalue, u_int *cur_col, u_int wrap)
+{
+        return (ahd_print_register(LQOMODE0_parse_table, 5, "LQOMODE0",
+            0x54, regvalue, cur_col, wrap));
+}
+
+static ahd_reg_parse_entry_t LQOMODE1_parse_table[] = {
+        { "ENLQOPHACHGINPKT",   0x01, 0x01 },
+        { "ENLQOBUSFREE",       0x02, 0x02 },
+        { "ENLQOBADQAS",        0x04, 0x04 },
+        { "ENLQOSTOPI2",        0x08, 0x08 },
+        { "ENLQOINITSCBPERR",   0x10, 0x10 }
+};
+
+int
+ahd_lqomode1_print(u_int regvalue, u_int *cur_col, u_int wrap)
+{
+        return (ahd_print_register(LQOMODE1_parse_table, 5, "LQOMODE1",
+            0x55, regvalue, cur_col, wrap));
+}
+
 static ahd_reg_parse_entry_t LQOSTAT1_parse_table[] = {
         { "LQOPHACHGINPKT",     0x01, 0x01 },
         { "LQOBUSFREE",         0x02, 0x02 },
@@ -1295,21 +1310,6 @@ ahd_clrlqoint1_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x55, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t LQOMODE1_parse_table[] = {
-        { "ENLQOPHACHGINPKT",   0x01, 0x01 },
-        { "ENLQOBUSFREE",       0x02, 0x02 },
-        { "ENLQOBADQAS",        0x04, 0x04 },
-        { "ENLQOSTOPI2",        0x08, 0x08 },
-        { "ENLQOINITSCBPERR",   0x10, 0x10 }
-};
-
-int
-ahd_lqomode1_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(LQOMODE1_parse_table, 5, "LQOMODE1",
-            0x55, regvalue, cur_col, wrap));
-}
-
 static ahd_reg_parse_entry_t LQOSTAT2_parse_table[] = {
         { "LQOSTOP0",           0x01, 0x01 },
         { "LQOPHACHGOUTPKT",    0x02, 0x02 },
@@ -1594,6 +1594,13 @@ ahd_annexcol_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x65, regvalue, cur_col, wrap));
 }
 
+int
+ahd_annexdat_print(u_int regvalue, u_int *cur_col, u_int wrap)
+{
+        return (ahd_print_register(NULL, 0, "ANNEXDAT",
+            0x66, regvalue, cur_col, wrap));
+}
+
 static ahd_reg_parse_entry_t SCSCHKN_parse_table[] = {
         { "LSTSGCLRDIS",        0x01, 0x01 },
         { "SHVALIDSTDIS",       0x02, 0x02 },
@@ -1612,13 +1619,6 @@ ahd_scschkn_print(u_int regvalue, u_int *cur_col, u_int wrap)
 }
 
 int
-ahd_annexdat_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(NULL, 0, "ANNEXDAT",
-            0x66, regvalue, cur_col, wrap));
-}
-
-int
 ahd_iownid_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
         return (ahd_print_register(NULL, 0, "IOWNID",
@@ -1728,16 +1728,16 @@ ahd_pll400ctl1_print(u_int regvalue, u_int *cur_col, u_int wrap)
 }
 
 int
-ahd_pll400cnt0_print(u_int regvalue, u_int *cur_col, u_int wrap)
+ahd_unfairness_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
-        return (ahd_print_register(NULL, 0, "PLL400CNT0",
+        return (ahd_print_register(NULL, 0, "UNFAIRNESS",
             0x6e, regvalue, cur_col, wrap));
 }
 
 int
-ahd_unfairness_print(u_int regvalue, u_int *cur_col, u_int wrap)
+ahd_pll400cnt0_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
-        return (ahd_print_register(NULL, 0, "UNFAIRNESS",
+        return (ahd_print_register(NULL, 0, "PLL400CNT0",
             0x6e, regvalue, cur_col, wrap));
 }
 
@@ -1788,30 +1788,30 @@ ahd_hodmaen_print(u_int regvalue, u_int *cur_col, u_int wrap)
 }
 
 int
-ahd_sghaddr_print(u_int regvalue, u_int *cur_col, u_int wrap)
+ahd_scbhaddr_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
-        return (ahd_print_register(NULL, 0, "SGHADDR",
+        return (ahd_print_register(NULL, 0, "SCBHADDR",
             0x7c, regvalue, cur_col, wrap));
 }
 
 int
-ahd_scbhaddr_print(u_int regvalue, u_int *cur_col, u_int wrap)
+ahd_sghaddr_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
-        return (ahd_print_register(NULL, 0, "SCBHADDR",
+        return (ahd_print_register(NULL, 0, "SGHADDR",
             0x7c, regvalue, cur_col, wrap));
 }
 
 int
-ahd_sghcnt_print(u_int regvalue, u_int *cur_col, u_int wrap)
+ahd_scbhcnt_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
-        return (ahd_print_register(NULL, 0, "SGHCNT",
+        return (ahd_print_register(NULL, 0, "SCBHCNT",
             0x84, regvalue, cur_col, wrap));
 }
 
 int
-ahd_scbhcnt_print(u_int regvalue, u_int *cur_col, u_int wrap)
+ahd_sghcnt_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
-        return (ahd_print_register(NULL, 0, "SCBHCNT",
+        return (ahd_print_register(NULL, 0, "SGHCNT",
             0x84, regvalue, cur_col, wrap));
 }
 
@@ -1950,25 +1950,25 @@ ahd_nsenable_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x91, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t DCHRXMSG1_parse_table[] = {
+static ahd_reg_parse_entry_t CMCRXMSG1_parse_table[] = {
         { "CBNUM",              0xff, 0xff }
 };
 
 int
-ahd_dchrxmsg1_print(u_int regvalue, u_int *cur_col, u_int wrap)
+ahd_cmcrxmsg1_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
-        return (ahd_print_register(DCHRXMSG1_parse_table, 1, "DCHRXMSG1",
+        return (ahd_print_register(CMCRXMSG1_parse_table, 1, "CMCRXMSG1",
             0x91, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t CMCRXMSG1_parse_table[] = {
+static ahd_reg_parse_entry_t DCHRXMSG1_parse_table[] = {
         { "CBNUM",              0xff, 0xff }
 };
 
 int
-ahd_cmcrxmsg1_print(u_int regvalue, u_int *cur_col, u_int wrap)
+ahd_dchrxmsg1_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
-        return (ahd_print_register(CMCRXMSG1_parse_table, 1, "CMCRXMSG1",
+        return (ahd_print_register(DCHRXMSG1_parse_table, 1, "DCHRXMSG1",
             0x91, regvalue, cur_col, wrap));
 }
 
@@ -1983,17 +1983,6 @@ ahd_dchrxmsg2_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x92, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t OVLYRXMSG2_parse_table[] = {
-        { "MINDEX",             0xff, 0xff }
-};
-
-int
-ahd_ovlyrxmsg2_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(OVLYRXMSG2_parse_table, 1, "OVLYRXMSG2",
-            0x92, regvalue, cur_col, wrap));
-}
-
 static ahd_reg_parse_entry_t CMCRXMSG2_parse_table[] = {
         { "MINDEX",             0xff, 0xff }
 };
@@ -2012,6 +2001,17 @@ ahd_ost_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x92, regvalue, cur_col, wrap));
 }
 
+static ahd_reg_parse_entry_t OVLYRXMSG2_parse_table[] = {
+        { "MINDEX",             0xff, 0xff }
+};
+
+int
+ahd_ovlyrxmsg2_print(u_int regvalue, u_int *cur_col, u_int wrap)
+{
+        return (ahd_print_register(OVLYRXMSG2_parse_table, 1, "OVLYRXMSG2",
+            0x92, regvalue, cur_col, wrap));
+}
+
 static ahd_reg_parse_entry_t DCHRXMSG3_parse_table[] = {
         { "MCLASS",             0x0f, 0x0f }
 };
@@ -2023,6 +2023,17 @@ ahd_dchrxmsg3_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x93, regvalue, cur_col, wrap));
 }
 
+static ahd_reg_parse_entry_t OVLYRXMSG3_parse_table[] = {
+        { "MCLASS",             0x0f, 0x0f }
+};
+
+int
+ahd_ovlyrxmsg3_print(u_int regvalue, u_int *cur_col, u_int wrap)
+{
+        return (ahd_print_register(OVLYRXMSG3_parse_table, 1, "OVLYRXMSG3",
+            0x93, regvalue, cur_col, wrap));
+}
+
 static ahd_reg_parse_entry_t CMCRXMSG3_parse_table[] = {
         { "MCLASS",             0x0f, 0x0f }
 };
@@ -2051,17 +2062,6 @@ ahd_pcixctl_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x93, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t OVLYRXMSG3_parse_table[] = {
-        { "MCLASS",             0x0f, 0x0f }
-};
-
-int
-ahd_ovlyrxmsg3_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(OVLYRXMSG3_parse_table, 1, "OVLYRXMSG3",
-            0x93, regvalue, cur_col, wrap));
-}
-
 int
 ahd_ovlyseqbcnt_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
@@ -2070,16 +2070,16 @@ ahd_ovlyseqbcnt_print(u_int regvalue, u_int *cur_col, u_int wrap)
 }
 
 int
-ahd_cmcseqbcnt_print(u_int regvalue, u_int *cur_col, u_int wrap)
+ahd_dchseqbcnt_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
-        return (ahd_print_register(NULL, 0, "CMCSEQBCNT",
+        return (ahd_print_register(NULL, 0, "DCHSEQBCNT",
             0x94, regvalue, cur_col, wrap));
 }
 
 int
-ahd_dchseqbcnt_print(u_int regvalue, u_int *cur_col, u_int wrap)
+ahd_cmcseqbcnt_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
-        return (ahd_print_register(NULL, 0, "DCHSEQBCNT",
+        return (ahd_print_register(NULL, 0, "CMCSEQBCNT",
             0x94, regvalue, cur_col, wrap));
 }
 
@@ -2101,7 +2101,7 @@ ahd_cmcspltstat0_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x96, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t OVLYSPLTSTAT0_parse_table[] = {
+static ahd_reg_parse_entry_t DCHSPLTSTAT0_parse_table[] = {
         { "RXSPLTRSP",          0x01, 0x01 },
         { "RXSCEMSG",           0x02, 0x02 },
         { "RXOVRUN",            0x04, 0x04 },
@@ -2113,13 +2113,13 @@ static ahd_reg_parse_entry_t OVLYSPLTSTAT0_parse_table[] = {
 };
 
 int
-ahd_ovlyspltstat0_print(u_int regvalue, u_int *cur_col, u_int wrap)
+ahd_dchspltstat0_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
-        return (ahd_print_register(OVLYSPLTSTAT0_parse_table, 8, "OVLYSPLTSTAT0",
+        return (ahd_print_register(DCHSPLTSTAT0_parse_table, 8, "DCHSPLTSTAT0",
             0x96, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t DCHSPLTSTAT0_parse_table[] = {
+static ahd_reg_parse_entry_t OVLYSPLTSTAT0_parse_table[] = {
         { "RXSPLTRSP",          0x01, 0x01 },
         { "RXSCEMSG",           0x02, 0x02 },
         { "RXOVRUN",            0x04, 0x04 },
@@ -2131,42 +2131,42 @@ static ahd_reg_parse_entry_t DCHSPLTSTAT0_parse_table[] = {
 };
 
 int
-ahd_dchspltstat0_print(u_int regvalue, u_int *cur_col, u_int wrap)
+ahd_ovlyspltstat0_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
-        return (ahd_print_register(DCHSPLTSTAT0_parse_table, 8, "DCHSPLTSTAT0",
+        return (ahd_print_register(OVLYSPLTSTAT0_parse_table, 8, "OVLYSPLTSTAT0",
             0x96, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t DCHSPLTSTAT1_parse_table[] = {
+static ahd_reg_parse_entry_t CMCSPLTSTAT1_parse_table[] = {
         { "RXDATABUCKET",       0x01, 0x01 }
 };
 
 int
-ahd_dchspltstat1_print(u_int regvalue, u_int *cur_col, u_int wrap)
+ahd_cmcspltstat1_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
-        return (ahd_print_register(DCHSPLTSTAT1_parse_table, 1, "DCHSPLTSTAT1",
+        return (ahd_print_register(CMCSPLTSTAT1_parse_table, 1, "CMCSPLTSTAT1",
             0x97, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t CMCSPLTSTAT1_parse_table[] = {
+static ahd_reg_parse_entry_t OVLYSPLTSTAT1_parse_table[] = {
         { "RXDATABUCKET",       0x01, 0x01 }
 };
 
 int
-ahd_cmcspltstat1_print(u_int regvalue, u_int *cur_col, u_int wrap)
+ahd_ovlyspltstat1_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
-        return (ahd_print_register(CMCSPLTSTAT1_parse_table, 1, "CMCSPLTSTAT1",
+        return (ahd_print_register(OVLYSPLTSTAT1_parse_table, 1, "OVLYSPLTSTAT1",
             0x97, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t OVLYSPLTSTAT1_parse_table[] = {
+static ahd_reg_parse_entry_t DCHSPLTSTAT1_parse_table[] = {
         { "RXDATABUCKET",       0x01, 0x01 }
 };
 
 int
-ahd_ovlyspltstat1_print(u_int regvalue, u_int *cur_col, u_int wrap)
+ahd_dchspltstat1_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
-        return (ahd_print_register(OVLYSPLTSTAT1_parse_table, 1, "OVLYSPLTSTAT1",
+        return (ahd_print_register(DCHSPLTSTAT1_parse_table, 1, "DCHSPLTSTAT1",
             0x97, regvalue, cur_col, wrap));
 }
 
@@ -2320,26 +2320,26 @@ ahd_sgspltstat0_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x9e, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t SFUNCT_parse_table[] = {
-        { "TEST_NUM",           0x0f, 0x0f },
-        { "TEST_GROUP",         0xf0, 0xf0 }
+static ahd_reg_parse_entry_t SGSPLTSTAT1_parse_table[] = {
+        { "RXDATABUCKET",       0x01, 0x01 }
 };
 
 int
-ahd_sfunct_print(u_int regvalue, u_int *cur_col, u_int wrap)
+ahd_sgspltstat1_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
-        return (ahd_print_register(SFUNCT_parse_table, 2, "SFUNCT",
+        return (ahd_print_register(SGSPLTSTAT1_parse_table, 1, "SGSPLTSTAT1",
             0x9f, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t SGSPLTSTAT1_parse_table[] = {
-        { "RXDATABUCKET",       0x01, 0x01 }
+static ahd_reg_parse_entry_t SFUNCT_parse_table[] = {
+        { "TEST_NUM",           0x0f, 0x0f },
+        { "TEST_GROUP",         0xf0, 0xf0 }
 };
 
 int
-ahd_sgspltstat1_print(u_int regvalue, u_int *cur_col, u_int wrap)
+ahd_sfunct_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
-        return (ahd_print_register(SGSPLTSTAT1_parse_table, 1, "SGSPLTSTAT1",
+        return (ahd_print_register(SFUNCT_parse_table, 2, "SFUNCT",
             0x9f, regvalue, cur_col, wrap));
 }
 
@@ -2537,16 +2537,16 @@ ahd_ccsgaddr_print(u_int regvalue, u_int *cur_col, u_int wrap)
 }
 
 int
-ahd_ccscbaddr_print(u_int regvalue, u_int *cur_col, u_int wrap)
+ahd_ccscbadr_bk_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
-        return (ahd_print_register(NULL, 0, "CCSCBADDR",
+        return (ahd_print_register(NULL, 0, "CCSCBADR_BK",
             0xac, regvalue, cur_col, wrap));
 }
 
 int
-ahd_ccscbadr_bk_print(u_int regvalue, u_int *cur_col, u_int wrap)
+ahd_ccscbaddr_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
-        return (ahd_print_register(NULL, 0, "CCSCBADR_BK",
+        return (ahd_print_register(NULL, 0, "CCSCBADDR",
             0xac, regvalue, cur_col, wrap));
 }
 
@@ -2566,22 +2566,6 @@ ahd_cmc_rambist_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0xad, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t CCSGCTL_parse_table[] = {
-        { "CCSGRESET",          0x01, 0x01 },
-        { "SG_FETCH_REQ",       0x02, 0x02 },
-        { "CCSGENACK",          0x08, 0x08 },
-        { "SG_CACHE_AVAIL",     0x10, 0x10 },
-        { "CCSGDONE",           0x80, 0x80 },
-        { "CCSGEN",             0x0c, 0x0c }
-};
-
-int
-ahd_ccsgctl_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(CCSGCTL_parse_table, 6, "CCSGCTL",
-            0xad, regvalue, cur_col, wrap));
-}
-
 static ahd_reg_parse_entry_t CCSCBCTL_parse_table[] = {
         { "CCSCBRESET",         0x01, 0x01 },
         { "CCSCBDIR",           0x04, 0x04 },
@@ -2598,6 +2582,22 @@ ahd_ccscbctl_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0xad, regvalue, cur_col, wrap));
 }
 
+static ahd_reg_parse_entry_t CCSGCTL_parse_table[] = {
+        { "CCSGRESET",          0x01, 0x01 },
+        { "SG_FETCH_REQ",       0x02, 0x02 },
+        { "CCSGENACK",          0x08, 0x08 },
+        { "SG_CACHE_AVAIL",     0x10, 0x10 },
+        { "CCSGDONE",           0x80, 0x80 },
+        { "CCSGEN",             0x0c, 0x0c }
+};
+
+int
+ahd_ccsgctl_print(u_int regvalue, u_int *cur_col, u_int wrap)
+{
+        return (ahd_print_register(CCSGCTL_parse_table, 6, "CCSGCTL",
+            0xad, regvalue, cur_col, wrap));
+}
+
 int
 ahd_ccsgram_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
@@ -2841,30 +2841,30 @@ ahd_wrtbiascalc_print(u_int regvalue, u_int *cur_col, u_int wrap)
 }
 
 int
-ahd_dfptrs_print(u_int regvalue, u_int *cur_col, u_int wrap)
+ahd_rcvrbiascalc_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
-        return (ahd_print_register(NULL, 0, "DFPTRS",
+        return (ahd_print_register(NULL, 0, "RCVRBIASCALC",
             0xc8, regvalue, cur_col, wrap));
 }
 
 int
-ahd_rcvrbiascalc_print(u_int regvalue, u_int *cur_col, u_int wrap)
+ahd_dfptrs_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
-        return (ahd_print_register(NULL, 0, "RCVRBIASCALC",
+        return (ahd_print_register(NULL, 0, "DFPTRS",
             0xc8, regvalue, cur_col, wrap));
 }
 
 int
-ahd_dfbkptr_print(u_int regvalue, u_int *cur_col, u_int wrap)
+ahd_skewcalc_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
-        return (ahd_print_register(NULL, 0, "DFBKPTR",
+        return (ahd_print_register(NULL, 0, "SKEWCALC",
             0xc9, regvalue, cur_col, wrap));
 }
 
 int
-ahd_skewcalc_print(u_int regvalue, u_int *cur_col, u_int wrap)
+ahd_dfbkptr_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
-        return (ahd_print_register(NULL, 0, "SKEWCALC",
+        return (ahd_print_register(NULL, 0, "DFBKPTR",
             0xc9, regvalue, cur_col, wrap));
 }
 
@@ -3001,6 +3001,13 @@ ahd_dindex_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0xe4, regvalue, cur_col, wrap));
 }
 
+int
+ahd_brkaddr0_print(u_int regvalue, u_int *cur_col, u_int wrap)
+{
+        return (ahd_print_register(NULL, 0, "BRKADDR0",
+            0xe6, regvalue, cur_col, wrap));
+}
+
 static ahd_reg_parse_entry_t BRKADDR1_parse_table[] = {
         { "BRKDIS",             0x80, 0x80 }
 };
@@ -3013,13 +3020,6 @@ ahd_brkaddr1_print(u_int regvalue, u_int *cur_col, u_int wrap)
 }
 
 int
-ahd_brkaddr0_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(NULL, 0, "BRKADDR0",
-            0xe6, regvalue, cur_col, wrap));
-}
-
-int
 ahd_allones_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
         return (ahd_print_register(NULL, 0, "ALLONES",
@@ -3069,30 +3069,30 @@ ahd_stack_print(u_int regvalue, u_int *cur_col, u_int wrap)
 }
 
 int
-ahd_curaddr_print(u_int regvalue, u_int *cur_col, u_int wrap)
+ahd_intvec1_addr_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
-        return (ahd_print_register(NULL, 0, "CURADDR",
+        return (ahd_print_register(NULL, 0, "INTVEC1_ADDR",
             0xf4, regvalue, cur_col, wrap));
 }
 
 int
-ahd_intvec1_addr_print(u_int regvalue, u_int *cur_col, u_int wrap)
+ahd_curaddr_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
-        return (ahd_print_register(NULL, 0, "INTVEC1_ADDR",
+        return (ahd_print_register(NULL, 0, "CURADDR",
             0xf4, regvalue, cur_col, wrap));
 }
 
 int
-ahd_intvec2_addr_print(u_int regvalue, u_int *cur_col, u_int wrap)
+ahd_lastaddr_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
-        return (ahd_print_register(NULL, 0, "INTVEC2_ADDR",
+        return (ahd_print_register(NULL, 0, "LASTADDR",
             0xf6, regvalue, cur_col, wrap));
 }
 
 int
-ahd_lastaddr_print(u_int regvalue, u_int *cur_col, u_int wrap)
+ahd_intvec2_addr_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
-        return (ahd_print_register(NULL, 0, "LASTADDR",
+        return (ahd_print_register(NULL, 0, "INTVEC2_ADDR",
             0xf6, regvalue, cur_col, wrap));
 }
 
@@ -3174,24 +3174,45 @@ ahd_complete_dma_scb_head_print(u_int regvalue, u_int *cur_col, u_int wrap)
 }
 
 int
+ahd_complete_dma_scb_tail_print(u_int regvalue, u_int *cur_col, u_int wrap)
+{
+        return (ahd_print_register(NULL, 0, "COMPLETE_DMA_SCB_TAIL",
+            0x12e, regvalue, cur_col, wrap));
+}
+
+int
+ahd_complete_on_qfreeze_head_print(u_int regvalue, u_int *cur_col, u_int wrap)
+{
+        return (ahd_print_register(NULL, 0, "COMPLETE_ON_QFREEZE_HEAD",
+            0x130, regvalue, cur_col, wrap));
+}
+
+int
 ahd_qfreeze_count_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
         return (ahd_print_register(NULL, 0, "QFREEZE_COUNT",
-            0x12e, regvalue, cur_col, wrap));
+            0x132, regvalue, cur_col, wrap));
+}
+
+int
+ahd_kernel_qfreeze_count_print(u_int regvalue, u_int *cur_col, u_int wrap)
+{
+        return (ahd_print_register(NULL, 0, "KERNEL_QFREEZE_COUNT",
+            0x134, regvalue, cur_col, wrap));
 }
 
 int
 ahd_saved_mode_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
         return (ahd_print_register(NULL, 0, "SAVED_MODE",
-            0x130, regvalue, cur_col, wrap));
+            0x136, regvalue, cur_col, wrap));
 }
 
 int
 ahd_msg_out_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
         return (ahd_print_register(NULL, 0, "MSG_OUT",
-            0x131, regvalue, cur_col, wrap));
+            0x137, regvalue, cur_col, wrap));
 }
 
 static ahd_reg_parse_entry_t DMAPARAMS_parse_table[] = {
@@ -3211,7 +3232,7 @@ int
 ahd_dmaparams_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
         return (ahd_print_register(DMAPARAMS_parse_table, 10, "DMAPARAMS",
-            0x132, regvalue, cur_col, wrap));
+            0x138, regvalue, cur_col, wrap));
 }
 
 static ahd_reg_parse_entry_t SEQ_FLAGS_parse_table[] = {
@@ -3230,21 +3251,21 @@ int
 ahd_seq_flags_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
         return (ahd_print_register(SEQ_FLAGS_parse_table, 9, "SEQ_FLAGS",
-            0x133, regvalue, cur_col, wrap));
+            0x139, regvalue, cur_col, wrap));
 }
 
 int
 ahd_saved_scsiid_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
         return (ahd_print_register(NULL, 0, "SAVED_SCSIID",
-            0x134, regvalue, cur_col, wrap));
+            0x13a, regvalue, cur_col, wrap));
 }
 
 int
 ahd_saved_lun_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
         return (ahd_print_register(NULL, 0, "SAVED_LUN",
-            0x135, regvalue, cur_col, wrap));
+            0x13b, regvalue, cur_col, wrap));
 }
 
 static ahd_reg_parse_entry_t LASTPHASE_parse_table[] = {
@@ -3267,42 +3288,42 @@ int
 ahd_lastphase_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
         return (ahd_print_register(LASTPHASE_parse_table, 13, "LASTPHASE",
-            0x136, regvalue, cur_col, wrap));
+            0x13c, regvalue, cur_col, wrap));
 }
 
 int
 ahd_qoutfifo_entry_valid_tag_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
         return (ahd_print_register(NULL, 0, "QOUTFIFO_ENTRY_VALID_TAG",
-            0x137, regvalue, cur_col, wrap));
+            0x13d, regvalue, cur_col, wrap));
 }
 
 int
-ahd_shared_data_addr_print(u_int regvalue, u_int *cur_col, u_int wrap)
+ahd_kernel_tqinpos_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
-        return (ahd_print_register(NULL, 0, "SHARED_DATA_ADDR",
-            0x138, regvalue, cur_col, wrap));
+        return (ahd_print_register(NULL, 0, "KERNEL_TQINPOS",
+            0x13e, regvalue, cur_col, wrap));
 }
 
 int
-ahd_qoutfifo_next_addr_print(u_int regvalue, u_int *cur_col, u_int wrap)
+ahd_tqinpos_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
-        return (ahd_print_register(NULL, 0, "QOUTFIFO_NEXT_ADDR",
-            0x13c, regvalue, cur_col, wrap));
+        return (ahd_print_register(NULL, 0, "TQINPOS",
+            0x13f, regvalue, cur_col, wrap));
 }
 
 int
-ahd_kernel_tqinpos_print(u_int regvalue, u_int *cur_col, u_int wrap)
+ahd_shared_data_addr_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
-        return (ahd_print_register(NULL, 0, "KERNEL_TQINPOS",
+        return (ahd_print_register(NULL, 0, "SHARED_DATA_ADDR",
             0x140, regvalue, cur_col, wrap));
 }
 
 int
-ahd_tqinpos_print(u_int regvalue, u_int *cur_col, u_int wrap)
+ahd_qoutfifo_next_addr_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
-        return (ahd_print_register(NULL, 0, "TQINPOS",
-            0x141, regvalue, cur_col, wrap));
+        return (ahd_print_register(NULL, 0, "QOUTFIFO_NEXT_ADDR",
+            0x144, regvalue, cur_col, wrap));
 }
 
 static ahd_reg_parse_entry_t ARG_1_parse_table[] = {
@@ -3320,21 +3341,21 @@ int
 ahd_arg_1_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
         return (ahd_print_register(ARG_1_parse_table, 8, "ARG_1",
-            0x142, regvalue, cur_col, wrap));
+            0x148, regvalue, cur_col, wrap));
 }
 
 int
 ahd_arg_2_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
         return (ahd_print_register(NULL, 0, "ARG_2",
-            0x143, regvalue, cur_col, wrap));
+            0x149, regvalue, cur_col, wrap));
 }
 
 int
 ahd_last_msg_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
         return (ahd_print_register(NULL, 0, "LAST_MSG",
-            0x144, regvalue, cur_col, wrap));
+            0x14a, regvalue, cur_col, wrap));
 }
 
 static ahd_reg_parse_entry_t SCSISEQ_TEMPLATE_parse_table[] = {
@@ -3350,14 +3371,14 @@ int
 ahd_scsiseq_template_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
         return (ahd_print_register(SCSISEQ_TEMPLATE_parse_table, 6, "SCSISEQ_TEMPLATE",
-            0x145, regvalue, cur_col, wrap));
+            0x14b, regvalue, cur_col, wrap));
 }
 
 int
 ahd_initiator_tag_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
         return (ahd_print_register(NULL, 0, "INITIATOR_TAG",
-            0x146, regvalue, cur_col, wrap));
+            0x14c, regvalue, cur_col, wrap));
 }
 
 static ahd_reg_parse_entry_t SEQ_FLAGS2_parse_table[] = {
@@ -3369,63 +3390,63 @@ int
 ahd_seq_flags2_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
         return (ahd_print_register(SEQ_FLAGS2_parse_table, 2, "SEQ_FLAGS2",
-            0x147, regvalue, cur_col, wrap));
+            0x14d, regvalue, cur_col, wrap));
 }
 
 int
 ahd_allocfifo_scbptr_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
         return (ahd_print_register(NULL, 0, "ALLOCFIFO_SCBPTR",
-            0x148, regvalue, cur_col, wrap));
+            0x14e, regvalue, cur_col, wrap));
 }
 
 int
 ahd_int_coalescing_timer_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
         return (ahd_print_register(NULL, 0, "INT_COALESCING_TIMER",
-            0x14a, regvalue, cur_col, wrap));
+            0x150, regvalue, cur_col, wrap));
 }
 
 int
 ahd_int_coalescing_maxcmds_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
         return (ahd_print_register(NULL, 0, "INT_COALESCING_MAXCMDS",
-            0x14c, regvalue, cur_col, wrap));
+            0x152, regvalue, cur_col, wrap));
 }
 
 int
 ahd_int_coalescing_mincmds_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
         return (ahd_print_register(NULL, 0, "INT_COALESCING_MINCMDS",
-            0x14d, regvalue, cur_col, wrap));
+            0x153, regvalue, cur_col, wrap));
 }
 
 int
 ahd_cmds_pending_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
         return (ahd_print_register(NULL, 0, "CMDS_PENDING",
-            0x14e, regvalue, cur_col, wrap));
+            0x154, regvalue, cur_col, wrap));
 }
 
 int
 ahd_int_coalescing_cmdcount_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
         return (ahd_print_register(NULL, 0, "INT_COALESCING_CMDCOUNT",
-            0x150, regvalue, cur_col, wrap));
+            0x156, regvalue, cur_col, wrap));
 }
 
 int
 ahd_local_hs_mailbox_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
         return (ahd_print_register(NULL, 0, "LOCAL_HS_MAILBOX",
-            0x151, regvalue, cur_col, wrap));
+            0x157, regvalue, cur_col, wrap));
 }
 
 int
 ahd_cmdsize_table_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
         return (ahd_print_register(NULL, 0, "CMDSIZE_TABLE",
-            0x152, regvalue, cur_col, wrap));
+            0x158, regvalue, cur_col, wrap));
 }
 
 int
diff --git a/drivers/scsi/aic7xxx/aic79xx_seq.h_shipped b/drivers/scsi/aic7xxx/aic79xx_seq.h_shipped
index 77c471f934e0..b1e5365be230 100644
--- a/drivers/scsi/aic7xxx/aic79xx_seq.h_shipped
+++ b/drivers/scsi/aic7xxx/aic79xx_seq.h_shipped
@@ -2,215 +2,228 @@
  * DO NOT EDIT - This file is automatically generated
  *               from the following source files:
  *
- * $Id: //depot/aic7xxx/aic7xxx/aic79xx.seq#94 $
- * $Id: //depot/aic7xxx/aic7xxx/aic79xx.reg#70 $
+ * $Id: //depot/aic7xxx/aic7xxx/aic79xx.seq#119 $
+ * $Id: //depot/aic7xxx/aic7xxx/aic79xx.reg#76 $
  */
 static uint8_t seqprog[] = {
         0xff, 0x02, 0x06, 0x78,
-        0x00, 0xea, 0x50, 0x59,
+        0x00, 0xea, 0x64, 0x59,
         0x01, 0xea, 0x04, 0x30,
         0xff, 0x04, 0x0c, 0x78,
-        0x19, 0xea, 0x50, 0x59,
+        0x19, 0xea, 0x64, 0x59,
         0x19, 0xea, 0x04, 0x00,
-        0x33, 0xea, 0x44, 0x59,
+        0x33, 0xea, 0x5e, 0x59,
         0x33, 0xea, 0x00, 0x00,
-        0x60, 0x3a, 0x1a, 0x68,
-        0x04, 0x47, 0x1b, 0x68,
-        0xff, 0x21, 0x1b, 0x70,
-        0x40, 0x4b, 0x92, 0x69,
-        0x00, 0xe2, 0x54, 0x59,
-        0x40, 0x4b, 0x92, 0x69,
-        0x20, 0x4b, 0x82, 0x69,
-        0xfc, 0x42, 0x24, 0x78,
-        0x10, 0x40, 0x24, 0x78,
-        0x00, 0xe2, 0xc4, 0x5d,
-        0x20, 0x4d, 0x28, 0x78,
-        0x00, 0xe2, 0xc4, 0x5d,
+        0x60, 0x3a, 0x3a, 0x68,
+        0x04, 0x4d, 0x35, 0x78,
+        0x01, 0x34, 0xc1, 0x31,
+        0x00, 0x32, 0x21, 0x60,
+        0x01, 0x35, 0xc1, 0x31,
+        0x00, 0x33, 0x21, 0x60,
+        0xfb, 0x4d, 0x9b, 0x0a,
+        0x00, 0xe2, 0x34, 0x40,
+        0x50, 0x4b, 0x3a, 0x68,
+        0xff, 0x31, 0x3b, 0x70,
+        0x02, 0x30, 0x51, 0x31,
+        0xff, 0x8d, 0x2d, 0x70,
+        0x02, 0x8c, 0x51, 0x31,
+        0xff, 0x8d, 0x29, 0x60,
+        0x02, 0x28, 0x19, 0x33,
+        0x02, 0x30, 0x51, 0x32,
+        0xff, 0xea, 0x62, 0x02,
+        0x00, 0xe2, 0x3a, 0x40,
+        0xff, 0x21, 0x3b, 0x70,
+        0x40, 0x4b, 0xaa, 0x69,
+        0x00, 0xe2, 0x68, 0x59,
+        0x40, 0x4b, 0xaa, 0x69,
+        0x20, 0x4b, 0x96, 0x69,
+        0xfc, 0x42, 0x44, 0x78,
+        0x10, 0x40, 0x44, 0x78,
+        0x00, 0xe2, 0xfc, 0x5d,
+        0x20, 0x4d, 0x48, 0x78,
+        0x00, 0xe2, 0xfc, 0x5d,
         0x30, 0x3f, 0xc0, 0x09,
-        0x30, 0xe0, 0x30, 0x60,
+        0x30, 0xe0, 0x50, 0x60,
         0x7f, 0x4a, 0x94, 0x08,
-        0x00, 0xe2, 0x32, 0x40,
+        0x00, 0xe2, 0x52, 0x40,
         0xc0, 0x4a, 0x94, 0x00,
-        0x00, 0xe2, 0x3e, 0x58,
-        0x00, 0xe2, 0x56, 0x58,
-        0x00, 0xe2, 0x66, 0x58,
+        0x00, 0xe2, 0x5e, 0x58,
+        0x00, 0xe2, 0x76, 0x58,
+        0x00, 0xe2, 0x86, 0x58,
         0x00, 0xe2, 0x06, 0x40,
-        0x33, 0xea, 0x44, 0x59,
+        0x33, 0xea, 0x5e, 0x59,
         0x33, 0xea, 0x00, 0x00,
-        0x01, 0x52, 0x64, 0x78,
+        0x01, 0x52, 0x84, 0x78,
         0x02, 0x58, 0x50, 0x31,
         0xff, 0xea, 0x10, 0x0b,
-        0xff, 0x97, 0x4f, 0x78,
-        0x50, 0x4b, 0x4a, 0x68,
+        0xff, 0x97, 0x6f, 0x78,
+        0x50, 0x4b, 0x6a, 0x68,
         0xbf, 0x3a, 0x74, 0x08,
-        0x14, 0xea, 0x50, 0x59,
+        0x14, 0xea, 0x64, 0x59,
         0x14, 0xea, 0x04, 0x00,
         0x08, 0x92, 0x25, 0x03,
-        0xff, 0x90, 0x3f, 0x68,
-        0x00, 0xe2, 0x56, 0x5b,
-        0x00, 0xe2, 0x3e, 0x40,
-        0x00, 0xea, 0x44, 0x59,
+        0xff, 0x90, 0x5f, 0x68,
+        0x00, 0xe2, 0x76, 0x5b,
+        0x00, 0xe2, 0x5e, 0x40,
+        0x00, 0xea, 0x5e, 0x59,
         0x01, 0xea, 0x00, 0x30,
-        0x80, 0xf9, 0x5e, 0x68,
-        0x00, 0xe2, 0x42, 0x59,
-        0x11, 0xea, 0x44, 0x59,
+        0x80, 0xf9, 0x7e, 0x68,
+        0x00, 0xe2, 0x5c, 0x59,
+        0x11, 0xea, 0x5e, 0x59,
         0x11, 0xea, 0x00, 0x00,
-        0x80, 0xf9, 0x42, 0x79,
+        0x80, 0xf9, 0x5c, 0x79,
         0xff, 0xea, 0xd4, 0x0d,
-        0x22, 0xea, 0x44, 0x59,
+        0x22, 0xea, 0x5e, 0x59,
         0x22, 0xea, 0x00, 0x00,
-        0x10, 0x16, 0x70, 0x78,
-        0x01, 0x0b, 0xa2, 0x32,
+        0x10, 0x16, 0x90, 0x78,
         0x10, 0x16, 0x2c, 0x00,
-        0x18, 0xad, 0x00, 0x79,
-        0x04, 0xad, 0xca, 0x68,
-        0x80, 0xad, 0x64, 0x78,
-        0x10, 0xad, 0x98, 0x78,
-        0xff, 0x88, 0x83, 0x68,
+        0x01, 0x0b, 0xae, 0x32,
+        0x18, 0xad, 0x12, 0x79,
+        0x04, 0xad, 0xdc, 0x68,
+        0x80, 0xad, 0x84, 0x78,
+        0x10, 0xad, 0xaa, 0x78,
         0xe7, 0xad, 0x5a, 0x09,
         0x02, 0x8c, 0x59, 0x32,
+        0xff, 0x8d, 0xa1, 0x60,
+        0xff, 0xea, 0x5e, 0x02,
+        0xff, 0x88, 0xa7, 0x78,
+        0x02, 0x30, 0x19, 0x33,
+        0x02, 0xa8, 0x60, 0x36,
         0x02, 0x28, 0x19, 0x33,
         0x02, 0xa8, 0x50, 0x36,
-        0x33, 0xea, 0x44, 0x59,
-        0x33, 0xea, 0x00, 0x00,
-        0x40, 0x3a, 0x64, 0x68,
-        0x50, 0x4b, 0x64, 0x68,
-        0x22, 0xea, 0x44, 0x59,
-        0x22, 0xea, 0x00, 0x00,
-        0xe7, 0xad, 0x5a, 0x09,
-        0x02, 0x8c, 0x59, 0x32,
-        0x1a, 0xea, 0x50, 0x59,
-        0x1a, 0xea, 0x04, 0x00,
-        0xff, 0xea, 0xd4, 0x0d,
         0xe7, 0xad, 0x5a, 0x09,
-        0x00, 0xe2, 0xa6, 0x58,
+        0x00, 0xe2, 0xb8, 0x58,
         0xff, 0xea, 0x56, 0x02,
-        0x04, 0x7c, 0x78, 0x32,
-        0x20, 0x16, 0x64, 0x78,
-        0x04, 0x38, 0x79, 0x32,
-        0x80, 0x37, 0x6f, 0x16,
-        0xff, 0x2d, 0xb5, 0x60,
-        0xff, 0x29, 0xb5, 0x60,
-        0x40, 0x51, 0xc5, 0x78,
-        0xff, 0x4f, 0xb5, 0x68,
-        0xff, 0x4d, 0xc1, 0x19,
-        0x00, 0x4e, 0xd5, 0x19,
-        0x00, 0xe2, 0xc4, 0x50,
-        0x01, 0x4c, 0xc1, 0x31,
-        0x00, 0x50, 0xd5, 0x19,
-        0x00, 0xe2, 0xc4, 0x48,
-        0x80, 0x18, 0x64, 0x78,
-        0x02, 0x4a, 0x1d, 0x30,
+        0x04, 0x7c, 0x88, 0x32,
+        0x20, 0x16, 0x84, 0x78,
+        0x04, 0x40, 0x89, 0x32,
+        0x80, 0x3d, 0x7b, 0x16,
+        0xff, 0x2d, 0xc7, 0x60,
+        0xff, 0x29, 0xc7, 0x60,
+        0x40, 0x57, 0xd7, 0x78,
+        0xff, 0x55, 0xc7, 0x68,
+        0xff, 0x53, 0xc1, 0x19,
+        0x00, 0x54, 0xd5, 0x19,
+        0x00, 0xe2, 0xd6, 0x50,
+        0x01, 0x52, 0xc1, 0x31,
+        0x00, 0x56, 0xd5, 0x19,
+        0x00, 0xe2, 0xd6, 0x48,
+        0x80, 0x18, 0x84, 0x78,
+        0x02, 0x50, 0x1d, 0x30,
         0x10, 0xea, 0x18, 0x00,
         0x60, 0x18, 0x30, 0x00,
         0x7f, 0x18, 0x30, 0x0c,
         0x02, 0xea, 0x02, 0x00,
-        0xff, 0xea, 0xa0, 0x0a,
+        0xff, 0xea, 0xac, 0x0a,
         0x80, 0x18, 0x30, 0x04,
-        0x40, 0xad, 0x64, 0x78,
+        0x40, 0xad, 0x84, 0x78,
         0xe7, 0xad, 0x5a, 0x09,
         0x02, 0xa8, 0x40, 0x31,
         0xff, 0xea, 0xc0, 0x09,
-        0x01, 0x4e, 0x9d, 0x1a,
-        0x00, 0x4f, 0x9f, 0x22,
+        0x01, 0x54, 0xa9, 0x1a,
+        0x00, 0x55, 0xab, 0x22,
         0x01, 0x94, 0x6d, 0x33,
-        0x01, 0xea, 0x20, 0x33,
+        0xff, 0xea, 0x20, 0x0b,
         0x04, 0xac, 0x49, 0x32,
         0xff, 0xea, 0x5a, 0x03,
         0xff, 0xea, 0x5e, 0x03,
         0x01, 0x10, 0xd4, 0x31,
-        0x10, 0x92, 0xf5, 0x68,
+        0x10, 0x92, 0x07, 0x69,
         0x3d, 0x93, 0xc5, 0x29,
         0xfe, 0xe2, 0xc4, 0x09,
         0x01, 0xea, 0xc6, 0x01,
         0x02, 0xe2, 0xc8, 0x31,
         0x02, 0xec, 0x50, 0x31,
         0x02, 0xa0, 0xda, 0x31,
-        0xff, 0xa9, 0xf4, 0x70,
+        0xff, 0xa9, 0x06, 0x71,
         0x02, 0xa0, 0x58, 0x37,
-        0xff, 0x21, 0xfd, 0x70,
+        0xff, 0x21, 0x0f, 0x71,
         0x02, 0x22, 0x51, 0x31,
         0x02, 0xa0, 0x5c, 0x33,
         0x02, 0xa0, 0x44, 0x36,
         0x02, 0xa0, 0x40, 0x32,
         0x02, 0xa0, 0x44, 0x36,
-        0x04, 0x47, 0x05, 0x69,
-        0x40, 0x16, 0x30, 0x69,
-        0xff, 0x2d, 0x35, 0x61,
-        0xff, 0x29, 0x65, 0x70,
-        0x01, 0x37, 0xc1, 0x31,
+        0x04, 0x4d, 0x17, 0x69,
+        0x40, 0x16, 0x48, 0x69,
+        0xff, 0x2d, 0x4d, 0x61,
+        0xff, 0x29, 0x85, 0x70,
         0x02, 0x28, 0x55, 0x32,
         0x01, 0xea, 0x5a, 0x01,
-        0x04, 0x3c, 0xf9, 0x30,
+        0x04, 0x44, 0xf9, 0x30,
+        0x01, 0x44, 0xc1, 0x31,
         0x02, 0x28, 0x51, 0x31,
-        0x01, 0xa8, 0x60, 0x31,
-        0x00, 0xa9, 0x60, 0x01,
+        0x02, 0xa8, 0x60, 0x31,
+        0x01, 0xa4, 0x61, 0x31,
+        0x01, 0x3d, 0x61, 0x31,
         0x01, 0x14, 0xd4, 0x31,
-        0x01, 0x50, 0xa1, 0x1a,
-        0xff, 0x4e, 0x9d, 0x1a,
-        0xff, 0x4f, 0x9f, 0x22,
-        0xff, 0x8d, 0x29, 0x71,
-        0x80, 0xac, 0x28, 0x71,
-        0x20, 0x16, 0x28, 0x69,
+        0x01, 0x56, 0xad, 0x1a,
+        0xff, 0x54, 0xa9, 0x1a,
+        0xff, 0x55, 0xab, 0x22,
+        0xff, 0x8d, 0x41, 0x71,
+        0x80, 0xac, 0x40, 0x71,
+        0x20, 0x16, 0x40, 0x69,
+        0x00, 0xac, 0xc4, 0x19,
+        0x07, 0xe2, 0x40, 0xf9,
         0x02, 0x8c, 0x51, 0x31,
-        0x00, 0xe2, 0x12, 0x41,
+        0x00, 0xe2, 0x24, 0x41,
         0x01, 0xac, 0x08, 0x31,
         0x09, 0xea, 0x5a, 0x01,
         0x02, 0x8c, 0x51, 0x32,
         0xff, 0xea, 0x1a, 0x07,
         0x04, 0x24, 0xf9, 0x30,
-        0x1d, 0xea, 0x3a, 0x41,
+        0x1d, 0xea, 0x52, 0x41,
         0x02, 0x2c, 0x51, 0x31,
         0x04, 0xa8, 0xf9, 0x30,
-        0x19, 0xea, 0x3a, 0x41,
+        0x19, 0xea, 0x52, 0x41,
         0x06, 0xea, 0x08, 0x81,
         0x01, 0xe2, 0x5a, 0x35,
-        0x02, 0xf2, 0xf0, 0x35,
+        0x02, 0xf2, 0xf0, 0x31,
+        0xff, 0xea, 0xd4, 0x0d,
         0x02, 0xf2, 0xf0, 0x31,
         0x02, 0xf8, 0xe4, 0x35,
         0x80, 0xea, 0xb2, 0x01,
         0x01, 0xe2, 0x00, 0x30,
         0xff, 0xea, 0xb2, 0x0d,
-        0x80, 0xea, 0xb2, 0x01,
-        0x11, 0x00, 0x00, 0x10,
-        0xff, 0xea, 0xb2, 0x0d,
         0x01, 0xe2, 0x04, 0x30,
         0x01, 0xea, 0x04, 0x34,
         0x02, 0x20, 0xbd, 0x30,
         0x02, 0x20, 0xb9, 0x30,
         0x02, 0x20, 0x51, 0x31,
         0x4c, 0x93, 0xd7, 0x28,
-        0x10, 0x92, 0x63, 0x79,
+        0x10, 0x92, 0x77, 0x79,
         0x01, 0x6b, 0xc0, 0x30,
         0x02, 0x64, 0xc8, 0x00,
         0x40, 0x3a, 0x74, 0x04,
-        0x00, 0xe2, 0x56, 0x58,
-        0x33, 0xea, 0x44, 0x59,
+        0x00, 0xe2, 0x76, 0x58,
+        0x33, 0xea, 0x5e, 0x59,
         0x33, 0xea, 0x00, 0x00,
         0x30, 0x3f, 0xc0, 0x09,
-        0x30, 0xe0, 0x64, 0x61,
-        0x20, 0x3f, 0x7a, 0x69,
-        0x10, 0x3f, 0x64, 0x79,
+        0x30, 0xe0, 0x78, 0x61,
+        0x20, 0x3f, 0x8e, 0x69,
+        0x10, 0x3f, 0x78, 0x79,
         0x02, 0xea, 0x7e, 0x00,
-        0x00, 0xea, 0x44, 0x59,
+        0x00, 0xea, 0x5e, 0x59,
         0x01, 0xea, 0x00, 0x30,
-        0x02, 0x48, 0x51, 0x35,
+        0x02, 0x4e, 0x51, 0x35,
         0x01, 0xea, 0x7e, 0x00,
-        0x11, 0xea, 0x44, 0x59,
+        0x11, 0xea, 0x5e, 0x59,
         0x11, 0xea, 0x00, 0x00,
-        0x02, 0x48, 0x51, 0x35,
+        0x02, 0x4e, 0x51, 0x35,
+        0xc0, 0x4a, 0x94, 0x00,
+        0x04, 0x41, 0x9c, 0x79,
         0x08, 0xea, 0x98, 0x00,
         0x08, 0x57, 0xae, 0x00,
         0x08, 0x3c, 0x78, 0x00,
-        0xf0, 0x49, 0x68, 0x0a,
+        0xf0, 0x49, 0x74, 0x0a,
         0x0f, 0x67, 0xc0, 0x09,
-        0x00, 0x34, 0x69, 0x02,
+        0x00, 0x3a, 0x75, 0x02,
         0x20, 0xea, 0x96, 0x00,
-        0x00, 0xe2, 0xf8, 0x41,
-        0x40, 0x3a, 0xae, 0x69,
+        0x00, 0xe2, 0x14, 0x42,
+        0xc0, 0x4a, 0x94, 0x00,
+        0x40, 0x3a, 0xc8, 0x69,
         0x02, 0x55, 0x06, 0x68,
-        0x02, 0x56, 0xae, 0x69,
-        0xff, 0x5b, 0xae, 0x61,
+        0x02, 0x56, 0xc8, 0x69,
+        0xff, 0x5b, 0xc8, 0x61,
         0x02, 0x20, 0x51, 0x31,
         0x80, 0xea, 0xb2, 0x01,
         0x44, 0xea, 0x00, 0x00,
@@ -218,237 +231,246 @@ static uint8_t seqprog[] = {
         0x33, 0xea, 0x00, 0x00,
         0xff, 0xea, 0xb2, 0x09,
         0xff, 0xe0, 0xc0, 0x19,
-        0xff, 0xe0, 0xb0, 0x79,
+        0xff, 0xe0, 0xca, 0x79,
         0x02, 0xac, 0x51, 0x31,
-        0x00, 0xe2, 0xa6, 0x41,
+        0x00, 0xe2, 0xc0, 0x41,
         0x02, 0x5e, 0x50, 0x31,
         0x02, 0xa8, 0xb8, 0x30,
         0x02, 0x5c, 0x50, 0x31,
-        0xff, 0xad, 0xc1, 0x71,
+        0xff, 0xad, 0xdb, 0x71,
         0x02, 0xac, 0x41, 0x31,
         0x02, 0x22, 0x51, 0x31,
         0x02, 0xa0, 0x5c, 0x33,
         0x02, 0xa0, 0x44, 0x32,
-        0x00, 0xe2, 0xca, 0x41,
-        0x10, 0x92, 0xcb, 0x69,
+        0x00, 0xe2, 0xe4, 0x41,
+        0x10, 0x92, 0xe5, 0x69,
         0x3d, 0x93, 0xc9, 0x29,
         0x01, 0xe4, 0xc8, 0x01,
         0x01, 0xea, 0xca, 0x01,
         0xff, 0xea, 0xda, 0x01,
         0x02, 0x20, 0x51, 0x31,
         0x02, 0xae, 0x41, 0x32,
-        0xff, 0x21, 0xd3, 0x61,
+        0xff, 0x21, 0xed, 0x61,
         0xff, 0xea, 0x46, 0x02,
         0x02, 0x5c, 0x50, 0x31,
         0x40, 0xea, 0x96, 0x00,
-        0x02, 0x56, 0xcc, 0x6d,
-        0x01, 0x55, 0xcc, 0x6d,
-        0x10, 0x92, 0xdf, 0x79,
-        0x10, 0x40, 0xe8, 0x69,
-        0x01, 0x56, 0xe8, 0x79,
+        0x02, 0x56, 0x04, 0x6e,
+        0x01, 0x55, 0x04, 0x6e,
+        0x10, 0x92, 0xf9, 0x79,
+        0x10, 0x40, 0x02, 0x6a,
+        0x01, 0x56, 0x02, 0x7a,
         0xff, 0x97, 0x07, 0x78,
-        0x13, 0xea, 0x50, 0x59,
+        0x13, 0xea, 0x64, 0x59,
         0x13, 0xea, 0x04, 0x00,
         0x00, 0xe2, 0x06, 0x40,
         0xbf, 0x3a, 0x74, 0x08,
+        0x04, 0x41, 0x08, 0x7a,
         0x08, 0xea, 0x98, 0x00,
         0x08, 0x57, 0xae, 0x00,
-        0x01, 0x93, 0x69, 0x32,
-        0x01, 0x94, 0x6b, 0x32,
-        0x40, 0xea, 0x66, 0x02,
+        0x01, 0x93, 0x75, 0x32,
+        0x01, 0x94, 0x77, 0x32,
+        0x40, 0xea, 0x72, 0x02,
         0x08, 0x3c, 0x78, 0x00,
-        0x80, 0xea, 0x62, 0x02,
-        0x00, 0xe2, 0xb8, 0x5b,
-        0x01, 0x36, 0xc1, 0x31,
-        0x9f, 0xe0, 0x4c, 0x7c,
-        0x80, 0xe0, 0x0c, 0x72,
-        0xa0, 0xe0, 0x44, 0x72,
-        0xc0, 0xe0, 0x3a, 0x72,
-        0xe0, 0xe0, 0x74, 0x72,
-        0x01, 0xea, 0x50, 0x59,
+        0x80, 0xea, 0x6e, 0x02,
+        0x00, 0xe2, 0xe2, 0x5b,
+        0x01, 0x3c, 0xc1, 0x31,
+        0x9f, 0xe0, 0x84, 0x7c,
+        0x80, 0xe0, 0x28, 0x72,
+        0xa0, 0xe0, 0x64, 0x72,
+        0xc0, 0xe0, 0x5a, 0x72,
+        0xe0, 0xe0, 0x94, 0x72,
+        0x01, 0xea, 0x64, 0x59,
         0x01, 0xea, 0x04, 0x00,
-        0x00, 0xe2, 0xf8, 0x41,
-        0x80, 0x33, 0x13, 0x7a,
-        0x03, 0xea, 0x50, 0x59,
+        0x00, 0xe2, 0x14, 0x42,
+        0x80, 0x39, 0x2f, 0x7a,
+        0x03, 0xea, 0x64, 0x59,
         0x03, 0xea, 0x04, 0x00,
-        0xee, 0x00, 0x1a, 0x6a,
+        0xee, 0x00, 0x36, 0x6a,
         0x05, 0xea, 0xb4, 0x00,
-        0x33, 0xea, 0x44, 0x59,
+        0x33, 0xea, 0x5e, 0x59,
         0x33, 0xea, 0x00, 0x00,
-        0x02, 0xa8, 0x90, 0x32,
-        0x00, 0xe2, 0x6a, 0x59,
+        0x02, 0xa8, 0x9c, 0x32,
+        0x00, 0xe2, 0x7e, 0x59,
         0xef, 0x96, 0xd5, 0x19,
-        0x00, 0xe2, 0x2a, 0x52,
+        0x00, 0xe2, 0x46, 0x52,
         0x09, 0x80, 0xe1, 0x30,
         0x02, 0xea, 0x36, 0x00,
         0xa8, 0xea, 0x32, 0x00,
-        0x00, 0xe2, 0x30, 0x42,
+        0x00, 0xe2, 0x4c, 0x42,
         0x01, 0x96, 0xd1, 0x30,
         0x10, 0x80, 0x89, 0x31,
         0x20, 0xea, 0x32, 0x00,
-        0xbf, 0x33, 0x67, 0x0a,
-        0x20, 0x19, 0x32, 0x6a,
-        0x02, 0x4d, 0xf8, 0x69,
-        0x40, 0x33, 0x67, 0x02,
-        0x00, 0xe2, 0xf8, 0x41,
-        0x80, 0x33, 0xb5, 0x6a,
+        0xbf, 0x39, 0x73, 0x0a,
+        0x10, 0x4c, 0x56, 0x6a,
+        0x20, 0x19, 0x4e, 0x6a,
+        0x20, 0x19, 0x52, 0x6a,
+        0x02, 0x4d, 0x14, 0x6a,
+        0x40, 0x39, 0x73, 0x02,
+        0x00, 0xe2, 0x14, 0x42,
+        0x80, 0x39, 0xd5, 0x6a,
         0x01, 0x44, 0x10, 0x33,
         0x08, 0x92, 0x25, 0x03,
-        0x00, 0xe2, 0xf8, 0x41,
+        0x00, 0xe2, 0x14, 0x42,
         0x10, 0xea, 0x80, 0x00,
-        0x01, 0x31, 0xc5, 0x31,
-        0x80, 0xe2, 0x60, 0x62,
-        0x10, 0x92, 0x85, 0x6a,
+        0x01, 0x37, 0xc5, 0x31,
+        0x80, 0xe2, 0x80, 0x62,
+        0x10, 0x92, 0xa5, 0x6a,
         0xc0, 0x94, 0xc5, 0x01,
-        0x40, 0x92, 0x51, 0x6a,
+        0x40, 0x92, 0x71, 0x6a,
         0xbf, 0xe2, 0xc4, 0x09,
-        0x20, 0x92, 0x65, 0x7a,
+        0x20, 0x92, 0x85, 0x7a,
         0x01, 0xe2, 0x88, 0x30,
-        0x00, 0xe2, 0xb8, 0x5b,
-        0xa0, 0x36, 0x6d, 0x62,
+        0x00, 0xe2, 0xe2, 0x5b,
+        0xa0, 0x3c, 0x8d, 0x62,
         0x23, 0x92, 0x89, 0x08,
-        0x00, 0xe2, 0xb8, 0x5b,
-        0xa0, 0x36, 0x6d, 0x62,
-        0x00, 0xa8, 0x64, 0x42,
-        0xff, 0xe2, 0x64, 0x62,
-        0x00, 0xe2, 0x84, 0x42,
+        0x00, 0xe2, 0xe2, 0x5b,
+        0xa0, 0x3c, 0x8d, 0x62,
+        0x00, 0xa8, 0x84, 0x42,
+        0xff, 0xe2, 0x84, 0x62,
+        0x00, 0xe2, 0xa4, 0x42,
         0x40, 0xea, 0x98, 0x00,
         0x01, 0xe2, 0x88, 0x30,
-        0x00, 0xe2, 0xb8, 0x5b,
-        0xa0, 0x36, 0x43, 0x72,
+        0x00, 0xe2, 0xe2, 0x5b,
+        0xa0, 0x3c, 0x63, 0x72,
         0x40, 0xea, 0x98, 0x00,
-        0x01, 0x31, 0x89, 0x32,
-        0x08, 0xea, 0x62, 0x02,
-        0x00, 0xe2, 0xf8, 0x41,
-        0xe0, 0xea, 0xd4, 0x5b,
-        0x80, 0xe0, 0xc0, 0x6a,
-        0x04, 0xe0, 0x66, 0x73,
-        0x02, 0xe0, 0x96, 0x73,
-        0x00, 0xea, 0x1e, 0x73,
-        0x03, 0xe0, 0xa6, 0x73,
-        0x23, 0xe0, 0x96, 0x72,
-        0x08, 0xe0, 0xbc, 0x72,
-        0x00, 0xe2, 0xb8, 0x5b,
-        0x07, 0xea, 0x50, 0x59,
+        0x01, 0x37, 0x95, 0x32,
+        0x08, 0xea, 0x6e, 0x02,
+        0x00, 0xe2, 0x14, 0x42,
+        0xe0, 0xea, 0xfe, 0x5b,
+        0x80, 0xe0, 0xe0, 0x6a,
+        0x04, 0xe0, 0x92, 0x73,
+        0x02, 0xe0, 0xc4, 0x73,
+        0x00, 0xea, 0x3e, 0x73,
+        0x03, 0xe0, 0xd4, 0x73,
+        0x23, 0xe0, 0xb6, 0x72,
+        0x08, 0xe0, 0xdc, 0x72,
+        0x00, 0xe2, 0xe2, 0x5b,
+        0x07, 0xea, 0x64, 0x59,
         0x07, 0xea, 0x04, 0x00,
-        0x08, 0x42, 0xf9, 0x71,
-        0x04, 0x42, 0x93, 0x62,
-        0x01, 0x43, 0x89, 0x30,
-        0x00, 0xe2, 0x84, 0x42,
+        0x08, 0x48, 0x15, 0x72,
+        0x04, 0x48, 0xb3, 0x62,
+        0x01, 0x49, 0x89, 0x30,
+        0x00, 0xe2, 0xa4, 0x42,
         0x01, 0x44, 0xd4, 0x31,
-        0x00, 0xe2, 0x84, 0x42,
-        0x01, 0x00, 0x60, 0x32,
-        0x33, 0xea, 0x44, 0x59,
+        0x00, 0xe2, 0xa4, 0x42,
+        0x01, 0x00, 0x6c, 0x32,
+        0x33, 0xea, 0x5e, 0x59,
         0x33, 0xea, 0x00, 0x00,
-        0x4c, 0x34, 0xc1, 0x28,
+        0x4c, 0x3a, 0xc1, 0x28,
         0x01, 0x64, 0xc0, 0x31,
-        0x00, 0x30, 0x45, 0x59,
-        0x01, 0x30, 0x01, 0x30,
-        0x01, 0xe0, 0xba, 0x7a,
-        0xa0, 0xea, 0xca, 0x5b,
-        0x01, 0xa0, 0xba, 0x62,
-        0x01, 0x84, 0xaf, 0x7a,
-        0x01, 0x95, 0xbd, 0x6a,
-        0x05, 0xea, 0x50, 0x59,
+        0x00, 0x36, 0x5f, 0x59,
+        0x01, 0x36, 0x01, 0x30,
+        0x01, 0xe0, 0xda, 0x7a,
+        0xa0, 0xea, 0xf4, 0x5b,
+        0x01, 0xa0, 0xda, 0x62,
+        0x01, 0x84, 0xcf, 0x7a,
+        0x01, 0x95, 0xdd, 0x6a,
+        0x05, 0xea, 0x64, 0x59,
         0x05, 0xea, 0x04, 0x00,
-        0x00, 0xe2, 0xbc, 0x42,
-        0x03, 0xea, 0x50, 0x59,
+        0x00, 0xe2, 0xdc, 0x42,
+        0x03, 0xea, 0x64, 0x59,
         0x03, 0xea, 0x04, 0x00,
-        0x00, 0xe2, 0xbc, 0x42,
-        0x07, 0xea, 0xdc, 0x5b,
+        0x00, 0xe2, 0xdc, 0x42,
+        0x07, 0xea, 0x06, 0x5c,
         0x01, 0x44, 0xd4, 0x31,
-        0x00, 0xe2, 0xf8, 0x41,
-        0x3f, 0xe0, 0x6a, 0x0a,
-        0xc0, 0x34, 0xc1, 0x09,
-        0x00, 0x35, 0x51, 0x01,
+        0x00, 0xe2, 0x14, 0x42,
+        0x3f, 0xe0, 0x76, 0x0a,
+        0xc0, 0x3a, 0xc1, 0x09,
+        0x00, 0x3b, 0x51, 0x01,
         0xff, 0xea, 0x52, 0x09,
-        0x30, 0x34, 0xc5, 0x09,
+        0x30, 0x3a, 0xc5, 0x09,
         0x3d, 0xe2, 0xc4, 0x29,
         0xb8, 0xe2, 0xc4, 0x19,
         0x01, 0xea, 0xc6, 0x01,
         0x02, 0xe2, 0xc8, 0x31,
         0x02, 0xec, 0x40, 0x31,
-        0xff, 0xa1, 0xdc, 0x72,
+        0xff, 0xa1, 0xfc, 0x72,
         0x02, 0xe8, 0xda, 0x31,
         0x02, 0xa0, 0x50, 0x31,
-        0x00, 0xe2, 0xfe, 0x42,
-        0x80, 0x33, 0x67, 0x02,
+        0x00, 0xe2, 0x1e, 0x43,
+        0x80, 0x39, 0x73, 0x02,
         0x01, 0x44, 0xd4, 0x31,
-        0x00, 0xe2, 0xb8, 0x5b,
-        0x01, 0x33, 0x67, 0x02,
-        0xe0, 0x36, 0x19, 0x63,
-        0x02, 0x33, 0x67, 0x02,
-        0x20, 0x46, 0x12, 0x63,
+        0x00, 0xe2, 0xe2, 0x5b,
+        0x01, 0x39, 0x73, 0x02,
+        0xe0, 0x3c, 0x39, 0x63,
+        0x02, 0x39, 0x73, 0x02,
+        0x20, 0x46, 0x32, 0x63,
         0xff, 0xea, 0x52, 0x09,
-        0xa8, 0xea, 0xca, 0x5b,
-        0x04, 0x92, 0xf9, 0x7a,
-        0x01, 0x34, 0xc1, 0x31,
-        0x00, 0x93, 0xf9, 0x62,
-        0x01, 0x35, 0xc1, 0x31,
-        0x00, 0x94, 0x03, 0x73,
+        0xa8, 0xea, 0xf4, 0x5b,
+        0x04, 0x92, 0x19, 0x7b,
+        0x01, 0x3a, 0xc1, 0x31,
+        0x00, 0x93, 0x19, 0x63,
+        0x01, 0x3b, 0xc1, 0x31,
+        0x00, 0x94, 0x23, 0x73,
         0x01, 0xa9, 0x52, 0x11,
-        0xff, 0xa9, 0xee, 0x6a,
-        0x00, 0xe2, 0x12, 0x43,
-        0x10, 0x33, 0x67, 0x02,
-        0x04, 0x92, 0x13, 0x7b,
+        0xff, 0xa9, 0x0e, 0x6b,
+        0x00, 0xe2, 0x32, 0x43,
+        0x10, 0x39, 0x73, 0x02,
+        0x04, 0x92, 0x33, 0x7b,
         0xfb, 0x92, 0x25, 0x0b,
-        0xff, 0xea, 0x66, 0x0a,
-        0x01, 0xa4, 0x0d, 0x6b,
-        0x02, 0xa8, 0x90, 0x32,
-        0x00, 0xe2, 0x6a, 0x59,
-        0x10, 0x92, 0xbd, 0x7a,
-        0xff, 0xea, 0xdc, 0x5b,
-        0x00, 0xe2, 0xbc, 0x42,
-        0x04, 0xea, 0x50, 0x59,
+        0xff, 0xea, 0x72, 0x0a,
+        0x01, 0xa4, 0x2d, 0x6b,
+        0x02, 0xa8, 0x9c, 0x32,
+        0x00, 0xe2, 0x7e, 0x59,
+        0x10, 0x92, 0xdd, 0x7a,
+        0xff, 0xea, 0x06, 0x5c,
+        0x00, 0xe2, 0xdc, 0x42,
+        0x04, 0xea, 0x64, 0x59,
         0x04, 0xea, 0x04, 0x00,
-        0x00, 0xe2, 0xbc, 0x42,
-        0x04, 0xea, 0x50, 0x59,
+        0x00, 0xe2, 0xdc, 0x42,
+        0x04, 0xea, 0x64, 0x59,
         0x04, 0xea, 0x04, 0x00,
-        0x00, 0xe2, 0xf8, 0x41,
-        0x08, 0x92, 0xb5, 0x7a,
-        0xc0, 0x33, 0x29, 0x7b,
-        0x80, 0x33, 0xb5, 0x6a,
-        0xff, 0x88, 0x29, 0x6b,
-        0x40, 0x33, 0xb5, 0x6a,
-        0x10, 0x92, 0x2f, 0x7b,
-        0x0a, 0xea, 0x50, 0x59,
+        0x00, 0xe2, 0x14, 0x42,
+        0x08, 0x92, 0xd5, 0x7a,
+        0xc0, 0x39, 0x49, 0x7b,
+        0x80, 0x39, 0xd5, 0x6a,
+        0xff, 0x88, 0x49, 0x6b,
+        0x40, 0x39, 0xd5, 0x6a,
+        0x10, 0x92, 0x4f, 0x7b,
+        0x0a, 0xea, 0x64, 0x59,
         0x0a, 0xea, 0x04, 0x00,
-        0x00, 0xe2, 0x4e, 0x5b,
-        0x00, 0xe2, 0x82, 0x43,
-        0x50, 0x4b, 0x36, 0x6b,
+        0x00, 0xe2, 0x6e, 0x5b,
+        0x00, 0xe2, 0xae, 0x43,
+        0x50, 0x4b, 0x56, 0x6b,
         0xbf, 0x3a, 0x74, 0x08,
         0x01, 0xe0, 0xf4, 0x31,
         0xff, 0xea, 0xc0, 0x09,
-        0x01, 0x2e, 0x5d, 0x1a,
-        0x00, 0x2f, 0x5f, 0x22,
-        0x04, 0x47, 0x8f, 0x02,
+        0x01, 0x32, 0x65, 0x1a,
+        0x00, 0x33, 0x67, 0x22,
+        0x04, 0x4d, 0x9b, 0x02,
         0x01, 0xfa, 0xc0, 0x35,
-        0x02, 0xa8, 0x84, 0x32,
+        0x02, 0xa8, 0x90, 0x32,
         0x02, 0xea, 0xb4, 0x00,
-        0x33, 0xea, 0x44, 0x59,
+        0x33, 0xea, 0x5e, 0x59,
         0x33, 0xea, 0x00, 0x00,
-        0x02, 0x42, 0x51, 0x31,
-        0xff, 0x90, 0x65, 0x68,
-        0xff, 0x88, 0x5b, 0x6b,
-        0x01, 0xa4, 0x57, 0x6b,
-        0x02, 0xa4, 0x5f, 0x6b,
-        0x01, 0x84, 0x5f, 0x7b,
+        0x02, 0x48, 0x51, 0x31,
+        0xff, 0x90, 0x85, 0x68,
+        0xff, 0x88, 0x7b, 0x6b,
+        0x01, 0xa4, 0x77, 0x6b,
+        0x02, 0xa4, 0x7f, 0x6b,
+        0x01, 0x84, 0x7f, 0x7b,
         0x02, 0x28, 0x19, 0x33,
         0x02, 0xa8, 0x50, 0x36,
-        0xff, 0x88, 0x5f, 0x73,
-        0x00, 0xe2, 0x32, 0x5b,
+        0xff, 0x88, 0x7f, 0x73,
+        0x00, 0xe2, 0x52, 0x5b,
         0x02, 0xa8, 0x20, 0x33,
-        0x02, 0x2c, 0x19, 0x33,
+        0x04, 0xa4, 0x49, 0x03,
+        0xff, 0xea, 0x1a, 0x03,
+        0xff, 0x2d, 0x8b, 0x63,
         0x02, 0xa8, 0x58, 0x32,
-        0x04, 0xa4, 0x49, 0x07,
-        0xc0, 0x33, 0xb5, 0x6a,
+        0x02, 0xa8, 0x5c, 0x36,
+        0x02, 0xa8, 0x40, 0x31,
+        0x02, 0x2e, 0x51, 0x31,
+        0x02, 0xa0, 0x18, 0x33,
+        0x02, 0xa0, 0x5c, 0x36,
+        0xc0, 0x39, 0xd5, 0x6a,
         0x04, 0x92, 0x25, 0x03,
-        0x20, 0x92, 0x83, 0x6b,
+        0x20, 0x92, 0xaf, 0x6b,
         0x02, 0xa8, 0x40, 0x31,
-        0xc0, 0x34, 0xc1, 0x09,
-        0x00, 0x35, 0x51, 0x01,
+        0xc0, 0x3a, 0xc1, 0x09,
+        0x00, 0x3b, 0x51, 0x01,
         0xff, 0xea, 0x52, 0x09,
-        0x30, 0x34, 0xc5, 0x09,
+        0x30, 0x3a, 0xc5, 0x09,
         0x3d, 0xe2, 0xc4, 0x29,
         0xb8, 0xe2, 0xc4, 0x19,
         0x01, 0xea, 0xc6, 0x01,
@@ -458,69 +480,75 @@ static uint8_t seqprog[] = {
         0xf7, 0x57, 0xae, 0x08,
         0x08, 0xea, 0x98, 0x00,
         0x01, 0x44, 0xd4, 0x31,
-        0xee, 0x00, 0x8c, 0x6b,
+        0xee, 0x00, 0xb8, 0x6b,
         0x02, 0xea, 0xb4, 0x00,
-        0x00, 0xe2, 0xb4, 0x5b,
-        0x09, 0x4c, 0x8e, 0x7b,
+        0xc0, 0xea, 0x72, 0x02,
+        0x09, 0x4c, 0xba, 0x7b,
+        0x01, 0xea, 0x78, 0x02,
         0x08, 0x4c, 0x06, 0x68,
-        0x0b, 0xea, 0x50, 0x59,
+        0x0b, 0xea, 0x64, 0x59,
         0x0b, 0xea, 0x04, 0x00,
         0x01, 0x44, 0xd4, 0x31,
-        0x20, 0x33, 0xf9, 0x79,
-        0x00, 0xe2, 0x9e, 0x5b,
-        0x00, 0xe2, 0xf8, 0x41,
-        0x01, 0x84, 0xa3, 0x7b,
+        0x20, 0x39, 0x15, 0x7a,
+        0x00, 0xe2, 0xcc, 0x5b,
+        0x00, 0xe2, 0x14, 0x42,
+        0x01, 0x84, 0xd1, 0x7b,
         0x01, 0xa4, 0x49, 0x07,
         0x08, 0x60, 0x30, 0x33,
         0x08, 0x80, 0x41, 0x37,
-        0xdf, 0x33, 0x67, 0x0a,
-        0xee, 0x00, 0xb0, 0x6b,
+        0xdf, 0x39, 0x73, 0x0a,
+        0xee, 0x00, 0xde, 0x6b,
         0x05, 0xea, 0xb4, 0x00,
-        0x33, 0xea, 0x44, 0x59,
+        0x33, 0xea, 0x5e, 0x59,
         0x33, 0xea, 0x00, 0x00,
-        0x00, 0xe2, 0x6a, 0x59,
-        0x00, 0xe2, 0xbc, 0x42,
-        0x01, 0xea, 0x6c, 0x02,
-        0xc0, 0xea, 0x66, 0x06,
-        0xff, 0x42, 0xc4, 0x6b,
-        0x01, 0x41, 0xb8, 0x6b,
-        0x02, 0x41, 0xb8, 0x7b,
-        0xff, 0x42, 0xc4, 0x6b,
-        0x01, 0x41, 0xb8, 0x6b,
-        0x02, 0x41, 0xb8, 0x7b,
-        0xff, 0x42, 0xc4, 0x7b,
-        0x04, 0x4c, 0xb8, 0x6b,
-        0xe0, 0x41, 0x6c, 0x0e,
+        0x00, 0xe2, 0x7e, 0x59,
+        0x00, 0xe2, 0xdc, 0x42,
+        0xff, 0x42, 0xee, 0x6b,
+        0x01, 0x41, 0xe2, 0x6b,
+        0x02, 0x41, 0xe2, 0x7b,
+        0xff, 0x42, 0xee, 0x6b,
+        0x01, 0x41, 0xe2, 0x6b,
+        0x02, 0x41, 0xe2, 0x7b,
+        0xff, 0x42, 0xee, 0x7b,
+        0x04, 0x4c, 0xe2, 0x6b,
+        0xe0, 0x41, 0x78, 0x0e,
         0x01, 0x44, 0xd4, 0x31,
-        0xff, 0x42, 0xcc, 0x7b,
-        0x04, 0x4c, 0xcc, 0x6b,
-        0xe0, 0x41, 0x6c, 0x0a,
-        0xe0, 0x36, 0xf9, 0x61,
+        0xff, 0x42, 0xf6, 0x7b,
+        0x04, 0x4c, 0xf6, 0x6b,
+        0xe0, 0x41, 0x78, 0x0a,
+        0xe0, 0x3c, 0x15, 0x62,
         0xff, 0xea, 0xca, 0x09,
         0x01, 0xe2, 0xc8, 0x31,
         0x01, 0x46, 0xda, 0x35,
         0x01, 0x44, 0xd4, 0x35,
         0x10, 0xea, 0x80, 0x00,
-        0x01, 0xe2, 0x62, 0x36,
-        0x04, 0xa6, 0xe4, 0x7b,
+        0x01, 0xe2, 0x6e, 0x36,
+        0x04, 0xa6, 0x0e, 0x7c,
         0xff, 0xea, 0x5a, 0x09,
         0xff, 0xea, 0x4c, 0x0d,
-        0x01, 0xa6, 0x02, 0x6c,
-        0x10, 0xad, 0x64, 0x78,
-        0x80, 0xad, 0xfa, 0x6b,
-        0x08, 0xad, 0x64, 0x68,
+        0x01, 0xa6, 0x3a, 0x6c,
+        0x10, 0xad, 0x84, 0x78,
+        0x80, 0xad, 0x32, 0x6c,
+        0x08, 0xad, 0x84, 0x68,
+        0x20, 0x19, 0x26, 0x7c,
+        0x80, 0xea, 0xb2, 0x01,
+        0x11, 0x00, 0x00, 0x10,
+        0x02, 0xa6, 0x22, 0x7c,
+        0xff, 0xea, 0xb2, 0x0d,
+        0x11, 0x00, 0x00, 0x10,
+        0xff, 0xea, 0xb2, 0x09,
         0x04, 0x84, 0xf9, 0x30,
         0x00, 0xea, 0x08, 0x81,
         0xff, 0xea, 0xd4, 0x09,
         0x02, 0x84, 0xf9, 0x88,
         0x0d, 0xea, 0x5a, 0x01,
         0x04, 0xa6, 0x4c, 0x05,
-        0x04, 0xa6, 0x64, 0x78,
+        0x04, 0xa6, 0x84, 0x78,
         0xff, 0xea, 0x5a, 0x09,
         0x03, 0x84, 0x59, 0x89,
         0x03, 0xea, 0x4c, 0x01,
-        0x80, 0x1a, 0x64, 0x78,
-        0x08, 0x19, 0x64, 0x78,
+        0x80, 0x1a, 0x84, 0x78,
+        0x08, 0x19, 0x84, 0x78,
         0x08, 0xb0, 0xe0, 0x30,
         0x04, 0xb0, 0xe0, 0x30,
         0x03, 0xb0, 0xf0, 0x30,
@@ -533,259 +561,259 @@ static uint8_t seqprog[] = {
         0x00, 0x86, 0x0d, 0x23,
         0x00, 0x87, 0x0f, 0x23,
         0x01, 0x84, 0xc5, 0x31,
-        0x80, 0x83, 0x25, 0x7c,
+        0x80, 0x83, 0x5d, 0x7c,
         0x02, 0xe2, 0xc4, 0x01,
         0xff, 0xea, 0x4c, 0x09,
         0x01, 0xe2, 0x36, 0x30,
         0xc8, 0x19, 0x32, 0x00,
         0x88, 0x19, 0x32, 0x00,
         0x01, 0xac, 0xd4, 0x99,
-        0x00, 0xe2, 0x64, 0x50,
+        0x00, 0xe2, 0x84, 0x50,
         0xfe, 0xa6, 0x4c, 0x0d,
         0x0b, 0x98, 0xe1, 0x30,
         0xfd, 0xa4, 0x49, 0x09,
-        0x80, 0xa3, 0x39, 0x7c,
+        0x80, 0xa3, 0x71, 0x7c,
         0x02, 0xa4, 0x48, 0x01,
         0x01, 0xa4, 0x36, 0x30,
         0xa8, 0xea, 0x32, 0x00,
         0xfd, 0xa4, 0x49, 0x0b,
         0x05, 0xa3, 0x07, 0x33,
-        0x80, 0x83, 0x45, 0x6c,
+        0x80, 0x83, 0x7d, 0x6c,
         0x02, 0xea, 0x4c, 0x05,
         0xff, 0xea, 0x4c, 0x0d,
-        0x00, 0xe2, 0x3e, 0x59,
-        0x02, 0xa6, 0xe6, 0x6b,
+        0x00, 0xe2, 0x56, 0x59,
+        0x02, 0xa6, 0x10, 0x6c,
         0x80, 0xf9, 0xf2, 0x05,
-        0xc0, 0x33, 0x53, 0x7c,
-        0x03, 0xea, 0x50, 0x59,
+        0xc0, 0x39, 0x8b, 0x7c,
+        0x03, 0xea, 0x64, 0x59,
         0x03, 0xea, 0x04, 0x00,
-        0x20, 0x33, 0x77, 0x7c,
-        0x01, 0x84, 0x5d, 0x6c,
-        0x06, 0xea, 0x50, 0x59,
+        0x20, 0x39, 0xaf, 0x7c,
+        0x01, 0x84, 0x95, 0x6c,
+        0x06, 0xea, 0x64, 0x59,
         0x06, 0xea, 0x04, 0x00,
-        0x00, 0xe2, 0x7a, 0x44,
-        0x01, 0x00, 0x60, 0x32,
-        0xee, 0x00, 0x66, 0x6c,
+        0x00, 0xe2, 0xb2, 0x44,
+        0x01, 0x00, 0x6c, 0x32,
+        0xee, 0x00, 0x9e, 0x6c,
         0x05, 0xea, 0xb4, 0x00,
-        0x33, 0xea, 0x44, 0x59,
+        0x33, 0xea, 0x5e, 0x59,
         0x33, 0xea, 0x00, 0x00,
         0x80, 0x3d, 0x7a, 0x00,
-        0xfc, 0x42, 0x68, 0x7c,
+        0xfc, 0x42, 0xa0, 0x7c,
         0x7f, 0x3d, 0x7a, 0x08,
-        0x00, 0x30, 0x45, 0x59,
-        0x01, 0x30, 0x01, 0x30,
-        0x09, 0xea, 0x50, 0x59,
+        0x00, 0x36, 0x5f, 0x59,
+        0x01, 0x36, 0x01, 0x30,
+        0x09, 0xea, 0x64, 0x59,
         0x09, 0xea, 0x04, 0x00,
-        0x00, 0xe2, 0xf8, 0x41,
-        0x01, 0xa4, 0x5d, 0x6c,
-        0x00, 0xe2, 0x30, 0x5c,
-        0x20, 0x33, 0x67, 0x02,
-        0x01, 0x00, 0x60, 0x32,
-        0x02, 0xa6, 0x82, 0x7c,
-        0x00, 0xe2, 0x46, 0x5c,
-        0x00, 0xe2, 0x56, 0x58,
-        0x00, 0xe2, 0x66, 0x58,
-        0x00, 0xe2, 0x3a, 0x58,
-        0x00, 0x30, 0x45, 0x59,
-        0x01, 0x30, 0x01, 0x30,
-        0x20, 0x19, 0x82, 0x6c,
-        0x00, 0xe2, 0xb2, 0x5c,
-        0x04, 0x19, 0x9c, 0x6c,
+        0x00, 0xe2, 0x14, 0x42,
+        0x01, 0xa4, 0x95, 0x6c,
+        0x00, 0xe2, 0x68, 0x5c,
+        0x20, 0x39, 0x73, 0x02,
+        0x01, 0x00, 0x6c, 0x32,
+        0x02, 0xa6, 0xba, 0x7c,
+        0x00, 0xe2, 0x7e, 0x5c,
+        0x00, 0xe2, 0x76, 0x58,
+        0x00, 0xe2, 0x86, 0x58,
+        0x00, 0xe2, 0x5a, 0x58,
+        0x00, 0x36, 0x5f, 0x59,
+        0x01, 0x36, 0x01, 0x30,
+        0x20, 0x19, 0xba, 0x6c,
+        0x00, 0xe2, 0xea, 0x5c,
+        0x04, 0x19, 0xd4, 0x6c,
         0x02, 0x19, 0x32, 0x00,
-        0x01, 0x84, 0x9d, 0x7c,
-        0x01, 0x1b, 0x96, 0x7c,
-        0x01, 0x1a, 0x9c, 0x6c,
-        0x00, 0xe2, 0x4c, 0x44,
-        0x80, 0x4b, 0xa2, 0x6c,
-        0x01, 0x4c, 0x9e, 0x7c,
-        0x03, 0x42, 0x4c, 0x6c,
-        0x00, 0xe2, 0xe0, 0x5b,
+        0x01, 0x84, 0xd5, 0x7c,
+        0x01, 0x1b, 0xce, 0x7c,
+        0x01, 0x1a, 0xd4, 0x6c,
+        0x00, 0xe2, 0x84, 0x44,
+        0x80, 0x4b, 0xda, 0x6c,
+        0x01, 0x4c, 0xd6, 0x7c,
+        0x03, 0x42, 0x84, 0x6c,
+        0x00, 0xe2, 0x0a, 0x5c,
         0x80, 0xf9, 0xf2, 0x01,
-        0x04, 0x33, 0xf9, 0x79,
-        0x00, 0xe2, 0xf8, 0x41,
-        0x08, 0x5d, 0xba, 0x6c,
-        0x00, 0xe2, 0x56, 0x58,
-        0x00, 0x30, 0x45, 0x59,
-        0x01, 0x30, 0x01, 0x30,
-        0x02, 0x1b, 0xaa, 0x7c,
-        0x08, 0x5d, 0xb8, 0x7c,
+        0x04, 0x39, 0x15, 0x7a,
+        0x00, 0xe2, 0x14, 0x42,
+        0x08, 0x5d, 0xf2, 0x6c,
+        0x00, 0xe2, 0x76, 0x58,
+        0x00, 0x36, 0x5f, 0x59,
+        0x01, 0x36, 0x01, 0x30,
+        0x02, 0x1b, 0xe2, 0x7c,
+        0x08, 0x5d, 0xf0, 0x7c,
         0x03, 0x68, 0x00, 0x37,
         0x01, 0x84, 0x09, 0x07,
-        0x80, 0x1b, 0xc4, 0x7c,
-        0x80, 0x84, 0xc5, 0x6c,
+        0x80, 0x1b, 0xfc, 0x7c,
+        0x80, 0x84, 0xfd, 0x6c,
         0xff, 0x85, 0x0b, 0x1b,
         0xff, 0x86, 0x0d, 0x23,
         0xff, 0x87, 0x0f, 0x23,
         0xf8, 0x1b, 0x08, 0x0b,
         0xff, 0xea, 0x06, 0x0b,
         0x03, 0x68, 0x00, 0x37,
-        0x00, 0xe2, 0xc4, 0x58,
+        0x00, 0xe2, 0xd6, 0x58,
         0x10, 0xea, 0x18, 0x00,
         0xf9, 0xd9, 0xb2, 0x0d,
         0x01, 0xd9, 0xb2, 0x05,
         0x01, 0x52, 0x48, 0x31,
-        0x20, 0xa4, 0xee, 0x7c,
-        0x20, 0x5b, 0xee, 0x7c,
-        0x80, 0xf9, 0xfc, 0x7c,
+        0x20, 0xa4, 0x26, 0x7d,
+        0x20, 0x5b, 0x26, 0x7d,
+        0x80, 0xf9, 0x34, 0x7d,
         0x02, 0xea, 0xb4, 0x00,
         0x11, 0x00, 0x00, 0x10,
-        0x04, 0x19, 0x08, 0x7d,
+        0x04, 0x19, 0x40, 0x7d,
         0xdf, 0x19, 0x32, 0x08,
-        0x60, 0x5b, 0xe6, 0x6c,
-        0x01, 0x4c, 0xe2, 0x7c,
+        0x60, 0x5b, 0x40, 0x6d,
+        0x01, 0x4c, 0x1a, 0x7d,
         0x20, 0x19, 0x32, 0x00,
         0x01, 0xd9, 0xb2, 0x05,
         0x02, 0xea, 0xb4, 0x00,
         0x01, 0xd9, 0xb2, 0x05,
-        0x10, 0x5b, 0x00, 0x6d,
-        0x08, 0x5b, 0x0a, 0x6d,
-        0x20, 0x5b, 0xfa, 0x6c,
-        0x02, 0x5b, 0x2a, 0x6d,
-        0x0e, 0xea, 0x50, 0x59,
+        0x10, 0x5b, 0x38, 0x6d,
+        0x08, 0x5b, 0x42, 0x6d,
+        0x20, 0x5b, 0x32, 0x6d,
+        0x02, 0x5b, 0x62, 0x6d,
+        0x0e, 0xea, 0x64, 0x59,
         0x0e, 0xea, 0x04, 0x00,
-        0x80, 0xf9, 0xea, 0x6c,
+        0x80, 0xf9, 0x22, 0x6d,
         0xdf, 0x5c, 0xb8, 0x08,
         0x01, 0xd9, 0xb2, 0x05,
-        0x01, 0xa4, 0xe5, 0x6d,
-        0x00, 0xe2, 0x30, 0x5c,
-        0x00, 0xe2, 0x34, 0x5d,
+        0x01, 0xa4, 0x1d, 0x6e,
+        0x00, 0xe2, 0x68, 0x5c,
+        0x00, 0xe2, 0x6c, 0x5d,
         0x01, 0x90, 0x21, 0x1b,
         0x01, 0xd9, 0xb2, 0x05,
-        0x00, 0xe2, 0x32, 0x5b,
+        0x00, 0xe2, 0x52, 0x5b,
         0xf3, 0x96, 0xd5, 0x19,
-        0x00, 0xe2, 0x18, 0x55,
-        0x80, 0x96, 0x19, 0x6d,
-        0x0f, 0xea, 0x50, 0x59,
+        0x00, 0xe2, 0x50, 0x55,
+        0x80, 0x96, 0x51, 0x6d,
+        0x0f, 0xea, 0x64, 0x59,
         0x0f, 0xea, 0x04, 0x00,
-        0x00, 0xe2, 0x20, 0x45,
+        0x00, 0xe2, 0x58, 0x45,
         0x04, 0x8c, 0xe1, 0x30,
         0x01, 0xea, 0xf2, 0x00,
         0x02, 0xea, 0x36, 0x00,
         0xa8, 0xea, 0x32, 0x00,
-        0xff, 0x97, 0x27, 0x7d,
-        0x14, 0xea, 0x50, 0x59,
+        0xff, 0x97, 0x5f, 0x7d,
+        0x14, 0xea, 0x64, 0x59,
         0x14, 0xea, 0x04, 0x00,
-        0x00, 0xe2, 0x96, 0x5d,
+        0x00, 0xe2, 0xce, 0x5d,
         0x01, 0xd9, 0xb2, 0x05,
         0x09, 0x80, 0xe1, 0x30,
         0x02, 0xea, 0x36, 0x00,
         0xa8, 0xea, 0x32, 0x00,
-        0x00, 0xe2, 0x8e, 0x5d,
+        0x00, 0xe2, 0xc6, 0x5d,
         0x01, 0xd9, 0xb2, 0x05,
-        0x02, 0xa6, 0x44, 0x7d,
-        0x00, 0xe2, 0x3e, 0x59,
-        0x20, 0x5b, 0x52, 0x6d,
-        0xfc, 0x42, 0x3e, 0x7d,
-        0x10, 0x40, 0x40, 0x6d,
-        0x20, 0x4d, 0x42, 0x7d,
-        0x08, 0x5d, 0x52, 0x6d,
-        0x02, 0xa6, 0xe6, 0x6b,
-        0x00, 0xe2, 0x3e, 0x59,
-        0x20, 0x5b, 0x52, 0x6d,
-        0x01, 0x1b, 0x72, 0x6d,
-        0xfc, 0x42, 0x4e, 0x7d,
-        0x10, 0x40, 0x50, 0x6d,
-        0x20, 0x4d, 0x64, 0x78,
-        0x08, 0x5d, 0x64, 0x78,
+        0x02, 0xa6, 0x7c, 0x7d,
+        0x00, 0xe2, 0x56, 0x59,
+        0x20, 0x5b, 0x8a, 0x6d,
+        0xfc, 0x42, 0x76, 0x7d,
+        0x10, 0x40, 0x78, 0x6d,
+        0x20, 0x4d, 0x7a, 0x7d,
+        0x08, 0x5d, 0x8a, 0x6d,
+        0x02, 0xa6, 0x10, 0x6c,
+        0x00, 0xe2, 0x56, 0x59,
+        0x20, 0x5b, 0x8a, 0x6d,
+        0x01, 0x1b, 0xaa, 0x6d,
+        0xfc, 0x42, 0x86, 0x7d,
+        0x10, 0x40, 0x88, 0x6d,
+        0x20, 0x4d, 0x84, 0x78,
+        0x08, 0x5d, 0x84, 0x78,
         0x02, 0x19, 0x32, 0x00,
         0x01, 0x5b, 0x40, 0x31,
-        0x00, 0xe2, 0xb2, 0x5c,
-        0x00, 0xe2, 0x9e, 0x5b,
+        0x00, 0xe2, 0xea, 0x5c,
+        0x00, 0xe2, 0xcc, 0x5b,
         0x20, 0xea, 0xb6, 0x00,
-        0x00, 0xe2, 0xe0, 0x5b,
+        0x00, 0xe2, 0x0a, 0x5c,
         0x20, 0x5c, 0xb8, 0x00,
-        0x04, 0x19, 0x68, 0x6d,
-        0x01, 0x1a, 0x68, 0x6d,
-        0x00, 0xe2, 0x3e, 0x59,
-        0x01, 0x1a, 0x64, 0x78,
+        0x04, 0x19, 0xa0, 0x6d,
+        0x01, 0x1a, 0xa0, 0x6d,
+        0x00, 0xe2, 0x56, 0x59,
+        0x01, 0x1a, 0x84, 0x78,
         0x80, 0xf9, 0xf2, 0x01,
-        0x20, 0xa0, 0xcc, 0x7d,
+        0x20, 0xa0, 0x04, 0x7e,
         0xff, 0x90, 0x21, 0x1b,
-        0x08, 0x92, 0x43, 0x6b,
+        0x08, 0x92, 0x63, 0x6b,
         0x02, 0xea, 0xb4, 0x04,
         0x01, 0xa4, 0x49, 0x03,
-        0x40, 0x5b, 0x82, 0x6d,
-        0x00, 0xe2, 0x3e, 0x59,
-        0x40, 0x5b, 0x82, 0x6d,
-        0x04, 0x5d, 0xe6, 0x7d,
-        0x01, 0x1a, 0xe6, 0x7d,
-        0x20, 0x4d, 0x64, 0x78,
-        0x40, 0x5b, 0xcc, 0x7d,
-        0x04, 0x5d, 0xe6, 0x7d,
-        0x01, 0x1a, 0xe6, 0x7d,
+        0x40, 0x5b, 0xba, 0x6d,
+        0x00, 0xe2, 0x56, 0x59,
+        0x40, 0x5b, 0xba, 0x6d,
+        0x04, 0x5d, 0x1e, 0x7e,
+        0x01, 0x1a, 0x1e, 0x7e,
+        0x20, 0x4d, 0x84, 0x78,
+        0x40, 0x5b, 0x04, 0x7e,
+        0x04, 0x5d, 0x1e, 0x7e,
+        0x01, 0x1a, 0x1e, 0x7e,
         0x80, 0xf9, 0xf2, 0x01,
         0xff, 0x90, 0x21, 0x1b,
-        0x08, 0x92, 0x43, 0x6b,
+        0x08, 0x92, 0x63, 0x6b,
         0x02, 0xea, 0xb4, 0x04,
-        0x00, 0xe2, 0x3e, 0x59,
-        0x01, 0x1b, 0x64, 0x78,
+        0x00, 0xe2, 0x56, 0x59,
+        0x01, 0x1b, 0x84, 0x78,
         0x80, 0xf9, 0xf2, 0x01,
         0x02, 0xea, 0xb4, 0x04,
-        0x00, 0xe2, 0x3e, 0x59,
-        0x01, 0x1b, 0xaa, 0x6d,
-        0x40, 0x5b, 0xb8, 0x7d,
-        0x01, 0x1b, 0xaa, 0x6d,
+        0x00, 0xe2, 0x56, 0x59,
+        0x01, 0x1b, 0xe2, 0x6d,
+        0x40, 0x5b, 0xf0, 0x7d,
+        0x01, 0x1b, 0xe2, 0x6d,
         0x02, 0x19, 0x32, 0x00,
-        0x01, 0x1a, 0x64, 0x78,
+        0x01, 0x1a, 0x84, 0x78,
         0x80, 0xf9, 0xf2, 0x01,
         0xff, 0xea, 0x10, 0x03,
         0x08, 0x92, 0x25, 0x03,
-        0x00, 0xe2, 0x42, 0x43,
-        0x01, 0x1a, 0xb4, 0x7d,
-        0x40, 0x5b, 0xb0, 0x7d,
-        0x01, 0x1a, 0x9e, 0x6d,
-        0xfc, 0x42, 0x64, 0x78,
-        0x01, 0x1a, 0xb8, 0x6d,
-        0x10, 0xea, 0x50, 0x59,
+        0x00, 0xe2, 0x62, 0x43,
+        0x01, 0x1a, 0xec, 0x7d,
+        0x40, 0x5b, 0xe8, 0x7d,
+        0x01, 0x1a, 0xd6, 0x6d,
+        0xfc, 0x42, 0x84, 0x78,
+        0x01, 0x1a, 0xf0, 0x6d,
+        0x10, 0xea, 0x64, 0x59,
         0x10, 0xea, 0x04, 0x00,
-        0xfc, 0x42, 0x64, 0x78,
-        0x10, 0x40, 0xbe, 0x6d,
-        0x20, 0x4d, 0x64, 0x78,
-        0x40, 0x5b, 0x9e, 0x6d,
-        0x01, 0x1a, 0x64, 0x78,
+        0xfc, 0x42, 0x84, 0x78,
+        0x10, 0x40, 0xf6, 0x6d,
+        0x20, 0x4d, 0x84, 0x78,
+        0x40, 0x5b, 0xd6, 0x6d,
+        0x01, 0x1a, 0x84, 0x78,
         0x01, 0x90, 0x21, 0x1b,
         0x30, 0x3f, 0xc0, 0x09,
-        0x30, 0xe0, 0x64, 0x60,
-        0x40, 0x4b, 0x64, 0x68,
+        0x30, 0xe0, 0x84, 0x60,
+        0x40, 0x4b, 0x84, 0x68,
         0xff, 0xea, 0x52, 0x01,
-        0xee, 0x00, 0xd2, 0x6d,
+        0xee, 0x00, 0x0c, 0x6e,
         0x80, 0xf9, 0xf2, 0x01,
         0xff, 0x90, 0x21, 0x1b,
         0x02, 0xea, 0xb4, 0x00,
         0x20, 0xea, 0x9a, 0x00,
-        0xf3, 0x42, 0xde, 0x6d,
-        0x12, 0xea, 0x50, 0x59,
+        0xf3, 0x42, 0x16, 0x6e,
+        0x12, 0xea, 0x64, 0x59,
         0x12, 0xea, 0x04, 0x00,
-        0x00, 0xe2, 0xf8, 0x41,
-        0x0d, 0xea, 0x50, 0x59,
+        0x00, 0xe2, 0x14, 0x42,
+        0x0d, 0xea, 0x64, 0x59,
         0x0d, 0xea, 0x04, 0x00,
-        0x00, 0xe2, 0xf8, 0x41,
+        0x00, 0xe2, 0x14, 0x42,
         0x01, 0x90, 0x21, 0x1b,
-        0x11, 0xea, 0x50, 0x59,
+        0x11, 0xea, 0x64, 0x59,
         0x11, 0xea, 0x04, 0x00,
-        0x00, 0xe2, 0x32, 0x5b,
+        0x00, 0xe2, 0x52, 0x5b,
         0x08, 0x5a, 0xb4, 0x00,
-        0x00, 0xe2, 0x0c, 0x5e,
+        0x00, 0xe2, 0x44, 0x5e,
         0xa8, 0xea, 0x32, 0x00,
-        0x00, 0xe2, 0x3e, 0x59,
-        0x80, 0x1a, 0xfa, 0x7d,
-        0x00, 0xe2, 0x0c, 0x5e,
+        0x00, 0xe2, 0x56, 0x59,
+        0x80, 0x1a, 0x32, 0x7e,
+        0x00, 0xe2, 0x44, 0x5e,
         0x80, 0x19, 0x32, 0x00,
-        0x40, 0x5b, 0x00, 0x6e,
-        0x08, 0x5a, 0x00, 0x7e,
-        0x20, 0x4d, 0x64, 0x78,
+        0x40, 0x5b, 0x38, 0x6e,
+        0x08, 0x5a, 0x38, 0x7e,
+        0x20, 0x4d, 0x84, 0x78,
         0x02, 0x84, 0x09, 0x03,
-        0x40, 0x5b, 0xcc, 0x7d,
+        0x40, 0x5b, 0x04, 0x7e,
         0xff, 0x90, 0x21, 0x1b,
         0x80, 0xf9, 0xf2, 0x01,
-        0x08, 0x92, 0x43, 0x6b,
+        0x08, 0x92, 0x63, 0x6b,
         0x02, 0xea, 0xb4, 0x04,
-        0x01, 0x38, 0xe1, 0x30,
-        0x05, 0x39, 0xe3, 0x98,
+        0x01, 0x40, 0xe1, 0x30,
+        0x05, 0x41, 0xe3, 0x98,
         0x01, 0xe0, 0xf4, 0x31,
         0xff, 0xea, 0xc0, 0x09,
-        0x00, 0x3a, 0xe5, 0x20,
-        0x00, 0x3b, 0xe7, 0x20,
+        0x00, 0x42, 0xe5, 0x20,
+        0x00, 0x43, 0xe7, 0x20,
         0x01, 0xfa, 0xc0, 0x31,
         0x04, 0xea, 0xe8, 0x30,
         0xff, 0xea, 0xf0, 0x08,
@@ -794,12 +822,20 @@ static uint8_t seqprog[] = {
 };
 
 typedef int ahd_patch_func_t (struct ahd_softc *ahd);
+static ahd_patch_func_t ahd_patch23_func;
+
+static int
+ahd_patch23_func(struct ahd_softc *ahd)
+{
+        return ((ahd->bugs & AHD_PKT_BITBUCKET_BUG) != 0);
+}
+
 static ahd_patch_func_t ahd_patch22_func;
 
 static int
 ahd_patch22_func(struct ahd_softc *ahd)
 {
-        return ((ahd->bugs & AHD_PKT_BITBUCKET_BUG) != 0);
+        return ((ahd->bugs & AHD_PKT_BITBUCKET_BUG) == 0);
 }
 
 static ahd_patch_func_t ahd_patch21_func;
@@ -807,7 +843,7 @@ static ahd_patch_func_t ahd_patch21_func;
 static int
 ahd_patch21_func(struct ahd_softc *ahd)
 {
-        return ((ahd->bugs & AHD_PKT_BITBUCKET_BUG) == 0);
+        return ((ahd->flags & AHD_INITIATORROLE) != 0);
 }
 
 static ahd_patch_func_t ahd_patch20_func;
@@ -815,7 +851,7 @@ static ahd_patch_func_t ahd_patch20_func;
 static int
 ahd_patch20_func(struct ahd_softc *ahd)
 {
-        return ((ahd->features & AHD_RTI) == 0);
+        return ((ahd->flags & AHD_TARGETROLE) != 0);
 }
 
 static ahd_patch_func_t ahd_patch19_func;
@@ -823,7 +859,7 @@ static ahd_patch_func_t ahd_patch19_func;
 static int
 ahd_patch19_func(struct ahd_softc *ahd)
 {
-        return ((ahd->flags & AHD_INITIATORROLE) != 0);
+        return ((ahd->bugs & AHD_AUTOFLUSH_BUG) != 0);
 }
 
 static ahd_patch_func_t ahd_patch18_func;
@@ -831,7 +867,7 @@ static ahd_patch_func_t ahd_patch18_func;
 static int
 ahd_patch18_func(struct ahd_softc *ahd)
 {
-        return ((ahd->flags & AHD_TARGETROLE) != 0);
+        return ((ahd->features & AHD_NEW_DFCNTRL_OPTS) != 0);
 }
 
 static ahd_patch_func_t ahd_patch17_func;
@@ -839,7 +875,7 @@ static ahd_patch_func_t ahd_patch17_func;
 static int
 ahd_patch17_func(struct ahd_softc *ahd)
 {
-        return ((ahd->bugs & AHD_AUTOFLUSH_BUG) != 0);
+        return ((ahd->flags & AHD_39BIT_ADDRESSING) != 0);
 }
 
 static ahd_patch_func_t ahd_patch16_func;
@@ -847,7 +883,7 @@ static ahd_patch_func_t ahd_patch16_func;
 static int
 ahd_patch16_func(struct ahd_softc *ahd)
 {
-        return ((ahd->features & AHD_NEW_DFCNTRL_OPTS) != 0);
+        return ((ahd->flags & AHD_64BIT_ADDRESSING) != 0);
 }
 
 static ahd_patch_func_t ahd_patch15_func;
@@ -855,7 +891,7 @@ static ahd_patch_func_t ahd_patch15_func;
 static int
 ahd_patch15_func(struct ahd_softc *ahd)
 {
-        return ((ahd->flags & AHD_39BIT_ADDRESSING) != 0);
+        return ((ahd->features & AHD_NEW_DFCNTRL_OPTS) == 0);
 }
 
 static ahd_patch_func_t ahd_patch14_func;
@@ -863,7 +899,7 @@ static ahd_patch_func_t ahd_patch14_func;
 static int
 ahd_patch14_func(struct ahd_softc *ahd)
 {
-        return ((ahd->flags & AHD_64BIT_ADDRESSING) != 0);
+        return ((ahd->bugs & AHD_REG_SLOW_SETTLE_BUG) != 0);
 }
 
 static ahd_patch_func_t ahd_patch13_func;
@@ -871,7 +907,7 @@ static ahd_patch_func_t ahd_patch13_func;
 static int
 ahd_patch13_func(struct ahd_softc *ahd)
 {
-        return ((ahd->features & AHD_NEW_DFCNTRL_OPTS) == 0);
+        return ((ahd->features & AHD_RTI) == 0);
 }
 
 static ahd_patch_func_t ahd_patch12_func;
@@ -879,7 +915,7 @@ static ahd_patch_func_t ahd_patch12_func;
 static int
 ahd_patch12_func(struct ahd_softc *ahd)
 {
-        return ((ahd->bugs & AHD_REG_SLOW_SETTLE_BUG) != 0);
+        return ((ahd->bugs & AHD_EARLY_REQ_BUG) != 0);
 }
 
 static ahd_patch_func_t ahd_patch11_func;
@@ -887,7 +923,7 @@ static ahd_patch_func_t ahd_patch11_func;
 static int
 ahd_patch11_func(struct ahd_softc *ahd)
 {
-        return ((ahd->bugs & AHD_EARLY_REQ_BUG) != 0);
+        return ((ahd->bugs & AHD_BUSFREEREV_BUG) == 0);
 }
 
 static ahd_patch_func_t ahd_patch10_func;
@@ -895,7 +931,7 @@ static ahd_patch_func_t ahd_patch10_func;
 static int
 ahd_patch10_func(struct ahd_softc *ahd)
 {
-        return ((ahd->bugs & AHD_BUSFREEREV_BUG) == 0);
+        return ((ahd->flags & AHD_SEQUENCER_DEBUG) != 0);
 }
 
 static ahd_patch_func_t ahd_patch9_func;
@@ -903,7 +939,7 @@ static ahd_patch_func_t ahd_patch9_func;
 static int
 ahd_patch9_func(struct ahd_softc *ahd)
 {
-        return ((ahd->flags & AHD_SEQUENCER_DEBUG) != 0);
+        return ((ahd->features & AHD_FAST_CDB_DELIVERY) != 0);
 }
 
 static ahd_patch_func_t ahd_patch8_func;
@@ -992,147 +1028,149 @@ static struct patch {
         { ahd_patch0_func, 5, 1, 1 },
         { ahd_patch2_func, 6, 1, 2 },
         { ahd_patch0_func, 7, 1, 1 },
-        { ahd_patch3_func, 20, 5, 1 },
-        { ahd_patch2_func, 29, 1, 2 },
-        { ahd_patch0_func, 30, 1, 1 },
-        { ahd_patch1_func, 37, 1, 2 },
-        { ahd_patch0_func, 38, 1, 1 },
-        { ahd_patch2_func, 43, 1, 2 },
-        { ahd_patch0_func, 44, 1, 1 },
-        { ahd_patch2_func, 47, 1, 2 },
-        { ahd_patch0_func, 48, 1, 1 },
-        { ahd_patch2_func, 51, 1, 2 },
-        { ahd_patch0_func, 52, 1, 1 },
-        { ahd_patch2_func, 65, 1, 2 },
-        { ahd_patch0_func, 66, 1, 1 },
-        { ahd_patch2_func, 69, 1, 2 },
-        { ahd_patch0_func, 70, 1, 1 },
-        { ahd_patch1_func, 73, 1, 2 },
-        { ahd_patch0_func, 74, 1, 1 },
-        { ahd_patch4_func, 107, 1, 1 },
-        { ahd_patch2_func, 162, 6, 1 },
-        { ahd_patch1_func, 168, 2, 1 },
-        { ahd_patch5_func, 170, 1, 1 },
-        { ahd_patch2_func, 179, 1, 2 },
-        { ahd_patch0_func, 180, 1, 1 },
-        { ahd_patch6_func, 181, 2, 2 },
-        { ahd_patch0_func, 183, 6, 3 },
-        { ahd_patch2_func, 186, 1, 2 },
-        { ahd_patch0_func, 187, 1, 1 },
-        { ahd_patch2_func, 190, 1, 2 },
-        { ahd_patch0_func, 191, 1, 1 },
-        { ahd_patch7_func, 193, 2, 1 },
-        { ahd_patch5_func, 201, 16, 2 },
-        { ahd_patch0_func, 217, 1, 1 },
-        { ahd_patch8_func, 237, 2, 1 },
-        { ahd_patch1_func, 241, 1, 2 },
-        { ahd_patch0_func, 242, 1, 1 },
-        { ahd_patch7_func, 245, 2, 1 },
-        { ahd_patch1_func, 259, 1, 2 },
-        { ahd_patch0_func, 260, 1, 1 },
-        { ahd_patch1_func, 263, 1, 2 },
-        { ahd_patch0_func, 264, 1, 1 },
-        { ahd_patch2_func, 267, 1, 2 },
-        { ahd_patch0_func, 268, 1, 1 },
-        { ahd_patch1_func, 323, 1, 2 },
-        { ahd_patch0_func, 324, 1, 1 },
-        { ahd_patch2_func, 332, 1, 2 },
-        { ahd_patch0_func, 333, 1, 1 },
-        { ahd_patch2_func, 336, 1, 2 },
-        { ahd_patch0_func, 337, 1, 1 },
-        { ahd_patch1_func, 343, 1, 2 },
-        { ahd_patch0_func, 344, 1, 1 },
-        { ahd_patch1_func, 346, 1, 2 },
-        { ahd_patch0_func, 347, 1, 1 },
-        { ahd_patch9_func, 366, 1, 1 },
-        { ahd_patch9_func, 369, 1, 1 },
-        { ahd_patch9_func, 371, 1, 1 },
-        { ahd_patch9_func, 383, 1, 1 },
-        { ahd_patch1_func, 393, 1, 2 },
-        { ahd_patch0_func, 394, 1, 1 },
-        { ahd_patch1_func, 396, 1, 2 },
-        { ahd_patch0_func, 397, 1, 1 },
-        { ahd_patch1_func, 405, 1, 2 },
-        { ahd_patch0_func, 406, 1, 1 },
-        { ahd_patch2_func, 419, 1, 2 },
-        { ahd_patch0_func, 420, 1, 1 },
-        { ahd_patch10_func, 450, 1, 1 },
-        { ahd_patch1_func, 457, 1, 2 },
-        { ahd_patch0_func, 458, 1, 1 },
-        { ahd_patch2_func, 470, 1, 2 },
-        { ahd_patch0_func, 471, 1, 1 },
-        { ahd_patch11_func, 476, 6, 2 },
-        { ahd_patch0_func, 482, 1, 1 },
-        { ahd_patch12_func, 505, 1, 1 },
-        { ahd_patch13_func, 514, 1, 1 },
-        { ahd_patch14_func, 515, 1, 2 },
-        { ahd_patch0_func, 516, 1, 1 },
-        { ahd_patch15_func, 519, 1, 1 },
-        { ahd_patch14_func, 520, 1, 1 },
-        { ahd_patch16_func, 531, 1, 2 },
-        { ahd_patch0_func, 532, 1, 1 },
-        { ahd_patch1_func, 551, 1, 2 },
-        { ahd_patch0_func, 552, 1, 1 },
-        { ahd_patch1_func, 555, 1, 2 },
-        { ahd_patch0_func, 556, 1, 1 },
-        { ahd_patch2_func, 561, 1, 2 },
-        { ahd_patch0_func, 562, 1, 1 },
-        { ahd_patch2_func, 566, 1, 2 },
-        { ahd_patch0_func, 567, 1, 1 },
-        { ahd_patch1_func, 568, 1, 2 },
-        { ahd_patch0_func, 569, 1, 1 },
-        { ahd_patch2_func, 580, 1, 2 },
-        { ahd_patch0_func, 581, 1, 1 },
-        { ahd_patch17_func, 585, 1, 1 },
-        { ahd_patch18_func, 590, 1, 1 },
-        { ahd_patch19_func, 591, 2, 1 },
-        { ahd_patch18_func, 595, 1, 2 },
-        { ahd_patch0_func, 596, 1, 1 },
-        { ahd_patch2_func, 599, 1, 2 },
-        { ahd_patch0_func, 600, 1, 1 },
-        { ahd_patch2_func, 615, 1, 2 },
-        { ahd_patch0_func, 616, 1, 1 },
-        { ahd_patch20_func, 617, 14, 1 },
-        { ahd_patch1_func, 635, 1, 2 },
-        { ahd_patch0_func, 636, 1, 1 },
-        { ahd_patch20_func, 637, 1, 1 },
-        { ahd_patch1_func, 649, 1, 2 },
-        { ahd_patch0_func, 650, 1, 1 },
-        { ahd_patch1_func, 657, 1, 2 },
-        { ahd_patch0_func, 658, 1, 1 },
-        { ahd_patch17_func, 681, 1, 1 },
-        { ahd_patch17_func, 719, 1, 1 },
-        { ahd_patch1_func, 730, 1, 2 },
-        { ahd_patch0_func, 731, 1, 1 },
-        { ahd_patch1_func, 748, 1, 2 },
-        { ahd_patch0_func, 749, 1, 1 },
-        { ahd_patch1_func, 751, 1, 2 },
-        { ahd_patch0_func, 752, 1, 1 },
-        { ahd_patch1_func, 755, 1, 2 },
-        { ahd_patch0_func, 756, 1, 1 },
-        { ahd_patch21_func, 758, 1, 2 },
-        { ahd_patch0_func, 759, 2, 1 },
-        { ahd_patch22_func, 762, 4, 2 },
-        { ahd_patch0_func, 766, 1, 1 },
-        { ahd_patch22_func, 774, 11, 1 }
+        { ahd_patch3_func, 36, 5, 1 },
+        { ahd_patch2_func, 45, 1, 2 },
+        { ahd_patch0_func, 46, 1, 1 },
+        { ahd_patch1_func, 53, 1, 2 },
+        { ahd_patch0_func, 54, 1, 1 },
+        { ahd_patch2_func, 59, 1, 2 },
+        { ahd_patch0_func, 60, 1, 1 },
+        { ahd_patch2_func, 63, 1, 2 },
+        { ahd_patch0_func, 64, 1, 1 },
+        { ahd_patch2_func, 67, 1, 2 },
+        { ahd_patch0_func, 68, 1, 1 },
+        { ahd_patch4_func, 116, 1, 1 },
+        { ahd_patch2_func, 175, 3, 1 },
+        { ahd_patch1_func, 178, 2, 1 },
+        { ahd_patch5_func, 180, 1, 1 },
+        { ahd_patch2_func, 189, 1, 2 },
+        { ahd_patch0_func, 190, 1, 1 },
+        { ahd_patch6_func, 191, 2, 2 },
+        { ahd_patch0_func, 193, 6, 3 },
+        { ahd_patch2_func, 196, 1, 2 },
+        { ahd_patch0_func, 197, 1, 1 },
+        { ahd_patch2_func, 200, 1, 2 },
+        { ahd_patch0_func, 201, 1, 1 },
+        { ahd_patch3_func, 203, 1, 1 },
+        { ahd_patch7_func, 204, 3, 1 },
+        { ahd_patch3_func, 213, 1, 1 },
+        { ahd_patch5_func, 214, 16, 2 },
+        { ahd_patch0_func, 230, 1, 1 },
+        { ahd_patch8_func, 250, 2, 1 },
+        { ahd_patch1_func, 254, 1, 2 },
+        { ahd_patch0_func, 255, 1, 1 },
+        { ahd_patch7_func, 258, 3, 1 },
+        { ahd_patch1_func, 273, 1, 2 },
+        { ahd_patch0_func, 274, 1, 1 },
+        { ahd_patch1_func, 277, 1, 2 },
+        { ahd_patch0_func, 278, 1, 1 },
+        { ahd_patch2_func, 281, 1, 2 },
+        { ahd_patch0_func, 282, 1, 1 },
+        { ahd_patch9_func, 295, 2, 2 },
+        { ahd_patch0_func, 297, 1, 1 },
+        { ahd_patch1_func, 339, 1, 2 },
+        { ahd_patch0_func, 340, 1, 1 },
+        { ahd_patch2_func, 348, 1, 2 },
+        { ahd_patch0_func, 349, 1, 1 },
+        { ahd_patch2_func, 352, 1, 2 },
+        { ahd_patch0_func, 353, 1, 1 },
+        { ahd_patch1_func, 359, 1, 2 },
+        { ahd_patch0_func, 360, 1, 1 },
+        { ahd_patch1_func, 362, 1, 2 },
+        { ahd_patch0_func, 363, 1, 1 },
+        { ahd_patch10_func, 382, 1, 1 },
+        { ahd_patch10_func, 385, 1, 1 },
+        { ahd_patch10_func, 387, 1, 1 },
+        { ahd_patch10_func, 399, 1, 1 },
+        { ahd_patch1_func, 409, 1, 2 },
+        { ahd_patch0_func, 410, 1, 1 },
+        { ahd_patch1_func, 412, 1, 2 },
+        { ahd_patch0_func, 413, 1, 1 },
+        { ahd_patch1_func, 421, 1, 2 },
+        { ahd_patch0_func, 422, 1, 1 },
+        { ahd_patch2_func, 435, 1, 2 },
+        { ahd_patch0_func, 436, 1, 1 },
+        { ahd_patch11_func, 472, 1, 1 },
+        { ahd_patch1_func, 480, 1, 2 },
+        { ahd_patch0_func, 481, 1, 1 },
+        { ahd_patch2_func, 493, 1, 2 },
+        { ahd_patch0_func, 494, 1, 1 },
+        { ahd_patch12_func, 497, 6, 2 },
+        { ahd_patch0_func, 503, 1, 1 },
+        { ahd_patch13_func, 524, 7, 1 },
+        { ahd_patch14_func, 533, 1, 1 },
+        { ahd_patch15_func, 542, 1, 1 },
+        { ahd_patch16_func, 543, 1, 2 },
+        { ahd_patch0_func, 544, 1, 1 },
+        { ahd_patch17_func, 547, 1, 1 },
+        { ahd_patch16_func, 548, 1, 1 },
+        { ahd_patch18_func, 559, 1, 2 },
+        { ahd_patch0_func, 560, 1, 1 },
+        { ahd_patch1_func, 579, 1, 2 },
+        { ahd_patch0_func, 580, 1, 1 },
+        { ahd_patch1_func, 583, 1, 2 },
+        { ahd_patch0_func, 584, 1, 1 },
+        { ahd_patch2_func, 589, 1, 2 },
+        { ahd_patch0_func, 590, 1, 1 },
+        { ahd_patch2_func, 594, 1, 2 },
+        { ahd_patch0_func, 595, 1, 1 },
+        { ahd_patch1_func, 596, 1, 2 },
+        { ahd_patch0_func, 597, 1, 1 },
+        { ahd_patch2_func, 608, 1, 2 },
+        { ahd_patch0_func, 609, 1, 1 },
+        { ahd_patch19_func, 613, 1, 1 },
+        { ahd_patch20_func, 618, 1, 1 },
+        { ahd_patch21_func, 619, 2, 1 },
+        { ahd_patch20_func, 623, 1, 2 },
+        { ahd_patch0_func, 624, 1, 1 },
+        { ahd_patch2_func, 627, 1, 2 },
+        { ahd_patch0_func, 628, 1, 1 },
+        { ahd_patch2_func, 643, 1, 2 },
+        { ahd_patch0_func, 644, 1, 1 },
+        { ahd_patch13_func, 645, 14, 1 },
+        { ahd_patch1_func, 663, 1, 2 },
+        { ahd_patch0_func, 664, 1, 1 },
+        { ahd_patch13_func, 665, 1, 1 },
+        { ahd_patch1_func, 677, 1, 2 },
+        { ahd_patch0_func, 678, 1, 1 },
+        { ahd_patch1_func, 685, 1, 2 },
+        { ahd_patch0_func, 686, 1, 1 },
+        { ahd_patch19_func, 709, 1, 1 },
+        { ahd_patch19_func, 747, 1, 1 },
+        { ahd_patch1_func, 758, 1, 2 },
+        { ahd_patch0_func, 759, 1, 1 },
+        { ahd_patch1_func, 776, 1, 2 },
+        { ahd_patch0_func, 777, 1, 1 },
+        { ahd_patch1_func, 779, 1, 2 },
+        { ahd_patch0_func, 780, 1, 1 },
+        { ahd_patch1_func, 783, 1, 2 },
+        { ahd_patch0_func, 784, 1, 1 },
+        { ahd_patch22_func, 786, 1, 2 },
+        { ahd_patch0_func, 787, 2, 1 },
+        { ahd_patch23_func, 790, 4, 2 },
+        { ahd_patch0_func, 794, 1, 1 },
+        { ahd_patch23_func, 802, 11, 1 }
 };
 
 static struct cs {
         uint16_t        begin;
         uint16_t        end;
 } critical_sections[] = {
-        { 11, 12 },
-        { 13, 14 },
-        { 29, 42 },
-        { 56, 59 },
-        { 101, 128 },
-        { 129, 157 },
-        { 159, 162 },
-        { 170, 178 },
-        { 201, 250 },
-        { 681, 697 },
-        { 697, 711 },
-        { 721, 725 }
+        { 17, 28 },
+        { 29, 30 },
+        { 47, 58 },
+        { 61, 63 },
+        { 65, 66 },
+        { 72, 92 },
+        { 110, 137 },
+        { 138, 175 },
+        { 180, 188 },
+        { 213, 264 },
+        { 425, 433 },
+        { 443, 445 },
+        { 448, 457 },
+        { 709, 739 },
+        { 749, 753 }
 };
 
 static const int num_critical_sections = sizeof(critical_sections)
diff --git a/drivers/scsi/aic7xxx/aic7xxx_osm.c b/drivers/scsi/aic7xxx/aic7xxx_osm.c
index fd389e9f9460..051970efba68 100644
--- a/drivers/scsi/aic7xxx/aic7xxx_osm.c
+++ b/drivers/scsi/aic7xxx/aic7xxx_osm.c
@@ -375,7 +375,7 @@ static void ahc_linux_queue_cmd_complete(struct ahc_softc *ahc,
                                          struct scsi_cmnd *cmd);
 static void ahc_linux_sem_timeout(u_long arg);
 static void ahc_linux_freeze_simq(struct ahc_softc *ahc);
-static void ahc_linux_release_simq(u_long arg);
+static void ahc_linux_release_simq(struct ahc_softc *ahc);
 static int  ahc_linux_queue_recovery_cmd(struct scsi_cmnd *cmd, scb_flag flag);
 static void ahc_linux_initialize_scsi_bus(struct ahc_softc *ahc);
 static u_int ahc_linux_user_tagdepth(struct ahc_softc *ahc,
@@ -1073,7 +1073,6 @@ ahc_linux_register_host(struct ahc_softc *ahc, struct scsi_host_template *templa
                 return (ENOMEM);
 
         *((struct ahc_softc **)host->hostdata) = ahc;
-        ahc_lock(ahc, &s);
         ahc->platform_data->host = host;
         host->can_queue = AHC_MAX_QUEUE;
         host->cmd_per_lun = 2;
@@ -1084,7 +1083,9 @@ ahc_linux_register_host(struct ahc_softc *ahc, struct scsi_host_template *templa
         host->max_lun = AHC_NUM_LUNS;
         host->max_channel = (ahc->features & AHC_TWIN) ? 1 : 0;
         host->sg_tablesize = AHC_NSEG;
+        ahc_lock(ahc, &s);
         ahc_set_unit(ahc, ahc_linux_unit++);
+        ahc_unlock(ahc, &s);
         sprintf(buf, "scsi%d", host->host_no);
         new_name = malloc(strlen(buf) + 1, M_DEVBUF, M_NOWAIT);
         if (new_name != NULL) {
@@ -1094,7 +1095,6 @@ ahc_linux_register_host(struct ahc_softc *ahc, struct scsi_host_template *templa
         host->unique_id = ahc->unit;
         ahc_linux_initialize_scsi_bus(ahc);
         ahc_intr_enable(ahc, TRUE);
-        ahc_unlock(ahc, &s);
 
         host->transportt = ahc_linux_transport_template;
 
@@ -1120,10 +1120,13 @@ ahc_linux_initialize_scsi_bus(struct ahc_softc *ahc)
 {
         int i;
         int numtarg;
+        unsigned long s;
 
         i = 0;
         numtarg = 0;
 
+        ahc_lock(ahc, &s);
+
         if (aic7xxx_no_reset != 0)
                 ahc->flags &= ~(AHC_RESET_BUS_A|AHC_RESET_BUS_B);
 
@@ -1170,16 +1173,12 @@ ahc_linux_initialize_scsi_bus(struct ahc_softc *ahc)
                 ahc_update_neg_request(ahc, &devinfo, tstate,
                                        tinfo, AHC_NEG_ALWAYS);
         }
+        ahc_unlock(ahc, &s);
         /* Give the bus some time to recover */
         if ((ahc->flags & (AHC_RESET_BUS_A|AHC_RESET_BUS_B)) != 0) {
                 ahc_linux_freeze_simq(ahc);
-                init_timer(&ahc->platform_data->reset_timer);
-                ahc->platform_data->reset_timer.data = (u_long)ahc;
-                ahc->platform_data->reset_timer.expires =
-                    jiffies + (AIC7XXX_RESET_DELAY * HZ)/1000;
-                ahc->platform_data->reset_timer.function =
-                    ahc_linux_release_simq;
-                add_timer(&ahc->platform_data->reset_timer);
+                msleep(AIC7XXX_RESET_DELAY);
+                ahc_linux_release_simq(ahc);
         }
 }
 
@@ -2059,6 +2058,9 @@ ahc_linux_sem_timeout(u_long arg)
 static void
 ahc_linux_freeze_simq(struct ahc_softc *ahc)
 {
+        unsigned long s;
+
+        ahc_lock(ahc, &s);
         ahc->platform_data->qfrozen++;
         if (ahc->platform_data->qfrozen == 1) {
                 scsi_block_requests(ahc->platform_data->host);
@@ -2068,17 +2070,15 @@ ahc_linux_freeze_simq(struct ahc_softc *ahc)
                                         CAM_LUN_WILDCARD, SCB_LIST_NULL,
                                         ROLE_INITIATOR, CAM_REQUEUE_REQ);
         }
+        ahc_unlock(ahc, &s);
 }
 
 static void
-ahc_linux_release_simq(u_long arg)
+ahc_linux_release_simq(struct ahc_softc *ahc)
 {
-        struct ahc_softc *ahc;
         u_long s;
         int    unblock_reqs;
 
-        ahc = (struct ahc_softc *)arg;
-
         unblock_reqs = 0;
         ahc_lock(ahc, &s);
         if (ahc->platform_data->qfrozen > 0)
diff --git a/drivers/scsi/aic7xxx/aic7xxx_osm.h b/drivers/scsi/aic7xxx/aic7xxx_osm.h
index f2a95447142c..e0edacae895f 100644
--- a/drivers/scsi/aic7xxx/aic7xxx_osm.h
+++ b/drivers/scsi/aic7xxx/aic7xxx_osm.h
@@ -223,9 +223,6 @@ int	ahc_dmamap_unload(struct ahc_softc *, bus_dma_tag_t, bus_dmamap_t);
  */
 #define ahc_dmamap_sync(ahc, dma_tag, dmamap, offset, len, op)
 
-/************************** Timer DataStructures ******************************/
-typedef struct timer_list ahc_timer_t;
-
 /********************************** Includes **********************************/
 #ifdef CONFIG_AIC7XXX_REG_PRETTY_PRINT
 #define AIC_DEBUG_REGISTERS 1
@@ -235,30 +232,9 @@ typedef struct timer_list ahc_timer_t;
 #include "aic7xxx.h"
 
 /***************************** Timer Facilities *******************************/
-#define ahc_timer_init init_timer
-#define ahc_timer_stop del_timer_sync
-typedef void ahc_linux_callback_t (u_long);  
-static __inline void ahc_timer_reset(ahc_timer_t *timer, int usec,
-                                     ahc_callback_t *func, void *arg);
-static __inline void ahc_scb_timer_reset(struct scb *scb, u_int usec);
-
-static __inline void
-ahc_timer_reset(ahc_timer_t *timer, int usec, ahc_callback_t *func, void *arg)
-{
-        struct ahc_softc *ahc;
-
-        ahc = (struct ahc_softc *)arg;
-        del_timer(timer);
-        timer->data = (u_long)arg;
-        timer->expires = jiffies + (usec * HZ)/1000000;
-        timer->function = (ahc_linux_callback_t*)func;
-        add_timer(timer);
-}
-
 static __inline void
 ahc_scb_timer_reset(struct scb *scb, u_int usec)
 {
-        mod_timer(&scb->io_ctx->eh_timeout, jiffies + (usec * HZ)/1000000);
 }
 
 /***************************** SMP support ************************************/
@@ -393,7 +369,6 @@ struct ahc_platform_data {
 
         spinlock_t               spin_lock;
         u_int                    qfrozen;
-        struct timer_list        reset_timer;
         struct semaphore         eh_sem;
         struct Scsi_Host        *host;          /* pointer to scsi host */
 #define AHC_LINUX_NOIRQ ((uint32_t)~0)
diff --git a/drivers/scsi/aic7xxx/aic7xxx_pci.c b/drivers/scsi/aic7xxx/aic7xxx_pci.c
index b3b2e2237eb3..5f586140e057 100644
--- a/drivers/scsi/aic7xxx/aic7xxx_pci.c
+++ b/drivers/scsi/aic7xxx/aic7xxx_pci.c
@@ -39,9 +39,7 @@
  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGES.
  *
- * $Id: //depot/aic7xxx/aic7xxx/aic7xxx_pci.c#69 $
- *
- * $FreeBSD$
+ * $Id: //depot/aic7xxx/aic7xxx/aic7xxx_pci.c#79 $
  */
 
 #ifdef __linux__
@@ -393,6 +391,12 @@ struct ahc_pci_identity ahc_pci_ident_table [] =
                 "Adaptec aic7892 Ultra160 SCSI adapter (ARO)",
                 ahc_aic7892_setup
         },
+        {
+                ID_AHA_2915_30LP,
+                ID_ALL_MASK,
+                "Adaptec 2915/30LP Ultra160 SCSI adapter",
+                ahc_aic7892_setup
+        },
         /* aic7895 based controllers */ 
         {
                 ID_AHA_2940U_DUAL,
@@ -1193,9 +1197,19 @@ ahc_pci_test_register_access(struct ahc_softc *ahc)
          * use for this test.
          */
         hcntrl = ahc_inb(ahc, HCNTRL);
+
         if (hcntrl == 0xFF)
                 goto fail;
 
+        if ((hcntrl & CHIPRST) != 0) {
+                /*
+                 * The chip has not been initialized since
+                 * PCI/EISA/VLB bus reset.  Don't trust
+                 * "left over BIOS data".
+                 */
+                ahc->flags |= AHC_NO_BIOS_INIT;
+        }
+
         /*
          * Next create a situation where write combining
          * or read prefetching could be initiated by the
@@ -1307,6 +1321,10 @@ check_extport(struct ahc_softc *ahc, u_int *sxfrctl1)
                         sd.sd_chip = C56_66;
                 }
                 ahc_release_seeprom(&sd);
+
+                /* Remember the SEEPROM type for later */
+                if (sd.sd_chip == C56_66)
+                        ahc->flags |= AHC_LARGE_SEEPROM;
         }
 
         if (!have_seeprom) {
diff --git a/drivers/scsi/aic7xxx/aic7xxx_pci.h b/drivers/scsi/aic7xxx/aic7xxx_pci.h
index be27fcb20346..263f85da405e 100644
--- a/drivers/scsi/aic7xxx/aic7xxx_pci.h
+++ b/drivers/scsi/aic7xxx/aic7xxx_pci.h
@@ -105,6 +105,7 @@
 #define ID_AHA_29160C                   0x0080900562209005ull
 #define ID_AHA_29160B                   0x00809005E2209005ull
 #define ID_AHA_19160B                   0x0081900562A19005ull
+#define ID_AHA_2915_30LP                0x0082900502109005ull
 
 #define ID_AIC7896                      0x005F9005FFFF9005ull
 #define ID_AIC7896_ARO                  0x00539005FFFF9005ull
diff --git a/drivers/scsi/aic7xxx_old.c b/drivers/scsi/aic7xxx_old.c
index 33d56c344944..770f1647e4d6 100644
--- a/drivers/scsi/aic7xxx_old.c
+++ b/drivers/scsi/aic7xxx_old.c
@@ -1290,7 +1290,7 @@ static void aic7xxx_check_scbs(struct aic7xxx_host *p, char *buffer);
  *
  ***************************************************************************/
 
-static inline unsigned char
+static unsigned char
 aic_inb(struct aic7xxx_host *p, long port)
 {
 #ifdef MMAPIO
@@ -1309,7 +1309,7 @@ aic_inb(struct aic7xxx_host *p, long port)
 #endif
 }
 
-static inline void
+static void
 aic_outb(struct aic7xxx_host *p, unsigned char val, long port)
 {
 #ifdef MMAPIO
diff --git a/drivers/scsi/ch.c b/drivers/scsi/ch.c
index 4299fabca554..c3f27285db1b 100644
--- a/drivers/scsi/ch.c
+++ b/drivers/scsi/ch.c
@@ -22,6 +22,7 @@
 #include <linux/completion.h>
 #include <linux/compat.h>
 #include <linux/chio.h>                 /* here are all the ioctls */
+#include <linux/mutex.h>
 
 #include <scsi/scsi.h>
 #include <scsi/scsi_cmnd.h>
@@ -111,7 +112,7 @@ typedef struct {
         u_int               counts[CH_TYPES];
         u_int               unit_attention;
         u_int               voltags;
-        struct semaphore    lock;
+        struct mutex        lock;
 } scsi_changer;
 
 static LIST_HEAD(ch_devlist);
@@ -565,7 +566,7 @@ static int ch_gstatus(scsi_changer *ch, int type, unsigned char __user *dest)
         u_char data[16];
         unsigned int i;
         
-        down(&ch->lock);
+        mutex_lock(&ch->lock);
         for (i = 0; i < ch->counts[type]; i++) {
                 if (0 != ch_read_element_status
                     (ch, ch->firsts[type]+i,data)) {
@@ -582,7 +583,7 @@ static int ch_gstatus(scsi_changer *ch, int type, unsigned char __user *dest)
                 if (0 != retval)
                         break;
         }
-        up(&ch->lock);
+        mutex_unlock(&ch->lock);
         return retval;
 }
 
@@ -687,11 +688,11 @@ static int ch_ioctl(struct inode * inode, struct file * file,
                         dprintk("CHIOPOSITION: invalid parameter\n");
                         return -EBADSLT;
                 }
-                down(&ch->lock);
+                mutex_lock(&ch->lock);
                 retval = ch_position(ch,0,
                                      ch->firsts[pos.cp_type] + pos.cp_unit,
                                      pos.cp_flags & CP_INVERT);
-                up(&ch->lock);
+                mutex_unlock(&ch->lock);
                 return retval;
         }
         
@@ -708,12 +709,12 @@ static int ch_ioctl(struct inode * inode, struct file * file,
                         return -EBADSLT;
                 }
                 
-                down(&ch->lock);
+                mutex_lock(&ch->lock);
                 retval = ch_move(ch,0,
                                  ch->firsts[mv.cm_fromtype] + mv.cm_fromunit,
                                  ch->firsts[mv.cm_totype]   + mv.cm_tounit,
                                  mv.cm_flags & CM_INVERT);
-                up(&ch->lock);
+                mutex_unlock(&ch->lock);
                 return retval;
         }
 
@@ -731,14 +732,14 @@ static int ch_ioctl(struct inode * inode, struct file * file,
                         return -EBADSLT;
                 }
                 
-                down(&ch->lock);
+                mutex_lock(&ch->lock);
                 retval = ch_exchange
                         (ch,0,
                          ch->firsts[mv.ce_srctype]  + mv.ce_srcunit,
                          ch->firsts[mv.ce_fdsttype] + mv.ce_fdstunit,
                          ch->firsts[mv.ce_sdsttype] + mv.ce_sdstunit,
                          mv.ce_flags & CE_INVERT1, mv.ce_flags & CE_INVERT2);
-                up(&ch->lock);
+                mutex_unlock(&ch->lock);
                 return retval;
         }
 
@@ -772,7 +773,7 @@ static int ch_ioctl(struct inode * inode, struct file * file,
                 buffer = kmalloc(512, GFP_KERNEL | GFP_DMA);
                 if (!buffer)
                         return -ENOMEM;
-                down(&ch->lock);
+                mutex_lock(&ch->lock);
                 
         voltag_retry:
                 memset(cmd,0,sizeof(cmd));
@@ -823,7 +824,7 @@ static int ch_ioctl(struct inode * inode, struct file * file,
                         goto voltag_retry;
                 }
                 kfree(buffer);
-                up(&ch->lock);
+                mutex_unlock(&ch->lock);
                 
                 if (copy_to_user(argp, &cge, sizeof (cge)))
                         return -EFAULT;
@@ -832,9 +833,9 @@ static int ch_ioctl(struct inode * inode, struct file * file,
 
         case CHIOINITELEM:
         {
-                down(&ch->lock);
+                mutex_lock(&ch->lock);
                 retval = ch_init_elem(ch);
-                up(&ch->lock);
+                mutex_unlock(&ch->lock);
                 return retval;
         }
                 
@@ -851,12 +852,12 @@ static int ch_ioctl(struct inode * inode, struct file * file,
                         return -EBADSLT;
                 }
                 elem = ch->firsts[csv.csv_type] + csv.csv_unit;
-                down(&ch->lock);
+                mutex_lock(&ch->lock);
                 retval = ch_set_voltag(ch, elem,
                                        csv.csv_flags & CSV_AVOLTAG,
                                        csv.csv_flags & CSV_CLEARTAG,
                                        csv.csv_voltag);
-                up(&ch->lock);
+                mutex_unlock(&ch->lock);
                 return retval;
         }
 
@@ -929,7 +930,7 @@ static int ch_probe(struct device *dev)
         memset(ch,0,sizeof(*ch));
         ch->minor = ch_devcount;
         sprintf(ch->name,"ch%d",ch->minor);
-        init_MUTEX(&ch->lock);
+        mutex_init(&ch->lock);
         ch->device = sd;
         ch_readconfig(ch);
         if (init)
diff --git a/drivers/scsi/dpt_i2o.c b/drivers/scsi/dpt_i2o.c
index 6252b9ddc01e..6e6b293dcb28 100644
--- a/drivers/scsi/dpt_i2o.c
+++ b/drivers/scsi/dpt_i2o.c
@@ -61,6 +61,7 @@ MODULE_DESCRIPTION("Adaptec I2O RAID Driver");
 #include <linux/timer.h>
 #include <linux/string.h>
 #include <linux/ioport.h>
+#include <linux/mutex.h>
 
 #include <asm/processor.h>      /* for boot_cpu_data */
 #include <asm/pgtable.h>
@@ -106,7 +107,7 @@ static dpt_sig_S DPTI_sig = {
  *============================================================================
  */
 
-static DECLARE_MUTEX(adpt_configuration_lock);
+static DEFINE_MUTEX(adpt_configuration_lock);
 
 static struct i2o_sys_tbl *sys_tbl = NULL;
 static int sys_tbl_ind = 0;
@@ -537,13 +538,13 @@ static int adpt_proc_info(struct Scsi_Host *host, char *buffer, char **start, of
          */
 
         // Find HBA (host bus adapter) we are looking for
-        down(&adpt_configuration_lock);
+        mutex_lock(&adpt_configuration_lock);
         for (pHba = hba_chain; pHba; pHba = pHba->next) {
                 if (pHba->host == host) {
                         break;  /* found adapter */
                 }
         }
-        up(&adpt_configuration_lock);
+        mutex_unlock(&adpt_configuration_lock);
         if (pHba == NULL) {
                 return 0;
         }
@@ -898,6 +899,12 @@ static int adpt_install_hba(struct scsi_host_template* sht, struct pci_dev* pDev
         if(pci_enable_device(pDev)) {
                 return -EINVAL;
         }
+
+        if (pci_request_regions(pDev, "dpt_i2o")) {
+                PERROR("dpti: adpt_config_hba: pci request region failed\n");
+                return -EINVAL;
+        }
+
         pci_set_master(pDev);
         if (pci_set_dma_mask(pDev, 0xffffffffffffffffULL) &&
             pci_set_dma_mask(pDev, 0xffffffffULL))
@@ -923,10 +930,6 @@ static int adpt_install_hba(struct scsi_host_template* sht, struct pci_dev* pDev
                 raptorFlag = TRUE;
         }
 
-        if (pci_request_regions(pDev, "dpt_i2o")) {
-                PERROR("dpti: adpt_config_hba: pci request region failed\n");
-                return -EINVAL;
-        }
         base_addr_virt = ioremap(base_addr0_phys,hba_map0_area_size);
         if (!base_addr_virt) {
                 pci_release_regions(pDev);
@@ -958,7 +961,7 @@ static int adpt_install_hba(struct scsi_host_template* sht, struct pci_dev* pDev
         }
         memset(pHba, 0, sizeof(adpt_hba));
 
-        down(&adpt_configuration_lock);
+        mutex_lock(&adpt_configuration_lock);
 
         if(hba_chain != NULL){
                 for(p = hba_chain; p->next; p = p->next);
@@ -971,7 +974,7 @@ static int adpt_install_hba(struct scsi_host_template* sht, struct pci_dev* pDev
         sprintf(pHba->name, "dpti%d", hba_count);
         hba_count++;
         
-        up(&adpt_configuration_lock);
+        mutex_unlock(&adpt_configuration_lock);
 
         pHba->pDev = pDev;
         pHba->base_addr_phys = base_addr0_phys;
@@ -1027,7 +1030,7 @@ static void adpt_i2o_delete_hba(adpt_hba* pHba)
         struct adpt_device* pNext;
 
 
-        down(&adpt_configuration_lock);
+        mutex_lock(&adpt_configuration_lock);
         // scsi_unregister calls our adpt_release which
         // does a quiese
         if(pHba->host){
@@ -1046,7 +1049,7 @@ static void adpt_i2o_delete_hba(adpt_hba* pHba)
         }
 
         hba_count--;
-        up(&adpt_configuration_lock);
+        mutex_unlock(&adpt_configuration_lock);
 
         iounmap(pHba->base_addr_virt);
         pci_release_regions(pHba->pDev);
@@ -1549,7 +1552,7 @@ static int adpt_i2o_parse_lct(adpt_hba* pHba)
  
 static int adpt_i2o_install_device(adpt_hba* pHba, struct i2o_device *d)
 {
-        down(&adpt_configuration_lock);
+        mutex_lock(&adpt_configuration_lock);
         d->controller=pHba;
         d->owner=NULL;
         d->next=pHba->devices;
@@ -1560,7 +1563,7 @@ static int adpt_i2o_install_device(adpt_hba* pHba, struct i2o_device *d)
         pHba->devices=d;
         *d->dev_name = 0;
 
-        up(&adpt_configuration_lock);
+        mutex_unlock(&adpt_configuration_lock);
         return 0;
 }
 
@@ -1575,24 +1578,24 @@ static int adpt_open(struct inode *inode, struct file *file)
         if (minor >= hba_count) {
                 return -ENXIO;
         }
-        down(&adpt_configuration_lock);
+        mutex_lock(&adpt_configuration_lock);
         for (pHba = hba_chain; pHba; pHba = pHba->next) {
                 if (pHba->unit == minor) {
                         break;  /* found adapter */
                 }
         }
         if (pHba == NULL) {
-                up(&adpt_configuration_lock);
+                mutex_unlock(&adpt_configuration_lock);
                 return -ENXIO;
         }
 
 //      if(pHba->in_use){
-        //      up(&adpt_configuration_lock);
+        //      mutex_unlock(&adpt_configuration_lock);
 //              return -EBUSY;
 //      }
 
         pHba->in_use = 1;
-        up(&adpt_configuration_lock);
+        mutex_unlock(&adpt_configuration_lock);
 
         return 0;
 }
@@ -1606,13 +1609,13 @@ static int adpt_close(struct inode *inode, struct file *file)
         if (minor >= hba_count) {
                 return -ENXIO;
         }
-        down(&adpt_configuration_lock);
+        mutex_lock(&adpt_configuration_lock);
         for (pHba = hba_chain; pHba; pHba = pHba->next) {
                 if (pHba->unit == minor) {
                         break;  /* found adapter */
                 }
         }
-        up(&adpt_configuration_lock);
+        mutex_unlock(&adpt_configuration_lock);
         if (pHba == NULL) {
                 return -ENXIO;
         }
@@ -1910,13 +1913,13 @@ static int adpt_ioctl(struct inode *inode, struct file *file, uint cmd,
         if (minor >= DPTI_MAX_HBA){
                 return -ENXIO;
         }
-        down(&adpt_configuration_lock);
+        mutex_lock(&adpt_configuration_lock);
         for (pHba = hba_chain; pHba; pHba = pHba->next) {
                 if (pHba->unit == minor) {
                         break;  /* found adapter */
                 }
         }
-        up(&adpt_configuration_lock);
+        mutex_unlock(&adpt_configuration_lock);
         if(pHba == NULL){
                 return -ENXIO;
         }
diff --git a/drivers/scsi/hosts.c b/drivers/scsi/hosts.c
index 66783c860a19..588107923499 100644
--- a/drivers/scsi/hosts.c
+++ b/drivers/scsi/hosts.c
@@ -156,16 +156,16 @@ EXPORT_SYMBOL(scsi_host_set_state);
 void scsi_remove_host(struct Scsi_Host *shost)
 {
         unsigned long flags;
-        down(&shost->scan_mutex);
+        mutex_lock(&shost->scan_mutex);
         spin_lock_irqsave(shost->host_lock, flags);
         if (scsi_host_set_state(shost, SHOST_CANCEL))
                 if (scsi_host_set_state(shost, SHOST_CANCEL_RECOVERY)) {
                         spin_unlock_irqrestore(shost->host_lock, flags);
-                        up(&shost->scan_mutex);
+                        mutex_unlock(&shost->scan_mutex);
                         return;
                 }
         spin_unlock_irqrestore(shost->host_lock, flags);
-        up(&shost->scan_mutex);
+        mutex_unlock(&shost->scan_mutex);
         scsi_forget_host(shost);
         scsi_proc_host_rm(shost);
 
@@ -320,7 +320,7 @@ struct Scsi_Host *scsi_host_alloc(struct scsi_host_template *sht, int privsize)
         INIT_LIST_HEAD(&shost->starved_list);
         init_waitqueue_head(&shost->host_wait);
 
-        init_MUTEX(&shost->scan_mutex);
+        mutex_init(&shost->scan_mutex);
 
         shost->host_no = scsi_host_next_hn++; /* XXX(hch): still racy */
         shost->dma_channel = 0xff;
diff --git a/drivers/scsi/ips.c b/drivers/scsi/ips.c
index 3882d48a42bf..e5e1ca44e1ee 100644
--- a/drivers/scsi/ips.c
+++ b/drivers/scsi/ips.c
@@ -1319,6 +1319,9 @@ ips_slave_configure(struct scsi_device * SDptr)
                         min = ha->max_cmds - 1;
                 scsi_adjust_queue_depth(SDptr, MSG_ORDERED_TAG, min);
         }
+
+        SDptr->skip_ms_page_8 = 1;
+        SDptr->skip_ms_page_3f = 1;
         return 0;
 }
 #endif
diff --git a/drivers/scsi/iscsi_tcp.c b/drivers/scsi/iscsi_tcp.c
index 10bcf42cb65c..780bfcc67096 100644
--- a/drivers/scsi/iscsi_tcp.c
+++ b/drivers/scsi/iscsi_tcp.c
@@ -33,6 +33,7 @@
 #include <linux/delay.h>
 #include <linux/kfifo.h>
 #include <linux/scatterlist.h>
+#include <linux/mutex.h>
 #include <net/tcp.h>
 #include <scsi/scsi_cmnd.h>
 #include <scsi/scsi_device.h>
@@ -86,35 +87,32 @@ iscsi_buf_init_virt(struct iscsi_buf *ibuf, char *vbuf, int size)
 {
         sg_init_one(&ibuf->sg, (u8 *)vbuf, size);
         ibuf->sent = 0;
+        ibuf->use_sendmsg = 0;
 }
 
 static inline void
 iscsi_buf_init_iov(struct iscsi_buf *ibuf, char *vbuf, int size)
 {
-        ibuf->sg.page = (void*)vbuf;
-        ibuf->sg.offset = (unsigned int)-1;
+        ibuf->sg.page = virt_to_page(vbuf);
+        ibuf->sg.offset = offset_in_page(vbuf);
         ibuf->sg.length = size;
         ibuf->sent = 0;
-}
-
-static inline void*
-iscsi_buf_iov_base(struct iscsi_buf *ibuf)
-{
-        return (char*)ibuf->sg.page + ibuf->sent;
+        ibuf->use_sendmsg = 1;
 }
 
 static inline void
 iscsi_buf_init_sg(struct iscsi_buf *ibuf, struct scatterlist *sg)
 {
+        ibuf->sg.page = sg->page;
+        ibuf->sg.offset = sg->offset;
+        ibuf->sg.length = sg->length;
         /*
          * Fastpath: sg element fits into single page
          */
-        if (sg->length + sg->offset <= PAGE_SIZE && page_count(sg->page) >= 2) {
-                ibuf->sg.page = sg->page;
-                ibuf->sg.offset = sg->offset;
-                ibuf->sg.length = sg->length;
-        } else
-                iscsi_buf_init_iov(ibuf, page_address(sg->page), sg->length);
+        if (sg->length + sg->offset <= PAGE_SIZE && !PageSlab(sg->page))
+                ibuf->use_sendmsg = 0;
+        else
+                ibuf->use_sendmsg = 1;
         ibuf->sent = 0;
 }
 
@@ -356,7 +354,7 @@ iscsi_data_rsp(struct iscsi_conn *conn, struct iscsi_cmd_task *ctask)
                 struct scsi_cmnd *sc = ctask->sc;
 
                 conn->exp_statsn = be32_to_cpu(rhdr->statsn) + 1;
-                if (rhdr->flags & ISCSI_FLAG_CMD_UNDERFLOW) {
+                if (rhdr->flags & ISCSI_FLAG_DATA_UNDERFLOW) {
                         int res_count = be32_to_cpu(rhdr->residual_count);
 
                         if (res_count > 0 &&
@@ -366,9 +364,7 @@ iscsi_data_rsp(struct iscsi_conn *conn, struct iscsi_cmd_task *ctask)
                         } else
                                 sc->result = (DID_BAD_TARGET << 16) |
                                         rhdr->cmd_status;
-                } else if (rhdr->flags & ISCSI_FLAG_CMD_BIDI_UNDERFLOW)
-                        sc->result = (DID_BAD_TARGET << 16) | rhdr->cmd_status;
-                else if (rhdr->flags & ISCSI_FLAG_CMD_OVERFLOW) {
+                } else if (rhdr->flags & ISCSI_FLAG_DATA_OVERFLOW) {
                         sc->resid = be32_to_cpu(rhdr->residual_count);
                         sc->result = (DID_OK << 16) | rhdr->cmd_status;
                 } else
@@ -529,7 +525,7 @@ iscsi_r2t_rsp(struct iscsi_conn *conn, struct iscsi_cmd_task *ctask)
         __kfifo_put(ctask->r2tqueue, (void*)&r2t, sizeof(void*));
         __kfifo_put(conn->writequeue, (void*)&ctask, sizeof(void*));
 
-        schedule_work(&conn->xmitwork);
+        scsi_queue_work(session->host, &conn->xmitwork);
         conn->r2t_pdus_cnt++;
         spin_unlock(&session->lock);
 
@@ -686,7 +682,7 @@ iscsi_hdr_recv(struct iscsi_conn *conn)
                 switch(conn->in.opcode) {
                 case ISCSI_OP_LOGIN_RSP:
                 case ISCSI_OP_TEXT_RSP:
-                case ISCSI_OP_LOGOUT_RSP: 
+                case ISCSI_OP_LOGOUT_RSP:
                         rc = iscsi_check_assign_cmdsn(session,
                                                  (struct iscsi_nopin*)hdr);
                         if (rc)
@@ -727,12 +723,12 @@ iscsi_hdr_recv(struct iscsi_conn *conn)
                         }
                         spin_unlock(&session->lock);
                         break;
-                case ISCSI_OP_NOOP_IN: 
+                case ISCSI_OP_NOOP_IN:
                         if (hdr->ttt != ISCSI_RESERVED_TAG) {
                                 rc = ISCSI_ERR_PROTO;
                                 break;
                         }
-                        rc = iscsi_check_assign_cmdsn(session, 
+                        rc = iscsi_check_assign_cmdsn(session,
                                                 (struct iscsi_nopin*)hdr);
                         if (rc)
                                 break;
@@ -767,7 +763,7 @@ iscsi_hdr_recv(struct iscsi_conn *conn)
                                 if (!rc && hdr->ttt != ISCSI_RESERVED_TAG)
                                         rc = iscsi_recv_pdu(iscsi_handle(conn),
                                                             hdr, NULL, 0);
-                        } else 
+                        } else
                                 rc = ISCSI_ERR_PROTO;
                         break;
                 case ISCSI_OP_REJECT:
@@ -929,7 +925,7 @@ static int iscsi_scsi_data_in(struct iscsi_conn *conn)
                                       sc->request_bufflen, ctask->data_offset);
                 if (rc == -EAGAIN)
                         return rc;
-                if (conn->datadgst_en) 
+                if (conn->datadgst_en)
                         iscsi_recv_digest_update(conn, sc->request_buffer, i);
                 rc = 0;
                 goto done;
@@ -1024,7 +1020,7 @@ iscsi_data_recv(struct iscsi_conn *conn)
                 conn->in.hdr = &conn->hdr;
                 conn->senselen = (conn->data[0] << 8) | conn->data[1];
                 rc = iscsi_cmd_rsp(conn, conn->in.ctask);
-                if (!rc && conn->datadgst_en) 
+                if (!rc && conn->datadgst_en)
                         iscsi_recv_digest_update(conn, conn->data,
                                                  conn->in.datalen);
         }
@@ -1051,7 +1047,7 @@ iscsi_data_recv(struct iscsi_conn *conn)
                 rc = iscsi_recv_pdu(iscsi_handle(conn), conn->in.hdr,
                                     conn->data, conn->in.datalen);
 
-                if (!rc && conn->datadgst_en && 
+                if (!rc && conn->datadgst_en &&
                         conn->in.opcode != ISCSI_OP_LOGIN_RSP)
                         iscsi_recv_digest_update(conn, conn->data,
                                                 conn->in.datalen);
@@ -1271,7 +1267,7 @@ iscsi_write_space(struct sock *sk)
         conn->old_write_space(sk);
         debug_tcp("iscsi_write_space: cid %d\n", conn->id);
         clear_bit(SUSPEND_BIT, &conn->suspend_tx);
-        schedule_work(&conn->xmitwork);
+        scsi_queue_work(conn->session->host, &conn->xmitwork);
 }
 
 static void
@@ -1312,35 +1308,25 @@ iscsi_conn_restore_callbacks(struct iscsi_conn *conn)
  * @buf: buffer to write from
  * @size: actual size to write
  * @flags: socket's flags
- *
- * Notes:
- *      depending on buffer will use tcp_sendpage() or tcp_sendmsg().
- *      buf->sg.offset == -1 tells us that buffer is non S/G and forces
- *      to use tcp_sendmsg().
  */
 static inline int
-iscsi_send(struct socket *sk, struct iscsi_buf *buf, int size, int flags)
+iscsi_send(struct iscsi_conn *conn, struct iscsi_buf *buf, int size, int flags)
 {
-        int res;
-
-        if ((int)buf->sg.offset >= 0) {
-                int offset = buf->sg.offset + buf->sent;
-
-                /* tcp_sendpage */
-                res = sk->ops->sendpage(sk, buf->sg.page, offset, size, flags);
-        } else {
-                struct msghdr msg;
-
-                buf->iov.iov_base = iscsi_buf_iov_base(buf);
-                buf->iov.iov_len = size;
-
-                memset(&msg, 0, sizeof(struct msghdr));
-
-                /* tcp_sendmsg */
-                res = kernel_sendmsg(sk, &msg, &buf->iov, 1, size);
-        }
+        struct socket *sk = conn->sock;
+        int offset = buf->sg.offset + buf->sent;
 
-        return res;
+        /*
+         * if we got use_sg=0 or are sending something we kmallocd
+         * then we did not have to do kmap (kmap returns page_address)
+         *
+         * if we got use_sg > 0, but had to drop down, we do not
+         * set clustering so this should only happen for that
+         * slab case.
+         */
+        if (buf->use_sendmsg)
+                return sock_no_sendpage(sk, buf->sg.page, offset, size, flags);
+        else
+                return conn->sendpage(sk, buf->sg.page, offset, size, flags);
 }
 
 /**
@@ -1355,7 +1341,6 @@ iscsi_send(struct socket *sk, struct iscsi_buf *buf, int size, int flags)
 static inline int
 iscsi_sendhdr(struct iscsi_conn *conn, struct iscsi_buf *buf, int datalen)
 {
-        struct socket *sk = conn->sock;
         int flags = 0; /* MSG_DONTWAIT; */
         int res, size;
 
@@ -1364,7 +1349,7 @@ iscsi_sendhdr(struct iscsi_conn *conn, struct iscsi_buf *buf, int datalen)
         if (buf->sent + size != buf->sg.length || datalen)
                 flags |= MSG_MORE;
 
-        res = iscsi_send(sk, buf, size, flags);
+        res = iscsi_send(conn, buf, size, flags);
         debug_tcp("sendhdr %d bytes, sent %d res %d\n", size, buf->sent, res);
         if (res >= 0) {
                 conn->txdata_octets += res;
@@ -1395,7 +1380,6 @@ static inline int
 iscsi_sendpage(struct iscsi_conn *conn, struct iscsi_buf *buf,
                int *count, int *sent)
 {
-        struct socket *sk = conn->sock;
         int flags = 0; /* MSG_DONTWAIT; */
         int res, size;
 
@@ -1406,7 +1390,7 @@ iscsi_sendpage(struct iscsi_conn *conn, struct iscsi_buf *buf,
         if (buf->sent + size != buf->sg.length || *count != size)
                 flags |= MSG_MORE;
 
-        res = iscsi_send(sk, buf, size, flags);
+        res = iscsi_send(conn, buf, size, flags);
         debug_tcp("sendpage: %d bytes, sent %d left %d sent %d res %d\n",
                   size, buf->sent, *count, *sent, res);
         if (res >= 0) {
@@ -1434,20 +1418,7 @@ iscsi_data_digest_init(struct iscsi_conn *conn, struct iscsi_cmd_task *ctask)
         ctask->digest_count = 4;
 }
 
-static inline void
-iscsi_buf_data_digest_update(struct iscsi_conn *conn, struct iscsi_buf *buf)
-{
-        struct scatterlist sg;
-
-        if (buf->sg.offset != -1)
-                crypto_digest_update(conn->data_tx_tfm, &buf->sg, 1);
-        else {
-                sg_init_one(&sg, (char *)buf->sg.page, buf->sg.length);
-                crypto_digest_update(conn->data_tx_tfm, &sg, 1);
-        }
-}
-
-static inline int
+static int
 iscsi_digest_final_send(struct iscsi_conn *conn, struct iscsi_cmd_task *ctask,
                         struct iscsi_buf *buf, uint32_t *digest, int final)
 {
@@ -1680,7 +1651,7 @@ iscsi_cmd_init(struct iscsi_conn *conn, struct iscsi_cmd_task *ctask,
                 zero_data(ctask->hdr.dlength);
         }
 
-        iscsi_buf_init_virt(&ctask->headbuf, (char*)&ctask->hdr, 
+        iscsi_buf_init_virt(&ctask->headbuf, (char*)&ctask->hdr,
                             sizeof(struct iscsi_hdr));
         conn->scsicmd_pdus_cnt++;
 }
@@ -1746,7 +1717,7 @@ static inline int
 handle_xmstate_r_hdr(struct iscsi_conn *conn, struct iscsi_cmd_task *ctask)
 {
         ctask->xmstate &= ~XMSTATE_R_HDR;
-        if (conn->hdrdgst_en) 
+        if (conn->hdrdgst_en)
                 iscsi_hdr_digest(conn, &ctask->headbuf, (u8*)ctask->hdrext);
         if (!iscsi_sendhdr(conn, &ctask->headbuf, 0)) {
                 BUG_ON(ctask->xmstate != XMSTATE_IDLE);
@@ -1760,7 +1731,7 @@ static inline int
 handle_xmstate_w_hdr(struct iscsi_conn *conn, struct iscsi_cmd_task *ctask)
 {
         ctask->xmstate &= ~XMSTATE_W_HDR;
-        if (conn->hdrdgst_en) 
+        if (conn->hdrdgst_en)
                 iscsi_hdr_digest(conn, &ctask->headbuf, (u8*)ctask->hdrext);
         if (iscsi_sendhdr(conn, &ctask->headbuf, ctask->imm_count)) {
                 ctask->xmstate |= XMSTATE_W_HDR;
@@ -1809,7 +1780,8 @@ handle_xmstate_imm_data(struct iscsi_conn *conn, struct iscsi_cmd_task *ctask)
                         return -EAGAIN;
                 }
                 if (conn->datadgst_en)
-                        iscsi_buf_data_digest_update(conn, &ctask->sendbuf);
+                        crypto_digest_update(conn->data_tx_tfm,
+                                             &ctask->sendbuf.sg, 1);
 
                 if (!ctask->imm_count)
                         break;
@@ -1894,7 +1866,8 @@ handle_xmstate_uns_data(struct iscsi_conn *conn, struct iscsi_cmd_task *ctask)
                  * so pass it
                  */
                 if (conn->datadgst_en && ctask->sent - start > 0)
-                        iscsi_buf_data_digest_update(conn, &ctask->sendbuf);
+                        crypto_digest_update(conn->data_tx_tfm,
+                                             &ctask->sendbuf.sg, 1);
 
                 if (!ctask->data_count)
                         break;
@@ -1972,7 +1945,7 @@ solicit_again:
 
         BUG_ON(r2t->data_count < 0);
         if (conn->datadgst_en)
-                iscsi_buf_data_digest_update(conn, &r2t->sendbuf);
+                crypto_digest_update(conn->data_tx_tfm, &r2t->sendbuf.sg, 1);
 
         if (r2t->data_count) {
                 BUG_ON(ctask->sc->use_sg == 0);
@@ -2054,7 +2027,7 @@ handle_xmstate_w_pad(struct iscsi_conn *conn, struct iscsi_cmd_task *ctask)
         }
 
         if (conn->datadgst_en) {
-                iscsi_buf_data_digest_update(conn, &ctask->sendbuf);
+                crypto_digest_update(conn->data_tx_tfm, &ctask->sendbuf.sg, 1);
                 /* imm data? */
                 if (!dtask) {
                         if (iscsi_digest_final_send(conn, ctask, &ctask->immbuf,
@@ -2148,7 +2121,7 @@ unsolicit_head_again:
 solicit_head_again:
                 r2t = ctask->r2t;
                 if (conn->hdrdgst_en)
-                        iscsi_hdr_digest(conn, &r2t->headbuf, 
+                        iscsi_hdr_digest(conn, &r2t->headbuf,
                                         (u8*)r2t->dtask->hdrext);
                 if (iscsi_sendhdr(conn, &r2t->headbuf, r2t->data_count)) {
                         ctask->xmstate &= ~XMSTATE_SOL_DATA;
@@ -2300,10 +2273,10 @@ iscsi_xmitworker(void *data)
         /*
          * serialize Xmit worker on a per-connection basis.
          */
-        down(&conn->xmitsema);
+        mutex_lock(&conn->xmitmutex);
         if (iscsi_data_xmit(conn))
-                schedule_work(&conn->xmitwork);
-        up(&conn->xmitsema);
+                scsi_queue_work(conn->session->host, &conn->xmitwork);
+        mutex_unlock(&conn->xmitmutex);
 }
 
 #define FAILURE_BAD_HOST                1
@@ -2367,15 +2340,7 @@ iscsi_queuecommand(struct scsi_cmnd *sc, void (*done)(struct scsi_cmnd *))
                 session->cmdsn, session->max_cmdsn - session->exp_cmdsn + 1);
         spin_unlock(&session->lock);
 
-        if (!in_interrupt() && !down_trylock(&conn->xmitsema)) {
-                spin_unlock_irq(host->host_lock);
-                if (iscsi_data_xmit(conn))
-                        schedule_work(&conn->xmitwork);
-                up(&conn->xmitsema);
-                spin_lock_irq(host->host_lock);
-        } else
-                schedule_work(&conn->xmitwork);
-
+        scsi_queue_work(host, &conn->xmitwork);
         return 0;
 
 reject:
@@ -2462,17 +2427,20 @@ iscsi_pool_free(struct iscsi_queue *q, void **items)
         kfree(items);
 }
 
-static iscsi_connh_t
-iscsi_conn_create(iscsi_sessionh_t sessionh, uint32_t conn_idx)
+static struct iscsi_cls_conn *
+iscsi_conn_create(struct Scsi_Host *shost, uint32_t conn_idx)
 {
-        struct iscsi_session *session = iscsi_ptr(sessionh);
-        struct iscsi_conn *conn = NULL;
+        struct iscsi_session *session = iscsi_hostdata(shost->hostdata);
+        struct iscsi_conn *conn;
+        struct iscsi_cls_conn *cls_conn;
 
-        conn = kmalloc(sizeof(struct iscsi_conn), GFP_KERNEL);
-        if (conn == NULL)
-                goto conn_alloc_fail;
-        memset(conn, 0, sizeof(struct iscsi_conn));
+        cls_conn = iscsi_create_conn(hostdata_session(shost->hostdata),
+                                     conn_idx);
+        if (!cls_conn)
+                return NULL;
+        conn = cls_conn->dd_data;
 
+        memset(conn, 0, sizeof(struct iscsi_conn));
         conn->c_stage = ISCSI_CONN_INITIAL_STAGE;
         conn->in_progress = IN_PROGRESS_WAIT_HEADER;
         conn->id = conn_idx;
@@ -2531,10 +2499,10 @@ iscsi_conn_create(iscsi_sessionh_t sessionh, uint32_t conn_idx)
                 goto max_recv_dlenght_alloc_fail;
 
         init_timer(&conn->tmabort_timer);
-        init_MUTEX(&conn->xmitsema);
+        mutex_init(&conn->xmitmutex);
         init_waitqueue_head(&conn->ehwait);
 
-        return iscsi_handle(conn);
+        return cls_conn;
 
 max_recv_dlenght_alloc_fail:
         spin_lock_bh(&session->lock);
@@ -2550,18 +2518,18 @@ immqueue_alloc_fail:
 writequeue_alloc_fail:
         kfifo_free(conn->xmitqueue);
 xmitqueue_alloc_fail:
-        kfree(conn);
-conn_alloc_fail:
-        return iscsi_handle(NULL);
+        iscsi_destroy_conn(cls_conn);
+        return NULL;
 }
 
 static void
-iscsi_conn_destroy(iscsi_connh_t connh)
+iscsi_conn_destroy(struct iscsi_cls_conn *cls_conn)
 {
-        struct iscsi_conn *conn = iscsi_ptr(connh);
+        struct iscsi_conn *conn = cls_conn->dd_data;
         struct iscsi_session *session = conn->session;
+        unsigned long flags;
 
-        down(&conn->xmitsema);
+        mutex_lock(&conn->xmitmutex);
         set_bit(SUSPEND_BIT, &conn->suspend_tx);
         if (conn->c_stage == ISCSI_CONN_INITIAL_STAGE && conn->sock) {
                 struct sock *sk = conn->sock->sk;
@@ -2592,19 +2560,19 @@ iscsi_conn_destroy(iscsi_connh_t connh)
         }
         spin_unlock_bh(&session->lock);
 
-        up(&conn->xmitsema);
+        mutex_unlock(&conn->xmitmutex);
 
         /*
          * Block until all in-progress commands for this connection
          * time out or fail.
          */
         for (;;) {
-                spin_lock_bh(&conn->lock);
+                spin_lock_irqsave(session->host->host_lock, flags);
                 if (!session->host->host_busy) { /* OK for ERL == 0 */
-                        spin_unlock_bh(&conn->lock);
+                        spin_unlock_irqrestore(session->host->host_lock, flags);
                         break;
                 }
-                spin_unlock_bh(&conn->lock);
+                spin_unlock_irqrestore(session->host->host_lock, flags);
                 msleep_interruptible(500);
                 printk("conn_destroy(): host_busy %d host_failed %d\n",
                         session->host->host_busy, session->host->host_failed);
@@ -2652,7 +2620,8 @@ iscsi_conn_destroy(iscsi_connh_t connh)
         kfifo_free(conn->writequeue);
         kfifo_free(conn->immqueue);
         kfifo_free(conn->mgmtqueue);
-        kfree(conn);
+
+        iscsi_destroy_conn(cls_conn);
 }
 
 static int
@@ -2713,6 +2682,8 @@ iscsi_conn_bind(iscsi_sessionh_t sessionh, iscsi_connh_t connh,
                  */
                 iscsi_conn_set_callbacks(conn);
 
+                conn->sendpage = conn->sock->ops->sendpage;
+
                 /*
                  * set receive state machine into initial state
                  */
@@ -2796,7 +2767,7 @@ iscsi_conn_stop(iscsi_connh_t connh, int flag)
         set_bit(SUSPEND_BIT, &conn->suspend_rx);
         write_unlock_bh(&sk->sk_callback_lock);
 
-        down(&conn->xmitsema);
+        mutex_lock(&conn->xmitmutex);
 
         spin_lock_irqsave(session->host->host_lock, flags);
         spin_lock(&session->lock);
@@ -2878,7 +2849,7 @@ iscsi_conn_stop(iscsi_connh_t connh, int flag)
                         conn->datadgst_en = 0;
                 }
         }
-        up(&conn->xmitsema);
+        mutex_unlock(&conn->xmitmutex);
 }
 
 static int
@@ -2963,8 +2934,7 @@ iscsi_conn_send_generic(struct iscsi_conn *conn, struct iscsi_hdr *hdr,
         else
                 __kfifo_put(conn->mgmtqueue, (void*)&mtask, sizeof(void*));
 
-        schedule_work(&conn->xmitwork);
-
+        scsi_queue_work(session->host, &conn->xmitwork);
         return 0;
 }
 
@@ -3029,12 +2999,12 @@ iscsi_eh_abort(struct scsi_cmnd *sc)
          * 1) connection-level failure;
          * 2) recovery due protocol error;
          */
-        down(&conn->xmitsema);
+        mutex_lock(&conn->xmitmutex);
         spin_lock_bh(&session->lock);
         if (session->state != ISCSI_STATE_LOGGED_IN) {
                 if (session->state == ISCSI_STATE_TERMINATE) {
                         spin_unlock_bh(&session->lock);
-                        up(&conn->xmitsema);
+                        mutex_unlock(&conn->xmitmutex);
                         goto failed;
                 }
                 spin_unlock_bh(&session->lock);
@@ -3052,7 +3022,7 @@ iscsi_eh_abort(struct scsi_cmnd *sc)
                          * 2) session was re-open during time out of ctask.
                          */
                         spin_unlock_bh(&session->lock);
-                        up(&conn->xmitsema);
+                        mutex_unlock(&conn->xmitmutex);
                         goto success;
                 }
                 conn->tmabort_state = TMABORT_INITIAL;
@@ -3107,7 +3077,7 @@ iscsi_eh_abort(struct scsi_cmnd *sc)
                                     conn->tmabort_state == TMABORT_SUCCESS) {
                                         conn->tmabort_state = TMABORT_INITIAL;
                                         spin_unlock_bh(&session->lock);
-                                        up(&conn->xmitsema);
+                                        mutex_unlock(&conn->xmitmutex);
                                         goto success;
                                 }
                                 conn->tmabort_state = TMABORT_INITIAL;
@@ -3116,7 +3086,7 @@ iscsi_eh_abort(struct scsi_cmnd *sc)
                         spin_unlock_bh(&session->lock);
                 }
         }
-        up(&conn->xmitsema);
+        mutex_unlock(&conn->xmitmutex);
 
 
         /*
@@ -3182,7 +3152,7 @@ failed:
 exit:
         del_timer_sync(&conn->tmabort_timer);
 
-        down(&conn->xmitsema);
+        mutex_lock(&conn->xmitmutex);
         if (conn->sock) {
                 struct sock *sk = conn->sock->sk;
 
@@ -3190,7 +3160,7 @@ exit:
                 iscsi_ctask_cleanup(conn, ctask);
                 write_unlock_bh(&sk->sk_callback_lock);
         }
-        up(&conn->xmitsema);
+        mutex_unlock(&conn->xmitmutex);
         return rc;
 }
 
@@ -3281,17 +3251,23 @@ static struct scsi_host_template iscsi_sht = {
         .this_id                = -1,
 };
 
-static iscsi_sessionh_t
-iscsi_session_create(uint32_t initial_cmdsn, struct Scsi_Host *host)
+static struct iscsi_transport iscsi_tcp_transport;
+
+static struct Scsi_Host *
+iscsi_session_create(struct scsi_transport_template *scsit,
+                     uint32_t initial_cmdsn)
 {
-        int cmd_i;
+        struct Scsi_Host *shost;
         struct iscsi_session *session;
+        int cmd_i;
 
-        session = iscsi_hostdata(host->hostdata);
-        memset(session, 0, sizeof(struct iscsi_session));
+        shost = iscsi_transport_create_session(scsit, &iscsi_tcp_transport);
+        if (!shost)
+                return NULL; 
 
-        session->host = host;
-        session->id = host->host_no;
+        session = iscsi_hostdata(shost->hostdata);
+        memset(session, 0, sizeof(struct iscsi_session));
+        session->host = shost;
         session->state = ISCSI_STATE_LOGGED_IN;
         session->mgmtpool_max = ISCSI_MGMT_CMDS_MAX;
         session->cmds_max = ISCSI_XMIT_CMDS_MAX;
@@ -3335,7 +3311,7 @@ iscsi_session_create(uint32_t initial_cmdsn, struct Scsi_Host *host)
         if (iscsi_r2tpool_alloc(session))
                 goto r2tpool_alloc_fail;
 
-        return iscsi_handle(session);
+        return shost;
 
 r2tpool_alloc_fail:
         for (cmd_i = 0; cmd_i < session->mgmtpool_max; cmd_i++)
@@ -3345,15 +3321,15 @@ immdata_alloc_fail:
 mgmtpool_alloc_fail:
         iscsi_pool_free(&session->cmdpool, (void**)session->cmds);
 cmdpool_alloc_fail:
-        return iscsi_handle(NULL);
+        return NULL;
 }
 
 static void
-iscsi_session_destroy(iscsi_sessionh_t sessionh)
+iscsi_session_destroy(struct Scsi_Host *shost)
 {
+        struct iscsi_session *session = iscsi_hostdata(shost->hostdata);
         int cmd_i;
         struct iscsi_data_task *dtask, *n;
-        struct iscsi_session *session = iscsi_ptr(sessionh);
 
         for (cmd_i = 0; cmd_i < session->cmds_max; cmd_i++) {
                 struct iscsi_cmd_task *ctask = session->cmds[cmd_i];
@@ -3369,6 +3345,8 @@ iscsi_session_destroy(iscsi_sessionh_t sessionh)
         iscsi_r2tpool_free(session);
         iscsi_pool_free(&session->mgmtpool, (void**)session->mgmt_cmds);
         iscsi_pool_free(&session->cmdpool, (void**)session->cmds);
+
+        iscsi_transport_destroy_session(shost);
 }
 
 static int
@@ -3467,6 +3445,8 @@ iscsi_conn_set_param(iscsi_connh_t connh, enum iscsi_param param,
                         if (conn->data_rx_tfm)
                                 crypto_free_tfm(conn->data_rx_tfm);
                 }
+                conn->sendpage = conn->datadgst_en ?
+                        sock_no_sendpage : conn->sock->ops->sendpage;
                 break;
         case ISCSI_PARAM_INITIAL_R2T_EN:
                 session->initial_r2t_en = value;
@@ -3515,25 +3495,12 @@ iscsi_conn_set_param(iscsi_connh_t connh, enum iscsi_param param,
 }
 
 static int
-iscsi_conn_get_param(iscsi_connh_t connh, enum iscsi_param param,
-                     uint32_t *value)
+iscsi_session_get_param(struct Scsi_Host *shost,
+                        enum iscsi_param param, uint32_t *value)
 {
-        struct iscsi_conn *conn = iscsi_ptr(connh);
-        struct iscsi_session *session = conn->session;
+        struct iscsi_session *session = iscsi_hostdata(shost->hostdata);
 
         switch(param) {
-        case ISCSI_PARAM_MAX_RECV_DLENGTH:
-                *value = conn->max_recv_dlength;
-                break;
-        case ISCSI_PARAM_MAX_XMIT_DLENGTH:
-                *value = conn->max_xmit_dlength;
-                break;
-        case ISCSI_PARAM_HDRDGST_EN:
-                *value = conn->hdrdgst_en;
-                break;
-        case ISCSI_PARAM_DATADGST_EN:
-                *value = conn->datadgst_en;
-                break;
         case ISCSI_PARAM_INITIAL_R2T_EN:
                 *value = session->initial_r2t_en;
                 break;
@@ -3571,6 +3538,31 @@ iscsi_conn_get_param(iscsi_connh_t connh, enum iscsi_param param,
         return 0;
 }
 
+static int
+iscsi_conn_get_param(void *data, enum iscsi_param param, uint32_t *value)
+{
+        struct iscsi_conn *conn = data;
+
+        switch(param) {
+        case ISCSI_PARAM_MAX_RECV_DLENGTH:
+                *value = conn->max_recv_dlength;
+                break;
+        case ISCSI_PARAM_MAX_XMIT_DLENGTH:
+                *value = conn->max_xmit_dlength;
+                break;
+        case ISCSI_PARAM_HDRDGST_EN:
+                *value = conn->hdrdgst_en;
+                break;
+        case ISCSI_PARAM_DATADGST_EN:
+                *value = conn->datadgst_en;
+                break;
+        default:
+                return ISCSI_ERR_PARAM_NOT_FOUND;
+        }
+
+        return 0;
+}
+
 static void
 iscsi_conn_get_stats(iscsi_connh_t connh, struct iscsi_stats *stats)
 {
@@ -3601,9 +3593,9 @@ iscsi_conn_send_pdu(iscsi_connh_t connh, struct iscsi_hdr *hdr, char *data,
         struct iscsi_conn *conn = iscsi_ptr(connh);
         int rc;
 
-        down(&conn->xmitsema);
+        mutex_lock(&conn->xmitmutex);
         rc = iscsi_conn_send_generic(conn, hdr, data, data_size);
-        up(&conn->xmitsema);
+        mutex_unlock(&conn->xmitmutex);
 
         return rc;
 }
@@ -3615,6 +3607,7 @@ static struct iscsi_transport iscsi_tcp_transport = {
                                   | CAP_DATADGST,
         .host_template          = &iscsi_sht,
         .hostdata_size          = sizeof(struct iscsi_session),
+        .conndata_size          = sizeof(struct iscsi_conn),
         .max_conn               = 1,
         .max_cmd_len            = ISCSI_TCP_MAX_CMD_LEN,
         .create_session         = iscsi_session_create,
@@ -3623,7 +3616,8 @@ static struct iscsi_transport iscsi_tcp_transport = {
         .bind_conn              = iscsi_conn_bind,
         .destroy_conn           = iscsi_conn_destroy,
         .set_param              = iscsi_conn_set_param,
-        .get_param              = iscsi_conn_get_param,
+        .get_conn_param         = iscsi_conn_get_param,
+        .get_session_param      = iscsi_session_get_param,
         .start_conn             = iscsi_conn_start,
         .stop_conn              = iscsi_conn_stop,
         .send_pdu               = iscsi_conn_send_pdu,
@@ -3633,8 +3627,6 @@ static struct iscsi_transport iscsi_tcp_transport = {
 static int __init
 iscsi_tcp_init(void)
 {
-        int error;
-
         if (iscsi_max_lun < 1) {
                 printk(KERN_ERR "Invalid max_lun value of %u\n", iscsi_max_lun);
                 return -EINVAL;
@@ -3647,11 +3639,10 @@ iscsi_tcp_init(void)
         if (!taskcache)
                 return -ENOMEM;
 
-        error = iscsi_register_transport(&iscsi_tcp_transport);
-        if (error)
+        if (!iscsi_register_transport(&iscsi_tcp_transport))
                 kmem_cache_destroy(taskcache);
 
-        return error;
+        return 0;
 }
 
 static void __exit
diff --git a/drivers/scsi/iscsi_tcp.h b/drivers/scsi/iscsi_tcp.h
index 855f2dfd18af..f95e61b76f70 100644
--- a/drivers/scsi/iscsi_tcp.h
+++ b/drivers/scsi/iscsi_tcp.h
@@ -158,7 +158,7 @@ struct iscsi_conn {
         struct kfifo            *mgmtqueue;     /* mgmt (control) xmit queue */
         struct kfifo            *xmitqueue;     /* data-path cmd queue */
         struct work_struct      xmitwork;       /* per-conn. xmit workqueue */
-        struct semaphore        xmitsema;       /* serializes connection xmit,
+        struct mutex            xmitmutex;      /* serializes connection xmit,
                                                  * access to kfifos:      *
                                                  * xmitqueue, writequeue, *
                                                  * immqueue, mgmtqueue    */
@@ -191,6 +191,8 @@ struct iscsi_conn {
         uint32_t                sendpage_failures_cnt;
         uint32_t                discontiguous_hdr_cnt;
         uint32_t                eh_abort_cnt;
+
+        ssize_t (*sendpage)(struct socket *, struct page *, int, size_t, int);
 };
 
 struct iscsi_session {
@@ -240,8 +242,8 @@ struct iscsi_session {
 
 struct iscsi_buf {
         struct scatterlist      sg;
-        struct kvec             iov;
         unsigned int            sent;
+        char                    use_sendmsg;
 };
 
 struct iscsi_data_task {
diff --git a/drivers/scsi/libata-core.c b/drivers/scsi/libata-core.c
index f55b9b3f7b37..99bae8369ab2 100644
--- a/drivers/scsi/libata-core.c
+++ b/drivers/scsi/libata-core.c
@@ -1747,7 +1747,7 @@ static const struct {
         { ATA_SHIFT_PIO,        XFER_PIO_0 },
 };
 
-static inline u8 base_from_shift(unsigned int shift)
+static u8 base_from_shift(unsigned int shift)
 {
         int i;
 
diff --git a/drivers/scsi/lpfc/lpfc_scsi.c b/drivers/scsi/lpfc/lpfc_scsi.c
index 9ee8218404c0..dafabeefc5b3 100644
--- a/drivers/scsi/lpfc/lpfc_scsi.c
+++ b/drivers/scsi/lpfc/lpfc_scsi.c
@@ -150,7 +150,7 @@ lpfc_new_scsi_buf(struct lpfc_hba * phba)
         return psb;
 }
 
-struct  lpfc_scsi_buf*
+static struct lpfc_scsi_buf*
 lpfc_get_scsi_buf(struct lpfc_hba * phba)
 {
         struct  lpfc_scsi_buf * lpfc_cmd = NULL;
diff --git a/drivers/scsi/megaraid.c b/drivers/scsi/megaraid.c
index 4a6feb1e5e3d..d101a8a6f4e8 100644
--- a/drivers/scsi/megaraid.c
+++ b/drivers/scsi/megaraid.c
@@ -4479,7 +4479,7 @@ mega_internal_command(adapter_t *adapter, megacmd_t *mc, mega_passthru *pthru)
          * serialized. This is so because we want to reserve maximum number of
          * available command ids for the I/O commands.
          */
-        down(&adapter->int_mtx);
+        mutex_lock(&adapter->int_mtx);
 
         scb = &adapter->int_scb;
         memset(scb, 0, sizeof(scb_t));
@@ -4527,7 +4527,7 @@ mega_internal_command(adapter_t *adapter, megacmd_t *mc, mega_passthru *pthru)
                         mc->cmd, mc->opcode, mc->subopcode, scmd->result);
         }
 
-        up(&adapter->int_mtx);
+        mutex_unlock(&adapter->int_mtx);
 
         return rval;
 }
@@ -4866,7 +4866,7 @@ megaraid_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
                 adapter->has_64bit_addr = 0;
         }
                 
-        init_MUTEX(&adapter->int_mtx);
+        mutex_init(&adapter->int_mtx);
         init_completion(&adapter->int_waitq);
 
         adapter->this_id = DEFAULT_INITIATOR_ID;
diff --git a/drivers/scsi/megaraid.h b/drivers/scsi/megaraid.h
index 6f9078025748..4b3e0d6e5afa 100644
--- a/drivers/scsi/megaraid.h
+++ b/drivers/scsi/megaraid.h
@@ -2,7 +2,7 @@
 #define __MEGARAID_H__
 
 #include <linux/spinlock.h>
-
+#include <linux/mutex.h>
 
 #define MEGARAID_VERSION        \
         "v2.00.3 (Release Date: Wed Feb 19 08:51:30 EST 2003)\n"
@@ -889,7 +889,7 @@ typedef struct {
 
         scb_t                   int_scb;
         Scsi_Cmnd               int_scmd;
-        struct semaphore        int_mtx;        /* To synchronize the internal
+        struct mutex            int_mtx;        /* To synchronize the internal
                                                 commands */
         struct completion       int_waitq;      /* wait queue for internal
                                                  cmds */
diff --git a/drivers/scsi/megaraid/megaraid_mbox.c b/drivers/scsi/megaraid/megaraid_mbox.c
index d18a4bc2498c..bf9f7f7ba354 100644
--- a/drivers/scsi/megaraid/megaraid_mbox.c
+++ b/drivers/scsi/megaraid/megaraid_mbox.c
@@ -1266,7 +1266,7 @@ megaraid_mbox_teardown_dma_pools(adapter_t *adapter)
  * return the scb from the head of the free list. NULL if there are none
  * available
  **/
-static inline scb_t *
+static scb_t *
 megaraid_alloc_scb(adapter_t *adapter, struct scsi_cmnd *scp)
 {
         struct list_head        *head = &adapter->kscb_pool;
@@ -1329,7 +1329,7 @@ megaraid_dealloc_scb(adapter_t *adapter, scb_t *scb)
  *
  * prepare the scatter-gather list
  */
-static inline int
+static int
 megaraid_mbox_mksgl(adapter_t *adapter, scb_t *scb)
 {
         struct scatterlist      *sgl;
@@ -1402,7 +1402,7 @@ megaraid_mbox_mksgl(adapter_t *adapter, scb_t *scb)
  *
  * post the command to the controller if mailbox is availble.
  */
-static inline int
+static int
 mbox_post_cmd(adapter_t *adapter, scb_t *scb)
 {
         mraid_device_t  *raid_dev = ADAP2RAIDDEV(adapter);
@@ -2070,7 +2070,7 @@ megaraid_mbox_prepare_epthru(adapter_t *adapter, scb_t *scb,
  *
  * Returns:     1 if the interrupt is valid, 0 otherwise
  */
-static inline int
+static int
 megaraid_ack_sequence(adapter_t *adapter)
 {
         mraid_device_t          *raid_dev = ADAP2RAIDDEV(adapter);
@@ -2208,7 +2208,7 @@ megaraid_isr(int irq, void *devp, struct pt_regs *regs)
  *
  * DMA sync if required.
  */
-static inline void
+static void
 megaraid_mbox_sync_scb(adapter_t *adapter, scb_t *scb)
 {
         mbox_ccb_t      *ccb;
diff --git a/drivers/scsi/megaraid/megaraid_sas.c b/drivers/scsi/megaraid/megaraid_sas.c
index 3c32e69afcd9..511ed52a5807 100644
--- a/drivers/scsi/megaraid/megaraid_sas.c
+++ b/drivers/scsi/megaraid/megaraid_sas.c
@@ -35,6 +35,7 @@
 #include <asm/uaccess.h>
 #include <linux/fs.h>
 #include <linux/compat.h>
+#include <linux/mutex.h>
 
 #include <scsi/scsi.h>
 #include <scsi/scsi_cmnd.h>
@@ -72,7 +73,7 @@ MODULE_DEVICE_TABLE(pci, megasas_pci_table);
 static int megasas_mgmt_majorno;
 static struct megasas_mgmt_info megasas_mgmt_info;
 static struct fasync_struct *megasas_async_queue;
-static DECLARE_MUTEX(megasas_async_queue_mutex);
+static DEFINE_MUTEX(megasas_async_queue_mutex);
 
 /**
  * megasas_get_cmd -    Get a command from the free pool
@@ -80,7 +81,7 @@ static DECLARE_MUTEX(megasas_async_queue_mutex);
  *
  * Returns a free command from the pool
  */
-static inline struct megasas_cmd *megasas_get_cmd(struct megasas_instance
+static struct megasas_cmd *megasas_get_cmd(struct megasas_instance
                                                   *instance)
 {
         unsigned long flags;
@@ -262,7 +263,7 @@ megasas_issue_blocked_abort_cmd(struct megasas_instance *instance,
  * If successful, this function returns the number of SG elements. Otherwise,
  * it returnes -1.
  */
-static inline int
+static int
 megasas_make_sgl32(struct megasas_instance *instance, struct scsi_cmnd *scp,
                    union megasas_sgl *mfi_sgl)
 {
@@ -310,7 +311,7 @@ megasas_make_sgl32(struct megasas_instance *instance, struct scsi_cmnd *scp,
  * If successful, this function returns the number of SG elements. Otherwise,
  * it returnes -1.
  */
-static inline int
+static int
 megasas_make_sgl64(struct megasas_instance *instance, struct scsi_cmnd *scp,
                    union megasas_sgl *mfi_sgl)
 {
@@ -359,7 +360,7 @@ megasas_make_sgl64(struct megasas_instance *instance, struct scsi_cmnd *scp,
  * This function prepares CDB commands. These are typcially pass-through
  * commands to the devices.
  */
-static inline int
+static int
 megasas_build_dcdb(struct megasas_instance *instance, struct scsi_cmnd *scp,
                    struct megasas_cmd *cmd)
 {
@@ -440,7 +441,7 @@ megasas_build_dcdb(struct megasas_instance *instance, struct scsi_cmnd *scp,
  *
  * Frames (and accompanying SGLs) for regular SCSI IOs use this function.
  */
-static inline int
+static int
 megasas_build_ldio(struct megasas_instance *instance, struct scsi_cmnd *scp,
                    struct megasas_cmd *cmd)
 {
@@ -562,7 +563,7 @@ megasas_build_ldio(struct megasas_instance *instance, struct scsi_cmnd *scp,
  * @scp:                SCSI command
  * @frame_count:        [OUT] Number of frames used to prepare this command
  */
-static inline struct megasas_cmd *megasas_build_cmd(struct megasas_instance
+static struct megasas_cmd *megasas_build_cmd(struct megasas_instance
                                                     *instance,
                                                     struct scsi_cmnd *scp,
                                                     int *frame_count)
@@ -913,7 +914,7 @@ megasas_complete_abort(struct megasas_instance *instance,
  * @instance:                   Adapter soft state
  * @cmd:                        Completed command
  */
-static inline void
+static void
 megasas_unmap_sgbuf(struct megasas_instance *instance, struct megasas_cmd *cmd)
 {
         dma_addr_t buf_h;
@@ -957,7 +958,7 @@ megasas_unmap_sgbuf(struct megasas_instance *instance, struct megasas_cmd *cmd)
  *                              an alternate status (as in the case of aborted
  *                              commands)
  */
-static inline void
+static void
 megasas_complete_cmd(struct megasas_instance *instance, struct megasas_cmd *cmd,
                      u8 alt_status)
 {
@@ -1104,7 +1105,7 @@ megasas_complete_cmd(struct megasas_instance *instance, struct megasas_cmd *cmd,
  *                                      SCSI mid-layer instead of the status
  *                                      returned by the FW
  */
-static inline int
+static int
 megasas_deplete_reply_queue(struct megasas_instance *instance, u8 alt_status)
 {
         u32 status;
@@ -2362,11 +2363,11 @@ static int megasas_mgmt_fasync(int fd, struct file *filep, int mode)
 {
         int rc;
 
-        down(&megasas_async_queue_mutex);
+        mutex_lock(&megasas_async_queue_mutex);
 
         rc = fasync_helper(fd, filep, mode, &megasas_async_queue);
 
-        up(&megasas_async_queue_mutex);
+        mutex_unlock(&megasas_async_queue_mutex);
 
         if (rc >= 0) {
                 /* For sanity check when we get ioctl */
diff --git a/drivers/scsi/qla2xxx/Kconfig b/drivers/scsi/qla2xxx/Kconfig
index 5205c4e7d6ff..5758b2566d7f 100644
--- a/drivers/scsi/qla2xxx/Kconfig
+++ b/drivers/scsi/qla2xxx/Kconfig
@@ -1,4 +1,4 @@
-config SCSI_QLA2XXX
+config SCSI_QLA_FC
         tristate "QLogic QLA2XXX Fibre Channel Support"
         depends on PCI && SCSI
         select SCSI_FC_ATTRS
@@ -22,49 +22,57 @@ config SCSI_QLA2XXX
         Upon request, the driver caches the firmware image until
         the driver is unloaded.
 
+        Firmware images can be retrieved from:
+
+                ftp://ftp.qlogic.com/outgoing/linux/firmware/
+
         NOTE: The original method of building firmware-loader
         modules has been deprecated as the firmware-images will
         be removed from the kernel sources.
 
 config SCSI_QLA2XXX_EMBEDDED_FIRMWARE
         bool "  Use firmware-loader modules (DEPRECATED)"
-        depends on SCSI_QLA2XXX
+        depends on SCSI_QLA_FC
+        help
+          This option offers you the deprecated firmware-loader
+          modules that have been obsoleted by the usage of the
+          Firmware Loader interface in the qla2xxx driver.
 
 config SCSI_QLA21XX
         tristate "  Build QLogic ISP2100 firmware-module"
-        depends on SCSI_QLA2XXX_EMBEDDED_FIRMWARE
+        depends on SCSI_QLA_FC && SCSI_QLA2XXX_EMBEDDED_FIRMWARE
         ---help---
         This driver supports the QLogic 21xx (ISP2100) host adapter family.
 
 config SCSI_QLA22XX
         tristate "  Build QLogic ISP2200 firmware-module"
-        depends on SCSI_QLA2XXX_EMBEDDED_FIRMWARE
+        depends on SCSI_QLA_FC && SCSI_QLA2XXX_EMBEDDED_FIRMWARE
         ---help---
         This driver supports the QLogic 22xx (ISP2200) host adapter family.
 
 config SCSI_QLA2300
         tristate "  Build QLogic ISP2300 firmware-module"
-        depends on SCSI_QLA2XXX_EMBEDDED_FIRMWARE
+        depends on SCSI_QLA_FC && SCSI_QLA2XXX_EMBEDDED_FIRMWARE
         ---help---
         This driver supports the QLogic 2300 (ISP2300 and ISP2312) host
         adapter family.
 
 config SCSI_QLA2322
         tristate "  Build QLogic ISP2322 firmware-module"
-        depends on SCSI_QLA2XXX_EMBEDDED_FIRMWARE
+        depends on SCSI_QLA_FC && SCSI_QLA2XXX_EMBEDDED_FIRMWARE
         ---help---
         This driver supports the QLogic 2322 (ISP2322) host adapter family.
 
 config SCSI_QLA6312
         tristate "  Build QLogic ISP63xx firmware-module"
-        depends on SCSI_QLA2XXX_EMBEDDED_FIRMWARE
+        depends on SCSI_QLA_FC && SCSI_QLA2XXX_EMBEDDED_FIRMWARE
         ---help---
         This driver supports the QLogic 63xx (ISP6312 and ISP6322) host
         adapter family.
 
 config SCSI_QLA24XX
         tristate "  Build QLogic ISP24xx firmware-module"
-        depends on SCSI_QLA2XXX_EMBEDDED_FIRMWARE
+        depends on SCSI_QLA_FC && SCSI_QLA2XXX_EMBEDDED_FIRMWARE
         ---help---
         This driver supports the QLogic 24xx (ISP2422 and ISP2432) host
         adapter family.
diff --git a/drivers/scsi/qla2xxx/Makefile b/drivers/scsi/qla2xxx/Makefile
index 40c0de125889..d028bc50ccf7 100644
--- a/drivers/scsi/qla2xxx/Makefile
+++ b/drivers/scsi/qla2xxx/Makefile
@@ -3,7 +3,7 @@ EXTRA_CFLAGS += -DUNIQUE_FW_NAME
 qla2xxx-y := qla_os.o qla_init.o qla_mbx.o qla_iocb.o qla_isr.o qla_gs.o \
                 qla_dbg.o qla_sup.o qla_rscn.o qla_attr.o
 
-obj-$(CONFIG_SCSI_QLA2XXX) += qla2xxx.o
+obj-$(CONFIG_SCSI_QLA_FC) += qla2xxx.o
 
 qla2100-y := ql2100.o ql2100_fw.o
 qla2200-y := ql2200.o ql2200_fw.o
diff --git a/drivers/scsi/qla2xxx/qla_attr.c b/drivers/scsi/qla2xxx/qla_attr.c
index 2efca52dff50..b17ee62dd1a9 100644
--- a/drivers/scsi/qla2xxx/qla_attr.c
+++ b/drivers/scsi/qla2xxx/qla_attr.c
@@ -541,7 +541,7 @@ struct fc_function_template qla2xxx_transport_functions = {
 void
 qla2x00_init_host_attr(scsi_qla_host_t *ha)
 {
-        fc_host_node_name(ha->host) = wwn_to_u64(ha->init_cb->node_name);
-        fc_host_port_name(ha->host) = wwn_to_u64(ha->init_cb->port_name);
+        fc_host_node_name(ha->host) = wwn_to_u64(ha->node_name);
+        fc_host_port_name(ha->host) = wwn_to_u64(ha->port_name);
         fc_host_supported_classes(ha->host) = FC_COS_CLASS3;
 }
diff --git a/drivers/scsi/qla2xxx/qla_dbg.c b/drivers/scsi/qla2xxx/qla_dbg.c
index 5c5d2315cfab..2d9b12ffe09c 100644
--- a/drivers/scsi/qla2xxx/qla_dbg.c
+++ b/drivers/scsi/qla2xxx/qla_dbg.c
@@ -1003,10 +1003,10 @@ qla24xx_fw_dump(scsi_qla_host_t *ha, int hardware_locked)
         fw = (struct qla24xx_fw_dump *) ha->fw_dump24;
 
         rval = QLA_SUCCESS;
-        fw->hccr = RD_REG_DWORD(&reg->hccr);
+        fw->host_status = RD_REG_DWORD(&reg->host_status);
 
         /* Pause RISC. */
-        if ((fw->hccr & HCCRX_RISC_PAUSE) == 0) {
+        if ((RD_REG_DWORD(&reg->hccr) & HCCRX_RISC_PAUSE) == 0) {
                 WRT_REG_DWORD(&reg->hccr, HCCRX_SET_RISC_RESET |
                     HCCRX_CLR_HOST_INT);
                 RD_REG_DWORD(&reg->hccr);               /* PCI Posting. */
@@ -1021,16 +1021,54 @@ qla24xx_fw_dump(scsi_qla_host_t *ha, int hardware_locked)
                 }
         }
 
-        /* Disable interrupts. */
-        WRT_REG_DWORD(&reg->ictrl, 0);
-        RD_REG_DWORD(&reg->ictrl);
-
         if (rval == QLA_SUCCESS) {
                 /* Host interface registers. */
                 dmp_reg = (uint32_t __iomem *)(reg + 0);
                 for (cnt = 0; cnt < sizeof(fw->host_reg) / 4; cnt++)
                         fw->host_reg[cnt] = RD_REG_DWORD(dmp_reg++);
 
+                /* Disable interrupts. */
+                WRT_REG_DWORD(&reg->ictrl, 0);
+                RD_REG_DWORD(&reg->ictrl);
+
+                /* Shadow registers. */
+                WRT_REG_DWORD(&reg->iobase_addr, 0x0F70);
+                RD_REG_DWORD(&reg->iobase_addr);
+                dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xF0);
+                WRT_REG_DWORD(dmp_reg, 0xB0000000);
+                dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xFC);
+                fw->shadow_reg[0] = RD_REG_DWORD(dmp_reg);
+
+                dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xF0);
+                WRT_REG_DWORD(dmp_reg, 0xB0100000);
+                dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xFC);
+                fw->shadow_reg[1] = RD_REG_DWORD(dmp_reg);
+
+                dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xF0);
+                WRT_REG_DWORD(dmp_reg, 0xB0200000);
+                dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xFC);
+                fw->shadow_reg[2] = RD_REG_DWORD(dmp_reg);
+
+                dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xF0);
+                WRT_REG_DWORD(dmp_reg, 0xB0300000);
+                dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xFC);
+                fw->shadow_reg[3] = RD_REG_DWORD(dmp_reg);
+
+                dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xF0);
+                WRT_REG_DWORD(dmp_reg, 0xB0400000);
+                dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xFC);
+                fw->shadow_reg[4] = RD_REG_DWORD(dmp_reg);
+
+                dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xF0);
+                WRT_REG_DWORD(dmp_reg, 0xB0500000);
+                dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xFC);
+                fw->shadow_reg[5] = RD_REG_DWORD(dmp_reg);
+
+                dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xF0);
+                WRT_REG_DWORD(dmp_reg, 0xB0600000);
+                dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xFC);
+                fw->shadow_reg[6] = RD_REG_DWORD(dmp_reg);
+
                 /* Mailbox registers. */
                 mbx_reg = (uint16_t __iomem *)((uint8_t __iomem *)reg + 0x80);
                 for (cnt = 0; cnt < sizeof(fw->mailbox_reg) / 2; cnt++)
@@ -1308,43 +1346,6 @@ qla24xx_fw_dump(scsi_qla_host_t *ha, int hardware_locked)
                 for (cnt = 0; cnt < 16; cnt++)
                         *iter_reg++ = RD_REG_DWORD(dmp_reg++);
 
-                WRT_REG_DWORD(&reg->iobase_addr, 0x0F70);
-                RD_REG_DWORD(&reg->iobase_addr);
-                dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xF0);
-                WRT_REG_DWORD(dmp_reg, 0xB0000000);
-                dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xFC);
-                fw->shadow_reg[0] = RD_REG_DWORD(dmp_reg);
-
-                dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xF0);
-                WRT_REG_DWORD(dmp_reg, 0xB0100000);
-                dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xFC);
-                fw->shadow_reg[1] = RD_REG_DWORD(dmp_reg);
-
-                dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xF0);
-                WRT_REG_DWORD(dmp_reg, 0xB0200000);
-                dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xFC);
-                fw->shadow_reg[2] = RD_REG_DWORD(dmp_reg);
-
-                dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xF0);
-                WRT_REG_DWORD(dmp_reg, 0xB0300000);
-                dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xFC);
-                fw->shadow_reg[3] = RD_REG_DWORD(dmp_reg);
-
-                dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xF0);
-                WRT_REG_DWORD(dmp_reg, 0xB0400000);
-                dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xFC);
-                fw->shadow_reg[4] = RD_REG_DWORD(dmp_reg);
-
-                dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xF0);
-                WRT_REG_DWORD(dmp_reg, 0xB0500000);
-                dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xFC);
-                fw->shadow_reg[5] = RD_REG_DWORD(dmp_reg);
-
-                dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xF0);
-                WRT_REG_DWORD(dmp_reg, 0xB0600000);
-                dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xFC);
-                fw->shadow_reg[6] = RD_REG_DWORD(dmp_reg);
-
                 /* Local memory controller registers. */
                 iter_reg = fw->lmc_reg;
                 WRT_REG_DWORD(&reg->iobase_addr, 0x3000);
@@ -1677,7 +1678,7 @@ qla24xx_ascii_fw_dump(scsi_qla_host_t *ha)
             ha->fw_major_version, ha->fw_minor_version,
             ha->fw_subminor_version, ha->fw_attributes);
 
-        qla_uprintf(&uiter, "\nHCCR Register\n%04x\n", fw->hccr);
+        qla_uprintf(&uiter, "\nR2H Status Register\n%04x\n", fw->host_status);
 
         qla_uprintf(&uiter, "\nHost Interface Registers");
         for (cnt = 0; cnt < sizeof(fw->host_reg) / 4; cnt++) {
@@ -1687,6 +1688,14 @@ qla24xx_ascii_fw_dump(scsi_qla_host_t *ha)
                 qla_uprintf(&uiter, "%08x ", fw->host_reg[cnt]);
         }
 
+        qla_uprintf(&uiter, "\n\nShadow Registers");
+        for (cnt = 0; cnt < sizeof(fw->shadow_reg) / 4; cnt++) {
+                if (cnt % 8 == 0)
+                        qla_uprintf(&uiter, "\n");
+
+                qla_uprintf(&uiter, "%08x ", fw->shadow_reg[cnt]);
+        }
+
         qla_uprintf(&uiter, "\n\nMailbox Registers");
         for (cnt = 0; cnt < sizeof(fw->mailbox_reg) / 2; cnt++) {
                 if (cnt % 8 == 0)
@@ -1855,14 +1864,6 @@ qla24xx_ascii_fw_dump(scsi_qla_host_t *ha)
                 qla_uprintf(&uiter, "%08x ", fw->risc_gp_reg[cnt]);
         }
 
-        qla_uprintf(&uiter, "\n\nShadow Registers");
-        for (cnt = 0; cnt < sizeof(fw->shadow_reg) / 4; cnt++) {
-                if (cnt % 8 == 0)
-                        qla_uprintf(&uiter, "\n");
-
-                qla_uprintf(&uiter, "%08x ", fw->shadow_reg[cnt]);
-        }
-
         qla_uprintf(&uiter, "\n\nLMC Registers");
         for (cnt = 0; cnt < sizeof(fw->lmc_reg) / 4; cnt++) {
                 if (cnt % 8 == 0)
diff --git a/drivers/scsi/qla2xxx/qla_dbg.h b/drivers/scsi/qla2xxx/qla_dbg.h
index 935a59a8c054..ab6afeaa2f2c 100644
--- a/drivers/scsi/qla2xxx/qla_dbg.h
+++ b/drivers/scsi/qla2xxx/qla_dbg.h
@@ -227,8 +227,9 @@ struct qla2100_fw_dump {
 #define FW_DUMP_SIZE_24XX       0x2B0000
 
 struct qla24xx_fw_dump {
-        uint32_t hccr;
+        uint32_t host_status;
         uint32_t host_reg[32];
+        uint32_t shadow_reg[7];
         uint16_t mailbox_reg[32];
         uint32_t xseq_gp_reg[128];
         uint32_t xseq_0_reg[16];
@@ -250,7 +251,6 @@ struct qla24xx_fw_dump {
         uint32_t rcvt0_data_dma_reg[32];
         uint32_t rcvt1_data_dma_reg[32];
         uint32_t risc_gp_reg[128];
-        uint32_t shadow_reg[7];
         uint32_t lmc_reg[112];
         uint32_t fpm_hdw_reg[192];
         uint32_t fb_hdw_reg[176];
diff --git a/drivers/scsi/qla2xxx/qla_gbl.h b/drivers/scsi/qla2xxx/qla_gbl.h
index bec81adcf4fd..32be4c14cccb 100644
--- a/drivers/scsi/qla2xxx/qla_gbl.h
+++ b/drivers/scsi/qla2xxx/qla_gbl.h
@@ -62,6 +62,7 @@ extern int qlport_down_retry;
 extern int ql2xplogiabsentdevice;
 extern int ql2xloginretrycount;
 extern int ql2xfdmienable;
+extern int ql2xprocessrscn;
 
 extern void qla2x00_sp_compl(scsi_qla_host_t *, srb_t *);
 
@@ -96,10 +97,7 @@ int __qla2x00_marker(scsi_qla_host_t *, uint16_t, uint16_t, uint8_t);
  * Global Function Prototypes in qla_mbx.c source file.
  */
 extern int
-qla2x00_load_ram(scsi_qla_host_t *, dma_addr_t, uint16_t, uint16_t);
-
-extern int
-qla2x00_load_ram_ext(scsi_qla_host_t *, dma_addr_t, uint32_t, uint32_t);
+qla2x00_load_ram(scsi_qla_host_t *, dma_addr_t, uint32_t, uint32_t);
 
 extern int
 qla2x00_execute_fw(scsi_qla_host_t *, uint32_t);
diff --git a/drivers/scsi/qla2xxx/qla_gs.c b/drivers/scsi/qla2xxx/qla_gs.c
index cd6f7c3cfe68..d620a8e8a614 100644
--- a/drivers/scsi/qla2xxx/qla_gs.c
+++ b/drivers/scsi/qla2xxx/qla_gs.c
@@ -538,6 +538,7 @@ qla2x00_rff_id(scsi_qla_host_t *ha)
         ct_req->req.rff_id.port_id[1] = ha->d_id.b.area;
         ct_req->req.rff_id.port_id[2] = ha->d_id.b.al_pa;
 
+        ct_req->req.rff_id.fc4_feature = BIT_1;
         ct_req->req.rff_id.fc4_type = 0x08;             /* SCSI - FCP */
 
         /* Execute MS IOCB */
@@ -1529,9 +1530,9 @@ qla2x00_fdmi_rpa(scsi_qla_host_t *ha)
         eiter->type = __constant_cpu_to_be16(FDMI_PORT_SUPPORT_SPEED);
         eiter->len = __constant_cpu_to_be16(4 + 4);
         if (IS_QLA25XX(ha))
-                eiter->a.sup_speed = __constant_cpu_to_be32(4);
-        else if (IS_QLA24XX(ha))
                 eiter->a.sup_speed = __constant_cpu_to_be32(8);
+        else if (IS_QLA24XX(ha))
+                eiter->a.sup_speed = __constant_cpu_to_be32(4);
         else if (IS_QLA23XX(ha))
                 eiter->a.sup_speed = __constant_cpu_to_be32(2);
         else
@@ -1553,9 +1554,6 @@ qla2x00_fdmi_rpa(scsi_qla_host_t *ha)
                 eiter->a.cur_speed = __constant_cpu_to_be32(2);
                 break;
         case 3:
-                eiter->a.cur_speed = __constant_cpu_to_be32(8);
-                break;
-        case 4:
                 eiter->a.cur_speed = __constant_cpu_to_be32(4);
                 break;
         }
diff --git a/drivers/scsi/qla2xxx/qla_init.c b/drivers/scsi/qla2xxx/qla_init.c
index 7d973bd9022b..a91fea69ad63 100644
--- a/drivers/scsi/qla2xxx/qla_init.c
+++ b/drivers/scsi/qla2xxx/qla_init.c
@@ -1014,11 +1014,13 @@ qla24xx_update_fw_options(scsi_qla_host_t *ha)
         int rval;
 
         /* Update Serial Link options. */
-        if ((ha->fw_seriallink_options24[0] & BIT_0) == 0)
+        if ((le16_to_cpu(ha->fw_seriallink_options24[0]) & BIT_0) == 0)
                 return;
 
-        rval = qla2x00_set_serdes_params(ha, ha->fw_seriallink_options24[1],
-            ha->fw_seriallink_options24[2], ha->fw_seriallink_options24[3]);
+        rval = qla2x00_set_serdes_params(ha,
+            le16_to_cpu(ha->fw_seriallink_options24[1]),
+            le16_to_cpu(ha->fw_seriallink_options24[2]),
+            le16_to_cpu(ha->fw_seriallink_options24[3]));
         if (rval != QLA_SUCCESS) {
                 qla_printk(KERN_WARNING, ha,
                     "Unable to update Serial Link options (%x).\n", rval);
@@ -1939,6 +1941,9 @@ qla2x00_configure_local_loop(scsi_qla_host_t *ha)
                             "information -- get_port_database=%x, "
                             "loop_id=0x%04x\n",
                             ha->host_no, rval2, new_fcport->loop_id));
+                        DEBUG2(printk("scsi(%ld): Scheduling resync...\n",
+                            ha->host_no));
+                        set_bit(LOOP_RESYNC_NEEDED, &ha->dpc_flags);
                         continue;
                 }
 
@@ -2648,7 +2653,8 @@ qla2x00_device_resync(scsi_qla_host_t *ha)
 
                 switch (format) {
                 case 0:
-                        if (!IS_QLA2100(ha) && !IS_QLA2200(ha) &&
+                        if (ql2xprocessrscn &&
+                            !IS_QLA2100(ha) && !IS_QLA2200(ha) &&
                             !IS_QLA6312(ha) && !IS_QLA6322(ha) &&
                             !IS_QLA24XX(ha) && !IS_QLA25XX(ha) &&
                             ha->flags.init_done) {
@@ -3402,6 +3408,8 @@ qla24xx_nvram_config(scsi_qla_host_t *ha)
         ha->node_name = icb->node_name;
         ha->port_name = icb->port_name;
 
+        icb->execution_throttle = __constant_cpu_to_le16(0xFFFF);
+
         ha->retry_count = le16_to_cpu(nv->login_retry_count);
 
         /* Set minimum login_timeout to 4 seconds. */
@@ -3667,8 +3675,8 @@ qla24xx_load_risc_flash(scsi_qla_host_t *ha, uint32_t *srisc_addr)
                         for (i = 0; i < dlen; i++)
                                 dcode[i] = swab32(dcode[i]);
 
-                        rval = qla2x00_load_ram_ext(ha, ha->request_dma,
-                            risc_addr, dlen);
+                        rval = qla2x00_load_ram(ha, ha->request_dma, risc_addr,
+                            dlen);
                         if (rval) {
                                 DEBUG(printk("scsi(%ld):[ERROR] Failed to load "
                                     "segment %d of firmware\n", ha->host_no,
@@ -3868,8 +3876,8 @@ qla24xx_load_risc(scsi_qla_host_t *ha, uint32_t *srisc_addr)
                         for (i = 0; i < dlen; i++)
                                 dcode[i] = swab32(fwcode[i]);
 
-                        rval = qla2x00_load_ram_ext(ha, ha->request_dma,
-                            risc_addr, dlen);
+                        rval = qla2x00_load_ram(ha, ha->request_dma, risc_addr,
+                            dlen);
                         if (rval) {
                                 DEBUG(printk("scsi(%ld):[ERROR] Failed to load "
                                     "segment %d of firmware\n", ha->host_no,
diff --git a/drivers/scsi/qla2xxx/qla_isr.c b/drivers/scsi/qla2xxx/qla_isr.c
index 5181d966fecb..f63af081d4ff 100644
--- a/drivers/scsi/qla2xxx/qla_isr.c
+++ b/drivers/scsi/qla2xxx/qla_isr.c
@@ -519,7 +519,8 @@ qla2x00_async_event(scsi_qla_host_t *ha, uint16_t *mb)
                  * us, create a new entry in our rscn fcports list and handle
                  * the event like an RSCN.
                  */
-                if (!IS_QLA2100(ha) && !IS_QLA2200(ha) && !IS_QLA6312(ha) &&
+                if (ql2xprocessrscn &&
+                    !IS_QLA2100(ha) && !IS_QLA2200(ha) && !IS_QLA6312(ha) &&
                     !IS_QLA6322(ha) && !IS_QLA24XX(ha) && !IS_QLA25XX(ha) &&
                     ha->flags.init_done && mb[1] != 0xffff &&
                     ((ha->operating_mode == P2P && mb[1] != 0) ||
@@ -963,15 +964,16 @@ qla2x00_status_entry(scsi_qla_host_t *ha, void *pkt)
                 break;
 
         case CS_DATA_UNDERRUN:
-                DEBUG2(printk(KERN_INFO
-                    "scsi(%ld:%d:%d) UNDERRUN status detected 0x%x-0x%x.\n",
-                    ha->host_no, cp->device->id, cp->device->lun, comp_status,
-                    scsi_status));
-
                 resid = resid_len;
                 if (scsi_status & SS_RESIDUAL_UNDER) {
                         cp->resid = resid;
                         CMD_RESID_LEN(cp) = resid;
+                } else {
+                        DEBUG2(printk(KERN_INFO
+                            "scsi(%ld:%d:%d) UNDERRUN status detected "
+                            "0x%x-0x%x.\n", ha->host_no, cp->device->id,
+                            cp->device->lun, comp_status, scsi_status));
+
                 }
 
                 /*
diff --git a/drivers/scsi/qla2xxx/qla_mbx.c b/drivers/scsi/qla2xxx/qla_mbx.c
index 9746cd1e664b..3099b379de9d 100644
--- a/drivers/scsi/qla2xxx/qla_mbx.c
+++ b/drivers/scsi/qla2xxx/qla_mbx.c
@@ -196,7 +196,9 @@ qla2x00_mailbox_command(scsi_qla_host_t *ha, mbx_cmd_t *mcp)
                         /* Check for pending interrupts. */
                         qla2x00_poll(ha);
 
-                        udelay(10); /* v4.27 */
+                        if (command != MBC_LOAD_RISC_RAM_EXTENDED &&
+                            !ha->flags.mbox_int)
+                                msleep(10);
                 } /* while */
         }
 
@@ -325,113 +327,30 @@ qla2x00_mailbox_command(scsi_qla_host_t *ha, mbx_cmd_t *mcp)
         return rval;
 }
 
-/*
- * qla2x00_load_ram
- *      Load adapter RAM using DMA.
- *
- * Input:
- *      ha = adapter block pointer.
- *
- * Returns:
- *      qla2x00 local function return status code.
- *
- * Context:
- *      Kernel context.
- */
 int
-qla2x00_load_ram(scsi_qla_host_t *ha, dma_addr_t req_dma, uint16_t risc_addr,
-    uint16_t risc_code_size)
+qla2x00_load_ram(scsi_qla_host_t *ha, dma_addr_t req_dma, uint32_t risc_addr,
+    uint32_t risc_code_size)
 {
         int rval;
         mbx_cmd_t mc;
         mbx_cmd_t *mcp = &mc;
-        uint32_t        req_len;
-        dma_addr_t      nml_dma;
-        uint32_t        nml_len;
-        uint32_t        normalized;
-
-        DEBUG11(printk("qla2x00_load_ram(%ld): entered.\n",
-            ha->host_no);)
 
-        req_len = risc_code_size;
-        nml_dma = 0;
-        nml_len = 0;
-
-        normalized = qla2x00_normalize_dma_addr(&req_dma, &req_len, &nml_dma,
-            &nml_len);
-
-        /* Load first segment */
-        mcp->mb[0] = MBC_LOAD_RISC_RAM;
-        mcp->mb[1] = risc_addr;
-        mcp->mb[2] = MSW(req_dma);
-        mcp->mb[3] = LSW(req_dma);
-        mcp->mb[4] = (uint16_t)req_len;
-        mcp->mb[6] = MSW(MSD(req_dma));
-        mcp->mb[7] = LSW(MSD(req_dma));
-        mcp->out_mb = MBX_7|MBX_6|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
-        mcp->in_mb = MBX_0;
-        mcp->tov = 30;
-        mcp->flags = 0;
-        rval = qla2x00_mailbox_command(ha, mcp);
-
-        /* Load second segment - if necessary */
-        if (normalized && (rval == QLA_SUCCESS)) {
-                mcp->mb[0] = MBC_LOAD_RISC_RAM;
-                mcp->mb[1] = risc_addr + (uint16_t)req_len;
-                mcp->mb[2] = MSW(nml_dma);
-                mcp->mb[3] = LSW(nml_dma);
-                mcp->mb[4] = (uint16_t)nml_len;
-                mcp->mb[6] = MSW(MSD(nml_dma));
-                mcp->mb[7] = LSW(MSD(nml_dma));
-                mcp->out_mb = MBX_7|MBX_6|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
-                mcp->in_mb = MBX_0;
-                mcp->tov = 30;
-                mcp->flags = 0;
-                rval = qla2x00_mailbox_command(ha, mcp);
-        }
+        DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no));
 
-        if (rval == QLA_SUCCESS) {
-                /* Empty */
-                DEBUG11(printk("qla2x00_load_ram(%ld): done.\n", ha->host_no);)
+        if (MSW(risc_addr) || IS_QLA24XX(ha) || IS_QLA25XX(ha)) {
+                mcp->mb[0] = MBC_LOAD_RISC_RAM_EXTENDED;
+                mcp->mb[8] = MSW(risc_addr);
+                mcp->out_mb = MBX_8|MBX_0;
         } else {
-                /* Empty */
-                DEBUG2_3_11(printk("qla2x00_load_ram(%ld): failed. rval=%x "
-                    "mb[0]=%x.\n", ha->host_no, rval, mcp->mb[0]);)
+                mcp->mb[0] = MBC_LOAD_RISC_RAM;
+                mcp->out_mb = MBX_0;
         }
-        return rval;
-}
-
-/*
- * qla2x00_load_ram_ext
- *      Load adapter extended RAM using DMA.
- *
- * Input:
- *      ha = adapter block pointer.
- *
- * Returns:
- *      qla2x00 local function return status code.
- *
- * Context:
- *      Kernel context.
- */
-int
-qla2x00_load_ram_ext(scsi_qla_host_t *ha, dma_addr_t req_dma,
-    uint32_t risc_addr, uint32_t risc_code_size)
-{
-        int rval;
-        mbx_cmd_t mc;
-        mbx_cmd_t *mcp = &mc;
-
-        DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no));
-
-        mcp->mb[0] = MBC_LOAD_RISC_RAM_EXTENDED;
         mcp->mb[1] = LSW(risc_addr);
         mcp->mb[2] = MSW(req_dma);
         mcp->mb[3] = LSW(req_dma);
         mcp->mb[6] = MSW(MSD(req_dma));
         mcp->mb[7] = LSW(MSD(req_dma));
-        mcp->mb[8] = MSW(risc_addr);
-        mcp->out_mb = MBX_8|MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
+        mcp->out_mb |= MBX_7|MBX_6|MBX_3|MBX_2|MBX_1;
         if (IS_QLA24XX(ha) || IS_QLA25XX(ha)) {
                 mcp->mb[4] = MSW(risc_code_size);
                 mcp->mb[5] = LSW(risc_code_size);
diff --git a/drivers/scsi/qla2xxx/qla_os.c b/drivers/scsi/qla2xxx/qla_os.c
index 24304300d7b5..4916847d84ec 100644
--- a/drivers/scsi/qla2xxx/qla_os.c
+++ b/drivers/scsi/qla2xxx/qla_os.c
@@ -71,6 +71,12 @@ MODULE_PARM_DESC(ql2xfdmienable,
                 "Enables FDMI registratons "
                 "Default is 0 - no FDMI. 1 - perfom FDMI.");
 
+int ql2xprocessrscn;
+module_param(ql2xprocessrscn, int, S_IRUGO|S_IRUSR);
+MODULE_PARM_DESC(ql2xprocessrscn,
+                "Option to enable port RSCN handling via a series of less"
+                "fabric intrusive ADISCs and PLOGIs.");
+
 /*
  * SCSI host template entry points
  */
diff --git a/drivers/scsi/qla2xxx/qla_sup.c b/drivers/scsi/qla2xxx/qla_sup.c
index d54d2a99c3d3..f4d755a643e4 100644
--- a/drivers/scsi/qla2xxx/qla_sup.c
+++ b/drivers/scsi/qla2xxx/qla_sup.c
@@ -573,6 +573,9 @@ qla24xx_write_flash_data(scsi_qla_host_t *ha, uint32_t *dwptr, uint32_t faddr,
                 }
         } while (0);
 
+        /* Enable flash write-protection. */
+        qla24xx_write_flash_dword(ha, flash_conf_to_access_addr(0x101), 0x9c);
+
         /* Disable flash write. */
         WRT_REG_DWORD(&reg->ctrl_status,
             RD_REG_DWORD(&reg->ctrl_status) & ~CSRX_FLASH_ENABLE);
diff --git a/drivers/scsi/qla2xxx/qla_version.h b/drivers/scsi/qla2xxx/qla_version.h
index f7937f7f9c68..d537192a1edb 100644
--- a/drivers/scsi/qla2xxx/qla_version.h
+++ b/drivers/scsi/qla2xxx/qla_version.h
@@ -7,9 +7,9 @@
 /*
  * Driver version
  */
-#define QLA2XXX_VERSION      "8.01.03-k"
+#define QLA2XXX_VERSION      "8.01.04-k"
 
 #define QLA_DRIVER_MAJOR_VER    8
 #define QLA_DRIVER_MINOR_VER    1
-#define QLA_DRIVER_PATCH_VER    3
+#define QLA_DRIVER_PATCH_VER    4
 #define QLA_DRIVER_BETA_VER     0
diff --git a/drivers/scsi/raid_class.c b/drivers/scsi/raid_class.c
index 5ec5f44602ac..50c398aab557 100644
--- a/drivers/scsi/raid_class.c
+++ b/drivers/scsi/raid_class.c
@@ -148,9 +148,11 @@ static struct {
         { RAID_LEVEL_LINEAR, "linear" },
         { RAID_LEVEL_0, "raid0" },
         { RAID_LEVEL_1, "raid1" },
+        { RAID_LEVEL_10, "raid10" },
         { RAID_LEVEL_3, "raid3" },
         { RAID_LEVEL_4, "raid4" },
         { RAID_LEVEL_5, "raid5" },
+        { RAID_LEVEL_50, "raid50" },
         { RAID_LEVEL_6, "raid6" },
 };
 
diff --git a/drivers/scsi/scsi.c b/drivers/scsi/scsi.c
index ee5f4dfdab14..245ca99a641e 100644
--- a/drivers/scsi/scsi.c
+++ b/drivers/scsi/scsi.c
@@ -55,6 +55,7 @@
 #include <linux/interrupt.h>
 #include <linux/notifier.h>
 #include <linux/cpu.h>
+#include <linux/mutex.h>
 
 #include <scsi/scsi.h>
 #include <scsi/scsi_cmnd.h>
@@ -209,7 +210,7 @@ static struct scsi_host_cmd_pool scsi_cmd_dma_pool = {
         .gfp_mask       = __GFP_DMA,
 };
 
-static DECLARE_MUTEX(host_cmd_pool_mutex);
+static DEFINE_MUTEX(host_cmd_pool_mutex);
 
 static struct scsi_cmnd *__scsi_get_command(struct Scsi_Host *shost,
                                             gfp_t gfp_mask)
@@ -330,7 +331,7 @@ int scsi_setup_command_freelist(struct Scsi_Host *shost)
          * Select a command slab for this host and create it if not
          * yet existant.
          */
-        down(&host_cmd_pool_mutex);
+        mutex_lock(&host_cmd_pool_mutex);
         pool = (shost->unchecked_isa_dma ? &scsi_cmd_dma_pool : &scsi_cmd_pool);
         if (!pool->users) {
                 pool->slab = kmem_cache_create(pool->name,
@@ -342,7 +343,7 @@ int scsi_setup_command_freelist(struct Scsi_Host *shost)
 
         pool->users++;
         shost->cmd_pool = pool;
-        up(&host_cmd_pool_mutex);
+        mutex_unlock(&host_cmd_pool_mutex);
 
         /*
          * Get one backup command for this host.
@@ -359,7 +360,7 @@ int scsi_setup_command_freelist(struct Scsi_Host *shost)
                 kmem_cache_destroy(pool->slab);
         return -ENOMEM;
  fail:
-        up(&host_cmd_pool_mutex);
+        mutex_unlock(&host_cmd_pool_mutex);
         return -ENOMEM;
 
 }
@@ -381,10 +382,10 @@ void scsi_destroy_command_freelist(struct Scsi_Host *shost)
                 kmem_cache_free(shost->cmd_pool->slab, cmd);
         }
 
-        down(&host_cmd_pool_mutex);
+        mutex_lock(&host_cmd_pool_mutex);
         if (!--shost->cmd_pool->users)
                 kmem_cache_destroy(shost->cmd_pool->slab);
-        up(&host_cmd_pool_mutex);
+        mutex_unlock(&host_cmd_pool_mutex);
 }
 
 #ifdef CONFIG_SCSI_LOGGING
diff --git a/drivers/scsi/scsi_debug.c b/drivers/scsi/scsi_debug.c
index 3ded9daaf4a0..0e529f8171c4 100644
--- a/drivers/scsi/scsi_debug.c
+++ b/drivers/scsi/scsi_debug.c
@@ -221,8 +221,6 @@ static struct bus_type pseudo_lld_bus;
 static struct device_driver sdebug_driverfs_driver = {
         .name           = sdebug_proc_name,
         .bus            = &pseudo_lld_bus,
-        .probe          = sdebug_driver_probe,
-        .remove         = sdebug_driver_remove,
 };
 
 static const int check_condition_result =
@@ -1796,6 +1794,8 @@ static int pseudo_lld_bus_match(struct device *dev,
 static struct bus_type pseudo_lld_bus = {
         .name = "pseudo",
         .match = pseudo_lld_bus_match,
+        .probe = sdebug_driver_probe,
+        .remove = sdebug_driver_remove,
 };
 
 static void sdebug_release_adapter(struct device * dev)
diff --git a/drivers/scsi/scsi_lib.c b/drivers/scsi/scsi_lib.c
index 00c9bf383e23..3574ba935af8 100644
--- a/drivers/scsi/scsi_lib.c
+++ b/drivers/scsi/scsi_lib.c
@@ -1212,7 +1212,7 @@ static int scsi_issue_flush_fn(request_queue_t *q, struct gendisk *disk,
         return -EOPNOTSUPP;
 }
 
-static void scsi_generic_done(struct scsi_cmnd *cmd)
+static void scsi_blk_pc_done(struct scsi_cmnd *cmd)
 {
         BUG_ON(!blk_pc_request(cmd->request));
         /*
@@ -1224,7 +1224,7 @@ static void scsi_generic_done(struct scsi_cmnd *cmd)
         scsi_io_completion(cmd, cmd->bufflen, 0);
 }
 
-void scsi_setup_blk_pc_cmnd(struct scsi_cmnd *cmd)
+static void scsi_setup_blk_pc_cmnd(struct scsi_cmnd *cmd)
 {
         struct request *req = cmd->request;
 
@@ -1241,8 +1241,8 @@ void scsi_setup_blk_pc_cmnd(struct scsi_cmnd *cmd)
         cmd->transfersize = req->data_len;
         cmd->allowed = req->retries;
         cmd->timeout_per_command = req->timeout;
+        cmd->done = scsi_blk_pc_done;
 }
-EXPORT_SYMBOL_GPL(scsi_setup_blk_pc_cmnd);
 
 static int scsi_prep_fn(struct request_queue *q, struct request *req)
 {
@@ -1339,7 +1339,6 @@ static int scsi_prep_fn(struct request_queue *q, struct request *req)
          * happening now.
          */
         if (req->flags & (REQ_CMD | REQ_BLOCK_PC)) {
-                struct scsi_driver *drv;
                 int ret;
 
                 /*
@@ -1371,16 +1370,17 @@ static int scsi_prep_fn(struct request_queue *q, struct request *req)
                 /*
                  * Initialize the actual SCSI command for this request.
                  */
-                if (req->rq_disk) {
+                if (req->flags & REQ_BLOCK_PC) {
+                        scsi_setup_blk_pc_cmnd(cmd);
+                } else if (req->rq_disk) {
+                        struct scsi_driver *drv;
+
                         drv = *(struct scsi_driver **)req->rq_disk->private_data;
                         if (unlikely(!drv->init_command(cmd))) {
                                 scsi_release_buffers(cmd);
                                 scsi_put_command(cmd);
                                 goto kill;
                         }
-                } else {
-                        scsi_setup_blk_pc_cmnd(cmd);
-                        cmd->done = scsi_generic_done;
                 }
         }
 
diff --git a/drivers/scsi/scsi_priv.h b/drivers/scsi/scsi_priv.h
index 14a6198cb8d2..27c48274e8cb 100644
--- a/drivers/scsi/scsi_priv.h
+++ b/drivers/scsi/scsi_priv.h
@@ -26,12 +26,6 @@ struct Scsi_Host;
 #define SCSI_SENSE_VALID(scmd) \
         (((scmd)->sense_buffer[0] & 0x70) == 0x70)
 
-/*
- * Special value for scanning to specify scanning or rescanning of all
- * possible channels, (target) ids, or luns on a given shost.
- */
-#define SCAN_WILD_CARD  ~0
-
 /* hosts.c */
 extern int scsi_init_hosts(void);
 extern void scsi_exit_hosts(void);
diff --git a/drivers/scsi/scsi_proc.c b/drivers/scsi/scsi_proc.c
index a50958b1b6ee..07be62bbaaea 100644
--- a/drivers/scsi/scsi_proc.c
+++ b/drivers/scsi/scsi_proc.c
@@ -25,11 +25,13 @@
 #include <linux/errno.h>
 #include <linux/blkdev.h>
 #include <linux/seq_file.h>
+#include <linux/mutex.h>
 #include <asm/uaccess.h>
 
 #include <scsi/scsi.h>
 #include <scsi/scsi_device.h>
 #include <scsi/scsi_host.h>
+#include <scsi/scsi_transport.h>
 
 #include "scsi_priv.h"
 #include "scsi_logging.h"
@@ -41,7 +43,7 @@
 static struct proc_dir_entry *proc_scsi;
 
 /* Protect sht->present and sht->proc_dir */
-static DECLARE_MUTEX(global_host_template_sem);
+static DEFINE_MUTEX(global_host_template_mutex);
 
 static int proc_scsi_read(char *buffer, char **start, off_t offset,
                           int length, int *eof, void *data)
@@ -83,7 +85,7 @@ void scsi_proc_hostdir_add(struct scsi_host_template *sht)
         if (!sht->proc_info)
                 return;
 
-        down(&global_host_template_sem);
+        mutex_lock(&global_host_template_mutex);
         if (!sht->present++) {
                 sht->proc_dir = proc_mkdir(sht->proc_name, proc_scsi);
                 if (!sht->proc_dir)
@@ -92,7 +94,7 @@ void scsi_proc_hostdir_add(struct scsi_host_template *sht)
                 else
                         sht->proc_dir->owner = sht->module;
         }
-        up(&global_host_template_sem);
+        mutex_unlock(&global_host_template_mutex);
 }
 
 void scsi_proc_hostdir_rm(struct scsi_host_template *sht)
@@ -100,12 +102,12 @@ void scsi_proc_hostdir_rm(struct scsi_host_template *sht)
         if (!sht->proc_info)
                 return;
 
-        down(&global_host_template_sem);
+        mutex_lock(&global_host_template_mutex);
         if (!--sht->present && sht->proc_dir) {
                 remove_proc_entry(sht->proc_name, proc_scsi);
                 sht->proc_dir = NULL;
         }
-        up(&global_host_template_sem);
+        mutex_unlock(&global_host_template_mutex);
 }
 
 void scsi_proc_host_add(struct Scsi_Host *shost)
@@ -199,7 +201,10 @@ static int scsi_add_single_device(uint host, uint channel, uint id, uint lun)
         if (IS_ERR(shost))
                 return PTR_ERR(shost);
 
-        error = scsi_scan_host_selected(shost, channel, id, lun, 1);
+        if (shost->transportt->user_scan)
+                error = shost->transportt->user_scan(shost, channel, id, lun);
+        else
+                error = scsi_scan_host_selected(shost, channel, id, lun, 1);
         scsi_host_put(shost);
         return error;
 }
diff --git a/drivers/scsi/scsi_scan.c b/drivers/scsi/scsi_scan.c
index 05ebb9cef961..752fb5da3de4 100644
--- a/drivers/scsi/scsi_scan.c
+++ b/drivers/scsi/scsi_scan.c
@@ -334,19 +334,6 @@ static struct scsi_target *scsi_alloc_target(struct device *parent,
         struct scsi_target *starget;
         struct scsi_target *found_target;
 
-        /*
-         * Obtain the real parent from the transport. The transport
-         * is allowed to fail (no error) if there is nothing at that
-         * target id.
-         */
-        if (shost->transportt->target_parent) {
-                spin_lock_irqsave(shost->host_lock, flags);
-                parent = shost->transportt->target_parent(shost, channel, id);
-                spin_unlock_irqrestore(shost->host_lock, flags);
-                if (!parent)
-                        return NULL;
-        }
-
         starget = kmalloc(size, GFP_KERNEL);
         if (!starget) {
                 printk(KERN_ERR "%s: allocation failure\n", __FUNCTION__);
@@ -1283,20 +1270,21 @@ struct scsi_device *__scsi_add_device(struct Scsi_Host *shost, uint channel,
         struct scsi_device *sdev;
         struct device *parent = &shost->shost_gendev;
         int res;
-        struct scsi_target *starget = scsi_alloc_target(parent, channel, id);
+        struct scsi_target *starget;
 
+        starget = scsi_alloc_target(parent, channel, id);
         if (!starget)
                 return ERR_PTR(-ENOMEM);
 
         get_device(&starget->dev);
-        down(&shost->scan_mutex);
+        mutex_lock(&shost->scan_mutex);
         if (scsi_host_scan_allowed(shost)) {
                 res = scsi_probe_and_add_lun(starget, lun, NULL, &sdev, 1,
                                              hostdata);
                 if (res != SCSI_SCAN_LUN_PRESENT)
                         sdev = ERR_PTR(-ENODEV);
         }
-        up(&shost->scan_mutex);
+        mutex_unlock(&shost->scan_mutex);
         scsi_target_reap(starget);
         put_device(&starget->dev);
 
@@ -1404,10 +1392,10 @@ void scsi_scan_target(struct device *parent, unsigned int channel,
 {
         struct Scsi_Host *shost = dev_to_shost(parent);
 
-        down(&shost->scan_mutex);
+        mutex_lock(&shost->scan_mutex);
         if (scsi_host_scan_allowed(shost))
                 __scsi_scan_target(parent, channel, id, lun, rescan);
-        up(&shost->scan_mutex);
+        mutex_unlock(&shost->scan_mutex);
 }
 EXPORT_SYMBOL(scsi_scan_target);
 
@@ -1454,7 +1442,7 @@ int scsi_scan_host_selected(struct Scsi_Host *shost, unsigned int channel,
             ((lun != SCAN_WILD_CARD) && (lun > shost->max_lun)))
                 return -EINVAL;
 
-        down(&shost->scan_mutex);
+        mutex_lock(&shost->scan_mutex);
         if (scsi_host_scan_allowed(shost)) {
                 if (channel == SCAN_WILD_CARD)
                         for (channel = 0; channel <= shost->max_channel;
@@ -1464,7 +1452,7 @@ int scsi_scan_host_selected(struct Scsi_Host *shost, unsigned int channel,
                 else
                         scsi_scan_channel(shost, channel, id, lun, rescan);
         }
-        up(&shost->scan_mutex);
+        mutex_unlock(&shost->scan_mutex);
 
         return 0;
 }
@@ -1522,7 +1510,7 @@ struct scsi_device *scsi_get_host_dev(struct Scsi_Host *shost)
         struct scsi_device *sdev = NULL;
         struct scsi_target *starget;
 
-        down(&shost->scan_mutex);
+        mutex_lock(&shost->scan_mutex);
         if (!scsi_host_scan_allowed(shost))
                 goto out;
         starget = scsi_alloc_target(&shost->shost_gendev, 0, shost->this_id);
@@ -1536,7 +1524,7 @@ struct scsi_device *scsi_get_host_dev(struct Scsi_Host *shost)
         }
         put_device(&starget->dev);
  out:
-        up(&shost->scan_mutex);
+        mutex_unlock(&shost->scan_mutex);
         return sdev;
 }
 EXPORT_SYMBOL(scsi_get_host_dev);
diff --git a/drivers/scsi/scsi_sysfs.c b/drivers/scsi/scsi_sysfs.c
index ea7f3a433572..a77b32deaf8f 100644
--- a/drivers/scsi/scsi_sysfs.c
+++ b/drivers/scsi/scsi_sysfs.c
@@ -106,7 +106,10 @@ static int scsi_scan(struct Scsi_Host *shost, const char *str)
                 return -EINVAL;
         if (check_set(&lun, s3))
                 return -EINVAL;
-        res = scsi_scan_host_selected(shost, channel, id, lun, 1);
+        if (shost->transportt->user_scan)
+                res = shost->transportt->user_scan(shost, channel, id, lun);
+        else
+                res = scsi_scan_host_selected(shost, channel, id, lun, 1);
         return res;
 }
 
@@ -745,9 +748,9 @@ void scsi_remove_device(struct scsi_device *sdev)
 {
         struct Scsi_Host *shost = sdev->host;
 
-        down(&shost->scan_mutex);
+        mutex_lock(&shost->scan_mutex);
         __scsi_remove_device(sdev);
-        up(&shost->scan_mutex);
+        mutex_unlock(&shost->scan_mutex);
 }
 EXPORT_SYMBOL(scsi_remove_device);
 
diff --git a/drivers/scsi/scsi_transport_fc.c b/drivers/scsi/scsi_transport_fc.c
index 685b997306cf..f2c9acf11bd0 100644
--- a/drivers/scsi/scsi_transport_fc.c
+++ b/drivers/scsi/scsi_transport_fc.c
@@ -295,6 +295,7 @@ static int fc_host_setup(struct transport_container *tc, struct device *dev,
          */
         fc_host_node_name(shost) = -1;
         fc_host_port_name(shost) = -1;
+        fc_host_permanent_port_name(shost) = -1;
         fc_host_supported_classes(shost) = FC_COS_UNSPECIFIED;
         memset(fc_host_supported_fc4s(shost), 0,
                 sizeof(fc_host_supported_fc4s(shost)));
@@ -795,6 +796,8 @@ static FC_CLASS_DEVICE_ATTR(host, supported_speeds, S_IRUGO,
 
 fc_private_host_rd_attr_cast(node_name, "0x%llx\n", 20, unsigned long long);
 fc_private_host_rd_attr_cast(port_name, "0x%llx\n", 20, unsigned long long);
+fc_private_host_rd_attr_cast(permanent_port_name, "0x%llx\n", 20,
+                             unsigned long long);
 fc_private_host_rd_attr(symbolic_name, "%s\n", (FC_SYMBOLIC_NAME_SIZE +1));
 fc_private_host_rd_attr(maxframe_size, "%u bytes\n", 20);
 fc_private_host_rd_attr(serial_number, "%s\n", (FC_SERIAL_NUMBER_SIZE +1));
@@ -1090,17 +1093,23 @@ static int fc_rport_match(struct attribute_container *cont,
 /*
  * Must be called with shost->host_lock held
  */
-static struct device *fc_target_parent(struct Scsi_Host *shost,
-                                        int channel, uint id)
+static int fc_user_scan(struct Scsi_Host *shost, uint channel,
+                uint id, uint lun)
 {
         struct fc_rport *rport;
 
-        list_for_each_entry(rport, &fc_host_rports(shost), peers)
-                if ((rport->channel == channel) &&
-                    (rport->scsi_target_id == id))
-                        return &rport->dev;
+        list_for_each_entry(rport, &fc_host_rports(shost), peers) {
+                if (rport->scsi_target_id == -1)
+                        continue;
 
-        return NULL;
+                if ((channel == SCAN_WILD_CARD || channel == rport->channel) &&
+                    (id == SCAN_WILD_CARD || id == rport->scsi_target_id)) {
+                        scsi_scan_target(&rport->dev, rport->channel,
+                                         rport->scsi_target_id, lun, 1);
+                }
+        }
+
+        return 0;
 }
 
 struct scsi_transport_template *
@@ -1139,7 +1148,7 @@ fc_attach_transport(struct fc_function_template *ft)
         /* Transport uses the shost workq for scsi scanning */
         i->t.create_work_queue = 1;
 
-        i->t.target_parent = fc_target_parent;
+        i->t.user_scan = fc_user_scan;
         
         /*
          * Setup SCSI Target Attributes.
@@ -1160,6 +1169,7 @@ fc_attach_transport(struct fc_function_template *ft)
         count=0;
         SETUP_HOST_ATTRIBUTE_RD(node_name);
         SETUP_HOST_ATTRIBUTE_RD(port_name);
+        SETUP_HOST_ATTRIBUTE_RD(permanent_port_name);
         SETUP_HOST_ATTRIBUTE_RD(supported_classes);
         SETUP_HOST_ATTRIBUTE_RD(supported_fc4s);
         SETUP_HOST_ATTRIBUTE_RD(symbolic_name);
diff --git a/drivers/scsi/scsi_transport_iscsi.c b/drivers/scsi/scsi_transport_iscsi.c
index e08462d50c97..59a1c9d9d3bd 100644
--- a/drivers/scsi/scsi_transport_iscsi.c
+++ b/drivers/scsi/scsi_transport_iscsi.c
@@ -21,11 +21,9 @@
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  */
 #include <linux/module.h>
-#include <linux/string.h>
-#include <linux/slab.h>
 #include <linux/mempool.h>
+#include <linux/mutex.h>
 #include <net/tcp.h>
-
 #include <scsi/scsi.h>
 #include <scsi/scsi_host.h>
 #include <scsi/scsi_device.h>
@@ -45,11 +43,6 @@ struct iscsi_internal {
          */
         struct list_head sessions;
         /*
-         * lock to serialize access to the sessions list which must
-         * be taken after the rx_queue_sema
-         */
-        spinlock_t session_lock;
-        /*
          * based on transport capabilities, at register time we set these
          * bits to tell the transport class it wants attributes displayed
          * in sysfs or that it can support different iSCSI Data-Path
@@ -70,7 +63,7 @@ struct iscsi_internal {
 /*
  * list of registered transports and lock that must
  * be held while accessing list. The iscsi_transport_lock must
- * be acquired after the rx_queue_sema.
+ * be acquired after the rx_queue_mutex.
  */
 static LIST_HEAD(iscsi_transports);
 static DEFINE_SPINLOCK(iscsi_transport_lock);
@@ -145,7 +138,7 @@ static DECLARE_TRANSPORT_CLASS(iscsi_connection_class,
 
 static struct sock *nls;
 static int daemon_pid;
-static DECLARE_MUTEX(rx_queue_sema);
+static DEFINE_MUTEX(rx_queue_mutex);
 
 struct mempool_zone {
         mempool_t *pool;
@@ -156,7 +149,7 @@ struct mempool_zone {
         spinlock_t freelock;
 };
 
-static struct mempool_zone z_reply;
+static struct mempool_zone *z_reply;
 
 /*
  * Z_MAX_* - actual mempool size allocated at the mempool_zone_init() time
@@ -171,50 +164,271 @@ static struct mempool_zone z_reply;
 #define Z_MAX_ERROR     16
 #define Z_HIWAT_ERROR   12
 
-struct iscsi_if_conn {
-        struct list_head conn_list;     /* item in connlist */
-        struct list_head session_list;  /* item in session->connections */
-        iscsi_connh_t connh;
-        int active;                     /* must be accessed with the connlock */
-        struct Scsi_Host *host;         /* originated shost */
-        struct device dev;              /* sysfs transport/container device */
-        struct iscsi_transport *transport;
-        struct mempool_zone z_error;
-        struct mempool_zone z_pdu;
-        struct list_head freequeue;
-};
+static LIST_HEAD(connlist);
+static DEFINE_SPINLOCK(connlock);
 
-#define iscsi_dev_to_if_conn(_dev) \
-        container_of(_dev, struct iscsi_if_conn, dev)
+/*
+ * The following functions can be used by LLDs that allocate
+ * their own scsi_hosts or by software iscsi LLDs
+ */
+static void iscsi_session_release(struct device *dev)
+{
+        struct iscsi_cls_session *session = iscsi_dev_to_session(dev);
+        struct iscsi_transport *transport = session->transport;
+        struct Scsi_Host *shost;
 
-#define iscsi_cdev_to_if_conn(_cdev) \
-        iscsi_dev_to_if_conn(_cdev->dev)
+        shost = iscsi_session_to_shost(session);
+        scsi_host_put(shost);
+        kfree(session);
+        module_put(transport->owner);
+}
 
-static LIST_HEAD(connlist);
-static DEFINE_SPINLOCK(connlock);
+static int iscsi_is_session_dev(const struct device *dev)
+{
+        return dev->release == iscsi_session_release;
+}
 
-struct iscsi_if_session {
-        struct list_head list;  /* item in session_list */
-        struct list_head connections;
-        iscsi_sessionh_t sessionh;
-        struct iscsi_transport *transport;
-        struct device dev;      /* sysfs transport/container device */
-};
+/**
+ * iscsi_create_session - create iscsi class session
+ * @shost: scsi host
+ * @transport: iscsi transport
+ *
+ * This can be called from a LLD or iscsi_transport
+ **/
+struct iscsi_cls_session *
+iscsi_create_session(struct Scsi_Host *shost, struct iscsi_transport *transport)
+{
+        struct iscsi_cls_session *session;
+        int err;
+
+        if (!try_module_get(transport->owner))
+                return NULL;
+
+        session = kzalloc(sizeof(*session), GFP_KERNEL);
+        if (!session)
+                goto module_put;
+        session->transport = transport;
+
+        /* this is released in the dev's release function */
+        scsi_host_get(shost);
+        snprintf(session->dev.bus_id, BUS_ID_SIZE, "session%u", shost->host_no);
+        session->dev.parent = &shost->shost_gendev;
+        session->dev.release = iscsi_session_release;
+        err = device_register(&session->dev);
+        if (err) {
+                dev_printk(KERN_ERR, &session->dev, "iscsi: could not "
+                           "register session's dev\n");
+                goto free_session;
+        }
+        transport_register_device(&session->dev);
+
+        return session;
+
+free_session:
+        kfree(session);
+module_put:
+        module_put(transport->owner);
+        return NULL;
+}
+
+EXPORT_SYMBOL_GPL(iscsi_create_session);
+
+/**
+ * iscsi_destroy_session - destroy iscsi session
+ * @session: iscsi_session
+ *
+ * Can be called by a LLD or iscsi_transport. There must not be
+ * any running connections.
+ **/
+int iscsi_destroy_session(struct iscsi_cls_session *session)
+{
+        transport_unregister_device(&session->dev);
+        device_unregister(&session->dev);
+        return 0;
+}
+
+EXPORT_SYMBOL_GPL(iscsi_destroy_session);
+
+static void iscsi_conn_release(struct device *dev)
+{
+        struct iscsi_cls_conn *conn = iscsi_dev_to_conn(dev);
+        struct device *parent = conn->dev.parent;
+
+        kfree(conn);
+        put_device(parent);
+}
+
+static int iscsi_is_conn_dev(const struct device *dev)
+{
+        return dev->release == iscsi_conn_release;
+}
+
+/**
+ * iscsi_create_conn - create iscsi class connection
+ * @session: iscsi cls session
+ * @cid: connection id
+ *
+ * This can be called from a LLD or iscsi_transport. The connection
+ * is child of the session so cid must be unique for all connections
+ * on the session.
+ **/
+struct iscsi_cls_conn *
+iscsi_create_conn(struct iscsi_cls_session *session, uint32_t cid)
+{
+        struct iscsi_transport *transport = session->transport;
+        struct Scsi_Host *shost = iscsi_session_to_shost(session);
+        struct iscsi_cls_conn *conn;
+        int err;
+
+        conn = kzalloc(sizeof(*conn) + transport->conndata_size, GFP_KERNEL);
+        if (!conn)
+                return NULL;
+
+        if (transport->conndata_size)
+                conn->dd_data = &conn[1];
+
+        INIT_LIST_HEAD(&conn->conn_list);
+        conn->transport = transport;
+
+        /* this is released in the dev's release function */
+        if (!get_device(&session->dev))
+                goto free_conn;
+        snprintf(conn->dev.bus_id, BUS_ID_SIZE, "connection%d:%u",
+                 shost->host_no, cid);
+        conn->dev.parent = &session->dev;
+        conn->dev.release = iscsi_conn_release;
+        err = device_register(&conn->dev);
+        if (err) {
+                dev_printk(KERN_ERR, &conn->dev, "iscsi: could not register "
+                           "connection's dev\n");
+                goto release_parent_ref;
+        }
+        transport_register_device(&conn->dev);
+        return conn;
+
+release_parent_ref:
+        put_device(&session->dev);
+free_conn:
+        kfree(conn);
+        return NULL;
+}
+
+EXPORT_SYMBOL_GPL(iscsi_create_conn);
+
+/**
+ * iscsi_destroy_conn - destroy iscsi class connection
+ * @session: iscsi cls session
+ *
+ * This can be called from a LLD or iscsi_transport.
+ **/
+int iscsi_destroy_conn(struct iscsi_cls_conn *conn)
+{
+        transport_unregister_device(&conn->dev);
+        device_unregister(&conn->dev);
+        return 0;
+}
+
+EXPORT_SYMBOL_GPL(iscsi_destroy_conn);
+
+/*
+ * These functions are used only by software iscsi_transports
+ * which do not allocate and more their scsi_hosts since this
+ * is initiated from userspace.
+ */
+
+/*
+ * iSCSI Session's hostdata organization:
+ *
+ *    *------------------* <== hostdata_session(host->hostdata)
+ *    | ptr to class sess|
+ *    |------------------| <== iscsi_hostdata(host->hostdata)
+ *    | transport's data |
+ *    *------------------*
+ */
+
+#define hostdata_privsize(_t)   (sizeof(unsigned long) + _t->hostdata_size + \
+                                 _t->hostdata_size % sizeof(unsigned long))
+
+#define hostdata_session(_hostdata) (iscsi_ptr(*(unsigned long *)_hostdata))
+
+/**
+ * iscsi_transport_create_session - create iscsi cls session and host
+ * scsit: scsi transport template
+ * transport: iscsi transport template
+ *
+ * This can be used by software iscsi_transports that allocate
+ * a session per scsi host.
+ **/
+struct Scsi_Host *
+iscsi_transport_create_session(struct scsi_transport_template *scsit,
+                               struct iscsi_transport *transport)
+{
+        struct iscsi_cls_session *session;
+        struct Scsi_Host *shost;
+
+        shost = scsi_host_alloc(transport->host_template,
+                                hostdata_privsize(transport));
+        if (!shost) {
+                printk(KERN_ERR "iscsi: can not allocate SCSI host for "
+                        "session\n");
+                return NULL;
+        }
+
+        shost->max_id = 1;
+        shost->max_channel = 0;
+        shost->max_lun = transport->max_lun;
+        shost->max_cmd_len = transport->max_cmd_len;
+        shost->transportt = scsit;
+        shost->transportt->create_work_queue = 1;
+
+        if (scsi_add_host(shost, NULL))
+                goto free_host;
+
+        session = iscsi_create_session(shost, transport);
+        if (!session)
+                goto remove_host;
 
-#define iscsi_dev_to_if_session(_dev) \
-        container_of(_dev, struct iscsi_if_session, dev)
+        *(unsigned long*)shost->hostdata = (unsigned long)session;
+        return shost;
+
+remove_host:
+        scsi_remove_host(shost);
+free_host:
+        scsi_host_put(shost);
+        return NULL;
+}
 
-#define iscsi_cdev_to_if_session(_cdev) \
-        iscsi_dev_to_if_session(_cdev->dev)
+EXPORT_SYMBOL_GPL(iscsi_transport_create_session);
 
-#define iscsi_if_session_to_shost(_session) \
-        dev_to_shost(_session->dev.parent)
+/**
+ * iscsi_transport_destroy_session - destroy session and scsi host
+ * shost: scsi host
+ *
+ * This can be used by software iscsi_transports that allocate
+ * a session per scsi host.
+ **/
+int iscsi_transport_destroy_session(struct Scsi_Host *shost)
+{
+        struct iscsi_cls_session *session;
 
-static struct iscsi_if_conn*
+        scsi_remove_host(shost);
+        session = hostdata_session(shost->hostdata);
+        iscsi_destroy_session(session);
+        /* ref from host alloc */
+        scsi_host_put(shost);
+        return 0;
+}
+
+EXPORT_SYMBOL_GPL(iscsi_transport_destroy_session);
+
+/*
+ * iscsi interface functions
+ */
+static struct iscsi_cls_conn*
 iscsi_if_find_conn(uint64_t key)
 {
         unsigned long flags;
-        struct iscsi_if_conn *conn;
+        struct iscsi_cls_conn *conn;
 
         spin_lock_irqsave(&connlock, flags);
         list_for_each_entry(conn, &connlist, conn_list)
@@ -249,7 +463,7 @@ static inline struct list_head *skb_to_lh(struct sk_buff *skb)
 }
 
 static void*
-mempool_zone_alloc_skb(gfp_t gfp_mask, void *pool_data)
+mempool_zone_alloc_skb(unsigned int gfp_mask, void *pool_data)
 {
         struct mempool_zone *zone = pool_data;
 
@@ -281,14 +495,21 @@ mempool_zone_complete(struct mempool_zone *zone)
         spin_unlock_irqrestore(&zone->freelock, flags);
 }
 
-static int
-mempool_zone_init(struct mempool_zone *zp, unsigned max, unsigned size,
-                unsigned hiwat)
+static struct mempool_zone *
+mempool_zone_init(unsigned max, unsigned size, unsigned hiwat)
 {
+        struct mempool_zone *zp;
+
+        zp = kzalloc(sizeof(*zp), GFP_KERNEL);
+        if (!zp)
+                return NULL;
+
         zp->pool = mempool_create(max, mempool_zone_alloc_skb,
                                   mempool_zone_free_skb, zp);
-        if (!zp->pool)
-                return -ENOMEM;
+        if (!zp->pool) {
+                kfree(zp);
+                return NULL;
+        }
 
         zp->size = size;
         zp->hiwat = hiwat;
@@ -297,9 +518,14 @@ mempool_zone_init(struct mempool_zone *zp, unsigned max, unsigned size,
         spin_lock_init(&zp->freelock);
         atomic_set(&zp->allocated, 0);
 
-        return 0;
+        return zp;
 }
 
+static void mempool_zone_destroy(struct mempool_zone *zp)
+{
+        mempool_destroy(zp->pool);
+        kfree(zp);
+}
 
 static struct sk_buff*
 mempool_zone_get_skb(struct mempool_zone *zone)
@@ -339,7 +565,7 @@ int iscsi_recv_pdu(iscsi_connh_t connh, struct iscsi_hdr *hdr,
         struct nlmsghdr *nlh;
         struct sk_buff *skb;
         struct iscsi_uevent *ev;
-        struct iscsi_if_conn *conn;
+        struct iscsi_cls_conn *conn;
         char *pdu;
         int len = NLMSG_SPACE(sizeof(*ev) + sizeof(struct iscsi_hdr) +
                               data_size);
@@ -347,13 +573,13 @@ int iscsi_recv_pdu(iscsi_connh_t connh, struct iscsi_hdr *hdr,
         conn = iscsi_if_find_conn(connh);
         BUG_ON(!conn);
 
-        mempool_zone_complete(&conn->z_pdu);
+        mempool_zone_complete(conn->z_pdu);
 
-        skb = mempool_zone_get_skb(&conn->z_pdu);
+        skb = mempool_zone_get_skb(conn->z_pdu);
         if (!skb) {
                 iscsi_conn_error(connh, ISCSI_ERR_CONN_FAILED);
-                printk(KERN_ERR "iscsi%d: can not deliver control PDU: OOM\n",
-                       conn->host->host_no);
+                dev_printk(KERN_ERR, &conn->dev, "iscsi: can not deliver "
+                           "control PDU: OOM\n");
                 return -ENOMEM;
         }
 
@@ -362,14 +588,14 @@ int iscsi_recv_pdu(iscsi_connh_t connh, struct iscsi_hdr *hdr,
         memset(ev, 0, sizeof(*ev));
         ev->transport_handle = iscsi_handle(conn->transport);
         ev->type = ISCSI_KEVENT_RECV_PDU;
-        if (atomic_read(&conn->z_pdu.allocated) >= conn->z_pdu.hiwat)
+        if (atomic_read(&conn->z_pdu->allocated) >= conn->z_pdu->hiwat)
                 ev->iferror = -ENOMEM;
         ev->r.recv_req.conn_handle = connh;
         pdu = (char*)ev + sizeof(*ev);
         memcpy(pdu, hdr, sizeof(struct iscsi_hdr));
         memcpy(pdu + sizeof(struct iscsi_hdr), data, data_size);
 
-        return iscsi_unicast_skb(&conn->z_pdu, skb);
+        return iscsi_unicast_skb(conn->z_pdu, skb);
 }
 EXPORT_SYMBOL_GPL(iscsi_recv_pdu);
 
@@ -378,18 +604,18 @@ void iscsi_conn_error(iscsi_connh_t connh, enum iscsi_err error)
         struct nlmsghdr *nlh;
         struct sk_buff  *skb;
         struct iscsi_uevent *ev;
-        struct iscsi_if_conn *conn;
+        struct iscsi_cls_conn *conn;
         int len = NLMSG_SPACE(sizeof(*ev));
 
         conn = iscsi_if_find_conn(connh);
         BUG_ON(!conn);
 
-        mempool_zone_complete(&conn->z_error);
+        mempool_zone_complete(conn->z_error);
 
-        skb = mempool_zone_get_skb(&conn->z_error);
+        skb = mempool_zone_get_skb(conn->z_error);
         if (!skb) {
-                printk(KERN_ERR "iscsi%d: gracefully ignored conn error (%d)\n",
-                       conn->host->host_no, error);
+                dev_printk(KERN_ERR, &conn->dev, "iscsi: gracefully ignored "
+                          "conn error (%d)\n", error);
                 return;
         }
 
@@ -397,15 +623,15 @@ void iscsi_conn_error(iscsi_connh_t connh, enum iscsi_err error)
         ev = NLMSG_DATA(nlh);
         ev->transport_handle = iscsi_handle(conn->transport);
         ev->type = ISCSI_KEVENT_CONN_ERROR;
-        if (atomic_read(&conn->z_error.allocated) >= conn->z_error.hiwat)
+        if (atomic_read(&conn->z_error->allocated) >= conn->z_error->hiwat)
                 ev->iferror = -ENOMEM;
         ev->r.connerror.error = error;
         ev->r.connerror.conn_handle = connh;
 
-        iscsi_unicast_skb(&conn->z_error, skb);
+        iscsi_unicast_skb(conn->z_error, skb);
 
-        printk(KERN_INFO "iscsi%d: detected conn error (%d)\n",
-               conn->host->host_no, error);
+        dev_printk(KERN_INFO, &conn->dev, "iscsi: detected conn error (%d)\n",
+                   error);
 }
 EXPORT_SYMBOL_GPL(iscsi_conn_error);
 
@@ -419,9 +645,9 @@ iscsi_if_send_reply(int pid, int seq, int type, int done, int multi,
         int flags = multi ? NLM_F_MULTI : 0;
         int t = done ? NLMSG_DONE : type;
 
-        mempool_zone_complete(&z_reply);
+        mempool_zone_complete(z_reply);
 
-        skb = mempool_zone_get_skb(&z_reply);
+        skb = mempool_zone_get_skb(z_reply);
         /*
          * FIXME:
          * user is supposed to react on iferror == -ENOMEM;
@@ -432,366 +658,197 @@ iscsi_if_send_reply(int pid, int seq, int type, int done, int multi,
         nlh = __nlmsg_put(skb, pid, seq, t, (len - sizeof(*nlh)), 0);
         nlh->nlmsg_flags = flags;
         memcpy(NLMSG_DATA(nlh), payload, size);
-        return iscsi_unicast_skb(&z_reply, skb);
+        return iscsi_unicast_skb(z_reply, skb);
 }
 
-/*
- * iSCSI Session's hostdata organization:
- *
- *    *------------------* <== host->hostdata
- *    | transport        |
- *    |------------------| <== iscsi_hostdata(host->hostdata)
- *    | transport's data |
- *    |------------------| <== hostdata_session(host->hostdata)
- *    | interface's data |
- *    *------------------*
- */
+static int
+iscsi_if_get_stats(struct iscsi_transport *transport, struct sk_buff *skb,
+                   struct nlmsghdr *nlh)
+{
+        struct iscsi_uevent *ev = NLMSG_DATA(nlh);
+        struct iscsi_stats *stats;
+        struct sk_buff *skbstat;
+        struct iscsi_cls_conn *conn;
+        struct nlmsghdr *nlhstat;
+        struct iscsi_uevent *evstat;
+        int len = NLMSG_SPACE(sizeof(*ev) +
+                              sizeof(struct iscsi_stats) +
+                              sizeof(struct iscsi_stats_custom) *
+                              ISCSI_STATS_CUSTOM_MAX);
+        int err = 0;
 
-#define hostdata_privsize(_t)   (sizeof(unsigned long) + _t->hostdata_size + \
-                                 _t->hostdata_size % sizeof(unsigned long) + \
-                                 sizeof(struct iscsi_if_session))
+        conn = iscsi_if_find_conn(ev->u.get_stats.conn_handle);
+        if (!conn)
+                return -EEXIST;
 
-#define hostdata_session(_hostdata) ((void*)_hostdata + sizeof(unsigned long) + \
-                        ((struct iscsi_transport *) \
-                         iscsi_ptr(*(uint64_t *)_hostdata))->hostdata_size)
+        do {
+                int actual_size;
 
-static void iscsi_if_session_dev_release(struct device *dev)
-{
-        struct iscsi_if_session *session = iscsi_dev_to_if_session(dev);
-        struct iscsi_transport *transport = session->transport;
-        struct Scsi_Host *shost = iscsi_if_session_to_shost(session);
-        struct iscsi_if_conn *conn, *tmp;
-        unsigned long flags;
+                mempool_zone_complete(conn->z_pdu);
 
-        /* now free connections */
-        spin_lock_irqsave(&connlock, flags);
-        list_for_each_entry_safe(conn, tmp, &session->connections,
-                                 session_list) {
-                list_del(&conn->session_list);
-                mempool_destroy(conn->z_pdu.pool);
-                mempool_destroy(conn->z_error.pool);
-                kfree(conn);
-        }
-        spin_unlock_irqrestore(&connlock, flags);
-        scsi_host_put(shost);
-        module_put(transport->owner);
+                skbstat = mempool_zone_get_skb(conn->z_pdu);
+                if (!skbstat) {
+                        dev_printk(KERN_ERR, &conn->dev, "iscsi: can not "
+                                   "deliver stats: OOM\n");
+                        return -ENOMEM;
+                }
+
+                nlhstat = __nlmsg_put(skbstat, daemon_pid, 0, 0,
+                                      (len - sizeof(*nlhstat)), 0);
+                evstat = NLMSG_DATA(nlhstat);
+                memset(evstat, 0, sizeof(*evstat));
+                evstat->transport_handle = iscsi_handle(conn->transport);
+                evstat->type = nlh->nlmsg_type;
+                if (atomic_read(&conn->z_pdu->allocated) >= conn->z_pdu->hiwat)
+                        evstat->iferror = -ENOMEM;
+                evstat->u.get_stats.conn_handle =
+                        ev->u.get_stats.conn_handle;
+                stats = (struct iscsi_stats *)
+                        ((char*)evstat + sizeof(*evstat));
+                memset(stats, 0, sizeof(*stats));
+
+                transport->get_stats(ev->u.get_stats.conn_handle, stats);
+                actual_size = NLMSG_SPACE(sizeof(struct iscsi_uevent) +
+                                          sizeof(struct iscsi_stats) +
+                                          sizeof(struct iscsi_stats_custom) *
+                                          stats->custom_length);
+                actual_size -= sizeof(*nlhstat);
+                actual_size = NLMSG_LENGTH(actual_size);
+                skb_trim(skb, NLMSG_ALIGN(actual_size));
+                nlhstat->nlmsg_len = actual_size;
+
+                err = iscsi_unicast_skb(conn->z_pdu, skbstat);
+        } while (err < 0 && err != -ECONNREFUSED);
+
+        return err;
 }
 
 static int
 iscsi_if_create_session(struct iscsi_internal *priv, struct iscsi_uevent *ev)
 {
         struct iscsi_transport *transport = priv->iscsi_transport;
-        struct iscsi_if_session *session;
         struct Scsi_Host *shost;
-        unsigned long flags;
-        int error;
-
-        if (!try_module_get(transport->owner))
-                return -EPERM;
 
-        shost = scsi_host_alloc(transport->host_template,
-                                hostdata_privsize(transport));
-        if (!shost) {
-                ev->r.c_session_ret.session_handle = iscsi_handle(NULL);
-                printk(KERN_ERR "iscsi: can not allocate SCSI host for "
-                       "session\n");
-                error = -ENOMEM;
-                goto out_module_put;
-        }
-        shost->max_id = 1;
-        shost->max_channel = 0;
-        shost->max_lun = transport->max_lun;
-        shost->max_cmd_len = transport->max_cmd_len;
-        shost->transportt = &priv->t;
-
-        /* store struct iscsi_transport in hostdata */
-        *(uint64_t*)shost->hostdata = ev->transport_handle;
+        if (!transport->create_session)
+                return -EINVAL;
 
-        ev->r.c_session_ret.session_handle = transport->create_session(
-                                        ev->u.c_session.initial_cmdsn, shost);
-        if (ev->r.c_session_ret.session_handle == iscsi_handle(NULL)) {
-                error = 0;
-                goto out_host_put;
-        }
+        shost = transport->create_session(&priv->t,
+                                          ev->u.c_session.initial_cmdsn);
+        if (!shost)
+                return -ENOMEM;
 
-        /* host_no becomes assigned SID */
+        ev->r.c_session_ret.session_handle = iscsi_handle(iscsi_hostdata(shost->hostdata));
         ev->r.c_session_ret.sid = shost->host_no;
-        /* initialize session */
-        session = hostdata_session(shost->hostdata);
-        INIT_LIST_HEAD(&session->connections);
-        INIT_LIST_HEAD(&session->list);
-        session->sessionh = ev->r.c_session_ret.session_handle;
-        session->transport = transport;
-
-        error = scsi_add_host(shost, NULL);
-        if (error)
-                goto out_destroy_session;
-
-        /*
-         * this is released in the dev's release function)
-         */
-        scsi_host_get(shost);
-        snprintf(session->dev.bus_id, BUS_ID_SIZE, "session%u", shost->host_no);
-        session->dev.parent = &shost->shost_gendev;
-        session->dev.release = iscsi_if_session_dev_release;
-        error = device_register(&session->dev);
-        if (error) {
-                printk(KERN_ERR "iscsi: could not register session%d's dev\n",
-                       shost->host_no);
-                goto out_remove_host;
-        }
-        transport_register_device(&session->dev);
-
-        /* add this session to the list of active sessions */
-        spin_lock_irqsave(&priv->session_lock, flags);
-        list_add(&session->list, &priv->sessions);
-        spin_unlock_irqrestore(&priv->session_lock, flags);
-
         return 0;
-
-out_remove_host:
-        scsi_remove_host(shost);
-out_destroy_session:
-        transport->destroy_session(ev->r.c_session_ret.session_handle);
-        ev->r.c_session_ret.session_handle = iscsi_handle(NULL);
-out_host_put:
-        scsi_host_put(shost);
-out_module_put:
-        module_put(transport->owner);
-        return error;
 }
 
 static int
 iscsi_if_destroy_session(struct iscsi_internal *priv, struct iscsi_uevent *ev)
 {
         struct iscsi_transport *transport = priv->iscsi_transport;
+
         struct Scsi_Host *shost;
-        struct iscsi_if_session *session;
-        unsigned long flags;
-        struct iscsi_if_conn *conn;
-        int error = 0;
+
+        if (!transport->destroy_session)
+                return -EINVAL;
 
         shost = scsi_host_lookup(ev->u.d_session.sid);
         if (shost == ERR_PTR(-ENXIO))
                 return -EEXIST;
-        session = hostdata_session(shost->hostdata);
 
-        /* check if we have active connections */
-        spin_lock_irqsave(&connlock, flags);
-        list_for_each_entry(conn, &session->connections, session_list) {
-                if (conn->active) {
-                        printk(KERN_ERR "iscsi%d: can not destroy session: "
-                               "has active connection (%p)\n",
-                               shost->host_no, iscsi_ptr(conn->connh));
-                        spin_unlock_irqrestore(&connlock, flags);
-                        error = EIO;
-                        goto out_release_ref;
-                }
-        }
-        spin_unlock_irqrestore(&connlock, flags);
-
-        scsi_remove_host(shost);
-        transport->destroy_session(ev->u.d_session.session_handle);
-        transport_unregister_device(&session->dev);
-        device_unregister(&session->dev);
-
-        /* remove this session from the list of active sessions */
-        spin_lock_irqsave(&priv->session_lock, flags);
-        list_del(&session->list);
-        spin_unlock_irqrestore(&priv->session_lock, flags);
-
-        /* ref from host alloc */
-        scsi_host_put(shost);
-out_release_ref:
-        /* ref from host lookup */
-        scsi_host_put(shost);
-        return error;
-}
-
-static void iscsi_if_conn_dev_release(struct device *dev)
-{
-        struct iscsi_if_conn *conn = iscsi_dev_to_if_conn(dev);
-        struct Scsi_Host *shost = conn->host;
-
-        scsi_host_put(shost);
+        if (transport->destroy_session)
+                transport->destroy_session(shost);
+        /* ref from host lookup */
+        scsi_host_put(shost);
+        return 0;
 }
 
 static int
-iscsi_if_create_conn(struct iscsi_transport *transport, struct iscsi_uevent *ev)
-{
-        struct iscsi_if_session *session;
+iscsi_if_create_conn(struct iscsi_transport *transport, struct iscsi_uevent *ev){
         struct Scsi_Host *shost;
-        struct iscsi_if_conn *conn;
+        struct iscsi_cls_conn *conn;
         unsigned long flags;
-        int error;
+
+        if (!transport->create_conn)
+                return -EINVAL;
 
         shost = scsi_host_lookup(ev->u.c_conn.sid);
         if (shost == ERR_PTR(-ENXIO))
                 return -EEXIST;
-        session = hostdata_session(shost->hostdata);
 
-        conn = kmalloc(sizeof(struct iscsi_if_conn), GFP_KERNEL);
-        if (!conn) {
-                error = -ENOMEM;
-                goto out_release_ref;
-        }
-        memset(conn, 0, sizeof(struct iscsi_if_conn));
-        INIT_LIST_HEAD(&conn->session_list);
-        INIT_LIST_HEAD(&conn->conn_list);
-        conn->host = shost;
-        conn->transport = transport;
+        conn = transport->create_conn(shost, ev->u.c_conn.cid);
+        if (!conn)
+                goto release_ref;
 
-        error = mempool_zone_init(&conn->z_pdu, Z_MAX_PDU,
+        conn->z_pdu = mempool_zone_init(Z_MAX_PDU,
                         NLMSG_SPACE(sizeof(struct iscsi_uevent) +
                                     sizeof(struct iscsi_hdr) +
                                     DEFAULT_MAX_RECV_DATA_SEGMENT_LENGTH),
                         Z_HIWAT_PDU);
-        if (error) {
-                printk(KERN_ERR "iscsi%d: can not allocate pdu zone for new "
-                       "conn\n", shost->host_no);
-                goto out_free_conn;
+        if (!conn->z_pdu) {
+                dev_printk(KERN_ERR, &conn->dev, "iscsi: can not allocate "
+                           "pdu zone for new conn\n");
+                goto destroy_conn;
         }
-        error = mempool_zone_init(&conn->z_error, Z_MAX_ERROR,
+
+        conn->z_error = mempool_zone_init(Z_MAX_ERROR,
                         NLMSG_SPACE(sizeof(struct iscsi_uevent)),
                         Z_HIWAT_ERROR);
-        if (error) {
-                printk(KERN_ERR "iscsi%d: can not allocate error zone for "
-                       "new conn\n", shost->host_no);
-                goto out_free_pdu_pool;
-        }
-
-        ev->r.handle = transport->create_conn(ev->u.c_conn.session_handle,
-                                        ev->u.c_conn.cid);
-        if (!ev->r.handle) {
-                error = -ENODEV;
-                goto out_free_error_pool;
+        if (!conn->z_error) {
+                dev_printk(KERN_ERR, &conn->dev, "iscsi: can not allocate "
+                           "error zone for new conn\n");
+                goto free_pdu_pool;
         }
 
-        conn->connh = ev->r.handle;
-
-        /*
-         * this is released in the dev's release function
-         */
-        if (!scsi_host_get(shost))
-                goto out_destroy_conn;
-        snprintf(conn->dev.bus_id, BUS_ID_SIZE, "connection%d:%u",
-                 shost->host_no, ev->u.c_conn.cid);
-        conn->dev.parent = &session->dev;
-        conn->dev.release = iscsi_if_conn_dev_release;
-        error = device_register(&conn->dev);
-        if (error) {
-                printk(KERN_ERR "iscsi%d: could not register connections%u "
-                       "dev\n", shost->host_no, ev->u.c_conn.cid);
-                goto out_release_parent_ref;
-        }
-        transport_register_device(&conn->dev);
+        ev->r.handle = conn->connh = iscsi_handle(conn->dd_data);
 
         spin_lock_irqsave(&connlock, flags);
         list_add(&conn->conn_list, &connlist);
-        list_add(&conn->session_list, &session->connections);
         conn->active = 1;
         spin_unlock_irqrestore(&connlock, flags);
 
         scsi_host_put(shost);
         return 0;
 
-out_release_parent_ref:
+free_pdu_pool:
+        mempool_zone_destroy(conn->z_pdu);
+destroy_conn:
+        if (transport->destroy_conn)
+                transport->destroy_conn(conn->dd_data);
+release_ref:
         scsi_host_put(shost);
-out_destroy_conn:
-        transport->destroy_conn(ev->r.handle);
-out_free_error_pool:
-        mempool_destroy(conn->z_error.pool);
-out_free_pdu_pool:
-        mempool_destroy(conn->z_pdu.pool);
-out_free_conn:
-        kfree(conn);
-out_release_ref:
-        scsi_host_put(shost);
-        return error;
+        return -ENOMEM;
 }
 
 static int
 iscsi_if_destroy_conn(struct iscsi_transport *transport, struct iscsi_uevent *ev)
 {
         unsigned long flags;
-        struct iscsi_if_conn *conn;
+        struct iscsi_cls_conn *conn;
+        struct mempool_zone *z_error, *z_pdu;
 
         conn = iscsi_if_find_conn(ev->u.d_conn.conn_handle);
         if (!conn)
                 return -EEXIST;
 
-        transport->destroy_conn(ev->u.d_conn.conn_handle);
+        if (!transport->destroy_conn)
+                return -EINVAL;
 
         spin_lock_irqsave(&connlock, flags);
         conn->active = 0;
         list_del(&conn->conn_list);
         spin_unlock_irqrestore(&connlock, flags);
 
-        transport_unregister_device(&conn->dev);
-        device_unregister(&conn->dev);
-        return 0;
-}
-
-static int
-iscsi_if_get_stats(struct iscsi_transport *transport, struct sk_buff *skb,
-                   struct nlmsghdr *nlh)
-{
-        struct iscsi_uevent *ev = NLMSG_DATA(nlh);
-        struct iscsi_stats *stats;
-        struct sk_buff *skbstat;
-        struct iscsi_if_conn *conn;
-        struct nlmsghdr *nlhstat;
-        struct iscsi_uevent *evstat;
-        int len = NLMSG_SPACE(sizeof(*ev) +
-                              sizeof(struct iscsi_stats) +
-                              sizeof(struct iscsi_stats_custom) *
-                              ISCSI_STATS_CUSTOM_MAX);
-        int err = 0;
-
-        conn = iscsi_if_find_conn(ev->u.get_stats.conn_handle);
-        if (!conn)
-                return -EEXIST;
-
-        do {
-                int actual_size;
-
-                mempool_zone_complete(&conn->z_pdu);
-
-                skbstat = mempool_zone_get_skb(&conn->z_pdu);
-                if (!skbstat) {
-                        printk(KERN_ERR "iscsi%d: can not deliver stats: OOM\n",
-                               conn->host->host_no);
-                        return -ENOMEM;
-                }
-
-                nlhstat = __nlmsg_put(skbstat, daemon_pid, 0, 0,
-                                      (len - sizeof(*nlhstat)), 0);
-                evstat = NLMSG_DATA(nlhstat);
-                memset(evstat, 0, sizeof(*evstat));
-                evstat->transport_handle = iscsi_handle(conn->transport);
-                evstat->type = nlh->nlmsg_type;
-                if (atomic_read(&conn->z_pdu.allocated) >= conn->z_pdu.hiwat)
-                        evstat->iferror = -ENOMEM;
-                evstat->u.get_stats.conn_handle =
-                        ev->u.get_stats.conn_handle;
-                stats = (struct iscsi_stats *)
-                        ((char*)evstat + sizeof(*evstat));
-                memset(stats, 0, sizeof(*stats));
+        z_pdu = conn->z_pdu;
+        z_error = conn->z_error;
 
-                transport->get_stats(ev->u.get_stats.conn_handle, stats);
-                actual_size = NLMSG_SPACE(sizeof(struct iscsi_uevent) +
-                                          sizeof(struct iscsi_stats) +
-                                          sizeof(struct iscsi_stats_custom) *
-                                          stats->custom_length);
-                actual_size -= sizeof(*nlhstat);
-                actual_size = NLMSG_LENGTH(actual_size);
-                skb_trim(skb, NLMSG_ALIGN(actual_size));
-                nlhstat->nlmsg_len = actual_size;
+        if (transport->destroy_conn)
+                transport->destroy_conn(conn);
 
-                err = iscsi_unicast_skb(&conn->z_pdu, skbstat);
-        } while (err < 0 && err != -ECONNREFUSED);
+        mempool_zone_destroy(z_pdu);
+        mempool_zone_destroy(z_error);
 
-        return err;
+        return 0;
 }
 
 static int
@@ -881,7 +938,7 @@ iscsi_if_rx(struct sock *sk, int len)
 {
         struct sk_buff *skb;
 
-        down(&rx_queue_sema);
+        mutex_lock(&rx_queue_mutex);
         while ((skb = skb_dequeue(&sk->sk_receive_queue)) != NULL) {
                 while (skb->len >= NLMSG_SPACE(0)) {
                         int err;
@@ -915,17 +972,20 @@ iscsi_if_rx(struct sock *sk, int len)
                                 err = iscsi_if_send_reply(
                                         NETLINK_CREDS(skb)->pid, nlh->nlmsg_seq,
                                         nlh->nlmsg_type, 0, 0, ev, sizeof(*ev));
-                                if (atomic_read(&z_reply.allocated) >=
-                                                z_reply.hiwat)
+                                if (atomic_read(&z_reply->allocated) >=
+                                                z_reply->hiwat)
                                         ev->iferror = -ENOMEM;
                         } while (err < 0 && err != -ECONNREFUSED);
                         skb_pull(skb, rlen);
                 }
                 kfree_skb(skb);
         }
-        up(&rx_queue_sema);
+        mutex_unlock(&rx_queue_mutex);
 }
 
+#define iscsi_cdev_to_conn(_cdev) \
+        iscsi_dev_to_conn(_cdev->dev)
+
 /*
  * iSCSI connection attrs
  */
@@ -934,12 +994,10 @@ static ssize_t								\
 show_conn_int_param_##param(struct class_device *cdev, char *buf)       \
 {                                                                       \
         uint32_t value = 0;                                             \
-        struct iscsi_if_conn *conn = iscsi_cdev_to_if_conn(cdev);       \
-        struct iscsi_internal *priv;                                    \
+        struct iscsi_cls_conn *conn = iscsi_cdev_to_conn(cdev);         \
+        struct iscsi_transport *t = conn->transport;                    \
                                                                         \
-        priv = to_iscsi_internal(conn->host->transportt);               \
-        if (priv->param_mask & (1 << param))                            \
-                priv->iscsi_transport->get_param(conn->connh, param, &value); \
+        t->get_conn_param(conn->dd_data, param, &value);                \
         return snprintf(buf, 20, format"\n", value);                    \
 }
 
@@ -954,6 +1012,9 @@ iscsi_conn_int_attr(data_digest, ISCSI_PARAM_DATADGST_EN, "%d");
 iscsi_conn_int_attr(ifmarker, ISCSI_PARAM_IFMARKER_EN, "%d");
 iscsi_conn_int_attr(ofmarker, ISCSI_PARAM_OFMARKER_EN, "%d");
 
+#define iscsi_cdev_to_session(_cdev) \
+        iscsi_dev_to_session(_cdev->dev)
+
 /*
  * iSCSI session attrs
  */
@@ -962,20 +1023,11 @@ static ssize_t								\
 show_session_int_param_##param(struct class_device *cdev, char *buf)    \
 {                                                                       \
         uint32_t value = 0;                                             \
-        struct iscsi_if_session *session = iscsi_cdev_to_if_session(cdev); \
-        struct Scsi_Host *shost = iscsi_if_session_to_shost(session);   \
-        struct iscsi_internal *priv = to_iscsi_internal(shost->transportt); \
-        struct iscsi_if_conn *conn = NULL;                              \
-        unsigned long  flags;                                           \
-                                                                        \
-        spin_lock_irqsave(&connlock, flags);                            \
-        if (!list_empty(&session->connections))                         \
-                conn = list_entry(session->connections.next,            \
-                                  struct iscsi_if_conn, session_list);  \
-        spin_unlock_irqrestore(&connlock, flags);                       \
+        struct iscsi_cls_session *session = iscsi_cdev_to_session(cdev);        \
+        struct Scsi_Host *shost = iscsi_session_to_shost(session);      \
+        struct iscsi_transport *t = session->transport;                 \
                                                                         \
-        if (conn && (priv->param_mask & (1 << param)))                  \
-                priv->iscsi_transport->get_param(conn->connh, param, &value);\
+        t->get_session_param(shost, param, &value);                     \
         return snprintf(buf, 20, format"\n", value);                    \
 }
 
@@ -1004,23 +1056,18 @@ iscsi_session_int_attr(erl, ISCSI_PARAM_ERL, "%d");
                 count++;                                                \
         }
 
-static int iscsi_is_session_dev(const struct device *dev)
-{
-        return dev->release == iscsi_if_session_dev_release;
-}
-
 static int iscsi_session_match(struct attribute_container *cont,
                            struct device *dev)
 {
-        struct iscsi_if_session *session;
+        struct iscsi_cls_session *session;
         struct Scsi_Host *shost;
         struct iscsi_internal *priv;
 
         if (!iscsi_is_session_dev(dev))
                 return 0;
 
-        session = iscsi_dev_to_if_session(dev);
-        shost = iscsi_if_session_to_shost(session);
+        session = iscsi_dev_to_session(dev);
+        shost = iscsi_session_to_shost(session);
         if (!shost->transportt)
                 return 0;
 
@@ -1031,23 +1078,21 @@ static int iscsi_session_match(struct attribute_container *cont,
         return &priv->session_cont.ac == cont;
 }
 
-static int iscsi_is_conn_dev(const struct device *dev)
-{
-        return dev->release == iscsi_if_conn_dev_release;
-}
-
 static int iscsi_conn_match(struct attribute_container *cont,
                            struct device *dev)
 {
-        struct iscsi_if_conn *conn;
+        struct iscsi_cls_session *session;
+        struct iscsi_cls_conn *conn;
         struct Scsi_Host *shost;
         struct iscsi_internal *priv;
 
         if (!iscsi_is_conn_dev(dev))
                 return 0;
 
-        conn = iscsi_dev_to_if_conn(dev);
-        shost = conn->host;
+        conn = iscsi_dev_to_conn(dev);
+        session = iscsi_dev_to_session(conn->dev.parent);
+        shost = iscsi_session_to_shost(session);
+
         if (!shost->transportt)
                 return 0;
 
@@ -1058,7 +1103,8 @@ static int iscsi_conn_match(struct attribute_container *cont,
         return &priv->conn_cont.ac == cont;
 }
 
-int iscsi_register_transport(struct iscsi_transport *tt)
+struct scsi_transport_template *
+iscsi_register_transport(struct iscsi_transport *tt)
 {
         struct iscsi_internal *priv;
         unsigned long flags;
@@ -1068,15 +1114,14 @@ int iscsi_register_transport(struct iscsi_transport *tt)
 
         priv = iscsi_if_transport_lookup(tt);
         if (priv)
-                return -EEXIST;
+                return NULL;
 
         priv = kmalloc(sizeof(*priv), GFP_KERNEL);
         if (!priv)
-                return -ENOMEM;
+                return NULL;
         memset(priv, 0, sizeof(*priv));
         INIT_LIST_HEAD(&priv->list);
         INIT_LIST_HEAD(&priv->sessions);
-        spin_lock_init(&priv->session_lock);
         priv->iscsi_transport = tt;
 
         priv->cdev.class = &iscsi_transport_class;
@@ -1142,13 +1187,13 @@ int iscsi_register_transport(struct iscsi_transport *tt)
         spin_unlock_irqrestore(&iscsi_transport_lock, flags);
 
         printk(KERN_NOTICE "iscsi: registered transport (%s)\n", tt->name);
-        return 0;
+        return &priv->t;
 
 unregister_cdev:
         class_device_unregister(&priv->cdev);
 free_priv:
         kfree(priv);
-        return err;
+        return NULL;
 }
 EXPORT_SYMBOL_GPL(iscsi_register_transport);
 
@@ -1159,19 +1204,11 @@ int iscsi_unregister_transport(struct iscsi_transport *tt)
 
         BUG_ON(!tt);
 
-        down(&rx_queue_sema);
+        mutex_lock(&rx_queue_mutex);
 
         priv = iscsi_if_transport_lookup(tt);
         BUG_ON (!priv);
 
-        spin_lock_irqsave(&priv->session_lock, flags);
-        if (!list_empty(&priv->sessions)) {
-                spin_unlock_irqrestore(&priv->session_lock, flags);
-                up(&rx_queue_sema);
-                return -EPERM;
-        }
-        spin_unlock_irqrestore(&priv->session_lock, flags);
-
         spin_lock_irqsave(&iscsi_transport_lock, flags);
         list_del(&priv->list);
         spin_unlock_irqrestore(&iscsi_transport_lock, flags);
@@ -1181,7 +1218,7 @@ int iscsi_unregister_transport(struct iscsi_transport *tt)
 
         sysfs_remove_group(&priv->cdev.kobj, &iscsi_transport_group);
         class_device_unregister(&priv->cdev);
-        up(&rx_queue_sema);
+        mutex_unlock(&rx_queue_mutex);
 
         return 0;
 }
@@ -1194,14 +1231,14 @@ iscsi_rcv_nl_event(struct notifier_block *this, unsigned long event, void *ptr)
 
         if (event == NETLINK_URELEASE &&
             n->protocol == NETLINK_ISCSI && n->pid) {
-                struct iscsi_if_conn *conn;
+                struct iscsi_cls_conn *conn;
                 unsigned long flags;
 
-                mempool_zone_complete(&z_reply);
+                mempool_zone_complete(z_reply);
                 spin_lock_irqsave(&connlock, flags);
                 list_for_each_entry(conn, &connlist, conn_list) {
-                        mempool_zone_complete(&conn->z_error);
-                        mempool_zone_complete(&conn->z_pdu);
+                        mempool_zone_complete(conn->z_error);
+                        mempool_zone_complete(conn->z_pdu);
                 }
                 spin_unlock_irqrestore(&connlock, flags);
         }
@@ -1234,15 +1271,15 @@ static __init int iscsi_transport_init(void)
                 goto unregister_session_class;
 
         nls = netlink_kernel_create(NETLINK_ISCSI, 1, iscsi_if_rx,
-                                    THIS_MODULE);
+                        THIS_MODULE);
         if (!nls) {
                 err = -ENOBUFS;
                 goto unregister_notifier;
         }
 
-        err = mempool_zone_init(&z_reply, Z_MAX_REPLY,
+        z_reply = mempool_zone_init(Z_MAX_REPLY,
                 NLMSG_SPACE(sizeof(struct iscsi_uevent)), Z_HIWAT_REPLY);
-        if (!err)
+        if (z_reply)
                 return 0;
 
         sock_release(nls->sk_socket);
@@ -1259,7 +1296,7 @@ unregister_transport_class:
 
 static void __exit iscsi_transport_exit(void)
 {
-        mempool_destroy(z_reply.pool);
+        mempool_zone_destroy(z_reply);
         sock_release(nls->sk_socket);
         netlink_unregister_notifier(&iscsi_nl_notifier);
         transport_class_unregister(&iscsi_connection_class);
diff --git a/drivers/scsi/scsi_transport_sas.c b/drivers/scsi/scsi_transport_sas.c
index edabbd05d258..a3e0b7bc2d7b 100644
--- a/drivers/scsi/scsi_transport_sas.c
+++ b/drivers/scsi/scsi_transport_sas.c
@@ -29,6 +29,7 @@
 #include <linux/slab.h>
 #include <linux/string.h>
 
+#include <scsi/scsi.h>
 #include <scsi/scsi_device.h>
 #include <scsi/scsi_host.h>
 #include <scsi/scsi_transport.h>
@@ -62,7 +63,7 @@ struct sas_internal {
 
 struct sas_host_attrs {
         struct list_head rphy_list;
-        spinlock_t lock;
+        struct mutex lock;
         u32 next_target_id;
 };
 #define to_sas_host_attrs(host) ((struct sas_host_attrs *)(host)->shost_data)
@@ -165,7 +166,7 @@ static int sas_host_setup(struct transport_container *tc, struct device *dev,
         struct sas_host_attrs *sas_host = to_sas_host_attrs(shost);
 
         INIT_LIST_HEAD(&sas_host->rphy_list);
-        spin_lock_init(&sas_host->lock);
+        mutex_init(&sas_host->lock);
         sas_host->next_target_id = 0;
         return 0;
 }
@@ -626,7 +627,7 @@ int sas_rphy_add(struct sas_rphy *rphy)
         transport_add_device(&rphy->dev);
         transport_configure_device(&rphy->dev);
 
-        spin_lock(&sas_host->lock);
+        mutex_lock(&sas_host->lock);
         list_add_tail(&rphy->list, &sas_host->rphy_list);
         if (identify->device_type == SAS_END_DEVICE &&
             (identify->target_port_protocols &
@@ -634,10 +635,10 @@ int sas_rphy_add(struct sas_rphy *rphy)
                 rphy->scsi_target_id = sas_host->next_target_id++;
         else
                 rphy->scsi_target_id = -1;
-        spin_unlock(&sas_host->lock);
+        mutex_unlock(&sas_host->lock);
 
         if (rphy->scsi_target_id != -1) {
-                scsi_scan_target(&rphy->dev, parent->number,
+                scsi_scan_target(&rphy->dev, parent->port_identifier,
                                 rphy->scsi_target_id, ~0, 0);
         }
 
@@ -661,9 +662,9 @@ void sas_rphy_free(struct sas_rphy *rphy)
         struct Scsi_Host *shost = dev_to_shost(rphy->dev.parent->parent);
         struct sas_host_attrs *sas_host = to_sas_host_attrs(shost);
 
-        spin_lock(&sas_host->lock);
+        mutex_lock(&sas_host->lock);
         list_del(&rphy->list);
-        spin_unlock(&sas_host->lock);
+        mutex_unlock(&sas_host->lock);
 
         transport_destroy_device(&rphy->dev);
         put_device(rphy->dev.parent);
@@ -687,15 +688,27 @@ sas_rphy_delete(struct sas_rphy *rphy)
         struct Scsi_Host *shost = dev_to_shost(parent->dev.parent);
         struct sas_host_attrs *sas_host = to_sas_host_attrs(shost);
 
-        scsi_remove_target(dev);
+        switch (rphy->identify.device_type) {
+        case SAS_END_DEVICE:
+                scsi_remove_target(dev);
+                break;
+        case SAS_EDGE_EXPANDER_DEVICE:
+        case SAS_FANOUT_EXPANDER_DEVICE:
+                device_for_each_child(dev, NULL, do_sas_phy_delete);
+                break;
+        default:
+                break;
+        }
 
         transport_remove_device(dev);
         device_del(dev);
         transport_destroy_device(dev);
 
-        spin_lock(&sas_host->lock);
+        mutex_lock(&sas_host->lock);
         list_del(&rphy->list);
-        spin_unlock(&sas_host->lock);
+        mutex_unlock(&sas_host->lock);
+
+        parent->rphy = NULL;
 
         put_device(&parent->dev);
 }
@@ -719,23 +732,28 @@ EXPORT_SYMBOL(scsi_is_sas_rphy);
  * SCSI scan helper
  */
 
-static struct device *sas_target_parent(struct Scsi_Host *shost,
-                                        int channel, uint id)
+static int sas_user_scan(struct Scsi_Host *shost, uint channel,
+                uint id, uint lun)
 {
         struct sas_host_attrs *sas_host = to_sas_host_attrs(shost);
         struct sas_rphy *rphy;
-        struct device *dev = NULL;
 
-        spin_lock(&sas_host->lock);
+        mutex_lock(&sas_host->lock);
         list_for_each_entry(rphy, &sas_host->rphy_list, list) {
                 struct sas_phy *parent = dev_to_phy(rphy->dev.parent);
-                if (parent->number == channel &&
-                    rphy->scsi_target_id == id)
-                        dev = &rphy->dev;
+
+                if (rphy->scsi_target_id == -1)
+                        continue;
+
+                if ((channel == SCAN_WILD_CARD || channel == parent->port_identifier) &&
+                    (id == SCAN_WILD_CARD || id == rphy->scsi_target_id)) {
+                        scsi_scan_target(&rphy->dev, parent->port_identifier,
+                                         rphy->scsi_target_id, lun, 1);
+                }
         }
-        spin_unlock(&sas_host->lock);
+        mutex_unlock(&sas_host->lock);
 
-        return dev;
+        return 0;
 }
 
 
@@ -780,7 +798,7 @@ sas_attach_transport(struct sas_function_template *ft)
                 return NULL;
         memset(i, 0, sizeof(struct sas_internal));
 
-        i->t.target_parent = sas_target_parent;
+        i->t.user_scan = sas_user_scan;
 
         i->t.host_attrs.ac.attrs = &i->host_attrs[0];
         i->t.host_attrs.ac.class = &sas_host_class.class;
diff --git a/drivers/scsi/scsi_transport_spi.c b/drivers/scsi/scsi_transport_spi.c
index 46da6fe10ad5..7ee95eb83dda 100644
--- a/drivers/scsi/scsi_transport_spi.c
+++ b/drivers/scsi/scsi_transport_spi.c
@@ -24,7 +24,7 @@
 #include <linux/module.h>
 #include <linux/workqueue.h>
 #include <linux/blkdev.h>
-#include <asm/semaphore.h>
+#include <linux/mutex.h>
 #include <scsi/scsi.h>
 #include "scsi_priv.h"
 #include <scsi/scsi_device.h>
@@ -48,7 +48,7 @@
 
 /* Private data accessors (keep these out of the header file) */
 #define spi_dv_pending(x) (((struct spi_transport_attrs *)&(x)->starget_data)->dv_pending)
-#define spi_dv_sem(x) (((struct spi_transport_attrs *)&(x)->starget_data)->dv_sem)
+#define spi_dv_mutex(x) (((struct spi_transport_attrs *)&(x)->starget_data)->dv_mutex)
 
 struct spi_internal {
         struct scsi_transport_template t;
@@ -242,7 +242,7 @@ static int spi_setup_transport_attrs(struct transport_container *tc,
         spi_hold_mcs(starget) = 0;
         spi_dv_pending(starget) = 0;
         spi_initial_dv(starget) = 0;
-        init_MUTEX(&spi_dv_sem(starget));
+        mutex_init(&spi_dv_mutex(starget));
 
         return 0;
 }
@@ -915,7 +915,7 @@ spi_dv_device(struct scsi_device *sdev)
         scsi_target_quiesce(starget);
 
         spi_dv_pending(starget) = 1;
-        down(&spi_dv_sem(starget));
+        mutex_lock(&spi_dv_mutex(starget));
 
         starget_printk(KERN_INFO, starget, "Beginning Domain Validation\n");
 
@@ -923,7 +923,7 @@ spi_dv_device(struct scsi_device *sdev)
 
         starget_printk(KERN_INFO, starget, "Ending Domain Validation\n");
 
-        up(&spi_dv_sem(starget));
+        mutex_unlock(&spi_dv_mutex(starget));
         spi_dv_pending(starget) = 0;
 
         scsi_target_resume(starget);
@@ -1075,7 +1075,7 @@ static const char * const extended_msgs[] = {
 /* 0x04 */ "Parallel Protocol Request"
 };
 
-void print_nego(const unsigned char *msg, int per, int off, int width)
+static void print_nego(const unsigned char *msg, int per, int off, int width)
 {
         if (per) {
                 char buf[20];
diff --git a/drivers/scsi/sd.c b/drivers/scsi/sd.c
index 4c5127ed379c..930db398d107 100644
--- a/drivers/scsi/sd.c
+++ b/drivers/scsi/sd.c
@@ -49,6 +49,7 @@
 #include <linux/blkpg.h>
 #include <linux/kref.h>
 #include <linux/delay.h>
+#include <linux/mutex.h>
 #include <asm/uaccess.h>
 
 #include <scsi/scsi.h>
@@ -111,7 +112,7 @@ static DEFINE_SPINLOCK(sd_index_lock);
 /* This semaphore is used to mediate the 0->1 reference get in the
  * face of object destruction (i.e. we can't allow a get on an
  * object after last put) */
-static DECLARE_MUTEX(sd_ref_sem);
+static DEFINE_MUTEX(sd_ref_mutex);
 
 static int sd_revalidate_disk(struct gendisk *disk);
 static void sd_rw_intr(struct scsi_cmnd * SCpnt);
@@ -193,9 +194,9 @@ static struct scsi_disk *scsi_disk_get(struct gendisk *disk)
 {
         struct scsi_disk *sdkp;
 
-        down(&sd_ref_sem);
+        mutex_lock(&sd_ref_mutex);
         sdkp = __scsi_disk_get(disk);
-        up(&sd_ref_sem);
+        mutex_unlock(&sd_ref_mutex);
         return sdkp;
 }
 
@@ -203,11 +204,11 @@ static struct scsi_disk *scsi_disk_get_from_dev(struct device *dev)
 {
         struct scsi_disk *sdkp;
 
-        down(&sd_ref_sem);
+        mutex_lock(&sd_ref_mutex);
         sdkp = dev_get_drvdata(dev);
         if (sdkp)
                 sdkp = __scsi_disk_get(sdkp->disk);
-        up(&sd_ref_sem);
+        mutex_unlock(&sd_ref_mutex);
         return sdkp;
 }
 
@@ -215,10 +216,10 @@ static void scsi_disk_put(struct scsi_disk *sdkp)
 {
         struct scsi_device *sdev = sdkp->device;
 
-        down(&sd_ref_sem);
+        mutex_lock(&sd_ref_mutex);
         kref_put(&sdkp->kref, scsi_disk_release);
         scsi_device_put(sdev);
-        up(&sd_ref_sem);
+        mutex_unlock(&sd_ref_mutex);
 }
 
 /**
@@ -231,34 +232,12 @@ static void scsi_disk_put(struct scsi_disk *sdkp)
  **/
 static int sd_init_command(struct scsi_cmnd * SCpnt)
 {
-        unsigned int this_count, timeout;
-        struct gendisk *disk;
-        sector_t block;
         struct scsi_device *sdp = SCpnt->device;
         struct request *rq = SCpnt->request;
-
-        timeout = sdp->timeout;
-
-        /*
-         * SG_IO from block layer already setup, just copy cdb basically
-         */
-        if (blk_pc_request(rq)) {
-                scsi_setup_blk_pc_cmnd(SCpnt);
-                if (rq->timeout)
-                        timeout = rq->timeout;
-
-                goto queue;
-        }
-
-        /*
-         * we only do REQ_CMD and REQ_BLOCK_PC
-         */
-        if (!blk_fs_request(rq))
-                return 0;
-
-        disk = rq->rq_disk;
-        block = rq->sector;
-        this_count = SCpnt->request_bufflen >> 9;
+        struct gendisk *disk = rq->rq_disk;
+        sector_t block = rq->sector;
+        unsigned int this_count = SCpnt->request_bufflen >> 9;
+        unsigned int timeout = sdp->timeout;
 
         SCSI_LOG_HLQUEUE(1, printk("sd_init_command: disk=%s, block=%llu, "
                             "count=%d\n", disk->disk_name,
@@ -401,8 +380,6 @@ static int sd_init_command(struct scsi_cmnd * SCpnt)
         SCpnt->transfersize = sdp->sector_size;
         SCpnt->underflow = this_count << 9;
         SCpnt->allowed = SD_MAX_RETRIES;
-
-queue:
         SCpnt->timeout_per_command = timeout;
 
         /*
@@ -836,15 +813,7 @@ static void sd_rw_intr(struct scsi_cmnd * SCpnt)
            relatively rare error condition, no care is taken to avoid
            unnecessary additional work such as memcpy's that could be avoided.
          */
-
-        /* 
-         * If SG_IO from block layer then set good_bytes to stop retries;
-         * else if errors, check them, and if necessary prepare for
-         * (partial) retries.
-         */
-        if (blk_pc_request(SCpnt->request))
-                good_bytes = this_count;
-        else if (driver_byte(result) != 0 &&
+        if (driver_byte(result) != 0 &&
                  sense_valid && !sense_deferred) {
                 switch (sshdr.sense_key) {
                 case MEDIUM_ERROR:
@@ -1635,10 +1604,10 @@ static int sd_remove(struct device *dev)
         del_gendisk(sdkp->disk);
         sd_shutdown(dev);
 
-        down(&sd_ref_sem);
+        mutex_lock(&sd_ref_mutex);
         dev_set_drvdata(dev, NULL);
         kref_put(&sdkp->kref, scsi_disk_release);
-        up(&sd_ref_sem);
+        mutex_unlock(&sd_ref_mutex);
 
         return 0;
 }
@@ -1647,7 +1616,7 @@ static int sd_remove(struct device *dev)
  *      scsi_disk_release - Called to free the scsi_disk structure
  *      @kref: pointer to embedded kref
  *
- *      sd_ref_sem must be held entering this routine.  Because it is
+ *      sd_ref_mutex must be held entering this routine.  Because it is
  *      called on last put, you should always use the scsi_disk_get()
  *      scsi_disk_put() helpers which manipulate the semaphore directly
  *      and never do a direct kref_put().
diff --git a/drivers/scsi/sr.c b/drivers/scsi/sr.c
index a4d9be7c6874..997f8e30509b 100644
--- a/drivers/scsi/sr.c
+++ b/drivers/scsi/sr.c
@@ -44,6 +44,7 @@
 #include <linux/interrupt.h>
 #include <linux/init.h>
 #include <linux/blkdev.h>
+#include <linux/mutex.h>
 #include <asm/uaccess.h>
 
 #include <scsi/scsi.h>
@@ -90,7 +91,7 @@ static DEFINE_SPINLOCK(sr_index_lock);
 /* This semaphore is used to mediate the 0->1 reference get in the
  * face of object destruction (i.e. we can't allow a get on an
  * object after last put) */
-static DECLARE_MUTEX(sr_ref_sem);
+static DEFINE_MUTEX(sr_ref_mutex);
 
 static int sr_open(struct cdrom_device_info *, int);
 static void sr_release(struct cdrom_device_info *);
@@ -133,7 +134,7 @@ static inline struct scsi_cd *scsi_cd_get(struct gendisk *disk)
 {
         struct scsi_cd *cd = NULL;
 
-        down(&sr_ref_sem);
+        mutex_lock(&sr_ref_mutex);
         if (disk->private_data == NULL)
                 goto out;
         cd = scsi_cd(disk);
@@ -146,18 +147,18 @@ static inline struct scsi_cd *scsi_cd_get(struct gendisk *disk)
         kref_put(&cd->kref, sr_kref_release);
         cd = NULL;
  out:
-        up(&sr_ref_sem);
+        mutex_unlock(&sr_ref_mutex);
         return cd;
 }
 
-static inline void scsi_cd_put(struct scsi_cd *cd)
+static void scsi_cd_put(struct scsi_cd *cd)
 {
         struct scsi_device *sdev = cd->device;
 
-        down(&sr_ref_sem);
+        mutex_lock(&sr_ref_mutex);
         kref_put(&cd->kref, sr_kref_release);
         scsi_device_put(sdev);
-        up(&sr_ref_sem);
+        mutex_unlock(&sr_ref_mutex);
 }
 
 /*
@@ -237,8 +238,6 @@ static void rw_intr(struct scsi_cmnd * SCpnt)
                 case ILLEGAL_REQUEST:
                         if (!(SCpnt->sense_buffer[0] & 0x90))
                                 break;
-                        if (!blk_fs_request(SCpnt->request))
-                                break;
                         error_sector = (SCpnt->sense_buffer[3] << 24) |
                                 (SCpnt->sense_buffer[4] << 16) |
                                 (SCpnt->sense_buffer[5] << 8) |
@@ -317,23 +316,6 @@ static int sr_init_command(struct scsi_cmnd * SCpnt)
         }
 
         /*
-         * these are already setup, just copy cdb basically
-         */
-        if (SCpnt->request->flags & REQ_BLOCK_PC) {
-                scsi_setup_blk_pc_cmnd(SCpnt);
-
-                if (SCpnt->timeout_per_command)
-                        timeout = SCpnt->timeout_per_command;
-
-                goto queue;
-        }
-
-        if (!(SCpnt->request->flags & REQ_CMD)) {
-                blk_dump_rq_flags(SCpnt->request, "sr unsup command");
-                return 0;
-        }
-
-        /*
          * we do lazy blocksize switching (when reading XA sectors,
          * see CDROMREADMODE2 ioctl) 
          */
@@ -421,8 +403,6 @@ static int sr_init_command(struct scsi_cmnd * SCpnt)
          */
         SCpnt->transfersize = cd->device->sector_size;
         SCpnt->underflow = this_count << 9;
-
-queue:
         SCpnt->allowed = MAX_RETRIES;
         SCpnt->timeout_per_command = timeout;
 
@@ -762,8 +742,9 @@ static void get_capabilities(struct scsi_cd *cd)
                 /* failed, drive doesn't have capabilities mode page */
                 cd->cdi.speed = 1;
                 cd->cdi.mask |= (CDC_CD_R | CDC_CD_RW | CDC_DVD_R |
-                                         CDC_DVD | CDC_DVD_RAM |
-                                         CDC_SELECT_DISC | CDC_SELECT_SPEED);
+                                 CDC_DVD | CDC_DVD_RAM |
+                                 CDC_SELECT_DISC | CDC_SELECT_SPEED |
+                                 CDC_MRW | CDC_MRW_W | CDC_RAM);
                 kfree(buffer);
                 printk("%s: scsi-1 drive\n", cd->cdi.name);
                 return;
@@ -845,7 +826,7 @@ static int sr_packet(struct cdrom_device_info *cdi,
  *      sr_kref_release - Called to free the scsi_cd structure
  *      @kref: pointer to embedded kref
  *
- *      sr_ref_sem must be held entering this routine.  Because it is
+ *      sr_ref_mutex must be held entering this routine.  Because it is
  *      called on last put, you should always use the scsi_cd_get()
  *      scsi_cd_put() helpers which manipulate the semaphore directly
  *      and never do a direct kref_put().
@@ -874,9 +855,9 @@ static int sr_remove(struct device *dev)
 
         del_gendisk(cd->disk);
 
-        down(&sr_ref_sem);
+        mutex_lock(&sr_ref_mutex);
         kref_put(&cd->kref, sr_kref_release);
-        up(&sr_ref_sem);
+        mutex_unlock(&sr_ref_mutex);
 
         return 0;
 }
diff --git a/drivers/scsi/sr_ioctl.c b/drivers/scsi/sr_ioctl.c
index 6e45ac3c43c5..5d02ff4db6cc 100644
--- a/drivers/scsi/sr_ioctl.c
+++ b/drivers/scsi/sr_ioctl.c
@@ -31,6 +31,79 @@ static int xa_test = 0;
 
 module_param(xa_test, int, S_IRUGO | S_IWUSR);
 
+/* primitive to determine whether we need to have GFP_DMA set based on
+ * the status of the unchecked_isa_dma flag in the host structure */
+#define SR_GFP_DMA(cd) (((cd)->device->host->unchecked_isa_dma) ? GFP_DMA : 0)
+
+
+static int sr_read_tochdr(struct cdrom_device_info *cdi,
+                struct cdrom_tochdr *tochdr)
+{
+        struct scsi_cd *cd = cdi->handle;
+        struct packet_command cgc;
+        int result;
+        unsigned char *buffer;
+
+        buffer = kmalloc(32, GFP_KERNEL | SR_GFP_DMA(cd));
+        if (!buffer)
+                return -ENOMEM;
+
+        memset(&cgc, 0, sizeof(struct packet_command));
+        cgc.timeout = IOCTL_TIMEOUT;
+        cgc.cmd[0] = GPCMD_READ_TOC_PMA_ATIP;
+        cgc.cmd[8] = 12;                /* LSB of length */
+        cgc.buffer = buffer;
+        cgc.buflen = 12;
+        cgc.quiet = 1;
+        cgc.data_direction = DMA_FROM_DEVICE;
+
+        result = sr_do_ioctl(cd, &cgc);
+
+        tochdr->cdth_trk0 = buffer[2];
+        tochdr->cdth_trk1 = buffer[3];
+
+        kfree(buffer);
+        return result;
+}
+
+static int sr_read_tocentry(struct cdrom_device_info *cdi,
+                struct cdrom_tocentry *tocentry)
+{
+        struct scsi_cd *cd = cdi->handle;
+        struct packet_command cgc;
+        int result;
+        unsigned char *buffer;
+
+        buffer = kmalloc(32, GFP_KERNEL | SR_GFP_DMA(cd));
+        if (!buffer)
+                return -ENOMEM;
+
+        memset(&cgc, 0, sizeof(struct packet_command));
+        cgc.timeout = IOCTL_TIMEOUT;
+        cgc.cmd[0] = GPCMD_READ_TOC_PMA_ATIP;
+        cgc.cmd[1] |= (tocentry->cdte_format == CDROM_MSF) ? 0x02 : 0;
+        cgc.cmd[6] = tocentry->cdte_track;
+        cgc.cmd[8] = 12;                /* LSB of length */
+        cgc.buffer = buffer;
+        cgc.buflen = 12;
+        cgc.data_direction = DMA_FROM_DEVICE;
+
+        result = sr_do_ioctl(cd, &cgc);
+
+        tocentry->cdte_ctrl = buffer[5] & 0xf;
+        tocentry->cdte_adr = buffer[5] >> 4;
+        tocentry->cdte_datamode = (tocentry->cdte_ctrl & 0x04) ? 1 : 0;
+        if (tocentry->cdte_format == CDROM_MSF) {
+                tocentry->cdte_addr.msf.minute = buffer[9];
+                tocentry->cdte_addr.msf.second = buffer[10];
+                tocentry->cdte_addr.msf.frame = buffer[11];
+        } else
+                tocentry->cdte_addr.lba = (((((buffer[8] << 8) + buffer[9]) << 8)
+                        + buffer[10]) << 8) + buffer[11];
+
+        kfree(buffer);
+        return result;
+}
 
 #define IOCTL_RETRIES 3
 
@@ -45,7 +118,8 @@ static int sr_fake_playtrkind(struct cdrom_device_info *cdi, struct cdrom_ti *ti
         struct packet_command cgc;
         int ntracks, ret;
 
-        if ((ret = sr_audio_ioctl(cdi, CDROMREADTOCHDR, &tochdr)))
+        ret = sr_read_tochdr(cdi, &tochdr);
+        if (ret)
                 return ret;
 
         ntracks = tochdr.cdth_trk1 - tochdr.cdth_trk0 + 1;
@@ -60,9 +134,11 @@ static int sr_fake_playtrkind(struct cdrom_device_info *cdi, struct cdrom_ti *ti
         trk1_te.cdte_track = ti->cdti_trk1;
         trk1_te.cdte_format = CDROM_MSF;
         
-        if ((ret = sr_audio_ioctl(cdi, CDROMREADTOCENTRY, &trk0_te)))
+        ret = sr_read_tocentry(cdi, &trk0_te);
+        if (ret)
                 return ret;
-        if ((ret = sr_audio_ioctl(cdi, CDROMREADTOCENTRY, &trk1_te)))
+        ret = sr_read_tocentry(cdi, &trk1_te);
+        if (ret)
                 return ret;
 
         memset(&cgc, 0, sizeof(struct packet_command));
@@ -78,6 +154,30 @@ static int sr_fake_playtrkind(struct cdrom_device_info *cdi, struct cdrom_ti *ti
         return sr_do_ioctl(cdi->handle, &cgc);
 }
 
+static int sr_play_trkind(struct cdrom_device_info *cdi,
+                struct cdrom_ti *ti)
+
+{
+        struct scsi_cd *cd = cdi->handle;
+        struct packet_command cgc;
+        int result;
+
+        memset(&cgc, 0, sizeof(struct packet_command));
+        cgc.timeout = IOCTL_TIMEOUT;
+        cgc.cmd[0] = GPCMD_PLAYAUDIO_TI;
+        cgc.cmd[4] = ti->cdti_trk0;
+        cgc.cmd[5] = ti->cdti_ind0;
+        cgc.cmd[7] = ti->cdti_trk1;
+        cgc.cmd[8] = ti->cdti_ind1;
+        cgc.data_direction = DMA_NONE;
+
+        result = sr_do_ioctl(cd, &cgc);
+        if (result == -EDRIVE_CANT_DO_THIS)
+                result = sr_fake_playtrkind(cdi, ti);
+
+        return result;
+}
+
 /* We do our own retries because we want to know what the specific
    error code is.  Normally the UNIT_ATTENTION code will automatically
    clear after one error */
@@ -229,13 +329,14 @@ int sr_disk_status(struct cdrom_device_info *cdi)
         int i, rc, have_datatracks = 0;
 
         /* look for data tracks */
-        if (0 != (rc = sr_audio_ioctl(cdi, CDROMREADTOCHDR, &toc_h)))
+        rc = sr_read_tochdr(cdi, &toc_h);
+        if (rc)
                 return (rc == -ENOMEDIUM) ? CDS_NO_DISC : CDS_NO_INFO;
 
         for (i = toc_h.cdth_trk0; i <= toc_h.cdth_trk1; i++) {
                 toc_e.cdte_track = i;
                 toc_e.cdte_format = CDROM_LBA;
-                if (sr_audio_ioctl(cdi, CDROMREADTOCENTRY, &toc_e))
+                if (sr_read_tocentry(cdi, &toc_e))
                         return CDS_NO_INFO;
                 if (toc_e.cdte_ctrl & CDROM_DATA_TRACK) {
                         have_datatracks = 1;
@@ -262,10 +363,6 @@ int sr_get_last_session(struct cdrom_device_info *cdi,
         return 0;
 }
 
-/* primitive to determine whether we need to have GFP_DMA set based on
- * the status of the unchecked_isa_dma flag in the host structure */
-#define SR_GFP_DMA(cd) (((cd)->device->host->unchecked_isa_dma) ? GFP_DMA : 0)
-
 int sr_get_mcn(struct cdrom_device_info *cdi, struct cdrom_mcn *mcn)
 {
         Scsi_CD *cd = cdi->handle;
@@ -329,93 +426,16 @@ int sr_select_speed(struct cdrom_device_info *cdi, int speed)
 
 int sr_audio_ioctl(struct cdrom_device_info *cdi, unsigned int cmd, void *arg)
 {
-        Scsi_CD *cd = cdi->handle;
-        struct packet_command cgc;
-        int result;
-        unsigned char *buffer = kmalloc(32, GFP_KERNEL | SR_GFP_DMA(cd));
-
-        if (!buffer)
-                return -ENOMEM;
-
-        memset(&cgc, 0, sizeof(struct packet_command));
-        cgc.timeout = IOCTL_TIMEOUT;
-
         switch (cmd) {
         case CDROMREADTOCHDR:
-                {
-                        struct cdrom_tochdr *tochdr = (struct cdrom_tochdr *) arg;
-
-                        cgc.cmd[0] = GPCMD_READ_TOC_PMA_ATIP;
-                        cgc.cmd[8] = 12;                /* LSB of length */
-                        cgc.buffer = buffer;
-                        cgc.buflen = 12;
-                        cgc.quiet = 1;
-                        cgc.data_direction = DMA_FROM_DEVICE;
-
-                        result = sr_do_ioctl(cd, &cgc);
-
-                        tochdr->cdth_trk0 = buffer[2];
-                        tochdr->cdth_trk1 = buffer[3];
-
-                        break;
-                }
-
+                return sr_read_tochdr(cdi, arg);
         case CDROMREADTOCENTRY:
-                {
-                        struct cdrom_tocentry *tocentry = (struct cdrom_tocentry *) arg;
-
-                        cgc.cmd[0] = GPCMD_READ_TOC_PMA_ATIP;
-                        cgc.cmd[1] |= (tocentry->cdte_format == CDROM_MSF) ? 0x02 : 0;
-                        cgc.cmd[6] = tocentry->cdte_track;
-                        cgc.cmd[8] = 12;                /* LSB of length */
-                        cgc.buffer = buffer;
-                        cgc.buflen = 12;
-                        cgc.data_direction = DMA_FROM_DEVICE;
-
-                        result = sr_do_ioctl(cd, &cgc);
-
-                        tocentry->cdte_ctrl = buffer[5] & 0xf;
-                        tocentry->cdte_adr = buffer[5] >> 4;
-                        tocentry->cdte_datamode = (tocentry->cdte_ctrl & 0x04) ? 1 : 0;
-                        if (tocentry->cdte_format == CDROM_MSF) {
-                                tocentry->cdte_addr.msf.minute = buffer[9];
-                                tocentry->cdte_addr.msf.second = buffer[10];
-                                tocentry->cdte_addr.msf.frame = buffer[11];
-                        } else
-                                tocentry->cdte_addr.lba = (((((buffer[8] << 8) + buffer[9]) << 8)
-                                        + buffer[10]) << 8) + buffer[11];
-
-                        break;
-                }
-
-        case CDROMPLAYTRKIND: {
-                struct cdrom_ti* ti = (struct cdrom_ti*)arg;
-
-                cgc.cmd[0] = GPCMD_PLAYAUDIO_TI;
-                cgc.cmd[4] = ti->cdti_trk0;
-                cgc.cmd[5] = ti->cdti_ind0;
-                cgc.cmd[7] = ti->cdti_trk1;
-                cgc.cmd[8] = ti->cdti_ind1;
-                cgc.data_direction = DMA_NONE;
-
-                result = sr_do_ioctl(cd, &cgc);
-                if (result == -EDRIVE_CANT_DO_THIS)
-                        result = sr_fake_playtrkind(cdi, ti);
-
-                break;
-        }
-
+                return sr_read_tocentry(cdi, arg);
+        case CDROMPLAYTRKIND:
+                return sr_play_trkind(cdi, arg);
         default:
-                result = -EINVAL;
+                return -EINVAL;
         }
-
-#if 0
-        if (result)
-                printk("DEBUG: sr_audio: result for ioctl %x: %x\n", cmd, result);
-#endif
-
-        kfree(buffer);
-        return result;
 }
 
 /* -----------------------------------------------------------------------
diff --git a/drivers/scsi/st.c b/drivers/scsi/st.c
index c4aade8f5345..13b1d3aac265 100644
--- a/drivers/scsi/st.c
+++ b/drivers/scsi/st.c
@@ -38,6 +38,7 @@ static const char *verstr = "20050830";
 #include <linux/devfs_fs_kernel.h>
 #include <linux/cdev.h>
 #include <linux/delay.h>
+#include <linux/mutex.h>
 
 #include <asm/uaccess.h>
 #include <asm/dma.h>
@@ -193,7 +194,6 @@ static int sgl_unmap_user_pages(struct scatterlist *, const unsigned int, int);
 
 static int st_probe(struct device *);
 static int st_remove(struct device *);
-static int st_init_command(struct scsi_cmnd *);
 
 static void do_create_driverfs_files(void);
 static void do_remove_driverfs_files(void);
@@ -206,7 +206,6 @@ static struct scsi_driver st_template = {
                 .probe          = st_probe,
                 .remove         = st_remove,
         },
-        .init_command           = st_init_command,
 };
 
 static int st_compression(struct scsi_tape *, int);
@@ -220,7 +219,7 @@ static void scsi_tape_release(struct kref *);
 
 #define to_scsi_tape(obj) container_of(obj, struct scsi_tape, kref)
 
-static DECLARE_MUTEX(st_ref_sem);
+static DEFINE_MUTEX(st_ref_mutex);
 
 
 #include "osst_detect.h"
@@ -237,7 +236,7 @@ static struct scsi_tape *scsi_tape_get(int dev)
 {
         struct scsi_tape *STp = NULL;
 
-        down(&st_ref_sem);
+        mutex_lock(&st_ref_mutex);
         write_lock(&st_dev_arr_lock);
 
         if (dev < st_dev_max && scsi_tapes != NULL)
@@ -259,7 +258,7 @@ out_put:
         STp = NULL;
 out:
         write_unlock(&st_dev_arr_lock);
-        up(&st_ref_sem);
+        mutex_unlock(&st_ref_mutex);
         return STp;
 }
 
@@ -267,10 +266,10 @@ static void scsi_tape_put(struct scsi_tape *STp)
 {
         struct scsi_device *sdev = STp->device;
 
-        down(&st_ref_sem);
+        mutex_lock(&st_ref_mutex);
         kref_put(&STp->kref, scsi_tape_release);
         scsi_device_put(sdev);
-        up(&st_ref_sem);
+        mutex_unlock(&st_ref_mutex);
 }
 
 struct st_reject_data {
@@ -4141,9 +4140,9 @@ static int st_remove(struct device *dev)
                                 }
                         }
 
-                        down(&st_ref_sem);
+                        mutex_lock(&st_ref_mutex);
                         kref_put(&tpnt->kref, scsi_tape_release);
-                        up(&st_ref_sem);
+                        mutex_unlock(&st_ref_mutex);
                         return 0;
                 }
         }
@@ -4156,7 +4155,7 @@ static int st_remove(struct device *dev)
  *      scsi_tape_release - Called to free the Scsi_Tape structure
  *      @kref: pointer to embedded kref
  *
- *      st_ref_sem must be held entering this routine.  Because it is
+ *      st_ref_mutex must be held entering this routine.  Because it is
  *      called on last put, you should always use the scsi_tape_get()
  *      scsi_tape_put() helpers which manipulate the semaphore directly
  *      and never do a direct kref_put().
@@ -4180,29 +4179,6 @@ static void scsi_tape_release(struct kref *kref)
         return;
 }
 
-static void st_intr(struct scsi_cmnd *SCpnt)
-{
-        /*
-         * The caller should be checking the request's errors
-         * value.
-         */
-        scsi_io_completion(SCpnt, SCpnt->bufflen, 0);
-}
-
-/*
- * st_init_command: only called via the scsi_cmd_ioctl (block SG_IO)
- * interface for REQ_BLOCK_PC commands.
- */
-static int st_init_command(struct scsi_cmnd *SCpnt)
-{
-        if (!(SCpnt->request->flags & REQ_BLOCK_PC))
-                return 0;
-
-        scsi_setup_blk_pc_cmnd(SCpnt);
-        SCpnt->done = st_intr;
-        return 1;
-}
-
 static int __init init_st(void)
 {
         validate_options();
diff --git a/drivers/serial/68328serial.c b/drivers/serial/68328serial.c
index 4dd5c3f98167..8cbf0fc5a225 100644
--- a/drivers/serial/68328serial.c
+++ b/drivers/serial/68328serial.c
@@ -143,7 +143,6 @@ static int m68328_console_cbaud   = DEFAULT_CBAUD;
  * memory if large numbers of serial ports are open.
  */
 static unsigned char tmp_buf[SERIAL_XMIT_SIZE]; /* This is cheating */
-DECLARE_MUTEX(tmp_buf_sem);
 
 static inline int serial_paranoia_check(struct m68k_serial *info,
                                         char *name, const char *routine)
diff --git a/drivers/serial/Kconfig b/drivers/serial/Kconfig
index 843717275d49..e0685a520514 100644
--- a/drivers/serial/Kconfig
+++ b/drivers/serial/Kconfig
@@ -190,7 +190,6 @@ config SERIAL_8250_BOCA
           To compile this driver as a module, choose M here: the module
           will be called 8250_boca.
 
-
 config SERIAL_8250_HUB6
         tristate "Support Hub6 cards"
         depends on SERIAL_8250 != n && ISA && SERIAL_8250_MANY_PORTS
@@ -917,4 +916,12 @@ config SERIAL_SGI_IOC4
                 and wish to use the serial ports on this card, say Y.
                 Otherwise, say N.
 
+config SERIAL_SGI_IOC3
+        tristate "SGI Altix IOC3 serial support"
+        depends on (IA64_GENERIC || IA64_SGI_SN2) && SGI_IOC3
+        select SERIAL_CORE
+        help
+          If you have an SGI Altix with an IOC3 serial card,
+          say Y or M.  Otherwise, say N.
+
 endmenu
diff --git a/drivers/serial/Makefile b/drivers/serial/Makefile
index 24a583e482bb..eaf8e01db198 100644
--- a/drivers/serial/Makefile
+++ b/drivers/serial/Makefile
@@ -56,4 +56,5 @@ obj-$(CONFIG_SERIAL_JSM) += jsm/
 obj-$(CONFIG_SERIAL_TXX9) += serial_txx9.o
 obj-$(CONFIG_SERIAL_VR41XX) += vr41xx_siu.o
 obj-$(CONFIG_SERIAL_SGI_IOC4) += ioc4_serial.o
+obj-$(CONFIG_SERIAL_SGI_IOC3) += ioc3_serial.o
 obj-$(CONFIG_SERIAL_AT91) += at91_serial.o
diff --git a/drivers/serial/imx.c b/drivers/serial/imx.c
index 5c098be9346b..587cc6a95114 100644
--- a/drivers/serial/imx.c
+++ b/drivers/serial/imx.c
@@ -499,7 +499,7 @@ imx_set_termios(struct uart_port *port, struct termios *termios,
                 ucr2 |= UCR2_STPB;
         if (termios->c_cflag & PARENB) {
                 ucr2 |= UCR2_PREN;
-                if (!(termios->c_cflag & PARODD))
+                if (termios->c_cflag & PARODD)
                         ucr2 |= UCR2_PROE;
         }
 
diff --git a/drivers/serial/ioc3_serial.c b/drivers/serial/ioc3_serial.c
new file mode 100644
index 000000000000..8097cd91f16b
--- /dev/null
+++ b/drivers/serial/ioc3_serial.c
@@ -0,0 +1,2197 @@
+/*
+ * 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.
+ *
+ * Copyright (C) 2005 Silicon Graphics, Inc.  All Rights Reserved.
+ */
+
+/*
+ * This file contains a module version of the ioc3 serial driver. This
+ * includes all the support functions needed (support functions, etc.)
+ * and the serial driver itself.
+ */
+#include <linux/errno.h>
+#include <linux/tty.h>
+#include <linux/serial.h>
+#include <linux/circ_buf.h>
+#include <linux/serial_reg.h>
+#include <linux/module.h>
+#include <linux/pci.h>
+#include <linux/serial_core.h>
+#include <linux/ioc3.h>
+
+/*
+ * Interesting things about the ioc3
+ */
+
+#define LOGICAL_PORTS           2       /* rs232(0) and rs422(1) */
+#define PORTS_PER_CARD          2
+#define LOGICAL_PORTS_PER_CARD (PORTS_PER_CARD * LOGICAL_PORTS)
+#define MAX_CARDS               8
+#define MAX_LOGICAL_PORTS       (LOGICAL_PORTS_PER_CARD * MAX_CARDS)
+
+/* determine given the sio_ir what port it applies to */
+#define GET_PORT_FROM_SIO_IR(_x)        (_x & SIO_IR_SA) ? 0 : 1
+
+
+/*
+ * we have 2 logical ports (rs232, rs422) for each physical port
+ * evens are rs232, odds are rs422
+ */
+#define GET_PHYSICAL_PORT(_x)   ((_x) >> 1)
+#define GET_LOGICAL_PORT(_x)    ((_x) & 1)
+#define IS_PHYSICAL_PORT(_x)    !((_x) & 1)
+#define IS_RS232(_x)            !((_x) & 1)
+
+static unsigned int Num_of_ioc3_cards;
+static unsigned int Submodule_slot;
+
+/* defining this will get you LOTS of great debug info */
+//#define DEBUG_INTERRUPTS
+#define DPRINT_CONFIG(_x...)    ;
+//#define DPRINT_CONFIG(_x...)  printk _x
+#define NOT_PROGRESS()  ;
+//#define NOT_PROGRESS()        printk("%s : fails %d\n", __FUNCTION__, __LINE__)
+
+/* number of characters we want to transmit to the lower level at a time */
+#define MAX_CHARS               256
+#define FIFO_SIZE               (MAX_CHARS-1)   /* it's a uchar */
+
+/* Device name we're using */
+#define DEVICE_NAME             "ttySIOC"
+#define DEVICE_MAJOR            204
+#define DEVICE_MINOR            116
+
+/* flags for next_char_state */
+#define NCS_BREAK               0x1
+#define NCS_PARITY              0x2
+#define NCS_FRAMING             0x4
+#define NCS_OVERRUN             0x8
+
+/* cause we need SOME parameters ... */
+#define MIN_BAUD_SUPPORTED      1200
+#define MAX_BAUD_SUPPORTED      115200
+
+/* protocol types supported */
+#define PROTO_RS232             0
+#define PROTO_RS422             1
+
+/* Notification types */
+#define N_DATA_READY            0x01
+#define N_OUTPUT_LOWAT          0x02
+#define N_BREAK                 0x04
+#define N_PARITY_ERROR          0x08
+#define N_FRAMING_ERROR         0x10
+#define N_OVERRUN_ERROR         0x20
+#define N_DDCD                  0x40
+#define N_DCTS                  0x80
+
+#define N_ALL_INPUT             (N_DATA_READY | N_BREAK                    \
+                                        | N_PARITY_ERROR | N_FRAMING_ERROR \
+                                        | N_OVERRUN_ERROR | N_DDCD | N_DCTS)
+
+#define N_ALL_OUTPUT            N_OUTPUT_LOWAT
+
+#define N_ALL_ERRORS            (N_PARITY_ERROR | N_FRAMING_ERROR \
+                                                | N_OVERRUN_ERROR)
+
+#define N_ALL                   (N_DATA_READY | N_OUTPUT_LOWAT | N_BREAK    \
+                                        | N_PARITY_ERROR | N_FRAMING_ERROR  \
+                                        | N_OVERRUN_ERROR | N_DDCD | N_DCTS)
+
+#define SER_CLK_SPEED(prediv)   ((22000000 << 1) / prediv)
+#define SER_DIVISOR(x, clk)     (((clk) + (x) * 8) / ((x) * 16))
+#define DIVISOR_TO_BAUD(div, clk) ((clk) / 16 / (div))
+
+/* Some masks */
+#define LCR_MASK_BITS_CHAR      (UART_LCR_WLEN5 | UART_LCR_WLEN6 \
+                                        | UART_LCR_WLEN7 | UART_LCR_WLEN8)
+#define LCR_MASK_STOP_BITS      (UART_LCR_STOP)
+
+#define PENDING(_a, _p)         (readl(&(_p)->vma->sio_ir) & (_a)->ic_enable)
+
+#define RING_BUF_SIZE           4096
+#define BUF_SIZE_BIT            SBBR_L_SIZE
+#define PROD_CONS_MASK          PROD_CONS_PTR_4K
+
+#define TOTAL_RING_BUF_SIZE     (RING_BUF_SIZE * 4)
+
+/* driver specific - one per card */
+struct ioc3_card {
+        struct {
+                /* uart ports are allocated here */
+                struct uart_port icp_uart_port[LOGICAL_PORTS];
+                /* the ioc3_port used for this port */
+                struct ioc3_port *icp_port;
+        } ic_port[PORTS_PER_CARD];
+        /* currently enabled interrupts */
+        uint32_t ic_enable;
+};
+
+/* Local port info for each IOC3 serial port */
+struct ioc3_port {
+        /* handy reference material */
+        struct uart_port *ip_port;
+        struct ioc3_card *ip_card;
+        struct ioc3_driver_data *ip_idd;
+        struct ioc3_submodule *ip_is;
+
+        /* pci mem addresses for this port */
+        struct ioc3_serialregs __iomem *ip_serial_regs;
+        struct ioc3_uartregs __iomem *ip_uart_regs;
+
+        /* Ring buffer page for this port */
+        dma_addr_t ip_dma_ringbuf;
+        /* vaddr of ring buffer */
+        struct ring_buffer *ip_cpu_ringbuf;
+
+        /* Rings for this port */
+        struct ring *ip_inring;
+        struct ring *ip_outring;
+
+        /* Hook to port specific values */
+        struct port_hooks *ip_hooks;
+
+        spinlock_t ip_lock;
+
+        /* Various rx/tx parameters */
+        int ip_baud;
+        int ip_tx_lowat;
+        int ip_rx_timeout;
+
+        /* Copy of notification bits */
+        int ip_notify;
+
+        /* Shadow copies of various registers so we don't need to PIO
+         * read them constantly
+         */
+        uint32_t ip_sscr;
+        uint32_t ip_tx_prod;
+        uint32_t ip_rx_cons;
+        unsigned char ip_flags;
+};
+
+/* tx low water mark.  We need to notify the driver whenever tx is getting
+ * close to empty so it can refill the tx buffer and keep things going.
+ * Let's assume that if we interrupt 1 ms before the tx goes idle, we'll
+ * have no trouble getting in more chars in time (I certainly hope so).
+ */
+#define TX_LOWAT_LATENCY      1000
+#define TX_LOWAT_HZ          (1000000 / TX_LOWAT_LATENCY)
+#define TX_LOWAT_CHARS(baud) (baud / 10 / TX_LOWAT_HZ)
+
+/* Flags per port */
+#define INPUT_HIGH              0x01
+        /* used to signify that we have turned off the rx_high
+         * temporarily - we need to drain the fifo and don't
+         * want to get blasted with interrupts.
+         */
+#define DCD_ON                  0x02
+        /* DCD state is on */
+#define LOWAT_WRITTEN           0x04
+#define READ_ABORTED            0x08
+        /* the read was aborted - used to avaoid infinate looping
+         * in the interrupt handler
+         */
+#define INPUT_ENABLE            0x10
+
+/* Since each port has different register offsets and bitmasks
+ * for everything, we'll store those that we need in tables so we
+ * don't have to be constantly checking the port we are dealing with.
+ */
+struct port_hooks {
+        uint32_t intr_delta_dcd;
+        uint32_t intr_delta_cts;
+        uint32_t intr_tx_mt;
+        uint32_t intr_rx_timer;
+        uint32_t intr_rx_high;
+        uint32_t intr_tx_explicit;
+        uint32_t intr_clear;
+        uint32_t intr_all;
+        char rs422_select_pin;
+};
+
+static struct port_hooks hooks_array[PORTS_PER_CARD] = {
+        /* values for port A */
+        {
+        .intr_delta_dcd = SIO_IR_SA_DELTA_DCD,
+        .intr_delta_cts = SIO_IR_SA_DELTA_CTS,
+        .intr_tx_mt = SIO_IR_SA_TX_MT,
+        .intr_rx_timer = SIO_IR_SA_RX_TIMER,
+        .intr_rx_high = SIO_IR_SA_RX_HIGH,
+        .intr_tx_explicit = SIO_IR_SA_TX_EXPLICIT,
+        .intr_clear = (SIO_IR_SA_TX_MT | SIO_IR_SA_RX_FULL
+                                | SIO_IR_SA_RX_HIGH
+                                | SIO_IR_SA_RX_TIMER
+                                | SIO_IR_SA_DELTA_DCD
+                                | SIO_IR_SA_DELTA_CTS
+                                | SIO_IR_SA_INT
+                                | SIO_IR_SA_TX_EXPLICIT
+                                | SIO_IR_SA_MEMERR),
+        .intr_all =  SIO_IR_SA,
+        .rs422_select_pin = GPPR_UARTA_MODESEL_PIN,
+         },
+
+        /* values for port B */
+        {
+        .intr_delta_dcd = SIO_IR_SB_DELTA_DCD,
+        .intr_delta_cts = SIO_IR_SB_DELTA_CTS,
+        .intr_tx_mt = SIO_IR_SB_TX_MT,
+        .intr_rx_timer = SIO_IR_SB_RX_TIMER,
+        .intr_rx_high = SIO_IR_SB_RX_HIGH,
+        .intr_tx_explicit = SIO_IR_SB_TX_EXPLICIT,
+        .intr_clear = (SIO_IR_SB_TX_MT | SIO_IR_SB_RX_FULL
+                                | SIO_IR_SB_RX_HIGH
+                                | SIO_IR_SB_RX_TIMER
+                                | SIO_IR_SB_DELTA_DCD
+                                | SIO_IR_SB_DELTA_CTS
+                                | SIO_IR_SB_INT
+                                | SIO_IR_SB_TX_EXPLICIT
+                                | SIO_IR_SB_MEMERR),
+        .intr_all = SIO_IR_SB,
+        .rs422_select_pin = GPPR_UARTB_MODESEL_PIN,
+         }
+};
+
+struct ring_entry {
+        union {
+                struct {
+                        uint32_t alldata;
+                        uint32_t allsc;
+                } all;
+                struct {
+                        char data[4];   /* data bytes */
+                        char sc[4];     /* status/control */
+                } s;
+        } u;
+};
+
+/* Test the valid bits in any of the 4 sc chars using "allsc" member */
+#define RING_ANY_VALID \
+        ((uint32_t)(RXSB_MODEM_VALID | RXSB_DATA_VALID) * 0x01010101)
+
+#define ring_sc         u.s.sc
+#define ring_data       u.s.data
+#define ring_allsc      u.all.allsc
+
+/* Number of entries per ring buffer. */
+#define ENTRIES_PER_RING (RING_BUF_SIZE / (int) sizeof(struct ring_entry))
+
+/* An individual ring */
+struct ring {
+        struct ring_entry entries[ENTRIES_PER_RING];
+};
+
+/* The whole enchilada */
+struct ring_buffer {
+        struct ring TX_A;
+        struct ring RX_A;
+        struct ring TX_B;
+        struct ring RX_B;
+};
+
+/* Get a ring from a port struct */
+#define RING(_p, _wh)   &(((struct ring_buffer *)((_p)->ip_cpu_ringbuf))->_wh)
+
+/* for Infinite loop detection  */
+#define MAXITER         10000000
+
+
+/**
+ * set_baud - Baud rate setting code
+ * @port: port to set
+ * @baud: baud rate to use
+ */
+static int set_baud(struct ioc3_port *port, int baud)
+{
+        int divisor;
+        int actual_baud;
+        int diff;
+        int lcr, prediv;
+        struct ioc3_uartregs __iomem *uart;
+
+        for (prediv = 6; prediv < 64; prediv++) {
+                divisor = SER_DIVISOR(baud, SER_CLK_SPEED(prediv));
+                if (!divisor)
+                        continue;       /* invalid divisor */
+                actual_baud = DIVISOR_TO_BAUD(divisor, SER_CLK_SPEED(prediv));
+
+                diff = actual_baud - baud;
+                if (diff < 0)
+                        diff = -diff;
+
+                /* if we're within 1% we've found a match */
+                if (diff * 100 <= actual_baud)
+                        break;
+        }
+
+        /* if the above loop completed, we didn't match
+         * the baud rate.  give up.
+         */
+        if (prediv == 64) {
+                NOT_PROGRESS();
+                return 1;
+        }
+
+        uart = port->ip_uart_regs;
+        lcr = readb(&uart->iu_lcr);
+
+        writeb(lcr | UART_LCR_DLAB, &uart->iu_lcr);
+        writeb((unsigned char)divisor, &uart->iu_dll);
+        writeb((unsigned char)(divisor >> 8), &uart->iu_dlm);
+        writeb((unsigned char)prediv, &uart->iu_scr);
+        writeb((unsigned char)lcr, &uart->iu_lcr);
+
+        return 0;
+}
+
+/**
+ * get_ioc3_port - given a uart port, return the control structure
+ * @the_port: uart port to find
+ */
+static struct ioc3_port *get_ioc3_port(struct uart_port *the_port)
+{
+        struct ioc3_driver_data *idd = dev_get_drvdata(the_port->dev);
+        struct ioc3_card *card_ptr = idd->data[Submodule_slot];
+        int ii, jj;
+
+        if (!card_ptr) {
+                NOT_PROGRESS();
+                return NULL;
+        }
+        for (ii = 0; ii < PORTS_PER_CARD; ii++) {
+                for (jj = 0; jj < LOGICAL_PORTS; jj++) {
+                        if (the_port == &card_ptr->ic_port[ii].icp_uart_port[jj])
+                                return card_ptr->ic_port[ii].icp_port;
+                }
+        }
+        NOT_PROGRESS();
+        return NULL;
+}
+
+/**
+ * port_init - Initialize the sio and ioc3 hardware for a given port
+ *                      called per port from attach...
+ * @port: port to initialize
+ */
+static int inline port_init(struct ioc3_port *port)
+{
+        uint32_t sio_cr;
+        struct port_hooks *hooks = port->ip_hooks;
+        struct ioc3_uartregs __iomem *uart;
+        int reset_loop_counter = 0xfffff;
+        struct ioc3_driver_data *idd = port->ip_idd;
+
+        /* Idle the IOC3 serial interface */
+        writel(SSCR_RESET, &port->ip_serial_regs->sscr);
+
+        /* Wait until any pending bus activity for this port has ceased */
+        do {
+                sio_cr = readl(&idd->vma->sio_cr);
+                if (reset_loop_counter-- <= 0) {
+                        printk(KERN_WARNING
+                               "IOC3 unable to come out of reset"
+                                " scr 0x%x\n", sio_cr);
+                        return -1;
+                }
+        } while (!(sio_cr & SIO_CR_ARB_DIAG_IDLE) &&
+               (((sio_cr &= SIO_CR_ARB_DIAG) == SIO_CR_ARB_DIAG_TXA)
+                || sio_cr == SIO_CR_ARB_DIAG_TXB
+                || sio_cr == SIO_CR_ARB_DIAG_RXA
+                || sio_cr == SIO_CR_ARB_DIAG_RXB));
+
+        /* Finish reset sequence */
+        writel(0, &port->ip_serial_regs->sscr);
+
+        /* Once RESET is done, reload cached tx_prod and rx_cons values
+         * and set rings to empty by making prod == cons
+         */
+        port->ip_tx_prod = readl(&port->ip_serial_regs->stcir) & PROD_CONS_MASK;
+        writel(port->ip_tx_prod, &port->ip_serial_regs->stpir);
+        port->ip_rx_cons = readl(&port->ip_serial_regs->srpir) & PROD_CONS_MASK;
+        writel(port->ip_rx_cons | SRCIR_ARM, &port->ip_serial_regs->srcir);
+
+        /* Disable interrupts for this 16550 */
+        uart = port->ip_uart_regs;
+        writeb(0, &uart->iu_lcr);
+        writeb(0, &uart->iu_ier);
+
+        /* Set the default baud */
+        set_baud(port, port->ip_baud);
+
+        /* Set line control to 8 bits no parity */
+        writeb(UART_LCR_WLEN8 | 0, &uart->iu_lcr);
+        /* UART_LCR_STOP == 1 stop */
+
+        /* Enable the FIFOs */
+        writeb(UART_FCR_ENABLE_FIFO, &uart->iu_fcr);
+        /* then reset 16550 FIFOs */
+        writeb(UART_FCR_ENABLE_FIFO | UART_FCR_CLEAR_RCVR | UART_FCR_CLEAR_XMIT,
+               &uart->iu_fcr);
+
+        /* Clear modem control register */
+        writeb(0, &uart->iu_mcr);
+
+        /* Clear deltas in modem status register */
+        writel(0, &port->ip_serial_regs->shadow);
+
+        /* Only do this once per port pair */
+        if (port->ip_hooks == &hooks_array[0]) {
+                unsigned long ring_pci_addr;
+                uint32_t __iomem *sbbr_l, *sbbr_h;
+
+                sbbr_l = &idd->vma->sbbr_l;
+                sbbr_h = &idd->vma->sbbr_h;
+                ring_pci_addr = (unsigned long __iomem)port->ip_dma_ringbuf;
+                DPRINT_CONFIG(("%s: ring_pci_addr 0x%p\n",
+                               __FUNCTION__, (void *)ring_pci_addr));
+
+                writel((unsigned int)((uint64_t) ring_pci_addr >> 32), sbbr_h);
+                writel((unsigned int)ring_pci_addr | BUF_SIZE_BIT, sbbr_l);
+        }
+
+        /* Set the receive timeout value to 10 msec */
+        writel(SRTR_HZ / 100, &port->ip_serial_regs->srtr);
+
+        /* Set rx threshold, enable DMA */
+        /* Set high water mark at 3/4 of full ring */
+        port->ip_sscr = (ENTRIES_PER_RING * 3 / 4);
+
+        /* uart experiences pauses at high baud rate reducing actual
+         * throughput by 10% or so unless we enable high speed polling
+         * XXX when this hardware bug is resolved we should revert to
+         * normal polling speed
+         */
+        port->ip_sscr |= SSCR_HIGH_SPD;
+
+        writel(port->ip_sscr, &port->ip_serial_regs->sscr);
+
+        /* Disable and clear all serial related interrupt bits */
+        port->ip_card->ic_enable &= ~hooks->intr_clear;
+        ioc3_disable(port->ip_is, idd, hooks->intr_clear);
+        ioc3_ack(port->ip_is, idd, hooks->intr_clear);
+        return 0;
+}
+
+/**
+ * enable_intrs - enable interrupts
+ * @port: port to enable
+ * @mask: mask to use
+ */
+static void enable_intrs(struct ioc3_port *port, uint32_t mask)
+{
+        if ((port->ip_card->ic_enable & mask) != mask) {
+                port->ip_card->ic_enable |= mask;
+                ioc3_enable(port->ip_is, port->ip_idd, mask);
+        }
+}
+
+/**
+ * local_open - local open a port
+ * @port: port to open
+ */
+static inline int local_open(struct ioc3_port *port)
+{
+        int spiniter = 0;
+
+        port->ip_flags = INPUT_ENABLE;
+
+        /* Pause the DMA interface if necessary */
+        if (port->ip_sscr & SSCR_DMA_EN) {
+                writel(port->ip_sscr | SSCR_DMA_PAUSE,
+                       &port->ip_serial_regs->sscr);
+                while ((readl(&port->ip_serial_regs->sscr)
+                        & SSCR_PAUSE_STATE) == 0) {
+                        spiniter++;
+                        if (spiniter > MAXITER) {
+                                NOT_PROGRESS();
+                                return -1;
+                        }
+                }
+        }
+
+        /* Reset the input fifo.  If the uart received chars while the port
+         * was closed and DMA is not enabled, the uart may have a bunch of
+         * chars hanging around in its rx fifo which will not be discarded
+         * by rclr in the upper layer. We must get rid of them here.
+         */
+        writeb(UART_FCR_ENABLE_FIFO | UART_FCR_CLEAR_RCVR,
+               &port->ip_uart_regs->iu_fcr);
+
+        writeb(UART_LCR_WLEN8, &port->ip_uart_regs->iu_lcr);
+        /* UART_LCR_STOP == 1 stop */
+
+        /* Re-enable DMA, set default threshold to intr whenever there is
+         * data available.
+         */
+        port->ip_sscr &= ~SSCR_RX_THRESHOLD;
+        port->ip_sscr |= 1;     /* default threshold */
+
+        /* Plug in the new sscr.  This implicitly clears the DMA_PAUSE
+         * flag if it was set above
+         */
+        writel(port->ip_sscr, &port->ip_serial_regs->sscr);
+        port->ip_tx_lowat = 1;
+        return 0;
+}
+
+/**
+ * set_rx_timeout - Set rx timeout and threshold values.
+ * @port: port to use
+ * @timeout: timeout value in ticks
+ */
+static inline int set_rx_timeout(struct ioc3_port *port, int timeout)
+{
+        int threshold;
+
+        port->ip_rx_timeout = timeout;
+
+        /* Timeout is in ticks.  Let's figure out how many chars we
+         * can receive at the current baud rate in that interval
+         * and set the rx threshold to that amount.  There are 4 chars
+         * per ring entry, so we'll divide the number of chars that will
+         * arrive in timeout by 4.
+         * So .... timeout * baud / 10 / HZ / 4, with HZ = 100.
+         */
+        threshold = timeout * port->ip_baud / 4000;
+        if (threshold == 0)
+                threshold = 1;  /* otherwise we'll intr all the time! */
+
+        if ((unsigned)threshold > (unsigned)SSCR_RX_THRESHOLD)
+                return 1;
+
+        port->ip_sscr &= ~SSCR_RX_THRESHOLD;
+        port->ip_sscr |= threshold;
+        writel(port->ip_sscr, &port->ip_serial_regs->sscr);
+
+        /* Now set the rx timeout to the given value
+         * again timeout * SRTR_HZ / HZ
+         */
+        timeout = timeout * SRTR_HZ / 100;
+        if (timeout > SRTR_CNT)
+                timeout = SRTR_CNT;
+        writel(timeout, &port->ip_serial_regs->srtr);
+        return 0;
+}
+
+/**
+ * config_port - config the hardware
+ * @port: port to config
+ * @baud: baud rate for the port
+ * @byte_size: data size
+ * @stop_bits: number of stop bits
+ * @parenb: parity enable ?
+ * @parodd: odd parity ?
+ */
+static inline int
+config_port(struct ioc3_port *port,
+            int baud, int byte_size, int stop_bits, int parenb, int parodd)
+{
+        char lcr, sizebits;
+        int spiniter = 0;
+
+        DPRINT_CONFIG(("%s: line %d baud %d byte_size %d stop %d parenb %d "
+                        "parodd %d\n",
+                       __FUNCTION__, ((struct uart_port *)port->ip_port)->line,
+                        baud, byte_size, stop_bits, parenb, parodd));
+
+        if (set_baud(port, baud))
+                return 1;
+
+        switch (byte_size) {
+        case 5:
+                sizebits = UART_LCR_WLEN5;
+                break;
+        case 6:
+                sizebits = UART_LCR_WLEN6;
+                break;
+        case 7:
+                sizebits = UART_LCR_WLEN7;
+                break;
+        case 8:
+                sizebits = UART_LCR_WLEN8;
+                break;
+        default:
+                return 1;
+        }
+
+        /* Pause the DMA interface if necessary */
+        if (port->ip_sscr & SSCR_DMA_EN) {
+                writel(port->ip_sscr | SSCR_DMA_PAUSE,
+                       &port->ip_serial_regs->sscr);
+                while ((readl(&port->ip_serial_regs->sscr)
+                        & SSCR_PAUSE_STATE) == 0) {
+                        spiniter++;
+                        if (spiniter > MAXITER)
+                                return -1;
+                }
+        }
+
+        /* Clear relevant fields in lcr */
+        lcr = readb(&port->ip_uart_regs->iu_lcr);
+        lcr &= ~(LCR_MASK_BITS_CHAR | UART_LCR_EPAR |
+                 UART_LCR_PARITY | LCR_MASK_STOP_BITS);
+
+        /* Set byte size in lcr */
+        lcr |= sizebits;
+
+        /* Set parity */
+        if (parenb) {
+                lcr |= UART_LCR_PARITY;
+                if (!parodd)
+                        lcr |= UART_LCR_EPAR;
+        }
+
+        /* Set stop bits */
+        if (stop_bits)
+                lcr |= UART_LCR_STOP /* 2 stop bits */ ;
+
+        writeb(lcr, &port->ip_uart_regs->iu_lcr);
+
+        /* Re-enable the DMA interface if necessary */
+        if (port->ip_sscr & SSCR_DMA_EN) {
+                writel(port->ip_sscr, &port->ip_serial_regs->sscr);
+        }
+        port->ip_baud = baud;
+
+        /* When we get within this number of ring entries of filling the
+         * entire ring on tx, place an EXPLICIT intr to generate a lowat
+         * notification when output has drained.
+         */
+        port->ip_tx_lowat = (TX_LOWAT_CHARS(baud) + 3) / 4;
+        if (port->ip_tx_lowat == 0)
+                port->ip_tx_lowat = 1;
+
+        set_rx_timeout(port, 2);
+        return 0;
+}
+
+/**
+ * do_write - Write bytes to the port.  Returns the number of bytes
+ *                      actually written. Called from transmit_chars
+ * @port: port to use
+ * @buf: the stuff to write
+ * @len: how many bytes in 'buf'
+ */
+static inline int do_write(struct ioc3_port *port, char *buf, int len)
+{
+        int prod_ptr, cons_ptr, total = 0;
+        struct ring *outring;
+        struct ring_entry *entry;
+        struct port_hooks *hooks = port->ip_hooks;
+
+        BUG_ON(!(len >= 0));
+
+        prod_ptr = port->ip_tx_prod;
+        cons_ptr = readl(&port->ip_serial_regs->stcir) & PROD_CONS_MASK;
+        outring = port->ip_outring;
+
+        /* Maintain a 1-entry red-zone.  The ring buffer is full when
+         * (cons - prod) % ring_size is 1.  Rather than do this subtraction
+         * in the body of the loop, I'll do it now.
+         */
+        cons_ptr = (cons_ptr - (int)sizeof(struct ring_entry)) & PROD_CONS_MASK;
+
+        /* Stuff the bytes into the output */
+        while ((prod_ptr != cons_ptr) && (len > 0)) {
+                int xx;
+
+                /* Get 4 bytes (one ring entry) at a time */
+                entry = (struct ring_entry *)((caddr_t) outring + prod_ptr);
+
+                /* Invalidate all entries */
+                entry->ring_allsc = 0;
+
+                /* Copy in some bytes */
+                for (xx = 0; (xx < 4) && (len > 0); xx++) {
+                        entry->ring_data[xx] = *buf++;
+                        entry->ring_sc[xx] = TXCB_VALID;
+                        len--;
+                        total++;
+                }
+
+                /* If we are within some small threshold of filling up the
+                 * entire ring buffer, we must place an EXPLICIT intr here
+                 * to generate a lowat interrupt in case we subsequently
+                 * really do fill up the ring and the caller goes to sleep.
+                 * No need to place more than one though.
+                 */
+                if (!(port->ip_flags & LOWAT_WRITTEN) &&
+                    ((cons_ptr - prod_ptr) & PROD_CONS_MASK)
+                    <= port->ip_tx_lowat * (int)sizeof(struct ring_entry)) {
+                        port->ip_flags |= LOWAT_WRITTEN;
+                        entry->ring_sc[0] |= TXCB_INT_WHEN_DONE;
+                }
+
+                /* Go on to next entry */
+                prod_ptr += sizeof(struct ring_entry);
+                prod_ptr &= PROD_CONS_MASK;
+        }
+
+        /* If we sent something, start DMA if necessary */
+        if (total > 0 && !(port->ip_sscr & SSCR_DMA_EN)) {
+                port->ip_sscr |= SSCR_DMA_EN;
+                writel(port->ip_sscr, &port->ip_serial_regs->sscr);
+        }
+
+        /* Store the new producer pointer.  If tx is disabled, we stuff the
+         * data into the ring buffer, but we don't actually start tx.
+         */
+        if (!uart_tx_stopped(port->ip_port)) {
+                writel(prod_ptr, &port->ip_serial_regs->stpir);
+
+                /* If we are now transmitting, enable tx_mt interrupt so we
+                 * can disable DMA if necessary when the tx finishes.
+                 */
+                if (total > 0)
+                        enable_intrs(port, hooks->intr_tx_mt);
+        }
+        port->ip_tx_prod = prod_ptr;
+
+        return total;
+}
+
+/**
+ * disable_intrs - disable interrupts
+ * @port: port to enable
+ * @mask: mask to use
+ */
+static inline void disable_intrs(struct ioc3_port *port, uint32_t mask)
+{
+        if (port->ip_card->ic_enable & mask) {
+                ioc3_disable(port->ip_is, port->ip_idd, mask);
+                port->ip_card->ic_enable &= ~mask;
+        }
+}
+
+/**
+ * set_notification - Modify event notification
+ * @port: port to use
+ * @mask: events mask
+ * @set_on: set ?
+ */
+static int set_notification(struct ioc3_port *port, int mask, int set_on)
+{
+        struct port_hooks *hooks = port->ip_hooks;
+        uint32_t intrbits, sscrbits;
+
+        BUG_ON(!mask);
+
+        intrbits = sscrbits = 0;
+
+        if (mask & N_DATA_READY)
+                intrbits |= (hooks->intr_rx_timer | hooks->intr_rx_high);
+        if (mask & N_OUTPUT_LOWAT)
+                intrbits |= hooks->intr_tx_explicit;
+        if (mask & N_DDCD) {
+                intrbits |= hooks->intr_delta_dcd;
+                sscrbits |= SSCR_RX_RING_DCD;
+        }
+        if (mask & N_DCTS)
+                intrbits |= hooks->intr_delta_cts;
+
+        if (set_on) {
+                enable_intrs(port, intrbits);
+                port->ip_notify |= mask;
+                port->ip_sscr |= sscrbits;
+        } else {
+                disable_intrs(port, intrbits);
+                port->ip_notify &= ~mask;
+                port->ip_sscr &= ~sscrbits;
+        }
+
+        /* We require DMA if either DATA_READY or DDCD notification is
+         * currently requested. If neither of these is requested and
+         * there is currently no tx in progress, DMA may be disabled.
+         */
+        if (port->ip_notify & (N_DATA_READY | N_DDCD))
+                port->ip_sscr |= SSCR_DMA_EN;
+        else if (!(port->ip_card->ic_enable & hooks->intr_tx_mt))
+                port->ip_sscr &= ~SSCR_DMA_EN;
+
+        writel(port->ip_sscr, &port->ip_serial_regs->sscr);
+        return 0;
+}
+
+/**
+ * set_mcr - set the master control reg
+ * @the_port: port to use
+ * @mask1: mcr mask
+ * @mask2: shadow mask
+ */
+static inline int set_mcr(struct uart_port *the_port,
+                          int mask1, int mask2)
+{
+        struct ioc3_port *port = get_ioc3_port(the_port);
+        uint32_t shadow;
+        int spiniter = 0;
+        char mcr;
+
+        if (!port)
+                return -1;
+
+        /* Pause the DMA interface if necessary */
+        if (port->ip_sscr & SSCR_DMA_EN) {
+                writel(port->ip_sscr | SSCR_DMA_PAUSE,
+                       &port->ip_serial_regs->sscr);
+                while ((readl(&port->ip_serial_regs->sscr)
+                        & SSCR_PAUSE_STATE) == 0) {
+                        spiniter++;
+                        if (spiniter > MAXITER)
+                                return -1;
+                }
+        }
+        shadow = readl(&port->ip_serial_regs->shadow);
+        mcr = (shadow & 0xff000000) >> 24;
+
+        /* Set new value */
+        mcr |= mask1;
+        shadow |= mask2;
+        writeb(mcr, &port->ip_uart_regs->iu_mcr);
+        writel(shadow, &port->ip_serial_regs->shadow);
+
+        /* Re-enable the DMA interface if necessary */
+        if (port->ip_sscr & SSCR_DMA_EN) {
+                writel(port->ip_sscr, &port->ip_serial_regs->sscr);
+        }
+        return 0;
+}
+
+/**
+ * ioc3_set_proto - set the protocol for the port
+ * @port: port to use
+ * @proto: protocol to use
+ */
+static int ioc3_set_proto(struct ioc3_port *port, int proto)
+{
+        struct port_hooks *hooks = port->ip_hooks;
+
+        switch (proto) {
+        default:
+        case PROTO_RS232:
+                /* Clear the appropriate GIO pin */
+                DPRINT_CONFIG(("%s: rs232\n", __FUNCTION__));
+                writel(0, (&port->ip_idd->vma->gppr[0]
+                                        + hooks->rs422_select_pin));
+                break;
+
+        case PROTO_RS422:
+                /* Set the appropriate GIO pin */
+                DPRINT_CONFIG(("%s: rs422\n", __FUNCTION__));
+                writel(1, (&port->ip_idd->vma->gppr[0]
+                                        + hooks->rs422_select_pin));
+                break;
+        }
+        return 0;
+}
+
+/**
+ * transmit_chars - upper level write, called with the_port->lock
+ * @the_port: port to write
+ */
+static void transmit_chars(struct uart_port *the_port)
+{
+        int xmit_count, tail, head;
+        int result;
+        char *start;
+        struct tty_struct *tty;
+        struct ioc3_port *port = get_ioc3_port(the_port);
+        struct uart_info *info;
+
+        if (!the_port)
+                return;
+        if (!port)
+                return;
+
+        info = the_port->info;
+        tty = info->tty;
+
+        if (uart_circ_empty(&info->xmit) || uart_tx_stopped(the_port)) {
+                /* Nothing to do or hw stopped */
+                set_notification(port, N_ALL_OUTPUT, 0);
+                return;
+        }
+
+        head = info->xmit.head;
+        tail = info->xmit.tail;
+        start = (char *)&info->xmit.buf[tail];
+
+        /* write out all the data or until the end of the buffer */
+        xmit_count = (head < tail) ? (UART_XMIT_SIZE - tail) : (head - tail);
+        if (xmit_count > 0) {
+                result = do_write(port, start, xmit_count);
+                if (result > 0) {
+                        /* booking */
+                        xmit_count -= result;
+                        the_port->icount.tx += result;
+                        /* advance the pointers */
+                        tail += result;
+                        tail &= UART_XMIT_SIZE - 1;
+                        info->xmit.tail = tail;
+                        start = (char *)&info->xmit.buf[tail];
+                }
+        }
+        if (uart_circ_chars_pending(&info->xmit) < WAKEUP_CHARS)
+                uart_write_wakeup(the_port);
+
+        if (uart_circ_empty(&info->xmit)) {
+                set_notification(port, N_OUTPUT_LOWAT, 0);
+        } else {
+                set_notification(port, N_OUTPUT_LOWAT, 1);
+        }
+}
+
+/**
+ * ioc3_change_speed - change the speed of the port
+ * @the_port: port to change
+ * @new_termios: new termios settings
+ * @old_termios: old termios settings
+ */
+static void
+ioc3_change_speed(struct uart_port *the_port,
+                  struct termios *new_termios, struct termios *old_termios)
+{
+        struct ioc3_port *port = get_ioc3_port(the_port);
+        unsigned int cflag;
+        int baud;
+        int new_parity = 0, new_parity_enable = 0, new_stop = 0, new_data = 8;
+        struct uart_info *info = the_port->info;
+
+        cflag = new_termios->c_cflag;
+
+        switch (cflag & CSIZE) {
+        case CS5:
+                new_data = 5;
+                break;
+        case CS6:
+                new_data = 6;
+                break;
+        case CS7:
+                new_data = 7;
+                break;
+        case CS8:
+                new_data = 8;
+                break;
+        default:
+                /* cuz we always need a default ... */
+                new_data = 5;
+                break;
+        }
+        if (cflag & CSTOPB) {
+                new_stop = 1;
+        }
+        if (cflag & PARENB) {
+                new_parity_enable = 1;
+                if (cflag & PARODD)
+                        new_parity = 1;
+        }
+        baud = uart_get_baud_rate(the_port, new_termios, old_termios,
+                                  MIN_BAUD_SUPPORTED, MAX_BAUD_SUPPORTED);
+        DPRINT_CONFIG(("%s: returned baud %d for line %d\n", __FUNCTION__, baud,
+                                the_port->line));
+
+        if (!the_port->fifosize)
+                the_port->fifosize = FIFO_SIZE;
+        uart_update_timeout(the_port, cflag, baud);
+
+        the_port->ignore_status_mask = N_ALL_INPUT;
+
+        info->tty->low_latency = 1;
+
+        if (I_IGNPAR(info->tty))
+                the_port->ignore_status_mask &= ~(N_PARITY_ERROR
+                                                  | N_FRAMING_ERROR);
+        if (I_IGNBRK(info->tty)) {
+                the_port->ignore_status_mask &= ~N_BREAK;
+                if (I_IGNPAR(info->tty))
+                        the_port->ignore_status_mask &= ~N_OVERRUN_ERROR;
+        }
+        if (!(cflag & CREAD)) {
+                /* ignore everything */
+                the_port->ignore_status_mask &= ~N_DATA_READY;
+        }
+
+        if (cflag & CRTSCTS) {
+                /* enable hardware flow control */
+                port->ip_sscr |= SSCR_HFC_EN;
+        }
+        else {
+                /* disable hardware flow control */
+                port->ip_sscr &= ~SSCR_HFC_EN;
+        }
+        writel(port->ip_sscr, &port->ip_serial_regs->sscr);
+
+        /* Set the configuration and proper notification call */
+        DPRINT_CONFIG(("%s : port 0x%p line %d cflag 0%o "
+                       "config_port(baud %d data %d stop %d penable %d "
+                        " parity %d), notification 0x%x\n",
+                       __FUNCTION__, (void *)port, the_port->line, cflag, baud,
+                       new_data, new_stop, new_parity_enable, new_parity,
+                       the_port->ignore_status_mask));
+
+        if ((config_port(port, baud,    /* baud */
+                         new_data,      /* byte size */
+                         new_stop,      /* stop bits */
+                         new_parity_enable,     /* set parity */
+                         new_parity)) >= 0) {   /* parity 1==odd */
+                set_notification(port, the_port->ignore_status_mask, 1);
+        }
+}
+
+/**
+ * ic3_startup_local - Start up the serial port - returns >= 0 if no errors
+ * @the_port: Port to operate on
+ */
+static inline int ic3_startup_local(struct uart_port *the_port)
+{
+        struct ioc3_port *port;
+
+        if (!the_port) {
+                NOT_PROGRESS();
+                return -1;
+        }
+
+        port = get_ioc3_port(the_port);
+        if (!port) {
+                NOT_PROGRESS();
+                return -1;
+        }
+
+        local_open(port);
+
+        /* set the protocol */
+        ioc3_set_proto(port, IS_RS232(the_port->line) ? PROTO_RS232 :
+                                                        PROTO_RS422);
+        return 0;
+}
+
+/*
+ * ioc3_cb_output_lowat - called when the output low water mark is hit
+ * @port: port to output
+ */
+static void ioc3_cb_output_lowat(struct ioc3_port *port)
+{
+        unsigned long pflags;
+
+        /* the_port->lock is set on the call here */
+        if (port->ip_port) {
+                spin_lock_irqsave(&port->ip_port->lock, pflags);
+                transmit_chars(port->ip_port);
+                spin_unlock_irqrestore(&port->ip_port->lock, pflags);
+        }
+}
+
+/*
+ * ioc3_cb_post_ncs - called for some basic errors
+ * @port: port to use
+ * @ncs: event
+ */
+static void ioc3_cb_post_ncs(struct uart_port *the_port, int ncs)
+{
+        struct uart_icount *icount;
+
+        icount = &the_port->icount;
+
+        if (ncs & NCS_BREAK)
+                icount->brk++;
+        if (ncs & NCS_FRAMING)
+                icount->frame++;
+        if (ncs & NCS_OVERRUN)
+                icount->overrun++;
+        if (ncs & NCS_PARITY)
+                icount->parity++;
+}
+
+/**
+ * do_read - Read in bytes from the port.  Return the number of bytes
+ *                      actually read.
+ * @the_port: port to use
+ * @buf: place to put the stuff we read
+ * @len: how big 'buf' is
+ */
+
+static inline int do_read(struct uart_port *the_port, char *buf, int len)
+{
+        int prod_ptr, cons_ptr, total;
+        struct ioc3_port *port = get_ioc3_port(the_port);
+        struct ring *inring;
+        struct ring_entry *entry;
+        struct port_hooks *hooks = port->ip_hooks;
+        int byte_num;
+        char *sc;
+        int loop_counter;
+
+        BUG_ON(!(len >= 0));
+        BUG_ON(!port);
+
+        /* There is a nasty timing issue in the IOC3. When the rx_timer
+         * expires or the rx_high condition arises, we take an interrupt.
+         * At some point while servicing the interrupt, we read bytes from
+         * the ring buffer and re-arm the rx_timer.  However the rx_timer is
+         * not started until the first byte is received *after* it is armed,
+         * and any bytes pending in the rx construction buffers are not drained
+         * to memory until either there are 4 bytes available or the rx_timer
+         * expires.  This leads to a potential situation where data is left
+         * in the construction buffers forever - 1 to 3 bytes were received
+         * after the interrupt was generated but before the rx_timer was
+         * re-armed. At that point as long as no subsequent bytes are received
+         * the timer will never be started and the bytes will remain in the
+         * construction buffer forever.  The solution is to execute a DRAIN
+         * command after rearming the timer.  This way any bytes received before
+         * the DRAIN will be drained to memory, and any bytes received after
+         * the DRAIN will start the TIMER and be drained when it expires.
+         * Luckily, this only needs to be done when the DMA buffer is empty
+         * since there is no requirement that this function return all
+         * available data as long as it returns some.
+         */
+        /* Re-arm the timer */
+
+        writel(port->ip_rx_cons | SRCIR_ARM, &port->ip_serial_regs->srcir);
+
+        prod_ptr = readl(&port->ip_serial_regs->srpir) & PROD_CONS_MASK;
+        cons_ptr = port->ip_rx_cons;
+
+        if (prod_ptr == cons_ptr) {
+                int reset_dma = 0;
+
+                /* Input buffer appears empty, do a flush. */
+
+                /* DMA must be enabled for this to work. */
+                if (!(port->ip_sscr & SSCR_DMA_EN)) {
+                        port->ip_sscr |= SSCR_DMA_EN;
+                        reset_dma = 1;
+                }
+
+                /* Potential race condition: we must reload the srpir after
+                 * issuing the drain command, otherwise we could think the rx
+                 * buffer is empty, then take a very long interrupt, and when
+                 * we come back it's full and we wait forever for the drain to
+                 * complete.
+                 */
+                writel(port->ip_sscr | SSCR_RX_DRAIN,
+                       &port->ip_serial_regs->sscr);
+                prod_ptr = readl(&port->ip_serial_regs->srpir) & PROD_CONS_MASK;
+
+                /* We must not wait for the DRAIN to complete unless there are
+                 * at least 8 bytes (2 ring entries) available to receive the
+                 * data otherwise the DRAIN will never complete and we'll
+                 * deadlock here.
+                 * In fact, to make things easier, I'll just ignore the flush if
+                 * there is any data at all now available.
+                 */
+                if (prod_ptr == cons_ptr) {
+                        loop_counter = 0;
+                        while (readl(&port->ip_serial_regs->sscr) &
+                               SSCR_RX_DRAIN) {
+                                loop_counter++;
+                                if (loop_counter > MAXITER)
+                                        return -1;
+                        }
+
+                        /* SIGH. We have to reload the prod_ptr *again* since
+                         * the drain may have caused it to change
+                         */
+                        prod_ptr = readl(&port->ip_serial_regs->srpir)
+                            & PROD_CONS_MASK;
+                }
+                if (reset_dma) {
+                        port->ip_sscr &= ~SSCR_DMA_EN;
+                        writel(port->ip_sscr, &port->ip_serial_regs->sscr);
+                }
+        }
+        inring = port->ip_inring;
+        port->ip_flags &= ~READ_ABORTED;
+
+        total = 0;
+        loop_counter = 0xfffff; /* to avoid hangs */
+
+        /* Grab bytes from the hardware */
+        while ((prod_ptr != cons_ptr) && (len > 0)) {
+                entry = (struct ring_entry *)((caddr_t) inring + cons_ptr);
+
+                if (loop_counter-- <= 0) {
+                        printk(KERN_WARNING "IOC3 serial: "
+                               "possible hang condition/"
+                               "port stuck on read (line %d).\n",
+                                the_port->line);
+                        break;
+                }
+
+                /* According to the producer pointer, this ring entry
+                 * must contain some data.  But if the PIO happened faster
+                 * than the DMA, the data may not be available yet, so let's
+                 * wait until it arrives.
+                 */
+                if ((entry->ring_allsc & RING_ANY_VALID) == 0) {
+                        /* Indicate the read is aborted so we don't disable
+                         * the interrupt thinking that the consumer is
+                         * congested.
+                         */
+                        port->ip_flags |= READ_ABORTED;
+                        len = 0;
+                        break;
+                }
+
+                /* Load the bytes/status out of the ring entry */
+                for (byte_num = 0; byte_num < 4 && len > 0; byte_num++) {
+                        sc = &(entry->ring_sc[byte_num]);
+
+                        /* Check for change in modem state or overrun */
+                        if ((*sc & RXSB_MODEM_VALID)
+                            && (port->ip_notify & N_DDCD)) {
+                                /* Notify upper layer if DCD dropped */
+                                if ((port->ip_flags & DCD_ON)
+                                    && !(*sc & RXSB_DCD)) {
+                                        /* If we have already copied some data,
+                                         * return it.  We'll pick up the carrier
+                                         * drop on the next pass.  That way we
+                                         * don't throw away the data that has
+                                         * already been copied back to
+                                         * the caller's buffer.
+                                         */
+                                        if (total > 0) {
+                                                len = 0;
+                                                break;
+                                        }
+                                        port->ip_flags &= ~DCD_ON;
+
+                                        /* Turn off this notification so the
+                                         * carrier drop protocol won't see it
+                                         * again when it does a read.
+                                         */
+                                        *sc &= ~RXSB_MODEM_VALID;
+
+                                        /* To keep things consistent, we need
+                                         * to update the consumer pointer so
+                                         * the next reader won't come in and
+                                         * try to read the same ring entries
+                                         * again. This must be done here before
+                                         * the dcd change.
+                                         */
+
+                                        if ((entry->ring_allsc & RING_ANY_VALID)
+                                            == 0) {
+                                                cons_ptr += (int)sizeof
+                                                    (struct ring_entry);
+                                                cons_ptr &= PROD_CONS_MASK;
+                                        }
+                                        writel(cons_ptr,
+                                               &port->ip_serial_regs->srcir);
+                                        port->ip_rx_cons = cons_ptr;
+
+                                        /* Notify upper layer of carrier drop */
+                                        if ((port->ip_notify & N_DDCD)
+                                            && port->ip_port) {
+                                                uart_handle_dcd_change
+                                                        (port->ip_port, 0);
+                                                wake_up_interruptible
+                                                    (&the_port->info->
+                                                     delta_msr_wait);
+                                        }
+
+                                        /* If we had any data to return, we
+                                         * would have returned it above.
+                                         */
+                                        return 0;
+                                }
+                        }
+                        if (*sc & RXSB_MODEM_VALID) {
+                                /* Notify that an input overrun occurred */
+                                if ((*sc & RXSB_OVERRUN)
+                                    && (port->ip_notify & N_OVERRUN_ERROR)) {
+                                        ioc3_cb_post_ncs(the_port, NCS_OVERRUN);
+                                }
+                                /* Don't look at this byte again */
+                                *sc &= ~RXSB_MODEM_VALID;
+                        }
+
+                        /* Check for valid data or RX errors */
+                        if ((*sc & RXSB_DATA_VALID) &&
+                            ((*sc & (RXSB_PAR_ERR
+                                     | RXSB_FRAME_ERR | RXSB_BREAK))
+                             && (port->ip_notify & (N_PARITY_ERROR
+                                                    | N_FRAMING_ERROR
+                                                    | N_BREAK)))) {
+                                /* There is an error condition on the next byte.
+                                 * If we have already transferred some bytes,
+                                 * we'll stop here. Otherwise if this is the
+                                 * first byte to be read, we'll just transfer
+                                 * it alone after notifying the
+                                 * upper layer of its status.
+                                 */
+                                if (total > 0) {
+                                        len = 0;
+                                        break;
+                                } else {
+                                        if ((*sc & RXSB_PAR_ERR) &&
+                                            (port->
+                                             ip_notify & N_PARITY_ERROR)) {
+                                                ioc3_cb_post_ncs(the_port,
+                                                                 NCS_PARITY);
+                                        }
+                                        if ((*sc & RXSB_FRAME_ERR) &&
+                                            (port->
+                                             ip_notify & N_FRAMING_ERROR)) {
+                                                ioc3_cb_post_ncs(the_port,
+                                                                 NCS_FRAMING);
+                                        }
+                                        if ((*sc & RXSB_BREAK)
+                                            && (port->ip_notify & N_BREAK)) {
+                                                ioc3_cb_post_ncs
+                                                    (the_port, NCS_BREAK);
+                                        }
+                                        len = 1;
+                                }
+                        }
+                        if (*sc & RXSB_DATA_VALID) {
+                                *sc &= ~RXSB_DATA_VALID;
+                                *buf = entry->ring_data[byte_num];
+                                buf++;
+                                len--;
+                                total++;
+                        }
+                }
+
+                /* If we used up this entry entirely, go on to the next one,
+                 * otherwise we must have run out of buffer space, so
+                 * leave the consumer pointer here for the next read in case
+                 * there are still unread bytes in this entry.
+                 */
+                if ((entry->ring_allsc & RING_ANY_VALID) == 0) {
+                        cons_ptr += (int)sizeof(struct ring_entry);
+                        cons_ptr &= PROD_CONS_MASK;
+                }
+        }
+
+        /* Update consumer pointer and re-arm rx timer interrupt */
+        writel(cons_ptr, &port->ip_serial_regs->srcir);
+        port->ip_rx_cons = cons_ptr;
+
+        /* If we have now dipped below the rx high water mark and we have
+         * rx_high interrupt turned off, we can now turn it back on again.
+         */
+        if ((port->ip_flags & INPUT_HIGH) && (((prod_ptr - cons_ptr)
+                                               & PROD_CONS_MASK) <
+                                              ((port->
+                                                ip_sscr &
+                                                SSCR_RX_THRESHOLD)
+                                               << PROD_CONS_PTR_OFF))) {
+                port->ip_flags &= ~INPUT_HIGH;
+                enable_intrs(port, hooks->intr_rx_high);
+        }
+        return total;
+}
+
+/**
+ * receive_chars - upper level read.
+ * @the_port: port to read from
+ */
+static int receive_chars(struct uart_port *the_port)
+{
+        struct tty_struct *tty;
+        unsigned char ch[MAX_CHARS];
+        int read_count = 0, read_room, flip = 0;
+        struct uart_info *info = the_port->info;
+        struct ioc3_port *port = get_ioc3_port(the_port);
+        unsigned long pflags;
+
+        /* Make sure all the pointers are "good" ones */
+        if (!info)
+                return 0;
+        if (!info->tty)
+                return 0;
+
+        if (!(port->ip_flags & INPUT_ENABLE))
+                return 0;
+
+        spin_lock_irqsave(&the_port->lock, pflags);
+        tty = info->tty;
+
+        read_count = do_read(the_port, ch, MAX_CHARS);
+        if (read_count > 0) {
+                flip = 1;
+                read_room = tty_buffer_request_room(tty, read_count);
+                tty_insert_flip_string(tty, ch, read_room);
+                the_port->icount.rx += read_count;
+        }
+        spin_unlock_irqrestore(&the_port->lock, pflags);
+
+        if (flip)
+                tty_flip_buffer_push(tty);
+
+        return read_count;
+}
+
+/**
+ * ioc3uart_intr_one - lowest level (per port) interrupt handler.
+ * @is : submodule
+ * @idd: driver data
+ * @pending: interrupts to handle
+ * @regs: pt_regs
+ */
+
+static int inline
+ioc3uart_intr_one(struct ioc3_submodule *is,
+                        struct ioc3_driver_data *idd,
+                        unsigned int pending, struct pt_regs *regs)
+{
+        int port_num = GET_PORT_FROM_SIO_IR(pending);
+        struct port_hooks *hooks;
+        unsigned int rx_high_rd_aborted = 0;
+        unsigned long flags;
+        struct uart_port *the_port;
+        struct ioc3_port *port;
+        int loop_counter;
+        struct ioc3_card *card_ptr;
+        unsigned int sio_ir;
+
+        card_ptr = idd->data[is->id];
+        port = card_ptr->ic_port[port_num].icp_port;
+        hooks = port->ip_hooks;
+
+        /* Possible race condition here: The tx_mt interrupt bit may be
+         * cleared without the intervention of the interrupt handler,
+         * e.g. by a write.  If the top level interrupt handler reads a
+         * tx_mt, then some other processor does a write, starting up
+         * output, then we come in here, see the tx_mt and stop DMA, the
+         * output started by the other processor will hang.  Thus we can
+         * only rely on tx_mt being legitimate if it is read while the
+         * port lock is held.  Therefore this bit must be ignored in the
+         * passed in interrupt mask which was read by the top level
+         * interrupt handler since the port lock was not held at the time
+         * it was read.  We can only rely on this bit being accurate if it
+         * is read while the port lock is held.  So we'll clear it for now,
+         * and reload it later once we have the port lock.
+         */
+
+        sio_ir = pending & ~(hooks->intr_tx_mt);
+        spin_lock_irqsave(&port->ip_lock, flags);
+
+        loop_counter = MAXITER; /* to avoid hangs */
+
+        do {
+                uint32_t shadow;
+
+                if (loop_counter-- <= 0) {
+                        printk(KERN_WARNING "IOC3 serial: "
+                               "possible hang condition/"
+                               "port stuck on interrupt (line %d).\n",
+                                ((struct uart_port *)port->ip_port)->line);
+                        break;
+                }
+                /* Handle a DCD change */
+                if (sio_ir & hooks->intr_delta_dcd) {
+                        ioc3_ack(is, idd, hooks->intr_delta_dcd);
+                        shadow = readl(&port->ip_serial_regs->shadow);
+
+                        if ((port->ip_notify & N_DDCD)
+                            && (shadow & SHADOW_DCD)
+                            && (port->ip_port)) {
+                                the_port = port->ip_port;
+                                uart_handle_dcd_change(the_port,
+                                                shadow & SHADOW_DCD);
+                                wake_up_interruptible
+                                    (&the_port->info->delta_msr_wait);
+                        } else if ((port->ip_notify & N_DDCD)
+                                   && !(shadow & SHADOW_DCD)) {
+                                /* Flag delta DCD/no DCD */
+                                uart_handle_dcd_change(port->ip_port,
+                                                shadow & SHADOW_DCD);
+                                port->ip_flags |= DCD_ON;
+                        }
+                }
+
+                /* Handle a CTS change */
+                if (sio_ir & hooks->intr_delta_cts) {
+                        ioc3_ack(is, idd, hooks->intr_delta_cts);
+                        shadow = readl(&port->ip_serial_regs->shadow);
+
+                        if ((port->ip_notify & N_DCTS) && (port->ip_port)) {
+                                the_port = port->ip_port;
+                                uart_handle_cts_change(the_port, shadow
+                                                & SHADOW_CTS);
+                                wake_up_interruptible
+                                    (&the_port->info->delta_msr_wait);
+                        }
+                }
+
+                /* rx timeout interrupt.  Must be some data available.  Put this
+                 * before the check for rx_high since servicing this condition
+                 * may cause that condition to clear.
+                 */
+                if (sio_ir & hooks->intr_rx_timer) {
+                        ioc3_ack(is, idd, hooks->intr_rx_timer);
+                        if ((port->ip_notify & N_DATA_READY)
+                                                && (port->ip_port)) {
+                                receive_chars(port->ip_port);
+                        }
+                }
+
+                /* rx high interrupt. Must be after rx_timer.  */
+                else if (sio_ir & hooks->intr_rx_high) {
+                        /* Data available, notify upper layer */
+                        if ((port->ip_notify & N_DATA_READY) && port->ip_port) {
+                                receive_chars(port->ip_port);
+                        }
+
+                        /* We can't ACK this interrupt.  If receive_chars didn't
+                         * cause the condition to clear, we'll have to disable
+                         * the interrupt until the data is drained.
+                         * If the read was aborted, don't disable the interrupt
+                         * as this may cause us to hang indefinitely.  An
+                         * aborted read generally means that this interrupt
+                         * hasn't been delivered to the cpu yet anyway, even
+                         * though we see it as asserted when we read the sio_ir.
+                         */
+                        if ((sio_ir = PENDING(card_ptr, idd))
+                                        & hooks->intr_rx_high) {
+                                if (port->ip_flags & READ_ABORTED) {
+                                        rx_high_rd_aborted++;
+                                }
+                                else {
+                                        card_ptr->ic_enable &= ~hooks->intr_rx_high;
+                                        port->ip_flags |= INPUT_HIGH;
+                                }
+                        }
+                }
+
+                /* We got a low water interrupt: notify upper layer to
+                 * send more data.  Must come before tx_mt since servicing
+                 * this condition may cause that condition to clear.
+                 */
+                if (sio_ir & hooks->intr_tx_explicit) {
+                        port->ip_flags &= ~LOWAT_WRITTEN;
+                        ioc3_ack(is, idd, hooks->intr_tx_explicit);
+                        if (port->ip_notify & N_OUTPUT_LOWAT)
+                                ioc3_cb_output_lowat(port);
+                }
+
+                /* Handle tx_mt.  Must come after tx_explicit.  */
+                else if (sio_ir & hooks->intr_tx_mt) {
+                        /* If we are expecting a lowat notification
+                         * and we get to this point it probably means that for
+                         * some reason the tx_explicit didn't work as expected
+                         * (that can legitimately happen if the output buffer is
+                         * filled up in just the right way).
+                         * So send the notification now.
+                         */
+                        if (port->ip_notify & N_OUTPUT_LOWAT) {
+                                ioc3_cb_output_lowat(port);
+
+                                /* We need to reload the sio_ir since the lowat
+                                 * call may have caused another write to occur,
+                                 * clearing the tx_mt condition.
+                                 */
+                                sio_ir = PENDING(card_ptr, idd);
+                        }
+
+                        /* If the tx_mt condition still persists even after the
+                         * lowat call, we've got some work to do.
+                         */
+                        if (sio_ir & hooks->intr_tx_mt) {
+                                /* If we are not currently expecting DMA input,
+                                 * and the transmitter has just gone idle,
+                                 * there is no longer any reason for DMA, so
+                                 * disable it.
+                                 */
+                                if (!(port->ip_notify
+                                      & (N_DATA_READY | N_DDCD))) {
+                                        BUG_ON(!(port->ip_sscr
+                                                 & SSCR_DMA_EN));
+                                        port->ip_sscr &= ~SSCR_DMA_EN;
+                                        writel(port->ip_sscr,
+                                               &port->ip_serial_regs->sscr);
+                                }
+                                /* Prevent infinite tx_mt interrupt */
+                                card_ptr->ic_enable &= ~hooks->intr_tx_mt;
+                        }
+                }
+                sio_ir = PENDING(card_ptr, idd);
+
+                /* if the read was aborted and only hooks->intr_rx_high,
+                 * clear hooks->intr_rx_high, so we do not loop forever.
+                 */
+
+                if (rx_high_rd_aborted && (sio_ir == hooks->intr_rx_high)) {
+                        sio_ir &= ~hooks->intr_rx_high;
+                }
+        } while (sio_ir & hooks->intr_all);
+
+        spin_unlock_irqrestore(&port->ip_lock, flags);
+        ioc3_enable(is, idd, card_ptr->ic_enable);
+        return 0;
+}
+
+/**
+ * ioc3uart_intr - field all serial interrupts
+ * @is : submodule
+ * @idd: driver data
+ * @pending: interrupts to handle
+ * @regs: pt_regs
+ *
+ */
+
+static int ioc3uart_intr(struct ioc3_submodule *is,
+                        struct ioc3_driver_data *idd,
+                        unsigned int pending, struct pt_regs *regs)
+{
+        int ret = 0;
+
+        /*
+         * The upper level interrupt handler sends interrupts for both ports
+         * here. So we need to call for each port with its interrupts.
+         */
+
+        if (pending & SIO_IR_SA)
+                ret |= ioc3uart_intr_one(is, idd, pending & SIO_IR_SA, regs);
+        if (pending & SIO_IR_SB)
+                ret |= ioc3uart_intr_one(is, idd, pending & SIO_IR_SB, regs);
+
+        return ret;
+}
+
+/**
+ * ic3_type
+ * @port: Port to operate with (we ignore since we only have one port)
+ *
+ */
+static const char *ic3_type(struct uart_port *the_port)
+{
+        if (IS_RS232(the_port->line))
+                return "SGI IOC3 Serial [rs232]";
+        else
+                return "SGI IOC3 Serial [rs422]";
+}
+
+/**
+ * ic3_tx_empty - Is the transmitter empty?
+ * @port: Port to operate on
+ *
+ */
+static unsigned int ic3_tx_empty(struct uart_port *the_port)
+{
+        unsigned int ret = 0;
+        struct ioc3_port *port = get_ioc3_port(the_port);
+
+        if (readl(&port->ip_serial_regs->shadow) & SHADOW_TEMT)
+                ret = TIOCSER_TEMT;
+        return ret;
+}
+
+/**
+ * ic3_stop_tx - stop the transmitter
+ * @port: Port to operate on
+ *
+ */
+static void ic3_stop_tx(struct uart_port *the_port)
+{
+        struct ioc3_port *port = get_ioc3_port(the_port);
+
+        if (port)
+                set_notification(port, N_OUTPUT_LOWAT, 0);
+}
+
+/**
+ * ic3_stop_rx - stop the receiver
+ * @port: Port to operate on
+ *
+ */
+static void ic3_stop_rx(struct uart_port *the_port)
+{
+        struct ioc3_port *port = get_ioc3_port(the_port);
+
+        if (port)
+                port->ip_flags &= ~INPUT_ENABLE;
+}
+
+/**
+ * null_void_function
+ * @port: Port to operate on
+ *
+ */
+static void null_void_function(struct uart_port *the_port)
+{
+}
+
+/**
+ * ic3_shutdown - shut down the port - free irq and disable
+ * @port: port to shut down
+ *
+ */
+static void ic3_shutdown(struct uart_port *the_port)
+{
+        unsigned long port_flags;
+        struct ioc3_port *port;
+        struct uart_info *info;
+
+        port = get_ioc3_port(the_port);
+        if (!port)
+                return;
+
+        info = the_port->info;
+        wake_up_interruptible(&info->delta_msr_wait);
+
+        spin_lock_irqsave(&the_port->lock, port_flags);
+        set_notification(port, N_ALL, 0);
+        spin_unlock_irqrestore(&the_port->lock, port_flags);
+}
+
+/**
+ * ic3_set_mctrl - set control lines (dtr, rts, etc)
+ * @port: Port to operate on
+ * @mctrl: Lines to set/unset
+ *
+ */
+static void ic3_set_mctrl(struct uart_port *the_port, unsigned int mctrl)
+{
+        unsigned char mcr = 0;
+
+        if (mctrl & TIOCM_RTS)
+                mcr |= UART_MCR_RTS;
+        if (mctrl & TIOCM_DTR)
+                mcr |= UART_MCR_DTR;
+        if (mctrl & TIOCM_OUT1)
+                mcr |= UART_MCR_OUT1;
+        if (mctrl & TIOCM_OUT2)
+                mcr |= UART_MCR_OUT2;
+        if (mctrl & TIOCM_LOOP)
+                mcr |= UART_MCR_LOOP;
+
+        set_mcr(the_port, mcr, SHADOW_DTR);
+}
+
+/**
+ * ic3_get_mctrl - get control line info
+ * @port: port to operate on
+ *
+ */
+static unsigned int ic3_get_mctrl(struct uart_port *the_port)
+{
+        struct ioc3_port *port = get_ioc3_port(the_port);
+        uint32_t shadow;
+        unsigned int ret = 0;
+
+        if (!port)
+                return 0;
+
+        shadow = readl(&port->ip_serial_regs->shadow);
+        if (shadow & SHADOW_DCD)
+                ret |= TIOCM_CD;
+        if (shadow & SHADOW_DR)
+                ret |= TIOCM_DSR;
+        if (shadow & SHADOW_CTS)
+                ret |= TIOCM_CTS;
+        return ret;
+}
+
+/**
+ * ic3_start_tx - Start transmitter. Called with the_port->lock
+ * @port: Port to operate on
+ *
+ */
+static void ic3_start_tx(struct uart_port *the_port)
+{
+        struct ioc3_port *port = get_ioc3_port(the_port);
+
+        if (port) {
+                set_notification(port, N_OUTPUT_LOWAT, 1);
+                enable_intrs(port, port->ip_hooks->intr_tx_mt);
+        }
+}
+
+/**
+ * ic3_break_ctl - handle breaks
+ * @port: Port to operate on
+ * @break_state: Break state
+ *
+ */
+static void ic3_break_ctl(struct uart_port *the_port, int break_state)
+{
+}
+
+/**
+ * ic3_startup - Start up the serial port - always return 0 (We're always on)
+ * @port: Port to operate on
+ *
+ */
+static int ic3_startup(struct uart_port *the_port)
+{
+        int retval;
+        struct ioc3_port *port;
+        struct ioc3_card *card_ptr;
+        unsigned long port_flags;
+
+        if (!the_port) {
+                NOT_PROGRESS();
+                return -ENODEV;
+        }
+        port = get_ioc3_port(the_port);
+        if (!port) {
+                NOT_PROGRESS();
+                return -ENODEV;
+        }
+        card_ptr = port->ip_card;
+        port->ip_port = the_port;
+
+        if (!card_ptr) {
+                NOT_PROGRESS();
+                return -ENODEV;
+        }
+
+        /* Start up the serial port */
+        spin_lock_irqsave(&the_port->lock, port_flags);
+        retval = ic3_startup_local(the_port);
+        spin_unlock_irqrestore(&the_port->lock, port_flags);
+        return retval;
+}
+
+/**
+ * ic3_set_termios - set termios stuff
+ * @port: port to operate on
+ * @termios: New settings
+ * @termios: Old
+ *
+ */
+static void
+ic3_set_termios(struct uart_port *the_port,
+                struct termios *termios, struct termios *old_termios)
+{
+        unsigned long port_flags;
+
+        spin_lock_irqsave(&the_port->lock, port_flags);
+        ioc3_change_speed(the_port, termios, old_termios);
+        spin_unlock_irqrestore(&the_port->lock, port_flags);
+}
+
+/**
+ * ic3_request_port - allocate resources for port - no op....
+ * @port: port to operate on
+ *
+ */
+static int ic3_request_port(struct uart_port *port)
+{
+        return 0;
+}
+
+/* Associate the uart functions above - given to serial core */
+static struct uart_ops ioc3_ops = {
+        .tx_empty = ic3_tx_empty,
+        .set_mctrl = ic3_set_mctrl,
+        .get_mctrl = ic3_get_mctrl,
+        .stop_tx = ic3_stop_tx,
+        .start_tx = ic3_start_tx,
+        .stop_rx = ic3_stop_rx,
+        .enable_ms = null_void_function,
+        .break_ctl = ic3_break_ctl,
+        .startup = ic3_startup,
+        .shutdown = ic3_shutdown,
+        .set_termios = ic3_set_termios,
+        .type = ic3_type,
+        .release_port = null_void_function,
+        .request_port = ic3_request_port,
+};
+
+/*
+ * Boot-time initialization code
+ */
+
+static struct uart_driver ioc3_uart = {
+        .owner = THIS_MODULE,
+        .driver_name = "ioc3_serial",
+        .dev_name = DEVICE_NAME,
+        .major = DEVICE_MAJOR,
+        .minor = DEVICE_MINOR,
+        .nr = MAX_LOGICAL_PORTS
+};
+
+/**
+ * ioc3_serial_core_attach - register with serial core
+ *              This is done during pci probing
+ * @is: submodule struct for this
+ * @idd: handle for this card
+ */
+static inline int ioc3_serial_core_attach( struct ioc3_submodule *is,
+                                struct ioc3_driver_data *idd)
+{
+        struct ioc3_port *port;
+        struct uart_port *the_port;
+        struct ioc3_card *card_ptr = idd->data[is->id];
+        int ii, phys_port;
+        struct pci_dev *pdev = idd->pdev;
+
+        DPRINT_CONFIG(("%s: attach pdev 0x%p - card_ptr 0x%p\n",
+                       __FUNCTION__, pdev, (void *)card_ptr));
+
+        if (!card_ptr)
+                return -ENODEV;
+
+        /* once around for each logical port on this card */
+        for (ii = 0; ii < LOGICAL_PORTS_PER_CARD; ii++) {
+                phys_port = GET_PHYSICAL_PORT(ii);
+                the_port = &card_ptr->ic_port[phys_port].
+                                icp_uart_port[GET_LOGICAL_PORT(ii)];
+                port = card_ptr->ic_port[phys_port].icp_port;
+                port->ip_port = the_port;
+
+                DPRINT_CONFIG(("%s: attach the_port 0x%p / port 0x%p [%d/%d]\n",
+                        __FUNCTION__, (void *)the_port, (void *)port,
+                                phys_port, ii));
+
+                /* membase, iobase and mapbase just need to be non-0 */
+                the_port->membase = (unsigned char __iomem *)1;
+                the_port->iobase = (pdev->bus->number << 16) |  ii;
+                the_port->line = (Num_of_ioc3_cards << 2) | ii;
+                the_port->mapbase = 1;
+                the_port->type = PORT_16550A;
+                the_port->fifosize = FIFO_SIZE;
+                the_port->ops = &ioc3_ops;
+                the_port->irq = idd->irq_io;
+                the_port->dev = &pdev->dev;
+
+                if (uart_add_one_port(&ioc3_uart, the_port) < 0) {
+                        printk(KERN_WARNING
+                          "%s: unable to add port %d bus %d\n",
+                               __FUNCTION__, the_port->line, pdev->bus->number);
+                } else {
+                        DPRINT_CONFIG(("IOC3 serial port %d irq %d bus %d\n",
+                          the_port->line, the_port->irq, pdev->bus->number));
+                }
+
+                /* all ports are rs232 for now */
+                if (IS_PHYSICAL_PORT(ii))
+                        ioc3_set_proto(port, PROTO_RS232);
+        }
+        return 0;
+}
+
+/**
+ * ioc3uart_remove - register detach function
+ * @is: submodule struct for this submodule
+ * @idd: ioc3 driver data for this submodule
+ */
+
+static int ioc3uart_remove(struct ioc3_submodule *is,
+                        struct ioc3_driver_data *idd)
+{
+        struct ioc3_card *card_ptr = idd->data[is->id];
+        struct uart_port *the_port;
+        struct ioc3_port *port;
+        int ii;
+
+        if (card_ptr) {
+                for (ii = 0; ii < LOGICAL_PORTS_PER_CARD; ii++) {
+                        the_port = &card_ptr->ic_port[GET_PHYSICAL_PORT(ii)].
+                                        icp_uart_port[GET_LOGICAL_PORT(ii)];
+                        if (the_port)
+                                uart_remove_one_port(&ioc3_uart, the_port);
+                        port = card_ptr->ic_port[GET_PHYSICAL_PORT(ii)].icp_port;
+                        if (port && IS_PHYSICAL_PORT(ii)
+                                        && (GET_PHYSICAL_PORT(ii) == 0)) {
+                                pci_free_consistent(port->ip_idd->pdev,
+                                        TOTAL_RING_BUF_SIZE,
+                                        (void *)port->ip_cpu_ringbuf,
+                                        port->ip_dma_ringbuf);
+                                kfree(port);
+                                card_ptr->ic_port[GET_PHYSICAL_PORT(ii)].
+                                                        icp_port = NULL;
+                        }
+                }
+                kfree(card_ptr);
+                idd->data[is->id] = NULL;
+        }
+        return 0;
+}
+
+/**
+ * ioc3uart_probe - card probe function called from shim driver
+ * @is: submodule struct for this submodule
+ * @idd: ioc3 driver data for this card
+ */
+
+static int __devinit
+ioc3uart_probe(struct ioc3_submodule *is, struct ioc3_driver_data *idd)
+{
+        struct pci_dev *pdev = idd->pdev;
+        struct ioc3_card *card_ptr;
+        int ret = 0;
+        struct ioc3_port *port;
+        struct ioc3_port *ports[PORTS_PER_CARD];
+        int phys_port;
+
+        DPRINT_CONFIG(("%s (0x%p, 0x%p)\n", __FUNCTION__, is, idd));
+
+        card_ptr = kmalloc(sizeof(struct ioc3_card), GFP_KERNEL);
+        if (!card_ptr) {
+                printk(KERN_WARNING "ioc3_attach_one"
+                       ": unable to get memory for the IOC3\n");
+                return -ENOMEM;
+        }
+        memset(card_ptr, 0, sizeof(struct ioc3_card));
+        idd->data[is->id] = card_ptr;
+        Submodule_slot = is->id;
+
+        writel(((UARTA_BASE >> 3) << SIO_CR_SER_A_BASE_SHIFT) |
+                ((UARTB_BASE >> 3) << SIO_CR_SER_B_BASE_SHIFT) |
+                (0xf << SIO_CR_CMD_PULSE_SHIFT), &idd->vma->sio_cr);
+
+        pci_write_config_dword(pdev, PCI_LAT, 0xff00);
+
+        /* Enable serial port mode select generic PIO pins as outputs */
+        ioc3_gpcr_set(idd, GPCR_UARTA_MODESEL | GPCR_UARTB_MODESEL);
+
+        /* Create port structures for each port */
+        for (phys_port = 0; phys_port < PORTS_PER_CARD; phys_port++) {
+                port = kmalloc(sizeof(struct ioc3_port), GFP_KERNEL);
+                if (!port) {
+                        printk(KERN_WARNING
+                               "IOC3 serial memory not available for port\n");
+                        goto out4;
+                }
+                memset(port, 0, sizeof(struct ioc3_port));
+                spin_lock_init(&port->ip_lock);
+
+                /* we need to remember the previous ones, to point back to
+                 * them farther down - setting up the ring buffers.
+                 */
+                ports[phys_port] = port;
+
+                /* init to something useful */
+                card_ptr->ic_port[phys_port].icp_port = port;
+                port->ip_is = is;
+                port->ip_idd = idd;
+                port->ip_baud = 9600;
+                port->ip_card = card_ptr;
+                port->ip_hooks = &hooks_array[phys_port];
+
+                /* Setup each port */
+                if (phys_port == 0) {
+                        port->ip_serial_regs = &idd->vma->port_a;
+                        port->ip_uart_regs = &idd->vma->sregs.uarta;
+
+                        DPRINT_CONFIG(("%s : Port A ip_serial_regs 0x%p "
+                                       "ip_uart_regs 0x%p\n",
+                                       __FUNCTION__,
+                                       (void *)port->ip_serial_regs,
+                                       (void *)port->ip_uart_regs));
+
+                        /* setup ring buffers */
+                        port->ip_cpu_ringbuf = pci_alloc_consistent(pdev,
+                                TOTAL_RING_BUF_SIZE, &port->ip_dma_ringbuf);
+
+                        BUG_ON(!((((int64_t) port->ip_dma_ringbuf) &
+                                  (TOTAL_RING_BUF_SIZE - 1)) == 0));
+                        port->ip_inring = RING(port, RX_A);
+                        port->ip_outring = RING(port, TX_A);
+                        DPRINT_CONFIG(("%s : Port A ip_cpu_ringbuf 0x%p "
+                                       "ip_dma_ringbuf 0x%p, ip_inring 0x%p "
+                                        "ip_outring 0x%p\n",
+                                       __FUNCTION__,
+                                       (void *)port->ip_cpu_ringbuf,
+                                       (void *)port->ip_dma_ringbuf,
+                                       (void *)port->ip_inring,
+                                       (void *)port->ip_outring));
+                }
+                else {
+                        port->ip_serial_regs = &idd->vma->port_b;
+                        port->ip_uart_regs = &idd->vma->sregs.uartb;
+
+                        DPRINT_CONFIG(("%s : Port B ip_serial_regs 0x%p "
+                                       "ip_uart_regs 0x%p\n",
+                                       __FUNCTION__,
+                                       (void *)port->ip_serial_regs,
+                                       (void *)port->ip_uart_regs));
+
+                        /* share the ring buffers */
+                        port->ip_dma_ringbuf =
+                            ports[phys_port - 1]->ip_dma_ringbuf;
+                        port->ip_cpu_ringbuf =
+                            ports[phys_port - 1]->ip_cpu_ringbuf;
+                        port->ip_inring = RING(port, RX_B);
+                        port->ip_outring = RING(port, TX_B);
+                        DPRINT_CONFIG(("%s : Port B ip_cpu_ringbuf 0x%p "
+                                       "ip_dma_ringbuf 0x%p, ip_inring 0x%p "
+                                        "ip_outring 0x%p\n",
+                                       __FUNCTION__,
+                                       (void *)port->ip_cpu_ringbuf,
+                                       (void *)port->ip_dma_ringbuf,
+                                       (void *)port->ip_inring,
+                                       (void *)port->ip_outring));
+                }
+
+                DPRINT_CONFIG(("%s : port %d [addr 0x%p] card_ptr 0x%p",
+                               __FUNCTION__,
+                               phys_port, (void *)port, (void *)card_ptr));
+                DPRINT_CONFIG((" ip_serial_regs 0x%p ip_uart_regs 0x%p\n",
+                               (void *)port->ip_serial_regs,
+                               (void *)port->ip_uart_regs));
+
+                /* Initialize the hardware for IOC3 */
+                port_init(port);
+
+                DPRINT_CONFIG(("%s: phys_port %d port 0x%p inring 0x%p "
+                               "outring 0x%p\n",
+                               __FUNCTION__,
+                               phys_port, (void *)port,
+                               (void *)port->ip_inring,
+                               (void *)port->ip_outring));
+
+        }
+
+        /* register port with the serial core */
+
+        if ((ret = ioc3_serial_core_attach(is, idd)))
+                goto out4;
+
+        Num_of_ioc3_cards++;
+
+        return ret;
+
+        /* error exits that give back resources */
+out4:
+        kfree(card_ptr);
+        return ret;
+}
+
+static struct ioc3_submodule ioc3uart_submodule = {
+        .name = "IOC3uart",
+        .probe = ioc3uart_probe,
+        .remove = ioc3uart_remove,
+        /* call .intr for both ports initially */
+        .irq_mask = SIO_IR_SA | SIO_IR_SB,
+        .intr = ioc3uart_intr,
+        .owner = THIS_MODULE,
+};
+
+/**
+ * ioc3_detect - module init called,
+ */
+static int __devinit ioc3uart_init(void)
+{
+        int ret;
+
+        /* register with serial core */
+        if ((ret = uart_register_driver(&ioc3_uart)) < 0) {
+                printk(KERN_WARNING
+                       "%s: Couldn't register IOC3 uart serial driver\n",
+                       __FUNCTION__);
+                return ret;
+        }
+        ret = ioc3_register_submodule(&ioc3uart_submodule);
+        if (ret)
+                uart_unregister_driver(&ioc3_uart);
+        return ret;
+}
+
+static void __devexit ioc3uart_exit(void)
+{
+        ioc3_unregister_submodule(&ioc3uart_submodule);
+        uart_unregister_driver(&ioc3_uart);
+}
+
+module_init(ioc3uart_init);
+module_exit(ioc3uart_exit);
+
+MODULE_AUTHOR("Pat Gefre - Silicon Graphics Inc. (SGI) <pfg@sgi.com>");
+MODULE_DESCRIPTION("Serial PCI driver module for SGI IOC3 card");
+MODULE_LICENSE("GPL");
diff --git a/drivers/sh/superhyway/superhyway.c b/drivers/sh/superhyway/superhyway.c
index 7bdab2a7f59c..94b229031198 100644
--- a/drivers/sh/superhyway/superhyway.c
+++ b/drivers/sh/superhyway/superhyway.c
@@ -175,8 +175,6 @@ int superhyway_register_driver(struct superhyway_driver *drv)
 {
         drv->drv.name   = drv->name;
         drv->drv.bus    = &superhyway_bus_type;
-        drv->drv.probe  = superhyway_device_probe;
-        drv->drv.remove = superhyway_device_remove;
 
         return driver_register(&drv->drv);
 }
@@ -213,6 +211,8 @@ struct bus_type superhyway_bus_type = {
 #ifdef CONFIG_SYSFS
         .dev_attrs      = superhyway_dev_attrs,
 #endif
+        .probe          = superhyway_device_probe,
+        .remove         = superhyway_device_remove,
 };
 
 static int __init superhyway_bus_init(void)
diff --git a/drivers/sn/Kconfig b/drivers/sn/Kconfig
index 13b8d249da5c..d95265b187a3 100644
--- a/drivers/sn/Kconfig
+++ b/drivers/sn/Kconfig
@@ -17,4 +17,18 @@ config SGI_IOC4
         If you have an SGI Altix with an IOC4-based
         I/O controller say Y.  Otherwise say N.
 
+config SGI_IOC3
+        tristate "SGI IOC3 Base IO support"
+        depends on (IA64_GENERIC || IA64_SGI_SN2)
+        default m
+        ---help---
+        This option enables basic support for the SGI IOC3-based Base IO
+        controller card.  This option does not enable any specific
+        functions on such a card, but provides necessary infrastructure
+        for other drivers to utilize.
+
+        If you have an SGI Altix with an IOC3-based
+        I/O controller or a PCI IOC3 serial card say Y.
+        Otherwise say N.
+
 endmenu
diff --git a/drivers/sn/Makefile b/drivers/sn/Makefile
index c2a284185372..2cda011597c0 100644
--- a/drivers/sn/Makefile
+++ b/drivers/sn/Makefile
@@ -4,3 +4,4 @@
 #
 
 obj-$(CONFIG_SGI_IOC4) += ioc4.o
+obj-$(CONFIG_SGI_IOC3) += ioc3.o
diff --git a/drivers/sn/ioc3.c b/drivers/sn/ioc3.c
new file mode 100644
index 000000000000..aaa009f4a7bf
--- /dev/null
+++ b/drivers/sn/ioc3.c
@@ -0,0 +1,851 @@
+/*
+ * SGI IOC3 master driver and IRQ demuxer
+ *
+ * Copyright (c) 2005 Stanislaw Skowronek <skylark@linux-mips.org>
+ * Heavily based on similar work by:
+ *   Brent Casavant <bcasavan@sgi.com> - IOC4 master driver
+ *   Pat Gefre <pfg@sgi.com> - IOC3 serial port IRQ demuxer
+ */
+
+#include <linux/config.h>
+#include <linux/errno.h>
+#include <linux/module.h>
+#include <linux/pci.h>
+#include <linux/interrupt.h>
+#include <linux/spinlock.h>
+#include <linux/delay.h>
+#include <linux/ioc3.h>
+#include <linux/rwsem.h>
+
+#define IOC3_PCI_SIZE 0x100000
+
+static LIST_HEAD(ioc3_devices);
+static int ioc3_counter;
+static DECLARE_RWSEM(ioc3_devices_rwsem);
+
+static struct ioc3_submodule *ioc3_submodules[IOC3_MAX_SUBMODULES];
+static struct ioc3_submodule *ioc3_ethernet;
+static rwlock_t ioc3_submodules_lock = RW_LOCK_UNLOCKED;
+
+/* NIC probing code */
+
+#define GPCR_MLAN_EN    0x00200000      /* enable MCR to pin 8 */
+
+static inline unsigned mcr_pack(unsigned pulse, unsigned sample)
+{
+        return (pulse << 10) | (sample << 2);
+}
+
+static int nic_wait(struct ioc3_driver_data *idd)
+{
+        volatile unsigned mcr;
+
+        do {
+                mcr = (volatile unsigned)idd->vma->mcr;
+        } while (!(mcr & 2));
+
+        return mcr & 1;
+}
+
+static int nic_reset(struct ioc3_driver_data *idd)
+{
+        int presence;
+        unsigned long flags;
+
+        local_irq_save(flags);
+        idd->vma->mcr = mcr_pack(500, 65);
+        presence = nic_wait(idd);
+        local_irq_restore(flags);
+
+        udelay(500);
+
+        return presence;
+}
+
+static inline int nic_read_bit(struct ioc3_driver_data *idd)
+{
+        int result;
+        unsigned long flags;
+
+        local_irq_save(flags);
+        idd->vma->mcr = mcr_pack(6, 13);
+        result = nic_wait(idd);
+        local_irq_restore(flags);
+
+        udelay(500);
+
+        return result;
+}
+
+static inline void nic_write_bit(struct ioc3_driver_data *idd, int bit)
+{
+        if (bit)
+                idd->vma->mcr = mcr_pack(6, 110);
+        else
+                idd->vma->mcr = mcr_pack(80, 30);
+
+        nic_wait(idd);
+}
+
+static unsigned nic_read_byte(struct ioc3_driver_data *idd)
+{
+        unsigned result = 0;
+        int i;
+
+        for (i = 0; i < 8; i++)
+                result = (result >> 1) | (nic_read_bit(idd) << 7);
+
+        return result;
+}
+
+static void nic_write_byte(struct ioc3_driver_data *idd, int byte)
+{
+        int i, bit;
+
+        for (i = 8; i; i--) {
+                bit = byte & 1;
+                byte >>= 1;
+
+                nic_write_bit(idd, bit);
+        }
+}
+
+static unsigned long
+nic_find(struct ioc3_driver_data *idd, int *last, unsigned long addr)
+{
+        int a, b, index, disc;
+
+        nic_reset(idd);
+
+        /* Search ROM.  */
+        nic_write_byte(idd, 0xF0);
+
+        /* Algorithm from ``Book of iButton Standards''.  */
+        for (index = 0, disc = 0; index < 64; index++) {
+                a = nic_read_bit(idd);
+                b = nic_read_bit(idd);
+
+                if (a && b) {
+                        printk(KERN_WARNING "IOC3 NIC search failed.\n");
+                        *last = 0;
+                        return 0;
+                }
+
+                if (!a && !b) {
+                        if (index == *last) {
+                                addr |= 1UL << index;
+                        } else if (index > *last) {
+                                addr &= ~(1UL << index);
+                                disc = index;
+                        } else if ((addr & (1UL << index)) == 0)
+                                disc = index;
+                        nic_write_bit(idd, (addr>>index)&1);
+                        continue;
+                } else {
+                        if (a)
+                                addr |= 1UL << index;
+                        else
+                                addr &= ~(1UL << index);
+                        nic_write_bit(idd, a);
+                        continue;
+                }
+        }
+        *last = disc;
+        return addr;
+}
+
+static void nic_addr(struct ioc3_driver_data *idd, unsigned long addr)
+{
+        int index;
+
+        nic_reset(idd);
+        nic_write_byte(idd, 0xF0);
+        for (index = 0; index < 64; index++) {
+                nic_read_bit(idd);
+                nic_read_bit(idd);
+                nic_write_bit(idd, (addr>>index)&1);
+        }
+}
+
+static void crc16_byte(unsigned int *crc, unsigned char db)
+{
+        int i;
+
+        for(i=0;i<8;i++) {
+                *crc <<= 1;
+                if((db^(*crc>>16)) & 1)
+                        *crc ^= 0x8005;
+                db >>= 1;
+        }
+        *crc &= 0xFFFF;
+}
+
+static unsigned int crc16_area(unsigned char *dbs, int size, unsigned int crc)
+{
+        while(size--)
+                crc16_byte(&crc, *(dbs++));
+        return crc;
+}
+
+static void crc8_byte(unsigned int *crc, unsigned char db)
+{
+        int i,f;
+
+        for(i=0;i<8;i++) {
+                f = (*crc ^ db) & 1;
+                *crc >>= 1;
+                db >>= 1;
+                if(f)
+                        *crc ^= 0x8c;
+        }
+        *crc &= 0xff;
+}
+
+static unsigned int crc8_addr(unsigned long addr)
+{
+        int i;
+        unsigned int crc = 0x00;
+
+        for(i=0;i<8;i++)
+                crc8_byte(&crc, addr>>(i<<3));
+        return crc;
+}
+
+static void
+read_redir_page(struct ioc3_driver_data *idd, unsigned long addr, int page,
+                        unsigned char *redir, unsigned char *data)
+{
+        int loops = 16, i;
+
+        while(redir[page] != 0xFF) {
+                page = redir[page]^0xFF;
+                loops--;
+                if(loops<0) {
+                        printk(KERN_ERR "IOC3: NIC circular redirection\n");
+                        return;
+                }
+        }
+        loops = 3;
+        while(loops>0) {
+                nic_addr(idd, addr);
+                nic_write_byte(idd, 0xF0);
+                nic_write_byte(idd, (page << 5) & 0xE0);
+                nic_write_byte(idd, (page >> 3) & 0x1F);
+                for(i=0;i<0x20;i++)
+                        data[i] = nic_read_byte(idd);
+                if(crc16_area(data, 0x20, 0x0000) == 0x800d)
+                        return;
+                loops--;
+        }
+        printk(KERN_ERR "IOC3: CRC error in data page\n");
+        for(i=0;i<0x20;i++)
+                data[i] = 0x00;
+}
+
+static void
+read_redir_map(struct ioc3_driver_data *idd, unsigned long addr,
+                                         unsigned char *redir)
+{
+        int i,j,loops = 3,crc_ok;
+        unsigned int crc;
+
+        while(loops>0) {
+                crc_ok = 1;
+                nic_addr(idd, addr);
+                nic_write_byte(idd, 0xAA);
+                nic_write_byte(idd, 0x00);
+                nic_write_byte(idd, 0x01);
+                for(i=0;i<64;i+=8) {
+                        for(j=0;j<8;j++)
+                                redir[i+j] = nic_read_byte(idd);
+                        crc = crc16_area(redir+i, 8, (i==0)?0x8707:0x0000);
+                        crc16_byte(&crc, nic_read_byte(idd));
+                        crc16_byte(&crc, nic_read_byte(idd));
+                        if(crc != 0x800d)
+                                crc_ok = 0;
+                }
+                if(crc_ok)
+                        return;
+                loops--;
+        }
+        printk(KERN_ERR "IOC3: CRC error in redirection page\n");
+        for(i=0;i<64;i++)
+                redir[i] = 0xFF;
+}
+
+static void read_nic(struct ioc3_driver_data *idd, unsigned long addr)
+{
+        unsigned char redir[64];
+        unsigned char data[64],part[32];
+        int i,j;
+
+        /* read redirections */
+        read_redir_map(idd, addr, redir);
+        /* read data pages */
+        read_redir_page(idd, addr, 0, redir, data);
+        read_redir_page(idd, addr, 1, redir, data+32);
+        /* assemble the part # */
+        j=0;
+        for(i=0;i<19;i++)
+                if(data[i+11] != ' ')
+                        part[j++] = data[i+11];
+        for(i=0;i<6;i++)
+                if(data[i+32] != ' ')
+                        part[j++] = data[i+32];
+        part[j] = 0;
+        /* skip Octane power supplies */
+        if(!strncmp(part, "060-0035-", 9))
+                return;
+        if(!strncmp(part, "060-0038-", 9))
+                return;
+        strcpy(idd->nic_part, part);
+        /* assemble the serial # */
+        j=0;
+        for(i=0;i<10;i++)
+                if(data[i+1] != ' ')
+                        idd->nic_serial[j++] = data[i+1];
+        idd->nic_serial[j] = 0;
+}
+
+static void read_mac(struct ioc3_driver_data *idd, unsigned long addr)
+{
+        int i, loops = 3;
+        unsigned char data[13];
+
+        while(loops>0) {
+                nic_addr(idd, addr);
+                nic_write_byte(idd, 0xF0);
+                nic_write_byte(idd, 0x00);
+                nic_write_byte(idd, 0x00);
+                nic_read_byte(idd);
+                for(i=0;i<13;i++)
+                        data[i] = nic_read_byte(idd);
+                if(crc16_area(data, 13, 0x0000) == 0x800d) {
+                        for(i=10;i>4;i--)
+                                idd->nic_mac[10-i] = data[i];
+                        return;
+                }
+                loops--;
+        }
+        printk(KERN_ERR "IOC3: CRC error in MAC address\n");
+        for(i=0;i<6;i++)
+                idd->nic_mac[i] = 0x00;
+}
+
+static void probe_nic(struct ioc3_driver_data *idd)
+{
+        int save = 0, loops = 3;
+        unsigned long first, addr;
+
+        idd->vma->gpcr_s = GPCR_MLAN_EN;
+
+        while(loops>0) {
+                idd->nic_part[0] = 0;
+                idd->nic_serial[0] = 0;
+                addr = first = nic_find(idd, &save, 0);
+                if(!first)
+                        return;
+                while(1) {
+                        if(crc8_addr(addr))
+                                break;
+                        else {
+                                switch(addr & 0xFF) {
+                                case 0x0B:
+                                        read_nic(idd, addr);
+                                        break;
+                                case 0x09:
+                                case 0x89:
+                                case 0x91:
+                                        read_mac(idd, addr);
+                                        break;
+                                }
+                        }
+                        addr = nic_find(idd, &save, addr);
+                        if(addr == first)
+                                return;
+                }
+                loops--;
+        }
+        printk(KERN_ERR "IOC3: CRC error in NIC address\n");
+}
+
+/* Interrupts */
+
+static inline void
+write_ireg(struct ioc3_driver_data *idd, uint32_t val, int which)
+{
+        unsigned long flags;
+
+        spin_lock_irqsave(&idd->ir_lock, flags);
+        switch (which) {
+        case IOC3_W_IES:
+                writel(val, &idd->vma->sio_ies);
+                break;
+        case IOC3_W_IEC:
+                writel(val, &idd->vma->sio_iec);
+                break;
+        }
+        spin_unlock_irqrestore(&idd->ir_lock, flags);
+}
+static inline uint32_t get_pending_intrs(struct ioc3_driver_data *idd)
+{
+        unsigned long flag;
+        uint32_t intrs = 0;
+
+        spin_lock_irqsave(&idd->ir_lock, flag);
+        intrs = readl(&idd->vma->sio_ir);
+        intrs &= readl(&idd->vma->sio_ies);
+        spin_unlock_irqrestore(&idd->ir_lock, flag);
+        return intrs;
+}
+
+static irqreturn_t ioc3_intr_io(int irq, void *arg, struct pt_regs *regs)
+{
+        unsigned long flags;
+        struct ioc3_driver_data *idd = (struct ioc3_driver_data *)arg;
+        int handled = 1, id;
+        unsigned int pending;
+
+        read_lock_irqsave(&ioc3_submodules_lock, flags);
+
+        if(idd->dual_irq && idd->vma->eisr) {
+                /* send Ethernet IRQ to the driver */
+                if(ioc3_ethernet && idd->active[ioc3_ethernet->id] &&
+                                                ioc3_ethernet->intr) {
+                        handled = handled && !ioc3_ethernet->intr(ioc3_ethernet,
+                                                        idd, 0, regs);
+                }
+        }
+        pending = get_pending_intrs(idd);       /* look at the IO IRQs */
+
+        for(id=0;id<IOC3_MAX_SUBMODULES;id++) {
+                if(idd->active[id] && ioc3_submodules[id]
+                                && (pending & ioc3_submodules[id]->irq_mask)
+                                && ioc3_submodules[id]->intr) {
+                        write_ireg(idd, ioc3_submodules[id]->irq_mask,
+                                                        IOC3_W_IEC);
+                        if(!ioc3_submodules[id]->intr(ioc3_submodules[id],
+                                   idd, pending & ioc3_submodules[id]->irq_mask,
+                                        regs))
+                                pending &= ~ioc3_submodules[id]->irq_mask;
+                        if (ioc3_submodules[id]->reset_mask)
+                                write_ireg(idd, ioc3_submodules[id]->irq_mask,
+                                                        IOC3_W_IES);
+                }
+        }
+        read_unlock_irqrestore(&ioc3_submodules_lock, flags);
+        if(pending) {
+                printk(KERN_WARNING
+                  "IOC3: Pending IRQs 0x%08x discarded and disabled\n",pending);
+                write_ireg(idd, pending, IOC3_W_IEC);
+                handled = 1;
+        }
+        return handled?IRQ_HANDLED:IRQ_NONE;
+}
+
+static irqreturn_t ioc3_intr_eth(int irq, void *arg, struct pt_regs *regs)
+{
+        unsigned long flags;
+        struct ioc3_driver_data *idd = (struct ioc3_driver_data *)arg;
+        int handled = 1;
+
+        if(!idd->dual_irq)
+                return IRQ_NONE;
+        read_lock_irqsave(&ioc3_submodules_lock, flags);
+        if(ioc3_ethernet && idd->active[ioc3_ethernet->id]
+                                && ioc3_ethernet->intr)
+                handled = handled && !ioc3_ethernet->intr(ioc3_ethernet, idd, 0,
+                                                                regs);
+        read_unlock_irqrestore(&ioc3_submodules_lock, flags);
+        return handled?IRQ_HANDLED:IRQ_NONE;
+}
+
+void ioc3_enable(struct ioc3_submodule *is,
+                                struct ioc3_driver_data *idd, unsigned int irqs)
+{
+        write_ireg(idd, irqs & is->irq_mask, IOC3_W_IES);
+}
+
+void ioc3_ack(struct ioc3_submodule *is, struct ioc3_driver_data *idd,
+                                unsigned int irqs)
+{
+        writel(irqs & is->irq_mask, &idd->vma->sio_ir);
+}
+
+void ioc3_disable(struct ioc3_submodule *is,
+                                struct ioc3_driver_data *idd, unsigned int irqs)
+{
+        write_ireg(idd, irqs & is->irq_mask, IOC3_W_IEC);
+}
+
+void ioc3_gpcr_set(struct ioc3_driver_data *idd, unsigned int val)
+{
+        unsigned long flags;
+        spin_lock_irqsave(&idd->gpio_lock, flags);
+        writel(val, &idd->vma->gpcr_s);
+        spin_unlock_irqrestore(&idd->gpio_lock, flags);
+}
+
+/* Keep it simple, stupid! */
+static int find_slot(void **tab, int max)
+{
+        int i;
+        for(i=0;i<max;i++)
+                if(!(tab[i]))
+                        return i;
+        return -1;
+}
+
+/* Register an IOC3 submodule */
+int ioc3_register_submodule(struct ioc3_submodule *is)
+{
+        struct ioc3_driver_data *idd;
+        int alloc_id;
+        unsigned long flags;
+
+        write_lock_irqsave(&ioc3_submodules_lock, flags);
+        alloc_id = find_slot((void **)ioc3_submodules, IOC3_MAX_SUBMODULES);
+        if(alloc_id != -1) {
+                ioc3_submodules[alloc_id] = is;
+                if(is->ethernet) {
+                        if(ioc3_ethernet==NULL)
+                                ioc3_ethernet=is;
+                        else
+                                printk(KERN_WARNING
+                                  "IOC3 Ethernet module already registered!\n");
+                }
+        }
+        write_unlock_irqrestore(&ioc3_submodules_lock, flags);
+
+        if(alloc_id == -1) {
+                printk(KERN_WARNING "Increase IOC3_MAX_SUBMODULES!\n");
+                return -ENOMEM;
+        }
+
+        is->id=alloc_id;
+
+        /* Initialize submodule for each IOC3 */
+        if (!is->probe)
+                return 0;
+
+        down_read(&ioc3_devices_rwsem);
+        list_for_each_entry(idd, &ioc3_devices, list) {
+                /* set to 1 for IRQs in probe */
+                idd->active[alloc_id] = 1;
+                idd->active[alloc_id] = !is->probe(is, idd);
+        }
+        up_read(&ioc3_devices_rwsem);
+
+        return 0;
+}
+
+/* Unregister an IOC3 submodule */
+void ioc3_unregister_submodule(struct ioc3_submodule *is)
+{
+        struct ioc3_driver_data *idd;
+        unsigned long flags;
+
+        write_lock_irqsave(&ioc3_submodules_lock, flags);
+        if(ioc3_submodules[is->id]==is)
+                ioc3_submodules[is->id]=NULL;
+        else
+                printk(KERN_WARNING
+                        "IOC3 submodule %s has wrong ID.\n",is->name);
+        if(ioc3_ethernet==is)
+                ioc3_ethernet = NULL;
+        write_unlock_irqrestore(&ioc3_submodules_lock, flags);
+
+        /* Remove submodule for each IOC3 */
+        down_read(&ioc3_devices_rwsem);
+        list_for_each_entry(idd, &ioc3_devices, list)
+                if(idd->active[is->id]) {
+                        if(is->remove)
+                                if(is->remove(is, idd))
+                                        printk(KERN_WARNING
+                                               "%s: IOC3 submodule %s remove failed "
+                                               "for pci_dev %s.\n",
+                                               __FUNCTION__, module_name(is->owner),
+                                               pci_name(idd->pdev));
+                        idd->active[is->id] = 0;
+                        if(is->irq_mask)
+                                write_ireg(idd, is->irq_mask, IOC3_W_IEC);
+                }
+        up_read(&ioc3_devices_rwsem);
+}
+
+/*********************
+ * Device management *
+ *********************/
+
+static char *
+ioc3_class_names[]={"unknown", "IP27 BaseIO", "IP30 system", "MENET 1/2/3",
+                        "MENET 4", "CADduo", "Altix Serial"};
+
+static int ioc3_class(struct ioc3_driver_data *idd)
+{
+        int res = IOC3_CLASS_NONE;
+        /* NIC-based logic */
+        if(!strncmp(idd->nic_part, "030-0891-", 9))
+                res = IOC3_CLASS_BASE_IP30;
+        if(!strncmp(idd->nic_part, "030-1155-", 9))
+                res = IOC3_CLASS_CADDUO;
+        if(!strncmp(idd->nic_part, "030-1657-", 9))
+                res = IOC3_CLASS_SERIAL;
+        if(!strncmp(idd->nic_part, "030-1664-", 9))
+                res = IOC3_CLASS_SERIAL;
+        /* total random heuristics */
+#ifdef CONFIG_SGI_IP27
+        if(!idd->nic_part[0])
+                res = IOC3_CLASS_BASE_IP27;
+#endif
+        /* print educational message */
+        printk(KERN_INFO "IOC3 part: [%s], serial: [%s] => class %s\n",
+                        idd->nic_part, idd->nic_serial, ioc3_class_names[res]);
+        return res;
+}
+/* Adds a new instance of an IOC3 card */
+static int ioc3_probe(struct pci_dev *pdev, const struct pci_device_id *pci_id)
+{
+        struct ioc3_driver_data *idd;
+        uint32_t pcmd;
+        int ret, id;
+
+        /* Enable IOC3 and take ownership of it */
+        if ((ret = pci_enable_device(pdev))) {
+                printk(KERN_WARNING
+                       "%s: Failed to enable IOC3 device for pci_dev %s.\n",
+                       __FUNCTION__, pci_name(pdev));
+                goto out;
+        }
+        pci_set_master(pdev);
+
+#ifdef USE_64BIT_DMA
+        ret = pci_set_dma_mask(pdev, 0xffffffffffffffffULL);
+        if (!ret) {
+                ret = pci_set_consistent_dma_mask(pdev, 0xffffffffffffffffULL);
+                if (ret < 0) {
+                        printk(KERN_WARNING "%s: Unable to obtain 64 bit DMA "
+                               "for consistent allocations\n",
+                                __FUNCTION__);
+                }
+        }
+#endif
+
+        /* Set up per-IOC3 data */
+        idd = kmalloc(sizeof(struct ioc3_driver_data), GFP_KERNEL);
+        if (!idd) {
+                printk(KERN_WARNING
+                       "%s: Failed to allocate IOC3 data for pci_dev %s.\n",
+                       __FUNCTION__, pci_name(pdev));
+                ret = -ENODEV;
+                goto out_idd;
+        }
+        memset(idd, 0, sizeof(struct ioc3_driver_data));
+        spin_lock_init(&idd->ir_lock);
+        spin_lock_init(&idd->gpio_lock);
+        idd->pdev = pdev;
+
+        /* Map all IOC3 registers.  These are shared between subdevices
+         * so the main IOC3 module manages them.
+         */
+        idd->pma = pci_resource_start(pdev, 0);
+        if (!idd->pma) {
+                printk(KERN_WARNING
+                       "%s: Unable to find IOC3 resource "
+                       "for pci_dev %s.\n",
+                       __FUNCTION__, pci_name(pdev));
+                ret = -ENODEV;
+                goto out_pci;
+        }
+        if (!request_region(idd->pma, IOC3_PCI_SIZE, "ioc3")) {
+                printk(KERN_WARNING
+                       "%s: Unable to request IOC3 region "
+                       "for pci_dev %s.\n",
+                       __FUNCTION__, pci_name(pdev));
+                ret = -ENODEV;
+                goto out_pci;
+        }
+        idd->vma = ioremap(idd->pma, IOC3_PCI_SIZE);
+        if (!idd->vma) {
+                printk(KERN_WARNING
+                       "%s: Unable to remap IOC3 region "
+                       "for pci_dev %s.\n",
+                       __FUNCTION__, pci_name(pdev));
+                ret = -ENODEV;
+                goto out_misc_region;
+        }
+
+        /* Track PCI-device specific data */
+        pci_set_drvdata(pdev, idd);
+        down_write(&ioc3_devices_rwsem);
+        list_add(&idd->list, &ioc3_devices);
+        idd->id = ioc3_counter++;
+        up_write(&ioc3_devices_rwsem);
+
+        idd->gpdr_shadow = idd->vma->gpdr;
+
+        /* Read IOC3 NIC contents */
+        probe_nic(idd);
+
+        /* Detect IOC3 class */
+        idd->class = ioc3_class(idd);
+
+        /* Initialize IOC3 */
+       pci_read_config_dword(pdev, PCI_COMMAND, &pcmd);
+       pci_write_config_dword(pdev, PCI_COMMAND,
+                               pcmd | PCI_COMMAND_MEMORY |
+                               PCI_COMMAND_PARITY | PCI_COMMAND_SERR |
+                               PCI_SCR_DROP_MODE_EN);
+
+        write_ireg(idd, ~0, IOC3_W_IEC);
+        writel(~0, &idd->vma->sio_ir);
+
+        /* Set up IRQs */
+        if(idd->class == IOC3_CLASS_BASE_IP30
+                                || idd->class == IOC3_CLASS_BASE_IP27) {
+                writel(0, &idd->vma->eier);
+                writel(~0, &idd->vma->eisr);
+
+                idd->dual_irq = 1;
+                if (!request_irq(pdev->irq, ioc3_intr_eth, SA_SHIRQ,
+                                 "ioc3-eth", (void *)idd)) {
+                        idd->irq_eth = pdev->irq;
+                } else {
+                        printk(KERN_WARNING
+                               "%s : request_irq fails for IRQ 0x%x\n ",
+                               __FUNCTION__, pdev->irq);
+                }
+                if (!request_irq(pdev->irq+2, ioc3_intr_io, SA_SHIRQ,
+                                 "ioc3-io", (void *)idd)) {
+                        idd->irq_io = pdev->irq+2;
+                } else {
+                        printk(KERN_WARNING
+                               "%s : request_irq fails for IRQ 0x%x\n ",
+                               __FUNCTION__, pdev->irq+2);
+                }
+        } else {
+                if (!request_irq(pdev->irq, ioc3_intr_io, SA_SHIRQ,
+                                 "ioc3", (void *)idd)) {
+                        idd->irq_io = pdev->irq;
+                } else {
+                        printk(KERN_WARNING
+                               "%s : request_irq fails for IRQ 0x%x\n ",
+                               __FUNCTION__, pdev->irq);
+                }
+        }
+
+        /* Add this IOC3 to all submodules */
+        read_lock(&ioc3_submodules_lock);
+        for(id=0;id<IOC3_MAX_SUBMODULES;id++)
+                if(ioc3_submodules[id] && ioc3_submodules[id]->probe) {
+                        idd->active[id] = 1;
+                        idd->active[id] = !ioc3_submodules[id]->probe
+                                                (ioc3_submodules[id], idd);
+                }
+        read_unlock(&ioc3_submodules_lock);
+
+        printk(KERN_INFO "IOC3 Master Driver loaded for %s\n", pci_name(pdev));
+
+        return 0;
+
+out_misc_region:
+        release_region(idd->pma, IOC3_PCI_SIZE);
+out_pci:
+        kfree(idd);
+out_idd:
+        pci_disable_device(pdev);
+out:
+        return ret;
+}
+
+/* Removes a particular instance of an IOC3 card. */
+static void ioc3_remove(struct pci_dev *pdev)
+{
+        int id;
+        struct ioc3_driver_data *idd;
+
+        idd = pci_get_drvdata(pdev);
+
+        /* Remove this IOC3 from all submodules */
+        read_lock(&ioc3_submodules_lock);
+        for(id=0;id<IOC3_MAX_SUBMODULES;id++)
+                if(idd->active[id]) {
+                        if(ioc3_submodules[id] && ioc3_submodules[id]->remove)
+                                if(ioc3_submodules[id]->remove(ioc3_submodules[id],
+                                                                idd))
+                                        printk(KERN_WARNING
+                                               "%s: IOC3 submodule 0x%s remove failed "
+                                               "for pci_dev %s.\n",
+                                                __FUNCTION__,
+                                                module_name(ioc3_submodules[id]->owner),
+                                                pci_name(pdev));
+                        idd->active[id] = 0;
+                }
+        read_unlock(&ioc3_submodules_lock);
+
+        /* Clear and disable all IRQs */
+        write_ireg(idd, ~0, IOC3_W_IEC);
+        writel(~0, &idd->vma->sio_ir);
+
+        /* Release resources */
+        free_irq(idd->irq_io, (void *)idd);
+        if(idd->dual_irq)
+                free_irq(idd->irq_eth, (void *)idd);
+        iounmap(idd->vma);
+        release_region(idd->pma, IOC3_PCI_SIZE);
+
+        /* Disable IOC3 and relinquish */
+        pci_disable_device(pdev);
+
+        /* Remove and free driver data */
+        down_write(&ioc3_devices_rwsem);
+        list_del(&idd->list);
+        up_write(&ioc3_devices_rwsem);
+        kfree(idd);
+}
+
+static struct pci_device_id ioc3_id_table[] = {
+        {PCI_VENDOR_ID_SGI, PCI_DEVICE_ID_SGI_IOC3, PCI_ANY_ID, PCI_ANY_ID},
+        {0}
+};
+
+static struct pci_driver ioc3_driver = {
+        .name = "IOC3",
+        .id_table = ioc3_id_table,
+        .probe = ioc3_probe,
+        .remove = ioc3_remove,
+};
+
+MODULE_DEVICE_TABLE(pci, ioc3_id_table);
+
+/*********************
+ * Module management *
+ *********************/
+
+/* Module load */
+static int __devinit ioc3_init(void)
+{
+        if (ia64_platform_is("sn2"))
+                return pci_register_driver(&ioc3_driver);
+        return 0;
+}
+
+/* Module unload */
+static void __devexit ioc3_exit(void)
+{
+        pci_unregister_driver(&ioc3_driver);
+}
+
+module_init(ioc3_init);
+module_exit(ioc3_exit);
+
+MODULE_AUTHOR("Stanislaw Skowronek <skylark@linux-mips.org>");
+MODULE_DESCRIPTION("PCI driver for SGI IOC3");
+MODULE_LICENSE("GPL");
+
+EXPORT_SYMBOL(ioc3_register_submodule);
+EXPORT_SYMBOL(ioc3_unregister_submodule);
+EXPORT_SYMBOL(ioc3_ack);
+EXPORT_SYMBOL(ioc3_gpcr_set);
+EXPORT_SYMBOL(ioc3_disable);
+EXPORT_SYMBOL(ioc3_enable);
diff --git a/drivers/spi/Kconfig b/drivers/spi/Kconfig
new file mode 100644
index 000000000000..b77dbd63e596
--- /dev/null
+++ b/drivers/spi/Kconfig
@@ -0,0 +1,109 @@
+#
+# SPI driver configuration
+#
+# NOTE:  the reason this doesn't show SPI slave support is mostly that
+# nobody's needed a slave side API yet.  The master-role API is not
+# fully appropriate there, so it'd need some thought to do well.
+#
+menu "SPI support"
+
+config SPI
+        bool "SPI support"
+        help
+          The "Serial Peripheral Interface" is a low level synchronous
+          protocol.  Chips that support SPI can have data transfer rates
+          up to several tens of Mbit/sec.  Chips are addressed with a
+          controller and a chipselect.  Most SPI slaves don't support
+          dynamic device discovery; some are even write-only or read-only.
+
+          SPI is widely used by microcontollers to talk with sensors,
+          eeprom and flash memory, codecs and various other controller
+          chips, analog to digital (and d-to-a) converters, and more.
+          MMC and SD cards can be accessed using SPI protocol; and for
+          DataFlash cards used in MMC sockets, SPI must always be used.
+
+          SPI is one of a family of similar protocols using a four wire
+          interface (select, clock, data in, data out) including Microwire
+          (half duplex), SSP, SSI, and PSP.  This driver framework should
+          work with most such devices and controllers.
+
+config SPI_DEBUG
+        boolean "Debug support for SPI drivers"
+        depends on SPI && DEBUG_KERNEL
+        help
+          Say "yes" to enable debug messaging (like dev_dbg and pr_debug),
+          sysfs, and debugfs support in SPI controller and protocol drivers.
+
+#
+# MASTER side ... talking to discrete SPI slave chips including microcontrollers
+#
+
+config SPI_MASTER
+#       boolean "SPI Master Support"
+        boolean
+        default SPI
+        help
+          If your system has an master-capable SPI controller (which
+          provides the clock and chipselect), you can enable that
+          controller and the protocol drivers for the SPI slave chips
+          that are connected.
+
+comment "SPI Master Controller Drivers"
+        depends on SPI_MASTER
+
+config SPI_BITBANG
+        tristate "Bitbanging SPI master"
+        depends on SPI_MASTER && EXPERIMENTAL
+        help
+          With a few GPIO pins, your system can bitbang the SPI protocol.
+          Select this to get SPI support through I/O pins (GPIO, parallel
+          port, etc).  Or, some systems' SPI master controller drivers use
+          this code to manage the per-word or per-transfer accesses to the
+          hardware shift registers.
+
+          This is library code, and is automatically selected by drivers that
+          need it.  You only need to select this explicitly to support driver
+          modules that aren't part of this kernel tree.
+
+config SPI_BUTTERFLY
+        tristate "Parallel port adapter for AVR Butterfly (DEVELOPMENT)"
+        depends on SPI_MASTER && PARPORT && EXPERIMENTAL
+        select SPI_BITBANG
+        help
+          This uses a custom parallel port cable to connect to an AVR
+          Butterfly <http://www.atmel.com/products/avr/butterfly>, an
+          inexpensive battery powered microcontroller evaluation board.
+          This same cable can be used to flash new firmware.
+
+config SPI_BUTTERFLY
+        tristate "Parallel port adapter for AVR Butterfly (DEVELOPMENT)"
+        depends on SPI_MASTER && PARPORT && EXPERIMENTAL
+        select SPI_BITBANG
+        help
+          This uses a custom parallel port cable to connect to an AVR
+          Butterfly <http://www.atmel.com/products/avr/butterfly>, an
+          inexpensive battery powered microcontroller evaluation board.
+          This same cable can be used to flash new firmware.
+
+#
+# Add new SPI master controllers in alphabetical order above this line
+#
+
+
+#
+# There are lots of SPI device types, with sensors and memory
+# being probably the most widely used ones.
+#
+comment "SPI Protocol Masters"
+        depends on SPI_MASTER
+
+
+#
+# Add new SPI protocol masters in alphabetical order above this line
+#
+
+
+# (slave support would go here)
+
+endmenu # "SPI support"
+
diff --git a/drivers/spi/Makefile b/drivers/spi/Makefile
new file mode 100644
index 000000000000..c2c87e845abf
--- /dev/null
+++ b/drivers/spi/Makefile
@@ -0,0 +1,25 @@
+#
+# Makefile for kernel SPI drivers.
+#
+
+ifeq ($(CONFIG_SPI_DEBUG),y)
+EXTRA_CFLAGS += -DDEBUG
+endif
+
+# small core, mostly translating board-specific
+# config declarations into driver model code
+obj-$(CONFIG_SPI_MASTER)                += spi.o
+
+# SPI master controller drivers (bus)
+obj-$(CONFIG_SPI_BITBANG)               += spi_bitbang.o
+obj-$(CONFIG_SPI_BUTTERFLY)             += spi_butterfly.o
+#       ... add above this line ...
+
+# SPI protocol drivers (device/link on bus)
+#       ... add above this line ...
+
+# SPI slave controller drivers (upstream link)
+#       ... add above this line ...
+
+# SPI slave drivers (protocol for that link)
+#       ... add above this line ...
diff --git a/drivers/spi/spi.c b/drivers/spi/spi.c
new file mode 100644
index 000000000000..791c4dc550ae
--- /dev/null
+++ b/drivers/spi/spi.c
@@ -0,0 +1,642 @@
+/*
+ * spi.c - SPI init/core code
+ *
+ * Copyright (C) 2005 David Brownell
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * 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., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <linux/autoconf.h>
+#include <linux/kernel.h>
+#include <linux/device.h>
+#include <linux/init.h>
+#include <linux/cache.h>
+#include <linux/spi/spi.h>
+
+
+/* SPI bustype and spi_master class are registered after board init code
+ * provides the SPI device tables, ensuring that both are present by the
+ * time controller driver registration causes spi_devices to "enumerate".
+ */
+static void spidev_release(struct device *dev)
+{
+        const struct spi_device *spi = to_spi_device(dev);
+
+        /* spi masters may cleanup for released devices */
+        if (spi->master->cleanup)
+                spi->master->cleanup(spi);
+
+        spi_master_put(spi->master);
+        kfree(dev);
+}
+
+static ssize_t
+modalias_show(struct device *dev, struct device_attribute *a, char *buf)
+{
+        const struct spi_device *spi = to_spi_device(dev);
+
+        return snprintf(buf, BUS_ID_SIZE + 1, "%s\n", spi->modalias);
+}
+
+static struct device_attribute spi_dev_attrs[] = {
+        __ATTR_RO(modalias),
+        __ATTR_NULL,
+};
+
+/* modalias support makes "modprobe $MODALIAS" new-style hotplug work,
+ * and the sysfs version makes coldplug work too.
+ */
+
+static int spi_match_device(struct device *dev, struct device_driver *drv)
+{
+        const struct spi_device *spi = to_spi_device(dev);
+
+        return strncmp(spi->modalias, drv->name, BUS_ID_SIZE) == 0;
+}
+
+static int spi_uevent(struct device *dev, char **envp, int num_envp,
+                char *buffer, int buffer_size)
+{
+        const struct spi_device         *spi = to_spi_device(dev);
+
+        envp[0] = buffer;
+        snprintf(buffer, buffer_size, "MODALIAS=%s", spi->modalias);
+        envp[1] = NULL;
+        return 0;
+}
+
+#ifdef  CONFIG_PM
+
+/*
+ * NOTE:  the suspend() method for an spi_master controller driver
+ * should verify that all its child devices are marked as suspended;
+ * suspend requests delivered through sysfs power/state files don't
+ * enforce such constraints.
+ */
+static int spi_suspend(struct device *dev, pm_message_t message)
+{
+        int                     value;
+        struct spi_driver       *drv = to_spi_driver(dev->driver);
+
+        if (!drv->suspend)
+                return 0;
+
+        /* suspend will stop irqs and dma; no more i/o */
+        value = drv->suspend(to_spi_device(dev), message);
+        if (value == 0)
+                dev->power.power_state = message;
+        return value;
+}
+
+static int spi_resume(struct device *dev)
+{
+        int                     value;
+        struct spi_driver       *drv = to_spi_driver(dev->driver);
+
+        if (!drv->resume)
+                return 0;
+
+        /* resume may restart the i/o queue */
+        value = drv->resume(to_spi_device(dev));
+        if (value == 0)
+                dev->power.power_state = PMSG_ON;
+        return value;
+}
+
+#else
+#define spi_suspend     NULL
+#define spi_resume      NULL
+#endif
+
+struct bus_type spi_bus_type = {
+        .name           = "spi",
+        .dev_attrs      = spi_dev_attrs,
+        .match          = spi_match_device,
+        .uevent         = spi_uevent,
+        .suspend        = spi_suspend,
+        .resume         = spi_resume,
+};
+EXPORT_SYMBOL_GPL(spi_bus_type);
+
+
+static int spi_drv_probe(struct device *dev)
+{
+        const struct spi_driver         *sdrv = to_spi_driver(dev->driver);
+
+        return sdrv->probe(to_spi_device(dev));
+}
+
+static int spi_drv_remove(struct device *dev)
+{
+        const struct spi_driver         *sdrv = to_spi_driver(dev->driver);
+
+        return sdrv->remove(to_spi_device(dev));
+}
+
+static void spi_drv_shutdown(struct device *dev)
+{
+        const struct spi_driver         *sdrv = to_spi_driver(dev->driver);
+
+        sdrv->shutdown(to_spi_device(dev));
+}
+
+int spi_register_driver(struct spi_driver *sdrv)
+{
+        sdrv->driver.bus = &spi_bus_type;
+        if (sdrv->probe)
+                sdrv->driver.probe = spi_drv_probe;
+        if (sdrv->remove)
+                sdrv->driver.remove = spi_drv_remove;
+        if (sdrv->shutdown)
+                sdrv->driver.shutdown = spi_drv_shutdown;
+        return driver_register(&sdrv->driver);
+}
+EXPORT_SYMBOL_GPL(spi_register_driver);
+
+/*-------------------------------------------------------------------------*/
+
+/* SPI devices should normally not be created by SPI device drivers; that
+ * would make them board-specific.  Similarly with SPI master drivers.
+ * Device registration normally goes into like arch/.../mach.../board-YYY.c
+ * with other readonly (flashable) information about mainboard devices.
+ */
+
+struct boardinfo {
+        struct list_head        list;
+        unsigned                n_board_info;
+        struct spi_board_info   board_info[0];
+};
+
+static LIST_HEAD(board_list);
+static DECLARE_MUTEX(board_lock);
+
+
+/* On typical mainboards, this is purely internal; and it's not needed
+ * after board init creates the hard-wired devices.  Some development
+ * platforms may not be able to use spi_register_board_info though, and
+ * this is exported so that for example a USB or parport based adapter
+ * driver could add devices (which it would learn about out-of-band).
+ */
+struct spi_device *__init_or_module
+spi_new_device(struct spi_master *master, struct spi_board_info *chip)
+{
+        struct spi_device       *proxy;
+        struct device           *dev = master->cdev.dev;
+        int                     status;
+
+        /* NOTE:  caller did any chip->bus_num checks necessary */
+
+        if (!spi_master_get(master))
+                return NULL;
+
+        proxy = kzalloc(sizeof *proxy, GFP_KERNEL);
+        if (!proxy) {
+                dev_err(dev, "can't alloc dev for cs%d\n",
+                        chip->chip_select);
+                goto fail;
+        }
+        proxy->master = master;
+        proxy->chip_select = chip->chip_select;
+        proxy->max_speed_hz = chip->max_speed_hz;
+        proxy->irq = chip->irq;
+        proxy->modalias = chip->modalias;
+
+        snprintf(proxy->dev.bus_id, sizeof proxy->dev.bus_id,
+                        "%s.%u", master->cdev.class_id,
+                        chip->chip_select);
+        proxy->dev.parent = dev;
+        proxy->dev.bus = &spi_bus_type;
+        proxy->dev.platform_data = (void *) chip->platform_data;
+        proxy->controller_data = chip->controller_data;
+        proxy->controller_state = NULL;
+        proxy->dev.release = spidev_release;
+
+        /* drivers may modify this default i/o setup */
+        status = master->setup(proxy);
+        if (status < 0) {
+                dev_dbg(dev, "can't %s %s, status %d\n",
+                                "setup", proxy->dev.bus_id, status);
+                goto fail;
+        }
+
+        /* driver core catches callers that misbehave by defining
+         * devices that already exist.
+         */
+        status = device_register(&proxy->dev);
+        if (status < 0) {
+                dev_dbg(dev, "can't %s %s, status %d\n",
+                                "add", proxy->dev.bus_id, status);
+                goto fail;
+        }
+        dev_dbg(dev, "registered child %s\n", proxy->dev.bus_id);
+        return proxy;
+
+fail:
+        spi_master_put(master);
+        kfree(proxy);
+        return NULL;
+}
+EXPORT_SYMBOL_GPL(spi_new_device);
+
+/*
+ * Board-specific early init code calls this (probably during arch_initcall)
+ * with segments of the SPI device table.  Any device nodes are created later,
+ * after the relevant parent SPI controller (bus_num) is defined.  We keep
+ * this table of devices forever, so that reloading a controller driver will
+ * not make Linux forget about these hard-wired devices.
+ *
+ * Other code can also call this, e.g. a particular add-on board might provide
+ * SPI devices through its expansion connector, so code initializing that board
+ * would naturally declare its SPI devices.
+ *
+ * The board info passed can safely be __initdata ... but be careful of
+ * any embedded pointers (platform_data, etc), they're copied as-is.
+ */
+int __init
+spi_register_board_info(struct spi_board_info const *info, unsigned n)
+{
+        struct boardinfo        *bi;
+
+        bi = kmalloc(sizeof(*bi) + n * sizeof *info, GFP_KERNEL);
+        if (!bi)
+                return -ENOMEM;
+        bi->n_board_info = n;
+        memcpy(bi->board_info, info, n * sizeof *info);
+
+        down(&board_lock);
+        list_add_tail(&bi->list, &board_list);
+        up(&board_lock);
+        return 0;
+}
+EXPORT_SYMBOL_GPL(spi_register_board_info);
+
+/* FIXME someone should add support for a __setup("spi", ...) that
+ * creates board info from kernel command lines
+ */
+
+static void __init_or_module
+scan_boardinfo(struct spi_master *master)
+{
+        struct boardinfo        *bi;
+        struct device           *dev = master->cdev.dev;
+
+        down(&board_lock);
+        list_for_each_entry(bi, &board_list, list) {
+                struct spi_board_info   *chip = bi->board_info;
+                unsigned                n;
+
+                for (n = bi->n_board_info; n > 0; n--, chip++) {
+                        if (chip->bus_num != master->bus_num)
+                                continue;
+                        /* some controllers only have one chip, so they
+                         * might not use chipselects.  otherwise, the
+                         * chipselects are numbered 0..max.
+                         */
+                        if (chip->chip_select >= master->num_chipselect
+                                        && master->num_chipselect) {
+                                dev_dbg(dev, "cs%d > max %d\n",
+                                        chip->chip_select,
+                                        master->num_chipselect);
+                                continue;
+                        }
+                        (void) spi_new_device(master, chip);
+                }
+        }
+        up(&board_lock);
+}
+
+/*-------------------------------------------------------------------------*/
+
+static void spi_master_release(struct class_device *cdev)
+{
+        struct spi_master *master;
+
+        master = container_of(cdev, struct spi_master, cdev);
+        kfree(master);
+}
+
+static struct class spi_master_class = {
+        .name           = "spi_master",
+        .owner          = THIS_MODULE,
+        .release        = spi_master_release,
+};
+
+
+/**
+ * spi_alloc_master - allocate SPI master controller
+ * @dev: the controller, possibly using the platform_bus
+ * @size: how much driver-private data to preallocate; the pointer to this
+ *      memory is in the class_data field of the returned class_device,
+ *      accessible with spi_master_get_devdata().
+ *
+ * This call is used only by SPI master controller drivers, which are the
+ * only ones directly touching chip registers.  It's how they allocate
+ * an spi_master structure, prior to calling spi_add_master().
+ *
+ * This must be called from context that can sleep.  It returns the SPI
+ * master structure on success, else NULL.
+ *
+ * The caller is responsible for assigning the bus number and initializing
+ * the master's methods before calling spi_add_master(); and (after errors
+ * adding the device) calling spi_master_put() to prevent a memory leak.
+ */
+struct spi_master * __init_or_module
+spi_alloc_master(struct device *dev, unsigned size)
+{
+        struct spi_master       *master;
+
+        if (!dev)
+                return NULL;
+
+        master = kzalloc(size + sizeof *master, SLAB_KERNEL);
+        if (!master)
+                return NULL;
+
+        class_device_initialize(&master->cdev);
+        master->cdev.class = &spi_master_class;
+        master->cdev.dev = get_device(dev);
+        spi_master_set_devdata(master, &master[1]);
+
+        return master;
+}
+EXPORT_SYMBOL_GPL(spi_alloc_master);
+
+/**
+ * spi_register_master - register SPI master controller
+ * @master: initialized master, originally from spi_alloc_master()
+ *
+ * SPI master controllers connect to their drivers using some non-SPI bus,
+ * such as the platform bus.  The final stage of probe() in that code
+ * includes calling spi_register_master() to hook up to this SPI bus glue.
+ *
+ * SPI controllers use board specific (often SOC specific) bus numbers,
+ * and board-specific addressing for SPI devices combines those numbers
+ * with chip select numbers.  Since SPI does not directly support dynamic
+ * device identification, boards need configuration tables telling which
+ * chip is at which address.
+ *
+ * This must be called from context that can sleep.  It returns zero on
+ * success, else a negative error code (dropping the master's refcount).
+ * After a successful return, the caller is responsible for calling
+ * spi_unregister_master().
+ */
+int __init_or_module
+spi_register_master(struct spi_master *master)
+{
+        static atomic_t         dyn_bus_id = ATOMIC_INIT(0);
+        struct device           *dev = master->cdev.dev;
+        int                     status = -ENODEV;
+        int                     dynamic = 0;
+
+        if (!dev)
+                return -ENODEV;
+
+        /* convention:  dynamically assigned bus IDs count down from the max */
+        if (master->bus_num == 0) {
+                master->bus_num = atomic_dec_return(&dyn_bus_id);
+                dynamic = 1;
+        }
+
+        /* register the device, then userspace will see it.
+         * registration fails if the bus ID is in use.
+         */
+        snprintf(master->cdev.class_id, sizeof master->cdev.class_id,
+                "spi%u", master->bus_num);
+        status = class_device_add(&master->cdev);
+        if (status < 0)
+                goto done;
+        dev_dbg(dev, "registered master %s%s\n", master->cdev.class_id,
+                        dynamic ? " (dynamic)" : "");
+
+        /* populate children from any spi device tables */
+        scan_boardinfo(master);
+        status = 0;
+done:
+        return status;
+}
+EXPORT_SYMBOL_GPL(spi_register_master);
+
+
+static int __unregister(struct device *dev, void *unused)
+{
+        /* note: before about 2.6.14-rc1 this would corrupt memory: */
+        spi_unregister_device(to_spi_device(dev));
+        return 0;
+}
+
+/**
+ * spi_unregister_master - unregister SPI master controller
+ * @master: the master being unregistered
+ *
+ * This call is used only by SPI master controller drivers, which are the
+ * only ones directly touching chip registers.
+ *
+ * This must be called from context that can sleep.
+ */
+void spi_unregister_master(struct spi_master *master)
+{
+        (void) device_for_each_child(master->cdev.dev, NULL, __unregister);
+        class_device_unregister(&master->cdev);
+        master->cdev.dev = NULL;
+}
+EXPORT_SYMBOL_GPL(spi_unregister_master);
+
+/**
+ * spi_busnum_to_master - look up master associated with bus_num
+ * @bus_num: the master's bus number
+ *
+ * This call may be used with devices that are registered after
+ * arch init time.  It returns a refcounted pointer to the relevant
+ * spi_master (which the caller must release), or NULL if there is
+ * no such master registered.
+ */
+struct spi_master *spi_busnum_to_master(u16 bus_num)
+{
+        if (bus_num) {
+                char                    name[8];
+                struct kobject          *bus;
+
+                snprintf(name, sizeof name, "spi%u", bus_num);
+                bus = kset_find_obj(&spi_master_class.subsys.kset, name);
+                if (bus)
+                        return container_of(bus, struct spi_master, cdev.kobj);
+        }
+        return NULL;
+}
+EXPORT_SYMBOL_GPL(spi_busnum_to_master);
+
+
+/*-------------------------------------------------------------------------*/
+
+static void spi_complete(void *arg)
+{
+        complete(arg);
+}
+
+/**
+ * spi_sync - blocking/synchronous SPI data transfers
+ * @spi: device with which data will be exchanged
+ * @message: describes the data transfers
+ *
+ * This call may only be used from a context that may sleep.  The sleep
+ * is non-interruptible, and has no timeout.  Low-overhead controller
+ * drivers may DMA directly into and out of the message buffers.
+ *
+ * Note that the SPI device's chip select is active during the message,
+ * and then is normally disabled between messages.  Drivers for some
+ * frequently-used devices may want to minimize costs of selecting a chip,
+ * by leaving it selected in anticipation that the next message will go
+ * to the same chip.  (That may increase power usage.)
+ *
+ * Also, the caller is guaranteeing that the memory associated with the
+ * message will not be freed before this call returns.
+ *
+ * The return value is a negative error code if the message could not be
+ * submitted, else zero.  When the value is zero, then message->status is
+ * also defined:  it's the completion code for the transfer, either zero
+ * or a negative error code from the controller driver.
+ */
+int spi_sync(struct spi_device *spi, struct spi_message *message)
+{
+        DECLARE_COMPLETION(done);
+        int status;
+
+        message->complete = spi_complete;
+        message->context = &done;
+        status = spi_async(spi, message);
+        if (status == 0)
+                wait_for_completion(&done);
+        message->context = NULL;
+        return status;
+}
+EXPORT_SYMBOL_GPL(spi_sync);
+
+#define SPI_BUFSIZ      (SMP_CACHE_BYTES)
+
+static u8       *buf;
+
+/**
+ * spi_write_then_read - SPI synchronous write followed by read
+ * @spi: device with which data will be exchanged
+ * @txbuf: data to be written (need not be dma-safe)
+ * @n_tx: size of txbuf, in bytes
+ * @rxbuf: buffer into which data will be read
+ * @n_rx: size of rxbuf, in bytes (need not be dma-safe)
+ *
+ * This performs a half duplex MicroWire style transaction with the
+ * device, sending txbuf and then reading rxbuf.  The return value
+ * is zero for success, else a negative errno status code.
+ * This call may only be used from a context that may sleep.
+ *
+ * Parameters to this routine are always copied using a small buffer;
+ * performance-sensitive or bulk transfer code should instead use
+ * spi_{async,sync}() calls with dma-safe buffers.
+ */
+int spi_write_then_read(struct spi_device *spi,
+                const u8 *txbuf, unsigned n_tx,
+                u8 *rxbuf, unsigned n_rx)
+{
+        static DECLARE_MUTEX(lock);
+
+        int                     status;
+        struct spi_message      message;
+        struct spi_transfer     x[2];
+        u8                      *local_buf;
+
+        /* Use preallocated DMA-safe buffer.  We can't avoid copying here,
+         * (as a pure convenience thing), but we can keep heap costs
+         * out of the hot path ...
+         */
+        if ((n_tx + n_rx) > SPI_BUFSIZ)
+                return -EINVAL;
+
+        spi_message_init(&message);
+        memset(x, 0, sizeof x);
+        if (n_tx) {
+                x[0].len = n_tx;
+                spi_message_add_tail(&x[0], &message);
+        }
+        if (n_rx) {
+                x[1].len = n_rx;
+                spi_message_add_tail(&x[1], &message);
+        }
+
+        /* ... unless someone else is using the pre-allocated buffer */
+        if (down_trylock(&lock)) {
+                local_buf = kmalloc(SPI_BUFSIZ, GFP_KERNEL);
+                if (!local_buf)
+                        return -ENOMEM;
+        } else
+                local_buf = buf;
+
+        memcpy(local_buf, txbuf, n_tx);
+        x[0].tx_buf = local_buf;
+        x[1].rx_buf = local_buf + n_tx;
+
+        /* do the i/o */
+        status = spi_sync(spi, &message);
+        if (status == 0) {
+                memcpy(rxbuf, x[1].rx_buf, n_rx);
+                status = message.status;
+        }
+
+        if (x[0].tx_buf == buf)
+                up(&lock);
+        else
+                kfree(local_buf);
+
+        return status;
+}
+EXPORT_SYMBOL_GPL(spi_write_then_read);
+
+/*-------------------------------------------------------------------------*/
+
+static int __init spi_init(void)
+{
+        int     status;
+
+        buf = kmalloc(SPI_BUFSIZ, SLAB_KERNEL);
+        if (!buf) {
+                status = -ENOMEM;
+                goto err0;
+        }
+
+        status = bus_register(&spi_bus_type);
+        if (status < 0)
+                goto err1;
+
+        status = class_register(&spi_master_class);
+        if (status < 0)
+                goto err2;
+        return 0;
+
+err2:
+        bus_unregister(&spi_bus_type);
+err1:
+        kfree(buf);
+        buf = NULL;
+err0:
+        return status;
+}
+
+/* board_info is normally registered in arch_initcall(),
+ * but even essential drivers wait till later
+ *
+ * REVISIT only boardinfo really needs static linking. the rest (device and
+ * driver registration) _could_ be dynamically linked (modular) ... costs
+ * include needing to have boardinfo data structures be much more public.
+ */
+subsys_initcall(spi_init);
+
diff --git a/drivers/spi/spi_bitbang.c b/drivers/spi/spi_bitbang.c
new file mode 100644
index 000000000000..f037e5593269
--- /dev/null
+++ b/drivers/spi/spi_bitbang.c
@@ -0,0 +1,472 @@
+/*
+ * spi_bitbang.c - polling/bitbanging SPI master controller driver utilities
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * 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/config.h>
+#include <linux/init.h>
+#include <linux/spinlock.h>
+#include <linux/workqueue.h>
+#include <linux/interrupt.h>
+#include <linux/delay.h>
+#include <linux/errno.h>
+#include <linux/platform_device.h>
+
+#include <linux/spi/spi.h>
+#include <linux/spi/spi_bitbang.h>
+
+
+/*----------------------------------------------------------------------*/
+
+/*
+ * FIRST PART (OPTIONAL):  word-at-a-time spi_transfer support.
+ * Use this for GPIO or shift-register level hardware APIs.
+ *
+ * spi_bitbang_cs is in spi_device->controller_state, which is unavailable
+ * to glue code.  These bitbang setup() and cleanup() routines are always
+ * used, though maybe they're called from controller-aware code.
+ *
+ * chipselect() and friends may use use spi_device->controller_data and
+ * controller registers as appropriate.
+ *
+ *
+ * NOTE:  SPI controller pins can often be used as GPIO pins instead,
+ * which means you could use a bitbang driver either to get hardware
+ * working quickly, or testing for differences that aren't speed related.
+ */
+
+struct spi_bitbang_cs {
+        unsigned        nsecs;  /* (clock cycle time)/2 */
+        u32             (*txrx_word)(struct spi_device *spi, unsigned nsecs,
+                                        u32 word, u8 bits);
+        unsigned        (*txrx_bufs)(struct spi_device *,
+                                        u32 (*txrx_word)(
+                                                struct spi_device *spi,
+                                                unsigned nsecs,
+                                                u32 word, u8 bits),
+                                        unsigned, struct spi_transfer *);
+};
+
+static unsigned bitbang_txrx_8(
+        struct spi_device       *spi,
+        u32                     (*txrx_word)(struct spi_device *spi,
+                                        unsigned nsecs,
+                                        u32 word, u8 bits),
+        unsigned                ns,
+        struct spi_transfer     *t
+) {
+        unsigned                bits = spi->bits_per_word;
+        unsigned                count = t->len;
+        const u8                *tx = t->tx_buf;
+        u8                      *rx = t->rx_buf;
+
+        while (likely(count > 0)) {
+                u8              word = 0;
+
+                if (tx)
+                        word = *tx++;
+                word = txrx_word(spi, ns, word, bits);
+                if (rx)
+                        *rx++ = word;
+                count -= 1;
+        }
+        return t->len - count;
+}
+
+static unsigned bitbang_txrx_16(
+        struct spi_device       *spi,
+        u32                     (*txrx_word)(struct spi_device *spi,
+                                        unsigned nsecs,
+                                        u32 word, u8 bits),
+        unsigned                ns,
+        struct spi_transfer     *t
+) {
+        unsigned                bits = spi->bits_per_word;
+        unsigned                count = t->len;
+        const u16               *tx = t->tx_buf;
+        u16                     *rx = t->rx_buf;
+
+        while (likely(count > 1)) {
+                u16             word = 0;
+
+                if (tx)
+                        word = *tx++;
+                word = txrx_word(spi, ns, word, bits);
+                if (rx)
+                        *rx++ = word;
+                count -= 2;
+        }
+        return t->len - count;
+}
+
+static unsigned bitbang_txrx_32(
+        struct spi_device       *spi,
+        u32                     (*txrx_word)(struct spi_device *spi,
+                                        unsigned nsecs,
+                                        u32 word, u8 bits),
+        unsigned                ns,
+        struct spi_transfer     *t
+) {
+        unsigned                bits = spi->bits_per_word;
+        unsigned                count = t->len;
+        const u32               *tx = t->tx_buf;
+        u32                     *rx = t->rx_buf;
+
+        while (likely(count > 3)) {
+                u32             word = 0;
+
+                if (tx)
+                        word = *tx++;
+                word = txrx_word(spi, ns, word, bits);
+                if (rx)
+                        *rx++ = word;
+                count -= 4;
+        }
+        return t->len - count;
+}
+
+/**
+ * spi_bitbang_setup - default setup for per-word I/O loops
+ */
+int spi_bitbang_setup(struct spi_device *spi)
+{
+        struct spi_bitbang_cs   *cs = spi->controller_state;
+        struct spi_bitbang      *bitbang;
+
+        if (!spi->max_speed_hz)
+                return -EINVAL;
+
+        if (!cs) {
+                cs = kzalloc(sizeof *cs, SLAB_KERNEL);
+                if (!cs)
+                        return -ENOMEM;
+                spi->controller_state = cs;
+        }
+        bitbang = spi_master_get_devdata(spi->master);
+
+        if (!spi->bits_per_word)
+                spi->bits_per_word = 8;
+
+        /* spi_transfer level calls that work per-word */
+        if (spi->bits_per_word <= 8)
+                cs->txrx_bufs = bitbang_txrx_8;
+        else if (spi->bits_per_word <= 16)
+                cs->txrx_bufs = bitbang_txrx_16;
+        else if (spi->bits_per_word <= 32)
+                cs->txrx_bufs = bitbang_txrx_32;
+        else
+                return -EINVAL;
+
+        /* per-word shift register access, in hardware or bitbanging */
+        cs->txrx_word = bitbang->txrx_word[spi->mode & (SPI_CPOL|SPI_CPHA)];
+        if (!cs->txrx_word)
+                return -EINVAL;
+
+        /* nsecs = (clock period)/2 */
+        cs->nsecs = (1000000000/2) / (spi->max_speed_hz);
+        if (cs->nsecs > MAX_UDELAY_MS * 1000)
+                return -EINVAL;
+
+        dev_dbg(&spi->dev, "%s, mode %d, %u bits/w, %u nsec\n",
+                        __FUNCTION__, spi->mode & (SPI_CPOL | SPI_CPHA),
+                        spi->bits_per_word, 2 * cs->nsecs);
+
+        /* NOTE we _need_ to call chipselect() early, ideally with adapter
+         * setup, unless the hardware defaults cooperate to avoid confusion
+         * between normal (active low) and inverted chipselects.
+         */
+
+        /* deselect chip (low or high) */
+        spin_lock(&bitbang->lock);
+        if (!bitbang->busy) {
+                bitbang->chipselect(spi, BITBANG_CS_INACTIVE);
+                ndelay(cs->nsecs);
+        }
+        spin_unlock(&bitbang->lock);
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(spi_bitbang_setup);
+
+/**
+ * spi_bitbang_cleanup - default cleanup for per-word I/O loops
+ */
+void spi_bitbang_cleanup(const struct spi_device *spi)
+{
+        kfree(spi->controller_state);
+}
+EXPORT_SYMBOL_GPL(spi_bitbang_cleanup);
+
+static int spi_bitbang_bufs(struct spi_device *spi, struct spi_transfer *t)
+{
+        struct spi_bitbang_cs   *cs = spi->controller_state;
+        unsigned                nsecs = cs->nsecs;
+
+        return cs->txrx_bufs(spi, cs->txrx_word, nsecs, t);
+}
+
+/*----------------------------------------------------------------------*/
+
+/*
+ * SECOND PART ... simple transfer queue runner.
+ *
+ * This costs a task context per controller, running the queue by
+ * performing each transfer in sequence.  Smarter hardware can queue
+ * several DMA transfers at once, and process several controller queues
+ * in parallel; this driver doesn't match such hardware very well.
+ *
+ * Drivers can provide word-at-a-time i/o primitives, or provide
+ * transfer-at-a-time ones to leverage dma or fifo hardware.
+ */
+static void bitbang_work(void *_bitbang)
+{
+        struct spi_bitbang      *bitbang = _bitbang;
+        unsigned long           flags;
+
+        spin_lock_irqsave(&bitbang->lock, flags);
+        bitbang->busy = 1;
+        while (!list_empty(&bitbang->queue)) {
+                struct spi_message      *m;
+                struct spi_device       *spi;
+                unsigned                nsecs;
+                struct spi_transfer     *t = NULL;
+                unsigned                tmp;
+                unsigned                cs_change;
+                int                     status;
+
+                m = container_of(bitbang->queue.next, struct spi_message,
+                                queue);
+                list_del_init(&m->queue);
+                spin_unlock_irqrestore(&bitbang->lock, flags);
+
+                /* FIXME this is made-up ... the correct value is known to
+                 * word-at-a-time bitbang code, and presumably chipselect()
+                 * should enforce these requirements too?
+                 */
+                nsecs = 100;
+
+                spi = m->spi;
+                tmp = 0;
+                cs_change = 1;
+                status = 0;
+
+                list_for_each_entry (t, &m->transfers, transfer_list) {
+                        if (bitbang->shutdown) {
+                                status = -ESHUTDOWN;
+                                break;
+                        }
+
+                        /* set up default clock polarity, and activate chip;
+                         * this implicitly updates clock and spi modes as
+                         * previously recorded for this device via setup().
+                         * (and also deselects any other chip that might be
+                         * selected ...)
+                         */
+                        if (cs_change) {
+                                bitbang->chipselect(spi, BITBANG_CS_ACTIVE);
+                                ndelay(nsecs);
+                        }
+                        cs_change = t->cs_change;
+                        if (!t->tx_buf && !t->rx_buf && t->len) {
+                                status = -EINVAL;
+                                break;
+                        }
+
+                        /* transfer data.  the lower level code handles any
+                         * new dma mappings it needs. our caller always gave
+                         * us dma-safe buffers.
+                         */
+                        if (t->len) {
+                                /* REVISIT dma API still needs a designated
+                                 * DMA_ADDR_INVALID; ~0 might be better.
+                                 */
+                                if (!m->is_dma_mapped)
+                                        t->rx_dma = t->tx_dma = 0;
+                                status = bitbang->txrx_bufs(spi, t);
+                        }
+                        if (status != t->len) {
+                                if (status > 0)
+                                        status = -EMSGSIZE;
+                                break;
+                        }
+                        m->actual_length += status;
+                        status = 0;
+
+                        /* protocol tweaks before next transfer */
+                        if (t->delay_usecs)
+                                udelay(t->delay_usecs);
+
+                        if (!cs_change)
+                                continue;
+                        if (t->transfer_list.next == &m->transfers)
+                                break;
+
+                        /* sometimes a short mid-message deselect of the chip
+                         * may be needed to terminate a mode or command
+                         */
+                        ndelay(nsecs);
+                        bitbang->chipselect(spi, BITBANG_CS_INACTIVE);
+                        ndelay(nsecs);
+                }
+
+                m->status = status;
+                m->complete(m->context);
+
+                /* normally deactivate chipselect ... unless no error and
+                 * cs_change has hinted that the next message will probably
+                 * be for this chip too.
+                 */
+                if (!(status == 0 && cs_change)) {
+                        ndelay(nsecs);
+                        bitbang->chipselect(spi, BITBANG_CS_INACTIVE);
+                        ndelay(nsecs);
+                }
+
+                spin_lock_irqsave(&bitbang->lock, flags);
+        }
+        bitbang->busy = 0;
+        spin_unlock_irqrestore(&bitbang->lock, flags);
+}
+
+/**
+ * spi_bitbang_transfer - default submit to transfer queue
+ */
+int spi_bitbang_transfer(struct spi_device *spi, struct spi_message *m)
+{
+        struct spi_bitbang      *bitbang;
+        unsigned long           flags;
+
+        m->actual_length = 0;
+        m->status = -EINPROGRESS;
+
+        bitbang = spi_master_get_devdata(spi->master);
+        if (bitbang->shutdown)
+                return -ESHUTDOWN;
+
+        spin_lock_irqsave(&bitbang->lock, flags);
+        list_add_tail(&m->queue, &bitbang->queue);
+        queue_work(bitbang->workqueue, &bitbang->work);
+        spin_unlock_irqrestore(&bitbang->lock, flags);
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(spi_bitbang_transfer);
+
+/*----------------------------------------------------------------------*/
+
+/**
+ * spi_bitbang_start - start up a polled/bitbanging SPI master driver
+ * @bitbang: driver handle
+ *
+ * Caller should have zero-initialized all parts of the structure, and then
+ * provided callbacks for chip selection and I/O loops.  If the master has
+ * a transfer method, its final step should call spi_bitbang_transfer; or,
+ * that's the default if the transfer routine is not initialized.  It should
+ * also set up the bus number and number of chipselects.
+ *
+ * For i/o loops, provide callbacks either per-word (for bitbanging, or for
+ * hardware that basically exposes a shift register) or per-spi_transfer
+ * (which takes better advantage of hardware like fifos or DMA engines).
+ *
+ * Drivers using per-word I/O loops should use (or call) spi_bitbang_setup and
+ * spi_bitbang_cleanup to handle those spi master methods.  Those methods are
+ * the defaults if the bitbang->txrx_bufs routine isn't initialized.
+ *
+ * This routine registers the spi_master, which will process requests in a
+ * dedicated task, keeping IRQs unblocked most of the time.  To stop
+ * processing those requests, call spi_bitbang_stop().
+ */
+int spi_bitbang_start(struct spi_bitbang *bitbang)
+{
+        int     status;
+
+        if (!bitbang->master || !bitbang->chipselect)
+                return -EINVAL;
+
+        INIT_WORK(&bitbang->work, bitbang_work, bitbang);
+        spin_lock_init(&bitbang->lock);
+        INIT_LIST_HEAD(&bitbang->queue);
+
+        if (!bitbang->master->transfer)
+                bitbang->master->transfer = spi_bitbang_transfer;
+        if (!bitbang->txrx_bufs) {
+                bitbang->use_dma = 0;
+                bitbang->txrx_bufs = spi_bitbang_bufs;
+                if (!bitbang->master->setup) {
+                        bitbang->master->setup = spi_bitbang_setup;
+                        bitbang->master->cleanup = spi_bitbang_cleanup;
+                }
+        } else if (!bitbang->master->setup)
+                return -EINVAL;
+
+        /* this task is the only thing to touch the SPI bits */
+        bitbang->busy = 0;
+        bitbang->workqueue = create_singlethread_workqueue(
+                        bitbang->master->cdev.dev->bus_id);
+        if (bitbang->workqueue == NULL) {
+                status = -EBUSY;
+                goto err1;
+        }
+
+        /* driver may get busy before register() returns, especially
+         * if someone registered boardinfo for devices
+         */
+        status = spi_register_master(bitbang->master);
+        if (status < 0)
+                goto err2;
+
+        return status;
+
+err2:
+        destroy_workqueue(bitbang->workqueue);
+err1:
+        return status;
+}
+EXPORT_SYMBOL_GPL(spi_bitbang_start);
+
+/**
+ * spi_bitbang_stop - stops the task providing spi communication
+ */
+int spi_bitbang_stop(struct spi_bitbang *bitbang)
+{
+        unsigned        limit = 500;
+
+        spin_lock_irq(&bitbang->lock);
+        bitbang->shutdown = 0;
+        while (!list_empty(&bitbang->queue) && limit--) {
+                spin_unlock_irq(&bitbang->lock);
+
+                dev_dbg(bitbang->master->cdev.dev, "wait for queue\n");
+                msleep(10);
+
+                spin_lock_irq(&bitbang->lock);
+        }
+        spin_unlock_irq(&bitbang->lock);
+        if (!list_empty(&bitbang->queue)) {
+                dev_err(bitbang->master->cdev.dev, "queue didn't empty\n");
+                return -EBUSY;
+        }
+
+        destroy_workqueue(bitbang->workqueue);
+
+        spi_unregister_master(bitbang->master);
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(spi_bitbang_stop);
+
+MODULE_LICENSE("GPL");
+
diff --git a/drivers/spi/spi_butterfly.c b/drivers/spi/spi_butterfly.c
new file mode 100644
index 000000000000..79a3c59615ab
--- /dev/null
+++ b/drivers/spi/spi_butterfly.c
@@ -0,0 +1,423 @@
+/*
+ * spi_butterfly.c - parport-to-butterfly adapter
+ *
+ * Copyright (C) 2005 David Brownell
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * 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., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+#include <linux/config.h>
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/delay.h>
+#include <linux/platform_device.h>
+#include <linux/parport.h>
+
+#include <linux/spi/spi.h>
+#include <linux/spi/spi_bitbang.h>
+#include <linux/spi/flash.h>
+
+#include <linux/mtd/partitions.h>
+
+
+/*
+ * This uses SPI to talk with an "AVR Butterfly", which is a $US20 card
+ * with a battery powered AVR microcontroller and lots of goodies.  You
+ * can use GCC to develop firmware for this.
+ *
+ * See Documentation/spi/butterfly for information about how to build
+ * and use this custom parallel port cable.
+ */
+
+#undef  HAVE_USI        /* nyet */
+
+
+/* DATA output bits (pins 2..9 == D0..D7) */
+#define butterfly_nreset (1 << 1)               /* pin 3 */
+
+#define spi_sck_bit     (1 << 0)                /* pin 2 */
+#define spi_mosi_bit    (1 << 7)                /* pin 9 */
+
+#define usi_sck_bit     (1 << 3)                /* pin 5 */
+#define usi_mosi_bit    (1 << 4)                /* pin 6 */
+
+#define vcc_bits        ((1 << 6) | (1 << 5))   /* pins 7, 8 */
+
+/* STATUS input bits */
+#define spi_miso_bit    PARPORT_STATUS_BUSY     /* pin 11 */
+
+#define usi_miso_bit    PARPORT_STATUS_PAPEROUT /* pin 12 */
+
+/* CONTROL output bits */
+#define spi_cs_bit      PARPORT_CONTROL_SELECT  /* pin 17 */
+/* USI uses no chipselect */
+
+
+
+static inline struct butterfly *spidev_to_pp(struct spi_device *spi)
+{
+        return spi->controller_data;
+}
+
+static inline int is_usidev(struct spi_device *spi)
+{
+#ifdef  HAVE_USI
+        return spi->chip_select != 1;
+#else
+        return 0;
+#endif
+}
+
+
+struct butterfly {
+        /* REVISIT ... for now, this must be first */
+        struct spi_bitbang      bitbang;
+
+        struct parport          *port;
+        struct pardevice        *pd;
+
+        u8                      lastbyte;
+
+        struct spi_device       *dataflash;
+        struct spi_device       *butterfly;
+        struct spi_board_info   info[2];
+
+};
+
+/*----------------------------------------------------------------------*/
+
+/*
+ * these routines may be slower than necessary because they're hiding
+ * the fact that there are two different SPI busses on this cable: one
+ * to the DataFlash chip (or AVR SPI controller), the other to the
+ * AVR USI controller.
+ */
+
+static inline void
+setsck(struct spi_device *spi, int is_on)
+{
+        struct butterfly        *pp = spidev_to_pp(spi);
+        u8                      bit, byte = pp->lastbyte;
+
+        if (is_usidev(spi))
+                bit = usi_sck_bit;
+        else
+                bit = spi_sck_bit;
+
+        if (is_on)
+                byte |= bit;
+        else
+                byte &= ~bit;
+        parport_write_data(pp->port, byte);
+        pp->lastbyte = byte;
+}
+
+static inline void
+setmosi(struct spi_device *spi, int is_on)
+{
+        struct butterfly        *pp = spidev_to_pp(spi);
+        u8                      bit, byte = pp->lastbyte;
+
+        if (is_usidev(spi))
+                bit = usi_mosi_bit;
+        else
+                bit = spi_mosi_bit;
+
+        if (is_on)
+                byte |= bit;
+        else
+                byte &= ~bit;
+        parport_write_data(pp->port, byte);
+        pp->lastbyte = byte;
+}
+
+static inline int getmiso(struct spi_device *spi)
+{
+        struct butterfly        *pp = spidev_to_pp(spi);
+        int                     value;
+        u8                      bit;
+
+        if (is_usidev(spi))
+                bit = usi_miso_bit;
+        else
+                bit = spi_miso_bit;
+
+        /* only STATUS_BUSY is NOT negated */
+        value = !(parport_read_status(pp->port) & bit);
+        return (bit == PARPORT_STATUS_BUSY) ? value : !value;
+}
+
+static void butterfly_chipselect(struct spi_device *spi, int value)
+{
+        struct butterfly        *pp = spidev_to_pp(spi);
+
+        /* set default clock polarity */
+        if (value)
+                setsck(spi, spi->mode & SPI_CPOL);
+
+        /* no chipselect on this USI link config */
+        if (is_usidev(spi))
+                return;
+
+        /* here, value == "activate or not" */
+
+        /* most PARPORT_CONTROL_* bits are negated */
+        if (spi_cs_bit == PARPORT_CONTROL_INIT)
+                value = !value;
+
+        /* here, value == "bit value to write in control register"  */
+
+        parport_frob_control(pp->port, spi_cs_bit, value ? spi_cs_bit : 0);
+}
+
+
+/* we only needed to implement one mode here, and choose SPI_MODE_0 */
+
+#define spidelay(X)     do{}while(0)
+//#define       spidelay        ndelay
+
+#define EXPAND_BITBANG_TXRX
+#include <linux/spi/spi_bitbang.h>
+
+static u32
+butterfly_txrx_word_mode0(struct spi_device *spi,
+                unsigned nsecs,
+                u32 word, u8 bits)
+{
+        return bitbang_txrx_be_cpha0(spi, nsecs, 0, word, bits);
+}
+
+/*----------------------------------------------------------------------*/
+
+/* override default partitioning with cmdlinepart */
+static struct mtd_partition partitions[] = { {
+        /* JFFS2 wants partitions of 4*N blocks for this device ... */
+
+        /* sector 0 = 8 pages * 264 bytes/page (1 block)
+         * sector 1 = 248 pages * 264 bytes/page
+         */
+        .name           = "bookkeeping",        // 66 KB
+        .offset         = 0,
+        .size           = (8 + 248) * 264,
+//      .mask_flags     = MTD_WRITEABLE,
+}, {
+        /* sector 2 = 256 pages * 264 bytes/page
+         * sectors 3-5 = 512 pages * 264 bytes/page
+         */
+        .name           = "filesystem",         // 462 KB
+        .offset         = MTDPART_OFS_APPEND,
+        .size           = MTDPART_SIZ_FULL,
+} };
+
+static struct flash_platform_data flash = {
+        .name           = "butterflash",
+        .parts          = partitions,
+        .nr_parts       = ARRAY_SIZE(partitions),
+};
+
+
+/* REVISIT remove this ugly global and its "only one" limitation */
+static struct butterfly *butterfly;
+
+static void butterfly_attach(struct parport *p)
+{
+        struct pardevice        *pd;
+        int                     status;
+        struct butterfly        *pp;
+        struct spi_master       *master;
+        struct platform_device  *pdev;
+
+        if (butterfly)
+                return;
+
+        /* REVISIT:  this just _assumes_ a butterfly is there ... no probe,
+         * and no way to be selective about what it binds to.
+         */
+
+        /* FIXME where should master->cdev.dev come from?
+         * e.g. /sys/bus/pnp0/00:0b, some PCI thing, etc
+         * setting up a platform device like this is an ugly kluge...
+         */
+        pdev = platform_device_register_simple("butterfly", -1, NULL, 0);
+
+        master = spi_alloc_master(&pdev->dev, sizeof *pp);
+        if (!master) {
+                status = -ENOMEM;
+                goto done;
+        }
+        pp = spi_master_get_devdata(master);
+
+        /*
+         * SPI and bitbang hookup
+         *
+         * use default setup(), cleanup(), and transfer() methods; and
+         * only bother implementing mode 0.  Start it later.
+         */
+        master->bus_num = 42;
+        master->num_chipselect = 2;
+
+        pp->bitbang.master = spi_master_get(master);
+        pp->bitbang.chipselect = butterfly_chipselect;
+        pp->bitbang.txrx_word[SPI_MODE_0] = butterfly_txrx_word_mode0;
+
+        /*
+         * parport hookup
+         */
+        pp->port = p;
+        pd = parport_register_device(p, "spi_butterfly",
+                        NULL, NULL, NULL,
+                        0 /* FLAGS */, pp);
+        if (!pd) {
+                status = -ENOMEM;
+                goto clean0;
+        }
+        pp->pd = pd;
+
+        status = parport_claim(pd);
+        if (status < 0)
+                goto clean1;
+
+        /*
+         * Butterfly reset, powerup, run firmware
+         */
+        pr_debug("%s: powerup/reset Butterfly\n", p->name);
+
+        /* nCS for dataflash (this bit is inverted on output) */
+        parport_frob_control(pp->port, spi_cs_bit, 0);
+
+        /* stabilize power with chip in reset (nRESET), and
+         * both spi_sck_bit and usi_sck_bit clear (CPOL=0)
+         */
+        pp->lastbyte |= vcc_bits;
+        parport_write_data(pp->port, pp->lastbyte);
+        msleep(5);
+
+        /* take it out of reset; assume long reset delay */
+        pp->lastbyte |= butterfly_nreset;
+        parport_write_data(pp->port, pp->lastbyte);
+        msleep(100);
+
+
+        /*
+         * Start SPI ... for now, hide that we're two physical busses.
+         */
+        status = spi_bitbang_start(&pp->bitbang);
+        if (status < 0)
+                goto clean2;
+
+        /* Bus 1 lets us talk to at45db041b (firmware disables AVR)
+         * or AVR (firmware resets at45, acts as spi slave)
+         */
+        pp->info[0].max_speed_hz = 15 * 1000 * 1000;
+        strcpy(pp->info[0].modalias, "mtd_dataflash");
+        pp->info[0].platform_data = &flash;
+        pp->info[0].chip_select = 1;
+        pp->info[0].controller_data = pp;
+        pp->dataflash = spi_new_device(pp->bitbang.master, &pp->info[0]);
+        if (pp->dataflash)
+                pr_debug("%s: dataflash at %s\n", p->name,
+                                pp->dataflash->dev.bus_id);
+
+#ifdef  HAVE_USI
+        /* even more custom AVR firmware */
+        pp->info[1].max_speed_hz = 10 /* ?? */ * 1000 * 1000;
+        strcpy(pp->info[1].modalias, "butterfly");
+        // pp->info[1].platform_data = ... TBD ... ;
+        pp->info[1].chip_select = 2,
+        pp->info[1].controller_data = pp;
+        pp->butterfly = spi_new_device(pp->bitbang.master, &pp->info[1]);
+        if (pp->butterfly)
+                pr_debug("%s: butterfly at %s\n", p->name,
+                                pp->butterfly->dev.bus_id);
+
+        /* FIXME setup ACK for the IRQ line ...  */
+#endif
+
+        // dev_info(_what?_, ...)
+        pr_info("%s: AVR Butterfly\n", p->name);
+        butterfly = pp;
+        return;
+
+clean2:
+        /* turn off VCC */
+        parport_write_data(pp->port, 0);
+
+        parport_release(pp->pd);
+clean1:
+        parport_unregister_device(pd);
+clean0:
+        (void) spi_master_put(pp->bitbang.master);
+done:
+        platform_device_unregister(pdev);
+        pr_debug("%s: butterfly probe, fail %d\n", p->name, status);
+}
+
+static void butterfly_detach(struct parport *p)
+{
+        struct butterfly        *pp;
+        struct platform_device  *pdev;
+        int                     status;
+
+        /* FIXME this global is ugly ... but, how to quickly get from
+         * the parport to the "struct butterfly" associated with it?
+         * "old school" driver-internal device lists?
+         */
+        if (!butterfly || butterfly->port != p)
+                return;
+        pp = butterfly;
+        butterfly = NULL;
+
+#ifdef  HAVE_USI
+        spi_unregister_device(pp->butterfly);
+        pp->butterfly = NULL;
+#endif
+        spi_unregister_device(pp->dataflash);
+        pp->dataflash = NULL;
+
+        status = spi_bitbang_stop(&pp->bitbang);
+
+        /* turn off VCC */
+        parport_write_data(pp->port, 0);
+        msleep(10);
+
+        parport_release(pp->pd);
+        parport_unregister_device(pp->pd);
+
+        pdev = to_platform_device(pp->bitbang.master->cdev.dev);
+
+        (void) spi_master_put(pp->bitbang.master);
+
+        platform_device_unregister(pdev);
+}
+
+static struct parport_driver butterfly_driver = {
+        .name =         "spi_butterfly",
+        .attach =       butterfly_attach,
+        .detach =       butterfly_detach,
+};
+
+
+static int __init butterfly_init(void)
+{
+        return parport_register_driver(&butterfly_driver);
+}
+device_initcall(butterfly_init);
+
+static void __exit butterfly_exit(void)
+{
+        parport_unregister_driver(&butterfly_driver);
+}
+module_exit(butterfly_exit);
+
+MODULE_LICENSE("GPL");
diff --git a/drivers/usb/atm/usbatm.c b/drivers/usb/atm/usbatm.c
index 9baa6296fc95..7af1883d4bf9 100644
--- a/drivers/usb/atm/usbatm.c
+++ b/drivers/usb/atm/usbatm.c
@@ -207,7 +207,7 @@ static inline void usbatm_pop(struct atm_vcc *vcc, struct sk_buff *skb)
 **  urbs  **
 ************/
 
-static inline struct urb *usbatm_pop_urb(struct usbatm_channel *channel)
+static struct urb *usbatm_pop_urb(struct usbatm_channel *channel)
 {
         struct urb *urb;
 
@@ -224,7 +224,7 @@ static inline struct urb *usbatm_pop_urb(struct usbatm_channel *channel)
         return urb;
 }
 
-static inline int usbatm_submit_urb(struct urb *urb)
+static int usbatm_submit_urb(struct urb *urb)
 {
         struct usbatm_channel *channel = urb->context;
         int ret;
diff --git a/drivers/usb/gadget/ether.c b/drivers/usb/gadget/ether.c
index 8f402f85e1ca..afc84cfb61f9 100644
--- a/drivers/usb/gadget/ether.c
+++ b/drivers/usb/gadget/ether.c
@@ -2534,9 +2534,6 @@ static struct usb_gadget_driver eth_driver = {
         .driver         = {
                 .name           = (char *) shortname,
                 .owner          = THIS_MODULE,
-                // .shutdown = ...
-                // .suspend = ...
-                // .resume = ...
         },
 };
 
diff --git a/drivers/usb/gadget/inode.c b/drivers/usb/gadget/inode.c
index c6c279de832e..9a4edc5657aa 100644
--- a/drivers/usb/gadget/inode.c
+++ b/drivers/usb/gadget/inode.c
@@ -1738,9 +1738,6 @@ static struct usb_gadget_driver gadgetfs_driver = {
 
         .driver         = {
                 .name           = (char *) shortname,
-                // .shutdown = ...
-                // .suspend = ...
-                // .resume = ...
         },
 };
 
diff --git a/drivers/usb/gadget/serial.c b/drivers/usb/gadget/serial.c
index 2e6926b33455..ba9acd531024 100644
--- a/drivers/usb/gadget/serial.c
+++ b/drivers/usb/gadget/serial.c
@@ -374,9 +374,6 @@ static struct usb_gadget_driver gs_gadget_driver = {
         .disconnect =           gs_disconnect,
         .driver = {
                 .name =         GS_SHORT_NAME,
-                /* .shutdown = ... */
-                /* .suspend = ...  */
-                /* .resume = ...   */
         },
 };
 
diff --git a/drivers/usb/gadget/zero.c b/drivers/usb/gadget/zero.c
index 6c58636e914b..2fc110d3ad5a 100644
--- a/drivers/usb/gadget/zero.c
+++ b/drivers/usb/gadget/zero.c
@@ -1303,9 +1303,6 @@ static struct usb_gadget_driver zero_driver = {
         .driver         = {
                 .name           = (char *) shortname,
                 .owner          = THIS_MODULE,
-                // .shutdown = ...
-                // .suspend = ...
-                // .resume = ...
         },
 };
 
diff --git a/drivers/usb/input/Kconfig b/drivers/usb/input/Kconfig
index 509dd0a04c54..5246b35301de 100644
--- a/drivers/usb/input/Kconfig
+++ b/drivers/usb/input/Kconfig
@@ -37,6 +37,16 @@ config USB_HIDINPUT
 
           If unsure, say Y.
 
+config USB_HIDINPUT_POWERBOOK
+        bool "Enable support for iBook/PowerBook special keys"
+        default n
+        depends on USB_HIDINPUT
+        help
+          Say Y here if you want support for the special keys (Fn, Numlock) on
+          Apple iBooks and PowerBooks.
+
+          If unsure, say N.
+
 config HID_FF
         bool "Force feedback support (EXPERIMENTAL)"
         depends on USB_HIDINPUT && EXPERIMENTAL
diff --git a/drivers/usb/input/hid-core.c b/drivers/usb/input/hid-core.c
index 5f52979af1c7..a91e72c41415 100644
--- a/drivers/usb/input/hid-core.c
+++ b/drivers/usb/input/hid-core.c
@@ -1450,6 +1450,9 @@ void hid_init_reports(struct hid_device *hid)
 #define USB_VENDOR_ID_APPLE             0x05ac
 #define USB_DEVICE_ID_APPLE_POWERMOUSE  0x0304
 
+#define USB_VENDOR_ID_CHERRY            0x046a
+#define USB_DEVICE_ID_CHERRY_CYMOTION   0x0023
+
 /*
  * Alphabetically sorted blacklist by quirk type.
  */
@@ -1580,6 +1583,16 @@ static const struct hid_blacklist {
         { USB_VENDOR_ID_SAITEK, USB_DEVICE_ID_SAITEK_RUMBLEPAD, HID_QUIRK_BADPAD },
         { USB_VENDOR_ID_TOPMAX, USB_DEVICE_ID_TOPMAX_COBRAPAD, HID_QUIRK_BADPAD },
 
+        { USB_VENDOR_ID_CHERRY, USB_DEVICE_ID_CHERRY_CYMOTION, HID_QUIRK_CYMOTION },
+
+        { USB_VENDOR_ID_APPLE, 0x020E, HID_QUIRK_POWERBOOK_HAS_FN },
+        { USB_VENDOR_ID_APPLE, 0x020F, HID_QUIRK_POWERBOOK_HAS_FN },
+        { USB_VENDOR_ID_APPLE, 0x0214, HID_QUIRK_POWERBOOK_HAS_FN },
+        { USB_VENDOR_ID_APPLE, 0x0215, HID_QUIRK_POWERBOOK_HAS_FN },
+        { USB_VENDOR_ID_APPLE, 0x0216, HID_QUIRK_POWERBOOK_HAS_FN },
+        { USB_VENDOR_ID_APPLE, 0x030A, HID_QUIRK_POWERBOOK_HAS_FN },
+        { USB_VENDOR_ID_APPLE, 0x030B, HID_QUIRK_POWERBOOK_HAS_FN },
+
         { 0, 0 }
 };
 
@@ -1626,6 +1639,20 @@ static void hid_free_buffers(struct usb_device *dev, struct hid_device *hid)
                 usb_buffer_free(dev, hid->bufsize, hid->ctrlbuf, hid->ctrlbuf_dma);
 }
 
+/*
+ * Cherry Cymotion keyboard have an invalid HID report descriptor,
+ * that needs fixing before we can parse it.
+ */
+
+static void hid_fixup_cymotion_descriptor(char *rdesc, int rsize)
+{
+        if (rsize >= 17 && rdesc[11] == 0x3c && rdesc[12] == 0x02) {
+                info("Fixing up Cherry Cymotion report descriptor");
+                rdesc[11] = rdesc[16] = 0xff;
+                rdesc[12] = rdesc[17] = 0x03;
+        }
+}
+
 static struct hid_device *usb_hid_configure(struct usb_interface *intf)
 {
         struct usb_host_interface *interface = intf->cur_altsetting;
@@ -1673,6 +1700,9 @@ static struct hid_device *usb_hid_configure(struct usb_interface *intf)
                 return NULL;
         }
 
+        if ((quirks & HID_QUIRK_CYMOTION))
+                hid_fixup_cymotion_descriptor(rdesc, rsize);
+
 #ifdef DEBUG_DATA
         printk(KERN_DEBUG __FILE__ ": report descriptor (size %u, read %d) = ", rsize, n);
         for (n = 0; n < rsize; n++)
diff --git a/drivers/usb/input/hid-input.c b/drivers/usb/input/hid-input.c
index 192a03b28971..cb0d80f49252 100644
--- a/drivers/usb/input/hid-input.c
+++ b/drivers/usb/input/hid-input.c
@@ -73,6 +73,160 @@ static const struct {
 #define map_key_clear(c)        do { map_key(c); clear_bit(c, bit); } while (0)
 #define map_ff_effect(c)        do { set_bit(c, input->ffbit); } while (0)
 
+#ifdef CONFIG_USB_HIDINPUT_POWERBOOK
+
+struct hidinput_key_translation {
+        u16 from;
+        u16 to;
+        u8 flags;
+};
+
+#define POWERBOOK_FLAG_FKEY 0x01
+
+static struct hidinput_key_translation powerbook_fn_keys[] = {
+        { KEY_BACKSPACE, KEY_DELETE },
+        { KEY_F1,       KEY_BRIGHTNESSDOWN,     POWERBOOK_FLAG_FKEY },
+        { KEY_F2,       KEY_BRIGHTNESSUP,       POWERBOOK_FLAG_FKEY },
+        { KEY_F3,       KEY_MUTE,               POWERBOOK_FLAG_FKEY },
+        { KEY_F4,       KEY_VOLUMEDOWN,         POWERBOOK_FLAG_FKEY },
+        { KEY_F5,       KEY_VOLUMEUP,           POWERBOOK_FLAG_FKEY },
+        { KEY_F6,       KEY_NUMLOCK,            POWERBOOK_FLAG_FKEY },
+        { KEY_F7,       KEY_SWITCHVIDEOMODE,    POWERBOOK_FLAG_FKEY },
+        { KEY_F8,       KEY_KBDILLUMTOGGLE,     POWERBOOK_FLAG_FKEY },
+        { KEY_F9,       KEY_KBDILLUMDOWN,       POWERBOOK_FLAG_FKEY },
+        { KEY_F10,      KEY_KBDILLUMUP,         POWERBOOK_FLAG_FKEY },
+        { KEY_UP,       KEY_PAGEUP },
+        { KEY_DOWN,     KEY_PAGEDOWN },
+        { KEY_LEFT,     KEY_HOME },
+        { KEY_RIGHT,    KEY_END },
+        { }
+};
+
+static struct hidinput_key_translation powerbook_numlock_keys[] = {
+        { KEY_J,        KEY_KP1 },
+        { KEY_K,        KEY_KP2 },
+        { KEY_L,        KEY_KP3 },
+        { KEY_U,        KEY_KP4 },
+        { KEY_I,        KEY_KP5 },
+        { KEY_O,        KEY_KP6 },
+        { KEY_7,        KEY_KP7 },
+        { KEY_8,        KEY_KP8 },
+        { KEY_9,        KEY_KP9 },
+        { KEY_M,        KEY_KP0 },
+        { KEY_DOT,      KEY_KPDOT },
+        { KEY_SLASH,    KEY_KPPLUS },
+        { KEY_SEMICOLON, KEY_KPMINUS },
+        { KEY_P,        KEY_KPASTERISK },
+        { KEY_MINUS,    KEY_KPEQUAL },
+        { KEY_0,        KEY_KPSLASH },
+        { KEY_F6,       KEY_NUMLOCK },
+        { KEY_KPENTER,  KEY_KPENTER },
+        { KEY_BACKSPACE, KEY_BACKSPACE },
+        { }
+};
+
+static int usbhid_pb_fnmode = 1;
+module_param_named(pb_fnmode, usbhid_pb_fnmode, int, 0644);
+MODULE_PARM_DESC(pb_fnmode,
+        "Mode of fn key on PowerBooks (0 = disabled, 1 = fkeyslast, 2 = fkeysfirst)");
+
+static struct hidinput_key_translation *find_translation(struct hidinput_key_translation *table, u16 from)
+{
+        struct hidinput_key_translation *trans;
+
+        /* Look for the translation */
+        for (trans = table; trans->from; trans++)
+                if (trans->from == from)
+                        return trans;
+
+        return NULL;
+}
+
+static int hidinput_pb_event(struct hid_device *hid, struct input_dev *input,
+                             struct hid_usage *usage, __s32 value)
+{
+        struct hidinput_key_translation *trans;
+
+        if (usage->code == KEY_FN) {
+                if (value) hid->quirks |=  HID_QUIRK_POWERBOOK_FN_ON;
+                else       hid->quirks &= ~HID_QUIRK_POWERBOOK_FN_ON;
+
+                input_event(input, usage->type, usage->code, value);
+
+                return 1;
+        }
+
+        if (usbhid_pb_fnmode) {
+                int do_translate;
+
+                trans = find_translation(powerbook_fn_keys, usage->code);
+                if (trans) {
+                        if (test_bit(usage->code, hid->pb_pressed_fn))
+                                do_translate = 1;
+                        else if (trans->flags & POWERBOOK_FLAG_FKEY)
+                                do_translate =
+                                        (usbhid_pb_fnmode == 2 &&  (hid->quirks & HID_QUIRK_POWERBOOK_FN_ON)) ||
+                                        (usbhid_pb_fnmode == 1 && !(hid->quirks & HID_QUIRK_POWERBOOK_FN_ON));
+                        else
+                                do_translate = (hid->quirks & HID_QUIRK_POWERBOOK_FN_ON);
+
+                        if (do_translate) {
+                                if (value)
+                                        set_bit(usage->code, hid->pb_pressed_fn);
+                                else
+                                        clear_bit(usage->code, hid->pb_pressed_fn);
+
+                                input_event(input, usage->type, trans->to, value);
+
+                                return 1;
+                        }
+                }
+
+                if (test_bit(usage->code, hid->pb_pressed_numlock) ||
+                    test_bit(LED_NUML, input->led)) {
+                        trans = find_translation(powerbook_numlock_keys, usage->code);
+
+                        if (trans) {
+                                if (value)
+                                        set_bit(usage->code, hid->pb_pressed_numlock);
+                                else
+                                        clear_bit(usage->code, hid->pb_pressed_numlock);
+
+                                input_event(input, usage->type, trans->to, value);
+                        }
+
+                        return 1;
+                }
+        }
+
+        return 0;
+}
+
+static void hidinput_pb_setup(struct input_dev *input)
+{
+        struct hidinput_key_translation *trans;
+
+        set_bit(KEY_NUMLOCK, input->keybit);
+
+        /* Enable all needed keys */
+        for (trans = powerbook_fn_keys; trans->from; trans++)
+                set_bit(trans->to, input->keybit);
+
+        for (trans = powerbook_numlock_keys; trans->from; trans++)
+                set_bit(trans->to, input->keybit);
+}
+#else
+static inline int hidinput_pb_event(struct hid_device *hid, struct input_dev *input,
+                                    struct hid_usage *usage, __s32 value)
+{
+        return 0;
+}
+
+static inline void hidinput_pb_setup(struct input_dev *input)
+{
+}
+#endif
+
 static void hidinput_configure_usage(struct hid_input *hidinput, struct hid_field *field,
                                      struct hid_usage *usage)
 {
@@ -135,8 +289,11 @@ static void hidinput_configure_usage(struct hid_input *hidinput, struct hid_fiel
                 case HID_UP_SIMULATION:
 
                         switch (usage->hid & 0xffff) {
-                                case 0xba: map_abs(ABS_RUDDER); break;
+                                case 0xba: map_abs(ABS_RUDDER);   break;
                                 case 0xbb: map_abs(ABS_THROTTLE); break;
+                                case 0xc4: map_abs(ABS_GAS);      break;
+                                case 0xc5: map_abs(ABS_BRAKE);    break;
+                                case 0xc8: map_abs(ABS_WHEEL);    break;
                                 default:   goto ignore;
                         }
                         break;
@@ -289,11 +446,19 @@ static void hidinput_configure_usage(struct hid_input *hidinput, struct hid_fiel
                                 case 0x226: map_key_clear(KEY_STOP);            break;
                                 case 0x227: map_key_clear(KEY_REFRESH);         break;
                                 case 0x22a: map_key_clear(KEY_BOOKMARKS);       break;
+                                case 0x233: map_key_clear(KEY_SCROLLUP);        break;
+                                case 0x234: map_key_clear(KEY_SCROLLDOWN);      break;
                                 case 0x238: map_rel(REL_HWHEEL);                break;
                                 case 0x279: map_key_clear(KEY_REDO);            break;
                                 case 0x289: map_key_clear(KEY_REPLY);           break;
                                 case 0x28b: map_key_clear(KEY_FORWARDMAIL);     break;
                                 case 0x28c: map_key_clear(KEY_SEND);            break;
+
+                                /* Reported on a Cherry Cymotion keyboard */
+                                case 0x301: map_key_clear(KEY_PROG1);           break;
+                                case 0x302: map_key_clear(KEY_PROG2);           break;
+                                case 0x303: map_key_clear(KEY_PROG3);           break;
+
                                 default:    goto ignore;
                         }
                         break;
@@ -325,7 +490,12 @@ static void hidinput_configure_usage(struct hid_input *hidinput, struct hid_fiel
 
                         set_bit(EV_REP, input->evbit);
                         switch(usage->hid & HID_USAGE) {
-                                case 0x003: map_key_clear(KEY_FN);              break;
+                                case 0x003:
+                                        /* The fn key on Apple PowerBooks */
+                                        map_key_clear(KEY_FN);
+                                        hidinput_pb_setup(input);
+                                        break;
+
                                 default:    goto ignore;
                         }
                         break;
@@ -482,6 +652,9 @@ void hidinput_hid_event(struct hid_device *hid, struct hid_field *field, struct
                 return;
         }
 
+        if ((hid->quirks & HID_QUIRK_POWERBOOK_HAS_FN) && hidinput_pb_event(hid, input, usage, value))
+                return;
+
         if (usage->hat_min < usage->hat_max || usage->hat_dir) {
                 int hat_dir = usage->hat_dir;
                 if (!hat_dir)
@@ -524,7 +697,7 @@ void hidinput_hid_event(struct hid_device *hid, struct hid_field *field, struct
                 return;
         }
 
-        if((usage->type == EV_KEY) && (usage->code == 0)) /* Key 0 is "unassigned", not KEY_UNKNOWN */
+        if ((usage->type == EV_KEY) && (usage->code == 0)) /* Key 0 is "unassigned", not KEY_UNKNOWN */
                 return;
 
         input_event(input, usage->type, usage->code, value);
diff --git a/drivers/usb/input/hid.h b/drivers/usb/input/hid.h
index ee48a2276104..8b0d4346ce9c 100644
--- a/drivers/usb/input/hid.h
+++ b/drivers/usb/input/hid.h
@@ -235,17 +235,20 @@ struct hid_item {
  * HID device quirks.
  */
 
-#define HID_QUIRK_INVERT                        0x001
-#define HID_QUIRK_NOTOUCH                       0x002
-#define HID_QUIRK_IGNORE                        0x004
-#define HID_QUIRK_NOGET                         0x008
-#define HID_QUIRK_HIDDEV                        0x010
-#define HID_QUIRK_BADPAD                        0x020
-#define HID_QUIRK_MULTI_INPUT                   0x040
-#define HID_QUIRK_2WHEEL_MOUSE_HACK_7           0x080
-#define HID_QUIRK_2WHEEL_MOUSE_HACK_5           0x100
-#define HID_QUIRK_2WHEEL_MOUSE_HACK_ON          0x200
-#define HID_QUIRK_2WHEEL_POWERMOUSE             0x400
+#define HID_QUIRK_INVERT                        0x00000001
+#define HID_QUIRK_NOTOUCH                       0x00000002
+#define HID_QUIRK_IGNORE                        0x00000004
+#define HID_QUIRK_NOGET                         0x00000008
+#define HID_QUIRK_HIDDEV                        0x00000010
+#define HID_QUIRK_BADPAD                        0x00000020
+#define HID_QUIRK_MULTI_INPUT                   0x00000040
+#define HID_QUIRK_2WHEEL_MOUSE_HACK_7           0x00000080
+#define HID_QUIRK_2WHEEL_MOUSE_HACK_5           0x00000100
+#define HID_QUIRK_2WHEEL_MOUSE_HACK_ON          0x00000200
+#define HID_QUIRK_2WHEEL_POWERMOUSE             0x00000400
+#define HID_QUIRK_CYMOTION                      0x00000800
+#define HID_QUIRK_POWERBOOK_HAS_FN              0x00001000
+#define HID_QUIRK_POWERBOOK_FN_ON               0x00002000
 
 /*
  * This is the global environment of the parser. This information is
@@ -431,6 +434,11 @@ struct hid_device {							/* device report descriptor */
         void (*ff_exit)(struct hid_device*);                            /* Called by hid_exit_ff(hid) */
         int (*ff_event)(struct hid_device *hid, struct input_dev *input,
                         unsigned int type, unsigned int code, int value);
+
+#ifdef CONFIG_USB_HIDINPUT_POWERBOOK
+        unsigned long pb_pressed_fn[NBITS(KEY_MAX)];
+        unsigned long pb_pressed_numlock[NBITS(KEY_MAX)];
+#endif
 };
 
 #define HID_GLOBAL_STACK_SIZE 4
diff --git a/drivers/usb/input/pid.c b/drivers/usb/input/pid.c
index 19e015d171aa..d9d9f656b8c9 100644
--- a/drivers/usb/input/pid.c
+++ b/drivers/usb/input/pid.c
@@ -259,7 +259,7 @@ static int hid_pid_upload_effect(struct input_dev *dev,
 int hid_pid_init(struct hid_device *hid)
 {
         struct hid_ff_pid *private;
-        struct hid_input *hidinput = list_entry(&hid->inputs, struct hid_input, list);
+        struct hid_input *hidinput = list_entry(hid->inputs.next, struct hid_input, list);
         struct input_dev *input_dev = hidinput->input;
 
         private = hid->ff_private = kzalloc(sizeof(struct hid_ff_pid), GFP_KERNEL);
diff --git a/drivers/usb/input/wacom.c b/drivers/usb/input/wacom.c
index 48df4cfd5a42..d3e15df9e815 100644
--- a/drivers/usb/input/wacom.c
+++ b/drivers/usb/input/wacom.c
@@ -95,7 +95,7 @@ MODULE_LICENSE(DRIVER_LICENSE);
 enum {
         PENPARTNER = 0,
         GRAPHIRE,
-        G4,
+        WACOM_G4,
         PL,
         INTUOS,
         INTUOS3,
@@ -373,7 +373,7 @@ static void wacom_graphire_irq(struct urb *urb, struct pt_regs *regs)
 
                         case 2: /* Mouse with wheel */
                                 input_report_key(dev, BTN_MIDDLE, data[1] & 0x04);
-                                if (wacom->features->type == G4) {
+                                if (wacom->features->type == WACOM_G4) {
                                         rw = data[7] & 0x04 ? -(data[7] & 0x03) : (data[7] & 0x03);
                                         input_report_rel(dev, REL_WHEEL, rw);
                                 } else
@@ -385,7 +385,7 @@ static void wacom_graphire_irq(struct urb *urb, struct pt_regs *regs)
                                 id = CURSOR_DEVICE_ID;
                                 input_report_key(dev, BTN_LEFT, data[1] & 0x01);
                                 input_report_key(dev, BTN_RIGHT, data[1] & 0x02);
-                                if (wacom->features->type == G4)
+                                if (wacom->features->type == WACOM_G4)
                                         input_report_abs(dev, ABS_DISTANCE, data[6]);
                                 else
                                         input_report_abs(dev, ABS_DISTANCE, data[7]);
@@ -410,7 +410,7 @@ static void wacom_graphire_irq(struct urb *urb, struct pt_regs *regs)
         input_sync(dev);
 
         /* send pad data */
-        if (wacom->features->type == G4) {
+        if (wacom->features->type == WACOM_G4) {
                 /* fist time sending pad data */
                 if (wacom->tool[1] != BTN_TOOL_FINGER) {
                         wacom->id[1] = 0;
@@ -713,8 +713,8 @@ static struct wacom_features wacom_features[] = {
         { "Wacom Graphire2 5x7", 8,  13918, 10206,  511, 32, GRAPHIRE,   wacom_graphire_irq },
         { "Wacom Graphire3",     8,  10208,  7424,  511, 32, GRAPHIRE,   wacom_graphire_irq },
         { "Wacom Graphire3 6x8", 8,  16704, 12064,  511, 32, GRAPHIRE,   wacom_graphire_irq },
-        { "Wacom Graphire4 4x5", 8,  10208,  7424,  511, 32, G4,         wacom_graphire_irq },
-        { "Wacom Graphire4 6x8", 8,  16704, 12064,  511, 32, G4,         wacom_graphire_irq },
+        { "Wacom Graphire4 4x5", 8,  10208,  7424,  511, 32, WACOM_G4,   wacom_graphire_irq },
+        { "Wacom Graphire4 6x8", 8,  16704, 12064,  511, 32, WACOM_G4,   wacom_graphire_irq },
         { "Wacom Volito",        8,   5104,  3712,  511, 32, GRAPHIRE,   wacom_graphire_irq },
         { "Wacom PenStation2",   8,   3250,  2320,  255, 32, GRAPHIRE,   wacom_graphire_irq },
         { "Wacom Volito2 4x5",   8,   5104,  3712,  511, 32, GRAPHIRE,   wacom_graphire_irq },
@@ -859,7 +859,7 @@ static int wacom_probe(struct usb_interface *intf, const struct usb_device_id *i
         input_set_abs_params(input_dev, ABS_PRESSURE, 0, wacom->features->pressure_max, 0, 0);
 
         switch (wacom->features->type) {
-                case G4:
+                case WACOM_G4:
                         input_dev->evbit[0] |= BIT(EV_MSC);
                         input_dev->mscbit[0] |= BIT(MSC_SERIAL);
                         input_dev->keybit[LONG(BTN_DIGI)] |= BIT(BTN_TOOL_FINGER);
diff --git a/drivers/usb/serial/bus.c b/drivers/usb/serial/bus.c
index 664139afcfa9..e9f9f4bafa17 100644
--- a/drivers/usb/serial/bus.c
+++ b/drivers/usb/serial/bus.c
@@ -37,11 +37,6 @@ static int usb_serial_device_match (struct device *dev, struct device_driver *dr
         return 0;
 }
 
-struct bus_type usb_serial_bus_type = {
-        .name =         "usb-serial",
-        .match =        usb_serial_device_match,
-};
-
 static int usb_serial_device_probe (struct device *dev)
 {
         struct usb_serial_driver *driver;
@@ -109,14 +104,18 @@ exit:
         return retval;
 }
 
+struct bus_type usb_serial_bus_type = {
+        .name =         "usb-serial",
+        .match =        usb_serial_device_match,
+        .probe =        usb_serial_device_probe,
+        .remove =       usb_serial_device_remove,
+};
+
 int usb_serial_bus_register(struct usb_serial_driver *driver)
 {
         int retval;
 
         driver->driver.bus = &usb_serial_bus_type;
-        driver->driver.probe = usb_serial_device_probe;
-        driver->driver.remove = usb_serial_device_remove;
-
         retval = driver_register(&driver->driver);
 
         return retval;
diff --git a/drivers/usb/serial/pl2303.c b/drivers/usb/serial/pl2303.c
index 9ffff1938239..0eb883f44ada 100644
--- a/drivers/usb/serial/pl2303.c
+++ b/drivers/usb/serial/pl2303.c
@@ -43,8 +43,6 @@ static int debug;
 #define PL2303_BUF_SIZE         1024
 #define PL2303_TMP_BUF_SIZE     1024
 
-static DECLARE_MUTEX(pl2303_tmp_buf_sem);
-
 struct pl2303_buf {
         unsigned int    buf_size;
         char            *buf_buf;
diff --git a/drivers/video/68328fb.c b/drivers/video/68328fb.c
index 3b0ddc55236b..78488bb41aeb 100644
--- a/drivers/video/68328fb.c
+++ b/drivers/video/68328fb.c
@@ -102,8 +102,7 @@ static int mc68x328fb_setcolreg(u_int regno, u_int red, u_int green, u_int blue,
                          u_int transp, struct fb_info *info);
 static int mc68x328fb_pan_display(struct fb_var_screeninfo *var,
                            struct fb_info *info);
-static int mc68x328fb_mmap(struct fb_info *info, struct file *file,
-                    struct vm_area_struct *vma);
+static int mc68x328fb_mmap(struct fb_info *info, struct vm_area_struct *vma);
 
 static struct fb_ops mc68x328fb_ops = {
         .fb_check_var   = mc68x328fb_check_var,
@@ -398,8 +397,7 @@ static int mc68x328fb_pan_display(struct fb_var_screeninfo *var,
      *  Most drivers don't need their own mmap function 
      */
 
-static int mc68x328fb_mmap(struct fb_info *info, struct file *file,
-                    struct vm_area_struct *vma)
+static int mc68x328fb_mmap(struct fb_info *info, struct vm_area_struct *vma)
 {
 #ifndef MMU
         /* this is uClinux (no MMU) specific code */
diff --git a/drivers/video/acornfb.c b/drivers/video/acornfb.c
index 750cebb18306..b058273527bb 100644
--- a/drivers/video/acornfb.c
+++ b/drivers/video/acornfb.c
@@ -883,7 +883,7 @@ acornfb_pan_display(struct fb_var_screeninfo *var, struct fb_info *info)
  * Note that we are entered with the kernel locked.
  */
 static int
-acornfb_mmap(struct fb_info *info, struct file *file, struct vm_area_struct *vma)
+acornfb_mmap(struct fb_info *info, struct vm_area_struct *vma)
 {
         unsigned long off, start;
         u32 len;
diff --git a/drivers/video/amba-clcd.c b/drivers/video/amba-clcd.c
index 0da4083ba908..b2187175d03f 100644
--- a/drivers/video/amba-clcd.c
+++ b/drivers/video/amba-clcd.c
@@ -307,7 +307,7 @@ static int clcdfb_blank(int blank_mode, struct fb_info *info)
         return 0;
 }
 
-static int clcdfb_mmap(struct fb_info *info, struct file *file,
+static int clcdfb_mmap(struct fb_info *info,
                        struct vm_area_struct *vma)
 {
         struct clcd_fb *fb = to_clcd(info);
diff --git a/drivers/video/amifb.c b/drivers/video/amifb.c
index 2c42a812655a..3033c72dea20 100644
--- a/drivers/video/amifb.c
+++ b/drivers/video/amifb.c
@@ -1131,9 +1131,7 @@ static void amifb_copyarea(struct fb_info *info,
                            const struct fb_copyarea *region);
 static void amifb_imageblit(struct fb_info *info,
                             const struct fb_image *image);
-static int amifb_ioctl(struct inode *inode, struct file *file,
-                       unsigned int cmd, unsigned long arg,
-                       struct fb_info *info);
+static int amifb_ioctl(struct fb_info *info, unsigned int cmd, unsigned long arg);
 
 
         /*
@@ -2172,9 +2170,8 @@ static void amifb_imageblit(struct fb_info *info, const struct fb_image *image)
          * Amiga Frame Buffer Specific ioctls
          */
 
-static int amifb_ioctl(struct inode *inode, struct file *file,
-                       unsigned int cmd, unsigned long arg,
-                       struct fb_info *info)
+static int amifb_ioctl(struct fb_info *info,
+                       unsigned int cmd, unsigned long arg)
 {
         union {
                 struct fb_fix_cursorinfo fix;
diff --git a/drivers/video/arcfb.c b/drivers/video/arcfb.c
index 89060b2db8e5..df8e5667b348 100644
--- a/drivers/video/arcfb.c
+++ b/drivers/video/arcfb.c
@@ -399,9 +399,8 @@ static void arcfb_imageblit(struct fb_info *info, const struct fb_image *image)
                                 image->height);
 }
 
-static int arcfb_ioctl(struct inode *inode, struct file *file,
-                          unsigned int cmd, unsigned long arg,
-                          struct fb_info *info)
+static int arcfb_ioctl(struct fb_info *info,
+                          unsigned int cmd, unsigned long arg)
 {
         void __user *argp = (void __user *)arg;
         struct arcfb_par *par = info->par;
diff --git a/drivers/video/atafb.c b/drivers/video/atafb.c
index 15ec1295bc29..e69ab65f7843 100644
--- a/drivers/video/atafb.c
+++ b/drivers/video/atafb.c
@@ -2571,8 +2571,7 @@ atafb_pan_display(struct fb_var_screeninfo *var, int con, struct fb_info *info)
 }
 
 static int
-atafb_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
-               unsigned long arg, int con, struct fb_info *info)
+atafb_ioctl(struct fb_info *info, unsigned int cmd, unsigned long arg)
 {
         switch (cmd) {
 #ifdef FBCMD_GET_CURRENTPAR
diff --git a/drivers/video/aty/aty128fb.c b/drivers/video/aty/aty128fb.c
index e686185a076d..bfc8a93b2c73 100644
--- a/drivers/video/aty/aty128fb.c
+++ b/drivers/video/aty/aty128fb.c
@@ -431,8 +431,7 @@ static int aty128fb_setcolreg(u_int regno, u_int red, u_int green, u_int blue,
 static int aty128fb_pan_display(struct fb_var_screeninfo *var,
                            struct fb_info *fb);
 static int aty128fb_blank(int blank, struct fb_info *fb);
-static int aty128fb_ioctl(struct inode *inode, struct file *file, u_int cmd,
-                          u_long arg, struct fb_info *info);
+static int aty128fb_ioctl(struct fb_info *info, u_int cmd, unsigned long arg);
 static int aty128fb_sync(struct fb_info *info);
 
     /*
@@ -2108,8 +2107,7 @@ static int aty128fb_setcolreg(u_int regno, u_int red, u_int green, u_int blue,
 /* in param: u32*       backlight value: 0 to 15 */
 #define FBIO_ATY128_SET_MIRROR  _IOW('@', 2, __u32)
 
-static int aty128fb_ioctl(struct inode *inode, struct file *file, u_int cmd,
-                          u_long arg, struct fb_info *info)
+static int aty128fb_ioctl(struct fb_info *info, u_int cmd, u_long arg)
 {
         struct aty128fb_par *par = info->par;
         u32 value;
diff --git a/drivers/video/aty/atyfb_base.c b/drivers/video/aty/atyfb_base.c
index ed81005cbdba..485be386a8ff 100644
--- a/drivers/video/aty/atyfb_base.c
+++ b/drivers/video/aty/atyfb_base.c
@@ -238,13 +238,12 @@ static int atyfb_setcolreg(u_int regno, u_int red, u_int green, u_int blue,
         u_int transp, struct fb_info *info);
 static int atyfb_pan_display(struct fb_var_screeninfo *var, struct fb_info *info);
 static int atyfb_blank(int blank, struct fb_info *info);
-static int atyfb_ioctl(struct inode *inode, struct file *file, u_int cmd,
-        u_long arg, struct fb_info *info);
+static int atyfb_ioctl(struct fb_info *info, u_int cmd, u_long arg);
 extern void atyfb_fillrect(struct fb_info *info, const struct fb_fillrect *rect);
 extern void atyfb_copyarea(struct fb_info *info, const struct fb_copyarea *area);
 extern void atyfb_imageblit(struct fb_info *info, const struct fb_image *image);
 #ifdef __sparc__
-static int atyfb_mmap(struct fb_info *info, struct file *file, struct vm_area_struct *vma);
+static int atyfb_mmap(struct fb_info *info, struct vm_area_struct *vma);
 #endif
 static int atyfb_sync(struct fb_info *info);
 
@@ -1739,8 +1738,7 @@ struct atyclk {
 #define FBIO_WAITFORVSYNC _IOW('F', 0x20, __u32)
 #endif
 
-static int atyfb_ioctl(struct inode *inode, struct file *file, u_int cmd,
-        u_long arg, struct fb_info *info)
+static int atyfb_ioctl(struct fb_info *info, u_int cmd, u_long arg)
 {
         struct atyfb_par *par = (struct atyfb_par *) info->par;
 #ifdef __sparc__
@@ -1845,7 +1843,7 @@ static int atyfb_sync(struct fb_info *info)
 }
 
 #ifdef __sparc__
-static int atyfb_mmap(struct fb_info *info, struct file *file, struct vm_area_struct *vma)
+static int atyfb_mmap(struct fb_info *info, struct vm_area_struct *vma)
 {
         struct atyfb_par *par = (struct atyfb_par *) info->par;
         unsigned int size, page, map_size = 0;
diff --git a/drivers/video/aty/radeon_base.c b/drivers/video/aty/radeon_base.c
index 156db84cb363..c9f0c5a07e6e 100644
--- a/drivers/video/aty/radeon_base.c
+++ b/drivers/video/aty/radeon_base.c
@@ -864,8 +864,8 @@ static int radeonfb_pan_display (struct fb_var_screeninfo *var,
 }
 
 
-static int radeonfb_ioctl (struct inode *inode, struct file *file, unsigned int cmd,
-                           unsigned long arg, struct fb_info *info)
+static int radeonfb_ioctl (struct fb_info *info, unsigned int cmd,
+                           unsigned long arg)
 {
         struct radeonfb_info *rinfo = info->par;
         unsigned int tmp;
diff --git a/drivers/video/au1100fb.c b/drivers/video/au1100fb.c
index a5129806172f..2406899f1207 100644
--- a/drivers/video/au1100fb.c
+++ b/drivers/video/au1100fb.c
@@ -379,7 +379,7 @@ void au1100fb_fb_rotate(struct fb_info *fbi, int angle)
  * Map video memory in user space. We don't use the generic fb_mmap method mainly
  * to allow the use of the TLB streaming flag (CCA=6)
  */
-int au1100fb_fb_mmap(struct fb_info *fbi, struct file *file, struct vm_area_struct *vma)
+int au1100fb_fb_mmap(struct fb_info *fbi, struct vm_area_struct *vma)
 {
         struct au1100fb_device *fbdev = to_au1100fb_device(fbi);
         unsigned int len;
diff --git a/drivers/video/bw2.c b/drivers/video/bw2.c
index 9248fe1fbb1a..c029db4646f6 100644
--- a/drivers/video/bw2.c
+++ b/drivers/video/bw2.c
@@ -35,9 +35,8 @@
 
 static int bw2_blank(int, struct fb_info *);
 
-static int bw2_mmap(struct fb_info *, struct file *, struct vm_area_struct *);
-static int bw2_ioctl(struct inode *, struct file *, unsigned int,
-                     unsigned long, struct fb_info *);
+static int bw2_mmap(struct fb_info *, struct vm_area_struct *);
+static int bw2_ioctl(struct fb_info *, unsigned int, unsigned long);
 
 /*
  *  Frame buffer operations
@@ -169,7 +168,7 @@ static struct sbus_mmap_map bw2_mmap_map[] = {
         { .size = 0 }
 };
 
-static int bw2_mmap(struct fb_info *info, struct file *file, struct vm_area_struct *vma)
+static int bw2_mmap(struct fb_info *info, struct vm_area_struct *vma)
 {
         struct bw2_par *par = (struct bw2_par *)info->par;
 
@@ -181,8 +180,7 @@ static int bw2_mmap(struct fb_info *info, struct file *file, struct vm_area_stru
                                   vma);
 }
 
-static int bw2_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
-                     unsigned long arg, struct fb_info *info)
+static int bw2_ioctl(struct fb_info *info, unsigned int cmd, unsigned long arg)
 {
         struct bw2_par *par = (struct bw2_par *) info->par;
 
diff --git a/drivers/video/cg14.c b/drivers/video/cg14.c
index a56147102abb..63b6c79c8a0a 100644
--- a/drivers/video/cg14.c
+++ b/drivers/video/cg14.c
@@ -31,9 +31,8 @@
 static int cg14_setcolreg(unsigned, unsigned, unsigned, unsigned,
                          unsigned, struct fb_info *);
 
-static int cg14_mmap(struct fb_info *, struct file *, struct vm_area_struct *);
-static int cg14_ioctl(struct inode *, struct file *, unsigned int,
-                      unsigned long, struct fb_info *);
+static int cg14_mmap(struct fb_info *, struct vm_area_struct *);
+static int cg14_ioctl(struct fb_info *, unsigned int, unsigned long);
 static int cg14_pan_display(struct fb_var_screeninfo *, struct fb_info *);
 
 /*
@@ -268,7 +267,7 @@ static int cg14_setcolreg(unsigned regno,
         return 0;
 }
 
-static int cg14_mmap(struct fb_info *info, struct file *file, struct vm_area_struct *vma)
+static int cg14_mmap(struct fb_info *info, struct vm_area_struct *vma)
 {
         struct cg14_par *par = (struct cg14_par *) info->par;
 
@@ -277,8 +276,7 @@ static int cg14_mmap(struct fb_info *info, struct file *file, struct vm_area_str
                                   par->iospace, vma);
 }
 
-static int cg14_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
-                      unsigned long arg, struct fb_info *info)
+static int cg14_ioctl(struct fb_info *info, unsigned int cmd, unsigned long arg)
 {
         struct cg14_par *par = (struct cg14_par *) info->par;
         struct cg14_regs __iomem *regs = par->regs;
diff --git a/drivers/video/cg3.c b/drivers/video/cg3.c
index 9fcd89608ed7..3de6e1b5ab2f 100644
--- a/drivers/video/cg3.c
+++ b/drivers/video/cg3.c
@@ -33,9 +33,8 @@ static int cg3_setcolreg(unsigned, unsigned, unsigned, unsigned,
                          unsigned, struct fb_info *);
 static int cg3_blank(int, struct fb_info *);
 
-static int cg3_mmap(struct fb_info *, struct file *, struct vm_area_struct *);
-static int cg3_ioctl(struct inode *, struct file *, unsigned int,
-                     unsigned long, struct fb_info *);
+static int cg3_mmap(struct fb_info *, struct vm_area_struct *);
+static int cg3_ioctl(struct fb_info *, unsigned int, unsigned long);
 
 /*
  *  Frame buffer operations
@@ -230,7 +229,7 @@ static struct sbus_mmap_map cg3_mmap_map[] = {
         { .size = 0 }
 };
 
-static int cg3_mmap(struct fb_info *info, struct file *file, struct vm_area_struct *vma)
+static int cg3_mmap(struct fb_info *info, struct vm_area_struct *vma)
 {
         struct cg3_par *par = (struct cg3_par *)info->par;
 
@@ -240,8 +239,7 @@ static int cg3_mmap(struct fb_info *info, struct file *file, struct vm_area_stru
                                   vma);
 }
 
-static int cg3_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
-                     unsigned long arg, struct fb_info *info)
+static int cg3_ioctl(struct fb_info *info, unsigned int cmd, unsigned long arg)
 {
         struct cg3_par *par = (struct cg3_par *) info->par;
 
diff --git a/drivers/video/cg6.c b/drivers/video/cg6.c
index 050835e39aa3..7aab91ead681 100644
--- a/drivers/video/cg6.c
+++ b/drivers/video/cg6.c
@@ -36,9 +36,8 @@ static int cg6_blank(int, struct fb_info *);
 static void cg6_imageblit(struct fb_info *, const struct fb_image *);
 static void cg6_fillrect(struct fb_info *, const struct fb_fillrect *);
 static int cg6_sync(struct fb_info *);
-static int cg6_mmap(struct fb_info *, struct file *, struct vm_area_struct *);
-static int cg6_ioctl(struct inode *, struct file *, unsigned int,
-                     unsigned long, struct fb_info *);
+static int cg6_mmap(struct fb_info *, struct vm_area_struct *);
+static int cg6_ioctl(struct fb_info *, unsigned int, unsigned long);
 
 /*
  *  Frame buffer operations
@@ -524,7 +523,7 @@ static struct sbus_mmap_map cg6_mmap_map[] = {
         { .size = 0 }
 };
 
-static int cg6_mmap(struct fb_info *info, struct file *file, struct vm_area_struct *vma)
+static int cg6_mmap(struct fb_info *info, struct vm_area_struct *vma)
 {
         struct cg6_par *par = (struct cg6_par *)info->par;
 
@@ -534,8 +533,7 @@ static int cg6_mmap(struct fb_info *info, struct file *file, struct vm_area_stru
                                   vma);
 }
 
-static int cg6_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
-                     unsigned long arg, struct fb_info *info)
+static int cg6_ioctl(struct fb_info *info, unsigned int cmd, unsigned long arg)
 {
         struct cg6_par *par = (struct cg6_par *) info->par;
 
diff --git a/drivers/video/controlfb.c b/drivers/video/controlfb.c
index 03798e9c882d..655301a8671c 100644
--- a/drivers/video/controlfb.c
+++ b/drivers/video/controlfb.c
@@ -128,7 +128,7 @@ static int controlfb_pan_display(struct fb_var_screeninfo *var,
 static int controlfb_setcolreg(u_int regno, u_int red, u_int green, u_int blue,
         u_int transp, struct fb_info *info);
 static int controlfb_blank(int blank_mode, struct fb_info *info);
-static int controlfb_mmap(struct fb_info *info, struct file *file,
+static int controlfb_mmap(struct fb_info *info,
         struct vm_area_struct *vma);
 static int controlfb_set_par (struct fb_info *info);
 static int controlfb_check_var (struct fb_var_screeninfo *var, struct fb_info *info);
@@ -280,7 +280,7 @@ static int controlfb_pan_display(struct fb_var_screeninfo *var,
  * for controlfb.
  * Note there's no locking in here; it's done in fb_mmap() in fbmem.c.
  */
-static int controlfb_mmap(struct fb_info *info, struct file *file,
+static int controlfb_mmap(struct fb_info *info,
                        struct vm_area_struct *vma)
 {
        unsigned long off, start;
diff --git a/drivers/video/fbmem.c b/drivers/video/fbmem.c
index 32a9b69becc5..d2dede6ed3e5 100644
--- a/drivers/video/fbmem.c
+++ b/drivers/video/fbmem.c
@@ -957,7 +957,7 @@ fb_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
         default:
                 if (fb->fb_ioctl == NULL)
                         return -EINVAL;
-                return fb->fb_ioctl(inode, file, cmd, arg, info);
+                return fb->fb_ioctl(info, cmd, arg);
         }
 }
 
@@ -1107,7 +1107,7 @@ fb_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 
         default:
                 if (fb->fb_compat_ioctl)
-                        ret = fb->fb_compat_ioctl(file, cmd, arg, info);
+                        ret = fb->fb_compat_ioctl(info, cmd, arg);
                 break;
         }
         unlock_kernel();
@@ -1135,7 +1135,7 @@ fb_mmap(struct file *file, struct vm_area_struct * vma)
         if (fb->fb_mmap) {
                 int res;
                 lock_kernel();
-                res = fb->fb_mmap(info, file, vma);
+                res = fb->fb_mmap(info, vma);
                 unlock_kernel();
                 return res;
         }
diff --git a/drivers/video/ffb.c b/drivers/video/ffb.c
index c4870d559afc..9c9b21d469a1 100644
--- a/drivers/video/ffb.c
+++ b/drivers/video/ffb.c
@@ -37,9 +37,8 @@ static void ffb_imageblit(struct fb_info *, const struct fb_image *);
 static void ffb_fillrect(struct fb_info *, const struct fb_fillrect *);
 static void ffb_copyarea(struct fb_info *, const struct fb_copyarea *);
 static int ffb_sync(struct fb_info *);
-static int ffb_mmap(struct fb_info *, struct file *, struct vm_area_struct *);
-static int ffb_ioctl(struct inode *, struct file *, unsigned int,
-                     unsigned long, struct fb_info *);
+static int ffb_mmap(struct fb_info *, struct vm_area_struct *);
+static int ffb_ioctl(struct fb_info *, unsigned int, unsigned long);
 static int ffb_pan_display(struct fb_var_screeninfo *, struct fb_info *);
 
 /*
@@ -839,7 +838,7 @@ static struct sbus_mmap_map ffb_mmap_map[] = {
         { .size = 0 }
 };
 
-static int ffb_mmap(struct fb_info *info, struct file *file, struct vm_area_struct *vma)
+static int ffb_mmap(struct fb_info *info, struct vm_area_struct *vma)
 {
         struct ffb_par *par = (struct ffb_par *)info->par;
 
@@ -848,8 +847,7 @@ static int ffb_mmap(struct fb_info *info, struct file *file, struct vm_area_stru
                                   0, vma);
 }
 
-static int ffb_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
-                     unsigned long arg, struct fb_info *info)
+static int ffb_ioctl(struct fb_info *info, unsigned int cmd, unsigned long arg)
 {
         struct ffb_par *par = (struct ffb_par *) info->par;
 
diff --git a/drivers/video/gbefb.c b/drivers/video/gbefb.c
index d744c51807b7..38d22729b129 100644
--- a/drivers/video/gbefb.c
+++ b/drivers/video/gbefb.c
@@ -979,7 +979,7 @@ static int gbefb_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
         return 0;
 }
 
-static int gbefb_mmap(struct fb_info *info, struct file *file,
+static int gbefb_mmap(struct fb_info *info,
                         struct vm_area_struct *vma)
 {
         unsigned long size = vma->vm_end - vma->vm_start;
@@ -1000,7 +1000,6 @@ static int gbefb_mmap(struct fb_info *info, struct file *file,
                 pgprot_fb(pgprot_val(vma->vm_page_prot));
 
         vma->vm_flags |= VM_IO | VM_RESERVED;
-        vma->vm_file = file;
 
         /* look for the starting tile */
         tile = &gbe_tiles.cpu[offset >> TILE_SHIFT];
diff --git a/drivers/video/geode/gx1fb_core.c b/drivers/video/geode/gx1fb_core.c
index 8e8da7433994..20e69156d728 100644
--- a/drivers/video/geode/gx1fb_core.c
+++ b/drivers/video/geode/gx1fb_core.c
@@ -215,11 +215,11 @@ static int __init gx1fb_map_video_memory(struct fb_info *info, struct pci_dev *d
         if (ret < 0)
                 return ret;
 
-        ret = pci_request_region(dev, 1, "gx1fb (video)");
+        ret = pci_request_region(dev, 0, "gx1fb (video)");
         if (ret < 0)
                 return ret;
-        par->vid_regs = ioremap(pci_resource_start(dev, 1),
-                                pci_resource_len(dev, 1));
+        par->vid_regs = ioremap(pci_resource_start(dev, 0),
+                                pci_resource_len(dev, 0));
         if (!par->vid_regs)
                 return -ENOMEM;
 
@@ -229,12 +229,9 @@ static int __init gx1fb_map_video_memory(struct fb_info *info, struct pci_dev *d
         if (!par->dc_regs)
                 return -ENOMEM;
 
-        ret = pci_request_region(dev, 0, "gx1fb (frame buffer)");
-        if (ret < 0 )
-                return -EBUSY;
         if ((fb_len = gx1_frame_buffer_size()) < 0)
                 return -ENOMEM;
-        info->fix.smem_start = pci_resource_start(dev, 0);
+        info->fix.smem_start = gx_base + 0x800000;
         info->fix.smem_len = fb_len;
         info->screen_base = ioremap(info->fix.smem_start, info->fix.smem_len);
         if (!info->screen_base)
diff --git a/drivers/video/igafb.c b/drivers/video/igafb.c
index e326f44f652d..6b88050d21bf 100644
--- a/drivers/video/igafb.c
+++ b/drivers/video/igafb.c
@@ -219,7 +219,7 @@ static void iga_blank_border(struct iga_par *par)
 }
 
 #ifdef __sparc__
-static int igafb_mmap(struct fb_info *info, struct file *file,
+static int igafb_mmap(struct fb_info *info,
                       struct vm_area_struct *vma)
 {
         struct iga_par *par = (struct iga_par *)info->par;
diff --git a/drivers/video/imsttfb.c b/drivers/video/imsttfb.c
index a5d813050db5..ad416ae47596 100644
--- a/drivers/video/imsttfb.c
+++ b/drivers/video/imsttfb.c
@@ -1267,8 +1267,7 @@ imsttfb_cursor(struct fb_info *info, struct fb_cursor *cursor)
 #define FBIMSTT_GETIDXREG       0x545406
 
 static int
-imsttfb_ioctl(struct inode *inode, struct file *file, u_int cmd,
-              u_long arg, struct fb_info *info)
+imsttfb_ioctl(struct fb_info *info, u_int cmd, u_long arg)
 {
         struct imstt_par *par = info->par;
         void __user *argp = (void __user *)arg;
diff --git a/drivers/video/intelfb/intelfbdrv.c b/drivers/video/intelfb/intelfbdrv.c
index 0090544842f5..6b8bd3cdf9c0 100644
--- a/drivers/video/intelfb/intelfbdrv.c
+++ b/drivers/video/intelfb/intelfbdrv.c
@@ -157,9 +157,8 @@ static int intelfb_cursor(struct fb_info *info,
 
 static int intelfb_sync(struct fb_info *info);
 
-static int intelfb_ioctl(struct inode *inode, struct file *file,
-                         unsigned int cmd, unsigned long arg,
-                         struct fb_info *info);
+static int intelfb_ioctl(struct fb_info *info,
+                         unsigned int cmd, unsigned long arg);
 
 static int __devinit intelfb_pci_register(struct pci_dev *pdev,
                                           const struct pci_device_id *ent);
@@ -1380,8 +1379,7 @@ intelfb_pan_display(struct fb_var_screeninfo *var, struct fb_info *info)
 
 /* When/if we have our own ioctls. */
 static int
-intelfb_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
-              unsigned long arg, struct fb_info *info)
+intelfb_ioctl(struct fb_info *info, unsigned int cmd, unsigned long arg)
 {
         int retval = 0;
 
diff --git a/drivers/video/kyro/fbdev.c b/drivers/video/kyro/fbdev.c
index bcd359b6d4ff..477ad297de4e 100644
--- a/drivers/video/kyro/fbdev.c
+++ b/drivers/video/kyro/fbdev.c
@@ -586,9 +586,8 @@ static int __init kyrofb_setup(char *options)
 }
 #endif
 
-static int kyrofb_ioctl(struct inode *inode, struct file *file,
-                        unsigned int cmd, unsigned long arg,
-                        struct fb_info *info)
+static int kyrofb_ioctl(struct fb_info *info,
+                        unsigned int cmd, unsigned long arg)
 {
         overlay_create ol_create;
         overlay_viewport_set ol_viewport_set;
diff --git a/drivers/video/leo.c b/drivers/video/leo.c
index 494287f8f8bf..a23cfdb9d826 100644
--- a/drivers/video/leo.c
+++ b/drivers/video/leo.c
@@ -32,9 +32,8 @@ static int leo_setcolreg(unsigned, unsigned, unsigned, unsigned,
                          unsigned, struct fb_info *);
 static int leo_blank(int, struct fb_info *);
 
-static int leo_mmap(struct fb_info *, struct file *, struct vm_area_struct *);
-static int leo_ioctl(struct inode *, struct file *, unsigned int,
-                     unsigned long, struct fb_info *);
+static int leo_mmap(struct fb_info *, struct vm_area_struct *);
+static int leo_ioctl(struct fb_info *, unsigned int, unsigned long);
 static int leo_pan_display(struct fb_var_screeninfo *, struct fb_info *);
 
 /*
@@ -363,7 +362,7 @@ static struct sbus_mmap_map leo_mmap_map[] = {
         { .size = 0 }
 };
 
-static int leo_mmap(struct fb_info *info, struct file *file, struct vm_area_struct *vma)
+static int leo_mmap(struct fb_info *info, struct vm_area_struct *vma)
 {
         struct leo_par *par = (struct leo_par *)info->par;
 
@@ -373,8 +372,7 @@ static int leo_mmap(struct fb_info *info, struct file *file, struct vm_area_stru
                                   vma);
 }
 
-static int leo_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
-                     unsigned long arg, struct fb_info *info)
+static int leo_ioctl(struct fb_info *info, unsigned int cmd, unsigned long arg)
 {
         struct leo_par *par = (struct leo_par *) info->par;
 
diff --git a/drivers/video/matrox/matroxfb_base.c b/drivers/video/matrox/matroxfb_base.c
index 1e74f4cca53b..4055ff6f5a81 100644
--- a/drivers/video/matrox/matroxfb_base.c
+++ b/drivers/video/matrox/matroxfb_base.c
@@ -865,9 +865,8 @@ static struct matrox_altout panellink_output = {
         .name    = "Panellink output",
 };
 
-static int matroxfb_ioctl(struct inode *inode, struct file *file,
-                          unsigned int cmd, unsigned long arg,
-                          struct fb_info *info)
+static int matroxfb_ioctl(struct fb_info *info,
+                          unsigned int cmd, unsigned long arg)
 {
         void __user *argp = (void __user *)arg;
         MINFO_FROM_INFO(info);
diff --git a/drivers/video/matrox/matroxfb_crtc2.c b/drivers/video/matrox/matroxfb_crtc2.c
index d52d7d825c41..27eb4bb4f89f 100644
--- a/drivers/video/matrox/matroxfb_crtc2.c
+++ b/drivers/video/matrox/matroxfb_crtc2.c
@@ -419,11 +419,10 @@ static int matroxfb_dh_get_vblank(const struct matroxfb_dh_fb_info* m2info, stru
         return 0;
 }
 
-static int matroxfb_dh_ioctl(struct inode* inode,
-                struct file* file,
+static int matroxfb_dh_ioctl(struct fb_info *info,
                 unsigned int cmd,
-                unsigned long arg,
-                struct fb_info* info) {
+                unsigned long arg)
+{
 #define m2info (container_of(info, struct matroxfb_dh_fb_info, fbcon))
         MINFO_FROM(m2info->primary_dev);
 
@@ -457,7 +456,7 @@ static int matroxfb_dh_ioctl(struct inode* inode,
                 case MATROXFB_GET_OUTPUT_MODE:
                 case MATROXFB_GET_ALL_OUTPUTS:
                         {
-                                return ACCESS_FBINFO(fbcon.fbops)->fb_ioctl(inode, file, cmd, arg, &ACCESS_FBINFO(fbcon));
+                                return ACCESS_FBINFO(fbcon.fbops)->fb_ioctl(&ACCESS_FBINFO(fbcon), cmd, arg);
                         }
                 case MATROXFB_SET_OUTPUT_CONNECTION:
                         {
diff --git a/drivers/video/matrox/matroxfb_maven.c b/drivers/video/matrox/matroxfb_maven.c
index a1f2c5e8fc88..6019710dc298 100644
--- a/drivers/video/matrox/matroxfb_maven.c
+++ b/drivers/video/matrox/matroxfb_maven.c
@@ -968,7 +968,7 @@ static inline int maven_compute_timming(struct maven_data* md,
         return 0;
 }
 
-static inline int maven_program_timming(struct maven_data* md,
+static int maven_program_timming(struct maven_data* md,
                 const struct mavenregs* m) {
         struct i2c_client* c = md->client;
 
diff --git a/drivers/video/neofb.c b/drivers/video/neofb.c
index e18c9f98a401..747602aa5615 100644
--- a/drivers/video/neofb.c
+++ b/drivers/video/neofb.c
@@ -853,7 +853,7 @@ static int neofb_set_par(struct fb_info *info)
         /* If the user did not specify any display devices, then... */
         if (par->PanelDispCntlReg1 == 0x00) {
                 /* Default to internal (i.e., LCD) only. */
-                par->PanelDispCntlReg1 |= 0x02;
+                par->PanelDispCntlReg1 = vga_rgfx(NULL, 0x20) & 0x03;
         }
 
         /* If we are using a fixed mode, then tell the chip we are. */
diff --git a/drivers/video/p9100.c b/drivers/video/p9100.c
index b251e754e16c..0d1957505359 100644
--- a/drivers/video/p9100.c
+++ b/drivers/video/p9100.c
@@ -31,9 +31,8 @@ static int p9100_setcolreg(unsigned, unsigned, unsigned, unsigned,
                            unsigned, struct fb_info *);
 static int p9100_blank(int, struct fb_info *);
 
-static int p9100_mmap(struct fb_info *, struct file *, struct vm_area_struct *);
-static int p9100_ioctl(struct inode *, struct file *, unsigned int,
-                       unsigned long, struct fb_info *);
+static int p9100_mmap(struct fb_info *, struct vm_area_struct *);
+static int p9100_ioctl(struct fb_info *, unsigned int, unsigned long);
 
 /*
  *  Frame buffer operations
@@ -222,7 +221,7 @@ static struct sbus_mmap_map p9100_mmap_map[] = {
         { 0,                    0,              0                   }
 };
 
-static int p9100_mmap(struct fb_info *info, struct file *file, struct vm_area_struct *vma)
+static int p9100_mmap(struct fb_info *info, struct vm_area_struct *vma)
 {
         struct p9100_par *par = (struct p9100_par *)info->par;
 
@@ -232,8 +231,8 @@ static int p9100_mmap(struct fb_info *info, struct file *file, struct vm_area_st
                                   vma);
 }
 
-static int p9100_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
-                       unsigned long arg, struct fb_info *info)
+static int p9100_ioctl(struct fb_info *info, unsigned int cmd,
+                       unsigned long arg)
 {
         struct p9100_par *par = (struct p9100_par *) info->par;
 
diff --git a/drivers/video/pm3fb.c b/drivers/video/pm3fb.c
index 2e11b601c488..0e78ddc81583 100644
--- a/drivers/video/pm3fb.c
+++ b/drivers/video/pm3fb.c
@@ -657,9 +657,7 @@ static void pm3fb_set_disp(const void *par, struct display *disp,
 static void pm3fb_detect(void);
 static int pm3fb_pan_display(const struct fb_var_screeninfo *var,
                              struct fb_info_gen *info);
-static int pm3fb_ioctl(struct inode *inode, struct file *file,
-                       u_int cmd, u_long arg, int con,
-                       struct fb_info *info);
+static int pm3fb_ioctl(struct fb_info *info, u_int cmd, u_long arg);
 
 
 /* the struct that hold them together */
@@ -3438,9 +3436,7 @@ static int pm3fb_pan_display(const struct fb_var_screeninfo *var,
         return 0;
 }
 
-static int pm3fb_ioctl(struct inode *inode, struct file *file,
-                       u_int cmd, u_long arg, int con,
-                       struct fb_info *info)
+static int pm3fb_ioctl(struct fb_info *info, u_int cmd, u_long arg)
 {
         struct pm3fb_info *l_fb_info = (struct pm3fb_info *) info;
         u32 cm, i;
diff --git a/drivers/video/pmag-aa-fb.c b/drivers/video/pmag-aa-fb.c
index 28d1fe5fe340..d92f352211ef 100644
--- a/drivers/video/pmag-aa-fb.c
+++ b/drivers/video/pmag-aa-fb.c
@@ -299,8 +299,7 @@ static int aafb_set_cmap(struct fb_cmap *cmap, int kspc, int con,
                 return -EINVAL;
 }
 
-static int aafb_ioctl(struct inode *inode, struct file *file, u32 cmd,
-                      unsigned long arg, int con, struct fb_info *info)
+static int aafb_ioctl(struct fb_info *info, u32 cmd, unsigned long arg)
 {
         /* TODO: Not yet implemented */
         return -ENOIOCTLCMD;
diff --git a/drivers/video/pxafb.c b/drivers/video/pxafb.c
index 9fc10b9e6f57..53ad61f1038c 100644
--- a/drivers/video/pxafb.c
+++ b/drivers/video/pxafb.c
@@ -395,7 +395,7 @@ static int pxafb_blank(int blank, struct fb_info *info)
         return 0;
 }
 
-static int pxafb_mmap(struct fb_info *info, struct file *file,
+static int pxafb_mmap(struct fb_info *info,
                       struct vm_area_struct *vma)
 {
         struct pxafb_info *fbi = (struct pxafb_info *)info;
diff --git a/drivers/video/radeonfb.c b/drivers/video/radeonfb.c
index 600318f708f2..db9fb9074dbc 100644
--- a/drivers/video/radeonfb.c
+++ b/drivers/video/radeonfb.c
@@ -1497,8 +1497,8 @@ static int radeonfb_pan_display (struct fb_var_screeninfo *var,
 }
 
 
-static int radeonfb_ioctl (struct inode *inode, struct file *file, unsigned int cmd,
-                           unsigned long arg, struct fb_info *info)
+static int radeonfb_ioctl (struct fb_info *info, unsigned int cmd,
+                           unsigned long arg)
 {
         struct radeonfb_info *rinfo = (struct radeonfb_info *) info;
         unsigned int tmp;
diff --git a/drivers/video/sa1100fb.c b/drivers/video/sa1100fb.c
index 087e58689e4c..8a893ce7040d 100644
--- a/drivers/video/sa1100fb.c
+++ b/drivers/video/sa1100fb.c
@@ -815,7 +815,7 @@ static int sa1100fb_blank(int blank, struct fb_info *info)
         return 0;
 }
 
-static int sa1100fb_mmap(struct fb_info *info, struct file *file,
+static int sa1100fb_mmap(struct fb_info *info,
                          struct vm_area_struct *vma)
 {
         struct sa1100fb_info *fbi = (struct sa1100fb_info *)info;
diff --git a/drivers/video/sgivwfb.c b/drivers/video/sgivwfb.c
index 7054660767e4..2e6df1fcb2b9 100644
--- a/drivers/video/sgivwfb.c
+++ b/drivers/video/sgivwfb.c
@@ -115,7 +115,7 @@ static int sgivwfb_set_par(struct fb_info *info);
 static int sgivwfb_setcolreg(u_int regno, u_int red, u_int green,
                              u_int blue, u_int transp,
                              struct fb_info *info);
-static int sgivwfb_mmap(struct fb_info *info, struct file *file,
+static int sgivwfb_mmap(struct fb_info *info,
                         struct vm_area_struct *vma);
 
 static struct fb_ops sgivwfb_ops = {
@@ -706,7 +706,7 @@ static int sgivwfb_setcolreg(u_int regno, u_int red, u_int green,
         return 0;
 }
 
-static int sgivwfb_mmap(struct fb_info *info, struct file *file,
+static int sgivwfb_mmap(struct fb_info *info,
                         struct vm_area_struct *vma)
 {
         unsigned long size = vma->vm_end - vma->vm_start;
@@ -723,7 +723,6 @@ static int sgivwfb_mmap(struct fb_info *info, struct file *file,
         if (remap_pfn_range(vma, vma->vm_start, offset >> PAGE_SHIFT,
                                                 size, vma->vm_page_prot))
                 return -EAGAIN;
-        vma->vm_file = file;
         printk(KERN_DEBUG "sgivwfb: mmap framebuffer P(%lx)->V(%lx)\n",
                offset, vma->vm_start);
         return 0;
diff --git a/drivers/video/sis/sis_main.c b/drivers/video/sis/sis_main.c
index dea1a46c67c4..8adf5bf91eee 100644
--- a/drivers/video/sis/sis_main.c
+++ b/drivers/video/sis/sis_main.c
@@ -1743,13 +1743,14 @@ sisfb_blank(int blank, struct fb_info *info)
 
 /* ----------- FBDev related routines for all series ---------- */
 
-static int
-sisfb_ioctl(struct inode *inode, struct file *file,
-            unsigned int cmd, unsigned long arg,
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
-            int con,
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,15)
+static int      sisfb_ioctl(struct fb_info *info, unsigned int cmd,
+                            unsigned long arg)
+#else
+static int      sisfb_ioctl(struct inode *inode, struct file *file,
+                                unsigned int cmd, unsigned long arg,
+                                struct fb_info *info)
 #endif
-            struct fb_info *info)
 {
         struct sis_video_info   *ivideo = (struct sis_video_info *)info->par;
         struct sis_memreq       sismemreq;
@@ -1924,19 +1925,6 @@ sisfb_ioctl(struct inode *inode, struct file *file,
         return 0;
 }
 
-#ifdef SIS_NEW_CONFIG_COMPAT
-static long
-sisfb_compat_ioctl(struct file *f, unsigned int cmd, unsigned long arg, struct fb_info *info)
-{
-        int ret;
-
-        lock_kernel();
-        ret = sisfb_ioctl(NULL, f, cmd, arg, info);
-        unlock_kernel();
-        return ret;
-}
-#endif
-
 static int
 sisfb_get_fix(struct fb_fix_screeninfo *fix, int con, struct fb_info *info)
 {
@@ -2007,7 +1995,7 @@ static struct fb_ops sisfb_ops = {
 #endif
         .fb_sync        = fbcon_sis_sync,
 #ifdef SIS_NEW_CONFIG_COMPAT
-        .fb_compat_ioctl= sisfb_compat_ioctl,
+        .fb_compat_ioctl= sisfb_ioctl,
 #endif
         .fb_ioctl       = sisfb_ioctl
 };
diff --git a/drivers/video/sis/sis_main.h b/drivers/video/sis/sis_main.h
index 445bcbba03ae..70b6df371b8e 100644
--- a/drivers/video/sis/sis_main.h
+++ b/drivers/video/sis/sis_main.h
@@ -727,9 +727,14 @@ static int	sisfb_ioctl(struct inode *inode, struct file *file,
 #endif
 
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0)
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,15)
+static int      sisfb_ioctl(struct fb_info *info, unsigned int cmd,
+                            unsigned long arg);
+#else
 static int      sisfb_ioctl(struct inode *inode, struct file *file,
                                 unsigned int cmd, unsigned long arg,
                                 struct fb_info *info);
+#endif
 static int      sisfb_set_par(struct fb_info *info);
 static int      sisfb_blank(int blank,
                                 struct fb_info *info);
diff --git a/drivers/video/sstfb.c b/drivers/video/sstfb.c
index 8a5ce210bb27..99921df35474 100644
--- a/drivers/video/sstfb.c
+++ b/drivers/video/sstfb.c
@@ -771,8 +771,7 @@ static int sstfb_setcolreg(u_int regno, u_int red, u_int green, u_int blue,
         return 0;
 }
 
-static int sstfb_ioctl(struct inode *inode, struct file *file,
-                       u_int cmd, u_long arg, struct fb_info *info )
+static int sstfb_ioctl(struct fb_info *info, u_int cmd, u_long arg)
 {
         struct sstfb_par *par = info->par;
         struct pci_dev *sst_dev = par->dev;
diff --git a/drivers/video/tcx.c b/drivers/video/tcx.c
index 2b27b4474001..95b918229d9b 100644
--- a/drivers/video/tcx.c
+++ b/drivers/video/tcx.c
@@ -33,9 +33,8 @@ static int tcx_setcolreg(unsigned, unsigned, unsigned, unsigned,
                          unsigned, struct fb_info *);
 static int tcx_blank(int, struct fb_info *);
 
-static int tcx_mmap(struct fb_info *, struct file *, struct vm_area_struct *);
-static int tcx_ioctl(struct inode *, struct file *, unsigned int,
-                     unsigned long, struct fb_info *);
+static int tcx_mmap(struct fb_info *, struct vm_area_struct *);
+static int tcx_ioctl(struct fb_info *, unsigned int, unsigned long);
 static int tcx_pan_display(struct fb_var_screeninfo *, struct fb_info *);
 
 /*
@@ -302,7 +301,7 @@ static struct sbus_mmap_map __tcx_mmap_map[TCX_MMAP_ENTRIES] = {
         { .size = 0 }
 };
 
-static int tcx_mmap(struct fb_info *info, struct file *file, struct vm_area_struct *vma)
+static int tcx_mmap(struct fb_info *info, struct vm_area_struct *vma)
 {
         struct tcx_par *par = (struct tcx_par *)info->par;
 
@@ -312,8 +311,8 @@ static int tcx_mmap(struct fb_info *info, struct file *file, struct vm_area_stru
                                   vma);
 }
 
-static int tcx_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
-                     unsigned long arg, struct fb_info *info)
+static int tcx_ioctl(struct fb_info *info, unsigned int cmd,
+                     unsigned long arg)
 {
         struct tcx_par *par = (struct tcx_par *) info->par;
 
diff --git a/drivers/video/vfb.c b/drivers/video/vfb.c
index ffa1ad474226..53208cb58396 100644
--- a/drivers/video/vfb.c
+++ b/drivers/video/vfb.c
@@ -81,7 +81,7 @@ static int vfb_setcolreg(u_int regno, u_int red, u_int green, u_int blue,
                          u_int transp, struct fb_info *info);
 static int vfb_pan_display(struct fb_var_screeninfo *var,
                            struct fb_info *info);
-static int vfb_mmap(struct fb_info *info, struct file *file,
+static int vfb_mmap(struct fb_info *info,
                     struct vm_area_struct *vma);
 
 static struct fb_ops vfb_ops = {
@@ -368,7 +368,7 @@ static int vfb_pan_display(struct fb_var_screeninfo *var,
      *  Most drivers don't need their own mmap function 
      */
 
-static int vfb_mmap(struct fb_info *info, struct file *file,
+static int vfb_mmap(struct fb_info *info,
                     struct vm_area_struct *vma)
 {
         return -EINVAL;
diff --git a/drivers/zorro/zorro-driver.c b/drivers/zorro/zorro-driver.c
index ccba227676f2..fcbee748c592 100644
--- a/drivers/zorro/zorro-driver.c
+++ b/drivers/zorro/zorro-driver.c
@@ -77,7 +77,6 @@ int zorro_register_driver(struct zorro_driver *drv)
         /* initialize common driver fields */
         drv->driver.name = drv->name;
         drv->driver.bus = &zorro_bus_type;
-        drv->driver.probe = zorro_device_probe;
 
         /* register with core */
         count = driver_register(&drv->driver);
@@ -132,7 +131,8 @@ static int zorro_bus_match(struct device *dev, struct device_driver *drv)
 
 struct bus_type zorro_bus_type = {
         .name   = "zorro",
-        .match  = zorro_bus_match
+        .match  = zorro_bus_match,
+        .probe  = zorro_device_probe,
 };